This document discusses Ethereum accounts and introduces account abstraction on StarkNet. It summarizes that Ethereum accounts are tied to cryptographic signers, but account abstraction decouples accounts and signers by implementing the IAccount interface. This allows accounts to have multiple signers, different signature schemes, and to be upgraded, improving security and enabling use cases like fraud monitoring, account recovery, and hardware security modules. Developers can access accounts through the Argent X wallet and starknet.js library.

2. Table of Contents
● Understanding Ethereum Accounts
○ How it works
○ Limitations
● Account Abstraction
○ How it works
○ The IAccount interface
○ What it means for Dapp developers
● Use Cases
○ Fraud monitoring
○ Social Recovery
○ Secure Enclave
● How to build with Argent X

3. Ethereum Accounts 101
There is 2 types of Accounts on Ethereum:
- Externally Owned Accounts (EOA)
- Contract Accounts (CA)
The state of Ethereum S is the state of all the Accounts (EOA + CA)
The state can only be updated by transactions: S’ = T(S)
Every transaction T must be initiated (a.k.a start) from an EOA
from: <an EOA>
to: …
value: …
data: …

4. Ethereum Accounts 101
An (EOA) Account has:
- an address for identification
- a nonce to make sure transactions are unique
- a balance in ETH to pay fees
The EOA is “owned” by an external user through a pair of cryptographic keys:
- The address of the account is derived from the public key
- Transactions from the account must be signed by the private key

5. Ethereum Accounts 101
A cryptographic Signer is a pair of private and public key (kpriv
, kpub
) such that:
- The public key can be derived from the private key: kpriv
→ kpub
- The private key cannot be computed from the public key: kpub
→ kpriv
The private key can generate a signature Sig(m) for a message m such that:
- Anyone with kpub
can verify that the signature is valid for kpriv
- Only kpriv
can generate a valid signature for kpriv
The signature scheme of Ethereum is ECDSA on the elliptic curve secp256k1.
ECDSA has the additional property that (Sig(m), m) → kpub

6. Ethereum Accounts 101
address = keccak(kpub
)[0:19]
nonce + balance
EVM logic to validate and execute transactions
EOA Account
(kpriv
, kpub
)
Signer
Ethereum
User
ECDSA on Secp256k1

7. Ethereum Accounts 101
address = keccak(kpub
)[0:19]
nonce + balance
EVM logic to validate and execute transactions
EOA Account
(kpriv
, kpub
)
Signer
Ethereum
User
The concept of Account and the concept of Signer are merged.
ECDSA on Secp256k1
Holds your tokens Authorised to spend your tokens

8. Ethereum Account: Problems?
- The Signer IS the Account, and vice versa
→ You can derive the address of the Account from the Signer
→ You can verify a signature for the Account using the Signer (ecrecover)
- But:
- If you loose the Signer you loose the Account!
- If the Signer is compromised the Account is compromised!
- Everybody must use the same cryptography (ECDSA on secp256k1)
→ This will not work for mainstream adoption!

9. Account Abstraction
Goal: Decouple the relation between Account and Signer
→ Signer = Account
The account is a smart-contract that defines what a valid transaction is:
- Different Signature scheme?
- Different elliptic curve?
- Multiple Signers?
- Signer can be replaced?
On StarkNet the account must implement the IAccount interface.

10. IAccount interface
namespace IAccount {
struct Call:
member to: felt
member selector: felt
member data_len: felt
member data: felt*
}
func get_nonce() -> (res : felt):
func is_valid_signature(hash: felt, signature_len: felt, signature: felt*) -> (success:
felt):
func __execute__(calls_len: felt, calls: Call*) -> (response_len: felt, response: felt);
func __validate__(calls_len: felt, calls: Call*) -> (success: felt);
}
https://github.com/OpenZeppelin/cairo-contracts/blob/main/openzeppelin/account/Account.cairo
https://github.com/argentlabs/argent-contracts-starknet/blob/develop/contracts/ArgentAccount.cairo

11. IAccount interface
interface IAccount {
struct Call:
member to: felt
member selector: felt
member data_len: felt
member data: felt*
}
func get_nonce() -> (res : felt):
func is_valid_signature(hash: felt, signature_len: felt, signature: felt*) -> (success:
felt):
func __execute__(calls_len: felt, calls: Call*) -> (response_len: felt, response: felt);
func __validate__(calls_len: felt, calls: Call*) -> (success: felt);
}
https://github.com/OpenZeppelin/cairo-contracts/blob/main/openzeppelin/account/Account.cairo
https://github.com/argentlabs/argent-contracts-starknet/blob/develop/contracts/ArgentAccount.cairo
Verify off-chain signatures

