Skip to main content
Version: 10.8.0

Class: WalletAccountV6

Defined in: src/wallet/accountV6.ts:33

WalletAccountV6 class. Extends WalletAccountV5 with get-starknet v6 types and STRK20 privacy protocol methods.

Extends​

Constructors​

Constructor​

new WalletAccountV6(options): WalletAccountV6

Defined in: src/wallet/accountV6.ts:34

Parameters​

options​

WalletAccountV6Options

Returns​

WalletAccountV6

Overrides​

WalletAccountV5.constructor

Properties​

walletProvider​

walletProvider: WalletWithStarknetFeatures

Defined in: src/wallet/accountV5.ts:50

Inherited from​

WalletAccountV5.walletProvider

provider​

provider: RpcProvider

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

Provider instance for blockchain interaction

Inherited from​

WalletAccountV5.provider

signer​

signer: SignerInterface

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

Signer instance for signing transactions and messages

Inherited from​

WalletAccountV5.signer

address​

address: string

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

The address of the account contract on Starknet

Inherited from​

WalletAccountV5.address

cairoVersion​

cairoVersion: CairoVersion

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

Cairo version of the account contract implementation

Inherited from​

WalletAccountV5.cairoVersion

transactionVersion​

readonly transactionVersion: "0x3"

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

Inherited from​

WalletAccountV5.transactionVersion

paymaster​

paymaster: PaymasterInterface

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

Inherited from​

WalletAccountV5.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​

WalletAccountV5.deployer

defaultTipType​

defaultTipType: TipType

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

Inherited from​

WalletAccountV5.defaultTipType

accountPluginManager​

readonly accountPluginManager: PluginManager

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

Internal

Account-level plugin management

Inherited from​

WalletAccountV5.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​

WalletAccountV5.deploySelf

Methods​

connect()​

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

Defined in: src/wallet/accountV6.ts:150

Parameters​

provider​

ProviderInterface | ProviderOptions

walletProvider​

WalletWithStarknetFeatures

cairoVersion?​

CairoVersion

paymaster?​

PaymasterOptions | PaymasterInterface

silentMode?​

boolean = false

Returns​

Promise<WalletAccountV6>

Overrides​

WalletAccountV5.connect

connectSilent()​

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

Defined in: src/wallet/accountV6.ts:172

Parameters​

provider​

ProviderInterface | ProviderOptions

walletProvider​

WalletWithStarknetFeatures

cairoVersion?​

CairoVersion

paymaster?​

PaymasterOptions | PaymasterInterface

Returns​

Promise<WalletAccountV6>

Overrides​

WalletAccountV5.connectSilent

switchStarknetChain()​

switchStarknetChain(chainId, silent_mode?): Promise<boolean>

Defined in: src/wallet/accountV6.ts:43

Parameters​

chainId​

"0x534e5f4d41494e" | "0x534e5f5345504f4c4941"

silent_mode?​

boolean = false

Returns​

Promise<boolean>

Overrides​

WalletAccountV5.switchStarknetChain

executeWithProof()​

executeWithProof(calls, proof?): Promise<AddInvokeTransactionResult>

Defined in: src/wallet/accountV6.ts:60

Execute call(s) with an optional STRK20 privacy proof attached. Same signature as execute(), with an extra parameter for the proof provided by strk20PrepareInvoke().

Parameters​

calls​

AllowArray<Call>

The call(s) to invoke.

proof?​

STRK20_PROOF

The SNIP-36 zero-knowledge proof to attach.

Returns​

Promise<AddInvokeTransactionResult>

The hash of the submitted transaction.

Example​

const { proof } = await myWalletAccount.strk20PrepareInvoke(actions);
const result = await myWalletAccount.executeWithProof(myContract.populate('claim'), proof);
// result = { transaction_hash: '0x6f7d...' }

strk20Balances()​

strk20Balances(tokens): Promise<STRK20_BALANCE_ENTRY[]>

