Skip to main content

​
Interfaces

​
CreateEvmEip7702DelegationOptions

Defined in: client/evm/evm.types.ts:515 Options for creating an EIP-7702 delegation for an EVM EOA account.

​
Properties

address
address: `0x${string}`;
Defined in: client/evm/evm.types.ts:517 The address of the EOA account.
enableSpendPermissions?
optional enableSpendPermissions: boolean;
Defined in: client/evm/evm.types.ts:521 Whether to configure spend permissions for the upgraded, delegated account. When enabled, the account can grant permissions for third parties to spend on its behalf. Defaults to false.
idempotencyKey?
optional idempotencyKey: string;
Defined in: client/evm/evm.types.ts:523 Optional idempotency key.
network
network: EvmEip7702DelegationNetwork;
Defined in: client/evm/evm.types.ts:519 The network for the EIP-7702 delegation.

​
CreateServerAccountOptions

Defined in: client/evm/evm.types.ts:388 Options for creating an EVM server account.

​
Properties

accountPolicy?
optional accountPolicy: string;
Defined in: client/evm/evm.types.ts:392 The policy ID to apply to the account.
idempotencyKey?
optional idempotencyKey: string;
Defined in: client/evm/evm.types.ts:394 The idempotency key.
name?
optional name: string;
Defined in: client/evm/evm.types.ts:390 The name of the account.

​
CreateSmartAccountOptions

Defined in: client/evm/evm.types.ts:577 Options for creating an EVM smart account.

​
Properties

enableSpendPermissions?
optional enableSpendPermissions: boolean;
Defined in: client/evm/evm.types.ts:585 The flag to enable spend permissions.
idempotencyKey?
optional idempotencyKey: string;
Defined in: client/evm/evm.types.ts:581 The idempotency key.
name?
optional name: string;
Defined in: client/evm/evm.types.ts:583 The name of the account.
owner
owner: EvmAccount;
Defined in: client/evm/evm.types.ts:579 The owner of the account.

​
CreateSwapQuoteOptions

Defined in: client/evm/evm.types.ts:139 Options for creating a swap quote between two tokens on an EVM network.

​
Properties

fromAmount
fromAmount: bigint;
Defined in: client/evm/evm.types.ts:147 The amount to send in atomic units of the token.
fromToken
fromToken: `0x${string}`;
Defined in: client/evm/evm.types.ts:145 The token to send (source token).
gasPrice?
optional gasPrice: bigint;
Defined in: client/evm/evm.types.ts:155 The price per unit of gas in wei.
idempotencyKey?
optional idempotencyKey: string;
Defined in: client/evm/evm.types.ts:159 The idempotency key.
network
network: EvmSwapsNetwork;
Defined in: client/evm/evm.types.ts:141 The network to create a swap quote on.
signerAddress?
optional signerAddress: `0x${string}`;
Defined in: client/evm/evm.types.ts:151 The address signing the swap (only needed if taker is a smart contract, i.e. for smart account swaps).
slippageBps?
optional slippageBps: number;
Defined in: client/evm/evm.types.ts:157 The slippage tolerance in basis points (0-10000).
smartAccount?
optional smartAccount: {
  address: `0x${string}`;
  getUserOperation: (options: Omit<GetUserOperationOptions, "smartAccount">) => Promise<UserOperation>;
  listTokenBalances: (options: Omit<ListTokenBalancesOptions, "address">) => Promise<ListTokenBalancesResult>;
  name?: string;
  owners: EvmAccount[];
  policies: string[] | undefined;
  quoteSwap: (options: SmartAccountQuoteSwapOptions) => Promise<SmartAccountQuoteSwapResult>;
  requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<RequestFaucetResult>;
  sendUserOperation: (options: Omit<SendUserOperationOptions<unknown[]>, "smartAccount">) => Promise<SendUserOperationReturnType>;
  signTypedData: (options: Omit<SignTypedDataOptions, "address"> & {
     network: KnownEvmNetworks;
  }) => Promise<`0x${string}`>;
  swap: (options: SmartAccountSwapOptions) => Promise<SmartAccountSwapResult>;
  transfer: (options: SmartAccountTransferOptions) => Promise<SendUserOperationReturnType>;
  type: "evm-smart";
  useNetwork: <Network>(network: Network) => Promise<{ [K in string | number | symbol]: (Omit<EvmSmartAccountProperties, "useNetwork"> & { [K in string | number | symbol]: ({ getUserOperation: ...; sendUserOperation: ...; signTypedData: ...; waitForUserOperation: ... } & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)))[K] } & { network: Network })[K] }>;
  useSpendPermission: (options: UseSpendPermissionOptions) => Promise<SendUserOperationReturnType>;
  waitForUserOperation: (options: Omit<WaitForUserOperationOptions, "smartAccountAddress">) => Promise<WaitForUserOperationReturnType>;
};
Defined in: client/evm/evm.types.ts:153 The smart account object (required for smart account execution context only).
address
address: `0x${string}`;
The smart account’s address.
getUserOperation()
getUserOperation: (options: Omit<GetUserOperationOptions, "smartAccount">) => Promise<UserOperation>;
Gets a user operation by its hash.
Parameters
options
Omit<GetUserOperationOptions, "smartAccount"> Parameters for getting the user operation.
Returns
Promise<UserOperation> A promise that resolves to the user operation.
Example
const userOp = await smartAccount.getUserOperation({
  userOpHash: "0x1234567890123456789012345678901234567890",
});
listTokenBalances()
listTokenBalances: (options: Omit<ListTokenBalancesOptions, "address">) => Promise<ListTokenBalancesResult>;
List the token balances of an account.
Parameters
options
Omit<ListTokenBalancesOptions, "address"> The options for the list token balances.
Returns
Promise<ListTokenBalancesResult> The result of the list token balances.
Example
const balances = await account.listTokenBalances({
  network: "base-sepolia",
});
name?
optional name: string;
The name of the smart account.
owners
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).
policies
policies: string[] | undefined;
The list of policy IDs that apply to the smart account. This will include both the project-level policy and the account-level policy, if one exists.
quoteSwap()
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.
Parameters
options
SmartAccountQuoteSwapOptions Configuration options for creating the swap quote.
Returns
Promise<SmartAccountQuoteSwapResult> A promise that resolves to the swap quote or a response indicating that liquidity is unavailable.
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`);
}
requestFaucet()
requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<RequestFaucetResult>;
Requests funds from an EVM faucet.
Parameters
options
Omit<RequestFaucetOptions, "address"> Parameters for requesting funds from the EVM faucet.
Returns
Promise<RequestFaucetResult> A promise that resolves to the transaction hash.
Example
const result = await account.requestFaucet({
  network: "base-sepolia",
  token: "eth",
});
sendUserOperation()
sendUserOperation: (options: Omit<SendUserOperationOptions<unknown[]>, "smartAccount">) => Promise<SendUserOperationReturnType>;
Sends a user operation.
Parameters
options
Omit<SendUserOperationOptions<unknown[]>, "smartAccount"> Parameters for sending the user operation.
Returns
Promise<SendUserOperationReturnType> A promise that resolves to an object containing the smart account address, the user operation hash, and the status of the user operation.
Example
const userOp = await smartAccount.sendUserOperation({
  network: "base-sepolia",
  calls: [
    {
      to: "0x1234567890123456789012345678901234567890",
      value: parseEther("0.000001"),
      data: "0x",
    },
  ],
});
signTypedData()
signTypedData: (options: Omit<SignTypedDataOptions, "address"> & {
  network: KnownEvmNetworks;
}) => Promise<`0x${string}`>;
Signs a typed data message.
Parameters
options
Omit<SignTypedDataOptions, "address"> & { network: KnownEvmNetworks; } Configuration options for signing the typed data.
Returns
Promise<`0x${string}`> A promise that resolves to the signature.
Example
const signature = await smartAccount.signTypedData({
  network: "base-sepolia",
  typedData: {
    domain: {
      name: "Test",
      chainId: 84532,
      verifyingContract: "0x0000000000000000000000000000000000000000",
    },
    types: {
      Test: [{ name: "name", type: "string" }],
    },
    primaryType: "Test",
    message: {
      name: "John Doe",
    },
  },
});
swap()
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.
Parameters
options
SmartAccountSwapOptions Configuration options for the swap.
Returns
Promise<SmartAccountSwapResult> A promise that resolves to the user operation result.
Throws
If liquidity is not available when using inline options.
Examples
// 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}`);

// 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}`);
transfer()
transfer: (options: SmartAccountTransferOptions) => Promise<SendUserOperationReturnType>;
Transfer an amount of a token from an account to another account.
Parameters
options
SmartAccountTransferOptions The options for the transfer.
Returns
Promise<SendUserOperationReturnType> The user operation result.
Examples
const { userOpHash } = await sender.transfer({
  to: "0x9F663335Cd6Ad02a37B633602E98866CF944124d",
  amount: 10000n, // equivalent to 0.01 USDC
  token: "usdc",
  network: "base-sepolia",
});
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",
});
Transfer ETH 
import { parseEther } from "viem";

const { userOpHash } = await sender.transfer({
  to: "0x9F663335Cd6Ad02a37B633602E98866CF944124d",
  amount: parseEther("0.000001"),
  token: "eth",
  network: "base-sepolia",
});
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",
});
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",
});
type
type: "evm-smart";
Identifier for the smart account type.
useNetwork()
useNetwork: <Network>(network: Network) => Promise<{ [K in string | number | symbol]: (Omit<EvmSmartAccountProperties, "useNetwork"> & { [K in string | number | symbol]: ({ getUserOperation: ...; sendUserOperation: ...; signTypedData: ...; waitForUserOperation: ... } & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)))[K] } & { network: Network })[K] }>;
A function that returns a network-scoped smart account.
Type Parameters
Network
Network extends NetworkOrRpcUrl
Parameters
network
Network The network name or RPC URL
Returns
Promise<&#123; [K in string | number | symbol]: (Omit<EvmSmartAccountProperties, “useNetwork”> & &#123; [K in string | number | symbol]: (&#123; getUserOperation: …; sendUserOperation: …; signTypedData: …; waitForUserOperation: … &#125; & ((…) extends (…) ? (…) : (…)) & ((…) extends (…) ? (…) : (…)) & ((…) extends (…) ? (…) : (…)) & ((…) extends (…) ? (…) : (…)) & ((…) extends (…) ? (…) : (…)) & ((…) extends (…) ? (…) : (…)))[K] } & &#123; network: Network &#125;)[K] }>
Example
// For known networks, type is inferred automatically:
const baseAccount = await smartAccount.useNetwork("base");

// For custom RPC URLs with type hints (requires casting):
const typedAccount = await smartAccount.useNetwork<"base">("https://mainnet.base.org" as "base");

// For custom RPC URLs without type hints (only sendTransaction, transfer and waitForTransactionReceipt methods available):
const customAccount = await smartAccount.useNetwork("https://mainnet.base.org");
useSpendPermission()
useSpendPermission: (options: UseSpendPermissionOptions) => Promise<SendUserOperationReturnType>;
Uses a spend permission to execute a transaction via user operation. This allows the smart account to spend tokens that have been approved via a spend permission.
Parameters
options
UseSpendPermissionOptions Configuration options for using the spend permission.
Returns
Promise<SendUserOperationReturnType> A promise that resolves to the user operation result.
Throws
If the network doesn’t support spend permissions via CDP API.
Example
const spendPermission = {
  account: "0x1234...", // Smart account that owns the tokens
  spender: smartAccount.address, // This smart account that can spend
  token: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", // ETH
  allowance: parseEther("0.01"),
  period: 86400, // 1 day
  start: 0,
  end: 281474976710655,
  salt: 0n,
  extraData: "0x",
};

