@coinbase/agentkit 0.7.1 → 0.8.0

package/README.md

@@ -65,8 +65,8 @@ npm install @coinbase/agentkit
 
 ```typescript
 const agentKit = await AgentKit.from({
-  cdpApiKeyName: "CDP API KEY NAME",
-  cdpApiKeyPrivate: "CDP API KEY PRIVATE KEY",
+  cdpApiKeyId: "CDP API KEY NAME",
+  cdpApiKeyPrivate: "CDP API KEY SECRET",
 });
 ```
 
@@ -76,8 +76,8 @@ If no wallet or action provider are specified, the agent will use the `CdpWallet
 
 ```typescript
 const agentKit = await AgentKit.from({
-  cdpApiKeyName: "CDP API KEY NAME",
-  cdpApiKeyPrivate: "CDP API KEY PRIVATE KEY",
+  cdpApiKeyId: "CDP API KEY NAME",
+  cdpApiKeyPrivate: "CDP API KEY SECRET",
 });
 ```
 
@@ -87,8 +87,8 @@ const agentKit = await AgentKit.from({
 import { CdpWalletProvider } from "@coinbase/agentkit";
 
 const walletProvider = await CdpWalletProvider.configureWithWallet({
-    apiKeyName: "CDP API KEY NAME",
-    apiKeyPrivate: "CDP API KEY PRIVATE KEY",
+    apiKeyId: "CDP API KEY NAME",
+    apiKeyPrivate: "CDP API KEY SECRET",
     networkId: "base-mainnet",
 });
 
@@ -106,8 +106,8 @@ const agentKit = await AgentKit.from({
     walletProvider,
     actionProviders: [
         cdpApiActionProvider({
-            apiKeyName: "CDP API KEY NAME",
-            apiKeyPrivate: "CDP API KEY PRIVATE KEY",
+            apiKeyId: "CDP API KEY NAME",
+            apiKeyPrivate: "CDP API KEY SECRET",
         }),
         pythActionProvider(),
     ],
@@ -528,8 +528,8 @@ 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",
+  cdpApiKeyId: "CDP API KEY NAME",
+  cdpApiKeyPrivate: "CDP API KEY SECRET",
   actionProviders: [myActionProvider()],
 });
 ```
@@ -621,8 +621,8 @@ The `CdpWalletProvider` can be configured to use a specific network by passing t
 import { CdpWalletProvider } from "@coinbase/agentkit";
 
 const walletProvider = await CdpWalletProvider.configureWithWallet({
-    apiKeyName: "CDP API KEY NAME",
-    apiKeyPrivate: "CDP API KEY PRIVATE KEY",
+    apiKeyId: "CDP API KEY NAME",
+    apiKeyPrivate: "CDP API KEY SECRET",
     networkId: "base-mainnet",
 });
 ```
@@ -636,8 +636,8 @@ 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",
+    apiKeyId: "CDP API KEY NAME",
+    apiKeyPrivate: "CDP API KEY SECRET",
 });
 ```
 
