Class SmartWallet

constructor

• new SmartWallet(options): SmartWallet

• Parameters

  • options: WalletOptions<SmartWalletConfig>

  Returns SmartWallet

Optional connector

Static id

Static meta

walletName

• get walletName(): string

• Returns string

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>

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

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.

getAllActiveSigners

• getAllActiveSigners(): Promise<SignerWithPermissions[]>

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

  Returns Promise<SignerWithPermissions[]>

getConnector

• getConnector(): Promise<SmartWalletConnector>

• Returns Promise<SmartWalletConnector>

getFactoryContract

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

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

  Returns Promise<SmartContract<BaseContract>>

  the account factory contract.

getPersonalWallet

• getPersonalWallet(): undefined | EVMWallet

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

  Returns undefined | EVMWallet

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