Standard account interface

[juniset]

Both OpenZeppelin and Argent are working on a user facing account (or wallet) with the intention to share some common methods to execute transactions, verify off-chain signatures, etc. We should standardize that interface to simplify the development of the Starknet ecosystem. This will also make it simpler to introduce fees, L1 escape, etc.

For example, with a well defined interface we can create an abstraction in the starknet.js SDK and facilitate interactions with all user facing accounts.

There is already an IAccount interface but I think it is not generic enough. For example, the set_public_key method is only relevant in the context where there is only one keys, but would not work for a multisig.

n alternative definition of the interface could be:

@contract_interface
namespace IAccount:
    #
    # Getters
    #

    func get_L1_address() -> (res : felt):
    end

    func get_nonce() -> (res : felt):
    end

    #
    # Setters
    #

    func set_L1_address(new_L1_address: felt):
    end

    #
    # Business logic
    #

    func execute(
        to: felt,
        selector: felt,
        calldata_len: felt,
        calldata: felt*,
        nonce: felt
        ) -> (response: felt):
    end

    func is_valid_signature(
         hash: felt, 
         signature_len: felt,
         signature: felt*
     ):
    end
end

Maybe we also need a better name than the "generic" Account?

[martriay]

Great initiative! A few comments:

• any reason not to include signature on execute?
• I moved the L1 coupling out to the account contract to a registry one, in agreement with StarkNet, this allows for a global registry of L1:L2 coupling enabling
  • all contracts (not just accounts) to have an associated L1 address
  • better security assumptions for starknet os
  • less account specific logic

so what do you think about this?:

@contract_interface
namespace IAccount:
    #
    # Getters
    #

    func get_nonce() -> (res : felt):
    end

    #
    # Business logic
    #

    func execute(
        to: felt,
        selector: felt,
        calldata_len: felt,
        calldata: felt*,
        nonce: felt,
        signature_len: felt,
        signature: felt*
        ) -> (response: felt):
    end

    func is_valid_signature(
         hash: felt, 
         signature_len: felt,
         signature: felt*
     ):
    end
end

[juniset]

• I've removed the signatures from execute as they are now treated separately in Cairo 0.5 and accessible through the get_tx_signature() routine, see e.g. https://github.com/argentlabs/argent-contracts-starknet/blob/b8a87610473d47ee0e68cb237ed9f15b9c18b504/contracts/ArgentAccount.cairo#L99

• I remember them mentioning that and it makes sense. The simpler the IAccount, the better :-)

[martriay]

Implemented in #51

[agolajko]

Hey @juniset you mention that For example, the set_public_key method is only relevant in the context where there is only one key.

Looking at the code implementation of set_public_key it checks within the assert_only_self function whether the caller is the account itself.

Why is this implemented in this way? As currently this means the set_public_key function is only callable by itself. Am I correct in guessing that a future version of Account.cairo will have another callable function that will make this usable?

Thanks!

[juniset]

As part of the discussions around the Account Contract (AC) specification, it was decided that all AC will have a single entry point, the execute method. This makes the implementation of full account abstraction (paying fees, etc) simpler for Starkware.

As a consequence the calls to the other external methods of an account ( such as set_public_key) must first go through the execute method which then calls the target method. To enforce that pattern, the other external methods must check that they are being called by the Account itself which can be enforced with the assert_only_self .

[agolajko]

Ahh, I see that's enlightening thank you

[martriay]

This is covered in the documentation :)

Edit: updated link.

[martriay]

Linking #24 for completeness since it's related.

[martriay]

As discussed in here, here, and ratified in here, this is the latest agreed standard interface for account contracts:

%lang starknet

struct Call {
    to: felt,
    selector: felt,
    calldata_len: felt,
    calldata: felt*,
}

// Tmp struct introduced while we wait for Cairo to support passing `[Call]` to __execute__
struct CallArray {
    to: felt,
    selector: felt,
    data_offset: felt,
    data_len: felt,
}

@contract_interface
namespace IAccount {

    func supportsInterface(interfaceId: felt) -> (success: felt) {
    }

    func isValidSignature(
        hash: felt,
        signature_len: felt,
        signature: felt*
    ) -> (isValid: felt) {
    }

    func __validate__(
        call_array_len: felt,
        call_array: CallArray*,
        calldata_len: felt,
        calldata: felt*
    ) {
    }

    func __validate_declare__(class_hash: felt) {
    }

    func __execute__(
        call_array_len: felt,
        call_array: CallArray*,
        calldata_len: felt,
         calldata: felt*
    ) -> (response_len: felt, response: felt*) {
    }
}