@@ -678,8 +678,8 @@ 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",
+    apiKeyId: "CDP API KEY NAME",
+    apiKeyPrivate: "CDP API KEY SECRET",
 });
 ```
 
@@ -692,8 +692,8 @@ 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",
+    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
@@ -879,8 +879,8 @@ import { ZeroDevWalletProvider, CdpWalletProvider } from "@coinbase/agentkit";
 
 // First create a CDP wallet provider as the signer
 const cdpWalletProvider = await CdpWalletProvider.configureWithWallet({
-    apiKeyName: "CDP API KEY NAME",
-    apiKeyPrivate: "CDP API KEY PRIVATE KEY",
+    apiKeyId: "CDP API KEY NAME",
+    apiKeyPrivate: "CDP API KEY SECRET",
     networkId: "base-mainnet",
 });
 

package/dist/action-providers/cdp/cdpApiActionProvider.js

@@ -39,10 +39,10 @@ class CdpApiActionProvider extends actionProvider_1.ActionProvider {
          * @returns True if the Cdp action provider supports the network, false otherwise.
          */
         this.supportsNetwork = (_) => true;
-        if (config.apiKeyName && config.apiKeyPrivateKey) {
+        if (config.apiKeyId && config.apiKeySecret) {
             coinbase_sdk_1.Coinbase.configure({
-                apiKeyName: config.apiKeyName,
-                privateKey: config.apiKeyPrivateKey?.replace(/\\n/g, "\n"),
+                apiKeyName: config.apiKeyId,
+                privateKey: config.apiKeySecret?.replace(/\\n/g, "\n"),
                 source: "agentkit",
                 sourceVersion: package_json_1.version,
             });

package/dist/action-providers/cdp/cdpWalletActionProvider.js

@@ -38,10 +38,10 @@ class CdpWalletActionProvider extends actionProvider_1.ActionProvider {
          * @returns True if the Cdp action provider supports the network, false otherwise.
          */
         this.supportsNetwork = (network) => network.protocolFamily === "evm";
-        if (config.apiKeyName && config.apiKeyPrivateKey) {
+        if (config.apiKeyId && config.apiKeySecret) {
             coinbase_sdk_1.Coinbase.configure({
-                apiKeyName: config.apiKeyName,
-                privateKey: config.apiKeyPrivateKey?.replace(/\\n/g, "\n"),
+                apiKeyName: config.apiKeyId,
+                privateKey: config.apiKeySecret?.replace(/\\n/g, "\n"),
                 source: "agentkit",
                 sourceVersion: package_json_1.version,
             });

package/dist/action-providers/cdp-v2/cdpApiV2ActionProvider.d.ts

@@ -1,16 +1,14 @@
 import { z } from "zod";
 import { Network } from "../../network";
 import { WalletProvider } from "../../wallet-providers";
-import { WalletProviderWithClient } from "../../wallet-providers/cdpV2Shared";
 import { ActionProvider } from "../actionProvider";
 import { RequestFaucetFundsV2Schema } from "./schemas";
-type CdpV2WalletProviderWithClient = WalletProvider & WalletProviderWithClient;
 /**
  * CdpApiActionProvider is an action provider for CDP API.
  *
  * This provider is used for any action that uses the CDP API, but does not require a CDP Wallet.
  */
-export declare class CdpApiV2ActionProvider extends ActionProvider<CdpV2WalletProviderWithClient> {
+export declare class CdpApiV2ActionProvider extends ActionProvider<WalletProvider> {
     /**
      * Constructor for the CdpApiActionProvider class.
      */
@@ -22,7 +20,7 @@ export declare class CdpApiV2ActionProvider extends ActionProvider<CdpV2WalletPr
      * @param args - The input arguments for the action.
      * @returns A confirmation message with transaction details.
      */
-    faucet(walletProvider: CdpV2WalletProviderWithClient, args: z.infer<typeof RequestFaucetFundsV2Schema>): Promise<string>;
+    faucet(walletProvider: WalletProvider, args: z.infer<typeof RequestFaucetFundsV2Schema>): Promise<string>;
     /**
      * Checks if the Cdp action provider supports the given network.
      *
@@ -34,4 +32,3 @@ export declare class CdpApiV2ActionProvider extends ActionProvider<CdpV2WalletPr
     supportsNetwork: (_: Network) => boolean;
 }
 export declare const cdpApiV2ActionProvider: () => CdpApiV2ActionProvider;
-export {};

package/dist/action-providers/cdp-v2/cdpApiV2ActionProvider.js

@@ -11,6 +11,8 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cdpApiV2ActionProvider = exports.CdpApiV2ActionProvider = void 0;
 const zod_1 = require("zod");
+const wallet_providers_1 = require("../../wallet-providers");
+const cdpV2Shared_1 = require("../../wallet-providers/cdpV2Shared");
 const actionDecorator_1 = require("../actionDecorator");
 const actionProvider_1 = require("../actionProvider");
 const schemas_1 = require("./schemas");
@@ -45,29 +47,34 @@ class CdpApiV2ActionProvider extends actionProvider_1.ActionProvider {
     async faucet(walletProvider, args) {
         const network = walletProvider.getNetwork();
         const networkId = network.networkId;
-        if (network.protocolFamily === "evm") {
-            if (networkId !== "base-sepolia" && networkId !== "ethereum-sepolia") {
-                throw new Error("Faucet is only supported on 'base-sepolia' or 'ethereum-sepolia' evm networks.");
+        if ((0, cdpV2Shared_1.isWalletProviderWithClient)(walletProvider)) {
+            if (network.protocolFamily === "evm") {
+                if (networkId !== "base-sepolia" && networkId !== "ethereum-sepolia") {
+                    throw new Error("Faucet is only supported on 'base-sepolia' or 'ethereum-sepolia' evm networks.");
+                }
+                const faucetTx = await walletProvider.getClient().evm.requestFaucet({
+                    address: walletProvider.getAddress(),
+                    token: (args.assetId || "eth"),
+                    network: networkId,
+                });
+                return `Received ${args.assetId || "ETH"} from the faucet. Transaction hash: ${faucetTx.transactionHash}`;
             }
-            const faucetTx = await walletProvider.getClient().evm.requestFaucet({
-                address: walletProvider.getAddress(),
-                token: (args.assetId || "eth"),
-                network: networkId,
-            });
-            return `Received ${args.assetId || "ETH"} from the faucet. Transaction hash: ${faucetTx.transactionHash}`;
-        }
-        else if (network.protocolFamily === "svm") {
-            if (networkId !== "solana-devnet") {
-                throw new Error("Faucet is only supported on 'solana-devnet' solana networks.");
+            else if (network.protocolFamily === "svm") {
+                if (networkId !== "solana-devnet") {
+                    throw new Error("Faucet is only supported on 'solana-devnet' solana networks.");
+                }
+                const faucetTx = await walletProvider.getClient().solana.requestFaucet({
+                    address: walletProvider.getAddress(),
+                    token: (args.assetId || "sol"),
+                });
+                return `Received ${args.assetId || "SOL"} from the faucet. Transaction signature hash: ${faucetTx.signature}`;
+            }
+            else {
+                throw new Error("Faucet is only supported on Ethereum and Solana protocol families.");
             }
-            const faucetTx = await walletProvider.getClient().solana.requestFaucet({
-                address: walletProvider.getAddress(),
-                token: (args.assetId || "sol"),
-            });
-            return `Received ${args.assetId || "SOL"} from the faucet. Transaction signature hash: ${faucetTx.signature}`;
         }
         else {
-            throw new Error("Faucet is only supported on Ethereum and Solana protocol families.");
+            throw new Error("Wallet provider is not a CDP Wallet Provider.");
         }
     }
 }
@@ -84,7 +91,7 @@ from another wallet and provide the user with your wallet details.`,
         schema: schemas_1.RequestFaucetFundsV2Schema,
     }),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, void 0]),
