Class: Account

AccountInterface.estimateInvokeFee

Fee estimation including overall_fee and resourceBounds

Example

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

Implementation of

Defined in

src/account/default.ts:172

estimateDeclareFee

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

Estimate fee for executing a DECLARE transaction on Starknet

Parameters

Name	Type	Description
`payload`	`DeclareContractPayload`	Contract declaration payload. - .contract - Compiled contract (Sierra JSON). - .casm - Compiled Cairo assembly (required for Cairo 1). - .classHash - Pre-computed class hash (optional optimization). - .compiledClassHash - Pre-computed CASM hash (alternative to casm).
`details`	`UniversalDetails`	Optional details for fee estimation. - .blockIdentifier - Block to estimate against. - .nonce - Account nonce (defaults to current nonce) - .skipValidate - Skip account validation (default: true) - .tip - Priority fee tip for faster inclusion - .version - Transaction version (v3 uses fri, v1/v2 use wei)

Returns

AccountInterface.estimateDeclareFee

Fee estimation including overall_fee and resourceBounds

Example

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

Implementation of

Defined in

src/account/default.ts:182

estimateAccountDeployFee

▸ estimateAccountDeployFee(«destructured», details?): Promise<EstimateFeeResponseOverhead>

Estimate fee for executing an INVOKE transaction on Starknet

Parameters

Name	Type	Description
`«destructured»`	`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`	Optional details for fee estimation - .blockIdentifier - Block to estimate against - .nonce - Account nonce (defaults to current nonce) - .skipValidate - Skip account validation (default: true) - .tip - Priority fee tip in fri/wei for faster inclusion - .accountDeploymentData - Include account deployment - .paymasterData - Paymaster sponsorship data - .nonceDataAvailabilityMode - DA mode for nonce - .feeDataAvailabilityMode - DA mode for fee - .version - Transaction version (v3 uses fri, v1/v2 use wei) - .resourceBounds - Resource limits for v3 transactions

Returns

AccountInterface.estimateAccountDeployFee

Fee estimation including overall_fee and resourceBounds

Example

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

Implementation of

Defined in

src/account/default.ts:201

estimateDeployFee

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

Estimate fee for executing an INVOKE transaction on Starknet

Parameters

Name	Type	Description
`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`	Optional details for fee estimation - .blockIdentifier - Block to estimate against - .nonce - Account nonce (defaults to current nonce) - .skipValidate - Skip account validation (default: true) - .tip - Priority fee tip in fri/wei for faster inclusion - .accountDeploymentData - Include account deployment - .paymasterData - Paymaster sponsorship data - .nonceDataAvailabilityMode - DA mode for nonce - .feeDataAvailabilityMode - DA mode for fee - .version - Transaction version (v3 uses fri, v1/v2 use wei) - .resourceBounds - Resource limits for v3 transactions

Returns

AccountInterface.estimateDeployFee

Fee estimation for the deployment transaction

Fee estimation including overall_fee and resourceBounds

Example

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

Implementation of

Defined in

src/account/default.ts:231

estimateFeeBulk

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

Estimate fee for executing an INVOKE transaction on Starknet

Parameters

Name	Type	Description
`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`	Optional details for fee estimation - .blockIdentifier - Block to estimate against - .nonce - Account nonce (defaults to current nonce) - .skipValidate - Skip account validation (default: true) - .tip - Priority fee tip in fri/wei for faster inclusion - .accountDeploymentData - Include account deployment - .paymasterData - Paymaster sponsorship data - .nonceDataAvailabilityMode - DA mode for nonce - .feeDataAvailabilityMode - DA mode for fee - .version - Transaction version (v3 uses fri, v1/v2 use wei) - .resourceBounds - Resource limits for v3 transactions

Returns

Promise<EstimateFeeBulk>

Array of fee estimations for each transaction

Fee estimation including overall_fee and resourceBounds

Example

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

Implementation of

AccountInterface.estimateFeeBulk

Defined in

src/account/default.ts:239

simulateTransaction

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

Parameters

Name	Type
`invocations`	`Invocations`
`details`	`SimulateTransactionDetails`

Returns

Promise<SimulateTransactionOverheadResponse>

Defined in

src/account/default.ts:269

execute

▸ execute(transactions, transactionsDetail?): Promise<{ transaction_hash: string }>

Execute one or multiple calls through the account contract

Parameters

Name	Type	Description
`transactions`	`AllowArray`<`Call`>	Single call or array of calls to execute - .contractAddress - Target contract address - .entrypoint - Function to invoke on the contract - .calldata - Function parameters
`transactionsDetail`	`UniversalDetails`	Transaction execution options - .nonce - Override account nonce - .maxFee - Maximum fee for v1/v2 transactions - .resourceBounds - Resource limits for v3 transactions - .tip - Priority fee tip - .version - Force specific transaction version

Returns

Promise<{ transaction_hash: string }>

Transaction hash and response

Example

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

Implementation of

AccountInterface.execute

Defined in

src/account/default.ts:297

fastExecute

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

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.

This method requires the provider to be initialized with pre_confirmed blockIdentifier option.
Rpc 0.9 minimum.
In a normal myAccount.execute() call, followed by myProvider.waitForTransaction(), you have an immediate access to the events and to the transaction report. Here, we are processing consecutive transactions faster, but events & transaction reports are not available immediately.
As a consequence of the previous point, do not use contract/account deployment with this method.

Parameters

Name	Type	Description
`transactions`	`AllowArray`<`Call`>	Single call or array of calls to execute
`transactionsDetail?`	`UniversalDetails`	Transaction execution options
`waitDetail?`	`fastWaitForTransactionOptions`	options to scan the network for the next possible transaction. `retries` is the number of times to retry, `retryInterval` is the time in ms between retries.

Returns

Promise<fastExecuteResponse>

