Skip to main content
Version: 11.x

Class: WalletAccount

Defined in: src/wallet/account.ts:99

Deprecated​

Use WalletAccountV6 (get-starknet v6) instead. This class is kept only for DAPPs that are still on get-starknet v4.

Remarks​

Account that lets a wallet sign and send the transactions, using get-starknet v4. It represents the 'Selected Active' Account inside the Connected Wallet.

The private key stays in the wallet. Reads go to the RPC node given at the instantiation, writes go to the wallet. It works only in a DAPP, not in a Node.js script.

The wallet is selected with the get-starknet v4 library. Its connect() function opens a window with the list of wallets. It returns the StarknetWindowObject (SWO) of the wallet that the user selected. With get-starknet-core v4 you can also build your own UI and logic. See this DAPP for an example where only the wallets compatible with the Starknet Wallet API can be selected.

The address and the chain ID follow the wallet automatically. This can lead to reads and writes on different networks, so create a new instance each time the account or the network changes.

The wallet emits 2 events: accountsChanged and networkChanged. A change of network emits both. A change of account emits only accountsChanged. You can subscribe with the SWO (on) or with the onAccountChange and onNetworkChanged methods of this class. To unsubscribe, call off on the SWO with the same function.

Needs @starknet-io/get-starknet v4.0.3 min.

Examples​

import { connect } from '@starknet-io/get-starknet';
import { WalletAccount, wallet } from 'starknet';
const selectedWalletSWO = await connect({ modalMode: 'alwaysAsk', modalTheme: 'light' });
const myWalletAccount = await WalletAccount.connect(
  { nodeUrl: 'https://api.zan.top/public/starknet-sepolia/rpc/v0_10' },
  selectedWalletSWO
);
// The wallet writes on this network:
const writeChainId = await wallet.requestChainId(myWalletAccount.walletProvider);
// writeChainId = '0x534e5f5345504f4c4941' (SN_SEPOLIA, if the wallet is on Sepolia)
// The provider reads on this network:
const readChainId = await myWalletAccount.provider.getChainId();
// readChainId = '0x534e5f5345504f4c4941'
// Subscribe with the wallet object (SWO). Unsubscribe with `.off` and the same function.
const handleAccount: AccountChangeEventHandler = (accounts: string[] | undefined) => {
  if (accounts?.length) console.log('new address =', accounts[0]);
};
const handleNetwork: NetworkChangeEventHandler = (chainId?: string) => {
  if (chainId) console.log('new chain =', chainId);
};
selectedWalletSWO.on('accountsChanged', handleAccount);
selectedWalletSWO.on('networkChanged', handleNetwork);
selectedWalletSWO.off('accountsChanged', handleAccount);
selectedWalletSWO.off('networkChanged', handleNetwork);

Extends​

Constructors​

Constructor​

new WalletAccount(options): WalletAccount

Defined in: src/wallet/account.ts:102

Parameters​

options​

WalletAccountV4Options

Returns​

WalletAccount

Overrides​

Account.constructor

Properties​

walletProvider​

walletProvider: StarknetWalletProvider

Defined in: src/wallet/account.ts:100

provider​

provider: RpcProvider

Defined in: src/account/default.ts:104

Provider instance for blockchain interaction

Inherited from​

Account.provider

signer​

signer: SignerInterface

Defined in: src/account/default.ts:106

Signer instance for signing transactions and messages

Inherited from​

Account.signer

address​

address: string

Defined in: src/account/default.ts:108

The address of the account contract on Starknet

Inherited from​

Account.address

cairoVersion​

cairoVersion: CairoVersion

Defined in: src/account/default.ts:112

Cairo version of the account contract implementation

Inherited from​

Account.cairoVersion

transactionVersion​

readonly transactionVersion: "0x3"

Defined in: src/account/default.ts:114

Inherited from​

Account.transactionVersion

deployer​

deployer: Deployer

Defined in: src/account/default.ts:116

Optional deployer instance for custom contract deployment logic

Default​

Uses default UDC (Universal Deployer Contract) if not specified

Inherited from​

Account.deployer

defaultTipType​

defaultTipType: TipType

Defined in: src/account/default.ts:118

Inherited from​

Account.defaultTipType

accountPluginManager​

readonly accountPluginManager: PluginManager

Defined in: src/account/default.ts:121

Internal

