@coinbase/agentkit 0.10.0 → 0.10.1

package/dist/action-providers/zeroX/zeroXActionProvider.test.js

@@ -0,0 +1,445 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zeroXActionProvider_1 = require("./zeroXActionProvider");
+const schemas_1 = require("./schemas");
+// Mock the fetch function
+global.fetch = jest.fn();
+describe("ZeroX Schema Validation", () => {
+    it("should validate GetSwapPrice schema with valid input", () => {
+        const validInput = {
+            sellToken: "0x1234567890123456789012345678901234567890",
+            buyToken: "0x0987654321098765432109876543210987654321",
+            sellAmount: "1.5",
+            slippageBps: 50,
+        };
+        const result = schemas_1.GetSwapPriceSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+    });
+    it("should fail validation with invalid address format", () => {
+        const invalidInput = {
+            sellToken: "invalid-address",
+            buyToken: "0x0987654321098765432109876543210987654321",
+            sellAmount: "1.5",
+            slippageBps: 50,
+        };
+        const result = schemas_1.GetSwapPriceSchema.safeParse(invalidInput);
+        expect(result.success).toBe(false);
+    });
+    it("should use default slippageBps when not provided", () => {
+        const inputWithoutSlippage = {
+            sellToken: "0x1234567890123456789012345678901234567890",
+            buyToken: "0x0987654321098765432109876543210987654321",
+            sellAmount: "1.5",
+        };
+        const result = schemas_1.GetSwapPriceSchema.safeParse(inputWithoutSlippage);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.slippageBps).toBe(100); // Default value from schema
+        }
+    });
+    it("should validate swap fee parameters when both provided", () => {
+        const inputWithSwapFees = {
+            sellToken: "0x1234567890123456789012345678901234567890",
+            buyToken: "0x0987654321098765432109876543210987654321",
+            sellAmount: "1.5",
+            swapFeeRecipient: "0xabcdef1234567890abcdef1234567890abcdef12",
+            swapFeeBps: 50,
+        };
+        const result = schemas_1.GetSwapPriceSchema.safeParse(inputWithSwapFees);
+        expect(result.success).toBe(true);
+    });
+    it("should validate when only swapFeeRecipient provided (swapFeeBps defaults to 100)", () => {
+        const inputWithOnlyRecipient = {
+            sellToken: "0x1234567890123456789012345678901234567890",
+            buyToken: "0x0987654321098765432109876543210987654321",
+            sellAmount: "1.5",
+            swapFeeBps: 100,
+            swapFeeRecipient: "0xabcdef1234567890abcdef1234567890abcdef12",
+        };
+        const result = schemas_1.GetSwapPriceSchema.safeParse(inputWithOnlyRecipient);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.swapFeeBps).toBe(100); // Default value
+        }
+    });
+    it("should fail validation when swapFeeBps exceeds maximum", () => {
+        const inputWithInvalidSwapFeeBps = {
+            sellToken: "0x1234567890123456789012345678901234567890",
+            buyToken: "0x0987654321098765432109876543210987654321",
+            sellAmount: "1.5",
+            swapFeeRecipient: "0xabcdef1234567890abcdef1234567890abcdef12",
+            swapFeeBps: 1500, // Exceeds maximum of 1000
+        };
+        const result = schemas_1.GetSwapPriceSchema.safeParse(inputWithInvalidSwapFeeBps);
+        expect(result.success).toBe(false);
+    });
+    it("should validate ExecuteSwap schema with valid input", () => {
+        const validInput = {
+            sellToken: "0x1234567890123456789012345678901234567890",
+            buyToken: "0x0987654321098765432109876543210987654321",
+            sellAmount: "1.5",
+            slippageBps: 50,
+        };
+        const result = schemas_1.ExecuteSwapSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+    });
+});
+describe("ZeroX Action Provider", () => {
+    let provider;
+    let mockWalletProvider;
+    const MOCK_SELL_TOKEN = "0x1234567890123456789012345678901234567890";
+    const MOCK_BUY_TOKEN = "0x0987654321098765432109876543210987654321";
+    const MOCK_SELL_AMOUNT = "1.5";
+    const MOCK_CHAIN_ID = 1;
+    const MOCK_ADDRESS = "0xabcdef1234567890abcdef1234567890abcdef12";
+    beforeEach(() => {
+        provider = (0, zeroXActionProvider_1.zeroXActionProvider)({ apiKey: "test-api-key" });
+        mockWalletProvider = {
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            getNetwork: jest.fn().mockReturnValue({
+                chainId: MOCK_CHAIN_ID,
+                protocolFamily: "evm",
+                networkId: "ethereum-mainnet",
+            }),
+            readContract: jest.fn(),
+            getPublicClient: jest.fn().mockReturnValue({
+                multicall: jest.fn(),
+            }),
+            sendTransaction: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+            signTypedData: jest.fn(),
+        };
+        // Reset mocks
+        global.fetch.mockReset();
+    });
+    describe("getSwapPrice", () => {
+        beforeEach(() => {
+            // Mock multicall for token details (decimals and names)
+            const mockMulticallResults = [
+                { status: "success", result: 18 }, // sellToken decimals
+                { status: "success", result: "TEST" }, // sellToken name
+                { status: "success", result: 6 }, // buyToken decimals
+                { status: "success", result: "USDC" }, // buyToken name
+            ];
+            mockWalletProvider.getPublicClient().multicall.mockResolvedValue(mockMulticallResults);
+            // Mock fetch for price API
+            const mockPriceResponse = {
+                buyAmount: "1000000", // 1 USDC with 6 decimals
+                minBuyAmount: "990000", // 0.99 USDC with 6 decimals
+                totalNetworkFee: "100000000000000", // 0.0001 ETH
+                issues: { balance: null },
+                liquidityAvailable: true,
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: jest.fn().mockResolvedValueOnce(mockPriceResponse),
+            });
+        });
+        it("should get swap price successfully", async () => {
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+            };
+            const response = await provider.getSwapPrice(mockWalletProvider, args);
+            const parsedResponse = JSON.parse(response);
+            // Verify fetch was called with correct URL params
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+            expect(global.fetch.mock.calls[0][0]).toContain("api.0x.org/swap/permit2/price");
+            expect(global.fetch.mock.calls[0][0]).toContain(`chainId=${MOCK_CHAIN_ID}`);
+            expect(global.fetch.mock.calls[0][0]).toContain(`sellToken=${MOCK_SELL_TOKEN}`);
+            expect(global.fetch.mock.calls[0][0]).toContain(`buyToken=${MOCK_BUY_TOKEN}`);
+            // Verify response formatting
+            expect(parsedResponse.success).toBe(true);
+            expect(parsedResponse.sellToken).toBe(MOCK_SELL_TOKEN);
+            expect(parsedResponse.sellTokenName).toBe("TEST");
+            expect(parsedResponse.buyToken).toBe(MOCK_BUY_TOKEN);
+            expect(parsedResponse.buyTokenName).toBe("USDC");
+            expect(parsedResponse.liquidityAvailable).toBe(true);
+            expect(parsedResponse.balanceEnough).toBe(true);
+            expect(parsedResponse.slippageBps).toBe(50);
+            expect(parsedResponse.buyAmount).toBeDefined();
+            expect(parsedResponse.minBuyAmount).toBeDefined();
+        });
+        it("should handle API errors", async () => {
+            global.fetch.mockReset();
+            global.fetch.mockResolvedValueOnce({
+                ok: false,
+                status: 400,
+                statusText: "Bad Request",
+                text: jest.fn().mockResolvedValueOnce("Invalid request parameters"),
+            });
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+            };
+            const response = await provider.getSwapPrice(mockWalletProvider, args);
+            const parsedResponse = JSON.parse(response);
+            expect(parsedResponse.success).toBe(false);
+            expect(parsedResponse.error).toContain("Error fetching swap price");
+        });
+        it("should handle fetch errors", async () => {
+            global.fetch.mockReset();
+            global.fetch.mockRejectedValueOnce(new Error("Network error"));
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+            };
+            const response = await provider.getSwapPrice(mockWalletProvider, args);
+            const parsedResponse = JSON.parse(response);
+            expect(parsedResponse.success).toBe(false);
+            expect(parsedResponse.error).toContain("Error fetching swap price");
+        });
+        it("should include swap fee parameters in API call when provided", async () => {
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeRecipient: "0xabcdef1234567890abcdef1234567890abcdef12",
+                swapFeeBps: 100,
+            };
+            await provider.getSwapPrice(mockWalletProvider, args);
+            // Verify fetch was called with swap fee parameters
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+            const fetchUrl = global.fetch.mock.calls[0][0];
+            expect(fetchUrl).toContain("swapFeeRecipient=0xabcdef1234567890abcdef1234567890abcdef12");
+            expect(fetchUrl).toContain("swapFeeBps=100");
+            expect(fetchUrl).toContain(`swapFeeToken=${MOCK_SELL_TOKEN}`);
+        });
+        it("should not include swap fee parameters when not provided", async () => {
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+            };
+            await provider.getSwapPrice(mockWalletProvider, args);
+            // Verify fetch was called without swap fee parameters
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+            const fetchUrl = global.fetch.mock.calls[0][0];
+            expect(fetchUrl).not.toContain("swapFeeRecipient");
+            expect(fetchUrl).not.toContain("swapFeeBps");
+            expect(fetchUrl).not.toContain("swapFeeToken");
+        });
+        it("should include swap fee parameters with default swapFeeBps when only recipient provided", async () => {
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+                swapFeeRecipient: "0xabcdef1234567890abcdef1234567890abcdef12",
+            };
+            await provider.getSwapPrice(mockWalletProvider, args);
+            // Verify fetch was called with swap fee parameters including default swapFeeBps
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+            const fetchUrl = global.fetch.mock.calls[0][0];
+            expect(fetchUrl).toContain("swapFeeRecipient=0xabcdef1234567890abcdef1234567890abcdef12");
+            expect(fetchUrl).toContain("swapFeeBps=100"); // Default value
+            expect(fetchUrl).toContain(`swapFeeToken=${MOCK_SELL_TOKEN}`);
+        });
+    });
+    describe("executeSwap", () => {
+        const MOCK_TX_HASH = "0xtxhash123456";
+        beforeEach(() => {
+            // Mock multicall for token details (decimals and names)
+            const mockMulticallResults = [
+                { status: "success", result: 18 }, // sellToken decimals
+                { status: "success", result: "TEST" }, // sellToken name
+                { status: "success", result: 6 }, // buyToken decimals
+                { status: "success", result: "USDC" }, // buyToken name
+            ];
+            mockWalletProvider.getPublicClient().multicall.mockResolvedValue(mockMulticallResults);
+            // Mock API responses
+            const mockPriceResponse = {
+                buyAmount: "1000000", // 1 USDC with 6 decimals
+                minBuyAmount: "990000", // 0.99 USDC with 6 decimals
+                totalNetworkFee: "100000000000000", // 0.0001 ETH
+                issues: null,
+                liquidityAvailable: true,
+            };
+            const mockQuoteResponse = {
+                buyAmount: "1000000",
+                minBuyAmount: "990000",
+                totalNetworkFee: "100000000000000",
+                transaction: {
+                    to: "0x0000000000000000000000000000000000000001",
+                    data: "0x12345678",
+                    value: "1500000000000000000", // 1.5 ETH
+                    gas: "300000",
+                    gasPrice: "20000000000",
+                },
+            };
+            // First fetch for price
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: jest.fn().mockResolvedValueOnce(mockPriceResponse),
+            });
+            // Second fetch for quote
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: jest.fn().mockResolvedValueOnce(mockQuoteResponse),
+            });
+            // Mock transaction functions
+            mockWalletProvider.sendTransaction.mockResolvedValueOnce(MOCK_TX_HASH);
+            mockWalletProvider.waitForTransactionReceipt.mockResolvedValueOnce({
+                transactionHash: MOCK_TX_HASH,
+                status: "success",
+            });
+        });
+        it("should execute swap successfully", async () => {
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+            };
+            const response = await provider.executeSwap(mockWalletProvider, args);
+            const parsedResponse = JSON.parse(response);
+            // Verify API calls
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+            expect(global.fetch.mock.calls[0][0]).toContain("api.0x.org/swap/permit2/price");
+            expect(global.fetch.mock.calls[1][0]).toContain("api.0x.org/swap/permit2/quote");
+            // Verify transaction was sent
+            expect(mockWalletProvider.sendTransaction).toHaveBeenCalledTimes(1);
+            expect(mockWalletProvider.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
+            // Verify response formatting
+            expect(parsedResponse.success).toBe(true);
+            expect(parsedResponse.sellToken).toBe(MOCK_SELL_TOKEN);
+            expect(parsedResponse.sellTokenName).toBe("TEST");
+            expect(parsedResponse.buyToken).toBe(MOCK_BUY_TOKEN);
+            expect(parsedResponse.buyTokenName).toBe("USDC");
+            expect(parsedResponse.transactionHash).toBe(MOCK_TX_HASH);
+            expect(parsedResponse.slippageBps).toBe(50);
+            expect(parsedResponse.network).toBe("ethereum-mainnet");
+        });
+        it("should handle price API errors", async () => {
+            global.fetch.mockReset();
+            global.fetch.mockResolvedValueOnce({
+                ok: false,
+                status: 400,
+                statusText: "Bad Request",
+                text: jest.fn().mockResolvedValueOnce("Invalid request parameters"),
+            });
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+            };
+            const response = await provider.executeSwap(mockWalletProvider, args);
+            const parsedResponse = JSON.parse(response);
+            expect(parsedResponse.success).toBe(false);
+            expect(parsedResponse.error).toContain("Error fetching swap price");
+        });
+        it("should handle no liquidity available", async () => {
+            global.fetch.mockReset();
+            const mockPriceResponse = {
+                liquidityAvailable: false,
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: jest.fn().mockResolvedValueOnce(mockPriceResponse),
+            });
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+            };
+            const response = await provider.executeSwap(mockWalletProvider, args);
+            const parsedResponse = JSON.parse(response);
+            expect(parsedResponse.success).toBe(false);
+            expect(parsedResponse.error).toContain("No liquidity available");
+        });
+        it("should include swap fee parameters in both API calls when provided", async () => {
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeRecipient: "0xabcdef1234567890abcdef1234567890abcdef12",
+                swapFeeBps: 100,
+            };
+            await provider.executeSwap(mockWalletProvider, args);
+            // Verify both API calls include swap fee parameters
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+            // Check price API call
+            const priceUrl = global.fetch.mock.calls[0][0];
+            expect(priceUrl).toContain("swapFeeRecipient=0xabcdef1234567890abcdef1234567890abcdef12");
+            expect(priceUrl).toContain("swapFeeBps=100");
+            expect(priceUrl).toContain(`swapFeeToken=${MOCK_SELL_TOKEN}`);
+            // Check quote API call
+            const quoteUrl = global.fetch.mock.calls[1][0];
+            expect(quoteUrl).toContain("swapFeeRecipient=0xabcdef1234567890abcdef1234567890abcdef12");
+            expect(quoteUrl).toContain("swapFeeBps=100");
+            expect(quoteUrl).toContain(`swapFeeToken=${MOCK_SELL_TOKEN}`);
+        });
+        it("should not include swap fee parameters when not provided", async () => {
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+            };
+            await provider.executeSwap(mockWalletProvider, args);
+            // Verify both API calls exclude swap fee parameters
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+            // Check price API call
+            const priceUrl = global.fetch.mock.calls[0][0];
+            expect(priceUrl).not.toContain("swapFeeRecipient");
+            expect(priceUrl).not.toContain("swapFeeBps");
+            expect(priceUrl).not.toContain("swapFeeToken");
+            // Check quote API call
+            const quoteUrl = global.fetch.mock.calls[1][0];
+            expect(quoteUrl).not.toContain("swapFeeRecipient");
+            expect(quoteUrl).not.toContain("swapFeeBps");
+            expect(quoteUrl).not.toContain("swapFeeToken");
+        });
+        it("should include swap fee parameters with default swapFeeBps when only recipient provided", async () => {
+            const args = {
+                sellToken: MOCK_SELL_TOKEN,
+                buyToken: MOCK_BUY_TOKEN,
+                sellAmount: MOCK_SELL_AMOUNT,
+                slippageBps: 50,
+                swapFeeBps: 100,
+                swapFeeRecipient: "0xabcdef1234567890abcdef1234567890abcdef12",
+            };
+            await provider.executeSwap(mockWalletProvider, args);
+            // Verify both API calls include swap fee parameters with default swapFeeBps
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+            // Check price API call
+            const priceUrl = global.fetch.mock.calls[0][0];
+            expect(priceUrl).toContain("swapFeeRecipient=0xabcdef1234567890abcdef1234567890abcdef12");
+            expect(priceUrl).toContain("swapFeeBps=100"); // Default value
+            expect(priceUrl).toContain(`swapFeeToken=${MOCK_SELL_TOKEN}`);
+            // Check quote API call
+            const quoteUrl = global.fetch.mock.calls[1][0];
+            expect(quoteUrl).toContain("swapFeeRecipient=0xabcdef1234567890abcdef1234567890abcdef12");
+            expect(quoteUrl).toContain("swapFeeBps=100"); // Default value
+            expect(quoteUrl).toContain(`swapFeeToken=${MOCK_SELL_TOKEN}`);
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for evm networks", () => {
+            expect(provider.supportsNetwork({ protocolFamily: "evm" })).toBe(true);
+        });
+        it("should return false for non-evm networks", () => {
+            expect(provider.supportsNetwork({ protocolFamily: "solana" })).toBe(false);
+        });
+    });
+});

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

