Class TokenBoundSmartWallet

Optional connector

type

walletId

addAdmin

• addAdmin(adminAddress): Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

• Add another admin to the smart wallet.

  Parameters

  • adminAddress: string

    the address of the admin to add.

  Returns Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

autoConnect

• autoConnect(params): Promise<string>

• tries to auto connect to the wallet

  Parameters

  • params: ConnectParams<SmartWalletConnectionArgs>

  Returns Promise<string>

connect

• connect(connectOptions?): Promise<string>

• connect to the wallet

  Parameters

  • Optional connectOptions: ConnectParams<SmartWalletConnectionArgs>

  Returns Promise<string>

createSessionKey

• createSessionKey(keyAddress, permissions): Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

• Create and add a session key to the smart wallet.

  Parameters

  • keyAddress: string

    the address of the session key to add.

  • permissions: {
        approvedCallTargets: Object;
        expirationDate?: number | Date;
        nativeTokenLimitPerTransaction?: string | number;
        startDate?: number | Date;
    }

    the permissions to grant to the session key.

    • approvedCallTargets: Object

    • Optional expirationDate?: number | Date

    • Optional nativeTokenLimitPerTransaction?: string | number

    • Optional startDate?: number | Date

  Returns Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

deploy

• deploy(): Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

• Manually deploy the smart wallet contract. If already deployed this will throw an error. Note that this is not necessary as the smart wallet will be deployed automatically on the first transaction the user makes.

  Returns Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

  the transaction receipt

deployIfNeeded

• deployIfNeeded(): Promise<void>

• Manually deploy the smart wallet contract. If already deployed this will do nothing. Note that this is not necessary as the smart wallet will be deployed automatically on the first transaction the user makes.

  Returns Promise<void>

  the transaction receipt

disconnect

• disconnect(): Promise<void>

• Returns Promise<void>

estimate

• estimate(transaction): Promise<{
      details: {
          deployCost: BigNumber;
          deployGasLimit: BigNumber;
          gasPrice: BigNumber;
          totalCost: BigNumber;
          transactionCost: BigNumber;
          transactionGasLimit: BigNumber;
      };
      ether: string;
      wei: BigNumber;
  }>

• Estimate the gas cost of a single transaction

  Parameters

  • transaction: Transaction<any>

    the transaction to estimate

  Returns Promise<{
      details: {
          deployCost: BigNumber;
          deployGasLimit: BigNumber;
          gasPrice: BigNumber;
          totalCost: BigNumber;
          transactionCost: BigNumber;
          transactionGasLimit: BigNumber;
      };
      ether: string;
      wei: BigNumber;
  }>

estimateBatch

• estimateBatch(transactions): Promise<{
      details: {
          deployCost: BigNumber;
          deployGasLimit: BigNumber;
          gasPrice: BigNumber;
          totalCost: BigNumber;
          transactionCost: BigNumber;
          transactionGasLimit: BigNumber;
      };
      ether: string;
      wei: BigNumber;
  }>

• Estimate the gas cost of a batch of transactions

  Parameters

  • transactions: Transaction<any>[]

    the transactions to estimate

  Returns Promise<{
      details: {
          deployCost: BigNumber;
          deployGasLimit: BigNumber;
          gasPrice: BigNumber;
          totalCost: BigNumber;
          transactionCost: BigNumber;
          transactionGasLimit: BigNumber;
      };
      ether: string;
      wei: BigNumber;
  }>

estimateBatchRaw

• estimateBatchRaw(transactions): Promise<{
      details: {
          deployCost: BigNumber;
          deployGasLimit: BigNumber;
          gasPrice: BigNumber;
          totalCost: BigNumber;
          transactionCost: BigNumber;
          transactionGasLimit: BigNumber;
      };
      ether: string;
      wei: BigNumber;
  }>

• Estimate the gas cost of a batch of raw transactions

  Parameters

  • transactions: Deferrable<TransactionRequest>[]

    the transactions to estimate

  Returns Promise<{
      details: {
          deployCost: BigNumber;
          deployGasLimit: BigNumber;
          gasPrice: BigNumber;
          totalCost: BigNumber;
          transactionCost: BigNumber;
          transactionGasLimit: BigNumber;
      };
      ether: string;
      wei: BigNumber;
  }>

estimateRaw

• estimateRaw(transactions): Promise<{
      details: {
          deployCost: BigNumber;
          deployGasLimit: BigNumber;
          gasPrice: BigNumber;
          totalCost: BigNumber;
          transactionCost: BigNumber;
          transactionGasLimit: BigNumber;
      };
      ether: string;
      wei: BigNumber;
  }>

• Estimate the gas cost of a single raw transaction

  Parameters

  • transactions: Deferrable<TransactionRequest>

    the transactions to estimate

  Returns Promise<{
      details: {
          deployCost: BigNumber;
          deployGasLimit: BigNumber;
          gasPrice: BigNumber;
          totalCost: BigNumber;
          transactionCost: BigNumber;
          transactionGasLimit: BigNumber;
      };
      ether: string;
      wei: BigNumber;
  }>

execute

• execute(transaction): Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

• Execute a single transaction and wait for confirmations

  Parameters

  • transaction: Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>

    the transaction to execute

  Returns Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

  the transaction receipt

executeBatch

• executeBatch(transactions): Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

• Execute multiple transactions in a single batch and wait for confirmations

  Parameters

  • transactions: Transaction<any>[]

    the transactions to execute

  Returns Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

  the transaction receipt

