@coinbase/agentkit 0.0.0-nightly-20250905210407 → 0.0.0-nightly-20250906210355

package/README.md

@@ -182,6 +182,14 @@ const agent = createReactAgent({
     <td width="200"><code>use_spend_permission</code></td>
     <td width="768">Uses a spend permission to spend tokens on behalf of a smart account that the current EVM wallet has permission to spend.</td>
 </tr>
+<tr>
+    <td width="200"><code>get_swap_price</code></td>
+    <td width="768">Fetches a price quote for swapping between two tokens using the CDP Swap API (does not execute swap).</td>
+</tr>
+<tr>
+    <td width="200"><code>swap</code></td>
+    <td width="768">Executes a token swap using the CDP Swap API with automatic token approvals.</td>
+</tr>
 </table>
 </details>
 <details>
@@ -195,6 +203,14 @@ const agent = createReactAgent({
     <td width="200"><code>use_spend_permission</code></td>
     <td width="768">Uses a spend permission to spend tokens on behalf of a smart account that the current smart wallet has permission to spend.</td>
 </tr>
+<tr>
+    <td width="200"><code>get_swap_price</code></td>
+    <td width="768">Fetches a price quote for swapping between two tokens using the CDP Swap API (does not execute swap).</td>
+</tr>
+<tr>
+    <td width="200"><code>swap</code></td>
+    <td width="768">Executes a token swap using the CDP Swap API with automatic token approvals.</td>
+</tr>
 </table>
 </details>
 <details>
@@ -220,6 +236,15 @@ const agent = createReactAgent({
 </table>
 </details>
 <details>
+<summary><strong>Clanker</strong></summary>
+<table width="100%">
+<tr>
+    <td width="200"><code>clank_token</code></td>
+    <td width="768">Deploys an ERC20 Clanker token based on the supplied config.</td>
+</tr>
+</table>
+</details>
+<details>
 <summary><strong>Compound</strong></summary>
 <table width="100%">
 <tr>

package/dist/action-providers/cdp/cdpApiActionProvider.d.ts

@@ -9,7 +9,6 @@ import { RequestFaucetFundsV2Schema } from "./schemas";
  * This provider is used for any action that uses the CDP API, but does not require a CDP Wallet.
  */
 export declare class CdpApiActionProvider extends ActionProvider<WalletProvider> {
-    #private;
     /**
      * Constructor for the CdpApiActionProvider class.
      */

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

@@ -8,7 +8,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var _CdpApiActionProvider_instances, _CdpApiActionProvider_getCdpSdkNetwork;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cdpApiActionProvider = exports.CdpApiActionProvider = void 0;
 const zod_1 = require("zod");
@@ -28,7 +27,6 @@ class CdpApiActionProvider extends actionProvider_1.ActionProvider {
      */
     constructor() {
         super("cdp_api", []);
-        _CdpApiActionProvider_instances.add(this);
         /**
          * Checks if the CDP action provider supports the given network.
          *
@@ -81,20 +79,6 @@ class CdpApiActionProvider extends actionProvider_1.ActionProvider {
     }
 }
 exports.CdpApiActionProvider = CdpApiActionProvider;
-_CdpApiActionProvider_instances = new WeakSet(), _CdpApiActionProvider_getCdpSdkNetwork = function _CdpApiActionProvider_getCdpSdkNetwork(networkId) {
-    switch (networkId) {
-        case "base-sepolia":
-            return "base-sepolia";
-        case "base-mainnet":
-            return "base";
-        case "ethereum-sepolia":
-            return "ethereum-sepolia";
-        case "ethereum-mainnet":
-            return "ethereum";
-        default:
-            return networkId; // For other networks, use as-is
-    }
-};
 __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "request_faucet_funds",

package/dist/action-providers/cdp/cdpEvmWalletActionProvider.d.ts

@@ -11,7 +11,6 @@ import type { Network } from "../../network";
  * that are optimized for EVM functionality, including spend permission usage.
  */
 export declare class CdpEvmWalletActionProvider extends ActionProvider<CdpEvmWalletProvider> {
-    #private;
     /**
      * Constructor for the CdpEvmWalletActionProvider class.
      */
@@ -31,7 +30,7 @@ export declare class CdpEvmWalletActionProvider extends ActionProvider<CdpEvmWal
      * @param args - The input arguments for using the spend permission.
      * @returns A confirmation message with transaction details.
      */
-    useSpendPermission(walletProvider: WalletProvider, args: z.infer<typeof UseSpendPermissionSchema>): Promise<string>;
+    useSpendPermission(walletProvider: CdpEvmWalletProvider, args: z.infer<typeof UseSpendPermissionSchema>): Promise<string>;
     /**
      * Gets a price quote for swapping tokens using the CDP Swap API.
      *

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

@@ -8,12 +8,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _CdpEvmWalletActionProvider_instances, _CdpEvmWalletActionProvider_getCdpSdkNetwork;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cdpEvmWalletActionProvider = exports.CdpEvmWalletActionProvider = void 0;
 const zod_1 = require("zod");
@@ -38,7 +32,6 @@ class CdpEvmWalletActionProvider extends actionProvider_1.ActionProvider {
      */
     constructor() {
         super("cdp_evm_wallet", []);
-        _CdpEvmWalletActionProvider_instances.add(this);
         /**
          * Checks if the EVM wallet action provider supports the given network.
          *
@@ -80,7 +73,7 @@ class CdpEvmWalletActionProvider extends actionProvider_1.ActionProvider {
      */
     async useSpendPermission(walletProvider, args) {
         const network = walletProvider.getNetwork();
-        const cdpNetwork = __classPrivateFieldGet(this, _CdpEvmWalletActionProvider_instances, "m", _CdpEvmWalletActionProvider_getCdpSdkNetwork).call(this, network.networkId);
+        const cdpNetwork = walletProvider.getCdpSdkNetwork();
         if ((0, cdpShared_1.isWalletProviderWithClient)(walletProvider)) {
             if (network.protocolFamily === "evm") {
                 try {
@@ -119,7 +112,7 @@ class CdpEvmWalletActionProvider extends actionProvider_1.ActionProvider {
         // Get CDP SDK network
         const network = walletProvider.getNetwork();
         const networkId = network.networkId;
-        const cdpNetwork = __classPrivateFieldGet(this, _CdpEvmWalletActionProvider_instances, "m", _CdpEvmWalletActionProvider_getCdpSdkNetwork).call(this, networkId);
+        const cdpNetwork = walletProvider.getCdpSdkNetwork();
         // Check if the network is supported
         if (networkId !== "base-mainnet" && networkId !== "ethereum-mainnet")
             return JSON.stringify({
@@ -174,7 +167,7 @@ class CdpEvmWalletActionProvider extends actionProvider_1.ActionProvider {
         // Get CDP SDK network
         const network = walletProvider.getNetwork();
         const networkId = network.networkId;
-        const cdpNetwork = __classPrivateFieldGet(this, _CdpEvmWalletActionProvider_instances, "m", _CdpEvmWalletActionProvider_getCdpSdkNetwork).call(this, networkId);
+        const cdpNetwork = walletProvider.getCdpSdkNetwork();
         // Check if the network is supported
         if (networkId !== "base-mainnet" && networkId !== "ethereum-mainnet")
             return JSON.stringify({
@@ -285,20 +278,6 @@ class CdpEvmWalletActionProvider extends actionProvider_1.ActionProvider {
     }
 }
 exports.CdpEvmWalletActionProvider = CdpEvmWalletActionProvider;
-_CdpEvmWalletActionProvider_instances = new WeakSet(), _CdpEvmWalletActionProvider_getCdpSdkNetwork = function _CdpEvmWalletActionProvider_getCdpSdkNetwork(networkId) {
-    switch (networkId) {
-        case "base-sepolia":
-            return "base-sepolia";
-        case "base-mainnet":
-            return "base";
-        case "ethereum-sepolia":
-            return "ethereum-sepolia";
-        case "ethereum-mainnet":
-            return "ethereum";
-        default:
-            return networkId; // For other networks, use as-is
-    }
-};
 __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "list_spend_permissions",
@@ -322,7 +301,7 @@ This action is specifically designed for EVM wallets and uses the EVM wallet for
         schema: schemas_1.UseSpendPermissionSchema,
     }),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [wallet_providers_1.WalletProvider, void 0]),
+    __metadata("design:paramtypes", [cdpEvmWalletProvider_1.CdpEvmWalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], CdpEvmWalletActionProvider.prototype, "useSpendPermission", null);
 __decorate([

package/dist/action-providers/cdp/cdpEvmWalletActionProvider.test.js

@@ -68,6 +68,7 @@ describe("CDP EVM Wallet Action Provider", () => {
             getClient: jest.fn(),
             sendTransaction: jest.fn(),
             waitForTransactionReceipt: jest.fn(),
+            getCdpSdkNetwork: jest.fn(),
         };
         // Default setup for utility functions
         mockRetryWithExponentialBackoff.mockImplementation(async (fn) => {
@@ -86,6 +87,7 @@ describe("CDP EVM Wallet Action Provider", () => {
             });
             mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
             mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base-sepolia");
         });
         it("should successfully list spend permissions for EVM wallets", async () => {
             const expectedResult = "Found 2 spend permission(s):\n1. Token: USDC, Allowance: 500, Period: 1800 seconds, Start: 111111, End: 222222\n2. Token: ETH, Allowance: 1000, Period: 3600 seconds, Start: 123456, End: 234567";
@@ -127,6 +129,7 @@ describe("CDP EVM Wallet Action Provider", () => {
             });
             mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
             mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base-sepolia");
             mockCdpClient.evm.getAccount.mockResolvedValue(mockAccount);
         });
         it("should successfully use spend permission for EVM wallets", async () => {
@@ -174,6 +177,7 @@ describe("CDP EVM Wallet Action Provider", () => {
                     networkId: testCase.networkId,
                 });
                 mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+                mockWalletProvider.getCdpSdkNetwork.mockReturnValue(testCase.expected);
                 mockCdpClient.evm.getAccount.mockResolvedValue(mockAccount);
                 await actionProvider.useSpendPermission(mockWalletProvider, mockArgs);
                 expect(mockAccount.useSpendPermission).toHaveBeenCalledWith({
@@ -188,6 +192,7 @@ describe("CDP EVM Wallet Action Provider", () => {
                 protocolFamily: "evm",
                 networkId: "polygon-mainnet",
             });
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("polygon-mainnet");
             const mockPermission = { spender: "0x1234", token: "MATIC" };
             const mockSpendResult = { status: "completed" };
             spendPermissionUtils.findLatestSpendPermission.mockResolvedValue(mockPermission);
@@ -251,6 +256,7 @@ describe("CDP EVM Wallet Action Provider", () => {
         beforeEach(() => {
             mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
             mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base");
             mockGetTokenDetails.mockResolvedValue({
                 fromTokenDecimals: 18,
                 toTokenDecimals: 6,
@@ -288,6 +294,7 @@ describe("CDP EVM Wallet Action Provider", () => {
                 protocolFamily: "evm",
                 networkId: "ethereum-mainnet",
             });
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("ethereum");
             mockCdpClient.evm.getSwapPrice.mockResolvedValue({
                 toAmount: "990000",
                 minToAmount: "980000",
@@ -337,6 +344,7 @@ describe("CDP EVM Wallet Action Provider", () => {
         beforeEach(() => {
             mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
             mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base");
             mockCdpClient.evm.getAccount.mockResolvedValue(mockAccount);
             mockWalletProvider.waitForTransactionReceipt.mockResolvedValue({ status: "success" });
             mockGetTokenDetails.mockResolvedValue({

package/dist/action-providers/cdp/cdpSmartWalletActionProvider.d.ts

@@ -10,7 +10,6 @@ import type { Network } from "../../network";
  * that are optimized for smart wallet functionality.
  */
 export declare class CdpSmartWalletActionProvider extends ActionProvider<CdpSmartWalletProvider> {
-    #private;
     /**
      * Constructor for the CdpSmartWalletActionProvider class.
      */

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

@@ -8,12 +8,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _CdpSmartWalletActionProvider_instances, _CdpSmartWalletActionProvider_getCdpSdkNetwork;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cdpSmartWalletActionProvider = exports.CdpSmartWalletActionProvider = void 0;
 const zod_1 = require("zod");
@@ -36,7 +30,6 @@ class CdpSmartWalletActionProvider extends actionProvider_1.ActionProvider {
      */
     constructor() {
         super("cdp_smart_wallet", []);
-        _CdpSmartWalletActionProvider_instances.add(this);
         /**
          * Checks if the smart wallet action provider supports the given network.
          *
@@ -73,7 +66,7 @@ class CdpSmartWalletActionProvider extends actionProvider_1.ActionProvider {
      */
     async useSpendPermission(walletProvider, args) {
         const network = walletProvider.getNetwork();
-        const cdpNetwork = __classPrivateFieldGet(this, _CdpSmartWalletActionProvider_instances, "m", _CdpSmartWalletActionProvider_getCdpSdkNetwork).call(this, network.networkId);
+        const cdpNetwork = walletProvider.getCdpSdkNetwork();
         if (network.protocolFamily === "evm") {
             try {
                 const permission = await (0, spendPermissionUtils_1.findLatestSpendPermission)(walletProvider.getClient(), args.smartAccountAddress, walletProvider.getAddress());
@@ -109,8 +102,8 @@ class CdpSmartWalletActionProvider extends actionProvider_1.ActionProvider {
                 error: "CDP Swap API for smart wallets is currently only supported on Base networks.",
             });
         }
-        const cdpNetwork = __classPrivateFieldGet(this, _CdpSmartWalletActionProvider_instances, "m", _CdpSmartWalletActionProvider_getCdpSdkNetwork).call(this, networkId);
         try {
+            const cdpNetwork = walletProvider.getCdpSdkNetwork();
             // Get token details
             const { fromTokenDecimals, toTokenDecimals, fromTokenName, toTokenName } = await (0, swapUtils_1.getTokenDetails)(walletProvider, args.fromToken, args.toToken);
             // Get swap price quote
@@ -164,12 +157,12 @@ class CdpSmartWalletActionProvider extends actionProvider_1.ActionProvider {
                 error: "CDP Swap API for smart wallets is currently only supported on Base networks.",
             });
         }
-        const cdpNetwork = __classPrivateFieldGet(this, _CdpSmartWalletActionProvider_instances, "m", _CdpSmartWalletActionProvider_getCdpSdkNetwork).call(this, networkId);
         // Check if the owner account is a CDP server account
         if (walletProvider.ownerAccount.type === "local") {
             throw new Error("Smart wallet owner account is not a CDP server account.");
         }
         try {
+            const cdpNetwork = walletProvider.getCdpSdkNetwork();
             // Get token details
             const { fromTokenDecimals, fromTokenName, toTokenName, toTokenDecimals } = await (0, swapUtils_1.getTokenDetails)(walletProvider, args.fromToken, args.toToken);
             // Estimate swap price first to check liquidity, token balance and permit2 approval status
@@ -271,16 +264,6 @@ class CdpSmartWalletActionProvider extends actionProvider_1.ActionProvider {
     }
 }
 exports.CdpSmartWalletActionProvider = CdpSmartWalletActionProvider;
-_CdpSmartWalletActionProvider_instances = new WeakSet(), _CdpSmartWalletActionProvider_getCdpSdkNetwork = function _CdpSmartWalletActionProvider_getCdpSdkNetwork(networkId) {
-    switch (networkId) {
-        case "base-sepolia":
-            return "base-sepolia";
-        case "base-mainnet":
-            return "base";
-        default:
-            throw new Error(`Unsupported network for smart wallets: ${networkId}`);
-    }
-};
 __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "list_spend_permissions",

package/dist/action-providers/cdp/cdpSmartWalletActionProvider.test.js

@@ -73,6 +73,7 @@ describe("CDP Smart Wallet Action Provider", () => {
             sendTransaction: jest.fn(),
             waitForTransactionReceipt: jest.fn(),
             getPaymasterUrl: jest.fn(),
+            getCdpSdkNetwork: jest.fn(),
         };
         // Default setup for utility functions
         mockRetryWithExponentialBackoff.mockImplementation(async (fn) => {
@@ -91,6 +92,7 @@ describe("CDP Smart Wallet Action Provider", () => {
             });
             mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
             mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base-sepolia");
         });
         it("should successfully list spend permissions for EVM networks", async () => {
             const expectedResult = "Found 1 spend permission(s):\n1. Token: ETH, Allowance: 1000, Period: 3600 seconds, Start: 123456, End: 234567";
@@ -127,6 +129,7 @@ describe("CDP Smart Wallet Action Provider", () => {
             });
             mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
             mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base-sepolia");
         });
         it("should successfully use spend permission for EVM networks", async () => {
             const mockPermission = {
@@ -157,6 +160,7 @@ describe("CDP Smart Wallet Action Provider", () => {
                 protocolFamily: "evm",
                 networkId: "base-mainnet",
             });
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base");
             const mockPermission = { spender: "0x1234", token: "ETH" };
             const mockSpendResult = { status: "completed" };
             spendPermissionUtils.findLatestSpendPermission.mockResolvedValue(mockPermission);
@@ -173,6 +177,9 @@ describe("CDP Smart Wallet Action Provider", () => {
                 protocolFamily: "evm",
                 networkId: "ethereum-mainnet",
             });
+            mockWalletProvider.getCdpSdkNetwork.mockImplementation(() => {
+                throw new Error("Unsupported network for smart wallets: ethereum-mainnet");
+            });
             await expect(actionProvider.useSpendPermission(mockWalletProvider, mockArgs)).rejects.toThrow("Unsupported network for smart wallets: ethereum-mainnet");
         });
         it("should return error message for non-EVM networks", async () => {
@@ -180,7 +187,7 @@ describe("CDP Smart Wallet Action Provider", () => {
                 protocolFamily: "svm",
                 networkId: "solana-devnet",
             });
-            await expect(actionProvider.useSpendPermission(mockWalletProvider, mockArgs)).rejects.toThrow("Unsupported network for smart wallets: solana-devnet");
+            await expect(actionProvider.useSpendPermission(mockWalletProvider, mockArgs)).rejects.toThrow("Spend permissions are currently only supported on EVM networks.");
         });
         it("should handle spend permission not found error", async () => {
             spendPermissionUtils.findLatestSpendPermission.mockRejectedValue(new Error("No spend permissions found"));
@@ -215,6 +222,7 @@ describe("CDP Smart Wallet Action Provider", () => {
         beforeEach(() => {
             mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
             mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base");
             mockGetTokenDetails.mockResolvedValue({
                 fromTokenDecimals: 18,
                 toTokenDecimals: 6,
@@ -252,6 +260,7 @@ describe("CDP Smart Wallet Action Provider", () => {
                 protocolFamily: "evm",
                 networkId: "base-sepolia",
             });
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base-sepolia");
             mockCdpClient.evm.getSwapPrice.mockResolvedValue({
                 toAmount: "990000",
                 minToAmount: "980000",
@@ -301,6 +310,7 @@ describe("CDP Smart Wallet Action Provider", () => {
         beforeEach(() => {
             mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
             mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
+            mockWalletProvider.getCdpSdkNetwork.mockReturnValue("base");
             mockWalletProvider.waitForTransactionReceipt.mockResolvedValue({ status: "complete" });
             mockWalletProvider.getPaymasterUrl.mockReturnValue("https://paymaster.example");
             mockGetTokenDetails.mockResolvedValue({

package/dist/action-providers/clanker/clankerActionProvider.d.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { EvmWalletProvider } from "../../wallet-providers";
+import { ClankTokenSchema } from "./schemas";
+/**
+ * ClankerActionProvider provides actions for clanker operations.
+ *
+ * @description
+ * This provider is designed to work with EvmWalletProvider for blockchain interactions.
+ * It supports all evm networks.
+ */
+export declare class ClankerActionProvider extends ActionProvider<EvmWalletProvider> {
+    /**
+     * Constructor for the ClankerActionProvider.
+     */
+    constructor();
+    /**
+     * Clanker action provider
+     *
+     * @description
+     * This action deploys a clanker token using the Clanker sdk
+     * It automatically includes the coin in the Clanker ecosystem
+     *
+     * @param walletProvider - The wallet provider instance for blockchain interactions
+     * @param args - Clanker arguments (modify these to fine tune token deployment, like initial quote token and rewards config)
+     * @returns A promise that resolves to a string describing the clanker result
+     */
+    clankToken(walletProvider: EvmWalletProvider, args: z.infer<typeof ClankTokenSchema>): Promise<string>;
+    /**
+     * Checks if this provider supports the given network.
+     *
+     * @param network - The network to check support for
+     * @returns True if the network is supported
+     */
+    supportsNetwork(network: Network): boolean;
+}
+/**
+ * Factory function to create a new ClankerActionProvider instance.
+ *
+ * @returns A new ClankerActionProvider instance
+ */
+export declare const clankerActionProvider: () => ClankerActionProvider;

package/dist/action-providers/clanker/clankerActionProvider.js

@@ -0,0 +1,130 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clankerActionProvider = exports.ClankerActionProvider = void 0;
+const zod_1 = require("zod");
+const actionProvider_1 = require("../actionProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const wallet_providers_1 = require("../../wallet-providers");
+const schemas_1 = require("./schemas");
+const utils_1 = require("./utils");
+/**
+ * ClankerActionProvider provides actions for clanker operations.
+ *
+ * @description
+ * This provider is designed to work with EvmWalletProvider for blockchain interactions.
+ * It supports all evm networks.
+ */
+class ClankerActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the ClankerActionProvider.
+     */
+    constructor() {
+        super("clanker", []);
+    }
+    /**
+     * Clanker action provider
+     *
+     * @description
+     * This action deploys a clanker token using the Clanker sdk
+     * It automatically includes the coin in the Clanker ecosystem
+     *
+     * @param walletProvider - The wallet provider instance for blockchain interactions
+     * @param args - Clanker arguments (modify these to fine tune token deployment, like initial quote token and rewards config)
+     * @returns A promise that resolves to a string describing the clanker result
+     */
+    async clankToken(walletProvider, args) {
+        const network = walletProvider.getNetwork();
+        const networkId = network.networkId || "base-mainnet";
+        if (!this.supportsNetwork(network)) {
+            return `Can't Clank token; network ${networkId} is not supported`;
+        }
+        const clanker = await (0, utils_1.createClankerClient)(walletProvider, networkId);
+        const lockDuration = args.lockDuration_Days * 24 * 60 * 60;
+        const vestingDuration = args.vestingDuration_Days * 24 * 60 * 60;
+        const tokenConfig = {
+            name: args.tokenName,
+            symbol: args.tokenSymbol,
+            image: args.image,
+            metadata: {
+                socialMediaUrls: args.socialMediaUrls,
+                description: args.description,
+            },
+            context: {
+                interface: args.interface,
+                id: args.id,
+            },
+            tokenAdmin: walletProvider.getAddress(),
+            vault: {
+                percentage: args.vaultPercentage,
+                lockupDuration: lockDuration,
+                vestingDuration: vestingDuration,
+            },
+            chainId: Number(network.chainId),
+        };
+        try {
+            const res = await clanker.deploy(tokenConfig);
+            if ("error" in res) {
+                return `There was an error deploying the clanker token: ${res}`;
+            }
+            const { txHash } = res;
+            const confirmed = await res.waitForTransaction();
+            if ("error" in confirmed) {
+                return `There was an error confirming the clanker token deployment: ${confirmed}`;
+            }
+            const { address } = confirmed;
+            return `Clanker token deployed at ${address}!  View the transaction at ${txHash}, or view the token page at https://clanker.world/clanker/${address}`;
+        }
+        catch (error) {
+            return `There was an error deploying the clanker token: ${error}`;
+        }
+    }
+    /**
+     * Checks if this provider supports the given network.
+     *
+     * @param network - The network to check support for
+     * @returns True if the network is supported
+     */
+    supportsNetwork(network) {
+        return (network.networkId === "base-mainnet" ||
+            network.networkId === "base-sepolia" ||
+            network.networkId === "arbitrum-mainnet");
+    }
+}
+exports.ClankerActionProvider = ClankerActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "clank_token",
+        description: `
+his tool will launch a Clanker token using the Clanker SDK.
+It takes the following inputs:
+- tokenName: The name of the deployed token
+- tokenSymbol: The symbol of the deployed token  
+- description: An optional description of the token or token project
+- socialMediaUrls: An optional array of social media links for the token, each with a platform and url
+- image: A normal or ipfs URL pointing to the image of the token
+- vaultPercentage: The percentage of the token supply to allocate to a vault accessible to the deployed after the lockup period with optional vesting
+- lockDuration_Days: The lock duration of the tokens in the vault (in days) (minimum 7 days)
+- vestingDuration_Days: The duration (in days) that the token should vest after lockup period, vesting is linear.
+  `,
+        schema: schemas_1.ClankTokenSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], ClankerActionProvider.prototype, "clankToken", null);
+/**
+ * Factory function to create a new ClankerActionProvider instance.
+ *
+ * @returns A new ClankerActionProvider instance
+ */
+const clankerActionProvider = () => new ClankerActionProvider();
+exports.clankerActionProvider = clankerActionProvider;

package/dist/action-providers/clanker/clankerActionProvider.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Clanker Action Provider tests
+ */
+export {};

package/dist/action-providers/clanker/clankerActionProvider.test.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * Clanker Action Provider tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const clankerActionProvider_1 = require("./clankerActionProvider");
+const schemas_1 = require("./schemas");
+const utils_1 = require("./utils");
+jest.mock("./utils", () => ({
+    createClankerClient: jest.fn(),
+}));
+const createClankerClientMock = utils_1.createClankerClient;
+const DEPLOYED_HASH = "0xdeadbeef";
+const DEPLOYED_TOKEN_ADDRESS = "0xabc123abc123abc123abc123abc123abc123abc1";
+describe("Clanker action provider tests", () => {
+    const provider = (0, clankerActionProvider_1.clankerActionProvider)();
+    let mockWalletProvider;
+    beforeEach(() => {
+        mockWalletProvider = {
+            getAddress: jest.fn(),
+            getBalance: jest.fn(),
+            getName: jest.fn(),
+            getNetwork: jest.fn().mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            }),
+            nativeTransfer: jest.fn(),
+        };
+        const fakeClanker = {
+            deploy: jest.fn(async (_tokenCfg) => ({
+                txHash: DEPLOYED_HASH,
+                waitForTransaction: async () => ({ address: DEPLOYED_TOKEN_ADDRESS }),
+            })),
+        };
+        createClankerClientMock.mockResolvedValue(fakeClanker);
+    });
+    describe("network validation", () => {
+        it("should support the protocol family and network", () => {
+            expect(provider.supportsNetwork({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            })).toBe(true);
+        });
+        it("should not support other protocol families", () => {
+            expect(provider.supportsNetwork({
+                protocolFamily: "other-protocol-family",
+            })).toBe(false);
+        });
+        it("should handle invalid network objects", () => {
+            expect(provider.supportsNetwork({ protocolFamily: "invalid-protocol" })).toBe(false);
+            expect(provider.supportsNetwork({})).toBe(false);
+        });
+    });
+    describe("schema validation", () => {
+        it("should validate example action schema", () => {
+            const validInput = {
+                tokenName: "testTokenName",
+                tokenSymbol: "TTN",
+                image: "https://test.com",
+                vaultPercentage: 10,
+                vestingDuration_Days: 30,
+                lockDuration_Days: 30,
+                interface: "CDP AgentKit",
+                id: "test-id",
+            };
+            const parseResult = schemas_1.ClankTokenSchema.safeParse(validInput);
+            expect(parseResult.success).toBe(true);
+            if (parseResult.success) {
+                expect(parseResult.data.tokenName).toBe("testTokenName");
+                expect(parseResult.data.tokenSymbol).toBe("TTN");
+                expect(parseResult.data.image).toBe("https://test.com");
+                expect(parseResult.data.vaultPercentage).toBe(10);
+                expect(parseResult.data.vestingDuration_Days).toBe(30);
+                expect(parseResult.data.lockDuration_Days).toBe(30);
+            }
+        });
+        it("should reject invalid example action input", () => {
+            const invalidInput = {
+                fieldName: "",
+                amount: "invalid",
+            };
+            const parseResult = schemas_1.ClankTokenSchema.safeParse(invalidInput);
+            expect(parseResult.success).toBe(false);
+        });
+    });
+    describe("clanker action execution", () => {
+        it("should execute the clanker action with wallet provider", async () => {
+            const args = {
+                tokenName: "testTokenName",
+                tokenSymbol: "TTN",
+                image: "https://test.com",
+                vaultPercentage: 10,
+                vestingDuration_Days: 30,
+                lockDuration_Days: 30,
+                interface: "CDP AgentKit",
+                id: "test-id",
+            };
+            const result = await provider.clankToken(mockWalletProvider, args);
+            expect(result).toContain(`Clanker token deployed at ${DEPLOYED_TOKEN_ADDRESS}`);
+            expect(result).toContain(`View the transaction at ${DEPLOYED_HASH}`);
+            expect(mockWalletProvider.getNetwork).toHaveBeenCalled();
+            expect(createClankerClientMock).toHaveBeenCalledWith(expect.any(Object), expect.any(String));
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for base-mainnet with evm protocol", () => {
+            expect(provider.supportsNetwork({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            })).toBe(true);
+        });
+        it("should return false for non-base networks", () => {
+            expect(provider.supportsNetwork({
+                protocolFamily: "evm",
+                networkId: "ethereum-mainnet",
+            })).toBe(false);
+        });
+    });
+});

package/dist/action-providers/clanker/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./clankerActionProvider";
+export * from "./schemas";

package/dist/action-providers/clanker/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./clankerActionProvider"), exports);
+__exportStar(require("./schemas"), exports);

package/dist/action-providers/clanker/schemas.d.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+/**
+ * Action schemas for the clanker action provider.
+ *
+ * This file contains the Zod schemas that define the shape and validation
+ * rules for action parameters in the clanker action provider.
+ */
+export declare const ClankTokenSchema: z.ZodObject<{
+    tokenName: z.ZodString;
+    tokenSymbol: z.ZodString;
+    image: z.ZodString;
+    vaultPercentage: z.ZodNumber;
+    lockDuration_Days: z.ZodNumber;
+    vestingDuration_Days: z.ZodNumber;
+    description: z.ZodOptional<z.ZodString>;
+    socialMediaUrls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        platform: z.ZodString;
+        url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        platform: string;
+    }, {
+        url: string;
+        platform: string;
+    }>, "many">>;
+    interface: z.ZodDefault<z.ZodString>;
+    id: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    tokenSymbol: string;
+    image: string;
+    tokenName: string;
+    vaultPercentage: number;
+    lockDuration_Days: number;
+    vestingDuration_Days: number;
+    interface: string;
+    description?: string | undefined;
+    socialMediaUrls?: {
+        url: string;
+        platform: string;
+    }[] | undefined;
+}, {
+    tokenSymbol: string;
+    image: string;
+    tokenName: string;
+    vaultPercentage: number;
+    lockDuration_Days: number;
+    vestingDuration_Days: number;
+    id?: string | undefined;
+    description?: string | undefined;
+    socialMediaUrls?: {
+        url: string;
+        platform: string;
+    }[] | undefined;
+    interface?: string | undefined;
+}>;

package/dist/action-providers/clanker/schemas.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClankTokenSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Action schemas for the clanker action provider.
+ *
+ * This file contains the Zod schemas that define the shape and validation
+ * rules for action parameters in the clanker action provider.
+ */
+exports.ClankTokenSchema = zod_1.z
+    .object({
+    tokenName: zod_1.z.string().min(1).max(100).describe("The name of the token (max 100 characters)"),
+    tokenSymbol: zod_1.z.string().min(1).max(10).describe("The symbol of the token (max 10 characters)"),
+    image: zod_1.z.string().url().describe("Normal or ipfs URL pointing to the token image"),
+    vaultPercentage: zod_1.z
+        .number()
+        .min(0)
+        .max(90)
+        .describe("Percentage of token supply allocated to a vault that can be claimed by deployer after lockup period with optional vesting"),
+    lockDuration_Days: zod_1.z
+        .number()
+        .min(7)
+        .describe("Lockup duration of token (in days), minimum 7 days"),
+    vestingDuration_Days: zod_1.z
+        .number()
+        .min(0)
+        .describe("Vesting duration of token after lockup has passed (in days). Vesting is linear over the duration"),
+    description: zod_1.z
+        .string()
+        .optional()
+        .describe("Description of the token or token project (optional)"),
+    socialMediaUrls: zod_1.z
+        .array(zod_1.z.object({ platform: zod_1.z.string(), url: zod_1.z.string() }))
+        .optional()
+        .describe("Socials for the token. These may be displayed on aggregators."),
+    interface: zod_1.z
+        .string()
+        .default("CDP AgentKit")
+        .describe('System the token was deployed via. Defaults to "CDP AgentKit".'),
+    id: zod_1.z
+        .string()
+        .default("")
+        .describe("User id of the poster on the social platform the token was deployed from. Used for provenance and will be verified by aggregators."),
+})
+    .strip()
+    .describe("Instructions for deploying a Clanker token");

package/dist/action-providers/clanker/utils.d.ts

@@ -0,0 +1,9 @@
+import { EvmWalletProvider } from "../../wallet-providers";
+/**
+ * Creates the client Clanker expects from the EvmWalletProvider
+ *
+ * @param walletProvider - The wallet provider instance for blockchain interactions
+ * @param networkId - The network to Clank on
+ * @returns The Clanker implementation
+ */
+export declare function createClankerClient(walletProvider: EvmWalletProvider, networkId: string): Promise<import("clanker-sdk/v4", { with: { "resolution-mode": "import" } }).Clanker>;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClankerClient = createClankerClient;
+const viem_1 = require("viem");
+const network_1 = require("../../network");
+/**
+ * Creates the client Clanker expects from the EvmWalletProvider
+ *
+ * @param walletProvider - The wallet provider instance for blockchain interactions
+ * @param networkId - The network to Clank on
+ * @returns The Clanker implementation
+ */
+async function createClankerClient(walletProvider, networkId) {
+    const { Clanker } = await import("clanker-sdk/v4");
+    const account = walletProvider.toSigner();
+    const publicClient = walletProvider.getPublicClient();
+    const wallet = (0, viem_1.createWalletClient)({
+        account,
+        chain: network_1.NETWORK_ID_TO_VIEM_CHAIN[networkId],
+        transport: (0, viem_1.http)(publicClient.transport.url),
+    });
+    return new Clanker({ wallet, publicClient });
+}

package/dist/action-providers/index.d.ts

@@ -33,3 +33,4 @@ export * from "./zerion";
 export * from "./zerodev";
 export * from "./zeroX";
 export * from "./zora";
+export * from "./clanker";

package/dist/action-providers/index.js

@@ -49,3 +49,4 @@ __exportStar(require("./zerion"), exports);
 __exportStar(require("./zerodev"), exports);
 __exportStar(require("./zeroX"), exports);
 __exportStar(require("./zora"), exports);
+__exportStar(require("./clanker"), exports);

package/dist/action-providers/pyth/pythActionProvider.js

@@ -37,6 +37,11 @@ class PythActionProvider extends actionProvider_1.ActionProvider {
      * @returns The price feed ID as a string.
      */
     async fetchPriceFeed(args) {
+        // Stop-gap solution: Return hardcoded price feed ID for ETH
+        // This is temporary until proper new API link is provided after talking to the Pyth team
+        if (args.tokenSymbol.toUpperCase() === "ETH") {
+            return "0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace";
+        }
         const url = `https://hermes.pyth.network/v2/price_feeds?query=${args.tokenSymbol}&asset_type=crypto`;
         const response = await fetch(url);
         if (!response.ok) {

package/dist/action-providers/pyth/pythActionProvider.test.js

@@ -22,7 +22,11 @@ describe("PythActionProvider", () => {
                 ok: true,
                 json: async () => [{ id: "some-price-feed-id", attributes: { base: "BTC" } }],
             });
-            await expect(provider.fetchPriceFeed({ tokenSymbol: "ETH" })).rejects.toThrow("No price feed found for ETH");
+            await expect(provider.fetchPriceFeed({ tokenSymbol: "SOL" })).rejects.toThrow("No price feed found for SOL");
+        });
+        it("should return hardcoded price feed ID for ETH", async () => {
+            const priceFeedId = await provider.fetchPriceFeed({ tokenSymbol: "ETH" });
+            expect(priceFeedId).toEqual("0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace");
         });
         it("should throw an error if the response is not ok", async () => {
             fetchMock.mockResolvedValueOnce({

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

@@ -3,6 +3,10 @@ import { Abi, Address, ContractFunctionArgs, ContractFunctionName, Hex, PublicCl
 import { Network } from "../network";
 import { EvmWalletProvider } from "./evmWalletProvider";
 import { WalletProviderWithClient, CdpWalletProviderConfig } from "./cdpShared";
+/**
+ * Supported network types for CDP SDK EVM transactions
+ */
+type CdpEvmNetwork = "base" | "base-sepolia" | "ethereum" | "ethereum-sepolia" | "polygon" | "arbitrum" | "optimism";
 /**
  * A wallet provider that uses the Coinbase SDK.
  */
@@ -117,4 +121,12 @@ export declare class CdpEvmWalletProvider extends EvmWalletProvider implements W
      * @returns The transaction hash.
      */
     nativeTransfer(to: Address, value: string): Promise<Hex>;
+    /**
+     * Converts the internal network ID to the format expected by the CDP SDK.
+     *
+     * @returns The network ID in CDP SDK format
+     * @throws Error if the network is not supported
+     */
+    getCdpSdkNetwork(): CdpEvmNetwork;
 }
+export {};

package/dist/wallet-providers/cdpEvmWalletProvider.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _CdpEvmWalletProvider_instances, _CdpEvmWalletProvider_publicClient, _CdpEvmWalletProvider_serverAccount, _CdpEvmWalletProvider_cdp, _CdpEvmWalletProvider_network, _CdpEvmWalletProvider_getCdpSdkNetwork;
+var _CdpEvmWalletProvider_publicClient, _CdpEvmWalletProvider_serverAccount, _CdpEvmWalletProvider_cdp, _CdpEvmWalletProvider_network;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CdpEvmWalletProvider = void 0;
 const cdp_sdk_1 = require("@coinbase/cdp-sdk");
@@ -28,7 +28,6 @@ class CdpEvmWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
      */
     constructor(config) {
         super();
-        _CdpEvmWalletProvider_instances.add(this);
         _CdpEvmWalletProvider_publicClient.set(this, void 0);
         _CdpEvmWalletProvider_serverAccount.set(this, void 0);
         _CdpEvmWalletProvider_cdp.set(this, void 0);
@@ -153,7 +152,7 @@ class CdpEvmWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         const result = await __classPrivateFieldGet(this, _CdpEvmWalletProvider_cdp, "f").evm.sendTransaction({
             address: __classPrivateFieldGet(this, _CdpEvmWalletProvider_serverAccount, "f").address,
             transaction: (0, viem_1.serializeTransaction)(txWithGasParams),
-            network: __classPrivateFieldGet(this, _CdpEvmWalletProvider_instances, "m", _CdpEvmWalletProvider_getCdpSdkNetwork).call(this),
+            network: this.getCdpSdkNetwork(),
         });
         return result.transactionHash;
     }
@@ -238,25 +237,32 @@ class CdpEvmWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
             data: "0x",
         });
     }
+    /**
+     * Converts the internal network ID to the format expected by the CDP SDK.
+     *
+     * @returns The network ID in CDP SDK format
+     * @throws Error if the network is not supported
+     */
+    getCdpSdkNetwork() {
+        switch (__classPrivateFieldGet(this, _CdpEvmWalletProvider_network, "f").networkId) {
+            case "base-sepolia":
+                return "base-sepolia";
+            case "base-mainnet":
+                return "base";
+            case "ethereum-mainnet":
+                return "ethereum";
+            case "ethereum-sepolia":
+                return "ethereum-sepolia";
+            case "polygon-mainnet":
+                return "polygon";
+            case "arbitrum-mainnet":
+                return "arbitrum";
+            case "optimism-mainnet":
+                return "optimism";
+            default:
+                throw new Error(`Unsupported network for CDP SDK: ${__classPrivateFieldGet(this, _CdpEvmWalletProvider_network, "f").networkId}`);
+        }
+    }
 }
 exports.CdpEvmWalletProvider = CdpEvmWalletProvider;
-_CdpEvmWalletProvider_publicClient = new WeakMap(), _CdpEvmWalletProvider_serverAccount = new WeakMap(), _CdpEvmWalletProvider_cdp = new WeakMap(), _CdpEvmWalletProvider_network = new WeakMap(), _CdpEvmWalletProvider_instances = new WeakSet(), _CdpEvmWalletProvider_getCdpSdkNetwork = function _CdpEvmWalletProvider_getCdpSdkNetwork() {
-    switch (__classPrivateFieldGet(this, _CdpEvmWalletProvider_network, "f").networkId) {
-        case "base-sepolia":
-            return "base-sepolia";
-        case "base-mainnet":
-            return "base";
-        case "ethereum-mainnet":
-            return "ethereum";
-        case "ethereum-sepolia":
-            return "ethereum-sepolia";
-        case "polygon-mainnet":
-            return "polygon";
-        case "arbitrum-mainnet":
-            return "arbitrum";
-        case "optimism-mainnet":
-            return "optimism";
-        default:
-            throw new Error(`Unsupported network for CDP SDK: ${__classPrivateFieldGet(this, _CdpEvmWalletProvider_network, "f").networkId}`);
-    }
-};
+_CdpEvmWalletProvider_publicClient = new WeakMap(), _CdpEvmWalletProvider_serverAccount = new WeakMap(), _CdpEvmWalletProvider_cdp = new WeakMap(), _CdpEvmWalletProvider_network = new WeakMap();

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

@@ -3,6 +3,10 @@ import { Abi, Address, ContractFunctionArgs, ContractFunctionName, Hex, PublicCl
 import { Network } from "../network";
 import { EvmWalletProvider } from "./evmWalletProvider";
 import { WalletProviderWithClient, CdpSmartWalletProviderConfig } from "./cdpShared";
+/**
+ * Supported network types for CDP SDK smart wallet operations
+ */
+type CdpSmartWalletNetwork = "base" | "base-sepolia" | "ethereum" | "ethereum-sepolia" | "polygon" | "arbitrum" | "optimism";
 /**
  * A wallet provider that uses the Coinbase CDP SDK smart wallets.
  */
@@ -126,4 +130,12 @@ export declare class CdpSmartWalletProvider extends EvmWalletProvider implements
      * @returns The user operation hash.
      */
     nativeTransfer(to: Address, value: string): Promise<Hex>;
+    /**
+     * Converts the internal network ID to the format expected by the CDP SDK.
+     *
+     * @returns The network ID in CDP SDK format
+     * @throws Error if the network is not supported
+     */
+    getCdpSdkNetwork(): CdpSmartWalletNetwork;
 }
+export {};

package/dist/wallet-providers/cdpSmartWalletProvider.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _CdpSmartWalletProvider_instances, _CdpSmartWalletProvider_publicClient, _CdpSmartWalletProvider_cdp, _CdpSmartWalletProvider_network, _CdpSmartWalletProvider_paymasterUrl, _CdpSmartWalletProvider_getCdpSdkNetwork;
+var _CdpSmartWalletProvider_publicClient, _CdpSmartWalletProvider_cdp, _CdpSmartWalletProvider_network, _CdpSmartWalletProvider_paymasterUrl;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CdpSmartWalletProvider = void 0;
 const cdp_sdk_1 = require("@coinbase/cdp-sdk");
@@ -28,7 +28,6 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
      */
     constructor(config) {
         super();
-        _CdpSmartWalletProvider_instances.add(this);
         _CdpSmartWalletProvider_publicClient.set(this, void 0);
         _CdpSmartWalletProvider_cdp.set(this, void 0);
         _CdpSmartWalletProvider_network.set(this, void 0);
@@ -140,7 +139,7 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
             types,
             primaryType,
             message,
-            network: __classPrivateFieldGet(this, _CdpSmartWalletProvider_instances, "m", _CdpSmartWalletProvider_getCdpSdkNetwork).call(this),
+            network: this.getCdpSdkNetwork(),
         });
     }
     /**
@@ -168,7 +167,7 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         ];
         const userOperation = await __classPrivateFieldGet(this, _CdpSmartWalletProvider_cdp, "f").evm.sendUserOperation({
             smartAccount: this.smartAccount,
-            network: __classPrivateFieldGet(this, _CdpSmartWalletProvider_instances, "m", _CdpSmartWalletProvider_getCdpSdkNetwork).call(this),
+            network: this.getCdpSdkNetwork(),
             calls,
             paymasterUrl: __classPrivateFieldGet(this, _CdpSmartWalletProvider_paymasterUrl, "f"),
         });
@@ -269,25 +268,32 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
             data: "0x",
         });
     }
+    /**
+     * Converts the internal network ID to the format expected by the CDP SDK.
+     *
+     * @returns The network ID in CDP SDK format
+     * @throws Error if the network is not supported
+     */
+    getCdpSdkNetwork() {
+        switch (__classPrivateFieldGet(this, _CdpSmartWalletProvider_network, "f").networkId) {
+            case "base-sepolia":
+                return "base-sepolia";
+            case "base-mainnet":
+                return "base";
+            case "ethereum-mainnet":
+                return "ethereum";
+            case "ethereum-sepolia":
+                return "ethereum-sepolia";
+            case "polygon-mainnet":
+                return "polygon";
+            case "arbitrum-mainnet":
+                return "arbitrum";
+            case "optimism-mainnet":
+                return "optimism";
+            default:
+                throw new Error(`Unsupported network for smart wallets: ${__classPrivateFieldGet(this, _CdpSmartWalletProvider_network, "f").networkId}`);
+        }
+    }
 }
 exports.CdpSmartWalletProvider = CdpSmartWalletProvider;
-_CdpSmartWalletProvider_publicClient = new WeakMap(), _CdpSmartWalletProvider_cdp = new WeakMap(), _CdpSmartWalletProvider_network = new WeakMap(), _CdpSmartWalletProvider_paymasterUrl = new WeakMap(), _CdpSmartWalletProvider_instances = new WeakSet(), _CdpSmartWalletProvider_getCdpSdkNetwork = function _CdpSmartWalletProvider_getCdpSdkNetwork() {
-    switch (__classPrivateFieldGet(this, _CdpSmartWalletProvider_network, "f").networkId) {
-        case "base-sepolia":
-            return "base-sepolia";
-        case "base-mainnet":
-            return "base";
-        case "ethereum-mainnet":
-            return "ethereum";
-        case "ethereum-sepolia":
-            return "ethereum-sepolia";
-        case "polygon-mainnet":
-            return "polygon";
-        case "arbitrum-mainnet":
-            return "arbitrum";
-        case "optimism-mainnet":
-            return "optimism";
-        default:
-            throw new Error(`Unsupported network for smart wallets: ${__classPrivateFieldGet(this, _CdpSmartWalletProvider_network, "f").networkId}`);
-    }
-};
+_CdpSmartWalletProvider_publicClient = new WeakMap(), _CdpSmartWalletProvider_cdp = new WeakMap(), _CdpSmartWalletProvider_network = new WeakMap(), _CdpSmartWalletProvider_paymasterUrl = new WeakMap();

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-20250905210407",
+  "version": "0.0.0-nightly-20250906210355",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -24,7 +24,7 @@
   "dependencies": {
     "@across-protocol/app-sdk": "^0.2.0",
     "@alloralabs/allora-sdk": "^0.1.0",
-    "@coinbase/cdp-sdk": "^1.36.0",
+    "@coinbase/cdp-sdk": "^1.36.1",
     "@coinbase/coinbase-sdk": "^0.20.0",
     "@jup-ag/api": "^6.0.39",
     "@privy-io/public-api": "2.18.5",
@@ -38,6 +38,7 @@
     "axios": "^1.9.0",
     "bs58": "^4.0.1",
     "canonicalize": "^2.1.0",
+    "clanker-sdk": "^4.1.18",
     "decimal.js": "^10.5.0",
     "ethers": "^6.13.5",
     "graphql-request": "^7.2.0",