Response containing the transaction result and status for the next transaction. If isReady is true, you can execute the next transaction. 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.

Defined in

src/account/default.ts:362

declareIfNot

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

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

Name	Type	Description
`payload`	`DeclareContractPayload`	-
`transactionsDetail`	`UniversalDetails`	(optional)

Returns

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

Implementation of

AccountInterface.declareIfNot

Defined in

src/account/default.ts:392

declare

▸ declare(payload, details?): Promise<{ class_hash: string ; transaction_hash: string }>

Execute one or multiple calls through the account contract

Parameters

Name	Type	Description
`payload`	`DeclareContractPayload`	Single call or array of calls to execute - .contractAddress - Target contract address - .entrypoint - Function to invoke on the contract - .calldata - Function parameters
`details`	`UniversalDetails`	Transaction execution options - .nonce - Override account nonce - .maxFee - Maximum fee for v1/v2 transactions - .resourceBounds - Resource limits for v3 transactions - .tip - Priority fee tip - .version - Force specific transaction version

Returns

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

Declaration transaction hash and class hash

Transaction hash and response

Example

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

Implementation of

AccountInterface.declare

Defined in

src/account/default.ts:411

deploy

▸ deploy(payload, details?): Promise<MultiDeployContractResponse>

Execute one or multiple calls through the account contract

Parameters

Name	Type	Description
`payload`	`UniversalDeployerContractPayload` \| `UniversalDeployerContractPayload`[]	Single call or array of calls to execute - .contractAddress - Target contract address - .entrypoint - Function to invoke on the contract - .calldata - Function parameters
`details`	`UniversalDetails`	Transaction execution options - .nonce - Override account nonce - .maxFee - Maximum fee for v1/v2 transactions - .resourceBounds - Resource limits for v3 transactions - .tip - Priority fee tip - .version - Force specific transaction version

Returns

Promise<MultiDeployContractResponse>

Deployed contract addresses and transaction hash

Transaction hash and response

Example

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

Implementation of

AccountInterface.deploy

Defined in

src/account/default.ts:460

deployContract

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

Execute one or multiple calls through the account contract

Parameters

Name	Type	Description
`payload`	`UniversalDeployerContractPayload` \| `UniversalDeployerContractPayload`[]	Single call or array of calls to execute - .contractAddress - Target contract address - .entrypoint - Function to invoke on the contract - .calldata - Function parameters
`details`	`UniversalDetails` & `waitForTransactionOptions`	Transaction execution options - .nonce - Override account nonce - .maxFee - Maximum fee for v1/v2 transactions - .resourceBounds - Resource limits for v3 transactions - .tip - Priority fee tip - .version - Force specific transaction version

Returns

Promise<DeployContractUDCResponse>

Deployment result with contract address and UDC event details

Deployed contract addresses and transaction hash

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);

Implementation of

AccountInterface.deployContract

Defined in

src/account/default.ts:473

declareAndDeploy

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

Execute one or multiple calls through the account contract

Parameters

Name	Type	Description
`payload`	`DeclareAndDeployContractPayload`	Single call or array of calls to execute - .contractAddress - Target contract address - .entrypoint - Function to invoke on the contract - .calldata - Function parameters
`details`	`UniversalDetails` & `waitForTransactionOptions`	Transaction execution options - .nonce - Override account nonce - .maxFee - Maximum fee for v1/v2 transactions - .resourceBounds - Resource limits for v3 transactions - .tip - Priority fee tip - .version - Force specific transaction version

Returns

Promise<DeclareDeployUDCResponse>

Declaration and deployment results

Transaction hash and response

Remarks

Automatically skips declaration if contract is already declared
Waits for both transactions to complete
Does not support batch operations

Example

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

Implementation of

AccountInterface.declareAndDeploy

Defined in

src/account/default.ts:484

deployAccount

▸ deployAccount(«destructured», details?): Promise<DeployContractResponse>

Execute one or multiple calls through the account contract

Parameters

Name	Type	Description
`«destructured»`	`DeployAccountContractPayload`	Single call or array of calls to execute - .contractAddress - Target contract address - .entrypoint - Function to invoke on the contract - .calldata - Function parameters
`details`	`UniversalDetails`	Transaction execution options - .nonce - Override account nonce - .maxFee - Maximum fee for v1/v2 transactions - .resourceBounds - Resource limits for v3 transactions - .tip - Priority fee tip - .version - Force specific transaction version

Returns

Promise<DeployContractResponse>

Deployment transaction hash and contract address

Transaction hash and response

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,
});

Implementation of

AccountInterface.deployAccount

Defined in

src/account/default.ts:502

signMessage

▸ signMessage(typedData): Promise<Signature>

Sign a typed data message for off-chain verification

Parameters

Name	Type	Description
`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!' }
});

Implementation of

AccountInterface.signMessage

Defined in

src/account/default.ts:573

hashMessage

▸ hashMessage(typedData): Promise<string>

Hash a typed data message using Pedersen hash

Parameters

Name	Type	Description
`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);

Implementation of

AccountInterface.hashMessage

Defined in

src/account/default.ts:577

getSnip9Version

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

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"

Defined in

src/account/default.ts:590

isValidSnip9Nonce

▸ isValidSnip9Nonce(nonce): Promise<boolean>

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

Parameters

Name	Type	Description
`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

Defined in

src/account/default.ts:611

getSnip9Nonce

▸ getSnip9Nonce(): Promise<string>

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"

Defined in

src/account/default.ts:635

getOutsideTransaction

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

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

Parameters

Name	Type	Description
`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'
// }

Defined in

src/account/default.ts:672

executeFromOutside

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

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

Parameters

Name	Type	Description
`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...`}

Defined in

src/account/default.ts:732

resolveDetailsWithTip

▸ resolveDetailsWithTip(details): Promise<UniversalDetails & { tip: BigNumberish }>

