Interface PrepareUserOperationOptions

Type declaration

• __experimental_useNetwork: (
      network: string,
  ) => Promise<
      {
          address: `0x${string}`;
          name?: string;
          network: string;
          owners: EvmAccount[];
          type: "evm-smart";
      },
  >

  Subject to breaking changes. A function that returns a network-scoped smart account.

• address: `0x${string}`

  The smart account's address.

• fund: (options: Omit<FundOptions, "address">) => Promise<FundOperationResult>

  Funds an EVM account with the specified token amount.

  Example

  const fundOperation = await account.fund({
    network: "base",
    token: "usdc",
    amount: 1000000n,
  });
  Copy

• getUserOperation: (
      options: Omit<GetUserOperationOptions, "smartAccount">,
  ) => Promise<UserOperation>

  Gets a user operation by its hash.

  Example

  const userOp = await smartAccount.getUserOperation({
    userOpHash: "0x1234567890123456789012345678901234567890",
  });
  Copy

• listTokenBalances: (
      options: Omit<ListTokenBalancesOptions, "address">,
  ) => Promise<ListTokenBalancesResult>

  List the token balances of an account.

  Example

  const balances = await account.listTokenBalances({
    network: "base-sepolia",
  });
  Copy

• Optionalname?: string

  The name of the smart account.

• owners: EvmAccount[]

  Array of accounts that own and can sign for the smart account (currently only supports one owner but will be extended to support multiple owners in the future).

• quoteFund: (options: Omit<QuoteFundOptions, "address">) => Promise<Quote>

  Gets a quote to fund an EVM account.

  Example

  const quote = await account.quoteFund({
    network: "base",
    token: "usdc",
    amount: 1000000n,
  });
  Copy

• quoteSwap: (options: SmartAccountQuoteSwapOptions) => Promise<SmartAccountQuoteSwapResult>

  Creates a swap quote without executing the transaction. This is useful when you need to get swap details before executing the swap. The taker is automatically set to the smart account's address.

  Example

  const swapQuote = await smartAccount.quoteSwap({
    network: "base",
    fromToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
    toToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
    fromAmount: BigInt("1000000000000000000"), // 1 WETH in wei
  });
  
  if (swapQuote.liquidityAvailable) {
    console.log(`Can swap for ${swapQuote.toAmount} USDC`);
  }
  Copy

• requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<RequestFaucetResult>

  Requests funds from an EVM faucet.

  Example

  const result = await account.requestFaucet({
    network: "base-sepolia",
    token: "eth",
  });
  Copy

• sendUserOperation: (
      options: Omit<SendUserOperationOptions<unknown[]>, "smartAccount">,
  ) => Promise<SendUserOperationReturnType>

  Sends a user operation.

  Example

  const userOp = await smartAccount.sendUserOperation({
    network: "base-sepolia",
    calls: [
      {
        to: "0x1234567890123456789012345678901234567890",
        value: parseEther("0.000001"),
        data: "0x",
      },
    ],
  });
  Copy

• swap: (options: SmartAccountSwapOptions) => Promise<SmartAccountSwapResult>

  Executes a token swap on the specified network via a user operation. This method handles all the steps required for a swap, including Permit2 signatures if needed. The taker is automatically set to the smart account's address.

  Throws

  If liquidity is not available when using inline options.

  Example: **Using a pre-created swap quote**

  // First create a swap quote
  const swapQuote = await cdp.evm.createSwapQuote({
    network: "base",
    toToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
    fromToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
    fromAmount: BigInt("1000000000000000000"), // 1 WETH in wei
    taker: smartAccount.address,
    signerAddress: smartAccount.owners[0].address
  });
  
  // Check if liquidity is available
  if (!swapQuote.liquidityAvailable) {
    console.error("Insufficient liquidity for swap");
    return;
  }
  
  // Execute the swap
  const { userOpHash } = await smartAccount.swap({
    swapQuote: swapQuote
  });
  
  console.log(`Swap executed with user op hash: ${userOpHash}`);
  Copy

  Example: **Using inline options (all-in-one)**

  // Create and execute swap in one call
  const { userOpHash } = await smartAccount.swap({
    network: "base",
    toToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
    fromToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
    fromAmount: BigInt("1000000000000000000"), // 1 WETH in wei
  });
  
  console.log(`Swap executed with user op hash: ${userOpHash}`);
  Copy

• transfer: (options: TransferOptions) => Promise<SendUserOperationReturnType>

  Transfer an amount of a token from an account to another account.

  Example

  const { userOpHash } = await sender.transfer({
    to: "0x9F663335Cd6Ad02a37B633602E98866CF944124d",
    amount: 10000n, // equivalent to 0.01 USDC
    token: "usdc",
    network: "base-sepolia",
  });
  Copy

  Example

  Using parseUnits to specify USDC amount

  import { parseUnits } from "viem";
  
  const { userOpHash } = await sender.transfer({
    to: "0x9F663335Cd6Ad02a37B633602E98866CF944124d",
    amount: parseUnits("0.01", 6), // USDC uses 6 decimal places
    token: "usdc",
    network: "base-sepolia",
  });
  Copy

  Example

  Transfer ETH

  import { parseEther } from "viem";
  
  const { userOpHash } = await sender.transfer({
    to: "0x9F663335Cd6Ad02a37B633602E98866CF944124d",
    amount: parseEther("0.000001"),
    token: "eth",
    network: "base-sepolia",
  });
  Copy

  Example

  Using a contract address

  import { parseEther } from "viem";
  
  const { userOpHash } = await sender.transfer({
    to: "0x9F663335Cd6Ad02a37B633602E98866CF944124d",
    amount: parseEther("0.000001"),
    token: "0x4200000000000000000000000000000000000006", // WETH on Base Sepolia
    network: "base-sepolia",
  });
  Copy

  Example

  Transfer to another account

  const sender = await cdp.evm.createAccount({ name: "Sender" });
  const receiver = await cdp.evm.createAccount({ name: "Receiver" });
  
  const { userOpHash } = await sender.transfer({
    to: receiver,
    amount: 10000n, // equivalent to 0.01 USDC
    token: "usdc",
    network: "base-sepolia",
  });
  Copy

• type: "evm-smart"

  Identifier for the smart account type.

• waitForUserOperation: (
      options: Omit<WaitForUserOperationOptions, "smartAccountAddress">,
  ) => Promise<WaitForUserOperationReturnType>

  Waits for a user operation to complete or fail.

  Example

  // Send a user operation and get the user operation hash
  const { userOpHash } = await smartAccount.sendUserOperation({
    network: "base-sepolia",
    calls: [
      {
        to: "0x0000000000000000000000000000000000000000",
        value: parseEther("0.000001"),
        data: "0x",
      },
    ],
  });
  
  // Wait for the user operation to complete or fail
  const result = await smartAccount.waitForUserOperation({
    userOpHash: userOp.userOpHash,
  });
  Copy

• waitForFundOperationReceipt:function

  • waitForFundOperationReceipt(
        options: WaitForFundOperationOptions,
    ): Promise<WaitForFundOperationResult>

    Waits for a fund operation to complete and returns the transfer receipt.

    Parameters

    • options: WaitForFundOperationOptions

      The options for the wait for fund operation.

      • transferId: string

        The ID of the transfer to wait for.

      • OptionalwaitOptions?: WaitOptions

        Optional options for the wait operation.

    Returns Promise<WaitForFundOperationResult>

    A promise that resolves to the completed transfer receipt containing details about the funding operation.

    Example

    const completedTransfer = await account.waitForFundOperationReceipt({
      transferId: "transfer_123",
    });
    Copy