@@ -1,8 +1,12 @@
 import { CdpClient } from "@coinbase/cdp-sdk";
-import { Abi, Address, ContractFunctionArgs, ContractFunctionName, Hex, ReadContractParameters, ReadContractReturnType, TransactionRequest } from "viem";
+import { Abi, Address, ContractFunctionArgs, ContractFunctionName, Hex, PublicClient, ReadContractParameters, ReadContractReturnType, TransactionRequest } from "viem";
 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.
  */
@@ -83,6 +87,12 @@ export declare class CdpEvmWalletProvider extends EvmWalletProvider implements W
      * @returns The CDP client.
      */
     getClient(): CdpClient;
+    /**
+     * Gets the Viem PublicClient used for read-only operations.
+     *
+     * @returns The Viem PublicClient instance used for read-only operations.
+     */
+    getPublicClient(): PublicClient;
     /**
      * Gets the balance of the wallet.
      *
@@ -107,8 +117,16 @@ export declare class CdpEvmWalletProvider extends EvmWalletProvider implements W
      * Transfer the native asset of the network.
      *
      * @param to - The destination address.
-     * @param value - The amount to transfer in Wei.
+     * @param value - The amount to transfer in atomic units (Wei).
      * @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);
@@ -67,9 +66,10 @@ class CdpEvmWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         const serverAccount = await (config.address
             ? cdpClient.evm.getAccount({ address: config.address })
             : cdpClient.evm.createAccount({ idempotencyKey }));
+        const rpcUrl = config.rpcUrl || process.env.RPC_URL;
         const publicClient = (0, viem_1.createPublicClient)({
             chain: network_1.NETWORK_ID_TO_VIEM_CHAIN[networkId],
-            transport: (0, viem_1.http)(),
+            transport: rpcUrl ? (0, viem_1.http)(rpcUrl) : (0, viem_1.http)(),
         });
         return new CdpEvmWalletProvider({
             publicClient,
@@ -152,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;
     }
@@ -188,6 +188,14 @@ class CdpEvmWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
     getClient() {
         return __classPrivateFieldGet(this, _CdpEvmWalletProvider_cdp, "f");
     }
+    /**
+     * Gets the Viem PublicClient used for read-only operations.
+     *
+     * @returns The Viem PublicClient instance used for read-only operations.
+     */
+    getPublicClient() {
+        return __classPrivateFieldGet(this, _CdpEvmWalletProvider_publicClient, "f");
+    }
     /**
      * Gets the balance of the wallet.
      *
@@ -219,7 +227,7 @@ class CdpEvmWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
      * Transfer the native asset of the network.
      *
      * @param to - The destination address.
-     * @param value - The amount to transfer in Wei.
+     * @param value - The amount to transfer in atomic units (Wei).
      * @returns The transaction hash.
      */
     async nativeTransfer(to, value) {
@@ -229,15 +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";
-        default:
-            throw new Error(`Unsupported network: ${__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/cdpShared.d.ts

@@ -30,6 +30,11 @@ export interface CdpWalletProviderConfig extends CdpProviderConfig {
      * The idempotency key of the wallet. Only used when creating a new account.
      */
     idempotencyKey?: string;
+    /**
+     * Optional RPC URL for Viem public client HTTP transport.
+     * Falls back to process.env.RPC_URL when not provided.
+     */
+    rpcUrl?: string;
 }
 export interface CdpSmartWalletProviderConfig extends CdpWalletProviderConfig {
     /**

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

@@ -1,14 +1,19 @@
-import { CdpClient, EvmSmartAccount } from "@coinbase/cdp-sdk";
-import { Abi, Address, ContractFunctionArgs, ContractFunctionName, Hex, ReadContractParameters, ReadContractReturnType, TransactionRequest } from "viem";
+import { CdpClient, EvmSmartAccount, EvmServerAccount } from "@coinbase/cdp-sdk";
+import { Abi, Address, ContractFunctionArgs, ContractFunctionName, Hex, PublicClient, ReadContractParameters, ReadContractReturnType, TransactionRequest, LocalAccount } from "viem";
 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.
  */
 export declare class CdpSmartWalletProvider extends EvmWalletProvider implements WalletProviderWithClient {
     #private;
     smartAccount: EvmSmartAccount;
+    ownerAccount: LocalAccount | EvmServerAccount;
     /**
      * Constructs a new CdpSmartWalletProvider.
      *
@@ -91,6 +96,12 @@ export declare class CdpSmartWalletProvider extends EvmWalletProvider implements
      * @returns The paymaster URL if configured, undefined otherwise.
      */
     getPaymasterUrl(): string | undefined;
+    /**
+     * Gets the Viem PublicClient used for read-only operations.
+     *
+     * @returns The Viem PublicClient instance used for read-only operations.
+     */
+    getPublicClient(): PublicClient;
     /**
      * Gets the balance of the smart wallet.
      *
@@ -115,8 +126,16 @@ export declare class CdpSmartWalletProvider extends EvmWalletProvider implements
      * Transfer the native asset of the network using smart wallet.
      *
      * @param to - The destination address.
-     * @param value - The amount to transfer in Wei.
+     * @param value - The amount to transfer in atomic units (Wei).
      * @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 {};