Type Alias SmartAccountActions<TChain, TSmartAccount>

SmartAccountActions: {
    debugUserOperation: (
        params: DebugUserOperationParameters,
    ) => Promise<DebugUserOperationReturnType>;
    prepareTokenPaymasterUserOp: (
        args: PrepareTokenPaymasterUserOpParameters,
    ) => Promise<Omit<UserOperation, "signature">>;
    prepareUserOperation: (
        params: PrepareUserOperationParameters,
    ) => Promise<ReturnType<typeof prepareUserOperationWithoutSignature>>;
    sendTokenPaymasterUserOp: (
        args: SendTokenPaymasterUserOpParameters,
    ) => Promise<Hash>;
    sendTransaction: <
        TChainOverride extends Chain
        | undefined = undefined,
        accountOverride extends SmartAccount | undefined = undefined,
        calls extends readonly unknown[] = readonly unknown[],
    >(
        args: Parameters<typeof sendTransaction>[1],
    ) => Promise<Hash>;
    signMessage: (
        args: Parameters<typeof signMessage>[1],
    ) => ReturnType<typeof signMessage>;
    signTypedData: <
        const TTypedData extends TypedData
        | { [key: string]: unknown },
        TPrimaryType extends string,
    >(
        args: Parameters<typeof signTypedData>[1],
    ) => ReturnType<typeof signTypedData>;
    upgradeSmartAccount: (
        args?: UpgradeSmartAccountParameters<TSmartAccount>,
    ) => Promise<Hash>;
    waitForTransactionReceipt: (
        params: WaitForTransactionReceiptParameters,
    ) => Promise<WaitForTransactionReceiptReturnType>;
    writeContract: <
        const TAbi extends Abi
        | readonly unknown[],
        TFunctionName extends
            ContractFunctionName<TAbi, "nonpayable" | "payable"> = ContractFunctionName<
            TAbi,
            "nonpayable"
            | "payable",
        >,
        TArgs extends
            ContractFunctionArgs<TAbi, "nonpayable" | "payable", TFunctionName> = ContractFunctionArgs<
            TAbi,
            "nonpayable"
            | "payable",
            TFunctionName,
        >,
        TChainOverride extends Chain
        | undefined = undefined,
    >(
        args: WriteContractParameters<
            TAbi,
            TFunctionName,
            TArgs,
            TChain,
            TSmartAccount,
            TChainOverride,
        >,
    ) => ReturnType<typeof writeContract>;
}

Type Parameters

  • TChain extends Chain | undefined = Chain | undefined
  • TSmartAccount extends SmartAccount | undefined = SmartAccount | undefined