Account-level plugin management

Inherited from​

Account.accountPluginManager

deploySelf​

deploySelf: (contractPayload, details) => Promise<DeployContractResponse>

Defined in: src/account/default.ts:608

Deploy the account contract itself on Starknet

Parameters​

contractPayload​

DeployAccountContractPayload & object

Account deployment configuration

  • .classHash - Account contract class hash
  • .constructorCalldata - Constructor parameters
  • .addressSalt - Salt for address generation
  • .contractAddress - Pre-computed address
  • .abi - Abi of the account contract (optional): the constructor calldata is checked against it
details?​

UniversalDetails = {}

Returns​

Promise<DeployContractResponse>

Deployment transaction hash and contract address

Remarks​

Used for deploying the account contract when using a pre-funded address

Example​

const deployment = await account.deployAccount({
  classHash: accountClassHash,
  constructorCalldata: { publicKey: pubKey },
  addressSalt: pubKey
});

Inherited from​

Account.deploySelf

paymaster​

paymaster: PaymasterInterface

Defined in: src/plugins/paymaster/types/plugin.type.ts:19

The paymaster service of the account. The paymaster methods read it at each call, so you can replace it after the account is created.

Inherited from​

Account.paymaster

Methods​

connect()​

static connect(provider, walletProvider, cairoVersion?, paymaster?, silentMode?): Promise<WalletAccount>

Defined in: src/wallet/account.ts:211

Parameters​

provider​

ProviderInterface | ProviderOptions

walletProvider​

StarknetWalletProvider

cairoVersion?​

CairoVersion

paymaster?​

PaymasterOptions | PaymasterInterface

silentMode?​

boolean = false

Returns​

Promise<WalletAccount>

connectSilent()​

static connectSilent(provider, walletProvider, cairoVersion?, paymaster?): Promise<WalletAccount>

Defined in: src/wallet/account.ts:231

Parameters​

provider​

ProviderInterface | ProviderOptions

walletProvider​

StarknetWalletProvider

cairoVersion?​

CairoVersion

paymaster?​

PaymasterOptions | PaymasterInterface

Returns​

Promise<WalletAccount>

onAccountChange()​

onAccountChange(callback): void

Defined in: src/wallet/account.ts:122

Parameters​

callback​

AccountChangeEventHandler

Returns​

void

onNetworkChanged()​

onNetworkChanged(callback): void

Defined in: src/wallet/account.ts:126

Parameters​

callback​

NetworkChangeEventHandler

Returns​

void

requestAccounts()​

requestAccounts(silentMode?): Promise<string[]>

Defined in: src/wallet/account.ts:131

Parameters​

silentMode?​

boolean = false

Returns​

Promise<string[]>

getPermissions()​

getPermissions(): Promise<"accounts"[]>

Defined in: src/wallet/account.ts:135

Returns​

Promise<"accounts"[]>

switchStarknetChain()​

switchStarknetChain(chainId): Promise<boolean>

Defined in: src/wallet/account.ts:139

Parameters​

chainId​

"0x534e5f4d41494e" | "0x534e5f5345504f4c4941"

Returns​

Promise<boolean>

watchAsset()​

watchAsset(asset): Promise<boolean>

Defined in: src/wallet/account.ts:143

Parameters​

asset​

WatchAssetParameters

Returns​

Promise<boolean>

addStarknetChain()​

addStarknetChain(chain): Promise<boolean>

Defined in: src/wallet/account.ts:147

Parameters​

chain​

AddStarknetChainParameters

Returns​

Promise<boolean>

execute()​

execute(calls): Promise<AddInvokeTransactionResult>

Defined in: src/wallet/account.ts:152

Execute one or multiple calls through the account contract

Parameters​

calls​

AllowArray<Call>

Single call or array of calls to execute

  • .contractAddress - Target contract address
  • .entrypoint - Function to invoke on the contract
  • .calldata - Function parameters

Returns​

Promise<AddInvokeTransactionResult>

Transaction hash and response

Example​

const result = await account.execute([
  { contractAddress: token, entrypoint: 'transfer', calldata: [to, amount] },
  { contractAddress: nft, entrypoint: 'mint', calldata: [recipient] }
]);

Overrides​

Account.execute

declare()​

declare(payload): Promise<AddDeclareTransactionResult>

Defined in: src/wallet/account.ts:169