executeBatchRaw

• executeBatchRaw(transactions): Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

• Execute multiple raw transactions in a single batch and wait for confirmations

  Parameters

  • transactions: Deferrable<TransactionRequest>[]

    the transactions to execute

  Returns Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

  the transaction receipt

executeRaw

• executeRaw(transaction): Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

• Execute a single raw transaction and wait for confirmations

  Parameters

  • transaction: Deferrable<TransactionRequest>

    the transaction to execute

  Returns Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

  the transaction receipt

getAccountContract

• getAccountContract(): Promise<SmartContract<BaseContract>>

• Get the underlying account contract of the smart wallet.

  Returns Promise<SmartContract<BaseContract>>

  the account contract of the smart wallet.

getAddress

• getAddress(): Promise<string>

• Returns Promise<string>

  the account address from connected wallet

getAllActiveSigners

• getAllActiveSigners(): Promise<SignerWithPermissions[]>

• Get all the admins and session keys active on the smart wallet.

  Returns Promise<SignerWithPermissions[]>

getBalance

• getBalance(currencyAddress?): Promise<{
      decimals: number;
      displayValue: string;
      name: string;
      symbol: string;
      value: BigNumber;
  }>

• Parameters

  • currencyAddress: string = NATIVE_TOKEN_ADDRESS

  Returns Promise<{
      decimals: number;
      displayValue: string;
      name: string;
      symbol: string;
      value: BigNumber;
  }>

  the native token balance of the connected wallet

getChainId

• getChainId(): Promise<number>

• Returns Promise<number>

  the chain id from connected wallet

getConnectParams

• getConnectParams(): undefined | ConnectParams<SmartWalletConnectionArgs>

• Returns undefined | ConnectParams<SmartWalletConnectionArgs>

getFactoryContract

• getFactoryContract(): Promise<SmartContract<BaseContract>>

• Get the underlying account factory contract of the smart wallet.

  Returns Promise<SmartContract<BaseContract>>

  the account factory contract.

getMeta

• getMeta(): WalletMeta

• Returns WalletMeta

getOptions

• getOptions(): undefined | WalletOptions<SmartWalletConfig>

• Returns undefined | WalletOptions<SmartWalletConfig>

getPersonalWallet

• getPersonalWallet(): undefined | EVMWallet

• If the wallet uses a personal wallet under the hood, return it

  Returns undefined | EVMWallet

getSigner

• getSigner(): Promise<Signer>

• Returns Promise<Signer>

hasPermissionToExecute

• hasPermissionToExecute(transaction): Promise<boolean>

• Check whether the connected signer can execute a given transaction using the smart wallet.

  Parameters

  • transaction: Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>

    the transaction to execute using the smart wallet.

  Returns Promise<boolean>

  whether the connected signer can execute the transaction using the smart wallet.

isDeployed

• isDeployed(): Promise<boolean>

• Check if the smart wallet contract is deployed

  Returns Promise<boolean>

  true if the smart wallet contract is deployed

removeAdmin

• removeAdmin(adminAddress): Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

• Remove an admin from the smart wallet.

  Parameters

  • adminAddress: string

    the address of the admin to remove.

  Returns Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

revokeSessionKey

• revokeSessionKey(keyAddress): Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

• Remove a session key from the smart wallet.

  Parameters

  • keyAddress: string

    the address of the session key to remove.

  Returns Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

send

• send(transaction): Promise<TransactionResponse>

• Send a single transaction without waiting for confirmations

  Parameters

  • transaction: Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>

    the transaction to send

  Returns Promise<TransactionResponse>

  the transaction result

sendBatch

• sendBatch(transactions): Promise<TransactionResponse>

• Send a multiple transaction in a batch without waiting for confirmations

  Parameters

  • transactions: Transaction<Omit<TransactionResultWithMetadata<unknown>, "data">>[]

    the transactions to send

  Returns Promise<TransactionResponse>

  the transaction result

sendBatchRaw

• sendBatchRaw(transactions): Promise<TransactionResponse>

• Send multiple raw transaction in a batch without waiting for confirmations

  Parameters

  • transactions: Deferrable<TransactionRequest>[]

    the transactions to send

  Returns Promise<TransactionResponse>

  the transaction result

sendRaw

• sendRaw(transaction): Promise<TransactionResponse>

• Send a single raw transaction without waiting for confirmations

  Parameters

  • transaction: Deferrable<TransactionRequest>

    the transaction to send

  Returns Promise<TransactionResponse>

  the transaction result

signMessage

• signMessage(message): Promise<string>

• Parameters

  • message: string | Bytes

  Returns Promise<string>

  the signature of the message

switchChain

• switchChain(chainId): Promise<void>

• Parameters

  • chainId: number

  Returns Promise<void>

transfer

• transfer(to, amount, currencyAddress?): Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

• Parameters

  • to: string

  • amount: string | number

  • currencyAddress: string = NATIVE_TOKEN_ADDRESS

  Returns Promise<Omit<TransactionResultWithMetadata<unknown>, "data">>

updateChains

• updateChains(chains): Promise<void>

• Parameters

  • chains: Chain[]

  Returns Promise<void>

verifySignature

• verifySignature(message, signature, address, chainId?): Promise<boolean>

• verify the signature of a message

  Parameters

  • message: string

  • signature: string

  • address: string

  • Optional chainId: number

  Returns Promise<boolean>

  true if the signature is valid, false otherwise