const result = await smartAccount.useSpendPermission({
  spendPermission,
  value: parseEther("0.001"), // Spend 0.001 ETH
  network: "base-sepolia",
});
waitForUserOperation()
waitForUserOperation: (options: Omit<WaitForUserOperationOptions, "smartAccountAddress">) => Promise<WaitForUserOperationReturnType>;
Waits for a user operation to complete or fail.
Parameters
options
Omit<WaitForUserOperationOptions, "smartAccountAddress"> Parameters for waiting for the user operation.
Returns
Promise<WaitForUserOperationReturnType> A promise that resolves to the transaction receipt.
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,
});
taker
taker: `0x${string}`;
Defined in: client/evm/evm.types.ts:149 The address receiving the output of the swap.
toToken
toToken: `0x${string}`;
Defined in: client/evm/evm.types.ts:143 The token to receive (destination token).

​
CreateSwapQuoteResult

Defined in: client/evm/evm.types.ts:247 Result of creating a swap quote.

​
Properties

blockNumber
blockNumber: bigint;
Defined in: client/evm/evm.types.ts:263 The block number at which the liquidity conditions were examined.
execute()
execute: (options?: ExecuteSwapQuoteOptions) => Promise<ExecuteSwapQuoteResult>;
Defined in: client/evm/evm.types.ts:292 Execute the swap using the quote.
Parameters
options?
ExecuteSwapQuoteOptions Options for executing the swap.
Returns
Promise<ExecuteSwapQuoteResult> A promise that resolves to the swap execution result.
fees
fees: SwapFees;
Defined in: client/evm/evm.types.ts:265 The estimated fees for the swap.
fromAmount
fromAmount: bigint;
Defined in: client/evm/evm.types.ts:257 The amount to send in atomic units of the token.
fromToken
fromToken: `0x${string}`;
Defined in: client/evm/evm.types.ts:255 The token to send (source token).
issues
issues: SwapIssues;
Defined in: client/evm/evm.types.ts:267 Potential issues discovered during validation.
liquidityAvailable
liquidityAvailable: true;
Defined in: client/evm/evm.types.ts:249 Whether liquidity is available for the swap.
minToAmount
minToAmount: bigint;
Defined in: client/evm/evm.types.ts:261 The minimum amount to receive after slippage in atomic units of the token.
network
network: EvmSwapsNetwork;
Defined in: client/evm/evm.types.ts:251 The network for which this swap quote was created.
permit2?
optional permit2: {
  eip712: EIP712Message;
};
Defined in: client/evm/evm.types.ts:282 Permit2 data if required for the swap.
eip712
eip712: EIP712Message;
EIP-712 typed data for signing.
toAmount
toAmount: bigint;
Defined in: client/evm/evm.types.ts:259 The amount to receive in atomic units of the token.
toToken
toToken: `0x${string}`;
Defined in: client/evm/evm.types.ts:253 The token to receive (destination token).
transaction?
optional transaction: {
  data: `0x${string}`;
  gas: bigint;
  gasPrice: bigint;
  to: `0x${string}`;
  value: bigint;
};
Defined in: client/evm/evm.types.ts:269 The transaction to execute the swap.
data
data: `0x${string}`;
The transaction data.
gas
gas: bigint;
The gas limit for the transaction.
gasPrice
gasPrice: bigint;
The gas price for the transaction in Wei.
to
to: `0x${string}`;
The contract address to send the transaction to.
value
value: bigint;
The value to send with the transaction in Wei.

​
EvmCall

Defined in: client/evm/evm.types.ts:342 A call to be executed in a user operation.

​
Properties

data
data: `0x${string}`;
Defined in: client/evm/evm.types.ts:352 The call data to send. This is the hex-encoded data of the function call consisting of the method selector and the function arguments.
overrideGasLimit?
optional overrideGasLimit: string;
Defined in: client/evm/evm.types.ts:354 The override gas limit.
to
to: `0x${string}`;
Defined in: client/evm/evm.types.ts:346 The address the call is directed to.
value
value: bigint;
Defined in: client/evm/evm.types.ts:348 The amount of ETH to send with the call, in wei.

​
ExecuteSwapQuoteOptions

Defined in: client/evm/evm.types.ts:225 Options for executing a swap quote.

​
Properties

idempotencyKey?
optional idempotencyKey: string;
Defined in: client/evm/evm.types.ts:227 Optional idempotency key for the request.

​
ExecuteSwapQuoteResult

Defined in: client/evm/evm.types.ts:233 Result of executing a swap quote.

​
Properties

smartAccountAddress?
optional smartAccountAddress: `0x${string}`;
Defined in: client/evm/evm.types.ts:239 The address of the smart account (for smart account swaps).
status?
optional status: "broadcast";
Defined in: client/evm/evm.types.ts:241 The status of the user operation (for smart accounts swaps).
transactionHash?
optional transactionHash: `0x${string}`;
Defined in: client/evm/evm.types.ts:235 The transaction hash of the executed swap (for EOA swaps).
userOpHash?
optional userOpHash: `0x${string}`;
Defined in: client/evm/evm.types.ts:237 The user operation hash of the executed swap (for smart account swaps).

​
ExportServerAccountOptions

Defined in: client/evm/evm.types.ts:414 Options for exporting an EVM server account.

​
Properties

address?
optional address: `0x${string}`;
Defined in: client/evm/evm.types.ts:416 The address of the account.
idempotencyKey?
optional idempotencyKey: string;
Defined in: client/evm/evm.types.ts:420 The idempotency key.
name?
optional name: string;
Defined in: client/evm/evm.types.ts:418 The name of the account.

​
GetOrCreateServerAccountOptions

Defined in: client/evm/evm.types.ts:448 Options for getting an EVM account, or creating one if it doesn’t exist.

​
Properties

name
name: string;
Defined in: client/evm/evm.types.ts:450 The name of the account.

​
GetOrCreateSmartAccountOptions

Defined in: client/evm/evm.types.ts:456 Options for getting an EVM account, or creating one if it doesn’t exist.

​
Properties

enableSpendPermissions?
optional enableSpendPermissions: boolean;
Defined in: client/evm/evm.types.ts:462 The flag to enable spend permissions.
name
name: string;
Defined in: client/evm/evm.types.ts:458 The name of the account.
owner
owner: EvmAccount;
Defined in: client/evm/evm.types.ts:460 The owner of the account.

​
GetServerAccountOptions

Defined in: client/evm/evm.types.ts:426 Options for getting an EVM account.

​
Properties

address?
optional address: `0x${string}`;
Defined in: client/evm/evm.types.ts:428 The address of the account.
name?
optional name: string;
Defined in: client/evm/evm.types.ts:430 The name of the account.

​
GetSmartAccountOptions

Defined in: client/evm/evm.types.ts:436 Options for getting an EVM smart account.

​
Properties

address?
optional address: `0x${string}`;
Defined in: client/evm/evm.types.ts:438 The address of the account.
name?
optional name: string;
Defined in: client/evm/evm.types.ts:442 The name of the account.
owner
owner: EvmAccount;
Defined in: client/evm/evm.types.ts:440 The owner of the account.

​
GetSwapPriceOptions

Defined in: client/evm/evm.types.ts:165 Options for getting a swap price.

​
Properties

fromAmount
fromAmount: bigint;
Defined in: client/evm/evm.types.ts:173 The amount to send in atomic units of the token.
fromToken
fromToken: `0x${string}`;
Defined in: client/evm/evm.types.ts:171 The token to send (source token).
gasPrice?
optional gasPrice: bigint;
Defined in: client/evm/evm.types.ts:179 The gas price in Wei.
idempotencyKey?
optional idempotencyKey: string;
Defined in: client/evm/evm.types.ts:183 The idempotency key.
network
network: EvmSwapsNetwork;
Defined in: client/evm/evm.types.ts:167 The network to get a price from.
signerAddress?
optional signerAddress: `0x${string}`;
Defined in: client/evm/evm.types.ts:177 The signer address (only needed if taker is a smart contract).
slippageBps?
optional slippageBps: number;
Defined in: client/evm/evm.types.ts:181 The slippage tolerance in basis points (0-10000).
taker
taker: `0x${string}`;
Defined in: client/evm/evm.types.ts:175 The address that will perform the swap.
toToken
toToken: `0x${string}`;
Defined in: client/evm/evm.types.ts:169 The token to receive (destination token).

​
GetSwapPriceResult

Defined in: client/evm/evm.types.ts:189 Result of getting a swap price.

​
Properties

blockNumber
blockNumber: bigint;
Defined in: client/evm/evm.types.ts:203 The block number at which the liquidity conditions were examined.
fees
fees: SwapFees;
Defined in: client/evm/evm.types.ts:205 The estimated fees for the swap.
fromAmount
fromAmount: bigint;
Defined in: client/evm/evm.types.ts:197 The amount to send in atomic units of the token.
fromToken
fromToken: `0x${string}`;
Defined in: client/evm/evm.types.ts:195 The token to send (source token).
gas?
optional gas: bigint;
Defined in: client/evm/evm.types.ts:209 The gas estimate for the swap.
gasPrice?
optional gasPrice: bigint;
Defined in: client/evm/evm.types.ts:211 The gas price in Wei.
issues
issues: SwapIssues;
Defined in: client/evm/evm.types.ts:207 Potential issues discovered during validation.
liquidityAvailable
liquidityAvailable: true;
Defined in: client/evm/evm.types.ts:191 Whether liquidity is available for the swap.
minToAmount
minToAmount: bigint;
Defined in: client/evm/evm.types.ts:201 The minimum amount to receive after slippage in atomic units of the token.
toAmount
toAmount: bigint;
Defined in: client/evm/evm.types.ts:199 The amount to receive in atomic units of the token.
toToken
toToken: `0x${string}`;
Defined in: client/evm/evm.types.ts:193 The token to receive (destination token).

​
GetUserOperationOptions

Defined in: client/evm/evm.types.ts:298 Options for getting a user operation.

​
Properties

smartAccount
smartAccount: 
  | `0x${string}`
  | {
  address: `0x${string}`;
  getUserOperation: (options: Omit<GetUserOperationOptions, "smartAccount">) => Promise<UserOperation>;
  listTokenBalances: (options: Omit<ListTokenBalancesOptions, "address">) => Promise<ListTokenBalancesResult>;
  name?: string;
  owners: EvmAccount[];
  policies: string[] | undefined;
  quoteSwap: (options: SmartAccountQuoteSwapOptions) => Promise<SmartAccountQuoteSwapResult>;
  requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<RequestFaucetResult>;
  sendUserOperation: (options: Omit<SendUserOperationOptions<unknown[]>, "smartAccount">) => Promise<SendUserOperationReturnType>;
  signTypedData: (options: Omit<SignTypedDataOptions, "address"> & {
     network: KnownEvmNetworks;
  }) => Promise<`0x${string}`>;
  swap: (options: SmartAccountSwapOptions) => Promise<SmartAccountSwapResult>;
  transfer: (options: SmartAccountTransferOptions) => Promise<SendUserOperationReturnType>;
  type: "evm-smart";
  useNetwork: <Network>(network: Network) => Promise<{ [K in string | number | symbol]: (Omit<EvmSmartAccountProperties, "useNetwork"> & { [K in string | number | symbol]: ({ getUserOperation: ...; sendUserOperation: ...; signTypedData: ...; waitForUserOperation: ... } & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)))[K] } & { network: Network })[K] }>;
  useSpendPermission: (options: UseSpendPermissionOptions) => Promise<SendUserOperationReturnType>;
  waitForUserOperation: (options: Omit<WaitForUserOperationOptions, "smartAccountAddress">) => Promise<WaitForUserOperationReturnType>;
}
  | ReadonlySmartAccount;
