@coinbase/agentkit 0.8.2 → 0.9.1

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

@@ -0,0 +1,200 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZoraTokenUri = generateZoraTokenUri;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Reads a local file and converts it to base64
+ *
+ * @param imageFileName - Path to the local file
+ * @returns Base64 encoded file and mime type
+ */
+async function readFileAsBase64(imageFileName) {
+    return new Promise((resolve, reject) => {
+        fs_1.default.readFile(imageFileName, (err, data) => {
+            if (err) {
+                reject(new Error(`Failed to read file: ${err.message}`));
+                return;
+            }
+            // Determine mime type based on file extension
+            const extension = path_1.default.extname(imageFileName).toLowerCase();
+            let mimeType = "application/octet-stream"; // default
+            if (extension === ".png")
+                mimeType = "image/png";
+            else if (extension === ".jpg" || extension === ".jpeg")
+                mimeType = "image/jpeg";
+            else if (extension === ".gif")
+                mimeType = "image/gif";
+            else if (extension === ".svg")
+                mimeType = "image/svg+xml";
+            const base64 = data.toString("base64");
+            resolve({ base64, mimeType });
+        });
+    });
+}
+/**
+ * Uploads a file to IPFS using Pinata
+ *
+ * @param params - Configuration and file data
+ * @param params.pinataConfig - Pinata configuration including JWT
+ * @param params.fileData - Base64 encoded file data
+ * @param params.fileName - Name for the uploaded file
+ * @param params.mimeType - MIME type of the file
+ * @returns Upload response with CID and other details
+ */
+async function uploadFileToIPFS(params) {
+    try {
+        const formData = new FormData();
+        // Convert base64 to Blob and then to File
+        const byteCharacters = atob(params.fileData);
+        const byteArrays = [];
+        for (let offset = 0; offset < byteCharacters.length; offset += 1024) {
+            const slice = byteCharacters.slice(offset, offset + 1024);
+            const byteNumbers = new Array(slice.length);
+            for (let i = 0; i < slice.length; i++) {
+                byteNumbers[i] = slice.charCodeAt(i);
+            }
+            const byteArray = new Uint8Array(byteNumbers);
+            byteArrays.push(byteArray);
+        }
+        const blob = new Blob(byteArrays, { type: params.mimeType });
+        const file = new File([blob], params.fileName, { type: params.mimeType });
+        formData.append("file", file);
+        const pinataMetadata = {
+            name: params.fileName,
+        };
+        formData.append("pinataMetadata", JSON.stringify(pinataMetadata));
+        const pinataOptions = {
+            cidVersion: 1,
+        };
+        formData.append("pinataOptions", JSON.stringify(pinataOptions));
+        const response = await fetch("https://api.pinata.cloud/pinning/pinFileToIPFS", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${params.pinataConfig.jwt}`,
+            },
+            body: formData,
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(`Failed to upload file to IPFS: ${error.message || response.statusText}`);
+        }
+        const data = await response.json();
+        return {
+            IpfsHash: data.IpfsHash,
+            PinSize: data.PinSize,
+            Timestamp: data.Timestamp,
+            isDuplicate: data.isDuplicate || false,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to upload file to IPFS: ${error.message}`);
+        }
+        throw error;
+    }
+}
+/**
+ * Uploads JSON data to IPFS using Pinata
+ *
+ * @param params - Configuration and JSON data
+ * @param params.pinataConfig - Pinata configuration including JWT
+ * @param params.json - JSON data to upload
+ * @returns Upload response with CID and other details
+ */
+async function uploadJsonToIPFS(params) {
+    try {
+        const requestBody = {
+            pinataOptions: {
+                cidVersion: 1,
+            },
+            pinataMetadata: {
+                name: `${params.json.name}-metadata.json`,
+            },
+            pinataContent: params.json,
+        };
+        const response = await fetch("https://api.pinata.cloud/pinning/pinJSONToIPFS", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${params.pinataConfig.jwt}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(`Failed to upload JSON to IPFS: ${error.message || response.statusText}`);
+        }
+        const data = await response.json();
+        return {
+            IpfsHash: data.IpfsHash,
+            PinSize: data.PinSize,
+            Timestamp: data.Timestamp,
+            isDuplicate: data.isDuplicate || false,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to upload JSON to IPFS: ${error.message}`);
+        }
+        throw error;
+    }
+}
+/**
+ * Generates a Zora token URI by handling local file or URI
+ *
+ * @param params - Parameters for generating the token URI
+ * @returns A promise that resolves to object containing the IPFS URI
+ */
+async function generateZoraTokenUri(params) {
+    try {
+        let imageUri;
+        // Check if image is already a URI (ipfs:// or https://)
+        if (params.image.startsWith("ipfs://") || params.image.startsWith("https://")) {
+            imageUri = params.image;
+        }
+        else {
+            // Handle local file
+            const { base64, mimeType } = await readFileAsBase64(params.image);
+            const fileName = path_1.default.basename(params.image);
+            const imageRes = await uploadFileToIPFS({
+                pinataConfig: params.pinataConfig,
+                fileData: base64,
+                fileName,
+                mimeType,
+            });
+            imageUri = `ipfs://${imageRes.IpfsHash}`;
+        }
+        // Create and upload the metadata
+        const metadata = {
+            name: params.name,
+            description: params.description,
+            symbol: params.symbol,
+            image: imageUri,
+            content: {
+                uri: imageUri,
+                mime: imageUri.startsWith("ipfs://") || imageUri.startsWith("https://")
+                    ? "image/*"
+                    : "image/png",
+            },
+            properties: {
+                category: params.category || "social",
+            },
+        };
+        const metadataRes = await uploadJsonToIPFS({
+            pinataConfig: params.pinataConfig,
+            json: metadata,
+        });
+        const uri = `ipfs://${metadataRes.IpfsHash}`;
+        return { uri, imageUri };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to generate Zora token URI: ${error.message}`);
+        }
+        throw error;
+    }
+}

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { EvmWalletProvider } from "../../wallet-providers/evmWalletProvider";
+import { CreateCoinSchema } from "./schemas";
+import { Network } from "../../network";
+/**
+ * ZoraActionProvider provides actions for interacting with the Zora protocol.
+ */
+export declare class ZoraActionProvider extends ActionProvider<EvmWalletProvider> {
+    #private;
+    /**
+     * Constructor for the ZoraActionProvider.
+     */
+    constructor();
+    /**
+     * 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.
+     */
+    createCoin(walletProvider: EvmWalletProvider, args: z.infer<typeof CreateCoinSchema>): Promise<string>;
+    /**
+     * 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.
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+/**
+ * Factory function to create a new ZoraActionProvider instance.
+ *
+ * @returns A new ZoraActionProvider instance
+ */
+export declare const zoraActionProvider: () => ZoraActionProvider;

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.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/agentkit.d.ts

@@ -6,6 +6,7 @@ import { Action, ActionProvider } from "./action-providers";
 export type AgentKitOptions = {
     cdpApiKeyId?: string;
     cdpApiKeySecret?: string;
+    cdpWalletSecret?: string;
     walletProvider?: WalletProvider;
     actionProviders?: ActionProvider[];
 };

package/dist/agentkit.js

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

package/dist/wallet-providers/{cdpV2EvmWalletProvider.d.ts → cdpEvmWalletProvider.d.ts}

@@ -2,26 +2,35 @@ import { CdpClient } from "@coinbase/cdp-sdk";
 import { Abi, Address, ContractFunctionArgs, ContractFunctionName, Hex, ReadContractParameters, ReadContractReturnType, TransactionRequest } from "viem";
 import { Network } from "../network";
 import { EvmWalletProvider } from "./evmWalletProvider";
-import { WalletProviderWithClient, CdpV2WalletProviderConfig } from "./cdpV2Shared";
+import { WalletProviderWithClient, CdpWalletProviderConfig } from "./cdpShared";
 /**
  * A wallet provider that uses the Coinbase SDK.
  */
-export declare class CdpV2EvmWalletProvider extends EvmWalletProvider implements WalletProviderWithClient {
+export declare class CdpEvmWalletProvider extends EvmWalletProvider implements WalletProviderWithClient {
     #private;
     /**
-     * Constructs a new CdpWalletProvider.
+     * Constructs a new CdpEvmWalletProvider.
      *
-     * @param config - The configuration options for the CdpWalletProvider.
+     * @param config - The configuration options for the CdpEvmWalletProvider.
      */
     private constructor();
     /**
-     * Configures a new CdpWalletProvider with a wallet.
+     * Configures a new CdpEvmWalletProvider with a wallet.
      *
      * @param config - Optional configuration parameters
-     * @returns A Promise that resolves to a new CdpWalletProvider instance
+     * @returns A Promise that resolves to a new CdpEvmWalletProvider instance
      * @throws Error if required environment variables are missing or wallet initialization fails
      */
-    static configureWithWallet(config?: CdpV2WalletProviderConfig): Promise<CdpV2EvmWalletProvider>;
+    static configureWithWallet(config?: CdpWalletProviderConfig): Promise<CdpEvmWalletProvider>;
+    /**
+     * Exports the wallet.
+     *
+     * @returns The wallet's data.
+     */
+    exportWallet(): Promise<{
+        name: string | undefined;
+        address: `0x${string}`;
+    }>;
     /**
      * Signs a message.
      *