12. IAccount interface
interface IAccount {
struct Call:
member to: felt
member selector: felt
member data_len: felt
member data: felt*
}
func get_nonce() -> (res : felt):
func is_valid_signature(hash: felt, signature_len: felt, signature: felt*) -> (success:
felt):
func __execute__(calls_len: felt, calls: Call*) -> (response_len: felt, response: felt);
func __validate__(calls_len: felt, calls: Call*) -> (success: felt);
}
https://github.com/OpenZeppelin/cairo-contracts/blob/main/openzeppelin/account/Account.cairo
https://github.com/argentlabs/argent-contracts-starknet/blob/develop/contracts/ArgentAccount.cairo
Used by the sequencer to validate
and execute a transaction

13. IAccount interface
interface IAccount {
struct Call:
member to: felt
member selector: felt
member data_len: felt
member data: felt*
}
func get_nonce() -> (res : felt):
func is_valid_signature(hash: felt, signature_len: felt, signature: felt*) -> (success:
felt):
func __execute__(calls_len: felt, calls: Call*) -> (response_len: felt, response: felt);
func __validate__(calls_len: felt, calls: Call*) -> (success: felt);
}
https://github.com/OpenZeppelin/cairo-contracts/blob/main/openzeppelin/account/Account.cairo
https://github.com/argentlabs/argent-contracts-starknet/blob/develop/contracts/ArgentAccount.cairo
Yeah Multicalls!

14. What it means for Dapp developers
1. The Account is a smart-contract
2. The address of the Account is not derived from the Signer
3. Transactions can have multiple signatures
→ sig = [sig1, sig2, …, sigN]
4. Off-chain signatures must be validated on-chain by the Account
→ You cannot use ecrecover(m, sig) locally!
→ You must use account.is_valid_signature(m, sig)
5. Bonus: You can use multicalls!

15. What it means for Dapp developers
1. The Account is a smart-contract
2. The address of the Account is not derived from the Signer
3. Transactions can have multiple signatures
→ sig = [sig1, sig2, …, sigN]
4. Off-chain signatures must be validated on-chain by the Account
→ You cannot use ecrecover(m, sig) locally
→ You must use account.is_valid_signature(m, sig)
5. Bonus: You can use multicalls!
All you need to remember!

16. Argent X?
● First Wallet on StarkNet
● Chrome extension
● Multi-account
● Multi (StarkNet) network
● Send and receive tokens
● Interact with dapps

17. How Argent X works
Argent X
Account Contract
StarkNet
func __execute__():

18. execute(doSomething, )
How Argent X works
Argent X
Account Contract Dapp Contract
Do Something
StarkNet
sendTransaction(doSomething) doSomething()
func __execute__(): func doSomething():

19. execute(doSomething, )
Signer
How Argent X works (developers)
Argent X
Account Contract Dapp Contract
Do Something
StarkNet
doSomething()
func __execute__(): func doSomething():
starknet.js
Js library to interact with StarkNet

20. execute(doSomething, , )
Use case 1: Fraud Monitoring
Argent X
Account Contract Dapp Contract
Do Something
StarkNet
sendTransaction(doSomething) doSomething()
func __execute__(): func doSomething():
Approve? -> YES +
Fraud Monitoring Service

21. Use case 1: Fraud Monitoring
Argent X
Account Contract Evil Contract
Do Something
StarkNet
sendTransaction(doEvil) doSomething()
func __execute__(): func doEvil():
Approve? -> No
Fraud Monitoring Service
X

22. escape( )
Use case 2: (Social) Recovery
Argent X
Account Contract
StarkNet
func __execute__():
Recovery Service
?

23. Use case 2: (Social) Recovery
Argent X
Account Contract
StarkNet
func __execute__():
Recovery Service
● Time delay of 7 days
● Can be canceled
● 100% non-custodial
● No more seed-phrases

24. Use case 3: Use the Secure Enclave
Argent X
Account Contract
StarkNet
func __execute__():
Secure Enclave*
* Uses a different elliptic curve (secp256r1) approved by the NIST

25. import { getStarknet } from "@argent/get-starknet"
// check if wallet extension is installed and initialized. Shows a modal prompting the user to download
// ArgentX otherwise.
const starknet = getStarknet({ showModal: true })
// may throws when no extension is detected
, or shows a modal prompting the user to download Argent X.
const [userAccountAddress] = await starknet.enable({ showModal: true }
)
// check if connection was successful
if(starknet.isConnected) {
// If the extension was installed and successfully connected, you have access to a
//starknet.js Signer object to do all kind of requests through the users wallet contract.
starknet.signer.invokeFunction
({ ... })
} else {
// In case the extension wasn't successfully connected you still have access to a
// starknet.js Provider to read starknet states and sent anonymous transactions
starknet.provider.callContract( ... )
}
How to get started

26. Time to Build!
● Download Argent X
https://chrome.google.com/webstore/detail/argent-x-starknet-wallet/dlcobpjiigpikoobohmabehhmhfoodbb?hl=fr
● npm install get-starknet
https://www.npmjs.com/package/@argent/get-starknet
● Contribute
https://github.com/argentlabs/argent-x
https://github.com/seanjameshan/starknet.js
● Join us on Discord #argent-extension