Declare a contract class on Starknet

Parameters​

payload​

DeclareContractPayload

Returns​

Promise<AddDeclareTransactionResult>

Declaration transaction hash and class hash

Example​

const declareResult = await account.declare({
  contract: compiledSierra,
  casm: compiledCasm
});

Overrides​

Account.declare

deploy()​

deploy(payload): Promise<MultiDeployContractResponse>

Defined in: src/wallet/account.ts:195

Deploy contract(s) using the Universal Deployer Contract (UDC)

Parameters​

payload​

UniversalDeployerContractPayload | UniversalDeployerContractPayload[]

Single or multiple deployment configurations.

  • .classHash - Class hash of declared contract.
  • .constructorCalldata - Constructor parameters.
  • .salt - Deployment salt (random if not specified).
  • .unique - Modify salt for unique address (default: true).
  • .abi - Abi of the contract (optional): the constructor calldata is checked against it. Without it, the calldata is flattened as given, with no check.

Returns​

Promise<MultiDeployContractResponse>

Deployed contract addresses and transaction hash

Example​

const deployment = await account.deploy([
  { classHash: erc20ClassHash, constructorCalldata: [name, symbol] },
  { classHash: nftClassHash, unique: true }
]);

Overrides​

Account.deploy

signMessage()​

signMessage(typedData): Promise<SIGNATURE>

Defined in: src/wallet/account.ts:207

Sign a typed data message for off-chain verification

Parameters​

typedData​

TypedData

EIP-712 style typed data structure

Returns​

Promise<SIGNATURE>

Signature array [r, s]

Remarks​

  • Includes domain separation to prevent signature reuse
  • Compatible with Starknet's signature verification
  • Cannot be used to sign transactions

Example​

const signature = await account.signMessage({
  domain: { name: 'MyDapp', chainId: 'SN_MAIN' },
  types: { ... },
  primaryType: 'Message',
  message: { content: 'Hello Starknet!' }
});

Overrides​

Account.signMessage

getNonce()​

getNonce(blockIdentifier?): Promise<string>

Defined in: src/account/default.ts:162

Get the current nonce of the account

Parameters​

blockIdentifier?​

BlockIdentifier

Block to query nonce at (default: 'latest' tag)

Returns​

Promise<string>

Account nonce as hex string

Example​

const nonce = await account.getNonce();
const historicalNonce = await account.getNonce('latest');

Inherited from​

Account.getNonce

getCairoVersion()​

getCairoVersion(classHash?): Promise<CairoVersion>

Defined in: src/account/default.ts:181

Retrieves the Cairo version from the network and sets cairoVersion if not already set in the constructor.

Parameters​

classHash?​

string

if provided detects Cairo version from classHash, otherwise from the account address

Returns​

Promise<CairoVersion>

Inherited from​

Account.getCairoVersion

estimateInvokeFee()​

estimateInvokeFee(calls, details?): Promise<EstimateFeeResponseOverhead>

Defined in: src/account/default.ts:191

Estimate fee for executing an INVOKE transaction on Starknet

Parameters​

calls​

AllowArray<Call>

Single call or array of calls to estimate fees for

  • .contractAddress - The address of the contract to invoke
  • .entrypoint - The function selector of the contract method
  • .calldata - The serialized function parameters (defaults to [])
details?​

UniversalDetails = {}

Returns​

Promise<EstimateFeeResponseOverhead>

Fee estimation including overall_fee and resourceBounds

Example​

const fee = await account.estimateInvokeFee({
  contractAddress: '0x123...',
  entrypoint: 'transfer',
  calldata: [recipient, amount]
});

Inherited from​

Account.estimateInvokeFee

estimateDeclareFee()​

estimateDeclareFee(payload, details?): Promise<EstimateFeeResponseOverhead>

Defined in: src/account/default.ts:201

Estimate fee for executing a DECLARE transaction on Starknet

Parameters​

payload​

DeclareContractPayload

details?​

UniversalDetails = {}

Returns​

Promise<EstimateFeeResponseOverhead>

Fee estimation including overall_fee and resourceBounds

Example​

const fee = await account.estimateDeclareFee({
  contract: compiledContract,
  casm: compiledCasm
});

Inherited from​

Account.estimateDeclareFee

estimateAccountDeployFee()​