Defined in: client/evm/evm.types.ts:300 The smart account.
Type Declaration
`0x${string}` 
{
  address: `0x${string}`;
  getUserOperation: (options: Omit<GetUserOperationOptions, "smartAccount">) => Promise<UserOperation>;
  listTokenBalances: (options: Omit<ListTokenBalancesOptions, "address">) => Promise<ListTokenBalancesResult>;
  name?: string;
  owners: EvmAccount[];
  policies: string[] | undefined;
  quoteSwap: (options: SmartAccountQuoteSwapOptions) => Promise<SmartAccountQuoteSwapResult>;
  requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<RequestFaucetResult>;
  sendUserOperation: (options: Omit<SendUserOperationOptions<unknown[]>, "smartAccount">) => Promise<SendUserOperationReturnType>;
  signTypedData: (options: Omit<SignTypedDataOptions, "address"> & {
     network: KnownEvmNetworks;
  }) => Promise<`0x${string}`>;
  swap: (options: SmartAccountSwapOptions) => Promise<SmartAccountSwapResult>;
  transfer: (options: SmartAccountTransferOptions) => Promise<SendUserOperationReturnType>;
  type: "evm-smart";
  useNetwork: <Network>(network: Network) => Promise<{ [K in string | number | symbol]: (Omit<EvmSmartAccountProperties, "useNetwork"> & { [K in string | number | symbol]: ({ getUserOperation: ...; sendUserOperation: ...; signTypedData: ...; waitForUserOperation: ... } & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)))[K] } & { network: Network })[K] }>;
  useSpendPermission: (options: UseSpendPermissionOptions) => Promise<SendUserOperationReturnType>;
  waitForUserOperation: (options: Omit<WaitForUserOperationOptions, "smartAccountAddress">) => Promise<WaitForUserOperationReturnType>;
}
address
address: `0x${string}`;
The smart account’s address.
getUserOperation()
getUserOperation: (options: Omit<GetUserOperationOptions, "smartAccount">) => Promise<UserOperation>;
Gets a user operation by its hash.
Parameters
options
Omit<GetUserOperationOptions, "smartAccount"> Parameters for getting the user operation.
Returns
Promise<UserOperation> A promise that resolves to the user operation.
Example
const userOp = await smartAccount.getUserOperation({
  userOpHash: "0x1234567890123456789012345678901234567890",
});
listTokenBalances()
listTokenBalances: (options: Omit<ListTokenBalancesOptions, "address">) => Promise<ListTokenBalancesResult>;
List the token balances of an account.
Parameters
options
Omit<ListTokenBalancesOptions, "address"> The options for the list token balances.
Returns
Promise<ListTokenBalancesResult> The result of the list token balances.
Example
const balances = await account.listTokenBalances({
  network: "base-sepolia",
});
name?
optional name: string;
The name of the smart account.
owners
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).
policies
policies: string[] | undefined;
The list of policy IDs that apply to the smart account. This will include both the project-level policy and the account-level policy, if one exists.
quoteSwap()
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.
Parameters
options
SmartAccountQuoteSwapOptions Configuration options for creating the swap quote.
Returns
Promise<SmartAccountQuoteSwapResult> A promise that resolves to the swap quote or a response indicating that liquidity is unavailable.
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`);
}
requestFaucet()
requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<RequestFaucetResult>;
Requests funds from an EVM faucet.
Parameters
options
Omit<RequestFaucetOptions, "address"> Parameters for requesting funds from the EVM faucet.
Returns
Promise<RequestFaucetResult> A promise that resolves to the transaction hash.
Example
const result = await account.requestFaucet({
  network: "base-sepolia",
  token: "eth",
});
sendUserOperation()
sendUserOperation: (options: Omit<SendUserOperationOptions<unknown[]>, "smartAccount">) => Promise<SendUserOperationReturnType>;
Sends a user operation.
Parameters
options
Omit<SendUserOperationOptions<unknown[]>, "smartAccount"> Parameters for sending the user operation.
Returns
Promise<SendUserOperationReturnType> A promise that resolves to an object containing the smart account address, the user operation hash, and the status of the user operation.
Example
const userOp = await smartAccount.sendUserOperation({
  network: "base-sepolia",
  calls: [
    {
      to: "0x1234567890123456789012345678901234567890",
      value: parseEther("0.000001"),
      data: "0x",
    },
  ],
});
signTypedData()
signTypedData: (options: Omit<SignTypedDataOptions, "address"> & {
  network: KnownEvmNetworks;
}) => Promise<`0x${string}`>;
Signs a typed data message.
Parameters
options
Omit<SignTypedDataOptions, "address"> & { network: KnownEvmNetworks; } Configuration options for signing the typed data.
Returns
Promise<`0x${string}`> A promise that resolves to the signature.
Example
const signature = await smartAccount.signTypedData({
  network: "base-sepolia",
  typedData: {
    domain: {
      name: "Test",
      chainId: 84532,
      verifyingContract: "0x0000000000000000000000000000000000000000",
    },
    types: {
      Test: [{ name: "name", type: "string" }],
    },
    primaryType: "Test",
    message: {
      name: "John Doe",
    },
  },
});
swap()
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.
Parameters
options
SmartAccountSwapOptions Configuration options for the swap.
Returns
Promise<SmartAccountSwapResult> A promise that resolves to the user operation result.
Throws
If liquidity is not available when using inline options.
Examples
// 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}`);

// 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}`);
transfer()
transfer: (options: SmartAccountTransferOptions) => Promise<SendUserOperationReturnType>;
Transfer an amount of a token from an account to another account.
Parameters
options
SmartAccountTransferOptions The options for the transfer.
Returns
Promise<SendUserOperationReturnType> The user operation result.
Examples
const { userOpHash } = await sender.transfer({
  to: "0x9F663335Cd6Ad02a37B633602E98866CF944124d",
  amount: 10000n, // equivalent to 0.01 USDC
  token: "usdc",
  network: "base-sepolia",
});
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",
});
Transfer ETH 
import { parseEther } from "viem";

const { userOpHash } = await sender.transfer({
  to: "0x9F663335Cd6Ad02a37B633602E98866CF944124d",
  amount: parseEther("0.000001"),
  token: "eth",
  network: "base-sepolia",
});
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",
});
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",
});
type
type: "evm-smart";
Identifier for the smart account type.
useNetwork()
useNetwork: <Network>(network: Network) => Promise<{ [K in string | number | symbol]: (Omit<EvmSmartAccountProperties, "useNetwork"> & { [K in string | number | symbol]: ({ getUserOperation: ...; sendUserOperation: ...; signTypedData: ...; waitForUserOperation: ... } & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)))[K] } & { network: Network })[K] }>;
A function that returns a network-scoped smart account.
Type Parameters
Network
Network extends NetworkOrRpcUrl
Parameters
network
Network The network name or RPC URL
Returns
Promise<&#123; [K in string | number | symbol]: (Omit<EvmSmartAccountProperties, “useNetwork”> & &#123; [K in string | number | symbol]: (&#123; getUserOperation: …; sendUserOperation: …; signTypedData: …; waitForUserOperation: … &#125; & ((…) extends (…) ? (…) : (…)) & ((…) extends (…) ? (…) : (…)) & ((…) extends (…) ? (…) : (…)) & ((…) extends (…) ? (…) : (…)) & ((…) extends (…) ? (…) : (…)) & ((…) extends (…) ? (…) : (…)))[K] } & &#123; network: Network &#125;)[K] }>
Example
// For known networks, type is inferred automatically:
const baseAccount = await smartAccount.useNetwork("base");

// For custom RPC URLs with type hints (requires casting):
const typedAccount = await smartAccount.useNetwork<"base">("https://mainnet.base.org" as "base");

// For custom RPC URLs without type hints (only sendTransaction, transfer and waitForTransactionReceipt methods available):
const customAccount = await smartAccount.useNetwork("https://mainnet.base.org");
useSpendPermission()
useSpendPermission: (options: UseSpendPermissionOptions) => Promise<SendUserOperationReturnType>;
Uses a spend permission to execute a transaction via user operation. This allows the smart account to spend tokens that have been approved via a spend permission.
Parameters
options
UseSpendPermissionOptions Configuration options for using the spend permission.
Returns
Promise<SendUserOperationReturnType> A promise that resolves to the user operation result.
Throws
If the network doesn’t support spend permissions via CDP API.
Example
const spendPermission = {
  account: "0x1234...", // Smart account that owns the tokens
  spender: smartAccount.address, // This smart account that can spend
  token: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", // ETH
  allowance: parseEther("0.01"),
  period: 86400, // 1 day
  start: 0,
  end: 281474976710655,
  salt: 0n,
  extraData: "0x",
};

const result = await smartAccount.useSpendPermission({
  spendPermission,
  value: parseEther("0.001"), // Spend 0.001 ETH
  network: "base-sepolia",
});
waitForUserOperation()
waitForUserOperation: (options: Omit<WaitForUserOperationOptions, "smartAccountAddress">) => Promise<WaitForUserOperationReturnType>;
Waits for a user operation to complete or fail.
Parameters
options
Omit<WaitForUserOperationOptions, "smartAccountAddress"> Parameters for waiting for the user operation.
Returns
Promise<WaitForUserOperationReturnType> A promise that resolves to the transaction receipt.
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,
});
ReadonlySmartAccount
userOpHash
userOpHash: `0x${string}`;
Defined in: client/evm/evm.types.ts:302 The user operation hash.

​
ImportServerAccountOptions

Defined in: client/evm/evm.types.ts:400 Options for importing an EVM server account.

​
Properties

encryptionPublicKey?
optional encryptionPublicKey: string;
Defined in: client/evm/evm.types.ts:402 The public RSA key used to encrypt the private key when importing an EVM account.
idempotencyKey?
optional idempotencyKey: string;
Defined in: client/evm/evm.types.ts:406 The idempotency key.
name?
optional name: string;
Defined in: client/evm/evm.types.ts:404 The name of the account.
privateKey
privateKey: `0x${string}`;
Defined in: client/evm/evm.types.ts:408 The private key of the account.

​
ListServerAccountResult

Defined in: client/evm/evm.types.ts:552 The result of listing EVM server accounts.

​
Properties

