@coinbase/agentkit 0.0.0-nightly-20250501210425 → 0.0.0-nightly-20250612210418

package/dist/action-providers/vaultsfyi/utils.js

@@ -4,6 +4,8 @@ exports.getVaultsLink = getVaultsLink;
 exports.executeActions = executeActions;
 exports.createSearchParams = createSearchParams;
 exports.parseAssetAmount = parseAssetAmount;
+exports.transformVault = transformVault;
+exports.transformDetailedVault = transformDetailedVault;
 const viem_1 = require("viem");
 /**
  * Get the link to the vaults.fyi page for a vault
@@ -67,3 +69,54 @@ async function parseAssetAmount(wallet, assetAddress, amount) {
     });
     return Math.floor(amount * 10 ** decimals);
 }
+/**
+ * Transform a vault from the API to a format that can be used by the agent
+ *
+ * @param vault - The vault to transform
+ * @param apyRange - The APY range to use
+ * @returns The transformed vault
+ */
+function transformVault(vault, apyRange) {
+    return {
+        name: vault.name,
+        address: vault.address,
+        network: vault.network,
+        protocol: vault.protocol,
+        tvlInUsd: Number(vault.tvlDetails.tvlUsd),
+        numberOfHolders: vault.numberOfHolders,
+        apy: {
+            base: vault.apy.base[apyRange] / 100,
+            rewards: vault.apy.rewards?.[apyRange] ? vault.apy.rewards[apyRange] / 100 : undefined,
+            total: vault.apy.total[apyRange] / 100,
+        },
+        token: {
+            address: vault.token.assetAddress,
+            name: vault.token.name,
+            symbol: vault.token.symbol,
+        },
+        vaultsFyiScore: vault.score.vaultScore,
+        link: getVaultsLink(vault),
+    };
+}
+/**
+ * Transform a detailed vault from the API to a format that can be used by the agent
+ *
+ * @param vault - The vault to transform
+ * @param apyRange - The APY range to use
+ * @returns The transformed vault
+ */
+function transformDetailedVault(vault, apyRange) {
+    return {
+        ...transformVault(vault, apyRange),
+        rewards: vault.rewards.map(reward => ({
+            apy: reward.apy[apyRange] / 100,
+            asset: {
+                address: reward.asset.assetAddress,
+                name: reward.asset.name,
+                symbol: reward.asset.symbol,
+            },
+        })),
+        description: vault.description,
+        additionalIncentives: vault.additionalIncentives,
+    };
+}

package/dist/action-providers/vaultsfyi/vaultsfyiActionProvider.d.ts

@@ -10,7 +10,7 @@ import { z } from "zod";
 import { ActionProvider } from "../actionProvider";
 import { Network } from "../../network";
 import { EvmWalletProvider } from "../../wallet-providers";
-import { claimActionSchema, depositActionSchema, redeemActionSchema, VaultsActionSchema } from "./schemas";
+import { claimActionSchema, depositActionSchema, redeemActionSchema, VaultDetailsActionSchema, VaultHistoricalDataActionSchema, VaultsActionSchema } from "./schemas";
 /**
  * Configuration options for the OpenseaActionProvider.
  */
@@ -39,10 +39,26 @@ export declare class VaultsfyiActionProvider extends ActionProvider<EvmWalletPro
      * vaults action
      *
      * @param wallet - The wallet provider instance for blockchain interactions
-     * @param args - Input arguments: token, network, transactionalOnly...
+     * @param args - Input arguments: token, network...
      * @returns A list of vaults.
      */
     vaults(wallet: EvmWalletProvider, args: z.infer<typeof VaultsActionSchema>): Promise<string>;