estimateAccountDeployFee(contractPayload, details?): Promise<EstimateFeeResponseOverhead>

Defined in: src/account/default.ts:222

Estimate fee for executing a DEPLOY_ACCOUNT transaction on Starknet

Parameters​

contractPayload​

DeployAccountContractPayload & object

Account deployment payload

  • .classHash - Class hash of the account contract
  • .constructorCalldata - Constructor parameters
  • .contractAddress - Pre-computed account address
  • .addressSalt - Salt for address generation
  • .abi - Abi of the account contract (optional): the constructor calldata is checked against it
details?​

UniversalDetails = {}

Returns​

Promise<EstimateFeeResponseOverhead>

Fee estimation including overall_fee and resourceBounds

Example​

const fee = await account.estimateAccountDeployFee({
  classHash: accountClassHash,
  constructorCalldata: { publicKey },
  addressSalt: publicKey
});

Inherited from​

Account.estimateAccountDeployFee

estimateDeployFee()​

estimateDeployFee(payload, details?): Promise<EstimateFeeResponseOverhead>

Defined in: src/account/default.ts:257

Estimate fee for deploying contract(s) through the Universal Deployer Contract (UDC)

Parameters​

payload​

UniversalDeployerContractPayload | UniversalDeployerContractPayload[]

details?​

UniversalDetails = {}

Returns​

Promise<EstimateFeeResponseOverhead>

Fee estimation for the deployment transaction

Example​

const fee = await account.estimateDeployFee({
  classHash: contractClassHash,
  constructorCalldata: [param1, param2],
  unique: true
});

Inherited from​

Account.estimateDeployFee

estimateFeeBulk()​

estimateFeeBulk(invocations, details?): Promise<EstimateFeeBulk>

Defined in: src/account/default.ts:265

Estimate fees for executing multiple transactions in a single request

Parameters​

invocations​

Invocations

Array of transactions to estimate

  • .type - Transaction type: DECLARE, DEPLOY, INVOKE, DEPLOY_ACCOUNT
  • .payload - Transaction-specific payload
details?​

UniversalDetails = {}

Optional details for fee estimation

Returns​

Promise<EstimateFeeBulk>

Array of fee estimations for each transaction

Example​

const fees = await account.estimateFeeBulk([
  { type: 'INVOKE', payload: { contractAddress, entrypoint, calldata } },
  { type: 'DECLARE', payload: { contract, casm } }
]);

Inherited from​

Account.estimateFeeBulk

simulateTransaction()​

simulateTransaction(invocations, details?): Promise<SimulateTransactionOverheadResponse>

Defined in: src/account/default.ts:295

Parameters​

invocations​

Invocations

details?​

SimulateTransactionDetails = {}

Returns​

Promise<SimulateTransactionOverheadResponse>

Inherited from​

Account.simulateTransaction

getSignedTransaction()​

getSignedTransaction(transactions, transactionsDetail?): Promise<INVOKE_TXN_V3>

Defined in: src/account/default.ts:430

Build a signed INVOKE_TXN_V3 transaction without submitting it to the network.

Produces a fully signed transaction object that can be inspected, stored, or submitted later via provider.channel.sendTransaction(). Main usage is to send a virtual transaction to a proof server. Fees are estimated automatically if not provided.

Parameters​

transactions​

AllowArray<Call>

Single call or array of calls to include in the transaction

transactionsDetail?​

UniversalDetails = {}

Transaction execution options

Returns​

Promise<INVOKE_TXN_V3>

A fully signed RPC.INVOKE_TXN_V3 object, ready to broadcast

Remarks​

  • Unlike execute(), this method does not submit the transaction ; the account nonce is unchanged after the call.
  • The afterExecute plugin hook is intentionally not triggered.
  • The returned object can be broadcast with provider.channel.sendTransaction().

Example​

const signedTx = await account.getSignedTransaction(
  { contractAddress: erc20Address, entrypoint: 'transfer', calldata: [recipient, amount, 0] }
);

Inherited from​

Account.getSignedTransaction

declareIfNot()​

declareIfNot(payload, transactionsDetail?): Promise<{ class_hash: string; transaction_hash: string; }>

Defined in: src/account/default.ts:464

First check if contract is already declared, if not declare it If contract already declared returned transaction_hash is ''. Method will pass even if contract is already declared

A given classHash is used as is to look for the class on the node, without being checked against contract, to save time.

