Agentkit

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.

Table of Contents

- Agentkit
- Getting Started
- Installation
- Usage
- Create an AgentKit instance
- Create an AgentKit instance with a specified wallet provider
- Create an AgentKit instance with a specified action providers
- Use the agent's actions with a framework extension. For example, using LangChain + OpenAI
- Action Providers
- Creating an Action Provider
- Adding Actions to your Action Provider
- Adding Actions to your Action Provider that use a Wallet Provider
- Adding an Action Provider to your AgentKit instance
- EVM Wallet Providers
- CdpWalletProvider
- Network Configuration
- Configuring from an existing CDP API Wallet
- Configuring from a mnemonic phrase
- Exporting a wallet
- Importing a wallet from WalletData JSON string
- Configuring gas parameters
- ViemWalletProvider
- Configuring gas parameters
- PrivyWalletProvider
- Authorization Keys
- Exporting Privy Wallet information
- SmartWalletProvider
- SVM Wallet Providers
- SolanaKeypairWalletProvider
- Network Configuration
- RPC URL Configuration
- PrivyWalletProvider
- Connection Configuration
- Authorization Keys
- Exporting Privy Wallet information
- Contributing

Getting Started

Prerequisites:
- Node.js 18+
- CDP Secret API Key

Installation

``bash
npm install @coinbase/agentkit
`

Usage

$3

`typescript
const agentKit = await AgentKit.from({
cdpApiKeyName: "CDP API KEY NAME",
cdpApiKeyPrivate: "CDP API KEY PRIVATE KEY",
});
`

$3

If no wallet or action provider are specified, the agent will use the CdpWalletProvider and WalletActionProvider action provider by default.

`typescript
const agentKit = await AgentKit.from({
cdpApiKeyName: "CDP API KEY NAME",
cdpApiKeyPrivate: "CDP API KEY PRIVATE KEY",
});
`

$3

`typescript
import { CdpWalletProvider } from "@coinbase/agentkit";

const walletProvider = await CdpWalletProvider.configureWithWallet({
apiKeyName: "CDP API KEY NAME",
apiKeyPrivate: "CDP API KEY PRIVATE KEY",
networkId: "base-mainnet",
});

const agentKit = await AgentKit.from({
walletProvider,
});
`

$3

`typescript
import { cdpApiActionProvider, pythActionProvider } from "@coinbase/agentkit";

const agentKit = await AgentKit.from({
walletProvider,
actionProviders: [
cdpApiActionProvider({
apiKeyName: "CDP API KEY NAME",
apiKeyPrivate: "CDP API KEY PRIVATE KEY",
}),
pythActionProvider(),
],
});
`

$3

Prerequisites:
- OpenAI API Key
- Set OPENAI_API_KEY environment variable.

`bash
npm install @langchain @langchain/langgraph @langchain/openai
`

`typescript
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,
});
`

Action Providers

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.

`typescript
import { ActionProvider, WalletProvider, Network } from "@coinbase/agentkit";

// Define an action provider that uses a wallet provider.
class MyActionProvider extends ActionProvider {
constructor() {
super("my-action-provider", []);
}

// Define if the action provider supports the given network
supportsNetwork = (network: Network) => true;
}
`

$3

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.

#### Required Typescript Compiler Options

Creating actions with the @CreateAction decorator requires the following compilerOptions to be included in your project's tsconfig.json.

`json
{
"compilerOptions": {
"experimentalDecorators": true,
"emitDecoratorMetadata": true
}
}
`

#### Steps to create an action

1. Define the action schema. Action schemas are defined using the zod library.

`typescript
import { z } from "zod";

export const MyActionSchema = z.object({
myField: z.string(),
});
`

2. Define the action.

`typescript
import { ActionProvider, WalletProvider, Network, CreateAction } from "@coinbase/agentkit";

class MyActionProvider extends ActionProvider {
constructor() {
super("my-action-provider", []);
}

@CreateAction({
name: "my-action",
description: "My action description",
schema: MyActionSchema,
})
async myAction(args: z.infer): Promise {
return args.myField;
}

supportsNetwork = (network: Network) => true;
}

export const myActionProvider = () => new MyActionProvider();
`

#### Adding Actions to your Action Provider that use a Wallet Provider

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.

`typescript
class MyActionProvider extends ActionProvider {
constructor() {
super("my-action-provider", []);
}

@CreateAction({
name: "my-action",
description: "My action description",
schema: MyActionSchema,
})
async myAction(walletProvider: WalletProvider, args: z.infer): Promise {
return walletProvider.signMessage(args.myField);
}

supportsNetwork = (network: Network) => true;
}
`

$3

This gives your agent access to the actions defined in the action provider.

`typescript
const agentKit = new AgentKit({
cdpApiKeyName: "CDP API KEY NAME",
cdpApiKeyPrivate: "CDP API KEY PRIVATE KEY",
actionProviders: [myActionProvider()],
});
`

EVM Wallet Providers

Wallet providers give an agent access to a wallet. AgentKit currently supports the following wallet providers:

EVM:
- CdpWalletProvider
- ViemWalletProvider
- PrivyWalletProvider

$3

The CdpWalletProvider is a wallet provider that uses the Coinbase Developer Platform (CDP) API Wallet.

#### Network Configuration

The CdpWalletProvider 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.

`typescript
import { CdpWalletProvider } from "@coinbase/agentkit";

