@thirdfy/agentkit

v0.10.3

Published

a month ago

Thirdfy AgentKit core primitives (forked from Coinbase)

Downloads

0High
0Medium
0Low

feliperieger

coinbase sdk crypto cdp agentkit ai agent nodejs typescript

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.

Agentkit

Getting Started

Prerequisites:

Installation

npm install @coinbase/agentkit

Usage

Create an AgentKit instance. If no wallet or action providers are specified, the agent will use the `CdpWalletProvider` and `WalletProvider` action provider.

const agentKit = await AgentKit.from({
  cdpApiKeyId: "CDP API KEY NAME",
  cdpApiKeySecret: "CDP API KEY SECRET",
});

Create an AgentKit instance

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

Create an AgentKit instance with a specified wallet provider.

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

Create an AgentKit instance with a specified action providers.

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(),
  ],
});

Use the agent's actions with a framework extension. For example, using LangChain + OpenAI.

Prerequisites:

OpenAI API Key
Set 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,
});

Action Providers

Creating an Action Provider

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

Adding Actions to your Action Provider

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.

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

Steps to create an action

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

import { z } from "zod";

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

Define the action.

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();

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.

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

Adding an Action Provider to your AgentKit instance.

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()],
});

EVM Wallet Providers

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

EVM:

CdpEvmWalletProvider

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.

Basic Configuration

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"
});

Using an Existing Wallet

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

Creating a New Wallet

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

Environment Variables

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();

Exporting a wallet

The CdpEvmWalletProvider can export a wallet by calling the exportWallet method:

const walletData = await walletProvider.exportWallet();

CdpSmartWalletProvider

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

Basic Configuration

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"
});

Using an Existing Smart Wallet

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

Specifying an Owner Account

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

Creating a New Smart Wallet

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

Environment Variables

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();

Exporting Smart Wallet Information

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
}

Key Differences from Regular Wallets

User Operations: Smart wallets use ERC-4337 user operations instead of regular transactions
No Direct Transaction Signing: Smart wallets cannot sign transactions directly; all operations go through the user operation flow
Gasless Transactions: Smart wallets can be configured to use paymasters for sponsored transactions
Batch Operations: Multiple operations can be bundled into a single user operation
Base Networks Only: Currently limited to base-sepolia and base-mainnet

LegacyCdpWalletProvider

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

Network Configuration

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

Configuring from an existing CDP API Wallet

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

Configuring from a mnemonic phrase

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

Exporting a wallet

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();

Importing a wallet from `WalletData` JSON string

The 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",
});

Configuring LegacyCdpWalletProvider gas parameters

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.

ViemWalletProvider

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

Configuring ViemWalletProvider gas parameters

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

PrivyWalletProvider

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

Server Wallet Configuration

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.

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

Prerequisites

Before using this wallet provider, you need to:

Set up Privy in your application
Enable server delegated actions
Have users delegate permissions to your server
Obtain the delegated wallet ID

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

Supported Operations

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.

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

SmartWalletProvider

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

ZeroDevWalletProvider

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.

Configuring from CdpWalletProvider

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

Configuring from PrivyWalletProvider

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

Configuring from ViemWalletProvider

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

SVM Wallet Providers

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

SVM:

CdpV2SolanaWalletProvider

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.

Basic Configuration

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"
});

Using an Existing Wallet

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

Creating a New Wallet

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

Environment Variables

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();

Supported Networks

The CdpV2SolanaWalletProvider supports the following Solana networks:

solana-mainnet
solana-devnet
solana-testnet

SolanaKeypairWalletProvider

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

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.

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

PrivyWalletProvider (Solana)

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

Connection Configuration

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

Authorization Keys

Privy offers the option to use authorization keys to secure your server wallets.

You can manage authorization keys from your Privy dashboard.

Exporting Privy Wallet information

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

Contributing

See CONTRIBUTING.md for more information.

Published

Vulnerabilities

Links

Maintainers

Keywords

Readme

Agentkit

Table of Contents

Getting Started

Installation

Usage

Create an AgentKit instance. If no wallet or action providers are specified, the agent will use the CdpWalletProvider and WalletProvider action provider.

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

Required Typescript Compiler Options

Steps to create an action

Adding Actions to your Action Provider that use a Wallet Provider

Adding an Action Provider to your AgentKit instance.

EVM Wallet Providers

CdpEvmWalletProvider

Basic Configuration

Using an Existing Wallet

Creating a New Wallet

Environment Variables

Exporting a wallet

CdpSmartWalletProvider

Basic Configuration

Using an Existing Smart Wallet

Specifying an Owner Account

Creating a New Smart Wallet

Environment Variables

Exporting Smart Wallet Information

Key Differences from Regular Wallets

LegacyCdpWalletProvider

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 LegacyCdpWalletProvider gas parameters

ViemWalletProvider

Configuring ViemWalletProvider gas parameters

PrivyWalletProvider

Server Wallet Configuration

Delegated Embedded Wallet Configuration

Prerequisites

Supported Operations

Authorization Keys

Exporting Privy Wallet information

SmartWalletProvider

ZeroDevWalletProvider

Configuring from CdpWalletProvider

Configuring from PrivyWalletProvider

Configuring from ViemWalletProvider

SVM Wallet Providers

CdpV2SolanaWalletProvider

Basic Configuration

Using an Existing Wallet

Creating a New Wallet

Environment Variables

Supported Networks

SolanaKeypairWalletProvider

Solana Network Configuration

RPC URL Configuration

PrivyWalletProvider (Solana)

Connection Configuration

Authorization Keys

Exporting Privy Wallet information

Contributing

Create an AgentKit instance. If no wallet or action providers are specified, the agent will use the `CdpWalletProvider` and `WalletProvider` action provider.

Importing a wallet from `WalletData` JSON string