Defined in: src/wallet/accountV6.ts:75

Get the private balances held by the user inside the STRK20 privacy pool.

Parameters​

tokens​

string[]

The tokens to get the private balance of. An empty array returns every shielded token.

Returns​

Promise<STRK20_BALANCE_ENTRY[]>

One entry per token.

Example​

const balances = await myWalletAccount.strk20Balances([strkAddress]);
// balances = [{ token: '0x4718...', amount: '0x2386f26fc10000' }]

strk20PrepareInvoke()​

strk20PrepareInvoke(actions, simulate?): Promise<STRK20_CALL_AND_PROOF>

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

Build the Starknet call and the SNIP-36 zero-knowledge proof of a STRK20 transaction, without submitting it : the DAPP submits the returned call itself, and therefore pays the fee (the wallet adds no fee action in this mode).

With simulate set to true, the wallet skips the expensive proof generation and returns an empty proof : the call is then NOT submittable on-chain, and is only useful for fee estimation or UI previews.

Parameters​

actions​

STRK20_ACTION[]

The STRK20 actions to perform atomically (min 1).

simulate?​

boolean

True to skip the proof generation.

Returns​

Promise<STRK20_CALL_AND_PROOF>

The Starknet.js call to submit, and its proof.

Example​

const { call, proof } = await myWalletAccount.strk20PrepareInvoke(actions);
const result = await mySponsorAccount.execute(call, {
  proof: proof.data,
  proofFacts: proof.proof_facts,
});
// result = { transaction_hash: '0x6f7d...' }

strk20InvokeTransaction()​

strk20InvokeTransaction(actions): Promise<{ transaction_hash: string; }>

Defined in: src/wallet/accountV6.ts:124

Submit STRK20 actions as a single atomic transaction. The wallet displays an approval UI, generates the SNIP-36 proof, adds the fee action, and submits — so this call may take significantly longer than a standard invoke.

Parameters​

actions​

STRK20_ACTION[]

The STRK20 actions to perform atomically (min 1).

Returns​

Promise<{ transaction_hash: string; }>

The hash of the submitted transaction.

Example​

const result = await myWalletAccount.strk20InvokeTransaction(actions);
// result = { transaction_hash: '0x6f7d...' }

strk20ShadowAccountCommitment()​

strk20ShadowAccountCommitment(dappName, nonce?): Promise<string>

Defined in: src/wallet/accountV6.ts:146

Compute the commitment of a DAPP STRK20 shadow account. The commitment is computed locally by the wallet from the user private state ; no transaction is sent.

When nonce is given, the full commitment of this single shadow account is returned. When nonce is omitted, the partial (nonce independent) commitment is returned instead : it is shared by every shadow account the user derives for this DAPP, so it can be published once to let a DAPP recognize all the shadow accounts of a user without learning any individual nonce.

Parameters​

dappName​

string

The DAPP that scopes the shadow account(s).

nonce?​

string

The shadow account nonce ; each nonce selects a distinct shadow account for this user + DAPP. Omit it to get the partial commitment.

Returns​

Promise<string>

The shadow account commitment.

Example​

const commitment = await myWalletAccount.strk20ShadowAccountCommitment('myDapp', '0x0');
// commitment = '0x5f2e...'

onChange()​

onChange(callback): () => void

Defined in: src/wallet/accountV5.ts:90

Subscribe a callback to wallet account/network changes.

Parameters​

callback​

(change) => void

called on each change.

Returns​

a function to unsubscribe this specific callback.

() => void

Inherited from​

WalletAccountV5.onChange

unsubscribeChange()​

unsubscribeChange(): void

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

Unsubscribe from all wallet events, including the callbacks registered through onChange. To call before the instance is deleted.

Returns​

void

Inherited from​

WalletAccountV5.unsubscribeChange

requestAccounts()​

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