+    /**
+     * vault details action
+     *
+     * @param wallet - The wallet provider instance for blockchain interactions
+     * @param args - Input arguments: address, network, apyRange
+     * @returns A detailed view of a single vault.
+     */
+    vaultDetails(wallet: EvmWalletProvider, args: z.infer<typeof VaultDetailsActionSchema>): Promise<string>;
+    /**
+     * vault historical data action
+     *
+     * @param wallet - The wallet provider instance for blockchain interactions
+     * @param args - Input arguments: address, network, date, apyRange
+     * @returns A detailed view of a single vault.
+     */
+    vaultHistoricalData(wallet: EvmWalletProvider, args: z.infer<typeof VaultHistoricalDataActionSchema>): Promise<string>;
     /**
      * Deposit action
      *

package/dist/action-providers/vaultsfyi/vaultsfyiActionProvider.js

@@ -27,6 +27,7 @@ const utils_1 = require("./utils");
 const constants_1 = require("./constants");
 const actions_1 = require("./api/actions");
 const vaults_1 = require("./api/vaults");
+const historicalData_1 = require("./api/historicalData");
 /**
  * VaultsfyiActionProvider provides actions for vaultsfyi operations.
  *
@@ -52,10 +53,11 @@ class VaultsfyiActionProvider extends actionProvider_1.ActionProvider {
      * vaults action
      *
      * @param wallet - The wallet provider instance for blockchain interactions
-     * @param args - Input arguments: token, network, transactionalOnly...
+     * @param args - Input arguments: token, network...
      * @returns A list of vaults.
      */
     async vaults(wallet, args) {
+        const apyRange = args.apyRange ?? "7day";
         const vaults = await (0, vaults_1.fetchVaults)(args, this.apiKey);
         if ("error" in vaults) {
             return `Failed to fetch vaults: ${vaults.error}, ${vaults.message}`;
@@ -66,24 +68,7 @@ class VaultsfyiActionProvider extends actionProvider_1.ActionProvider {
                 .filter((value, index, self) => self.indexOf(value) === index);
             return `Protocol ${args.protocol} is not supported. Supported protocols are: ${supportedProtocols.join(", ")}`;
         }
-        const transformedVaults = vaults.map(vault => ({
-            name: vault.name,
-            address: vault.address,
-            network: vault.network,
-            protocol: vault.protocol,
-            tvlInUsd: Number(vault.tvlDetails.tvlUsd),
-            apy: {
-                base: vault.apy.base["7day"] / 100,
-                rewards: vault.apy.rewards?.["7day"] ? vault.apy.rewards["7day"] / 100 : undefined,
-                total: vault.apy.total["7day"] / 100,
-            },
-            token: {
-                address: vault.token.assetAddress,
-                name: vault.token.name,
-                symbol: vault.token.symbol,
-            },
-            link: (0, utils_1.getVaultsLink)(vault),
-        }));
+        const transformedVaults = vaults.map(vault => (0, utils_1.transformVault)(vault, apyRange));
         const filteredVaults = transformedVaults.filter(vault => args.protocol ? vault.protocol === args.protocol : true);
         const sortedVaults = filteredVaults.sort((a, b) => {
             if (args.sort?.field === "tvl") {
@@ -107,6 +92,49 @@ class VaultsfyiActionProvider extends actionProvider_1.ActionProvider {
             results,
         });
     }
+    /**
+     * vault details action
+     *
+     * @param wallet - The wallet provider instance for blockchain interactions
+     * @param args - Input arguments: address, network, apyRange
+     * @returns A detailed view of a single vault.
+     */
+    async vaultDetails(wallet, args) {
+        const vault = await (0, vaults_1.fetchVault)(args, this.apiKey);
+        if ("error" in vault) {
+            return `Failed to fetch vault: ${vault.error}, ${vault.message}`;
+        }
+        return JSON.stringify((0, utils_1.transformDetailedVault)(vault, args.apyRange ?? "7day"));
+    }
+    /**
+     * vault historical data action
+     *
+     * @param wallet - The wallet provider instance for blockchain interactions
+     * @param args - Input arguments: address, network, date, apyRange
+     * @returns A detailed view of a single vault.
+     */
+    async vaultHistoricalData(wallet, args) {
+        const data = await (0, historicalData_1.fetchVaultHistoricalData)(args, this.apiKey);
+        if ("error" in data) {
+            return `Failed to fetch vault: ${data.error}, ${data.message}`;
+        }
+        return JSON.stringify({
+            apy: {
+                apy: {
+                    base: data.apy.apy.base / 100,
+                    rewards: data.apy.apy.rewards ? data.apy.apy.rewards / 100 : undefined,
+                    total: data.apy.apy.total / 100,
+                },
+                date: new Date(data.apy.timestamp * 1000).toISOString(),
+                blockNumber: data.apy.blockNumber,
+            },
+            tvl: {
+                tvlInUsd: data.tvl.tvlDetails.tvlUsd,
+                date: new Date(data.tvl.timestamp * 1000).toISOString(),
+                blockNumber: data.tvl.blockNumber,
+            },
+        });
+    }
     /**
      * Deposit action
      *
@@ -260,7 +288,7 @@ __decorate([
       This action returns a list of available vaults.
       Small vaults (under 100k TVL) are probably best avoided as they may be more risky. Unless the user is looking for high-risk, high-reward opportunities, don't include them.
       When the user asks for best vaults, optimize for apy, and if the user asks for safest/reliable vaults, optimize for TVL.
-      Try to take a reasonable number of results so its easier to analyze the data.
+      Try to take a reasonable number of results so its easier to analyze the data. Include vaults.fyi links for each vault.
       Format result apys as: x% (base: x%, rewards: x%) if rewards apy is available, otherwise: x%
       Examples:
       User: "Show me the best vaults"
@@ -275,6 +303,7 @@ __decorate([
       args: { network: 'polygon', sort: { field: 'apy', direction: 'desc' }, take: 5, minTvl: 0 }
       User: "Show me some more of those"
       args: { network: 'polygon', sort: { field: 'apy', direction: 'desc' }, take: 5, minTvl: 0, page: 2 }
+      All optional fields should be null if not specified.
     `,
         schema: schemas_1.VaultsActionSchema,
     }),
@@ -282,6 +311,44 @@ __decorate([
     __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], VaultsfyiActionProvider.prototype, "vaults", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "vault_details",
+        description: `
+      This action returns a more detailed view of a single vault. Additional details include:
+      - Description
+      - Additional incentives (points etc)
+      - Rewards breakdown
+      Params: 
+      - vaultAddress: The address of the vault to fetch details for
+      - network: The network of the vault
+      - apyRange: The APY moving average range (default: 7day)
+    `,
+        schema: schemas_1.VaultDetailsActionSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], VaultsfyiActionProvider.prototype, "vaultDetails", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "vault_historical_data",
+        description: `
+      This action returns a historical data of a vault. It returns the APY and TVL data closest to the given date.
+      Always check if the results date is close to the requested date, as the data may not be available for the exact date.
+      If there is a more than 7 day difference between the requested date and the resulting date, don't provide the data, but rather with a message explaining the missing data.
+      If the resulting date is a lot later than the requested date, the reason for missing data might be that the vault has not been deployed yet.
+      Example queries:
+      params: { vaultAddress: "0x1234567890abcdef1234567890abcdef12345678", network: "arbitrum", date: "2025-01-01T00:00:00Z" }
+      result: { ..., date: "2025-02-16T14:59:59.000Z" }
+      response: "The requested date was 2025-01-01T00:00:00Z, but the closest data available is from 2025-02-16T14:59:59.000Z. This may indicate that the vault was not deployed at the requested date."
+    `,
+        schema: schemas_1.VaultHistoricalDataActionSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], VaultsfyiActionProvider.prototype, "vaultHistoricalData", null);
 __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "deposit",

package/dist/action-providers/vaultsfyi/vaultsfyiActionProvider.test.js

@@ -35,6 +35,30 @@ const mockVault = (num) => ({
                 "7day": num * 100,
             },
         },
+        numberOfHolders: num,
+        rewards: [
+            {
+                apy: {
+                    "7day": num * 100,
+                },
+                asset: {
+                    name: `reward-token-${num}`,
+                    symbol: `RT${num}`,
+                    assetAddress: `0x${num.toString(16).padStart(40, "0")}`,
+                    decimals: 18,
+                },
+            },
+        ],
+        description: `Description for vault-${num}`,
+        additionalIncentives: `Incentives for vault-${num}`,
+        score: {
+            vaultScore: num,
+            vaultTvlScore: num,
+            protocolTvlScore: num,
+            holderScore: num,
+            networkScore: num,
+            assetScore: num,
+        },
         isTransactional: true,
     },
     transformedResult: {
@@ -53,6 +77,8 @@ const mockVault = (num) => ({
             rewards: num,
             total: num,
         },
+        vaultsFyiScore: num,
+        numberOfHolders: num,
         link: `https://app.vaults.fyi/opportunity/network-${num}/0x${num.toString(16).padStart(40, "0")}`,
     },
 });
@@ -435,4 +461,143 @@ describe("VaultsfyiActionProvider", () => {
             expect(await provider.positions(mockWalletProvider)).toBe("Failed to fetch positions: Internal Server Error, some more info");
         });
     });
+    describe("vault_details action", () => {
+        it("should transform vault details correctly", async () => {
+            const detailedVault = mockVault(1);
+            mockedFetch.mockResolvedValue(mockFetchResult(200, detailedVault.apiResult));
+            const args = {
+                vaultAddress: "0x123456",
+                network: "mainnet",
+            };
+            const result = await provider.vaultDetails(mockWalletProvider, args);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult).toStrictEqual({
+                ...detailedVault.transformedResult,
+                description: detailedVault.apiResult.description,
+                additionalIncentives: detailedVault.apiResult.additionalIncentives,
+                rewards: [
+                    {
+                        apy: detailedVault.apiResult.rewards[0].apy["7day"] / 100,
+                        asset: {
+                            name: detailedVault.apiResult.rewards[0].asset.name,
+                            symbol: detailedVault.apiResult.rewards[0].asset.symbol,
+                            address: detailedVault.apiResult.rewards[0].asset.assetAddress,
+                        },
+                    },
+                ],
+            });
+        });
+        it("should return an error if the API request fails", async () => {
+            mockedFetch.mockResolvedValue(mockFetchResult(500, { error: "Internal Server Error", message: "some more info" }));
+            const args = {
+                vaultAddress: "0x123456",
+                network: "mainnet",
+            };
+            expect(await provider.vaultDetails(mockWalletProvider, args)).toBe("Failed to fetch vault: Internal Server Error, some more info");
+        });
+    });
+    describe("vault_historical_data action", () => {
+        it("should fetch and transform historical data correctly", async () => {
+            // Mock API responses for both TVL and APY data
+            const mockApyData = {
+                timestamp: 1704067200, // Jan 1, 2024
+                blockNumber: 12345678,
+                apy: {
+                    base: 500,
+                    rewards: 300,
+                    total: 800,
+                },
+            };
+            const mockTvlData = {
+                timestamp: 1704067200, // Jan 1, 2024
+                blockNumber: 12345678,
+                tvlDetails: {
+                    tvlUsd: 1000000,
+                },
+            };
+            // Set up the mock to return appropriate data for each call
+            mockedFetch.mockImplementation(url => {
+                if (url.includes("/historical-apy/")) {
+                    return Promise.resolve(mockFetchResult(200, mockApyData));
+                }
+                else if (url.includes("/historical-tvl/")) {
+                    return Promise.resolve(mockFetchResult(200, mockTvlData));
+                }
+                return Promise.resolve(mockFetchResult(500, { error: "Unexpected URL" }));
+            });
+            const args = {
+                vaultAddress: "0x123456",
+                network: "mainnet",
+                date: "2024-01-01T00:00:00Z",
+            };
+            const result = await provider.vaultHistoricalData(mockWalletProvider, args);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult).toEqual({
+                apy: {
+                    apy: {
+                        base: 5,
+                        rewards: 3,
+                        total: 8,
+                    },
+                    date: "2024-01-01T00:00:00.000Z",
+                    blockNumber: 12345678,
+                },
+                tvl: {
+                    tvlInUsd: 1000000,
+                    date: "2024-01-01T00:00:00.000Z",
+                    blockNumber: 12345678,
+                },
+            });
+        });
+        it("should return an error if the APY API request fails", async () => {
+            // Set up the mock to fail for APY but succeed for TVL
+            mockedFetch.mockImplementation(url => {
+                if (url.includes("/historical-apy/")) {
+                    return Promise.resolve(mockFetchResult(500, {
+                        error: "Internal Server Error",
+                        message: "Failed to get historical APY data",
+                    }));
+                }
+                else if (url.includes("/historical-tvl/")) {
+                    return Promise.resolve(mockFetchResult(200, {
+                        timestamp: 1704067200,
+                        blockNumber: 12345678,
+                        tvlDetails: { tvlUsd: 1000000 },
+                    }));
+                }
+                return Promise.resolve(mockFetchResult(500, { error: "Unexpected URL" }));
+            });
+            const args = {
+                vaultAddress: "0x123456",
+                network: "mainnet",
+                date: "2024-01-01T00:00:00Z",
+            };
+            expect(await provider.vaultHistoricalData(mockWalletProvider, args)).toBe("Failed to fetch vault: Internal Server Error, Failed to get historical APY data");
+        });
+        it("should return an error if the TVL API request fails", async () => {
+            // Set up the mock to succeed for APY but fail for TVL
+            mockedFetch.mockImplementation(url => {
+                if (url.includes("/historical-apy/")) {
+                    return Promise.resolve(mockFetchResult(200, {
+                        timestamp: 1704067200,
+                        blockNumber: 12345678,
+                        apy: { base: 500, rewards: 300, total: 800 },
+                    }));
+                }
+                else if (url.includes("/historical-tvl/")) {
+                    return Promise.resolve(mockFetchResult(500, {
+                        error: "Internal Server Error",
+                        message: "Failed to get historical TVL data",
+                    }));
+                }
+                return Promise.resolve(mockFetchResult(500, { error: "Unexpected URL" }));
+            });
+            const args = {
+                vaultAddress: "0x123456",
+                network: "mainnet",
+                date: "2024-01-01T00:00:00Z",
+            };
+            expect(await provider.vaultHistoricalData(mockWalletProvider, args)).toBe("Failed to fetch vault: Internal Server Error, Failed to get historical TVL data");
+        });
+    });
 });

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.0.0-nightly-20250501210425",
+  "version": "0.0.0-nightly-20250612210418",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -27,10 +27,10 @@
     "@coinbase/cdp-sdk": "^1.3.0",
     "@coinbase/coinbase-sdk": "^0.20.0",
     "@jup-ag/api": "^6.0.39",
-    "@privy-io/public-api": "^2.18.5",
-    "@privy-io/server-auth": "^1.18.4",
+    "@privy-io/public-api": "2.18.5",
+    "@privy-io/server-auth": "1.18.4",
     "@solana/spl-token": "^0.4.12",
-    "@solana/web3.js": "^1.98.0",
+    "@solana/web3.js": "^1.98.1",
     "bs58": "^4.0.1",
     "canonicalize": "^2.1.0",
     "decimal.js": "^10.5.0",