+    __metadata("design:paramtypes", [wallet_providers_1.WalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], CdpApiV2ActionProvider.prototype, "faucet", null);
 const cdpApiV2ActionProvider = () => new CdpApiV2ActionProvider();

package/dist/agentkit.d.ts

@@ -4,8 +4,8 @@ import { Action, ActionProvider } from "./action-providers";
  * Configuration options for AgentKit
  */
 export type AgentKitOptions = {
-    cdpApiKeyName?: string;
-    cdpApiKeyPrivateKey?: string;
+    cdpApiKeyId?: string;
+    cdpApiKeySecret?: string;
     walletProvider?: WalletProvider;
     actionProviders?: ActionProvider[];
 };

package/dist/agentkit.js

@@ -32,12 +32,12 @@ class AgentKit {
     static async from(config = { actionProviders: [(0, action_providers_1.walletActionProvider)()] }) {
         let walletProvider = config.walletProvider;
         if (!config.walletProvider) {
-            if (!config.cdpApiKeyName || !config.cdpApiKeyPrivateKey) {
-                throw new Error("cdpApiKeyName and cdpApiKeyPrivateKey are required if not providing a walletProvider");
+            if (!config.cdpApiKeyId || !config.cdpApiKeySecret) {
+                throw new Error("cdpApiKeyId and cdpApiKeySecret are required if not providing a walletProvider");
             }
             walletProvider = await wallet_providers_1.CdpWalletProvider.configureWithWallet({
-                apiKeyName: config.cdpApiKeyName,
-                apiKeyPrivateKey: config.cdpApiKeyPrivateKey,
+                apiKeyId: config.cdpApiKeyId,
+                apiKeySecret: config.cdpApiKeySecret,
             });
         }
         return new AgentKit({ ...config, walletProvider: walletProvider });

package/dist/wallet-providers/cdpV2EvmWalletProvider.js

@@ -118,9 +118,29 @@ class CdpV2EvmWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
      * @returns The hash of the transaction.
      */
     async sendTransaction(transaction) {
+        const txWithGasParams = {
+            ...transaction,
+            chainId: __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_network, "f").chainId,
+        };
+        if (!txWithGasParams.maxFeePerGas && !txWithGasParams.gasPrice) {
+            const feeData = await __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_publicClient, "f").estimateFeesPerGas();
+            txWithGasParams.maxFeePerGas = feeData.maxFeePerGas;
+            txWithGasParams.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas;
+        }
+        if (!txWithGasParams.gas) {
+            try {
+                txWithGasParams.gas = await __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_publicClient, "f").estimateGas({
+                    account: __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_serverAccount, "f").address,
+                    ...txWithGasParams,
+                });
+            }
+            catch (error) {
+                console.warn("Failed to estimate gas, continuing without gas estimation", error);
+            }
+        }
         const result = await __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_cdp, "f").evm.sendTransaction({
             address: __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_serverAccount, "f").address,
-            transaction: (0, viem_1.serializeTransaction)(transaction),
+            transaction: (0, viem_1.serializeTransaction)(txWithGasParams),
             network: __classPrivateFieldGet(this, _CdpV2EvmWalletProvider_instances, "m", _CdpV2EvmWalletProvider_getCdpSdkNetwork).call(this),
         });
         return result.transactionHash;