accounts
accounts: {
  address: `0x${string}`;
  listTokenBalances: (options: Omit<ListTokenBalancesOptions, "address">) => Promise<ListTokenBalancesResult>;
  name?: string;
  policies?: string[];
  quoteSwap: (options: AccountQuoteSwapOptions) => Promise<AccountQuoteSwapResult>;
  requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<RequestFaucetResult>;
  sendTransaction: (options: Omit<SendTransactionOptions, "address">) => Promise<TransactionResult>;
  sign: (parameters: {
     hash: `0x${string}`;
  }) => Promise<`0x${string}`>;
  signMessage: (parameters: {
     message: SignableMessage;
  }) => Promise<`0x${string}`>;
  signTransaction: (transaction: TransactionSerializable) => Promise<`0x${string}`>;
  signTypedData: <typedData, primaryType>(parameters: TypedDataDefinition<typedData, primaryType>) => Promise<`0x${string}`>;
  swap: (options: AccountSwapOptions) => Promise<SendSwapTransactionResult>;
  transfer: (options: TransferOptions) => Promise<{
     transactionHash: `0x${string}`;
  }>;
  type: "evm-server";
  useNetwork: <Network>(network: Network) => Promise<{ [K in string | number | symbol]: (Omit<{ address: `0x${string}`; listTokenBalances: (options: Omit<(...), (...)>) => Promise<(...)>; name?: string; policies?: (...)[]; quoteSwap: (options: AccountQuoteSwapOptions) => Promise<(...)>; requestFaucet: (options: Omit<(...), (...)>) => Promise<(...)>; sendTransaction: (options: Omit<(...), (...)>) => Promise<(...)>; sign: (parameters: { hash: ... }) => Promise<(...)>; signMessage: (parameters: { message: ... }) => Promise<(...)>; signTransaction: (transaction: TransactionSerializable) => Promise<(...)>; signTypedData: (parameters: TypedDataDefinition<(...), (...)>) => Promise<(...)>; swap: (options: AccountSwapOptions) => Promise<(...)>; transfer: (options: TransferOptions) => Promise<(...)>; type: "evm-server"; useNetwork: <Network extends NetworkOrRpcUrl>(network: Network) => Promise<{ [K in keyof (Omit<{ address: `0x${string}`; sign: (parameters: { hash: `0x${string}`; }) => Promise<`0x${string}`>; signMessage: (parameters: { message: SignableMessage; }) => Promise<...>; ... 12 more ...; useNetwork: ...; }, keyof Actions | ... 5 mor...; useSpendPermission: (options: UseSpendPermissionOptions) => Promise<(...)> }, (keyof Actions) | "transfer" | "sendTransaction" | "quoteSwap" | "swap" | "useSpendPermission" | "useNetwork"> & { [K in string | number | symbol]: ({ sendTransaction: ...; transfer: ...; waitForTransactionReceipt: ... } & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)))[K] } & { network: Network })[K] }>;
  useSpendPermission: (options: UseSpendPermissionOptions) => Promise<TransactionResult>;
}[];
Defined in: client/evm/evm.types.ts:554 The accounts.
address
address: `0x${string}`;
The address of the signer.
listTokenBalances()
listTokenBalances: (options: Omit<ListTokenBalancesOptions, "address">) => Promise<ListTokenBalancesResult>;
List the token balances of an account.
Parameters
options
Omit<ListTokenBalancesOptions, "address"> The options for the list token balances.
Returns
Promise<ListTokenBalancesResult> The result of the list token balances.
Example
const balances = await account.listTokenBalances({
  network: "base-sepolia",
});
name?
optional name: string;
Optional name for the server account.
policies?
optional policies: string[];
A list of Policy ID’s that apply to the account.
quoteSwap()
quoteSwap: (options: AccountQuoteSwapOptions) => Promise<AccountQuoteSwapResult>;
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 account’s address.
Parameters
options
AccountQuoteSwapOptions Configuration options for creating the swap quote.
Returns
Promise<AccountQuoteSwapResult> A promise that resolves to the swap quote or a response indicating that liquidity is unavailable.
Example
const swapQuote = await account.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`);
}
requestFaucet()
requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<RequestFaucetResult>;
Requests funds from an EVM faucet.
Parameters
options
Omit<RequestFaucetOptions, "address"> Parameters for requesting funds from the EVM faucet.
Returns
Promise<RequestFaucetResult> A promise that resolves to the transaction hash.
Example
const result = await account.requestFaucet({
  network: "base-sepolia",
  token: "eth",
});
sendTransaction()
sendTransaction: (options: Omit<SendTransactionOptions, "address">) => Promise<TransactionResult>;
Signs an EVM transaction and sends it to the specified network using the Coinbase API. This method handles nonce management and gas estimation automatically.
Parameters
options
Omit<SendTransactionOptions, "address"> Configuration options for sending the transaction.
Returns
Promise<TransactionResult> A promise that resolves to the transaction hash.
Examples
Sending an RLP-encoded transaction 
import { parseEther, serializeTransaction } from "viem";
import { baseSepolia } from "viem/chains";

const { transactionHash } = await account.sendTransaction({
  transaction: serializeTransaction({
    to: "0x4252e0c9A3da5A2700e7d91cb50aEf522D0C6Fe8",
    value: parseEther("0.000001"),
    chainId: baseSepolia.id,
    // Fields below are optional, CDP API will populate them if omitted.
    // nonce
    // maxPriorityFeePerGas
    // maxFeePerGas
    // gas
  }),
  network: "base-sepolia",
});
Sending an EIP-1559 transaction request object 
const { transactionHash } = await account.sendTransaction({
  transaction: {
    to: "0x4252e0c9A3da5A2700e7d91cb50aEf522D0C6Fe8",
    value: parseEther("0.000001"),
    // Fields below are optional, CDP API will populate them if omitted.
    // nonce
    // maxPriorityFeePerGas
    // maxFeePerGas
    // gas
  },
  network: "base-sepolia",
});
sign()
sign: (parameters: {
  hash: `0x${string}`;
}) => Promise<`0x${string}`>;
Signs a message hash and returns the signature as a hex string.
Parameters
parameters
hash
`0x${string}`
Returns
Promise<`0x${string}`>
signMessage()
signMessage: (parameters: {
  message: SignableMessage;
}) => Promise<`0x${string}`>;
Signs a message and returns the signature as a hex string.
Parameters
parameters
message
SignableMessage
Returns
Promise<`0x${string}`>
signTransaction()
signTransaction: (transaction: TransactionSerializable) => Promise<`0x${string}`>;
Signs a transaction and returns the signed transaction as a hex string.
Parameters
transaction
TransactionSerializable
Returns
Promise<`0x${string}`>
signTypedData()
signTypedData: <typedData, primaryType>(parameters: TypedDataDefinition<typedData, primaryType>) => Promise<`0x${string}`>;
Signs a typed data and returns the signature as a hex string.
Type Parameters
typedData
typedData extends | { [key: string]: readonly TypedDataParameter[]; [key: `string[${string}]`]: undefined; [key: `function[${string}]`]: undefined; [key: `address[${string}]`]: undefined; [key: `bool[${string}]`]: undefined; [key: `bytes[${string}]`]: undefined; [key: `bytes1[${string}]`]: undefined; [key: `bytes2[${string}]`]: undefined; [key: `bytes3[${string}]`]: undefined; [key: `bytes4[${string}]`]: undefined; [key: `bytes5[${string}]`]: undefined; [key: `bytes6[${string}]`]: undefined; [key: `bytes7[${string}]`]: undefined; [key: `bytes8[${string}]`]: undefined; [key: `bytes9[${string}]`]: undefined; [key: `bytes10[${string}]`]: undefined; [key: `bytes11[${string}]`]: undefined; [key: `bytes12[${string}]`]: undefined; [key: `bytes13[${string}]`]: undefined; [key: `bytes14[${string}]`]: undefined; [key: `bytes15[${string}]`]: undefined; [key: `bytes16[${string}]`]: undefined; [key: `bytes17[${string}]`]: undefined; [key: `bytes18[${string}]`]: undefined; [key: `bytes19[${string}]`]: undefined; [key: `bytes20[${string}]`]: undefined; [key: `bytes21[${string}]`]: undefined; [key: `bytes22[${string}]`]: undefined; [key: `bytes23[${string}]`]: undefined; [key: `bytes24[${string}]`]: undefined; [key: `bytes25[${string}]`]: undefined; [key: `bytes26[${string}]`]: undefined; [key: `bytes27[${string}]`]: undefined; [key: `bytes28[${string}]`]: undefined; [key: `bytes29[${string}]`]: undefined; [key: `bytes30[${string}]`]: undefined; [key: `bytes31[${string}]`]: undefined; [key: `bytes32[${string}]`]: undefined; [key: `int[${string}]`]: undefined; [key: `int8[${string}]`]: undefined; [key: `int16[${string}]`]: undefined; [key: `int24[${string}]`]: undefined; [key: `int32[${string}]`]: undefined; [key: `int40[${string}]`]: undefined; [key: `int48[${string}]`]: undefined; [key: `int56[${string}]`]: undefined; [key: `int64[${string}]`]: undefined; [key: `int72[${string}]`]: undefined; [key: `int80[${string}]`]: undefined; [key: `int88[${string}]`]: undefined; [key: `int96[${string}]`]: undefined; [key: `int104[${string}]`]: undefined; [key: `int112[${string}]`]: undefined; [key: `int120[${string}]`]: undefined; [key: `int128[${string}]`]: undefined; [key: `int136[${string}]`]: undefined; [key: `int144[${string}]`]: undefined; [key: `int152[${string}]`]: undefined; [key: `int160[${string}]`]: undefined; [key: `int168[${string}]`]: undefined; [key: `int176[${string}]`]: undefined; [key: `int184[${string}]`]: undefined; [key: `int192[${string}]`]: undefined; [key: `int200[${string}]`]: undefined; [key: `int208[${string}]`]: undefined; [key: `int216[${string}]`]: undefined; [key: `int224[${string}]`]: undefined; [key: `int232[${string}]`]: undefined; [key: `int240[${string}]`]: undefined; [key: `int248[${string}]`]: undefined; [key: `int256[${string}]`]: undefined; [key: `uint[${string}]`]: undefined; [key: `uint8[${string}]`]: undefined; [key: `uint16[${string}]`]: undefined; [key: `uint24[${string}]`]: undefined; [key: `uint32[${string}]`]: undefined; [key: `uint40[${string}]`]: undefined; [key: `uint48[${string}]`]: undefined; [key: `uint56[${string}]`]: undefined; [key: `uint64[${string}]`]: undefined; [key: `uint72[${string}]`]: undefined; [key: `uint80[${string}]`]: undefined; [key: `uint88[${string}]`]: undefined; [key: `uint96[${string}]`]: undefined; [key: `uint104[${string}]`]: undefined; [key: `uint112[${string}]`]: undefined; [key: `uint120[${string}]`]: undefined; [key: `uint128[${string}]`]: undefined; [key: `uint136[${string}]`]: undefined; [key: `uint144[${string}]`]: undefined; [key: `uint152[${string}]`]: undefined; [key: `uint160[${string}]`]: undefined; [key: `uint168[${string}]`]: undefined; [key: `uint176[${string}]`]: undefined; [key: `uint184[${string}]`]: undefined; [key: `uint192[${string}]`]: undefined; [key: `uint200[${string}]`]: undefined; [key: `uint208[${string}]`]: undefined; [key: `uint216[${string}]`]: undefined; [key: `uint224[${string}]`]: undefined; [key: `uint232[${string}]`]: undefined; [key: `uint240[${string}]`]: undefined; [key: `uint248[${string}]`]: undefined; [key: `uint256[${string}]`]: undefined; address?: undefined; bool?: undefined; bytes?: undefined; bytes1?: undefined; bytes10?: undefined; bytes11?: undefined; bytes12?: undefined; bytes13?: undefined; bytes14?: undefined; bytes15?: undefined; bytes16?: undefined; bytes17?: undefined; bytes18?: undefined; bytes19?: undefined; bytes2?: undefined; bytes20?: undefined; bytes21?: undefined; bytes22?: undefined; bytes23?: undefined; bytes24?: undefined; bytes25?: undefined; bytes26?: undefined; bytes27?: undefined; bytes28?: undefined; bytes29?: undefined; bytes3?: undefined; bytes30?: undefined; bytes31?: undefined; bytes32?: undefined; bytes4?: undefined; bytes5?: undefined; bytes6?: undefined; bytes7?: undefined; bytes8?: undefined; bytes9?: undefined; int104?: undefined; int112?: undefined; int120?: undefined; int128?: undefined; int136?: undefined; int144?: undefined; int152?: undefined; int16?: undefined; int160?: undefined; int168?: undefined; int176?: undefined; int184?: undefined; int192?: undefined; int200?: undefined; int208?: undefined; int216?: undefined; int224?: undefined; int232?: undefined; int24?: undefined; int240?: undefined; int248?: undefined; int256?: undefined; int32?: undefined; int40?: undefined; int48?: undefined; int56?: undefined; int64?: undefined; int72?: undefined; int8?: undefined; int80?: undefined; int88?: undefined; int96?: undefined; string?: undefined; uint104?: undefined; uint112?: undefined; uint120?: undefined; uint128?: undefined; uint136?: undefined; uint144?: undefined; uint152?: undefined; uint16?: undefined; uint160?: undefined; uint168?: undefined; uint176?: undefined; uint184?: undefined; uint192?: undefined; uint200?: undefined; uint208?: undefined; uint216?: undefined; uint224?: undefined; uint232?: undefined; uint24?: undefined; uint240?: undefined; uint248?: undefined; uint256?: undefined; uint32?: undefined; uint40?: undefined; uint48?: undefined; uint56?: undefined; uint64?: undefined; uint72?: undefined; uint8?: undefined; uint80?: undefined; uint88?: undefined; uint96?: undefined; } | Record<string, unknown>
primaryType
primaryType extends string | number | symbol = keyof typedData
Parameters
parameters
TypedDataDefinition<typedData, primaryType>
Returns
Promise<`0x${string}`>
swap()
swap: (options: AccountSwapOptions) => Promise<SendSwapTransactionResult>;
Executes a token swap on the specified network. This method handles all the steps required for a swap, including Permit2 signatures if needed. The taker is automatically set to the account’s address.
Parameters
options
AccountSwapOptions Configuration options for the swap.
Returns
Promise<SendSwapTransactionResult> A promise that resolves to the transaction hash.
Throws
If liquidity is not available when using inline options.
Examples
// 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: account.address
});

// Check if liquidity is available
if (!swapQuote.liquidityAvailable) {
  console.error("Insufficient liquidity for swap");
  return;
}

// Execute the swap
const { transactionHash } = await account.swap({
  swapQuote: swapQuote
});

console.log(`Swap executed with transaction hash: ${transactionHash}`);

// Create and execute swap in one call
const { transactionHash } = await account.swap({
  network: "base",
  toToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
  fromToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
  fromAmount: BigInt("1000000000000000000"), // 1 WETH in wei
});

console.log(`Swap executed with transaction hash: ${transactionHash}`);
transfer()
transfer: (options: TransferOptions) => Promise<{
  transactionHash: `0x${string}`;
}>;
Transfer an amount of a token from an account to another account.
Parameters
options
TransferOptions The options for the transfer.
Returns
Promise<{ transactionHash: `0x${string}`; }> An object containing the transaction hash.
Examples
const { transactionHash } = await sender.transfer({
  to: "0x9F663335Cd6Ad02a37B633602E98866CF944124d",
  amount: 10000n, // equivalent to 0.01 USDC
  token: "usdc",
  network: "base-sepolia",
});
Using parseUnits to specify USDC amount 
import { parseUnits } from "viem";

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

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

const { transactionHash } = await sender.transfer({
  to: "0x9F663335Cd6Ad02a37B633602E98866CF944124d",
  amount: parseEther("0.000001"),
  token: "0x4200000000000000000000000000000000000006", // WETH on Base Sepolia
  network: "base-sepolia",
});
Transfer to another account 
const sender = await cdp.evm.createAccount({ name: "Sender" });
const receiver = await cdp.evm.createAccount({ name: "Receiver" });

const { transactionHash } = await sender.transfer({
  to: receiver,
  amount: 10000n, // equivalent to 0.01 USDC
  token: "usdc",
  network: "base-sepolia",
});
type
type: "evm-server";
Indicates this is a server-managed account.
useNetwork()
useNetwork: <Network>(network: Network) => Promise<{ [K in string | number | symbol]: (Omit<{ address: `0x${string}`; listTokenBalances: (options: Omit<(...), (...)>) => Promise<(...)>; name?: string; policies?: (...)[]; quoteSwap: (options: AccountQuoteSwapOptions) => Promise<(...)>; requestFaucet: (options: Omit<(...), (...)>) => Promise<(...)>; sendTransaction: (options: Omit<(...), (...)>) => Promise<(...)>; sign: (parameters: { hash: ... }) => Promise<(...)>; signMessage: (parameters: { message: ... }) => Promise<(...)>; signTransaction: (transaction: TransactionSerializable) => Promise<(...)>; signTypedData: (parameters: TypedDataDefinition<(...), (...)>) => Promise<(...)>; swap: (options: AccountSwapOptions) => Promise<(...)>; transfer: (options: TransferOptions) => Promise<(...)>; type: "evm-server"; useNetwork: <Network extends NetworkOrRpcUrl>(network: Network) => Promise<{ [K in keyof (Omit<{ address: `0x${string}`; sign: (parameters: { hash: `0x${string}`; }) => Promise<`0x${string}`>; signMessage: (parameters: { message: SignableMessage; }) => Promise<...>; ... 12 more ...; useNetwork: ...; }, keyof Actions | ... 5 mor...; useSpendPermission: (options: UseSpendPermissionOptions) => Promise<(...)> }, (keyof Actions) | "transfer" | "sendTransaction" | "quoteSwap" | "swap" | "useSpendPermission" | "useNetwork"> & { [K in string | number | symbol]: ({ sendTransaction: ...; transfer: ...; waitForTransactionReceipt: ... } & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)) & ((...) extends (...) ? (...) : (...)))[K] } & { network: Network })[K] }>;
A function that returns a network-scoped server-managed account.
Type Parameters
Network
Network extends NetworkOrRpcUrl
Parameters
network
Network The network name or RPC URL
Returns
Promise<&#123; [K in string | number | symbol]: (Omit<&#123; address: `0x\&#123;string\&#125;\`; listTokenBalances: (options: Omit\<(...), (...)\>) =\> Promise\<(...)\>; name?: string; policies?: (...)\[\]; quoteSwap: (options: AccountQuoteSwapOptions) =\> Promise\<(...)\>; requestFaucet: (options: Omit\<(...), (...)\>) =\> Promise\<(...)\>; sendTransaction: (options: Omit\<(...), (...)\>) =\> Promise\<(...)\>; sign: (parameters: \{ hash: ... \}) =\> Promise\<(...)\>; signMessage: (parameters: \{ message: ... \}) =\> Promise\<(...)\>; signTransaction: (transaction: TransactionSerializable) =\> Promise\<(...)\>; signTypedData: (parameters: TypedDataDefinition\<(...), (...)\>) =\> Promise\<(...)\>; swap: (options: AccountSwapOptions) =\> Promise\<(...)\>; transfer: (options: TransferOptions) =\> Promise\<(...)\>; type: "evm-server"; useNetwork: \<Network extends NetworkOrRpcUrl\>(network: Network) =\> Promise\<\{ \[K in keyof (Omit\<\{ address: \`0x&#123;string&#125;`; sign: (parameters: { hash: `0x\&#123;string\&#125;\`; \}) =\> Promise\<\`0x&#123;string&#125;`>; signMessage: (parameters: &#123; message: SignableMessage; &#125;) => Promise<…>; … 12 more …; useNetwork: …; }, keyof Actions | … 5 mor…; useSpendPermission: (options: UseSpendPermissionOptions) => Promise<(…)> }, (keyof Actions) | “transfer” | “sendTransaction” | “quoteSwap” | “swap” | “useSpendPermission” | “useNetwork”> & &#123; [K in string | number | symbol]: (&#123; sendTransaction: …; transfer: …; waitForTransactionReceipt: … &#125; & ((…) extends (…) ? (…) : (…)) & ((…) extends (…) ? (…) : (…)) & ((…) extends (…) ? (…) : (…)) & ((…) extends (…) ? (…) : (…)) & ((…) extends (…) ? (…) : (…)) & ((…) extends (…) ? (…) : (…)))[K] } & &#123; network: Network &#125;)[K] }>
Example
// For known networks, type is inferred automatically:
const baseAccount = await account.useNetwork("base");

// For custom RPC URLs with type hints (requires casting):
const typedAccount = await account.useNetwork<"base">("https://mainnet.base.org" as "base");

// For custom RPC URLs without type hints (only sendTransaction and waitForTransactionReceipt methods available):
const customAccount = await account.useNetwork("https://mainnet.base.org");
useSpendPermission()
useSpendPermission: (options: UseSpendPermissionOptions) => Promise<TransactionResult>;
Uses a spend permission to execute a transaction. This allows the account to spend tokens that have been approved via a spend permission.
Parameters
options
UseSpendPermissionOptions Configuration options for using the spend permission.
Returns
Promise<TransactionResult> A promise that resolves to the transaction result.
Throws
If the network doesn’t support spend permissions via CDP API.
Example
const spendPermission = {
  account: "0x1234...", // Smart account that owns the tokens
  spender: account.address, // This account that can spend
  token: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", // ETH
  allowance: parseEther("0.01"),
  period: 86400, // 1 day
  start: 0,
  end: 281474976710655,
  salt: 0n,
  extraData: "0x",
};

const result = await account.useSpendPermission({
  spendPermission,
  value: parseEther("0.001"), // Spend 0.001 ETH
  network: "base-sepolia",
});
nextPageToken?
optional nextPageToken: string;
Defined in: client/evm/evm.types.ts:559 The next page token to paginate through the accounts. If undefined, there are no more accounts to paginate through.

​
ListServerAccountsOptions

Defined in: client/evm/evm.types.ts:468 Options for listing EVM accounts.

​
Properties

pageSize?
optional pageSize: number;
Defined in: client/evm/evm.types.ts:470 The page size to paginate through the accounts.
pageToken?
optional pageToken: string;
Defined in: client/evm/evm.types.ts:472 The page token to paginate through the accounts.

​
ListSmartAccountResult

Defined in: client/evm/evm.types.ts:539 The result of listing EVM smart accounts.

​
Properties

accounts
accounts: ReadonlySmartAccount[];
Defined in: client/evm/evm.types.ts:541 The accounts.
nextPageToken?
optional nextPageToken: string;
Defined in: client/evm/evm.types.ts:546 The next page token to paginate through the accounts. If undefined, there are no more accounts to paginate through.

​
ListSmartAccountsOptions

Defined in: client/evm/evm.types.ts:565 Options for listing EVM smart accounts.

​
Properties

name?
optional name: string;
Defined in: client/evm/evm.types.ts:567 The name of the account.
pageSize?
optional pageSize: number;
Defined in: client/evm/evm.types.ts:569 The page size to paginate through the accounts.
pageToken?
optional pageToken: string;
Defined in: client/evm/evm.types.ts:571 The page token to paginate through the accounts.

​
PrepareAndSendUserOperationOptions

Defined in: client/evm/evm.types.ts:326 Options for preparing and sending a user operation.

​
Properties

calls
calls: readonly {
  data: `0x${string}`;
  overrideGasLimit?: string;
  to: `0x${string}`;
  value: bigint;
}[];
Defined in: client/evm/evm.types.ts:332 The calls.
idempotencyKey?
optional idempotencyKey: string;
Defined in: client/evm/evm.types.ts:336 An optional idempotency key.
network
network: EvmUserOperationNetwork;
Defined in: client/evm/evm.types.ts:330 The network.
paymasterUrl?
optional paymasterUrl: string;
Defined in: client/evm/evm.types.ts:334 The paymaster URL.
smartAccount
smartAccount: {
  address: `0x${string}`;
  getUserOperation: (options: Omit<GetUserOperationOptions, "smartAccount">) => Promise<UserOperation>;
  listTokenBalances: (options: Omit<ListTokenBalancesOptions, "address">) => Promise<ListTokenBalancesResult>;
  name?: string;
  owners: EvmAccount[];
  policies: string[] | undefined;
  quoteSwap: (options: SmartAccountQuoteSwapOptions) => Promise<SmartAccountQuoteSwapResult>;
  requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<RequestFaucetResult>;
  sendUserOperation: (options: Omit<SendUserOperationOptions<unknown[]>, "smartAccount">) => Promise<SendUserOperationReturnType>;
  signTypedData: (options: Omit<SignTypedDataOptions, "address"> & {
     network: KnownEvmNetworks;
  }) => Promise<`0x${string}`>;
  swap: (options: SmartAccountSwapOptions) => Promise<SmartAccountSwapResult>;
  transfer: (options: SmartAccountTransferOptions) => Promise<SendUserOperationReturnType>;
  type: "evm-smart";
  useNetwork: <Network>(network: Network) => Promise<{ [K in string | number | symbol]: (Omit<EvmSmartAccountProperties, "useNetwork"> & { [K in string | number | symbol]: ({ getUserOperation: (options: ...) => ...; sendUserOperation: (options: ...) => ...; signTypedData: (options: ...) => ...; waitForUserOperation: (options: ...) => ... } & (Network extends TransferNetworks ? { transfer: ... } : EmptyObject) & (Network extends ListTokenBalancesNetworks ? { listTokenBalances: ... } : EmptyObject) & (Network extends RequestFaucetNetworks ? { requestFaucet: ... } : EmptyObject) & (Network extends QuoteSwapNetworks ? { quoteSwap: ... } : EmptyObject) & (Network extends SwapNetworks ? { swap: ... } : EmptyObject) & (Network extends SpendPermissionNetwork ? { useSpendPermission: ... } : EmptyObject))[K] } & { network: Network })[K] }>;
  useSpendPermission: (options: UseSpendPermissionOptions) => Promise<SendUserOperationReturnType>;
  waitForUserOperation: (options: Omit<WaitForUserOperationOptions, "smartAccountAddress">) => Promise<WaitForUserOperationReturnType>;
};
Defined in: client/evm/evm.types.ts:328 The smart account.
address
address: `0x${string}`;
The smart account’s address.
getUserOperation()
getUserOperation: (options: Omit<GetUserOperationOptions, "smartAccount">) => Promise<UserOperation>;
Gets a user operation by its hash.
Parameters
options
Omit<GetUserOperationOptions, "smartAccount"> Parameters for getting the user operation.
Returns
Promise<UserOperation> A promise that resolves to the user operation.
Example
const userOp = await smartAccount.getUserOperation({
  userOpHash: "0x1234567890123456789012345678901234567890",
});
listTokenBalances()
listTokenBalances: (options: Omit<ListTokenBalancesOptions, "address">) => Promise<ListTokenBalancesResult>;
List the token balances of an account.
Parameters
options
Omit<ListTokenBalancesOptions, "address"> The options for the list token balances.
Returns
Promise<ListTokenBalancesResult> The result of the list token balances.
Example
const balances = await account.listTokenBalances({
  network: "base-sepolia",
});
name?
optional name: string;
The name of the smart account.
owners
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).
policies
policies: string[] | undefined;
The list of policy IDs that apply to the smart account. This will include both the project-level policy and the account-level policy, if one exists.
quoteSwap()
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.
Parameters
options
SmartAccountQuoteSwapOptions Configuration options for creating the swap quote.
Returns
Promise<SmartAccountQuoteSwapResult> A promise that resolves to the swap quote or a response indicating that liquidity is unavailable.
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`);
}
requestFaucet()
requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<RequestFaucetResult>;
Requests funds from an EVM faucet.
Parameters
options
Omit<RequestFaucetOptions, "address"> Parameters for requesting funds from the EVM faucet.
Returns
Promise<RequestFaucetResult> A promise that resolves to the transaction hash.
Example
const result = await account.requestFaucet({
  network: "base-sepolia",
  token: "eth",
});
sendUserOperation()
sendUserOperation: (options: Omit<SendUserOperationOptions<unknown[]>, "smartAccount">) => Promise<SendUserOperationReturnType>;
Sends a user operation.
Parameters
options
Omit<SendUserOperationOptions<unknown[]>, "smartAccount"> Parameters for sending the user operation.
Returns
Promise<SendUserOperationReturnType> A promise that resolves to an object containing the smart account address, the user operation hash, and the status of the user operation.
Example
const userOp = await smartAccount.sendUserOperation({
  network: "base-sepolia",
  calls: [
    {
      to: "0x1234567890123456789012345678901234567890",
      value: parseEther("0.000001"),
      data: "0x",
    },
  ],
});
signTypedData()
signTypedData: (options: Omit<SignTypedDataOptions, "address"> & {
  network: KnownEvmNetworks;
}) => Promise<`0x${string}`>;
Signs a typed data message.
Parameters
options
Omit<SignTypedDataOptions, "address"> & { network: KnownEvmNetworks; } Configuration options for signing the typed data.
Returns
Promise<`0x${string}`> A promise that resolves to the signature.
Example
const signature = await smartAccount.signTypedData({
  network: "base-sepolia",
  typedData: {
    domain: {
      name: "Test",
      chainId: 84532,
      verifyingContract: "0x0000000000000000000000000000000000000000",
    },
    types: {
      Test: [{ name: "name", type: "string" }],
    },
    primaryType: "Test",
    message: {
      name: "John Doe",
    },
  },
});
swap()
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.
Parameters
options
SmartAccountSwapOptions Configuration options for the swap.
Returns
Promise<SmartAccountSwapResult> A promise that resolves to the user operation result.
Throws
If liquidity is not available when using inline options.
Examples
// 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}`);