Parameters​

payload​

DeclareContractPayload

transactionsDetail?​

UniversalDetails = {}

(optional)

Returns​

Promise<{ class_hash: string; transaction_hash: string; }>

Inherited from​

Account.declareIfNot

deployContract()​

deployContract(payload, details?): Promise<DeployContractUDCResponse>

Defined in: src/account/default.ts:547

Deploy and wait for a contract deployment to complete

Parameters​

payload​

UniversalDeployerContractPayload | UniversalDeployerContractPayload[]

Deployment configuration(s)

details?​

UniversalDetails & waitForTransactionOptions = {}

Transaction execution options

Returns​

Promise<DeployContractUDCResponse>

Deployment result with contract address and UDC event details

Remarks​

This method waits for transaction confirmation before returning

Example​

const result = await account.deployContract({
  classHash: contractClassHash,
  constructorCalldata: params
});
console.log('Deployed at:', result.address);

Inherited from​

Account.deployContract

declareAndDeploy()​

declareAndDeploy(payload, details?): Promise<DeclareDeployUDCResponse>

Defined in: src/account/default.ts:558

Declare and deploy a contract in a single method

Parameters​

payload​

DeclareAndDeployContractPayload

Combined declare and deploy configuration

  • .contract - Compiled Sierra contract
  • .casm - Compiled CASM (required for Cairo 1)
  • .compiledClassHash - Pre-computed CASM hash
  • .classHash - Pre-computed class hash, checked against .contract: a wrong one is refused
  • .constructorCalldata - Constructor parameters, or felts already compiled
  • .salt - Deployment salt
  • .unique - Ensure unique deployment address
details?​

UniversalDetails & waitForTransactionOptions = {}

Transaction execution options

Returns​

Promise<DeclareDeployUDCResponse>

Declaration and deployment results

Remarks​

  • Before declaring, checks the constructor calldata against the abi of contract (felts already compiled are read back with it), and a given classHash against contract: a mismatch fails before any transaction is sent
  • Automatically skips declaration if contract is already declared
  • With a given nonce, the deployment uses the next one when a declaration is sent
  • Waits for both transactions to complete
  • Does not support batch operations

Example​

const result = await account.declareAndDeploy({
  contract: compiledContract,
  casm: compiledCasm,
  constructorCalldata: [param1, param2]
});

Inherited from​

Account.declareAndDeploy

deployAccount()​

deployAccount(contractPayload, details?): Promise<DeployContractResponse>

Defined in: src/account/default.ts:610

Deploy the account contract itself on Starknet

Parameters​

contractPayload​

DeployAccountContractPayload & object

Account deployment configuration

  • .classHash - Account contract class hash
  • .constructorCalldata - Constructor parameters
  • .addressSalt - Salt for address generation
  • .contractAddress - Pre-computed address
  • .abi - Abi of the account contract (optional): the constructor calldata is checked against it
details?​

UniversalDetails = {}

Returns​

Promise<DeployContractResponse>

Deployment transaction hash and contract address

Remarks​

Used for deploying the account contract when using a pre-funded address

Example​

const deployment = await account.deployAccount({
  classHash: accountClassHash,
  constructorCalldata: { publicKey: pubKey },
  addressSalt: pubKey
});

Inherited from​

Account.deployAccount

hashMessage()​

hashMessage(typedData): Promise<string>

Defined in: src/account/default.ts:703

Hash a typed data message using Pedersen hash

Parameters​

typedData​

TypedData

EIP-712 style typed data structure

Returns​

Promise<string>

Message hash as hex string

Remarks​

  • Uses Pedersen hash function (not Keccak)
  • Includes domain separation
  • Result can be used for signature verification

Example​

const messageHash = await account.hashMessage(typedData);

Inherited from​

Account.hashMessage

getSnip9Version()​

getSnip9Version(): Promise<"0" | "1" | "2">

Defined in: src/account/default.ts:716

Verify if an account is compatible with SNIP-9 outside execution, and with which version of this standard.

Returns​

Promise<"0" | "1" | "2">

Not compatible, V1, V2.

Example​

const result = myAccount.getSnip9Version();
// result = "V1"

Inherited from​

Account.getSnip9Version

isValidSnip9Nonce()​

isValidSnip9Nonce(nonce): Promise<boolean>

Defined in: src/account/default.ts:737