Type declaration

  • debugUserOperation: (params: DebugUserOperationParameters) => Promise<DebugUserOperationReturnType>

    Sends a user operation to the network and waits for the receipt.

  • prepareTokenPaymasterUserOp: (
        args: PrepareTokenPaymasterUserOpParameters,
    ) => Promise<Omit<UserOperation, "signature">>

    Prepares a user operation with token paymaster configuration, including ERC20 token approval

    This function handles:

    1. Checking current token allowance of Smart Account
    2. Creating an approval transaction for the token paymaster if needed
    3. Preparing the user operation with the approval and user transactions

    Example

    const userOp = await prepareTokenPaymasterUserOp(nexusClient, {
       txs: [
         {
           to: recipientAddress,
           value: 1n,
           data: "0x"
         }
       ],
       feeTokenAddress: baseSepoliaUSDCAddress,
       customApprovalAmount: usdcFeeAmount
     })

    Throws

    Will throw an error if client account or paymaster context is not properly configured

  • prepareUserOperation: (
        params: PrepareUserOperationParameters,
    ) => Promise<ReturnType<typeof prepareUserOperationWithoutSignature>>

    Prepares a user operation

    Example

    const userOp = await prepareUserOperation({
      calls: [{to: '0x...', value: 1n, data: '0x...'}]
    })
  • sendTokenPaymasterUserOp: (args: SendTokenPaymasterUserOpParameters) => Promise<Hash>

    Prepares and sends a user operation with token paymaster

    Example

    const hash = await sendTokenPaymasterUserOp(client, {
      calls: [{
        to: "0x...", // Contract address
        data: "0x...", // Encoded function data
        value: BigInt(0)
      }],
      feeTokenAddress: "0x...", // USDC/USDT/etc address
      customApprovalAmount: BigInt(1000) // Optional: specific approval amount
    })
  • sendTransaction: <
        TChainOverride extends Chain
        | undefined = undefined,
        accountOverride extends SmartAccount | undefined = undefined,
        calls extends readonly unknown[] = readonly unknown[],
    >(
        args: Parameters<typeof sendTransaction>[1],
    ) => Promise<Hash>

    Creates, signs, and sends a new transaction to the network using a smart account. This function also allows you to sponsor this transaction if the sender is a smart account.

    Throws

    If the account is not found.

    Example

    import { sendTransaction } from '@biconomy/abstractjs'

    const hash = await nexusClient.sendTransaction({calls: [{to: '0x...', value: parseEther('0.1'), data: '0x...'}]})
    console.log(hash) // '0x...'
  • signMessage: (args: Parameters<typeof signMessage>[1]) => ReturnType<typeof signMessage>

    Calculates an Ethereum-specific signature in EIP-191 format: keccak256("\x19Ethereum Signed Message:\n" + len(message) + message)).

    With the calculated signature, you can:

    Example

    import { createWalletClient, custom } from 'viem'
    import { mainnet } from 'viem/chains'

    const client = createWalletClient({
      chain: mainnet,
      transport: custom(window.ethereum),
    })
    const signature = await client.signMessage({
      account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
      message: 'hello world',
    })

    Example

    // Account Hoisting
    import { createWalletClient, http } from 'viem'
    import { privateKeyToAccount } from 'viem/accounts'
    import { mainnet } from 'viem/chains'

    const client = createWalletClient({
      account: privateKeyToAccount('0x…'),
      chain: mainnet,
      transport: http(),
    })
    const signature = await client.signMessage({
      message: 'hello world',
    })
  • signTypedData: <
        const TTypedData extends TypedData
        | { [key: string]: unknown },
        TPrimaryType extends string,
    >(
        args: Parameters<typeof signTypedData>[1],
    ) => ReturnType<typeof signTypedData>

    Signs typed data and calculates an Ethereum-specific signature in EIP-191 format: keccak256("\x19Ethereum Signed Message:\n" + len(message) + message)).

    Example

    import { createWalletClient, custom } from 'viem'
    import { mainnet } from 'viem/chains'

    const client = createWalletClient({
      chain: mainnet,
      transport: custom(window.ethereum),
    })
    const signature = await client.signTypedData({
      account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
      domain: {
        name: 'Ether Mail',
        version: '1',
        chainId: 1,
        verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
      },
      types: {
        Person: [
          { name: 'name', type: 'string' },
          { name: 'wallet', type: 'address' },
        ],
        Mail: [
          { name: 'from', type: 'Person' },
          { name: 'to', type: 'Person' },
          { name: 'contents', type: 'string' },
        ],
      },
      primaryType: 'Mail',
      message: {
        from: {
          name: 'Cow',
          wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
        },
        to: {
          name: 'Bob',
          wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
        },
        contents: 'Hello, Bob!',
      },
    })

    Example

    // Account Hoisting
    import { createWalletClient, http } from 'viem'
    import { privateKeyToAccount } from 'viem/accounts'
    import { mainnet } from 'viem/chains'

    const client = createWalletClient({
      account: privateKeyToAccount('0x…'),
      chain: mainnet,
      transport: http(),
    })
    const signature = await client.signTypedData({
      domain: {
        name: 'Ether Mail',
        version: '1',
        chainId: 1,
        verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
      },
      types: {
        Person: [
          { name: 'name', type: 'string' },
          { name: 'wallet', type: 'address' },
        ],
        Mail: [
          { name: 'from', type: 'Person' },
          { name: 'to', type: 'Person' },
          { name: 'contents', type: 'string' },
        ],
      },
      primaryType: 'Mail',
      message: {
        from: {
          name: 'Cow',
          wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
        },
        to: {
          name: 'Bob',
          wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
        },
        contents: 'Hello, Bob!',
      },
    })
  • upgradeSmartAccount: (args?: UpgradeSmartAccountParameters<TSmartAccount>) => Promise<Hash>

    Upgrades a smart account to a new implementation.

    Example

    const hash = await client.upgradeSmartAccount()
    console.log(hash) // '0x...'
  • waitForTransactionReceipt: (
        params: WaitForTransactionReceiptParameters,
    ) => Promise<WaitForTransactionReceiptReturnType>
  • writeContract: <
        const TAbi extends Abi
        | readonly unknown[],
        TFunctionName extends
            ContractFunctionName<TAbi, "nonpayable" | "payable"> = ContractFunctionName<
            TAbi,
            "nonpayable"
            | "payable",
        >,
        TArgs extends
            ContractFunctionArgs<TAbi, "nonpayable" | "payable", TFunctionName> = ContractFunctionArgs<
            TAbi,
            "nonpayable"
            | "payable",
            TFunctionName,
        >,
        TChainOverride extends Chain
        | undefined = undefined,
    >(
        args: WriteContractParameters<
            TAbi,
            TFunctionName,
            TArgs,
            TChain,
            TSmartAccount,
            TChainOverride,
        >,
    ) => ReturnType<typeof writeContract>

    Executes a write function on a contract. This function also allows you to sponsor this transaction if sender is a smartAccount

    A "write" function on a Solidity contract modifies the state of the blockchain. These types of functions require gas to be executed, and hence a Transaction is needed to be broadcast in order to change the state.

    Internally, uses a Wallet Client to call the sendTransaction action with ABI-encoded data.

    Warning: The write internally sends a transaction – it does not validate if the contract write will succeed (the contract may throw an error). It is highly recommended to simulate the contract write with contract.simulate before you execute it.

    Example

    import { createWalletClient, custom, parseAbi } from 'viem'
    import { mainnet } from 'viem/chains'

    const client = createWalletClient({
      chain: mainnet,
      transport: custom(window.ethereum),
    })
    const hash = await client.writeContract({
      address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
      abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
      functionName: 'mint',
      args: [69420],
    })

    Example

    // With Validation
    import { createWalletClient, custom, parseAbi } from 'viem'
    import { mainnet } from 'viem/chains'

    const client = createWalletClient({
      chain: mainnet,
      transport: custom(window.ethereum),
    })
    const { request } = await client.simulateContract({
      address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
      abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
      functionName: 'mint',
      args: [69420],
    }
    const hash = await client.writeContract(request)

Settings

Member Visibility