// 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}`);
transfer()
transfer: (options: SmartAccountTransferOptions) => Promise<SendUserOperationReturnType>;
Transfer an amount of a token from an account to another account.
Parameters
options
SmartAccountTransferOptions The options for the transfer.
Returns
Promise<SendUserOperationReturnType> The user operation result.
Examples
const { userOpHash } = await sender.transfer({
  to: "0x9F663335Cd6Ad02a37B633602E98866CF944124d",
  amount: 10000n, // equivalent to 0.01 USDC
  token: "usdc",
  network: "base-sepolia",
});
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",
});
Transfer ETH 
import { parseEther } from "viem";

const { userOpHash } = await sender.transfer({
  to: "0x9F663335Cd6Ad02a37B633602E98866CF944124d",
  amount: parseEther("0.000001"),
  token: "eth",
  network: "base-sepolia",
});
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",
});
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",
});
type
type: "evm-smart";
Identifier for the smart account type.
useNetwork()
useNetwork: <Network>(network: Network) => Promise<{ [K in string | number | symbol]: (Omit<EvmSmartAccountProperties, "useNetwork"> & { [K in string | number | symbol]: ({ getUserOperation: (options: ...) => ...; sendUserOperation: (options: ...) => ...; signTypedData: (options: ...) => ...; waitForUserOperation: (options: ...) => ... } & (Network extends TransferNetworks ? { transfer: ... } : EmptyObject) & (Network extends ListTokenBalancesNetworks ? { listTokenBalances: ... } : EmptyObject) & (Network extends RequestFaucetNetworks ? { requestFaucet: ... } : EmptyObject) & (Network extends QuoteSwapNetworks ? { quoteSwap: ... } : EmptyObject) & (Network extends SwapNetworks ? { swap: ... } : EmptyObject) & (Network extends SpendPermissionNetwork ? { useSpendPermission: ... } : EmptyObject))[K] } & { network: Network })[K] }>;
A function that returns a network-scoped smart account.
Type Parameters
Network
Network extends NetworkOrRpcUrl
Parameters
network
Network The network name or RPC URL
Returns
Promise<&#123; [K in string | number | symbol]: (Omit<EvmSmartAccountProperties, “useNetwork”> & &#123; [K in string | number | symbol]: (&#123; getUserOperation: (options: …) => …; sendUserOperation: (options: …) => …; signTypedData: (options: …) => …; waitForUserOperation: (options: …) => … &#125; & (Network extends TransferNetworks ? &#123; transfer: … &#125; : EmptyObject) & (Network extends ListTokenBalancesNetworks ? &#123; listTokenBalances: … &#125; : EmptyObject) & (Network extends RequestFaucetNetworks ? &#123; requestFaucet: … &#125; : EmptyObject) & (Network extends QuoteSwapNetworks ? &#123; quoteSwap: … &#125; : EmptyObject) & (Network extends SwapNetworks ? &#123; swap: … &#125; : EmptyObject) & (Network extends SpendPermissionNetwork ? &#123; useSpendPermission: … &#125; : EmptyObject))[K] } & &#123; network: Network &#125;)[K] }>
Example
// For known networks, type is inferred automatically:
const baseAccount = await smartAccount.useNetwork("base");