Defined in: src/wallet/accountV5.ts:109

WALLET SPECIFIC METHODS

Parameters​

silentMode?​

boolean = false

Returns​

Promise<string[]>

Inherited from​

WalletAccountV5.requestAccounts

getPermissions()​

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

Defined in: src/wallet/accountV5.ts:113

Returns​

Promise<"accounts"[]>

Inherited from​

WalletAccountV5.getPermissions

watchAsset()​

watchAsset(asset): Promise<boolean>

Defined in: src/wallet/accountV5.ts:121

Parameters​

asset​

WatchAssetParameters

Returns​

Promise<boolean>

Inherited from​

WalletAccountV5.watchAsset

addStarknetChain()​

addStarknetChain(chain): Promise<boolean>

Defined in: src/wallet/accountV5.ts:125

Parameters​

chain​

AddStarknetChainParameters

Returns​

Promise<boolean>

Inherited from​

WalletAccountV5.addStarknetChain

execute()​

execute(calls): Promise<AddInvokeTransactionResult>

Defined in: src/wallet/accountV5.ts:132

ACCOUNT METHODS

Parameters​

calls​

AllowArray<Call>

Returns​

Promise<AddInvokeTransactionResult>

Inherited from​

WalletAccountV5.execute

declare()​

declare(payload): Promise<AddDeclareTransactionResult>

Defined in: src/wallet/accountV5.ts:149

ACCOUNT METHODS

Parameters​

payload​

DeclareContractPayload

Returns​

Promise<AddDeclareTransactionResult>

Example​

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

Inherited from​

WalletAccountV5.declare

deploy()​

deploy(payload): Promise<MultiDeployContractResponse>

Defined in: src/wallet/accountV5.ts:167

ACCOUNT METHODS

Parameters​

payload​

UniversalDeployerContractPayload | UniversalDeployerContractPayload[]

Returns​

Promise<MultiDeployContractResponse>

Example​

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

Inherited from​

WalletAccountV5.deploy

signMessage()​

signMessage(typedData): Promise<SIGNATURE>

Defined in: src/wallet/accountV5.ts:178

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!' }
});

Inherited from​

WalletAccountV5.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​

WalletAccountV5.getNonce

getNonceSafe()​

protected getNonceSafe(nonce?): Promise<bigint>

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

Parameters​

nonce?​

BigNumberish

Returns​

Promise<bigint>

Inherited from​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.estimateFeeBulk

simulateTransaction()​

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

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

Parameters​

invocations​

Invocations

details?​

SimulateTransactionDetails = {}

Returns​

Promise<SimulateTransactionOverheadResponse>

Inherited from​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.executeFromOutside

buildInvocation()​

buildInvocation(call, details): Promise<Invocation>

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

Parameters​

call​

Call[]

details​

InvocationsSignerDetails

Returns​

Promise<Invocation>

Inherited from​

WalletAccountV5.buildInvocation

buildDeclarePayload()​

buildDeclarePayload(payload, details): Promise<DeclareContractTransaction>

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

Parameters​

payload​

DeclareContractPayload

details​

InvocationsSignerDetails

Returns​

Promise<DeclareContractTransaction>

Inherited from​

WalletAccountV5.buildDeclarePayload

buildAccountDeployPayload()​

buildAccountDeployPayload(__namedParameters, details): Promise<DeployAccountContractTransaction>

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

Parameters​

__namedParameters​

DeployAccountContractPayload

details​

InvocationsSignerDetails

Returns​

Promise<DeployAccountContractTransaction>

Inherited from​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.estimatePaymasterTransactionFee

preparePaymasterTransaction()​

preparePaymasterTransaction(preparedTransaction): Promise<ExecutableUserTransaction>

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

Parameters​

preparedTransaction​

PreparedTransaction

Returns​

Promise<ExecutableUserTransaction>

Inherited from​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.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​

WalletAccountV5.fastExecute