Verify if a SNIP-9 nonce has not yet been used by the account.

Parameters​

nonce​

BigNumberish

SNIP-9 nonce to test.

Returns​

Promise<boolean>

true if SNIP-9 nonce not yet used.

Example​

const result = myAccount.isValidSnip9Nonce(1234);
// result = true

Inherited from​

Account.isValidSnip9Nonce

getSnip9Nonce()​

getSnip9Nonce(): Promise<string>

Defined in: src/account/default.ts:761

Outside transaction needs a specific SNIP-9 nonce, that we get in this function. A SNIP-9 nonce can be any number not yet used ; no ordering is needed.

Returns​

Promise<string>

an Hex string of a SNIP-9 nonce.

Example​

const result = myAccount.getSnip9Nonce();
// result = "0x28a612590dbc36927933c8ee0f357eee639c8b22b3d3aa86949eed3ada4ac55"

Inherited from​

Account.getSnip9Nonce

getOutsideTransaction()​

getOutsideTransaction(options, calls, version?, nonce?): Promise<OutsideTransaction>

Defined in: src/account/default.ts:798

Creates an object containing transaction(s) that can be executed by an other account with Account.executeFromOutside(), called Outside Transaction.

Parameters​

options​

OutsideExecutionOptions

Parameters of the transaction(s).

calls​

AllowArray<Call>

Transaction(s) to execute.

version?​

"0" | "1" | "2"

SNIP-9 version of the Account that creates the outside transaction.

nonce?​

BigNumberish

Outside Nonce.

Returns​

Promise<OutsideTransaction>

and object that can be used in Account.executeFromOutside()

Example​

const now_seconds = Math.floor(Date.now() / 1000);
const callOptions: OutsideExecutionOptions = {
   caller: executorAccount.address, execute_after: now_seconds - 3600, execute_before: now_seconds + 3600 };
const call1: Call = { contractAddress: ethAddress, entrypoint: 'transfer', calldata: {
    recipient: recipientAccount.address, amount: cairo.uint256(100) } };
const outsideTransaction1: OutsideTransaction = await signerAccount.getOutsideTransaction(callOptions, call3);
// result = {
// outsideExecution: {
// caller: '0x64b48806902a367c8598f4f95c305e8c1a1acba5f082d294a43793113115691',
// nonce: '0x28a612590dbc36927933c8ee0f357eee639c8b22b3d3aa86949eed3ada4ac55',
// execute_after: 1723650229, execute_before: 1723704229, calls: [[Object]] },
// signature: Signature {
// r: 67518627037915514985321278857825384106482999609634873287406612756843916814n,
// s: 737198738569840639192844101690009498983611654458636624293579534560862067709n, recovery: 0 },
// signerAddress: '0x655f8fd7c4013c07cf12a92184aa6c314d181443913e21f7e209a18f0c78492',
// version: '2'
// }

Inherited from​

Account.getOutsideTransaction

executeFromOutside()​

executeFromOutside(outsideTransaction, opts?): Promise<{ transaction_hash: string; }>

Defined in: src/account/default.ts:858

An account B executes a transaction that has been signed by an account A. Fees are paid by B.

Parameters​

outsideTransaction​

AllowArray<OutsideTransaction>

the signed transaction generated by Account.getOutsideTransaction().

opts?​

UniversalDetails

same options than Account.execute().

Returns​

Promise<{ transaction_hash: string; }>

same response than Account.execute().

Example​

const outsideTransaction1: OutsideTransaction = await signerAccount.getOutsideTransaction(callOptions, call1);
const outsideTransaction2: OutsideTransaction = await signerAccount.getOutsideTransaction(callOptions4, call4);
const result = await myAccount.executeFromOutside([
   outsideTransaction1,
   outsideTransaction2,
 ]);
// result = { transaction_hash: '0x11233...`}

Inherited from​

Account.executeFromOutside

buildInvocation()​

buildInvocation(call, details): Promise<Invocation>

Defined in: src/account/default.ts:894

Parameters​

call​

Call[]

details​

InvocationsSignerDetails

Returns​

Promise<Invocation>

Inherited from​

Account.buildInvocation

buildDeclarePayload()​

buildDeclarePayload(payload, details): Promise<DeclareContractTransaction>

Defined in: src/account/default.ts:909

Parameters​

payload​