// For custom RPC URLs with type hints (requires casting):
const typedAccount = await smartAccount.useNetwork<"base">("https://mainnet.base.org" as "base");

// For custom RPC URLs without type hints (only sendTransaction, transfer and waitForTransactionReceipt methods available):
const customAccount = await smartAccount.useNetwork("https://mainnet.base.org");
useSpendPermission()
useSpendPermission: (options: UseSpendPermissionOptions) => Promise<SendUserOperationReturnType>;
Uses a spend permission to execute a transaction via user operation. This allows the smart account to spend tokens that have been approved via a spend permission.
Parameters
options
UseSpendPermissionOptions Configuration options for using the spend permission.
Returns
Promise<SendUserOperationReturnType> A promise that resolves to the user operation result.
Throws
If the network doesn’t support spend permissions via CDP API.
Example
const spendPermission = {
  account: "0x1234...", // Smart account that owns the tokens
  spender: smartAccount.address, // This smart account that can spend
  token: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", // ETH
  allowance: parseEther("0.01"),
  period: 86400, // 1 day
  start: 0,
  end: 281474976710655,
  salt: 0n,
  extraData: "0x",
};

const result = await smartAccount.useSpendPermission({
  spendPermission,
  value: parseEther("0.001"), // Spend 0.001 ETH
  network: "base-sepolia",
});
waitForUserOperation()
waitForUserOperation: (options: Omit<WaitForUserOperationOptions, "smartAccountAddress">) => Promise<WaitForUserOperationReturnType>;
Waits for a user operation to complete or fail.
Parameters
options
Omit<WaitForUserOperationOptions, "smartAccountAddress"> Parameters for waiting for the user operation.
Returns
Promise<WaitForUserOperationReturnType> A promise that resolves to the transaction receipt.
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,
});