Helper method to resolve details with tip estimation

Parameters

Name	Type
`details`	`UniversalDetails`

Returns

Promise<UniversalDetails & { tip: BigNumberish }>

Defined in

src/account/default.ts:748

resolveTransactionVersion

▸ resolveTransactionVersion(providedVersion?): ETransactionVersion3

Helper method to resolve transaction version

Parameters

Name	Type
`providedVersion?`	`BigNumberish`

Returns

ETransactionVersion3

Defined in

src/account/default.ts:761

buildInvocation

▸ buildInvocation(call, details): Promise<Invocation>

Parameters

Name	Type
`call`	`Call`[]
`details`	`InvocationsSignerDetails`

Returns

Promise<Invocation>

Defined in

src/account/default.ts:768

buildDeclarePayload

▸ buildDeclarePayload(payload, details): Promise<DeclareContractTransaction>

Parameters

Name	Type
`payload`	`DeclareContractPayload`
`details`	`InvocationsSignerDetails`

Returns

Promise<DeclareContractTransaction>

Defined in

src/account/default.ts:783

buildAccountDeployPayload

▸ buildAccountDeployPayload(«destructured», details): Promise<DeployAccountContractTransaction>

Parameters

Name	Type
`«destructured»`	`DeployAccountContractPayload`
`details`	`InvocationsSignerDetails`

Returns

Promise<DeployAccountContractTransaction>

Defined in

src/account/default.ts:818

accountInvocationsFactory

▸ accountInvocationsFactory(invocations, details): Promise<[{ type: "INVOKE" } & CallDetails & { signature?: Signature | undefined; } & InvocationsDetailsWithNonce]>

Build account invocations with proper typing based on transaction type

Parameters

Name	Type
`invocations`	[{ `type`: `"INVOKE"` ; `payload`: `AllowArray`<`Call`> }]
`details`	`AccountInvocationsFactoryDetails`

Returns

Promise<[{ type: "INVOKE" } & CallDetails & { signature?: Signature | undefined; } & InvocationsDetailsWithNonce]>

Defined in

src/account/default.ts:856

▸ accountInvocationsFactory(invocations, details): Promise<[{ type: "DECLARE" } & DeclareContractTransaction & InvocationsDetailsWithNonce]>

Parameters

Name	Type
`invocations`	[{ `type`: `"DECLARE"` ; `payload`: `DeclareContractPayload` }]
`details`	`AccountInvocationsFactoryDetails`

Returns

Promise<[{ type: "DECLARE" } & DeclareContractTransaction & InvocationsDetailsWithNonce]>

Defined in

src/account/default.ts:862

▸ accountInvocationsFactory(invocations, details): Promise<[{ type: "DEPLOY_ACCOUNT" } & Omit<DeployAccountContractPayload, "contractAddress"> & { signature?: Signature | undefined; } & InvocationsDetailsWithNonce]>

Parameters

Name	Type
`invocations`	[{ `type`: `"DEPLOY_ACCOUNT"` ; `payload`: `DeployAccountContractPayload` }]
`details`	`AccountInvocationsFactoryDetails`

Returns

Promise<[{ type: "DEPLOY_ACCOUNT" } & Omit<DeployAccountContractPayload, "contractAddress"> & { signature?: Signature | undefined; } & InvocationsDetailsWithNonce]>

Defined in

src/account/default.ts:871

▸ accountInvocationsFactory(invocations, details): Promise<AccountInvocations>

Parameters

Name	Type
`invocations`	`Invocations`
`details`	`AccountInvocationsFactoryDetails`

Returns

Promise<AccountInvocations>

Defined in

src/account/default.ts:882

buildPaymasterTransaction

▸ buildPaymasterTransaction(calls, paymasterDetails): Promise<PreparedTransaction>

Estimate fees for a paymaster-sponsored transaction

Parameters

Name	Type	Description
`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>

Prepared transaction with typed data for signing

Fee estimates in both STRK and gas token

Example

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

Implementation of

AccountInterface.buildPaymasterTransaction

Defined in

src/account/default.ts:971

estimatePaymasterTransactionFee

▸ estimatePaymasterTransactionFee(calls, paymasterDetails): Promise<PaymasterFeeEstimate>

Estimate fees for a paymaster-sponsored transaction

Parameters

Name	Type	Description
`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' } }
);

Implementation of

AccountInterface.estimatePaymasterTransactionFee

Defined in

src/account/default.ts:1010

preparePaymasterTransaction

▸ preparePaymasterTransaction(preparedTransaction): Promise<ExecutableUserTransaction>

Parameters

Name	Type
`preparedTransaction`	`PreparedTransaction`

Returns

Promise<ExecutableUserTransaction>

Defined in

src/account/default.ts:1018

executePaymasterTransaction

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

Execute a paymaster-sponsored transaction

Parameters

