@coinbase/agentkit 0.9.0 → 0.10.0

package/dist/action-providers/zora/zoraActionProvider.js

@@ -0,0 +1,151 @@
+"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);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+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 _ZoraActionProvider_pinataJwt;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zoraActionProvider = exports.ZoraActionProvider = void 0;
+const zod_1 = require("zod");
+const actionProvider_1 = require("../actionProvider");
+const evmWalletProvider_1 = require("../../wallet-providers/evmWalletProvider");
+const schemas_1 = require("./schemas");
+const actionDecorator_1 = require("../actionDecorator");
+const viem_1 = require("viem");
+const utils_1 = require("./utils");
+const SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia"];
+/**
+ * ZoraActionProvider provides actions for interacting with the Zora protocol.
+ */
+class ZoraActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the ZoraActionProvider.
+     */
+    constructor() {
+        super("zora", []);
+        _ZoraActionProvider_pinataJwt.set(this, void 0);
+        /**
+         * Checks if the Zora action provider supports the given network.
+         *
+         * @param network - The network to check.
+         * @returns True if the Zora action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (network) => network.protocolFamily === "evm" && SUPPORTED_NETWORKS.includes(network.networkId);
+        // Set Pinata JWT
+        const pinataJwt = process.env.PINATA_JWT;
+        if (!pinataJwt) {
+            throw new Error("PINATA_JWT is not configured. Required for IPFS uploads.");
+        }
+        __classPrivateFieldSet(this, _ZoraActionProvider_pinataJwt, pinataJwt, "f");
+    }
+    /**
+     * Creates a new Zora coin.
+     *
+     * @param walletProvider - The wallet provider to use for the transaction.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the coin creation details.
+     */
+    async createCoin(walletProvider, args) {
+        try {
+            // Generate token URI from local file or URI
+            const { uri, imageUri } = await (0, utils_1.generateZoraTokenUri)({
+                name: args.name,
+                symbol: args.symbol,
+                description: args.description,
+                image: args.image,
+                category: args.category,
+                pinataConfig: { jwt: __classPrivateFieldGet(this, _ZoraActionProvider_pinataJwt, "f") },
+            });
+            // Dynamically import Zora SDK
+            const { createCoinCall, DeployCurrency, getCoinCreateFromLogs } = await import("@zoralabs/coins-sdk");
+            // Create coin call
+            const call = {
+                name: args.name,
+                symbol: args.symbol,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                uri: uri,
+                payoutRecipient: args.payoutRecipient || walletProvider.getAddress(),
+                platformReferrer: args.platformReferrer || "0x0000000000000000000000000000000000000000",
+                currency: args.currency === "ZORA" ? DeployCurrency.ZORA : DeployCurrency.ETH,
+            };
+            const createCoinRequest = await createCoinCall(call);
+            const { abi, functionName, address, args: callArgs, value } = createCoinRequest;
+            const data = (0, viem_1.encodeFunctionData)({ abi, functionName, args: callArgs });
+            const txRequest = { to: address, data, value };
+            // Send transaction
+            const hash = await walletProvider.sendTransaction(txRequest);
+            const receipt = await walletProvider.waitForTransactionReceipt(hash);
+            const deployment = getCoinCreateFromLogs(receipt);
+            if (receipt.status === "success") {
+                return JSON.stringify({
+                    success: true,
+                    transactionHash: hash,
+                    coinAddress: deployment?.coin,
+                    imageUri,
+                    uri,
+                    deployment,
+                    ...(walletProvider.getNetwork().networkId === "base-mainnet" &&
+                        deployment?.coin && {
+                        zoraURL: `https://zora.co/coin/base:${deployment.coin}`,
+                    }),
+                });
+            }
+            else {
+                throw new Error("Coin creation transaction reverted");
+            }
+        }
+        catch (error) {
+            return JSON.stringify({
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+}
+exports.ZoraActionProvider = ZoraActionProvider;
+_ZoraActionProvider_pinataJwt = new WeakMap();
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "coinIt",
+        description: `
+This tool will create a new Zora coin.
+It takes the following parameters:
+- name: The name of the coin
+- symbol: The symbol of the coin
+- image: Local image file path or URI (ipfs:// or https://)
+- description: The description of the coin
+- payoutRecipient: The address that will receive creator earnings (optional, defaults to the wallet address)
+- platformReferrer: The address that will receive platform referrer fees (optional, defaults to 0x0000000000000000000000000000000000000000)
+- category: The category of the coin (optional, defaults to 'social')
+- currency: The currency for deployment, can be 'ZORA' or 'ETH'. Determines which token will be used for the trading pair (optional, defaults to 'ZORA').
+The action will return the transaction hash, coin address, and deployment details upon success.
+`,
+        schema: schemas_1.CreateCoinSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [evmWalletProvider_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], ZoraActionProvider.prototype, "createCoin", null);
+/**
+ * Factory function to create a new ZoraActionProvider instance.
+ *
+ * @returns A new ZoraActionProvider instance
+ */
+const zoraActionProvider = () => new ZoraActionProvider();
+exports.zoraActionProvider = zoraActionProvider;

package/dist/action-providers/zora/zoraActionProvider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/action-providers/zora/zoraActionProvider.test.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zoraActionProvider_1 = require("./zoraActionProvider");
+const schemas_1 = require("./schemas");
+// Mock viem's encodeFunctionData function to prevent ABI errors
+jest.mock("viem", () => {
+    const originalModule = jest.requireActual("viem");
+    return {
+        ...originalModule,
+        encodeFunctionData: jest.fn().mockReturnValue("0x1234"),
+    };
+});
+// Mock the dynamically imported Zora SDK
+jest.mock("@zoralabs/coins-sdk", () => ({
+    createCoinCall: jest.fn().mockResolvedValue({
+        abi: [{ name: "createCoin" }], // Add a minimal abi to prevent "function not found" error
+        functionName: "createCoin",
+        address: "0x1234567890123456789012345678901234567890",
+        args: [],
+        value: BigInt(0),
+    }),
+    getCoinCreateFromLogs: jest.fn().mockReturnValue({
+        coin: "0x2345678901234567890123456789012345678901",
+    }),
+    DeployCurrency: {
+        ZORA: "ZORA",
+        ETH: "ETH",
+    },
+}), { virtual: true });
+// Mock the utils module
+jest.mock("./utils", () => ({
+    generateZoraTokenUri: jest.fn().mockResolvedValue({
+        uri: "ipfs://testCID",
+        imageUri: "ipfs://testImageCID",
+    }),
+}));
+describe("ZoraActionProvider", () => {
+    const MOCK_TX_HASH = "0xabcdef1234567890";
+    const MOCK_ADDRESS = "0x9876543210987654321098765432109876543210";
+    let provider;
+    let mockWalletProvider;
+    let originalPinataJwt;
+    beforeEach(() => {
+        // Reset mocks between tests
+        jest.clearAllMocks();
+        originalPinataJwt = process.env.PINATA_JWT;
+        process.env.PINATA_JWT = "test-jwt";
+        // Create the provider
+        provider = new zoraActionProvider_1.ZoraActionProvider();
+        // Set up the mock wallet provider
+        mockWalletProvider = {
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            getNetwork: jest.fn().mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-sepolia",
+            }),
+            sendTransaction: jest.fn().mockResolvedValue(MOCK_TX_HASH),
+            waitForTransactionReceipt: jest.fn().mockResolvedValue({
+                status: "success",
+                logs: [],
+            }),
+        };
+    });
+    afterEach(() => {
+        process.env.PINATA_JWT = originalPinataJwt;
+    });
+    describe("constructor", () => {
+        it("should throw an error if Pinata JWT is not provided", () => {
+            delete process.env.PINATA_JWT;
+            expect(() => new zoraActionProvider_1.ZoraActionProvider()).toThrow("PINATA_JWT is not configured. Required for IPFS uploads.");
+        });
+        it("should create provider with Pinata JWT from environment", () => {
+            expect(new zoraActionProvider_1.ZoraActionProvider()).toBeInstanceOf(zoraActionProvider_1.ZoraActionProvider);
+        });
+    });
+    describe("supportsNetwork", () => {
+        const testCases = [
+            { network: { protocolFamily: "evm", networkId: "base-mainnet" }, expected: true },
+            { network: { protocolFamily: "evm", networkId: "base-sepolia" }, expected: true },
+            { network: { protocolFamily: "evm", networkId: "ethereum" }, expected: false },
+            { network: { protocolFamily: "solana", networkId: "base-mainnet" }, expected: false },
+        ];
+        testCases.forEach(({ network, expected }) => {
+            it(`should ${expected ? "support" : "not support"} ${network.protocolFamily}/${network.networkId}`, () => {
+                expect(provider.supportsNetwork(network)).toBe(expected);
+            });
+        });
+    });
+    describe("createCoin", () => {
+        it("should validate createCoin schema", () => {
+            const validInput = {
+                name: "Test Coin",
+                symbol: "TEST",
+                description: "A test coin",
+                image: "https://example.com/image.png",
+                category: "social",
+                currency: "ZORA",
+            };
+            const parseResult = schemas_1.CreateCoinSchema.safeParse(validInput);
+            expect(parseResult.success).toBe(true);
+        });
+        it("should reject invalid input", () => {
+            const invalidInput = {
+                name: "Test Coin",
+                symbol: "TEST",
+                description: "A test coin",
+                image: "https://example.com/image.png",
+                category: "social",
+                currency: "ZORA",
+                payoutRecipient: "invalid-address", // Should be 0x format
+            };
+            const parseResult = schemas_1.CreateCoinSchema.safeParse(invalidInput);
+            expect(parseResult.success).toBe(false);
+        });
+        it("should successfully create a coin", async () => {
+            const args = {
+                name: "Test Coin",
+                symbol: "TEST",
+                description: "A test coin",
+                image: "https://example.com/image.png",
+                category: "social",
+                currency: "ZORA",
+            };
+            const result = await provider.createCoin(mockWalletProvider, args);
+            const parsedResult = JSON.parse(result);
+            expect(mockWalletProvider.sendTransaction).toHaveBeenCalled();
+            expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
+            expect(parsedResult.success).toBe(true);
+            expect(parsedResult.transactionHash).toBe(MOCK_TX_HASH);
+            expect(parsedResult.coinAddress).toBe("0x2345678901234567890123456789012345678901");
+        });
+        it("should include zoraURL for base-mainnet network", async () => {
+            // Mock wallet provider to return base-mainnet network
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            const args = {
+                name: "Test Coin",
+                symbol: "TEST",
+                description: "A test coin",
+                image: "https://example.com/image.png",
+                category: "social",
+                currency: "ZORA",
+            };
+            const result = await provider.createCoin(mockWalletProvider, args);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(true);
+            expect(parsedResult.coinAddress).toBe("0x2345678901234567890123456789012345678901");
+            expect(parsedResult.zoraURL).toBe("https://zora.co/coin/base:0x2345678901234567890123456789012345678901");
+        });
+        it("should not include zoraURL for non-base-mainnet networks", async () => {
+            // Keep the default base-sepolia network from beforeEach
+            const args = {
+                name: "Test Coin",
+                symbol: "TEST",
+                description: "A test coin",
+                image: "https://example.com/image.png",
+                category: "social",
+                currency: "ZORA",
+            };
+            const result = await provider.createCoin(mockWalletProvider, args);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(true);
+            expect(parsedResult.coinAddress).toBe("0x2345678901234567890123456789012345678901");
+            expect(parsedResult.zoraURL).toBeUndefined();
+        });
+        it("should handle transaction failure", async () => {
+            const args = {
+                name: "Test Coin",
+                symbol: "TEST",
+                description: "A test coin",
+                image: "https://example.com/image.png",
+                category: "social",
+                currency: "ZORA",
+            };
+            // Mock a reverted transaction
+            mockWalletProvider.waitForTransactionReceipt.mockResolvedValueOnce({
+                status: "reverted",
+                logs: [],
+            });
+            const result = await provider.createCoin(mockWalletProvider, args);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(false);
+            expect(parsedResult.error).toBe("Coin creation transaction reverted");
+        });
+        it("should handle errors", async () => {
+            const args = {
+                name: "Test Coin",
+                symbol: "TEST",
+                description: "A test coin",
+                image: "https://example.com/image.png",
+                category: "social",
+                currency: "ZORA",
+            };
+            // Create an error that will be thrown during the request
+            const error = new Error("Failed to create coin");
+            mockWalletProvider.sendTransaction.mockRejectedValueOnce(error);
+            const result = await provider.createCoin(mockWalletProvider, args);
+            const parsedResult = JSON.parse(result);
+            expect(parsedResult.success).toBe(false);
+            expect(parsedResult.error).toBe("Failed to create coin");
+        });
+    });
+});

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

@@ -40,6 +40,10 @@ export interface CdpSmartWalletProviderConfig extends CdpWalletProviderConfig {
      * The name of the smart wallet.
      */
     smartAccountName?: string;
+    /**
+     * The paymaster URL for gasless transactions.
+     */
+    paymasterUrl?: string;
 }
 /**
  * A wallet provider that can be used to interact with the CDP.

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

@@ -1,4 +1,4 @@
-import { CdpClient } from "@coinbase/cdp-sdk";
+import { CdpClient, EvmSmartAccount } from "@coinbase/cdp-sdk";
 import { Abi, Address, ContractFunctionArgs, ContractFunctionName, Hex, ReadContractParameters, ReadContractReturnType, TransactionRequest } from "viem";
 import { Network } from "../network";
 import { EvmWalletProvider } from "./evmWalletProvider";
@@ -8,6 +8,7 @@ import { WalletProviderWithClient, CdpSmartWalletProviderConfig } from "./cdpSha
  */
 export declare class CdpSmartWalletProvider extends EvmWalletProvider implements WalletProviderWithClient {
     #private;
+    smartAccount: EvmSmartAccount;
     /**
      * Constructs a new CdpSmartWalletProvider.
      *
@@ -84,6 +85,12 @@ export declare class CdpSmartWalletProvider extends EvmWalletProvider implements
      * @returns The CDP client.
      */
     getClient(): CdpClient;
+    /**
+     * Gets the paymaster URL for gasless transactions.
+     *
+     * @returns The paymaster URL if configured, undefined otherwise.
+     */
+    getPaymasterUrl(): string | undefined;
     /**
      * Gets the balance of the smart wallet.
      *

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_smartAccount, _CdpSmartWalletProvider_ownerAccount, _CdpSmartWalletProvider_cdp, _CdpSmartWalletProvider_network, _CdpSmartWalletProvider_getCdpSdkNetwork;
+var _CdpSmartWalletProvider_instances, _CdpSmartWalletProvider_publicClient, _CdpSmartWalletProvider_ownerAccount, _CdpSmartWalletProvider_cdp, _CdpSmartWalletProvider_network, _CdpSmartWalletProvider_paymasterUrl, _CdpSmartWalletProvider_getCdpSdkNetwork;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CdpSmartWalletProvider = void 0;
 const cdp_sdk_1 = require("@coinbase/cdp-sdk");
@@ -30,15 +30,16 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         super();
         _CdpSmartWalletProvider_instances.add(this);
         _CdpSmartWalletProvider_publicClient.set(this, void 0);
-        _CdpSmartWalletProvider_smartAccount.set(this, void 0);
         _CdpSmartWalletProvider_ownerAccount.set(this, void 0);
         _CdpSmartWalletProvider_cdp.set(this, void 0);
         _CdpSmartWalletProvider_network.set(this, void 0);
-        __classPrivateFieldSet(this, _CdpSmartWalletProvider_smartAccount, config.smartAccount, "f");
+        _CdpSmartWalletProvider_paymasterUrl.set(this, void 0);
+        this.smartAccount = config.smartAccount;
         __classPrivateFieldSet(this, _CdpSmartWalletProvider_ownerAccount, config.ownerAccount, "f");
         __classPrivateFieldSet(this, _CdpSmartWalletProvider_cdp, config.cdp, "f");
         __classPrivateFieldSet(this, _CdpSmartWalletProvider_publicClient, config.publicClient, "f");
         __classPrivateFieldSet(this, _CdpSmartWalletProvider_network, config.network, "f");
+        __classPrivateFieldSet(this, _CdpSmartWalletProvider_paymasterUrl, config.paymasterUrl, "f");
     }
     /**
      * Configures a new CdpSmartWalletProvider with a smart wallet.
@@ -52,6 +53,7 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         const apiKeySecret = config.apiKeySecret || process.env.CDP_API_KEY_SECRET;
         const walletSecret = config.walletSecret || process.env.CDP_WALLET_SECRET;
         const idempotencyKey = config.idempotencyKey || process.env.IDEMPOTENCY_KEY;
+        const paymasterUrl = config.paymasterUrl || process.env.PAYMASTER_URL;
         if (!apiKeyId || !apiKeySecret || !walletSecret) {
             throw new Error("Missing required environment variables. CDP_API_KEY_ID, CDP_API_KEY_SECRET, CDP_WALLET_SECRET are required.");
         }
@@ -100,6 +102,7 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
             smartAccount,
             ownerAccount,
             network,
+            paymasterUrl,
         });
     }
     /**
@@ -109,8 +112,8 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
      */
     async exportWallet() {
         return {
-            name: __classPrivateFieldGet(this, _CdpSmartWalletProvider_smartAccount, "f").name,
-            address: __classPrivateFieldGet(this, _CdpSmartWalletProvider_smartAccount, "f").address,
+            name: this.smartAccount.name,
+            address: this.smartAccount.address,
             ownerAddress: __classPrivateFieldGet(this, _CdpSmartWalletProvider_ownerAccount, "f").address,
         };
     }
@@ -132,7 +135,7 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async signTypedData(typedData) {
         const { domain, types, primaryType, message } = typedData;
-        return await __classPrivateFieldGet(this, _CdpSmartWalletProvider_smartAccount, "f").signTypedData({
+        return await this.smartAccount.signTypedData({
             domain,
             types,
             primaryType,
@@ -164,9 +167,10 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
             },
         ];
         const userOperation = await __classPrivateFieldGet(this, _CdpSmartWalletProvider_cdp, "f").evm.sendUserOperation({
-            smartAccount: __classPrivateFieldGet(this, _CdpSmartWalletProvider_smartAccount, "f"),
+            smartAccount: this.smartAccount,
             network: __classPrivateFieldGet(this, _CdpSmartWalletProvider_instances, "m", _CdpSmartWalletProvider_getCdpSdkNetwork).call(this),
             calls,
+            paymasterUrl: __classPrivateFieldGet(this, _CdpSmartWalletProvider_paymasterUrl, "f"),
         });
         return userOperation.userOpHash;
     }
@@ -176,7 +180,7 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
      * @returns The address of the smart wallet.
      */
     getAddress() {
-        return __classPrivateFieldGet(this, _CdpSmartWalletProvider_smartAccount, "f").address;
+        return this.smartAccount.address;
     }
     /**
      * Gets the network of the wallet.
@@ -202,13 +206,21 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
     getClient() {
         return __classPrivateFieldGet(this, _CdpSmartWalletProvider_cdp, "f");
     }
+    /**
+     * Gets the paymaster URL for gasless transactions.
+     *
+     * @returns The paymaster URL if configured, undefined otherwise.
+     */
+    getPaymasterUrl() {
+        return __classPrivateFieldGet(this, _CdpSmartWalletProvider_paymasterUrl, "f");
+    }
     /**
      * Gets the balance of the smart wallet.
      *
      * @returns The balance of the wallet in wei
      */
     async getBalance() {
-        return await __classPrivateFieldGet(this, _CdpSmartWalletProvider_publicClient, "f").getBalance({ address: __classPrivateFieldGet(this, _CdpSmartWalletProvider_smartAccount, "f").address });
+        return await __classPrivateFieldGet(this, _CdpSmartWalletProvider_publicClient, "f").getBalance({ address: this.smartAccount.address });
     }
     /**
      * Waits for a user operation receipt.
@@ -222,7 +234,7 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         // This is a simplified implementation - in practice you might want to poll
         // the CDP API for user operation status
         return __classPrivateFieldGet(this, _CdpSmartWalletProvider_cdp, "f").evm.waitForUserOperation({
-            smartAccountAddress: __classPrivateFieldGet(this, _CdpSmartWalletProvider_smartAccount, "f").address,
+            smartAccountAddress: this.smartAccount.address,
             userOpHash,
         });
     }
@@ -251,7 +263,7 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
     }
 }
 exports.CdpSmartWalletProvider = CdpSmartWalletProvider;
-_CdpSmartWalletProvider_publicClient = new WeakMap(), _CdpSmartWalletProvider_smartAccount = new WeakMap(), _CdpSmartWalletProvider_ownerAccount = new WeakMap(), _CdpSmartWalletProvider_cdp = new WeakMap(), _CdpSmartWalletProvider_network = new WeakMap(), _CdpSmartWalletProvider_instances = new WeakSet(), _CdpSmartWalletProvider_getCdpSdkNetwork = function _CdpSmartWalletProvider_getCdpSdkNetwork() {
+_CdpSmartWalletProvider_publicClient = new WeakMap(), _CdpSmartWalletProvider_ownerAccount = 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";

package/package.json

@@ -2,7 +2,7 @@
   "name": "@coinbase/agentkit",
   "description": "Coinbase AgentKit core primitives",
   "repository": "https://github.com/coinbase/agentkit",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "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.26.0",
+    "@coinbase/cdp-sdk": "^1.34.0",
     "@coinbase/coinbase-sdk": "^0.20.0",
     "@jup-ag/api": "^6.0.39",
     "@privy-io/public-api": "2.18.5",
@@ -34,6 +34,7 @@
     "@zerodev/ecdsa-validator": "^5.4.5",
     "@zerodev/intent": "^0.0.24",
     "@zerodev/sdk": "^5.4.28",
+    "@zoralabs/coins-sdk": "^0.2.8",
     "axios": "^1.9.0",
     "bs58": "^4.0.1",
     "canonicalize": "^2.1.0",