​
PrepareUserOperationOptions

Defined in: client/evm/evm.types.ts:308 Options for preparing a user operation.

​
Properties

calls
calls: readonly {
  data: `0x${string}`;
  overrideGasLimit?: string;
  to: `0x${string}`;
  value: bigint;
}[];
Defined in: client/evm/evm.types.ts:314 The calls.
dataSuffix?
optional dataSuffix: string;
Defined in: client/evm/evm.types.ts:320 Optional data suffix (EIP-8021) to enable transaction attribution.
network
network: EvmUserOperationNetwork;
Defined in: client/evm/evm.types.ts:312 The network.
paymasterContext?
optional paymasterContext: PaymasterContext;
Defined in: client/evm/evm.types.ts:318 Optional ERC-7677 context object forwarded to the paymaster service. Only valid when a paymaster is configured.
paymasterUrl?
optional paymasterUrl: string;
Defined in: client/evm/evm.types.ts:316 The paymaster URL.
smartAccount
smartAccount: {
  address: `0x${string}`;
  getUserOperation: (options: Omit<GetUserOperationOptions, "smartAccount">) => Promise<UserOperation>;
  listTokenBalances: (options: Omit<ListTokenBalancesOptions, "address">) => Promise<ListTokenBalancesResult>;
  name?: string;
  owners: EvmAccount[];
  policies: string[] | undefined;
  quoteSwap: (options: SmartAccountQuoteSwapOptions) => Promise<SmartAccountQuoteSwapResult>;
  requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<RequestFaucetResult>;
  sendUserOperation: (options: Omit<SendUserOperationOptions<unknown[]>, "smartAccount">) => Promise<SendUserOperationReturnType>;
  signTypedData: (options: Omit<SignTypedDataOptions, "address"> & {
     network: KnownEvmNetworks;
  }) => Promise<`0x${string}`>;
  swap: (options: SmartAccountSwapOptions) => Promise<SmartAccountSwapResult>;
  transfer: (options: SmartAccountTransferOptions) => Promise<SendUserOperationReturnType>;
  type: "evm-smart";
  useNetwork: <Network>(network: Network) => Promise<{ [K in string | number | symbol]: (Omit<EvmSmartAccountProperties, "useNetwork"> & { [K in string | number | symbol]: ({ getUserOperation: (options: ...) => ...; sendUserOperation: (options: ...) => ...; signTypedData: (options: ...) => ...; waitForUserOperation: (options: ...) => ... } & (Network extends TransferNetworks ? { transfer: ... } : EmptyObject) & (Network extends ListTokenBalancesNetworks ? { listTokenBalances: ... } : EmptyObject) & (Network extends RequestFaucetNetworks ? { requestFaucet: ... } : EmptyObject) & (Network extends QuoteSwapNetworks ? { quoteSwap: ... } : EmptyObject) & (Network extends SwapNetworks ? { swap: ... } : EmptyObject) & (Network extends SpendPermissionNetwork ? { useSpendPermission: ... } : EmptyObject))[K] } & { network: Network })[K] }>;
  useSpendPermission: (options: UseSpendPermissionOptions) => Promise<SendUserOperationReturnType>;
  waitForUserOperation: (options: Omit<WaitForUserOperationOptions, "smartAccountAddress">) => Promise<WaitForUserOperationReturnType>;
};
Defined in: client/evm/evm.types.ts:310 The smart account.
address
address: `0x${string}`;
The smart account’s address.
getUserOperation()
getUserOperation: (options: Omit<GetUserOperationOptions, "smartAccount">) => Promise<UserOperation>;
Gets a user operation by its hash.
Parameters
options
Omit<GetUserOperationOptions, "smartAccount"> Parameters for getting the user operation.
Returns
Promise<UserOperation> A promise that resolves to the user operation.
Example
const userOp = await smartAccount.getUserOperation({
  userOpHash: "0x1234567890123456789012345678901234567890",
});
listTokenBalances()
listTokenBalances: (options: Omit<ListTokenBalancesOptions, "address">) => Promise<ListTokenBalancesResult>;
List the token balances of an account.
Parameters
options
Omit<ListTokenBalancesOptions, "address"> The options for the list token balances.
Returns
Promise<ListTokenBalancesResult> The result of the list token balances.
Example
const balances = await account.listTokenBalances({
  network: "base-sepolia",
});
name?
optional name: string;
The name of the smart account.
owners
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).
policies
policies: string[] | undefined;
The list of policy IDs that apply to the smart account. This will include both the project-level policy and the account-level policy, if one exists.
quoteSwap()
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.
Parameters
options
SmartAccountQuoteSwapOptions Configuration options for creating the swap quote.
Returns
Promise<SmartAccountQuoteSwapResult> A promise that resolves to the swap quote or a response indicating that liquidity is unavailable.
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`);
}
requestFaucet()
requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<RequestFaucetResult>;
Requests funds from an EVM faucet.
Parameters
options
Omit<RequestFaucetOptions, "address"> Parameters for requesting funds from the EVM faucet.
Returns
Promise<RequestFaucetResult> A promise that resolves to the transaction hash.
Example
const result = await account.requestFaucet({
  network: "base-sepolia",
  token: "eth",
});
sendUserOperation()
sendUserOperation: (options: Omit<SendUserOperationOptions<unknown[]>, "smartAccount">) => Promise<SendUserOperationReturnType>;
Sends a user operation.
Parameters
options
Omit<SendUserOperationOptions<unknown[]>, "smartAccount"> Parameters for sending the user operation.
Returns
Promise<SendUserOperationReturnType> A promise that resolves to an object containing the smart account address, the user operation hash, and the status of the user operation.
Example
const userOp = await smartAccount.sendUserOperation({
  network: "base-sepolia",
  calls: [
    {
      to: "0x1234567890123456789012345678901234567890",
      value: parseEther("0.000001"),
      data: "0x",
    },
  ],
});
signTypedData()
signTypedData: (options: Omit<SignTypedDataOptions, "address"> & {
  network: KnownEvmNetworks;
}) => Promise<`0x${string}`>;
Signs a typed data message.
Parameters
options
Omit<SignTypedDataOptions, "address"> & { network: KnownEvmNetworks; } Configuration options for signing the typed data.
Returns
Promise<`0x${string}`> A promise that resolves to the signature.
Example
const signature = await smartAccount.signTypedData({
  network: "base-sepolia",
  typedData: {
    domain: {
      name: "Test",
      chainId: 84532,
      verifyingContract: "0x0000000000000000000000000000000000000000",
    },
    types: {
      Test: [{ name: "name", type: "string" }],
    },
    primaryType: "Test",
    message: {
      name: "John Doe",
    },
  },
});
swap()
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.
Parameters
options
SmartAccountSwapOptions Configuration options for the swap.
Returns
Promise<SmartAccountSwapResult> A promise that resolves to the user operation result.
Throws
If liquidity is not available when using inline options.
Examples
// 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}`);

// 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}`);
transfer()
transfer: (options: SmartAccountTransferOptions) => Promise<SendUserOperationReturnType>;
Transfer an amount of a token from an account to another account.
Parameters
options
SmartAccountTransferOptions The options for the transfer.
Returns
Promise<SendUserOperationReturnType> The user operation result.
Examples
const { userOpHash } = await sender.transfer({
  to: "0x9F663335Cd6Ad02a37B633602E98866CF944124d",
  amount: 10000n, // equivalent to 0.01 USDC
  token: "usdc",
  network: "base-sepolia",
});
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",
});
Transfer ETH 
import { parseEther } from "viem";

const { userOpHash } = await sender.transfer({
  to: "0x9F663335Cd6Ad02a37B633602E98866CF944124d",
  amount: parseEther("0.000001"),
  token: "eth",
  network: "base-sepolia",
});
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",
});
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",
});
type
type: "evm-smart";
Identifier for the smart account type.
useNetwork()
useNetwork: <Network>(network: Network) => Promise<{ [K in string | number | symbol]: (Omit<EvmSmartAccountProperties, "useNetwork"> & { [K in string | number | symbol]: ({ getUserOperation: (options: ...) => ...; sendUserOperation: (options: ...) => ...; signTypedData: (options: ...) => ...; waitForUserOperation: (options: ...) => ... } & (Network extends TransferNetworks ? { transfer: ... } : EmptyObject) & (Network extends ListTokenBalancesNetworks ? { listTokenBalances: ... } : EmptyObject) & (Network extends RequestFaucetNetworks ? { requestFaucet: ... } : EmptyObject) & (Network extends QuoteSwapNetworks ? { quoteSwap: ... } : EmptyObject) & (Network extends SwapNetworks ? { swap: ... } : EmptyObject) & (Network extends SpendPermissionNetwork ? { useSpendPermission: ... } : EmptyObject))[K] } & { network: Network })[K] }>;
A function that returns a network-scoped smart account.
Type Parameters
Network
Network extends NetworkOrRpcUrl
Parameters
network
Network The network name or RPC URL
Returns
Promise<&#123; [K in string | number | symbol]: (Omit<EvmSmartAccountProperties, “useNetwork”> & &#123; [K in string | number | symbol]: (&#123; getUserOperation: (options: …) => …; sendUserOperation: (options: …) => …; signTypedData: (options: …) => …; waitForUserOperation: (options: …) => … &#125; & (Network extends TransferNetworks ? &#123; transfer: … &#125; : EmptyObject) & (Network extends ListTokenBalancesNetworks ? &#123; listTokenBalances: … &#125; : EmptyObject) & (Network extends RequestFaucetNetworks ? &#123; requestFaucet: … &#125; : EmptyObject) & (Network extends QuoteSwapNetworks ? &#123; quoteSwap: … &#125; : EmptyObject) & (Network extends SwapNetworks ? &#123; swap: … &#125; : EmptyObject) & (Network extends SpendPermissionNetwork ? &#123; useSpendPermission: … &#125; : EmptyObject))[K] } & &#123; network: Network &#125;)[K] }>
Example
// For known networks, type is inferred automatically:
const baseAccount = await smartAccount.useNetwork("base");

// For custom RPC URLs with type hints (requires casting):
const typedAccount = await smartAccount.useNetwork<"base">("https://mainnet.base.org" as "base");

// For custom RPC URLs without type hints (only sendTransaction, transfer and waitForTransactionReceipt methods available):
const customAccount = await smartAccount.useNetwork("https://mainnet.base.org");
useSpendPermission()
useSpendPermission: (options: UseSpendPermissionOptions) => Promise<SendUserOperationReturnType>;
Uses a spend permission to execute a transaction via user operation. This allows the smart account to spend tokens that have been approved via a spend permission.
Parameters
options
UseSpendPermissionOptions Configuration options for using the spend permission.
Returns
Promise<SendUserOperationReturnType> A promise that resolves to the user operation result.
Throws
If the network doesn’t support spend permissions via CDP API.
Example
const spendPermission = {
  account: "0x1234...", // Smart account that owns the tokens
  spender: smartAccount.address, // This smart account that can spend
  token: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", // ETH
  allowance: parseEther("0.01"),
  period: 86400, // 1 day
  start: 0,
  end: 281474976710655,
  salt: 0n,
  extraData: "0x",
};