DeclareContractPayload

details​

InvocationsSignerDetails

Returns​

Promise<DeclareContractTransaction>

Inherited from​

Account.buildDeclarePayload

buildAccountDeployPayload()​

buildAccountDeployPayload(__namedParameters, details): Promise<DeployAccountContractTransaction>

Defined in: src/account/default.ts:944

Parameters​

__namedParameters​

DeployAccountContractPayload & object

details​

InvocationsSignerDetails

Returns​

Promise<DeployAccountContractTransaction>

Inherited from​

Account.buildAccountDeployPayload

getStarkName()​

getStarkName(address?, StarknetIdContract?): Promise<string>

Defined in: src/plugins/starknet-id/index.ts:41

Parameters​

address?​

BigNumberish

StarknetIdContract?​

string

Returns​

Promise<string>

Inherited from​

Account.getStarkName

getAddressFromStarkName()​

getAddressFromStarkName(name, StarknetIdContract?): Promise<string>

Defined in: src/plugins/starknet-id/index.ts:42

Parameters​

name​

string

StarknetIdContract?​

string

Returns​

Promise<string>

Inherited from​

Account.getAddressFromStarkName

getStarkProfile()​

getStarkProfile(address, StarknetIdContract?, StarknetIdIdentityContract?, StarknetIdVerifierContract?, StarknetIdPfpContract?, StarknetIdPopContract?, StarknetIdMulticallContract?): Promise<StarkProfile>

Defined in: src/plugins/starknet-id/index.ts:43

Parameters​

address​

BigNumberish

StarknetIdContract?​

string

StarknetIdIdentityContract?​

string

StarknetIdVerifierContract?​

string

StarknetIdPfpContract?​

string

StarknetIdPopContract?​

string

StarknetIdMulticallContract?​

string

Returns​

Promise<StarkProfile>

Inherited from​

Account.getStarkProfile

getBrotherName()​

getBrotherName(address, BrotherIdContract?): Promise<string>

Defined in: src/plugins/brother-id/index.ts:47

Parameters​

address​

BigNumberish

BrotherIdContract?​

string

Returns​

Promise<string>

Inherited from​

Account.getBrotherName

getAddressFromBrotherName()​

getAddressFromBrotherName(name, BrotherIdContract?): Promise<string>

Defined in: src/plugins/brother-id/index.ts:48

Parameters​

name​

string

BrotherIdContract?​

string

Returns​

Promise<string>

Inherited from​

Account.getAddressFromBrotherName

getBrotherProfile()​

getBrotherProfile(address, BrotherIdContract?): Promise<BrotherProfile>

Defined in: src/plugins/brother-id/index.ts:49

Parameters​

address​

BigNumberish

BrotherIdContract?​

string

Returns​

Promise<BrotherProfile>

Inherited from​

Account.getBrotherProfile

fastExecute()​

fastExecute(transactions, transactionsDetail?, waitDetail?): Promise<FastExecuteResponse>

Defined in: src/plugins/fast-execute/types.ts:119

Execute one or multiple calls through the account contract, responding as soon as a new transaction is possible with the same account. Useful for gaming usage where rapid consecutive transactions are needed.

This method requires the provider to be initialized with pre_confirmed blockIdentifier option. RPC 0.9 minimum.

In a normal account.execute() call followed by provider.waitForTransaction(), you have immediate access to the events and transaction report. Here, we process consecutive transactions faster, but events and transaction reports are not available immediately.

As a consequence of the above, do not use contract/account deployment with this method.

Parameters​

transactions​

any

Single call or array of calls to execute

transactionsDetail?​

any

Transaction execution options

waitDetail?​

FastWaitForTransactionOptions

Options to scan the network for the next possible transaction. retries is the number of times to retry (default: 50), retryInterval is the time in ms between retries (default: 500).

Returns​

Promise<FastExecuteResponse>

Response containing the transaction result and status for the next transaction. If isReady is true, you can execute the next transaction immediately. If false, timeout has been reached before the next transaction was possible.

Example​

const myProvider = new RpcProvider({
  nodeUrl: url,
  blockIdentifier: BlockTag.PRE_CONFIRMED
});
const myAccount = new Account({
  provider: myProvider,
  address: accountAddress0,
  signer: privateKey0
});

const resp = await myAccount.fastExecute(
  call,
  { tip: recommendedTip },
  { retries: 30, retryInterval: 500 }
);

