@coinbase/agentkit
Advanced tools
AgentKit is a framework for easily enabling AI agents to take actions onchain. It is designed to be framework-agnostic, so you can use it with any AI framework, and wallet-agnostic, so you can use it with any wallet.
CdpWalletProvider and WalletProvider action provider.Prerequisites:
npm install @coinbase/agentkit
CdpWalletProvider and WalletProvider action provider.const agentKit = await AgentKit.from({
cdpApiKeyId: "CDP API KEY NAME",
cdpApiKeySecret: "CDP API KEY SECRET",
});
If no wallet or action provider are specified, the agent will use the CdpWalletProvider and WalletActionProvider action provider by default.
const agentKit = await AgentKit.from({
cdpApiKeyId: "CDP API KEY NAME",
cdpApiKeySecret: "CDP API KEY SECRET",
});
import { CdpWalletProvider } from "@coinbase/agentkit";
const walletProvider = await CdpWalletProvider.configureWithWallet({
apiKeyId: "CDP API KEY NAME",
apiKeyPrivate: "CDP API KEY SECRET",
networkId: "base-mainnet",
});
const agentKit = await AgentKit.from({
walletProvider,
});
import { cdpApiActionProvider, pythActionProvider } from "@coinbase/agentkit";
const agentKit = await AgentKit.from({
walletProvider,
actionProviders: [
cdpApiActionProvider({
apiKeyId: "CDP API KEY NAME",
apiKeyPrivate: "CDP API KEY SECRET",
}),
pythActionProvider(),
],
});
Prerequisites:
OPENAI_API_KEY environment variable.npm install @langchain @langchain/langgraph @langchain/openai
import { getLangChainTools } from "@coinbase/agentkit-langchain";
import { createReactAgent } from "@langchain/langgraph/prebuilt";
import { ChatOpenAI } from "@langchain/openai";
const tools = await getLangChainTools(agentKit);
const llm = new ChatOpenAI({
model: "gpt-4o-mini",
});
const agent = createReactAgent({
llm,
tools,
});
list_spend_permissions | Lists spend permissions that have been granted to the current EVM wallet by a smart account. |
use_spend_permission | Uses a spend permission to spend tokens on behalf of a smart account that the current EVM wallet has permission to spend. |
list_spend_permissions | Lists spend permissions that have been granted to the current smart wallet by a smart account. |
use_spend_permission | Uses a spend permission to spend tokens on behalf of a smart account that the current smart wallet has permission to spend. |
bridge_token | Bridges tokens between supported chains using Across Protocol. |
check_deposit_status | Checks the status of a cross-chain bridge deposit on the Across Protocol (mainnet networks only). |
register_basename | Registers a custom .base.eth or .basetest.eth domain name for the wallet address. |
supply | Supplies collateral assets (WETH, CBETH, CBBTC, WSTETH, or USDC) to Compound. |
withdraw | Withdraws previously supplied collateral assets from Compound. |
borrow | Borrows base assets (WETH or USDC) from Compound using supplied collateral. |
repay | Repays borrowed assets back to Compound. |
get_portfolio | Retrieves portfolio details including collateral balances and borrowed amounts. |
find_protocol | Searches for DeFi protocols on DefiLlama by name, returning protocol metadata including TVL, chain, and category. |
get_protocol | Fetches detailed information about a specific protocol from DefiLlama, including TVL, description, and historical data. |
get_token_prices | Fetches current token prices from DefiLlama for specified token addresses with chain prefixes. |
get_balance | Retrieves the token balance for a specified address and ERC-20 contract. |
transfer | Transfers a specified amount of ERC-20 tokens to a destination address. |
get_balance | Retrieves the NFT balance for a specified address and ERC-721 contract. |
mint | Creates a new NFT token and assigns it to a specified destination address. |
transfer | Transfers ownership of a specific NFT token to a destination address. |
account_details | Fetches profile information and metadata for the authenticated Farcaster account. |
post_cast | Creates a new cast (message) on Farcaster with up to 280 characters and support for up to 2 embedded URLs. |
flaunch | Launches a new memecoin token with customizable name, symbol, image, and metadata. |
buyCoinWithETHInput | Purchases Flaunch memecoin tokens by specifying ETH input amount with configurable slippage. |
buyCoinWithCoinInput | Purchases Flaunch memecoin tokens by specifying desired token output amount with configurable slippage. |
sellCoin | Sells Flaunch memecoin tokens back to ETH with configurable slippage. |
research_question | Queries Messari AI for comprehensive crypto research across news, market data, protocol information, and more. |
deposit | Deposits a specified amount of assets into a designated Morpho Vault. |
withdraw | Withdraws a specified amount of assets from a designated Morpho Vault. |
get_onramp_buy_url | Gets a URL to purchase cryptocurrency from Coinbase via Debit card or other payment methods. |
list_nft | Lists an NFT for sale on OpenSea. |
get_nfts_by_account | Fetches NFTs owned by a specific wallet address on OpenSea. |
fetch_price | Retrieves current price data from a specified Pyth price feed. |
fetch_price_feed_id | Retrieves the unique price feed identifier for a given token symbol. |
account_details | Fetches profile information and metadata for the authenticated Twitter account. |
account_mentions | Retrieves recent mentions and interactions for the authenticated account. |
post_tweet | Creates a new tweet on the authenticated Twitter account. |
post_tweet_reply | Creates a reply to an existing tweet using the tweet's unique identifier. |
upload_media | Uploads media (images, videos) to Twitter that can be attached to tweets. |
get_active_markets | Retrieves active prediction markets from Truemarkets with pagination and sorting options. |
get_market_details | Fetches comprehensive details for a specific Truemarkets prediction market including question, status, prices, and liquidity. |
get_wallet_details | Retrieves wallet address, network info, balances, and provider details. |
native_transfer | Transfers native blockchain tokens (e.g., ETH) to a destination address. |
wrap_eth | Converts native ETH to Wrapped ETH (WETH) on Base Sepolia or Base Mainnet. |
unwrap_eth | Converts Wrapped ETH (WETH) to Native ETH on Base Sepolia or Base Mainnet. |
buy_token | Purchases WOW tokens from a contract using ETH based on bonding curve pricing. |
create_token | Creates a new WOW memecoin with bonding curve functionality via Zora factory. |
sell_token | Sells WOW tokens back to the contract for ETH based on bonding curve pricing. |
swap | Swap tokens on Solana using the Jupiter DEX aggregator. |
make_http_request | Makes a basic HTTP request to an API endpoint. If the endpoint requires payment (returns 402), it will return payment details that can be used on retry. |
retry_http_request_with_x402 | Retries an HTTP request with x402 payment after receiving a 402 Payment Required response. |
make_http_request_with_x402 | Combines make_http_request and retry_http_request_with_x402 into a single step. |
getPortfolioOverview | Fetches and summarizes a crypto wallet's portfolio in USD. |
getFungiblePositions | Retrieves and summarizes a wallet's fungible token holdings (including DeFi positions) |
getCAB | Retrieves chain abstracted balances (CAB) for specified tokens across multiple networks. |
coinIt | Creates a new Zora coin with customizable name, symbol, description, and image. |
Action providers are used to define the actions that an agent can take. They are defined as a class that extends the ActionProvider abstract class.
import { ActionProvider, WalletProvider, Network } from "@coinbase/agentkit";
// Define an action provider that uses a wallet provider.
class MyActionProvider extends ActionProvider<WalletProvider> {
constructor() {
super("my-action-provider", []);
}
// Define if the action provider supports the given network
supportsNetwork = (network: Network) => true;
}
Actions are defined as instance methods on the action provider class with the @CreateAction decorator. Actions can use a wallet provider or not and always return a Promise that resolves to a string.
Creating actions with the @CreateAction decorator requires the following compilerOptions to be included in your project's tsconfig.json.
{
"compilerOptions": {
"experimentalDecorators": true,
"emitDecoratorMetadata": true
}
}
zod library.import { z } from "zod";
export const MyActionSchema = z.object({
myField: z.string(),
});
import { ActionProvider, WalletProvider, Network, CreateAction } from "@coinbase/agentkit";
class MyActionProvider extends ActionProvider<WalletProvider> {
constructor() {
super("my-action-provider", []);
}
@CreateAction({
name: "my-action",
description: "My action description",
schema: MyActionSchema,
})
async myAction(args: z.infer<typeof MyActionSchema>): Promise<string> {
return args.myField;
}
supportsNetwork = (network: Network) => true;
}
export const myActionProvider = () => new MyActionProvider();
Actions that use a wallet provider can be defined as instance methods on the action provider class with the @CreateAction decorator that have a WalletProvider as the first parameter.
class MyActionProvider extends ActionProvider<WalletProvider> {
constructor() {
super("my-action-provider", []);
}
@CreateAction({
name: "my-action",
description: "My action description",
schema: MyActionSchema,
})
async myAction(
walletProvider: WalletProvider,
args: z.infer<typeof MyActionSchema>,
): Promise<string> {
return walletProvider.signMessage(args.myField);
}
supportsNetwork = (network: Network) => true;
}
This gives your agent access to the actions defined in the action provider.
const agentKit = new AgentKit({
cdpApiKeyId: "CDP API KEY NAME",
cdpApiKeySecret: "CDP API KEY SECRET",
actionProviders: [myActionProvider()],
});
Wallet providers give an agent access to a wallet. AgentKit currently supports the following wallet providers:
EVM:
The CdpEvmWalletProvider is a wallet provider that uses the Coinbase Developer Platform (CDP) v2 Wallet API. It provides a more modern and streamlined interface for interacting with CDP wallets.
import { CdpEvmWalletProvider } from "@coinbase/agentkit";
const walletProvider = await CdpEvmWalletProvider.configureWithWallet({
apiKeyId: "CDP_API_KEY_ID",
apiKeySecret: "CDP_API_KEY_SECRET",
walletSecret: "CDP_WALLET_SECRET",
networkId: "base-sepolia", // Optional, defaults to "base-sepolia"
});
You can configure the provider with an existing wallet by providing the wallet's address:
import { CdpEvmWalletProvider } from "@coinbase/agentkit";
const walletProvider = await CdpEvmWalletProvider.configureWithWallet({
apiKeyId: "CDP_API_KEY_ID",
apiKeySecret: "CDP_API_KEY_SECRET",
walletSecret: "CDP_WALLET_SECRET",
address: "0x...", // The address of an existing wallet
networkId: "base-sepolia",
});
To create a new wallet, you can provide an idempotency key. The same idempotency key will always generate the same wallet address, and these keys are valid for 24 hours:
import { CdpEvmWalletProvider } from "@coinbase/agentkit";
const walletProvider = await CdpEvmWalletProvider.configureWithWallet({
apiKeyId: "CDP_API_KEY_ID",
apiKeySecret: "CDP_API_KEY_SECRET",
walletSecret: "CDP_WALLET_SECRET",
idempotencyKey: "unique-key-123", // Optional, if not provided a new wallet will be created
networkId: "base-sepolia",
});
The provider can also be configured using environment variables:
// Environment variables:
// CDP_API_KEY_ID=your_api_key_id
// CDP_API_KEY_SECRET=your_api_key_secret
// CDP_WALLET_SECRET=your_wallet_secret
// NETWORK_ID=base-sepolia (optional)
// IDEMPOTENCY_KEY=unique-key-123 (optional)
const walletProvider = await CdpEvmWalletProvider.configureWithWallet();
The CdpEvmWalletProvider can export a wallet by calling the exportWallet method:
const walletData = await walletProvider.exportWallet();
The CdpSmartWalletProvider is a wallet provider that uses the Coinbase Developer Platform (CDP) Smart Wallets. Smart wallets are ERC-4337 compliant smart contract wallets that provide enhanced features like gasless transactions, batch operations, and account recovery.
Note: Smart wallets are currently only supported on Base networks (base-sepolia and base-mainnet).
import { CdpSmartWalletProvider } from "@coinbase/agentkit";
const walletProvider = await CdpSmartWalletProvider.configureWithWallet({
apiKeyId: "CDP_API_KEY_ID",
apiKeySecret: "CDP_API_KEY_SECRET",
walletSecret: "CDP_WALLET_SECRET",
networkId: "base-sepolia", // Optional, defaults to "base-sepolia"
});
You can configure the provider with an existing smart wallet by providing either the wallet's address or name:
import { CdpSmartWalletProvider } from "@coinbase/agentkit";
// Using smart wallet address
const walletProvider = await CdpSmartWalletProvider.configureWithWallet({
apiKeyId: "CDP_API_KEY_ID",
apiKeySecret: "CDP_API_KEY_SECRET",
walletSecret: "CDP_WALLET_SECRET",
address: "0x...", // The address of an existing smart wallet
networkId: "base-sepolia",
});
// Or using smart wallet name
const walletProvider = await CdpSmartWalletProvider.configureWithWallet({
apiKeyId: "CDP_API_KEY_ID",
apiKeySecret: "CDP_API_KEY_SECRET",
walletSecret: "CDP_WALLET_SECRET",
smartAccountName: "my-smart-wallet", // The name of an existing smart wallet
networkId: "base-sepolia",
});
Smart wallets require an owner account. You can specify an existing owner account by providing its address or the account object itself:
import { CdpSmartWalletProvider } from "@coinbase/agentkit";
// Using owner address
const walletProvider = await CdpSmartWalletProvider.configureWithWallet({
apiKeyId: "CDP_API_KEY_ID",
apiKeySecret: "CDP_API_KEY_SECRET",
walletSecret: "CDP_WALLET_SECRET",
owner: "0x...", // The address of the owner account
networkId: "base-sepolia",
});
// Using owner account object
const walletProvider = await CdpSmartWalletProvider.configureWithWallet({
apiKeyId: "CDP_API_KEY_ID",
apiKeySecret: "CDP_API_KEY_SECRET",
walletSecret: "CDP_WALLET_SECRET",
owner: ownerAccount, // An EvmServerAccount or PrivateKeyAccount object
networkId: "base-sepolia",
});
To create a new smart wallet, provide an idempotency key. The same idempotency key will always generate the same owner account address, and these keys are valid for 24 hours:
import { CdpSmartWalletProvider } from "@coinbase/agentkit";
const walletProvider = await CdpSmartWalletProvider.configureWithWallet({
apiKeyId: "CDP_API_KEY_ID",
apiKeySecret: "CDP_API_KEY_SECRET",
walletSecret: "CDP_WALLET_SECRET",
idempotencyKey: "unique-key-123", // Optional, if not provided a new owner account will be created
networkId: "base-sepolia",
});
The provider can also be configured using environment variables:
// Environment variables:
// CDP_API_KEY_ID=your_api_key_id
// CDP_API_KEY_SECRET=your_api_key_secret
// CDP_WALLET_SECRET=your_wallet_secret
// NETWORK_ID=base-sepolia (optional)
// IDEMPOTENCY_KEY=unique-key-123 (optional)
const walletProvider = await CdpSmartWalletProvider.configureWithWallet();
The CdpSmartWalletProvider can export wallet information by calling the exportWallet method:
const walletData = await walletProvider.exportWallet();
// walletData will be in the following format:
{
name: string | undefined; // The smart wallet name (if set)
address: string; // The smart wallet address
ownerAddress: string; // The owner account address
}
The LegacyCdpWalletProvider is a wallet provider that uses the Coinbase Developer Platform (CDP) v1 Wallet API.
The LegacyCdpWalletProvider can be configured to use a specific network by passing the networkId parameter to the configureWithWallet method. The networkId is the ID of the network you want to use. You can find a list of supported networks on the CDP API docs.
import { LegacyCdpWalletProvider } from "@coinbase/agentkit";
const walletProvider = await CdpWalletProvider.configureWithWallet({
apiKeyId: "CDP API KEY NAME",
apiKeyPrivate: "CDP API KEY SECRET",
networkId: "base-mainnet",
});
If you already have a CDP API Wallet, you can configure the LegacyCdpWalletProvider by passing the wallet parameter to the configureWithWallet method.
import { LegacyCdpWalletProvider } from "@coinbase/agentkit";
import { Wallet } from "@coinbase/coinbase-sdk";
const walletProvider = await LegacyCdpWalletProvider.configureWithWallet({
wallet,
apiKeyId: "CDP API KEY NAME",
apiKeyPrivate: "CDP API KEY SECRET",
});
The LegacyCdpWalletProvider can be configured from a mnemonic phrase by passing the mnemonicPhrase and networkId parameters to the configureWithWallet method. If networkId is not defined, the LegacyCdpWalletProvider will fall back to the env var NETWORK_ID, and if that is not defined, it will default to base-sepolia.
import { LegacyCdpWalletProvider } from "@coinbase/agentkit";
const walletProvider = await LegacyCdpWalletProvider.configureWithWallet({
mnemonicPhrase: "MNEMONIC PHRASE",
networkId: "base-sepolia",
});
The LegacyCdpWalletProvider can export a wallet by calling the exportWallet method.
import { LegacyCdpWalletProvider } from "@coinbase/agentkit";
const walletProvider = await LegacyCdpWalletProvider.configureWithWallet({
mnemonicPhrase: "MNEMONIC PHRASE",
networkId: "base-sepolia",
});
const walletData = await walletProvider.exportWallet();
WalletData JSON stringThe LegacyCdpWalletProvider can import a wallet from a WalletData JSON string by passing the cdpWalletData parameter to the configureWithWallet method.
import { LegacyCdpWalletProvider } from "@coinbase/agentkit";
const walletProvider = await LegacyCdpWalletProvider.configureWithWallet({
cdpWalletData: "WALLET DATA JSON STRING",
apiKeyId: "CDP API KEY NAME",
apiKeyPrivate: "CDP API KEY SECRET",
});
The LegacyCdpWalletProvider also exposes parameters for effecting the gas calculations.
import { LegacyCdpWalletProvider } from "@coinbase/agentkit";
const walletProvider = await LegacyCdpWalletProvider.configureWithWallet({
cdpWalletData: "WALLET DATA JSON STRING",
apiKeyId: "CDP API KEY NAME",
apiKeyPrivate: "CDP API KEY SECRET",
gas: {
gasLimitMultiplier: 2.0, // Adjusts gas limit estimation
feePerGasMultiplier: 2.0, // Adjusts max fee per gas
},
});
Note: Gas parameters only impact the walletProvider.sendTransaction behavior. Actions that do not rely on direct transaction calls, such as deploy_token, deploy_contract, and native_transfer, remain unaffected.
The ViemWalletProvider is a wallet provider that uses the Viem library. It is useful for interacting with any EVM-compatible chain.
import { ViemWalletProvider } from "@coinbase/agentkit";
import { privateKeyToAccount } from "viem/accounts";
import { baseSepolia } from "viem/chains";
import { http } from "viem/transports";
import { createWalletClient } from "viem";
const account = privateKeyToAccount(
"0x4c0883a69102937d6231471b5dbb6208ffd70c02a813d7f2da1c54f2e3be9f38",
);
const client = createWalletClient({
account,
chain: baseSepolia,
transport: http(),
});
const walletProvider = new ViemWalletProvider(client);
The ViemWalletProvider also exposes parameters for effecting the gas calculations.
import { ViemWalletProvider } from "@coinbase/agentkit";
import { privateKeyToAccount } from "viem/accounts";
import { baseSepolia } from "viem/chains";
import { http } from "viem/transports";
import { createWalletClient } from "viem";
const account = privateKeyToAccount(
"0x4c0883a69102937d6231471b5dbb6208ffd70c02a813d7f2da1c54f2e3be9f38",
);
const client = createWalletClient({
account,
chain: baseSepolia,
transport: http(),
});
const walletProvider = new ViemWalletProvider(client, {
gasLimitMultiplier: 2.0, // Adjusts gas limit estimation
feePerGasMultiplier: 2.0, // Adjusts max fee per gas
});
The PrivyWalletProvider is a wallet provider that uses Privy Server Wallets or Privy Embedded Wallets. This implementation extends the EvmWalletProvider.
import { PrivyWalletProvider } from "@coinbase/agentkit";
// Configure Server Wallet Provider
const config = {
appId: "PRIVY_APP_ID",
appSecret: "PRIVY_APP_SECRET",
chainId: "84532", // base-sepolia
walletId: "PRIVY_WALLET_ID", // optional, otherwise a new wallet will be created
authorizationPrivateKey: "PRIVY_WALLET_AUTHORIZATION_PRIVATE_KEY", // optional, required if your account is using authorization keys
authorizationKeyId: "PRIVY_WALLET_AUTHORIZATION_KEY_ID", // optional, only required to create a new wallet if walletId is not provided
};
const walletProvider = await PrivyWalletProvider.configureWithWallet(config);
You can also use Privy's embedded wallets with delegation for agent actions. This allows your agent to use wallets that have been delegated transaction signing authority by users.
import { PrivyWalletProvider } from "@coinbase/agentkit";
// Configure Embedded Wallet Provider
const config = {
appId: "PRIVY_APP_ID",
appSecret: "PRIVY_APP_SECRET",
authorizationPrivateKey: "PRIVY_WALLET_AUTHORIZATION_PRIVATE_KEY",
walletId: "PRIVY_DELEGATED_WALLET_ID", // The ID of the wallet that was delegated to your server
networkId: "base-mainnet", // or any supported network
walletType: "embedded", // Specify "embedded" to use the embedded wallet provider
};
const walletProvider = await PrivyWalletProvider.configureWithWallet(config);
Before using this wallet provider, you need to:
For more information on setting up Privy and enabling delegated actions, see Privy's documentation.
The PrivyEvmDelegatedEmbeddedWalletProvider supports all standard wallet operations including transaction signing, message signing, and native transfers, using the wallet that was delegated to your server.
Privy offers the option to use authorization keys to secure your server wallets.
You can manage authorization keys from your Privy dashboard.
When using authorization keys, you must provide the authorizationPrivateKey and authorizationKeyId parameters to the configureWithWallet method if you are creating a new wallet. Please note that when creating a key, if you enable "Create and modify wallets", you will be required to use that key when creating new wallets via the PrivyWalletProvider.
The PrivyWalletProvider can export wallet information by calling the exportWallet method.
const walletData = await walletProvider.exportWallet();
// For server wallets, walletData will be in the following format:
{
walletId: string;
authorizationKey: string | undefined;
chainId: string | undefined;
}
// For embedded wallets, walletData will be in the following format:
{
walletId: string;
networkId: string;
chainId: string | undefined;
}
The SmartWalletProvider is a wallet provider that uses CDP Smart Wallets.
import { SmartWalletProvider, SmartWalletConfig } from "@coinbase/agentkit";
import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
const networkId = process.env.NETWORK_ID || "base-sepolia";
const privateKey = process.env.PRIVATE_KEY || generatePrivateKey();
const signer = privateKeyToAccount(privateKey);
// Configure Wallet Provider
const walletProvider = await SmartWalletProvider.configureWithWallet({
networkId,
signer,
smartWalletAddress: undefined, // If not provided a new smart wallet will be created
paymasterUrl: undefined, // Sponsor transactions: https://docs.cdp.coinbase.com/paymaster/docs/welcome
});
The ZeroDevWalletProvider is a wallet provider that uses ZeroDev smart accounts. It supports features like chain abstraction, gasless transactions, batched transactions, and more.
In the context of Agent Kit, "chain abstraction" means that the agent can spend funds across chains without explicitly bridging. For example, if you send funds to the agent's address on Base, the agent will be able to spend the funds on any supported EVM chains such as Arbitrum and Optimism.
The ZeroDev wallet provider does not itself manage keys. Rather, it can be used with any EVM wallet provider (e.g. CDP/Privy/Viem) which serves as the "signer" for the ZeroDev smart account.
import { ZeroDevWalletProvider, CdpWalletProvider } from "@coinbase/agentkit";
// First create a CDP wallet provider as the signer
const cdpWalletProvider = await CdpWalletProvider.configureWithWallet({
apiKeyId: "CDP API KEY NAME",
apiKeyPrivate: "CDP API KEY SECRET",
networkId: "base-mainnet",
});
// Configure ZeroDev Wallet Provider with CDP signer
const walletProvider = await ZeroDevWalletProvider.configureWithWallet({
signer: cdpWalletProvider.toSigner(),
projectId: "ZERODEV_PROJECT_ID",
entryPointVersion: "0.7" as const,
networkId: "base-mainnet",
});
import { ZeroDevWalletProvider, PrivyWalletProvider } from "@coinbase/agentkit";
// First create a Privy wallet provider as the signer
const privyWalletProvider = await PrivyWalletProvider.configureWithWallet({
appId: "PRIVY_APP_ID",
appSecret: "PRIVY_APP_SECRET",
chainId: "8453", // base-mainnet
});
// Configure ZeroDev Wallet Provider with Privy signer
const walletProvider = await ZeroDevWalletProvider.configureWithWallet({
signer: privyWalletProvider.toSigner(),
projectId: "ZERODEV_PROJECT_ID",
entryPointVersion: "0.7" as const,
networkId: "base-mainnet",
});
import { ZeroDevWalletProvider, ViemWalletProvider } from "@coinbase/agentkit";
import { privateKeyToAccount } from "viem/accounts";
import { base } from "viem/chains";
import { createWalletClient, http } from "viem";
// First create a Viem wallet provider as the signer
const account = privateKeyToAccount("PRIVATE_KEY");
const viemWalletProvider = new ViemWalletProvider(
createWalletClient({
account,
chain: base,
transport: http(),
}),
);
// Configure ZeroDev Wallet Provider with Viem signer
const walletProvider = await ZeroDevWalletProvider.configureWithWallet({
signer: viemWalletProvider.toSigner(),
projectId: "ZERODEV_PROJECT_ID",
entryPointVersion: "0.7" as const,
networkId: "base-mainnet",
});
Wallet providers give an agent access to a wallet. AgentKit currently supports the following wallet providers:
SVM:
The CdpV2SolanaWalletProvider is a wallet provider that uses the Coinbase Developer Platform (CDP) V2 API for Solana. It provides a more modern and streamlined interface for interacting with CDP wallets on the Solana network.
import { CdpV2SolanaWalletProvider } from "@coinbase/agentkit";
const walletProvider = await CdpV2SolanaWalletProvider.configureWithWallet({
apiKeyId: "CDP_API_KEY_ID",
apiKeySecret: "CDP_API_KEY_SECRET",
walletSecret: "CDP_WALLET_SECRET",
networkId: "solana-devnet", // Optional, defaults to "solana-devnet"
});
You can configure the provider with an existing wallet by providing the wallet's address:
import { CdpV2SolanaWalletProvider } from "@coinbase/agentkit";
const walletProvider = await CdpV2SolanaWalletProvider.configureWithWallet({
apiKeyId: "CDP_API_KEY_ID",
apiKeySecret: "CDP_API_KEY_SECRET",
walletSecret: "CDP_WALLET_SECRET",
address: "your-solana-address", // The address of an existing wallet
networkId: "solana-devnet",
});
To create a new wallet, you can provide an idempotency key. The same idempotency key will always generate the same wallet address, and these keys are valid for 24 hours:
import { CdpV2SolanaWalletProvider } from "@coinbase/agentkit";
const walletProvider = await CdpV2SolanaWalletProvider.configureWithWallet({
apiKeyId: "CDP_API_KEY_ID",
apiKeySecret: "CDP_API_KEY_SECRET",
walletSecret: "CDP_WALLET_SECRET",
idempotencyKey: "unique-key-123", // Optional, if not provided a new wallet will be created
networkId: "solana-devnet",
});
The provider can also be configured using environment variables:
// Environment variables:
// CDP_API_KEY_ID=your_api_key_id
// CDP_API_KEY_SECRET=your_api_key_secret
// CDP_WALLET_SECRET=your_wallet_secret
// NETWORK_ID=solana-devnet (optional)
// IDEMPOTENCY_KEY=unique-key-123 (optional)
const walletProvider = await CdpV2SolanaWalletProvider.configureWithWallet();
The CdpV2SolanaWalletProvider supports the following Solana networks:
solana-mainnetsolana-devnetsolana-testnetThe SolanaKeypairWalletProvider is a wallet provider that uses the API Solana web3.js.
NOTE: It is highly recommended to use a dedicated RPC provider. See here for more info on Solana RPC infrastructure, and see here for instructions on configuring SolanaKeypairWalletProvider with a custom RPC URL.
The SolanaKeypairWalletProvider can be configured to use a specific network by passing the networkId parameter to the fromNetwork method. The networkId is the ID of the Solana network you want to use. Valid values are solana-mainnet, solana-devnet and solana-testnet.
The default RPC endpoints for each network are as follows:
solana-mainnet: https://api.mainnet-beta.solana.comsolana-devnet: https://api.devnet.solana.comsolana-testnet: https://api.testnet.solana.comimport { SOLANA_NETWORK_ID, SolanaKeypairWalletProvider } from "@coinbase/agentkit";
// Configure Solana Keypair Wallet Provider
const privateKey = process.env.SOLANA_PRIVATE_KEY;
const network = process.env.NETWORK_ID as SOLANA_NETWORK_ID;
const walletProvider = await SolanaKeypairWalletProvider.fromNetwork(network, privateKey);
The SolanaKeypairWalletProvider can be configured to use a specific RPC url by passing the rpcUrl parameter to the fromRpcUrl method. The rpcUrl will determine the network you are using.
import { SOLANA_NETWORK_ID, SolanaKeypairWalletProvider } from "@coinbase/agentkit";
// Configure Solana Keypair Wallet Provider
const privateKey = process.env.SOLANA_PRIVATE_KEY;
const rpcUrl = process.env.SOLANA_RPC_URL;
const walletProvider = await SolanaKeypairWalletProvider.fromRpcUrl(network, privateKey);
The PrivyWalletProvider is a wallet provider that uses Privy Server Wallets.
NOTE: It is highly recommended to use a dedicated RPC provider. See here for more info on Solana RPC infrastructure, and see here for instructions on configuring PrivyWalletProvider with a custom RPC URL.
import { PrivyWalletProvider, PrivyWalletConfig } from "@coinbase/agentkit";
// Configure Wallet Provider
const config: PrivyWalletConfig = {
appId: "PRIVY_APP_ID",
appSecret: "PRIVY_APP_SECRET",
connection,
chainType: "solana", // optional, defaults to "evm". Make sure to set this to "solana" if you want to use Solana!
networkId: "solana-devnet", // optional, defaults to "solana-devnet"
walletId: "PRIVY_WALLET_ID", // optional, otherwise a new wallet will be created
authorizationPrivateKey: PRIVY_WALLET_AUTHORIZATION_PRIVATE_KEY, // optional, required if your account is using authorization keys
authorizationKeyId: PRIVY_WALLET_AUTHORIZATION_KEY_ID, // optional, only required to create a new wallet if walletId is not provided
};
const walletProvider = await PrivyWalletProvider.configureWithWallet(config);
Optionally, you can configure your own @solana/web3.js connection by passing the connection parameter to the configureWithWallet method.
import { PrivyWalletProvider, PrivyWalletConfig } from "@coinbase/agentkit";
const connection = new Connection("YOUR_RPC_URL");
// Configure Wallet Provider
const config: PrivyWalletConfig = {
appId: "PRIVY_APP_ID",
appSecret: "PRIVY_APP_SECRET",
connection,
chainType: "solana", // optional, defaults to "evm". Make sure to set this to "solana" if you want to use Solana!
networkId: "solana-devnet", // optional, defaults to "solana-devnet"
walletId: "PRIVY_WALLET_ID", // optional, otherwise a new wallet will be created
authorizationPrivateKey: PRIVY_WALLET_AUTHORIZATION_PRIVATE_KEY, // optional, required if your account is using authorization keys
authorizationKeyId: PRIVY_WALLET_AUTHORIZATION_KEY_ID, // optional, only required to create a new wallet if walletId is not provided
};
const walletProvider = await PrivyWalletProvider.configureWithWallet(config);
Privy offers the option to use authorization keys to secure your server wallets.
You can manage authorization keys from your Privy dashboard.
When using authorization keys, you must provide the authorizationPrivateKey and authorizationKeyId parameters to the configureWithWallet method if you are creating a new wallet. Please note that when creating a key, if you enable "Create and modify wallets", you will be required to use that key when creating new wallets via the PrivyWalletProvider.
The PrivyWalletProvider can export wallet information by calling the exportWallet method.
const walletData = await walletProvider.exportWallet();
// walletData will be in the following format:
{
walletId: string;
authorizationKey: string | undefined;
networkId: string | undefined;
}
See CONTRIBUTING.md for more information.
FAQs
Coinbase AgentKit core primitives
The npm package @coinbase/agentkit receives a total of 1,893 weekly downloads. As such, @coinbase/agentkit popularity was classified as popular.
We found that @coinbase/agentkit demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 2 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
This episode explores the hard problem of reachability analysis, from static analysis limits to handling dynamic languages and massive dependency trees.
Security News
/Research
Malicious Nx npm versions stole secrets and wallet info using AI CLI tools; Socket’s AI scanner detected the supply chain attack and flagged the malware.
Security News
CISA’s 2025 draft SBOM guidance adds new fields like hashes, licenses, and tool metadata to make software inventories more actionable.