Creates a new CDP EVM account.
Optionaloptions: CreateServerAccountOptions = {}Optional parameters for creating the account.
Options for creating an EVM server account.
Optionalname?: stringThe name of the account.
OptionalaccountPolicy?: stringThe policy ID to apply to the account.
OptionalidempotencyKey?: stringThe idempotency key.
A promise that resolves to the newly created account.
Imports a CDP EVM account from an external source.
Parameters for importing the account.
Options for importing an EVM server account.
OptionalencryptionPublicKey?: stringThe public RSA key used to encrypt the private key when importing an EVM account.
Optionalname?: stringThe name of the account.
OptionalidempotencyKey?: stringThe idempotency key.
The private key of the account.
A promise that resolves to the imported account.
const account = await cdp.evm.importAccount({
privateKey: "0x123456"
});
const account = await cdp.evm.importAccount({
privateKey: "0x123456",
name: "MyAccount"
});
const idempotencyKey = uuidv4();
// First call
await cdp.evm.importAccount({
privateKey: "0x123456",
idempotencyKey,
});
// Second call with the same idempotency key will return the same account
await cdp.evm.importAccount({
privateKey: "0x123456"
idempotencyKey,
});
Exports a CDP EVM account's private key. It is important to store the private key in a secure place after it's exported.
Parameters for exporting the account.
Options for exporting an EVM server account.
Optionaladdress?: `0x${string}`The address of the account.
Optionalname?: stringThe name of the account.
OptionalidempotencyKey?: stringThe idempotency key.
A promise that resolves to the exported account’s 32-byte private key as a hex string, without the "0x" prefix.
Creates a new CDP EVM smart account.
Parameters for creating the smart account.
Options for creating an EVM smart account.
The owner of the account.
OptionalidempotencyKey?: stringThe idempotency key.
Optionalname?: stringThe name of the account.
Optional__experimental_enableSpendPermission?: booleanA promise that resolves to the newly created smart account.
const account = await cdp.evm.createAccount();
const smartAccount = await cdp.evm.createSmartAccount({
owner: account,
});
// See https://viem.sh/docs/accounts/local/privateKeyToAccount
const privateKey = generatePrivateKey();
const account = privateKeyToAccount(privateKey);
const smartAccount = await client.evm.createSmartAccount({
owner: account,
});
const idempotencyKey = uuidv4();
// First call
await cdp.evm.createSmartAccount({
owner: account,
idempotencyKey,
});
// Second call with the same idempotency key will return the same smart account
await cdp.evm.createSmartAccount({
owner: account,
idempotencyKey,
Creates a spend permission for a smart account.
Parameters for creating the spend permission.
The spend permission.
The network.
OptionalpaymasterUrl?: stringThe paymaster URL.
OptionalidempotencyKey?: stringThe idempotency key.
A promise that resolves to the spend permission.
Gets a CDP EVM account.
Parameters for getting the account.
Either address or name must be provided.
If both are provided, lookup will be done by address and name will be ignored.
Options for getting an EVM account.
Optionaladdress?: `0x${string}`The address of the account.
Optionalname?: stringThe name of the account.
A promise that resolves to the account.
Gets a CDP EVM smart account.
Parameters for getting the smart account.
Either address or name must be provided.
If both are provided, lookup will be done by address and name will be ignored.
Options for getting an EVM smart account.
Optionaladdress?: `0x${string}`The address of the account.
The owner of the account.
Optionalname?: stringThe name of the account.
A promise that resolves to the smart account.
Gets a CDP EVM account, or creates one if it doesn't exist.
Parameters for getting or creating the account.
Options for getting an EVM account, or creating one if it doesn't exist.
The name of the account.
A promise that resolves to the account.
Gets a CDP EVM smart account, or creates one if it doesn't exist. This method first attempts to retrieve an existing smart account with the given parameters. If no account exists, it creates a new one with the specified owner.
Configuration options for getting or creating the smart account.
Options for getting an EVM account, or creating one if it doesn't exist.
The name of the account.
The owner of the account.
Optional__experimental_enableSpendPermission?: booleanA promise that resolves to the retrieved or newly created smart account.
Gets the price for a swap between two tokens on an EVM network.
The options for getting a swap price.
A promise that resolves to the swap price result or a response indicating that liquidity is unavailable.
const price = await cdp.evm.getSwapPrice({
network: "ethereum-mainnet",
toToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
fromToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
fromAmount: BigInt("1000000000000000000"), // 1 WETH
taker: "0x1234567890123456789012345678901234567890"
});
Creates a quote for a swap between two tokens on an EVM network.
The options for creating a swap quote.
A promise that resolves to the swap quote result or a response indicating that liquidity is unavailable.
const swapQuote = await cdp.evm.createSwapQuote({
network: "ethereum",
toToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
fromToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
fromAmount: BigInt("1000000000000000000"), // 1 WETH
taker: "0x1234567890123456789012345678901234567890"
});
Gets a user operation for a smart account by user operation hash.
Parameters for getting the user operation.
Options for getting a user operation.
The smart account.
The user operation hash.
A promise that resolves to the user operation.
Lists CDP EVM accounts.
Optionaloptions: ListServerAccountsOptions = {}Optional parameters for listing the accounts.
Options for listing EVM accounts.
OptionalpageSize?: numberThe page size to paginate through the accounts.
OptionalpageToken?: stringThe page token to paginate through the accounts.
A promise that resolves to an array of accounts, and a token to paginate through the accounts.
Lists CDP EVM token balances.
Parameters for listing the token balances.
The number of token balances to return.
The page token to begin listing from. This is obtained by previous calls to this method.
A promise that resolves to an array of token balances, and a token to paginate through the token balances.
const tokenBalances = await cdp.evm.listTokenBalances({
address: "0x1234567890123456789012345678901234567890",
network: "base-sepolia",
});
With pagination
let page = await cdp.evm.listTokenBalances({
address: "0x1234567890123456789012345678901234567890",
network: "base-sepolia",
});
while (page.nextPageToken) {
page = await cdp.evm.listTokenBalances({
address: "0x1234567890123456789012345678901234567890",
network: "base-sepolia",
pageToken: page.nextPageToken,
});
Lists CDP EVM smart accounts.
Parameters for listing the smart accounts.
Options for listing EVM smart accounts.
Optionalname?: stringThe name of the account.
OptionalpageSize?: numberThe page size to paginate through the accounts.
OptionalpageToken?: stringThe page token to paginate through the accounts.
A promise that resolves to an array of smart accounts, and a token to paginate through the smart accounts.
Prepares a user operation for a smart account.
Parameters for preparing the user operation.
Options for preparing a user operation.
The smart account.
The smart account's address.
Optionalname?: stringThe name of the smart account.
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).
Identifier for the smart account type.
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.
A function that returns a network-scoped smart account.
// 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");
List the token balances of an account.
Requests funds from an EVM faucet.
Gets a quote to fund an EVM account.
Funds an EVM account with the specified token amount.
Waits for a fund operation to complete and returns the transfer receipt.
The options for the wait for fund operation.
The ID of the transfer to wait for.
A promise that resolves to the completed transfer receipt containing details about the funding operation.
Transfer an amount of a token from an account to another account.
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",
});
Sends a user operation.
Waits for a user operation to complete or fail.
// 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,
});
Gets a user operation by its hash.
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.
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`);
}
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.
// 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}`);
Signs a typed data message.
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",
},
},
});
Experimental! This method name will change, and is subject to other breaking changes.
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.
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.__experimental_useSpendPermission({
spendPermission,
value: parseEther("0.001"), // Spend 0.001 ETH
network: "base-sepolia",
});
The network.
The calls.
OptionalpaymasterUrl?: stringThe paymaster URL.
A promise that resolves to the user operation hash.
Requests funds from an EVM faucet.
Parameters for requesting funds from the EVM faucet.
The address to request funds for.
The network to request funds from.
The token to request funds for.
An idempotency key.
A promise that resolves to the transaction hash.
Signs an EVM transaction and sends it to the specified network using the Coinbase API. This method handles nonce management and gas estimation automatically.
Configuration options for sending the transaction.
A promise that resolves to the transaction hash.
Sending an RLP-encoded transaction
import { parseEther, serializeTransaction } from "viem";
import { baseSepolia } from "viem/chains";
const { transactionHash } = await cdp.evm.sendTransaction({
address: account.address,
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 cdp.evm.sendTransaction({
address: account.address,
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",
});
Sends a user operation.
Parameters for sending the user operation.
The smart account sending the user operation.
The network to send the user operation on.
The calls to include in the user operation.
The optional paymaster URL to use for the user operation.
An idempotency key.
A promise that resolves to an object containing the smart account address, the user operation hash, and the status of the user operation.
Signs an EVM hash.
Parameters for signing the hash.
Options for signing an EVM hash.
The address of the account.
The hash to sign.
OptionalidempotencyKey?: stringThe idempotency key.
A promise that resolves to the signature.
Signs an EIP-191 message.
Parameters for signing the message.
Options for signing an EVM message.
The address of the account.
The message to sign.
OptionalidempotencyKey?: stringThe idempotency key.
A promise that resolves to the signature.
Signs an EIP-712 message.
Parameters for signing the EIP-712 message.
A promise that resolves to the signature.
const signature = await cdp.evm.signTypedData({
address: account.address,
domain: {
name: "Permit2",
chainId: 1,
verifyingContract: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
},
types: {
EIP712Domain: [
{ name: "name", type: "string" },
{ name: "chainId", type: "uint256" },
{ name: "verifyingContract", type: "address" },
],
PermitTransferFrom: [
{ name: "permitted", type: "TokenPermissions" },
{ name: "spender", type: "address" },
{ name: "nonce", type: "uint256" },
{ name: "deadline", type: "uint256" },
],
TokenPermissions: [
{ name: "token", type: "address" },
{ name: "amount", type: "uint256" },
],
},
primaryType: "PermitTransferFrom",
message: {
permitted: {
token: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
amount: "1000000",
},
spender: "0xFfFfFfFFfFFfFFfFFfFFFFFffFFFffffFfFFFfFf",
nonce: "0",
deadline: "1717123200",
},
});
Signs an EVM transaction.
Configuration options for signing the transaction.
A promise that resolves to the signature.
import { parseEther, serializeTransaction } from "viem";
import { baseSepolia } from "viem/chains";
// Create a new EVM server account to sign with
const ethAccount = await cdp.createEvmServerAccount({});
const serializedTx = serializeTransaction(
{
chainId: baseSepolia.id,
data: "0x",
to: "0x4252e0c9A3da5A2700e7d91cb50aEf522D0C6Fe8",
type: "eip1559",
value: parseEther("0.000001"),
},
);
const signature = await cdp.evm.signTransaction({
address: ethAccount.address,
transaction: serializedTx,
});
Updates a CDP EVM account.
Optionaloptions: UpdateEvmAccountOptionsOptional parameters for creating the account.
Options for creating an EVM server account.
The address of the account.
The updates to apply to the account
OptionalidempotencyKey?: stringThe idempotency key.
A promise that resolves to the updated account.
const account = await cdp.evm.updateAccount({ address: "0x...", update: { name: "New Name" } });
const account = await cdp.evm.updateAccount({ address: "0x...", update: { accountPolicy: "73bcaeeb-d7af-4615-b064-42b5fe83a31e" } });
const idempotencyKey = uuidv4();
// First call
await cdp.evm.updateAccount({
address: "0x...",
update: { accountPolicy: "73bcaeeb-d7af-4615-b064-42b5fe83a31e" },
idempotencyKey,
});
// Second call with the same idempotency key will not update
await cdp.evm.updateAccount({
address: '0x...',
update: { name: "" },
idempotencyKey,
});
Updates a CDP EVM smart account.
Optionaloptions: UpdateEvmSmartAccountOptionsOptional parameters for updating the account.
Options for updating an EVM smart account.
The address of the account.
The updates to apply to the account
OptionalidempotencyKey?: stringThe idempotency key.
The owner of the account.
A promise that resolves to the updated account.
Waits for a user operation to complete or fail.
Parameters for waiting for the user operation.
Options for waiting for a user operation.
The smart account address.
The user operation hash.
OptionalwaitOptions?: WaitOptionsThe wait options.
A promise that resolves to the transaction receipt.
// Send a user operation and get the user operation hash
const { userOpHash } = await cdp.evm.sendUserOperation({
smartAccount,
network: "base-sepolia",
calls: [
{
to: "0x0000000000000000000000000000000000000000",
value: parseEther("0.000001"),
data: "0x",
},
],
});
// Wait for the user operation to complete or fail
const result = await cdp.evm.waitForUserOperation({
smartAccountAddress: smartAccount.address,
userOpHash: userOp.userOpHash,
});
The namespace containing all EVM methods.