// if resp.isReady is true, you can launch immediately a new tx
if (resp.isReady) {
  // send next transaction
}

Inherited from​

Account.fastExecute

buildPaymasterTransaction()​

buildPaymasterTransaction(calls, paymasterDetails): Promise<PreparedTransaction>

Defined in: src/plugins/paymaster/types/plugin.type.ts:36

Build a transaction for paymaster execution

Parameters​

calls​

Call[]

Array of calls to be sponsored

paymasterDetails​

PaymasterDetails

Paymaster configuration

Returns​

Promise<PreparedTransaction>

Prepared transaction with typed data for signing

Example​

const prepared = await account.buildPaymasterTransaction(
  calls,
  { feeMode: { mode: 'default', gasToken: ETH_ADDRESS } }
);

Inherited from​

Account.buildPaymasterTransaction

estimatePaymasterTransactionFee()​

estimatePaymasterTransactionFee(calls, paymasterDetails): Promise<PaymasterFeeEstimate>

Defined in: src/plugins/paymaster/types/plugin.type.ts:63

Estimate fees for a paymaster-sponsored transaction

Parameters​

calls​

Call[]

Array of calls to be sponsored

  • .contractAddress - Target contract address
  • .entrypoint - Function to invoke
  • .calldata - Function parameters
paymasterDetails​

PaymasterDetails

Paymaster configuration

  • .feeMode - Sponsorship mode: 'sponsored' or gas token
  • .deploymentData - Account deployment data if needed
  • .timeBounds - Valid execution time window

Returns​

Promise<PaymasterFeeEstimate>

Fee estimates in both STRK and gas token

Example​

const fees = await account.estimatePaymasterTransactionFee(
  [{ contractAddress, entrypoint, calldata }],
  { feeMode: { mode: 'sponsored' } }
);

Inherited from​

Account.estimatePaymasterTransactionFee

preparePaymasterTransaction()​

preparePaymasterTransaction(preparedTransaction, calls, paymasterDetails, maxFeeInGasToken?): Promise<ExecutableUserTransaction>

Defined in: src/plugins/paymaster/types/plugin.type.ts:92

Signs a transaction prepared by the paymaster, after checking it is safe to sign. The safety check needs the calls and the fee details the user actually requested, so a caller that uses this low-level method directly must pass them, the same way executePaymasterTransaction does.

Parameters​

preparedTransaction​

PreparedTransaction

the transaction returned by the paymaster.

calls​

Call[]

the calls the user requested.

paymasterDetails​

PaymasterDetails

the fee mode and related paymaster details.

maxFeeInGasToken?​

BigNumberish

optional user-approved ceiling on the gas-token fee.

Returns​

Promise<ExecutableUserTransaction>

The transaction to send to the paymaster, with the signed typed data.

Example​

const prepared = await account.buildPaymasterTransaction(calls, paymasterDetails);
const executable = await account.preparePaymasterTransaction(
  prepared,
  calls,
  paymasterDetails
);
const { transaction_hash } = await account.paymaster.executeTransaction(
  executable,
  prepared.parameters
);

Inherited from​

Account.preparePaymasterTransaction

executePaymasterTransaction()​

executePaymasterTransaction(calls, paymasterDetails, maxFeeInGasToken?): Promise<{ transaction_hash: string; }>

Defined in: src/plugins/paymaster/types/plugin.type.ts:122

Execute a paymaster-sponsored transaction

Parameters​

calls​

Call[]

Array of calls to execute

paymasterDetails​

PaymasterDetails

Paymaster configuration

  • .feeMode - 'sponsored' or gas token payment
  • .deploymentData - Deploy account if needed
  • .timeBounds - Execution validity window (UNIX timestamps)
maxFeeInGasToken?​

BigNumberish

Maximum acceptable fee in gas token

Returns​

Promise<{ transaction_hash: string; }>

Transaction hash if successful

Throws​

If gas token price exceeds maxFeeInGasToken

Throws​

If transaction parameters are modified by paymaster

Example​

const txHash = await account.executePaymasterTransaction(
  calls,
  { feeMode: { mode: 'sponsored' }, timeBounds: { executeBefore: Date.now()/1000 + 3600 } },
  maxFeeETH
);

Inherited from​

Account.executePaymasterTransaction