Skip to main content
Version: Next

Class: WalletAccount

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

Interface for interacting with Starknet account contracts

Provides account-specific functionality including:

  • Transaction execution and signing
  • Fee estimation for various transaction types
  • Contract deployment through UDC (Universal Deployer Contract)
  • Paymaster support for sponsored transactions
  • EIP-712 message signing

Remarks​

Implementations of this interface typically handle the complexities of:

  • Nonce management
  • Transaction signing with the account's private key
  • Interaction with the account contract's execute entrypoint

Extends​

Constructors​

Constructor​

new WalletAccount(options): WalletAccount

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

Parameters​

options​

WalletAccountV4Options

Returns​

WalletAccount

Overrides​

Account.constructor

Properties​

walletProvider​

walletProvider: StarknetWalletProvider

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

provider​

provider: RpcProvider

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

Provider instance for blockchain interaction

Inherited from​

Account.provider

signer​

signer: SignerInterface

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

Signer instance for signing transactions and messages

Inherited from​

Account.signer

address​

address: string

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

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

paymaster​

paymaster: PaymasterInterface

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

Inherited from​

Account.paymaster

deployer​

deployer: Deployer

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

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:120

Inherited from​

Account.defaultTipType

accountPluginManager​

readonly accountPluginManager: PluginManager

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

Internal

Account-level plugin management

Inherited from​

Account.accountPluginManager

deploySelf​

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

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

ACCOUNT METHODS

Parameters​

contractPayload​

DeployAccountContractPayload

details?​

UniversalDetails = {}

Returns​

Promise<DeployContractResponse>

Example​

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

Inherited from​

Account.deploySelf

Methods​

connect()​

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

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

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:176

Parameters​

provider​

ProviderInterface | ProviderOptions

walletProvider​

StarknetWalletProvider

cairoVersion?​

CairoVersion

paymaster?​

PaymasterOptions | PaymasterInterface

Returns​

Promise<WalletAccount>

onAccountChange()​

onAccountChange(callback): void

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

WALLET EVENTS

Parameters​

callback​

AccountChangeEventHandler

Returns​

void

onNetworkChanged()​

onNetworkChanged(callback): void

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

Parameters​

callback​

NetworkChangeEventHandler

Returns​

void

requestAccounts()​

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

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

WALLET SPECIFIC METHODS

Parameters​

silentMode?​

boolean = false

Returns​

Promise<string[]>

getPermissions()​

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

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

Returns​

Promise<"accounts"[]>

switchStarknetChain()​

switchStarknetChain(chainId): Promise<boolean>

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

Parameters​

chainId​

"0x534e5f4d41494e" | "0x534e5f5345504f4c4941"

Returns​

Promise<boolean>

watchAsset()​

watchAsset(asset): Promise<boolean>

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

Parameters​

asset​

WatchAssetParameters

Returns​

Promise<boolean>

addStarknetChain()​

addStarknetChain(chain): Promise<boolean>

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

Parameters​

chain​

AddStarknetChainParameters

Returns​

Promise<boolean>

execute()​

execute(calls): Promise<AddInvokeTransactionResult>

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

ACCOUNT METHODS

Parameters​

calls​

AllowArray<Call>

Returns​

Promise<AddInvokeTransactionResult>

Overrides​

Account.execute

declare()​

declare(payload): Promise<AddDeclareTransactionResult>

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

ACCOUNT METHODS

Parameters​

payload​

DeclareContractPayload

Returns​

Promise<AddDeclareTransactionResult>

Example​

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

Overrides​

Account.declare

deploy()​

deploy(payload): Promise<MultiDeployContractResponse>

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

ACCOUNT METHODS

Parameters​

payload​

UniversalDeployerContractPayload | UniversalDeployerContractPayload[]

Returns​

Promise<MultiDeployContractResponse>

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:155

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:161

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

getNonceSafe()​

protected getNonceSafe(nonce?): Promise<bigint>

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

Parameters​

nonce?​

BigNumberish

Returns​

Promise<bigint>

Inherited from​

Account.getNonceSafe

getCairoVersion()​

getCairoVersion(classHash?): Promise<CairoVersion>

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

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:188

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:198

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:217

Estimate fee for executing an INVOKE transaction on Starknet

Parameters​

contractPayload​

DeployAccountContractPayload

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.estimateAccountDeployFee({
  classHash: accountClassHash,
  constructorCalldata: { publicKey },
  addressSalt: publicKey
});

Inherited from​

Account.estimateAccountDeployFee

estimateDeployFee()​

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

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

Estimate fee for executing an INVOKE transaction on Starknet

Parameters​

payload​

UniversalDeployerContractPayload | UniversalDeployerContractPayload[]

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.estimateDeployFee({
  classHash: contractClassHash,
  constructorCalldata: [param1, param2],
  unique: true
});

Inherited from​

Account.estimateDeployFee

estimateFeeBulk()​

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

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

Estimate fee for executing an INVOKE transaction on Starknet

Parameters​

invocations​

Invocations

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<EstimateFeeBulk>

Fee estimation including overall_fee and resourceBounds

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:285

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:420

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:451

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

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:532

ACCOUNT METHODS

Parameters​

payload​

UniversalDeployerContractPayload | UniversalDeployerContractPayload[]

details?​

UniversalDetails & waitForTransactionOptions = {}

Transaction execution options

Returns​

Promise<DeployContractUDCResponse>

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:543

ACCOUNT METHODS

Parameters​

payload​

DeclareAndDeployContractPayload

details?​

UniversalDetails & waitForTransactionOptions = {}

Transaction execution options

Returns​

Promise<DeclareDeployUDCResponse>

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:561

ACCOUNT METHODS

Parameters​

contractPayload​

DeployAccountContractPayload

details?​

UniversalDetails = {}

Returns​

Promise<DeployContractResponse>

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:648

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:661

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:682

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:706

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:743

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:803

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:839

Parameters​

call​

Call[]

details​

InvocationsSignerDetails

Returns​

Promise<Invocation>

Inherited from​

Account.buildInvocation

buildDeclarePayload()​

buildDeclarePayload(payload, details): Promise<DeclareContractTransaction>

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

Parameters​

payload​

DeclareContractPayload

details​

InvocationsSignerDetails

Returns​

Promise<DeclareContractTransaction>

Inherited from​

Account.buildDeclarePayload

buildAccountDeployPayload()​

buildAccountDeployPayload(__namedParameters, details): Promise<DeployAccountContractTransaction>

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

Parameters​

__namedParameters​

DeployAccountContractPayload

details​

InvocationsSignerDetails

Returns​

Promise<DeployAccountContractTransaction>

Inherited from​

Account.buildAccountDeployPayload

buildPaymasterTransaction()​

buildPaymasterTransaction(calls, paymasterDetails): Promise<PreparedTransaction>

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

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<PreparedTransaction>

Fee estimates in both STRK and gas token

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/account/default.ts:1081

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): Promise<ExecutableUserTransaction>

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

Parameters​

preparedTransaction​

PreparedTransaction

Returns​

Promise<ExecutableUserTransaction>

Inherited from​

Account.preparePaymasterTransaction

executePaymasterTransaction()​

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

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

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

getStarkName()​

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

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

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:41

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:42

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