const walletProvider = await CdpWalletProvider.configureWithWallet({
apiKeyName: "CDP API KEY NAME",
apiKeyPrivate: "CDP API KEY PRIVATE KEY",
networkId: "base-mainnet",
});
`

#### Configuring from an existing CDP API Wallet

If you already have a CDP API Wallet, you can configure the CdpWalletProvider by passing the wallet parameter to the configureWithWallet method.

`typescript
import { CdpWalletProvider } from "@coinbase/agentkit";
import { Wallet } from "@coinbase/coinbase-sdk";
const walletProvider = await CdpWalletProvider.configureWithWallet({
wallet,
apiKeyName: "CDP API KEY NAME",
apiKeyPrivate: "CDP API KEY PRIVATE KEY",
});
`

#### Configuring from a mnemonic phrase

The CdpWalletProvider can be configured from a mnemonic phrase by passing the mnemonicPhrase and networkId parameters to the configureWithWallet method. If networkId is not defined, the CdpWalletProvider will fall back to the env var NETWORK_ID, and if that is not defined, it will default to base-sepolia.

`typescript
import { CdpWalletProvider } from "@coinbase/agentkit";

const walletProvider = await CdpWalletProvider.configureWithWallet({
mnemonicPhrase: "MNEMONIC PHRASE",
networkId: "base-sepolia",
});
`

#### Exporting a wallet

The CdpWalletProvider can export a wallet by calling the exportWallet method.

`typescript
import { CdpWalletProvider } from "@coinbase/agentkit";

const walletProvider = await CdpWalletProvider.configureWithWallet({
mnemonicPhrase: "MNEMONIC PHRASE",
networkId: "base-sepolia",
});

const walletData = await walletProvider.exportWallet();
`

#### Importing a wallet from WalletData JSON string

The CdpWalletProvider can import a wallet from a WalletData JSON string by passing the cdpWalletData parameter to the configureWithWallet method.

`typescript
import { CdpWalletProvider } from "@coinbase/agentkit";

const walletProvider = await CdpWalletProvider.configureWithWallet({
cdpWalletData: "WALLET DATA JSON STRING",
apiKeyName: "CDP API KEY NAME",
apiKeyPrivate: "CDP API KEY PRIVATE KEY",
});
`

#### Configuring CdpWalletProvider gas parameters

The CdpWalletProvider also exposes parameters for effecting the gas calculations.

`typescript
import { CdpWalletProvider } from "@coinbase/agentkit";

const walletProvider = await CdpWalletProvider.configureWithWallet({
cdpWalletData: "WALLET DATA JSON STRING",
apiKeyName: "CDP API KEY NAME",
apiKeyPrivate: "CDP API KEY PRIVATE KEY",
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.

$3

The ViemWalletProvider is a wallet provider that uses the Viem library. It is useful for interacting with any EVM-compatible chain.

`typescript
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);
`

#### Configuring ViemWalletProvider gas parameters

The ViemWalletProvider also exposes parameters for effecting the gas calculations.

`typescript
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
});
`

$3

The PrivyWalletProvider is a wallet provider that uses Privy Server Wallets or Privy Embedded Wallets. This implementation extends the EvmWalletProvider.

#### Server Wallet Configuration

`typescript
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);
`

#### Delegated Embedded Wallet Configuration

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.

`typescript
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);
`

$3

Before using this wallet provider, you need to:

1. Set up Privy in your application
2. Enable server delegated actions
3. Have users delegate permissions to your server
4. Obtain the delegated wallet ID

For more information on setting up Privy and enabling delegated actions, see Privy's documentation.

$3

The PrivyEvmDelegatedEmbeddedWalletProvider supports all standard wallet operations including transaction signing, message signing, and native transfers, using the wallet that was delegated to your server.

#### Authorization Keys

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.

#### Exporting Privy Wallet information

The PrivyWalletProvider can export wallet information by calling the exportWallet method.

`typescript
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;
}
`

$3

The SmartWalletProvider is a wallet provider that uses CDP Smart Wallets.

`typescript
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
});
`

SVM Wallet Providers

SVM:
- SolanaKeypairWalletProvider
- PrivyWalletProvider

$3

The 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.

#### Solana Network Configuration

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.com
- solana-devnet: https://api.devnet.solana.com
- solana-testnet: https://api.testnet.solana.com

`typescript
import { 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);
`

#### RPC URL Configuration

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.

`typescript
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);
`

$3

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.

`typescript
import { PrivyWalletProvider, PrivyWalletConfig } from "@coinbase/agentkit";

// Configure Wallet Provider
const config: PrivyWalletConfig = {
appId: "PRIVY_APP_ID",
appSecret: "PRIVY_APP_SECRET",
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);
`

#### Connection Configuration

Optionally, you can configure your own @solana/web3.js connection by passing the connection parameter to the configureWithWallet method.

`typescript
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);
`

#### Authorization Keys

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.

#### Exporting Privy Wallet information

The PrivyWalletProvider can export wallet information by calling the exportWallet method.

`typescript
const walletData = await walletProvider.exportWallet();

// walletData will be in the following format:
{
walletId: string;
authorizationKey: string | undefined;
networkId: string | undefined;
}
``

Contributing

See CONTRIBUTING.md for more information.