Merge pull request #30 from argentlabs/feature/clean_after_multicall

Clean after multicall

Author: juniset

contracts/ArgentAccount.cairo

@@ -40,7 +40,7 @@ const ESCAPE_SECURITY_PERIOD = 7*24*60*60 # set to e.g. 7 days in prod
 const ESCAPE_TYPE_GUARDIAN = 0
 const ESCAPE_TYPE_SIGNER = 1
 
-const ERC156_ACCOUNT_INTERFACE = 0x50b70dcb
+const ERC156_ACCOUNT_INTERFACE = 0xf10dbd44
 
 const TRUE = 1
 const FALSE = 0
@@ -51,18 +51,20 @@ const PREFIX_TRANSACTION = 'StarkNet Transaction'
 # STRUCTS
 ####################
 
-struct MCall:
+struct Call:
     member to: felt
     member selector: felt
-    member data_offset: felt
-    member data_len: felt
+    member calldata_len: felt
+    member calldata: felt*
 end
 
-struct Call:
+# Tmp struct introduced while we wait for Cairo
+# to support passing `[Call]` to __execute__
+struct CallArray:
     member to: felt
     member selector: felt
-    member calldata_len: felt
-    member calldata: felt*
+    member data_offset: felt
+    member data_len: felt
 end
 
 struct Escape:
@@ -165,8 +167,8 @@ func __execute__{
         ecdsa_ptr: SignatureBuiltin*,
         range_check_ptr
     } (
-        mcalls_len: felt,
-        mcalls: MCall*,
+        call_array_len: felt,
+        call_array: CallArray*,
         calldata_len: felt,
         calldata: felt*,
         nonce: felt
@@ -179,8 +181,8 @@ func __execute__{
     ############### TMP #############################
     # parse inputs to an array of 'Call' struct
     let (calls : Call*) = alloc()
-    from_mcall_to_call(mcalls_len, mcalls, calldata, calls)
-    let calls_len = mcalls_len
+    from_call_array_to_call(call_array_len, call_array, calldata, calls)
+    let calls_len = call_array_len
     #################################################
 
     # validate and bump nonce
@@ -190,20 +192,20 @@ func __execute__{
     let (tx_info) = get_tx_info()
 
     # compute message hash
-    let (message_hash) = get_execute_hash(tx_info.account_contract_address, calls_len, calls, nonce, tx_info.max_fee, tx_info.version)
+    let (hash) = hash_multicall(tx_info.account_contract_address, calls_len, calls, nonce, tx_info.max_fee, tx_info.version)
 
     if calls_len == 1:
         if calls[0].to == tx_info.account_contract_address:
             tempvar signer_condition = (calls[0].selector - ESCAPE_GUARDIAN_SELECTOR) * (calls[0].selector - TRIGGER_ESCAPE_GUARDIAN_SELECTOR)
             tempvar guardian_condition = (calls[0].selector - ESCAPE_SIGNER_SELECTOR) * (calls[0].selector - TRIGGER_ESCAPE_SIGNER_SELECTOR)
             if signer_condition == 0:
                 # validate signer signature
-                validate_signer_signature(message_hash, tx_info.signature, tx_info.signature_len)
+                validate_signer_signature(hash, tx_info.signature, tx_info.signature_len)
                 jmp do_execute
             end
             if guardian_condition == 0:
                 # validate guardian signature
-                validate_guardian_signature(message_hash, tx_info.signature, tx_info.signature_len)
+                validate_guardian_signature(hash, tx_info.signature, tx_info.signature_len)
                 jmp do_execute
             end
         end
@@ -212,8 +214,8 @@ func __execute__{
         assert_no_self_call(tx_info.account_contract_address, calls_len, calls)
     end
     # validate signer and guardian signatures
-    validate_signer_signature(message_hash, tx_info.signature, tx_info.signature_len)
-    validate_guardian_signature(message_hash, tx_info.signature + 2, tx_info.signature_len - 2)
+    validate_signer_signature(hash, tx_info.signature, tx_info.signature_len)
+    validate_guardian_signature(hash, tx_info.signature + 2, tx_info.signature_len - 2)
 
     # execute calls
     do_execute:
@@ -719,7 +721,7 @@ end
 # @param max_fee The max fee the user is willing to pay for the multicall
 # @param version The version of transaction in the Cairo OS. Always set to 0.
 # @return res The hash of the multicall
-func get_execute_hash{
+func hash_multicall{
         syscall_ptr: felt*, 
         pedersen_ptr: HashBuiltin*
     } (
@@ -826,31 +828,28 @@ func hash_calldata{
     end
 end
 
-func from_mcall_to_call{
-        syscall_ptr: felt*,
-        pedersen_ptr: HashBuiltin*,
-        range_check_ptr
+func from_call_array_to_call{
+        syscall_ptr: felt*
     } (
-        mcalls_len: felt,
-        mcalls: MCall*,
+        call_array_len: felt,
+        call_array: CallArray*,
         calldata: felt*,
         calls: Call*
     ):
-    alloc_locals
-
-    # if no more mcalls
-    if mcalls_len == 0:
+    # if no more calls
+    if call_array_len == 0:
        return ()
     end
     
-    # parse the first mcall
+    # parse the current call
     assert [calls] = Call(
-            to=[mcalls].to,
-            selector=[mcalls].selector,
-            calldata_len=[mcalls].data_len,
-            calldata=calldata + [mcalls].data_offset)
+            to=[call_array].to,
+            selector=[call_array].selector,
+            calldata_len=[call_array].data_len,
+            calldata=calldata + [call_array].data_offset
+        )
     
-    # parse the other mcalls recursively
-    from_mcall_to_call(mcalls_len - 1, mcalls + MCall.SIZE, calldata, calls + Call.SIZE)
+    # parse the remaining calls recursively
+    from_call_array_to_call(call_array_len - 1, call_array + CallArray.SIZE, calldata, calls + Call.SIZE)
     return ()
 end

test/argent_account.py

@@ -24,6 +24,8 @@
 
 VERSION = str_to_felt('0.2.0')
 
+IACCOUNT_ID = 0xf10dbd44
+
 ESCAPE_TYPE_GUARDIAN = 0
 ESCAPE_TYPE_SIGNER = 1
 
@@ -62,7 +64,8 @@ async def test_initializer(account_factory):
     assert (await account.get_signer().call()).result.signer == (signer.public_key)
     assert (await account.get_guardian().call()).result.guardian == (guardian.public_key)
     assert (await account.get_version().call()).result.version == VERSION
-    # should throw when calling initialize
+    assert (await account.supportsInterface(IACCOUNT_ID).call()).result.success == 1
+    # should throw when calling initialize twice
     await assert_revert(
          account.initialize(signer.public_key, guardian.public_key).invoke()
      )

test/utils/Signer.py

@@ -1,5 +1,4 @@
-from starkware.crypto.signature.signature import pedersen_hash, private_to_stark_key, sign
-from starkware.starknet.public.abi import get_selector_from_name
+from starkware.crypto.signature.signature import private_to_stark_key, sign
 
 
 class Signer():

test/utils/TransactionSender.py

@@ -17,27 +17,28 @@ async def send_transaction(self, calls, signers, nonce=None, max_fee=0):
             execution_info = await self.account.get_nonce().call()
             nonce = execution_info.result.nonce
 
-        call_inputs = []
-        calls_with_selector = []
-        calldata = []
-        for i in range(len(calls)):
-            if len(calls[i]) != 3:
-                raise Exception("Invalid call parameters")
-            call = calls[i]
-            call_input = (call[0], get_selector_from_name(call[1]), len(calldata), len(call[2]))
-            call_inputs.append(call_input)
-            calldata.extend(call[2])
-            calls_with_selector.append((call[0], get_selector_from_name(call[1]), call[2]))
+        calls_with_selector = [(call[0], get_selector_from_name(call[1]), call[2]) for call in calls]
+        call_array, calldata = from_call_to_call_array(calls)
 
         message_hash = hash_multicall(self.account.contract_address, calls_with_selector, nonce, max_fee)
         signatures = []
         for signer in signers:
             if signer == 0:
-                signatures += list([0, 0])
+                signatures += [0, 0]
             else:    
                 signatures += list(signer.sign(message_hash))
 
-        return await self.account.__execute__(call_inputs, calldata, nonce).invoke(signature=signatures)
+        return await self.account.__execute__(call_array, calldata, nonce).invoke(signature=signatures)
+
+def from_call_to_call_array(calls):
+    call_array = []
+    calldata = []
+    for call in calls:
+        assert len(call) == 3, "Invalid call parameters"
+        entry = (call[0], get_selector_from_name(call[1]), len(calldata), len(call[2]))
+        call_array.append(entry)
+        calldata.extend(call[2])
+    return call_array, calldata
 
 def hash_multicall(account, calls, nonce, max_fee):
     hash_array = []

test/utils/utilities.py

@@ -1,7 +1,6 @@
 import os
 from starkware.starknet.testing.contract import StarknetContract
 from starkware.starknet.compiler.compile import compile_starknet_files
-from starkware.starknet.testing.state import StarknetState
 from starkware.starkware_utils.error_handling import StarkException
 from starkware.starknet.definitions.error_codes import StarknetErrorCode
 from starkware.starknet.business_logic.transaction_execution_objects import Event
@@ -12,7 +11,7 @@ def str_to_felt(text):
     return int.from_bytes(b_text, "big")
 
 def uint(a):
-    return(a, 0)
+    return a, 0
 
 async def assert_revert(expression, expected_message=None, expected_code=None):
     if expected_code is None:
@@ -49,7 +48,7 @@ async def deploy_proxy(starknet, proxy_path, implementation_path, params=None):
     params = params or []
     proxy_definition = compile_starknet_files([proxy_path], debug_info=True)
     implementation_definition = compile_starknet_files([implementation_path], debug_info=True)
-    deployed_proxy = await starknet.deploy(contract_def=proxy_definition,constructor_calldata=params)
+    deployed_proxy = await starknet.deploy(contract_def=proxy_definition, constructor_calldata=params)
     wrapped_proxy = StarknetContract(
         state=starknet.state,
         abi=implementation_definition.abi,