const result = await smartAccount.useSpendPermission({
  spendPermission,
  value: parseEther("0.001"), // Spend 0.001 ETH
  network: "base-sepolia",
});
waitForUserOperation()
waitForUserOperation: (options: Omit<WaitForUserOperationOptions, "smartAccountAddress">) => Promise<WaitForUserOperationReturnType>;
Waits for a user operation to complete or fail.
Parameters
options
Omit<WaitForUserOperationOptions, "smartAccountAddress"> Parameters for waiting for the user operation.
Returns
Promise<WaitForUserOperationReturnType> A promise that resolves to the transaction receipt.
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,
});

​
ReadonlySmartAccount

Defined in: client/evm/evm.types.ts:478 A smart account that only contains the owner address.

​
Extends

​
Properties

address
address: `0x${string}`;
Defined in: accounts/evm/types.ts:144 The smart account’s address.
Inherited from
Omit.address
name?
optional name: string;
Defined in: accounts/evm/types.ts:146 The name of the smart account.
Inherited from
Omit.name
owners
owners: `0x${string}`[];
Defined in: client/evm/evm.types.ts:483 The owners of the smart account.
policies
policies: string[] | undefined;
Defined in: accounts/evm/types.ts:152 The list of policy IDs that apply to the smart account. This will include both the project-level policy and the account-level policy, if one exists.
Inherited from
Omit.policies
type
type: "evm-smart";
Defined in: accounts/evm/types.ts:150 Identifier for the smart account type.
Inherited from
Omit.type

​
SignatureResult

Defined in: client/evm/evm.types.ts:645 A signature result.

​
Properties

signature
signature: `0x${string}`;
Defined in: client/evm/evm.types.ts:647 The signature.

​
SignHashOptions

Defined in: client/evm/evm.types.ts:591 Options for signing an EVM hash.

​
Properties

address
address: `0x${string}`;
Defined in: client/evm/evm.types.ts:593 The address of the account.
hash
hash: `0x${string}`;
Defined in: client/evm/evm.types.ts:595 The hash to sign.
idempotencyKey?
optional idempotencyKey: string;
Defined in: client/evm/evm.types.ts:597 The idempotency key.

​
SignMessageOptions

Defined in: client/evm/evm.types.ts:603 Options for signing an EVM message.

​
Properties

address
address: `0x${string}`;
Defined in: client/evm/evm.types.ts:605 The address of the account.
idempotencyKey?
optional idempotencyKey: string;
Defined in: client/evm/evm.types.ts:609 The idempotency key.
message
message: string;
Defined in: client/evm/evm.types.ts:607 The message to sign.

​
SignTransactionOptions

Defined in: client/evm/evm.types.ts:633 Options for signing an EVM transaction.

​
Properties

address
address: `0x${string}`;
Defined in: client/evm/evm.types.ts:635 The address of the account.
idempotencyKey?
optional idempotencyKey: string;
Defined in: client/evm/evm.types.ts:639 The idempotency key.
transaction
transaction: `0x${string}`;
Defined in: client/evm/evm.types.ts:637 The RLP-encoded transaction to sign, as a 0x-prefixed hex string.

​
SignTypedDataOptions

Defined in: client/evm/evm.types.ts:615 Options for signing an EVM typed data message.

​
Properties

address
address: `0x${string}`;
Defined in: client/evm/evm.types.ts:617 The address of the account.
domain
domain: EIP712Domain;
Defined in: client/evm/evm.types.ts:619 The domain of the message.
idempotencyKey?
optional idempotencyKey: string;
Defined in: client/evm/evm.types.ts:627 The idempotency key.
message
message: EIP712MessageMessage;
Defined in: client/evm/evm.types.ts:625 The message to sign. The structure of this message must match the primaryType struct in the types object.
primaryType
primaryType: string;
Defined in: client/evm/evm.types.ts:623 The primary type of the message. This is the name of the struct in the types object that is the root of the message.
types
types: EIP712Types;
Defined in: client/evm/evm.types.ts:621 The types of the message.

​
SmartAccountSignAndWrapTypedDataOptions

Defined in: client/evm/evm.types.ts:732 Options for signing and wrapping EIP-712 typed data with a smart account. This method handles the full smart account signature flow including replay-safe hashing.

​
Properties

chainId
chainId: bigint;
Defined in: client/evm/evm.types.ts:734 The chain ID for the signature (used for replay protection).
idempotencyKey?
optional idempotencyKey: string;
Defined in: client/evm/evm.types.ts:740 Optional idempotency key for the signing request.
ownerIndex?
optional ownerIndex: bigint;
Defined in: client/evm/evm.types.ts:738 The index of the owner to sign with (defaults to 0).
typedData
typedData: EIP712Message;
Defined in: client/evm/evm.types.ts:736 The EIP-712 typed data message to sign.

​
SwapAllowanceIssue

Defined in: client/evm/evm.types.ts:673 Details of allowance issues for a swap.

​
Properties

currentAllowance
currentAllowance: bigint;
Defined in: client/evm/evm.types.ts:675 The current allowance of the fromToken by the taker.
spender
spender: `0x${string}`;
Defined in: client/evm/evm.types.ts:677 The address to set the allowance on.

​
SwapBalanceIssue

Defined in: client/evm/evm.types.ts:683 Details of balance issues for a swap.

​
Properties

currentBalance
currentBalance: bigint;
Defined in: client/evm/evm.types.ts:687 The current balance of the fromToken by the taker.
requiredBalance
requiredBalance: bigint;
Defined in: client/evm/evm.types.ts:689 The amount of the token that the taker must hold.
token
token: `0x${string}`;
Defined in: client/evm/evm.types.ts:685 The contract address of the token.

​
SwapFees

Defined in: client/evm/evm.types.ts:663 The estimated fees for a swap.

​
Properties

gasFee?
optional gasFee: TokenFee;
Defined in: client/evm/evm.types.ts:665 The estimated gas fee for the swap.
protocolFee?
optional protocolFee: TokenFee;
Defined in: client/evm/evm.types.ts:667 The estimated protocol fee for the swap.

​
SwapIssues

Defined in: client/evm/evm.types.ts:695 Potential issues discovered during swap validation.

​
Properties

allowance?
optional allowance: SwapAllowanceIssue;
Defined in: client/evm/evm.types.ts:697 Details of the allowances that the taker must set. Null if no allowance is required.
balance?
optional balance: SwapBalanceIssue;
Defined in: client/evm/evm.types.ts:699 Details of the balance of the fromToken that the taker must hold. Null if sufficient balance.
simulationIncomplete
simulationIncomplete: boolean;
Defined in: client/evm/evm.types.ts:701 True when the transaction cannot be validated (e.g., insufficient balance).

​
SwapUnavailableResult

Defined in: client/evm/evm.types.ts:217 Result when liquidity is unavailable for a swap.

​
Properties

liquidityAvailable
liquidityAvailable: false;
Defined in: client/evm/evm.types.ts:219 Whether liquidity is available for the swap.

​
TokenFee

Defined in: client/evm/evm.types.ts:653 A fee in a specific token.

​
Properties

amount
amount: bigint;
Defined in: client/evm/evm.types.ts:655 The amount of the fee in atomic units of the token.
token
token: `0x${string}`;
Defined in: client/evm/evm.types.ts:657 The contract address of the token that the fee is paid in.

​
UpdateEvmAccountOptions

Defined in: client/evm/evm.types.ts:489 Options for creating an EVM server account.

​
Properties

address
address: `0x${string}`;
Defined in: client/evm/evm.types.ts:491 The address of the account.
idempotencyKey?
optional idempotencyKey: string;
Defined in: client/evm/evm.types.ts:495 The idempotency key.
update
update: UpdateEvmAccountBody;
Defined in: client/evm/evm.types.ts:493 The updates to apply to the account

​
UpdateEvmSmartAccountOptions

Defined in: client/evm/evm.types.ts:501 Options for updating an EVM smart account.

​
Properties

address
address: `0x${string}`;
Defined in: client/evm/evm.types.ts:503 The address of the account.
idempotencyKey?
optional idempotencyKey: string;
Defined in: client/evm/evm.types.ts:507 The idempotency key.
owner
owner: EvmAccount;
Defined in: client/evm/evm.types.ts:509 The owner of the account.
update
update: UpdateEvmSmartAccountBody;
Defined in: client/evm/evm.types.ts:505 The updates to apply to the account

​
UserOperation

Defined in: client/evm/evm.types.ts:360 A user operation.

​
Properties

calls
calls: readonly {
  data: `0x${string}`;
  overrideGasLimit?: string;
  to: `0x${string}`;
  value: bigint;
}[];
Defined in: client/evm/evm.types.ts:368 The list of calls in the user operation.
expiresAt?
optional expiresAt: string;
Defined in: client/evm/evm.types.ts:382 The timestamp at which the prepared user operation expires, as an ISO 8601 string.
network
network: EvmUserOperationNetwork;
Defined in: client/evm/evm.types.ts:362 The network the user operation is for.
receipts?
optional receipts: UserOperationReceipt[];
Defined in: client/evm/evm.types.ts:378 The receipts associated with the broadcasted user operation.
status
status: EvmUserOperationStatus;
Defined in: client/evm/evm.types.ts:370 The status of the user operation.
transactionHash?
optional transactionHash: `0x${string}`;
Defined in: client/evm/evm.types.ts:374 The hash of the transaction that included this particular user operation. This gets set after the user operation is broadcasted and the transaction is included in a block.
userOpHash
userOpHash: `0x${string}`;
Defined in: client/evm/evm.types.ts:366 The hash of the user operation. This is not the transaction hash, as a transaction consists of multiple user operations. The user operation hash is the hash of this particular user operation which gets signed by the owner of the Smart Account.

​
WaitForEvmEip7702DelegationOperationStatusOptions

Defined in: client/evm/evm.types.ts:529 Options for waiting for an EIP-7702 delegation operation to complete.

​
Properties

delegationOperationId
delegationOperationId: string;
Defined in: client/evm/evm.types.ts:531 The delegation operation ID returned by createEvmEip7702Delegation.
waitOptions?
optional waitOptions: WaitOptions;
Defined in: client/evm/evm.types.ts:533 Optional options for the wait operation.

​
WaitForUserOperationOptions

Defined in: client/evm/evm.types.ts:707 Options for waiting for a user operation.

​
Properties

smartAccountAddress
smartAccountAddress: `0x${string}`;
Defined in: client/evm/evm.types.ts:709 The smart account address.
userOpHash
userOpHash: `0x${string}`;
Defined in: client/evm/evm.types.ts:711 The user operation hash.
waitOptions?
optional waitOptions: WaitOptions;
Defined in: client/evm/evm.types.ts:713 The wait options.

​
Type Aliases

​
References

​
ServerAccount

Renames and re-exports EvmServerAccount

​
SmartAccount

Renames and re-exports EvmSmartAccount