package/dist/wallet-providers/cdpV2Shared.d.ts

@@ -39,3 +39,10 @@ export interface WalletProviderWithClient {
      */
     getClient(): CdpClient;
 }
+/**
+ * Type guard to check if a wallet provider implements WalletProviderWithClient interface.
+ *
+ * @param provider - The provider to check
+ * @returns True if the provider implements WalletProviderWithClient
+ */
+export declare function isWalletProviderWithClient(provider: unknown): provider is WalletProviderWithClient;

package/dist/wallet-providers/cdpV2Shared.js

@@ -1,2 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWalletProviderWithClient = isWalletProviderWithClient;
+/**
+ * Type guard to check if a wallet provider implements WalletProviderWithClient interface.
+ *
+ * @param provider - The provider to check
+ * @returns True if the provider implements WalletProviderWithClient
+ */
+function isWalletProviderWithClient(provider) {
+    return (provider !== null &&
+        typeof provider === "object" &&
+        "getClient" in provider &&
+        typeof provider.getClient === "function");
+}

package/dist/wallet-providers/cdpWalletProvider.d.ts

@@ -9,11 +9,11 @@ export interface CdpProviderConfig {
     /**
      * The CDP API Key Name.
      */
-    apiKeyName?: string;
+    apiKeyId?: string;
     /**
      * The CDP API Key Private Key.
      */
-    apiKeyPrivateKey?: string;
+    apiKeySecret?: string;
 }
 /**
  * Configuration options for the CdpActionProvider.

package/dist/wallet-providers/cdpWalletProvider.js

@@ -56,10 +56,10 @@ class CdpWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
      * @throws Error if required environment variables are missing or wallet initialization fails
      */
     static async configureWithWallet(config = {}) {
-        if (config.apiKeyName && config.apiKeyPrivateKey) {
+        if (config.apiKeyId && config.apiKeySecret) {
             coinbase_sdk_1.Coinbase.configure({
-                apiKeyName: config.apiKeyName,
-                privateKey: config.apiKeyPrivateKey?.replace(/\\n/g, "\n"),
+                apiKeyName: config.apiKeyId,
+                privateKey: config.apiKeySecret?.replace(/\\n/g, "\n"),
                 source: "agentkit",
                 sourceVersion: package_json_1.version,
             });

package/dist/wallet-providers/cdpWalletProvider.test.js

@@ -199,16 +199,16 @@ describe("CdpWalletProvider", () => {
             expect(provider.getNetwork()).toEqual(MOCK_NETWORK);
         });
         it("should initialize with API keys", async () => {
-            const apiKeyName = "test-key";
-            const apiKeyPrivateKey = "private-key";
+            const apiKeyId = "test-key";
+            const apiKeySecret = "private-key";
             const provider = await cdpWalletProvider_1.CdpWalletProvider.configureWithWallet({
-                apiKeyName,
-                apiKeyPrivateKey,
+                apiKeyId,
+                apiKeySecret,
                 networkId: MOCK_NETWORK_ID,
             });
             expect(coinbase_sdk_1.Coinbase.configure).toHaveBeenCalledWith({
-                apiKeyName,
-                privateKey: apiKeyPrivateKey,
+                apiKeyName: apiKeyId,
+                privateKey: apiKeySecret,
                 source: "agentkit",
                 sourceVersion: "1.0.0",
             });

package/dist/wallet-providers/smartWalletProvider.d.ts

@@ -3,8 +3,8 @@ import { Abi, Address, ContractFunctionArgs, ContractFunctionName, Hex, ReadCont
 import { Network } from "../network";
 import { EvmWalletProvider } from "./evmWalletProvider";
 export interface ConfigureSmartWalletOptions {
-    cdpApiKeyName?: string;
-    cdpApiKeyPrivateKey?: string;
+    cdpApiKeyId?: string;
+    cdpApiKeySecret?: string;
     networkId?: string;
     smartWalletAddress?: Hex;
     paymasterUrl?: string;
@@ -39,8 +39,8 @@ export declare class SmartWalletProvider extends EvmWalletProvider {
      * const smartWalletProvider = await SmartWalletProvider.configureWithWallet({
      *   networkId: "base-sepolia",
      *   signer: privateKeyToAccount("0xethprivatekey"),
-     *   cdpApiKeyName: "my-api-key",
-     *   cdpApiKeyPrivateKey: "my-private-key",
+     *   cdpApiKeyId: "my-api-key",
+     *   cdpApiKeySecret: "my-private-key",
      *   smartWalletAddress: "0x123456...",
      * });
      * ```

package/dist/wallet-providers/smartWalletProvider.js

@@ -57,8 +57,8 @@ class SmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
      * const smartWalletProvider = await SmartWalletProvider.configureWithWallet({
      *   networkId: "base-sepolia",
      *   signer: privateKeyToAccount("0xethprivatekey"),
-     *   cdpApiKeyName: "my-api-key",
-     *   cdpApiKeyPrivateKey: "my-private-key",
+     *   cdpApiKeyId: "my-api-key",
+     *   cdpApiKeySecret: "my-private-key",
      *   smartWalletAddress: "0x123456...",
      * });
      * ```
@@ -77,12 +77,12 @@ class SmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         if (!supportedChainIds.includes(network.chainId)) {
             throw new Error(`Invalid chain id ${network.chainId}. Chain id must be one of ${supportedChainIds.join(", ")}`);
         }
-        const cdpApiKeyName = config.cdpApiKeyName || process.env.CDP_API_KEY_NAME;
-        const cdpApiKeyPrivateKey = config.cdpApiKeyPrivateKey || process.env.CDP_API_KEY_PRIVATE_KEY;
-        if (cdpApiKeyName && cdpApiKeyPrivateKey) {
+        const cdpApiKeyId = config.cdpApiKeyId || process.env.CDP_API_KEY_ID;
+        const cdpApiKeySecret = config.cdpApiKeySecret || process.env.CDP_API_KEY_SECRET;
+        if (cdpApiKeyId && cdpApiKeySecret) {
             coinbase_sdk_1.Coinbase.configure({
-                apiKeyName: cdpApiKeyName,
-                privateKey: cdpApiKeyPrivateKey?.replace(/\\n/g, "\n"),
+                apiKeyName: cdpApiKeyId,
+                privateKey: cdpApiKeySecret?.replace(/\\n/g, "\n"),
                 source: "agentkit",
                 sourceVersion: package_json_1.version,
             });

package/package.json

@@ -2,7 +2,7 @@
   "name": "@coinbase/agentkit",
   "description": "Coinbase AgentKit core primitives",
   "repository": "https://github.com/coinbase/agentkit",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",