Name	Type	Description
`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
);

Implementation of

AccountInterface.executePaymasterTransaction

Defined in

src/account/default.ts:1061

getStarkName

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

Get the Starknet ID for an address

Parameters

Name	Type	Description
`address`	`BigNumberish`	The address to get the Starknet ID for
`StarknetIdContract?`	`string`	The Starknet ID contract address (optional)

Returns

Promise<string>

The Starknet ID for the address

Overrides

Provider.getStarkName

Defined in

src/account/default.ts:1099

fetch

▸ fetch(method, params?, id?): Promise<Response>

Direct RPC method call

Parameters

Name	Type	Default value	Description
`method`	`string`	`undefined`	RPC method name
`params?`	`object`	`undefined`	method parameters
`id`	`string` \| `number`	`0`	request ID

Returns

Promise<Response>

RPC response

Implementation of

AccountInterface.fetch

Inherited from

Provider.fetch

Defined in

src/provider/rpc.ts:128

getChainId

▸ getChainId(): Promise<"0x534e5f4d41494e" | "0x534e5f5345504f4c4941">

Gets the Starknet chain Id

Returns

Promise<"0x534e5f4d41494e" | "0x534e5f5345504f4c4941">

the chain Id

Implementation of

AccountInterface.getChainId

Inherited from

Provider.getChainId

Defined in

src/provider/rpc.ts:132

readSpecVersion

▸ readSpecVersion(): undefined | "0.9.0" | "0.10.0"

Read channel spec version

Returns

undefined | "0.9.0" | "0.10.0"

Spec version string or undefined if not set

Implementation of

AccountInterface.readSpecVersion

Inherited from

Provider.readSpecVersion

Defined in

src/provider/rpc.ts:136

getSpecVersion

▸ getSpecVersion(): Promise<string>

Get channel spec version

Returns

Promise<string>

Promise resolving to spec version

Implementation of

AccountInterface.getSpecVersion

Inherited from

Provider.getSpecVersion

Defined in

src/provider/rpc.ts:140

setUpSpecVersion

▸ setUpSpecVersion(): Promise<"0.9.0" | "0.10.0">

Setup channel spec version and return it

Returns

Promise<"0.9.0" | "0.10.0">

Promise resolving to spec version

Implementation of

AccountInterface.setUpSpecVersion

Inherited from

Provider.setUpSpecVersion

Defined in

src/provider/rpc.ts:144

getStarknetVersion

▸ getStarknetVersion(blockIdentifier?): Promise<string>

Parameters

Name	Type
`blockIdentifier?`	`BlockIdentifier`

Returns

Promise<string>

Inherited from

Provider.getStarknetVersion

Defined in

src/provider/rpc.ts:148

getNonceForAddress

▸ getNonceForAddress(contractAddress, blockIdentifier?): Promise<string>

Returns the nonce associated with the given address in the given block

Parameters

Name	Type	Description
`contractAddress`	`BigNumberish`	contract address
`blockIdentifier?`	`BlockIdentifier`	-

Returns

Promise<string>

the hex nonce

Implementation of

AccountInterface.getNonceForAddress

Inherited from

Provider.getNonceForAddress

Defined in

src/provider/rpc.ts:152

getBlock

▸ getBlock(): Promise<{ transactions: string[] ; block_number: number ; timestamp: number ; sequencer_address: string ; l1_gas_price: RESOURCE_PRICE ; l2_gas_price: RESOURCE_PRICE ; l1_data_gas_price: RESOURCE_PRICE ; l1_da_mode: L1_DA_MODE ; starknet_version: string }>

Gets the block information

Returns

Promise<{ transactions: string[] ; block_number: number ; timestamp: number ; sequencer_address: string ; l1_gas_price: RESOURCE_PRICE ; l2_gas_price: RESOURCE_PRICE ; l1_data_gas_price: RESOURCE_PRICE ; l1_da_mode: L1_DA_MODE ; starknet_version: string }>

the block object

Implementation of

Inherited from

Defined in

src/provider/rpc.ts:159

▸ getBlock(blockIdentifier): Promise<{ transactions: string[] ; block_number: number ; timestamp: number ; sequencer_address: string ; l1_gas_price: RESOURCE_PRICE ; l2_gas_price: RESOURCE_PRICE ; l1_data_gas_price: RESOURCE_PRICE ; l1_da_mode: L1_DA_MODE ; starknet_version: string }>

Parameters

Name	Type
`blockIdentifier`	`"pre_confirmed"`

Returns

Implementation of

Inherited from

Defined in

src/provider/rpc.ts:160

▸ getBlock(blockIdentifier): Promise<{ status: EBlockStatus ; block_hash: string ; parent_hash: string ; block_number: number ; new_root: string ; timestamp: number ; sequencer_address: string ; l1_gas_price: RESOURCE_PRICE ; l2_gas_price: RESOURCE_PRICE ; l1_data_gas_price: RESOURCE_PRICE ; l1_da_mode: L1_DA_MODE ; starknet_version: string ; event_commitment: string ; transaction_commitment: string ; receipt_commitment: string ; state_diff_commitment: string ; event_count: number ; transaction_count: number ; state_diff_length: number ; transactions: string[] }>

Parameters

Name	Type
`blockIdentifier`	`"latest"`

Returns

Promise<{ status: EBlockStatus ; block_hash: string ; parent_hash: string ; block_number: number ; new_root: string ; timestamp: number ; sequencer_address: string ; l1_gas_price: RESOURCE_PRICE ; l2_gas_price: RESOURCE_PRICE ; l1_data_gas_price: RESOURCE_PRICE ; l1_da_mode: L1_DA_MODE ; starknet_version: string ; event_commitment: string ; transaction_commitment: string ; receipt_commitment: string ; state_diff_commitment: string ; event_count: number ; transaction_count: number ; state_diff_length: number ; transactions: string[] }>

Implementation of

Inherited from

Defined in

src/provider/rpc.ts:161

▸ getBlock(blockIdentifier): Promise<GetBlockResponse>

Parameters

Name	Type
`blockIdentifier`	`BlockIdentifier`

Returns

Promise<GetBlockResponse>

Implementation of

Inherited from

AccountInterface.getBlockLatestAccepted

Defined in

src/provider/rpc.ts:162

getBlockLatestAccepted

▸ getBlockLatestAccepted(): Promise<BlockHashAndNumber>

Get the most recent accepted block hash and number

Returns

Promise<BlockHashAndNumber>

Object containing block hash and number

Implementation of

Inherited from

Provider.getBlockLatestAccepted

Defined in

src/provider/rpc.ts:169

getBlockNumber

▸ getBlockNumber(): Promise<number>

Get the most recent accepted block number

Returns

Promise<number>

Number of the latest block

Implementation of

AccountInterface.getBlockNumber

Inherited from

Provider.getBlockNumber

Defined in

src/provider/rpc.ts:173

getBlockWithTxHashes

▸ getBlockWithTxHashes(blockIdentifier?): Promise<OnlyFirst<BLOCK_WITH_TX_HASHES, { status: EBlockStatus } & BLOCK_HEADER & BLOCK_BODY_WITH_TX_HASHES & PRE_CONFIRMED_BLOCK_HEADER> | OnlyFirst<PRE_CONFIRMED_BLOCK_WITH_TX_HASHES, { status: EBlockStatus } & BLOCK_HEADER & BLOCK_BODY_WITH_TX_HASHES & PRE_CONFIRMED_BLOCK_HEADER>>

Get block information with transaction hashes

Parameters

Name	Type	Description
`blockIdentifier?`	`BlockIdentifier`	block identifier

Returns

Promise<OnlyFirst<BLOCK_WITH_TX_HASHES, { status: EBlockStatus } & BLOCK_HEADER & BLOCK_BODY_WITH_TX_HASHES & PRE_CONFIRMED_BLOCK_HEADER> | OnlyFirst<PRE_CONFIRMED_BLOCK_WITH_TX_HASHES, { status: EBlockStatus } & BLOCK_HEADER & BLOCK_BODY_WITH_TX_HASHES & PRE_CONFIRMED_BLOCK_HEADER>>

Block with transaction hashes

Implementation of

AccountInterface.getBlockWithTxHashes

Inherited from

Provider.getBlockWithTxHashes

Defined in

src/provider/rpc.ts:177

getBlockWithTxs

▸ getBlockWithTxs(blockIdentifier?): Promise<OnlyFirst<BLOCK_WITH_TXS, { status: EBlockStatus } & BLOCK_HEADER & BLOCK_BODY_WITH_TXS & PRE_CONFIRMED_BLOCK_HEADER> | OnlyFirst<PRE_CONFIRMED_BLOCK_WITH_TXS, { status: EBlockStatus } & BLOCK_HEADER & BLOCK_BODY_WITH_TXS & PRE_CONFIRMED_BLOCK_HEADER>>

Get block information with full transactions

Parameters

Name	Type	Description
`blockIdentifier?`	`BlockIdentifier`	block identifier

Returns

Promise<OnlyFirst<BLOCK_WITH_TXS, { status: EBlockStatus } & BLOCK_HEADER & BLOCK_BODY_WITH_TXS & PRE_CONFIRMED_BLOCK_HEADER> | OnlyFirst<PRE_CONFIRMED_BLOCK_WITH_TXS, { status: EBlockStatus } & BLOCK_HEADER & BLOCK_BODY_WITH_TXS & PRE_CONFIRMED_BLOCK_HEADER>>

Block with full transactions

Implementation of

AccountInterface.getBlockWithTxs

Inherited from

Provider.getBlockWithTxs

Defined in

src/provider/rpc.ts:181

waitForBlock

▸ waitForBlock(blockIdentifier?, retryInterval?): Promise<void>

Pause execution until a specified block is created

Parameters

Name	Type	Default value	Description
`blockIdentifier`	`BlockIdentifier`	`BlockTag.LATEST`	block number or tag
`retryInterval`	`number`	`5000`	milliseconds between requests (default: 5000)

Returns

Promise<void>

Example

await provider.waitForBlock(12345);
await provider.waitForBlock('latest');

Implementation of

AccountInterface.waitForBlock

Inherited from

Provider.waitForBlock

Defined in

src/provider/rpc.ts:185

getL1GasPrice

▸ getL1GasPrice(blockIdentifier?): Promise<string>

Gets the price of l1 gas in the block

Parameters

Name	Type	Description
`blockIdentifier?`	`BlockIdentifier`	block identifier

Returns

Promise<string>

gas price of the block

Implementation of

AccountInterface.getL1GasPrice

Inherited from

Provider.getL1GasPrice

Defined in

src/provider/rpc.ts:215

getGasPrices

▸ getGasPrices(blockIdentifier?): Promise<GasPrices>

Get the gas prices related to a block.

Parameters

Name	Type
`blockIdentifier?`	`BlockIdentifier`

Returns

Promise<GasPrices>

an object with l1DataGasPrice, l1GasPrice, l2GasPrice properties (all bigint type).

Example

const result = await myProvider.getGasPrices();
// result = { l1DataGasPrice: 3039n, l1GasPrice: 55590341542890n, l2GasPrice: 8441845008n }

Inherited from

Provider.getGasPrices

Defined in

src/provider/rpc.ts:231

getL1MessageHash

▸ getL1MessageHash(l2TxHash): Promise<string>

Get L1 message hash from L2 transaction hash

Parameters

Name	Type	Description
`l2TxHash`	`BigNumberish`	L2 transaction hash

Returns

Promise<string>

Hex string of L1 message hash

Example

In Sepolia Testnet :

const result = provider.getL1MessageHash(
  '0x28dfc05eb4f261b37ddad451ff22f1d08d4e3c24dc646af0ec69fa20e096819'
);
// result = '0x55b3f8b6e607fffd9b4d843dfe8f9b5c05822cd94fcad8797deb01d77805532a'

Implementation of

AccountInterface.getL1MessageHash

Inherited from

Provider.getL1MessageHash

Defined in

src/provider/rpc.ts:237

getBlockWithReceipts

▸ getBlockWithReceipts(blockIdentifier?): Promise<OnlyFirst<BLOCK_WITH_RECEIPTS, { status: EBlockStatus } & BLOCK_HEADER & BLOCK_BODY_WITH_RECEIPTS & PRE_CONFIRMED_BLOCK_HEADER> | OnlyFirst<PRE_CONFIRMED_BLOCK_WITH_RECEIPTS, { status: EBlockStatus } & BLOCK_HEADER & BLOCK_BODY_WITH_RECEIPTS & PRE_CONFIRMED_BLOCK_HEADER>>

Get block information with transaction receipts

Parameters

Name	Type	Description
`blockIdentifier?`	`BlockIdentifier`	block identifier

Returns

Promise<OnlyFirst<BLOCK_WITH_RECEIPTS, { status: EBlockStatus } & BLOCK_HEADER & BLOCK_BODY_WITH_RECEIPTS & PRE_CONFIRMED_BLOCK_HEADER> | OnlyFirst<PRE_CONFIRMED_BLOCK_WITH_RECEIPTS, { status: EBlockStatus } & BLOCK_HEADER & BLOCK_BODY_WITH_RECEIPTS & PRE_CONFIRMED_BLOCK_HEADER>>

Block with transaction receipts

Implementation of

AccountInterface.getBlockWithReceipts

Inherited from

Provider.getBlockWithReceipts

Defined in

src/provider/rpc.ts:253

getBlockStateUpdate

▸ getBlockStateUpdate(): Promise<{ block_hash: string ; new_root: string ; old_root: string ; state_diff: { storage_diffs: { address: string ; storage_entries: { key: string ; value: string }[] }[] ; deprecated_declared_classes: string[] ; declared_classes: { class_hash: string ; compiled_class_hash: string }[] ; deployed_contracts: { address: string ; class_hash: string }[] ; replaced_classes: { contract_address: string ; class_hash: string }[] ; nonces: { nonce: string ; contract_address: string }[] ; migrated_compiled_classes: undefined | { class_hash: string ; compiled_class_hash: string }[] } }>

Gets the state changes in a specific block (result of executing the requested block) Alternative method name for getStateUpdate with specific overloads

Returns

StateUpdateResponse

Implementation of

Inherited from

Defined in

src/provider/rpc.ts:259

▸ getBlockStateUpdate(blockIdentifier): Promise<{ block_hash: never ; state_diff: { storage_diffs: { address: string ; storage_entries: { key: string ; value: string }[] }[] ; deprecated_declared_classes: string[] ; declared_classes: { class_hash: string ; compiled_class_hash: string }[] ; deployed_contracts: { address: string ; class_hash: string }[] ; replaced_classes: { contract_address: string ; class_hash: string }[] ; nonces: { nonce: string ; contract_address: string }[] ; migrated_compiled_classes: undefined | { class_hash: string ; compiled_class_hash: string }[] } ; old_root: undefined | string }>

Parameters

Name	Type
`blockIdentifier`	`"pre_confirmed"`

Returns

Implementation of

Inherited from

Defined in

src/provider/rpc.ts:260

▸ getBlockStateUpdate(blockIdentifier): Promise<{ block_hash: string ; new_root: string ; old_root: string ; state_diff: { storage_diffs: { address: string ; storage_entries: { key: string ; value: string }[] }[] ; deprecated_declared_classes: string[] ; declared_classes: { class_hash: string ; compiled_class_hash: string }[] ; deployed_contracts: { address: string ; class_hash: string }[] ; replaced_classes: { contract_address: string ; class_hash: string }[] ; nonces: { nonce: string ; contract_address: string }[] ; migrated_compiled_classes: undefined | { class_hash: string ; compiled_class_hash: string }[] } }>

Parameters

Name	Type
`blockIdentifier`	`"latest"`

Returns

Implementation of

Inherited from

Defined in

src/provider/rpc.ts:263

▸ getBlockStateUpdate(blockIdentifier?): Promise<StateUpdateResponse>

Parameters

Name	Type
`blockIdentifier?`	`BlockIdentifier`

Returns

Promise<StateUpdateResponse>

Implementation of

Inherited from

AccountInterface.getBlockTransactionsTraces

Defined in

src/provider/rpc.ts:264

getBlockTransactionsTraces

▸ getBlockTransactionsTraces(blockIdentifier?): Promise<BlockTransactionsTraces | BlockTransactionsTraces>

Get transaction traces for all transactions in a block

Parameters

Name	Type	Description
`blockIdentifier?`	`BlockIdentifier`	block identifier

Returns

Promise<BlockTransactionsTraces | BlockTransactionsTraces>

Array of transaction traces

Implementation of

Inherited from

Provider.getBlockTransactionsTraces

Defined in

src/provider/rpc.ts:269

getBlockTransactionCount

▸ getBlockTransactionCount(blockIdentifier?): Promise<number>

Get the number of transactions in a block

Parameters

Name	Type	Description
`blockIdentifier?`	`BlockIdentifier`	block identifier

Returns

Promise<number>

Transaction count

Implementation of

AccountInterface.getBlockTransactionCount

Inherited from

Provider.getBlockTransactionCount

Defined in

src/provider/rpc.ts:273

getTransaction

▸ getTransaction(txHash): Promise<TXN_WITH_HASH>

Gets the transaction information from a tx id.

Parameters

Name	Type
`txHash`	`BigNumberish`

Returns

Promise<TXN_WITH_HASH>

the transaction object { transaction_id, status, transaction, block_number?, block_number?, transaction_index?, transaction_failure_reason? }

Implementation of

AccountInterface.getTransaction

Inherited from

Provider.getTransaction

Defined in

src/provider/rpc.ts:277

getTransactionByHash

▸ getTransactionByHash(txHash): Promise<TXN_WITH_HASH>

Gets the transaction information from a tx hash (alias for getTransaction)

Parameters

Name	Type	Description
`txHash`	`BigNumberish`	transaction hash

Returns

Promise<TXN_WITH_HASH>

Transaction information

Implementation of

AccountInterface.getTransactionByHash

Inherited from

Provider.getTransactionByHash

Defined in

src/provider/rpc.ts:281

getTransactionByBlockIdAndIndex

▸ getTransactionByBlockIdAndIndex(blockIdentifier, index): Promise<TXN_WITH_HASH>

Gets transaction by block identifier and index

Parameters

Name	Type	Description
`blockIdentifier`	`BlockIdentifier`	block identifier
`index`	`number`	transaction index in the block

Returns

Promise<TXN_WITH_HASH>

Transaction information

Implementation of

AccountInterface.getTransactionByBlockIdAndIndex

Inherited from

Provider.getTransactionByBlockIdAndIndex

Defined in

src/provider/rpc.ts:285

getTransactionReceipt

▸ getTransactionReceipt(txHash): Promise<GetTransactionReceiptResponse>

Gets the transaction receipt from a tx hash.

Parameters

Name	Type
`txHash`	`BigNumberish`

Returns

Promise<GetTransactionReceiptResponse>

the transaction receipt object

Implementation of

AccountInterface.getTransactionReceipt

Inherited from

Provider.getTransactionReceipt

Defined in

src/provider/rpc.ts:289

getTransactionTrace

▸ getTransactionTrace(txHash): Promise<TRANSACTION_TRACE | TRANSACTION_TRACE>

Gets the transaction trace

Parameters

Name	Type	Description
`txHash`	`BigNumberish`	transaction hash

Returns

Promise<TRANSACTION_TRACE | TRANSACTION_TRACE>

Transaction trace

Implementation of

AccountInterface.getTransactionTrace

Inherited from

Provider.getTransactionTrace

Defined in

src/provider/rpc.ts:296

getTransactionStatus

▸ getTransactionStatus(transactionHash): Promise<TXN_STATUS_RESULT>

Get the status of a transaction

Parameters

Name	Type	Description
`transactionHash`	`BigNumberish`	transaction hash

Returns

Promise<TXN_STATUS_RESULT>

Transaction status

Implementation of

AccountInterface.getTransactionStatus

Inherited from

Provider.getTransactionStatus

Defined in

src/provider/rpc.ts:302

getSimulateTransaction

▸ getSimulateTransaction(invocations, options?): Promise<SimulateTransactionOverheadResponse>

Simulates the transaction and returns the transaction trace and estimated fee.

Parameters

Name	Type	Description
`invocations`	`AccountInvocations`	AccountInvocations - Complete invocations array with account details
`options?`	`getSimulateTransactionOptions`	getSimulateTransactionOptions - (optional) blockIdentifier - block identifier - (optional) skipValidate - skip cairo validate method - (optional) skipExecute - skip cairo execute method

Returns

Promise<SimulateTransactionOverheadResponse>

an array of transaction trace and estimated fee

Implementation of

AccountInterface.getSimulateTransaction

Inherited from

Provider.getSimulateTransaction

Defined in

src/provider/rpc.ts:306

waitForTransaction

▸ waitForTransaction(txHash, options?): Promise<GetTransactionReceiptResponse>

Wait for the transaction to be accepted

Parameters

Name	Type	Description
`txHash`	`BigNumberish`	transaction hash
`options?`	`waitForTransactionOptions`	waitForTransactionOptions - (optional) retryInterval: number \| undefined; - (optional) successStates: TransactionStatus[] \| undefined;

Returns

Promise<GetTransactionReceiptResponse>

GetTransactionReceiptResponse

Implementation of

AccountInterface.waitForTransaction

Inherited from

Provider.waitForTransaction

Defined in

src/provider/rpc.ts:316

fastWaitForTransaction

▸ fastWaitForTransaction(txHash, address, initNonce, options?): Promise<boolean>

Wait up until a new transaction is possible with same the account. This method is fast, but Events and transaction report are not yet available. Useful for gaming activity.

only rpc 0.9 and onwards.

Parameters

Name	Type	Description
`txHash`	`BigNumberish`	transaction hash
`address`	`string`	address of the account
`initNonce`	`BigNumberish`	initial nonce of the account (before the transaction).
`options?`	`fastWaitForTransactionOptions`	options to scan the network for the next possible transaction. `retries` is the number of times to retry.

Returns

Promise<boolean>

Returns true if the next transaction is possible, false if the timeout has been reached, throw an error in case of provider communication.

Inherited from

Provider.fastWaitForTransaction

Defined in

src/provider/rpc.ts:341

getStorageAt

▸ getStorageAt(contractAddress, key, blockIdentifier?): Promise<string>

Get the value of the storage (contract's variable) at the given address and key

Parameters

Name	Type	Description
`contractAddress`	`BigNumberish`
`key`	`BigNumberish`	from getStorageVarAddress('<STORAGE_VARIABLE_NAME>') (WIP)
`blockIdentifier?`	`BlockIdentifier`	block identifier

Returns

Promise<string>

the value of the storage variable

Implementation of

AccountInterface.getStorageAt

Inherited from

Provider.getStorageAt

Defined in

src/provider/rpc.ts:356

getClassHashAt

▸ getClassHashAt(contractAddress, blockIdentifier?): Promise<string>

Returns the contract class hash in the given block for the contract deployed at the given address

Parameters

Name	Type	Description
`contractAddress`	`BigNumberish`	contract address
`blockIdentifier?`	`BlockIdentifier`	block identifier

Returns

Promise<string>

Class hash

Implementation of

AccountInterface.getClassHashAt

Inherited from

Provider.getClassHashAt

Defined in

src/provider/rpc.ts:364

getClassByHash

▸ getClassByHash(classHash): Promise<LegacyContractClass | Omit<CompiledSierra, "sierra_program_debug_info">>

Returns the contract class deployed under the given class hash.

Parameters

Name	Type	Description
`classHash`	`BigNumberish`	class hash

Returns

Promise<LegacyContractClass | Omit<CompiledSierra, "sierra_program_debug_info">>

Contract class of compiled contract

Implementation of

AccountInterface.getClassByHash

Inherited from

Provider.getClassByHash

Defined in

src/provider/rpc.ts:368

getClass

▸ getClass(classHash, blockIdentifier?): Promise<LegacyContractClass | Omit<CompiledSierra, "sierra_program_debug_info">>

Get contract class by hash with optional block identifier

Parameters

Name	Type	Description
`classHash`	`BigNumberish`	class hash
`blockIdentifier?`	`BlockIdentifier`	block identifier

Returns

Promise<LegacyContractClass | Omit<CompiledSierra, "sierra_program_debug_info">>

Contract class

Implementation of

AccountInterface.getClass

Inherited from

Provider.getClass

Defined in

src/provider/rpc.ts:372

getClassAt

▸ getClassAt(contractAddress, blockIdentifier?): Promise<LegacyContractClass | Omit<CompiledSierra, "sierra_program_debug_info">>

Gets the contract class of the deployed contract.

Parameters

Name	Type	Description
`contractAddress`	`BigNumberish`	contract address
`blockIdentifier?`	`BlockIdentifier`	block identifier

Returns

Promise<LegacyContractClass | Omit<CompiledSierra, "sierra_program_debug_info">>

Contract class of compiled contract

Implementation of

AccountInterface.getClassAt

Inherited from

Provider.getClassAt

Defined in

src/provider/rpc.ts:378

getContractVersion

▸ getContractVersion(contractAddress, classHash?, options?): Promise<ContractVersion>

Gets the contract version from the provided address

Parameters

Name	Type	Description
`contractAddress`	`BigNumberish`	string
`classHash?`	`undefined`	undefined
`options?`	`getContractVersionOptions`	getContractVersionOptions - (optional) compiler - (default true) extract compiler version using type tactic from abi - (optional) blockIdentifier - block identifier

Returns

Promise<ContractVersion>

Implementation of

AccountInterface.getContractVersion

Inherited from

Provider.getContractVersion

Defined in

src/provider/rpc.ts:384

▸ getContractVersion(contractAddress, classHash, options?): Promise<ContractVersion>

Gets the contract version from the provided address

Parameters

Name	Type	Description
`contractAddress`	`undefined`	undefined
`classHash`	`BigNumberish`
`options?`	`getContractVersionOptions`	getContractVersionOptions - (optional) compiler - (default true) extract compiler version using type tactic from abi - (optional) blockIdentifier - block identifier

Returns

Promise<ContractVersion>

Implementation of

AccountInterface.getContractVersion

Inherited from

Provider.getContractVersion

Defined in

src/provider/rpc.ts:389

getInvokeEstimateFee

▸ getInvokeEstimateFee(invocation, details, blockIdentifier?, skipValidate?): Promise<EstimateFeeResponseOverhead>

Estimates the fee for a given INVOKE transaction

Parameters

Name	Type	Description
`invocation`	`Invocation`	the invocation object containing: - contractAddress - the address of the contract - entrypoint - (optional) the entrypoint of the contract - calldata - (optional, defaults to []) the calldata - signature - (optional, defaults to []) the signature
`details`	`InvocationsDetailsWithNonce`	optional details containing: - nonce - optional nonce - version - optional version
`blockIdentifier?`	`BlockIdentifier`	(optional) block identifier
`skipValidate?`	`boolean`	(optional) skip cairo validate method

Returns

AccountInterface.getInvokeEstimateFee

the estimated fee

Deprecated

Consider using getEstimateFeeBulk for multiple transactions

Example

const feeEstimate = await provider.getInvokeEstimateFee(invocation, details);
// Equivalent to:
const [feeEstimate] = await provider.getEstimateFeeBulk(
  [{ type: ETransactionType.INVOKE, ...invocation, ...details }],
  options
);

Alias

getEstimateFeeBulk - This method is an alias that calls getEstimateFeeBulk with a single transaction

Implementation of

Inherited from

Provider.getInvokeEstimateFee

Defined in

src/provider/rpc.ts:422

getDeclareEstimateFee

▸ getDeclareEstimateFee(invocation, details, blockIdentifier?, skipValidate?): Promise<EstimateFeeResponseOverhead>

Estimates the fee for a given DECLARE transaction

Parameters

Name	Type	Description
`invocation`	`DeclareContractTransaction`	transaction payload to be declared containing: - compiled contract code - sender address - signature - (defaults to []) the signature
`details`	`InvocationsDetailsWithNonce`	optional details containing: - nonce - version - optional version - optional maxFee
`blockIdentifier?`	`BlockIdentifier`	(optional) block identifier
`skipValidate?`	`boolean`	(optional) skip cairo validate method

Returns

AccountInterface.getDeclareEstimateFee

the estimated fee

Deprecated

Consider using getEstimateFeeBulk for multiple transactions

Example

const feeEstimate = await provider.getDeclareEstimateFee(transaction, details);
// Equivalent to:
const [feeEstimate] = await provider.getEstimateFeeBulk(
  [{ type: ETransactionType.DECLARE, ...transaction, ...details }],
  options
);

Alias

getEstimateFeeBulk - This method is an alias that calls getEstimateFeeBulk with a single transaction

Implementation of

Inherited from

Provider.getDeclareEstimateFee

Defined in

src/provider/rpc.ts:436

getDeployAccountEstimateFee

▸ getDeployAccountEstimateFee(invocation, details, blockIdentifier?, skipValidate?): Promise<EstimateFeeResponseOverhead>

Estimates the fee for a given DEPLOY_ACCOUNT transaction

Parameters

Name	Type	Description
`invocation`	`DeployAccountContractTransaction`	transaction payload to be deployed containing: - classHash - constructorCalldata - addressSalt - signature - (defaults to []) the signature
`details`	`InvocationsDetailsWithNonce`	optional details containing: - nonce - version - optional version - optional maxFee
`blockIdentifier?`	`BlockIdentifier`	(optional) block identifier
`skipValidate?`	`boolean`	(optional) skip cairo validate method

Returns