Skip to main content
Version: Next

Class: Account

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

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​

Extended by​

Implements​

Constructors​

Constructor​

new Account(options): Account

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

Parameters​

options​

AccountOptions

Returns​

Account

Properties​

provider​

provider: RpcProvider

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

Provider instance for blockchain interaction

Implementation of​

AccountInterface.provider

signer​

signer: SignerInterface

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

Signer instance for signing transactions and messages

Implementation of​

AccountInterface.signer

address​

address: string

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

The address of the account contract on Starknet

Implementation of​

AccountInterface.address

cairoVersion​

cairoVersion: CairoVersion

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

Cairo version of the account contract implementation

Implementation of​

AccountInterface.cairoVersion

transactionVersion​

readonly transactionVersion: "0x3"

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

paymaster​

paymaster: PaymasterInterface

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

deployer​

deployer: Deployer

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

Optional deployer instance for custom contract deployment logic

Default​

Uses default UDC (Universal Deployer Contract) if not specified

Implementation of​

AccountInterface.deployer

defaultTipType​

defaultTipType: TipType

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

accountPluginManager​

readonly accountPluginManager: PluginManager

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

Internal

Account-level plugin management

deploySelf​

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

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

Execute one or multiple calls through the account contract

Parameters​

contractPayload​

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>

Transaction hash and response

Example​

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

Methods​

getNonce()​

getNonce(blockIdentifier?): Promise<string>

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

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

Implementation of​

AccountInterface.getNonce

getNonceSafe()​

protected getNonceSafe(nonce?): Promise<bigint>

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

Parameters​

nonce?​

BigNumberish

Returns​

Promise<bigint>

getCairoVersion()​

getCairoVersion(classHash?): Promise<CairoVersion>

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

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>

estimateInvokeFee()​

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

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

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

Implementation of​

AccountInterface.estimateInvokeFee

estimateDeclareFee()​

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

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

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

Implementation of​

AccountInterface.estimateDeclareFee

estimateAccountDeployFee()​

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

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

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

Implementation of​

AccountInterface.estimateAccountDeployFee

estimateDeployFee()​

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

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

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

Implementation of​

AccountInterface.estimateDeployFee

estimateFeeBulk()​

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

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

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

Implementation of​

AccountInterface.estimateFeeBulk

simulateTransaction()​

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

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

Parameters​

invocations​

Invocations

details?​

SimulateTransactionDetails = {}

Returns​

Promise<SimulateTransactionOverheadResponse>

execute()​

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

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

Execute one or multiple calls through the account contract

Parameters​

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

getSignedTransaction()​

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

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

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

declareIfNot()​

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

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

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

Implementation of​

AccountInterface.declareIfNot

declare()​

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

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

Execute one or multiple calls through the account contract

Parameters​

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

Transaction hash and response

Example​

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

Implementation of​

AccountInterface.declare

deploy()​

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

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

Execute one or multiple calls through the account contract

Parameters​

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>

Transaction hash and response

Example​

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

Implementation of​

AccountInterface.deploy

deployContract()​

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

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

Execute one or multiple calls through the account contract

Parameters​

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>

Transaction hash and response

Example​

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

Implementation of​

AccountInterface.deployContract

declareAndDeploy()​

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

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

Execute one or multiple calls through the account contract

Parameters​

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>

Transaction hash and response

Example​

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

Implementation of​

AccountInterface.declareAndDeploy

deployAccount()​

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

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

Execute one or multiple calls through the account contract

Parameters​

contractPayload​

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>

Transaction hash and response

Example​

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

Implementation of​

AccountInterface.deployAccount

signMessage()​

signMessage(typedData): Promise<Signature>

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

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

Implementation of​

AccountInterface.signMessage

hashMessage()​

hashMessage(typedData): Promise<string>

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

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

Implementation of​

AccountInterface.hashMessage

getSnip9Version()​

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

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

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"

isValidSnip9Nonce()​

isValidSnip9Nonce(nonce): Promise<boolean>

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

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

getSnip9Nonce()​

getSnip9Nonce(): Promise<string>

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

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"

getOutsideTransaction()​

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

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

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'
// }

executeFromOutside()​

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

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

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...`}

buildInvocation()​

buildInvocation(call, details): Promise<Invocation>

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

Parameters​

call​

Call[]

details​

InvocationsSignerDetails

Returns​

Promise<Invocation>

buildDeclarePayload()​

buildDeclarePayload(payload, details): Promise<DeclareContractTransaction>

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

Parameters​

payload​

DeclareContractPayload

details​

InvocationsSignerDetails

Returns​

Promise<DeclareContractTransaction>

buildAccountDeployPayload()​

buildAccountDeployPayload(__namedParameters, details): Promise<DeployAccountContractTransaction>

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

Parameters​

__namedParameters​

DeployAccountContractPayload

details​

InvocationsSignerDetails

Returns​

Promise<DeployAccountContractTransaction>

buildPaymasterTransaction()​

buildPaymasterTransaction(calls, paymasterDetails): Promise<PreparedTransaction>

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

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

Implementation of​

AccountInterface.buildPaymasterTransaction

estimatePaymasterTransactionFee()​

estimatePaymasterTransactionFee(calls, paymasterDetails): Promise<PaymasterFeeEstimate>

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

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

Implementation of​

AccountInterface.estimatePaymasterTransactionFee

preparePaymasterTransaction()​

preparePaymasterTransaction(preparedTransaction): Promise<ExecutableUserTransaction>

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

Parameters​

preparedTransaction​

PreparedTransaction

Returns​

Promise<ExecutableUserTransaction>

executePaymasterTransaction()​

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

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

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

Implementation of​

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

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

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

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

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

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

BrotherIdProviderMethods.getBrotherProfile