@coinbase/agentkit 0.10.1 → 0.10.2

package/dist/action-providers/baseAccount/baseAccountActionProvider.test.js

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const baseAccountActionProvider_1 = require("./baseAccountActionProvider");
+const schemas_1 = require("./schemas");
+const utils_1 = require("../erc20/utils");
+// Mock the getTokenDetails function from ERC20 utils
+jest.mock("../erc20/utils", () => ({
+    getTokenDetails: jest.fn(),
+}));
+// Mock the @base-org/account package to avoid ES module import issues in Jest
+jest.mock("@base-org/account/spend-permission", () => ({
+    fetchPermissions: jest.fn(),
+    getPermissionStatus: jest.fn(),
+    prepareSpendCallData: jest.fn(),
+    prepareRevokeCallData: jest.fn(),
+}));
+const mockGetTokenDetails = utils_1.getTokenDetails;
+// Get references to the mocked functions from the mocked modules
+const mockFetchPermissions = jest.fn();
+const mockGetPermissionStatus = jest.fn();
+const mockPrepareSpendCallData = jest.fn();
+const mockPrepareRevokeCallData = jest.fn();
+// Override the mocked module with our jest functions
+jest.mocked(jest.requireMock("@base-org/account/spend-permission")).fetchPermissions =
+    mockFetchPermissions;
+jest.mocked(jest.requireMock("@base-org/account/spend-permission")).getPermissionStatus =
+    mockGetPermissionStatus;
+jest.mocked(jest.requireMock("@base-org/account/spend-permission")).prepareSpendCallData =
+    mockPrepareSpendCallData;
+jest.mocked(jest.requireMock("@base-org/account/spend-permission")).prepareRevokeCallData =
+    mockPrepareRevokeCallData;
+const MOCK_BASE_ACCOUNT = "0x1234567890123456789012345678901234567890";
+const MOCK_SPENDER_ADDRESS = "0x9876543210987654321098765432109876543210";
+const MOCK_AMOUNT_USD = 10.5;
+const MOCK_TOKEN_ADDRESS = "0xA0b86a33E6441E0100d473BB88F5C8b3d8c13ab3"; // Mock USDC address
+// Mock permission data
+const mockPermission = {
+    permissionHash: "0xmockHash",
+    signature: "0xmockSignature",
+    chainId: 8453,
+    createdAt: 1700000000,
+    permission: {
+        account: MOCK_BASE_ACCOUNT,
+        spender: MOCK_SPENDER_ADDRESS,
+        token: MOCK_TOKEN_ADDRESS,
+        allowance: "1000000000", // 1000 USDC (6 decimals) as string
+        period: 86400, // 1 day
+        start: 1700000000,
+        end: 1700086400,
+        salt: "0xsalt",
+        extraData: "0x",
+    },
+};
+const mockPermissionStatus = {
+    remainingSpend: BigInt("500000000"), // 500 USDC remaining
+    nextPeriodStart: new Date(1700086400 * 1000), // Convert timestamp to Date
+    isActive: true,
+};
+// Mock token details for USDC
+const mockTokenDetails = {
+    name: "USD Coin",
+    decimals: 6,
+    balance: BigInt("1000000000"), // 1000 USDC
+    formattedBalance: "1000",
+};
+describe("ListBaseAccountSpendPermissionsSchema", () => {
+    it("should successfully parse valid input", () => {
+        const validInput = {
+            baseAccount: MOCK_BASE_ACCOUNT,
+        };
+        const result = schemas_1.ListBaseAccountSpendPermissionsSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual(validInput);
+    });
+    it("should fail parsing invalid address", () => {
+        const invalidInput = {
+            baseAccount: "invalid-address",
+        };
+        const result = schemas_1.ListBaseAccountSpendPermissionsSchema.safeParse(invalidInput);
+        expect(result.success).toBe(false);
+    });
+    it("should fail parsing empty input", () => {
+        const emptyInput = {};
+        const result = schemas_1.ListBaseAccountSpendPermissionsSchema.safeParse(emptyInput);
+        expect(result.success).toBe(false);
+    });
+});
+describe("UseBaseAccountSpendPermissionSchema", () => {
+    it("should successfully parse valid input", () => {
+        const validInput = {
+            baseAccount: MOCK_BASE_ACCOUNT,
+            amount: MOCK_AMOUNT_USD,
+        };
+        const result = schemas_1.UseBaseAccountSpendPermissionSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual(validInput);
+    });
+    it("should fail parsing negative amount", () => {
+        const invalidInput = {
+            baseAccount: MOCK_BASE_ACCOUNT,
+            amount: -5,
+        };
+        const result = schemas_1.UseBaseAccountSpendPermissionSchema.safeParse(invalidInput);
+        expect(result.success).toBe(false);
+    });
+    it("should fail parsing zero amount", () => {
+        const invalidInput = {
+            baseAccount: MOCK_BASE_ACCOUNT,
+            amount: 0,
+        };
+        const result = schemas_1.UseBaseAccountSpendPermissionSchema.safeParse(invalidInput);
+        expect(result.success).toBe(false);
+    });
+});
+describe("RevokeBaseAccountSpendPermissionSchema", () => {
+    it("should successfully parse valid input with permission index", () => {
+        const validInput = {
+            baseAccount: MOCK_BASE_ACCOUNT,
+            permissionIndex: 2,
+        };
+        const result = schemas_1.RevokeBaseAccountSpendPermissionSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual(validInput);
+    });
+    it("should successfully parse valid input without permission index", () => {
+        const validInput = {
+            baseAccount: MOCK_BASE_ACCOUNT,
+        };
+        const result = schemas_1.RevokeBaseAccountSpendPermissionSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual(validInput);
+    });
+    it("should fail parsing negative permission index", () => {
+        const invalidInput = {
+            baseAccount: MOCK_BASE_ACCOUNT,
+            permissionIndex: -1,
+        };
+        const result = schemas_1.RevokeBaseAccountSpendPermissionSchema.safeParse(invalidInput);
+        expect(result.success).toBe(false);
+    });
+});
+describe("BaseAccountActionProvider", () => {
+    let mockWallet;
+    const actionProvider = (0, baseAccountActionProvider_1.baseAccountActionProvider)();
+    beforeEach(() => {
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_SPENDER_ADDRESS),
+            getNetwork: jest.fn().mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            }),
+            sendTransaction: jest.fn().mockResolvedValue("0xmockTransactionHash"),
+            waitForTransactionReceipt: jest.fn(),
+        };
+        // Reset mocks before each test
+        mockFetchPermissions.mockReset();
+        mockGetPermissionStatus.mockReset();
+        mockPrepareSpendCallData.mockReset();
+        mockPrepareRevokeCallData.mockReset();
+        mockGetTokenDetails.mockReset();
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for base-mainnet", () => {
+            expect(actionProvider.supportsNetwork({ networkId: "base-mainnet", protocolFamily: "evm" })).toBe(true);
+        });
+        it("should return false for other networks", () => {
+            expect(actionProvider.supportsNetwork({ networkId: "base-sepolia", protocolFamily: "evm" })).toBe(false);
+            expect(actionProvider.supportsNetwork({ networkId: "ethereum-mainnet", protocolFamily: "evm" })).toBe(false);
+            expect(actionProvider.supportsNetwork({ protocolFamily: "solana" })).toBe(false);
+        });
+    });
+    describe("listBaseAccountSpendPermissions", () => {
+        it("should return empty permissions when none found", async () => {
+            mockFetchPermissions.mockResolvedValue([]);
+            const args = {
+                baseAccount: MOCK_BASE_ACCOUNT,
+            };
+            const response = await actionProvider.listBaseAccountSpendPermissions(mockWallet, args);
+            const parsedResponse = JSON.parse(response);
+            expect(parsedResponse.success).toBe(false);
+            expect(parsedResponse.error).toContain("No spend permissions found for Base Account");
+            expect(parsedResponse.baseAccount).toBe(MOCK_BASE_ACCOUNT);
+            expect(parsedResponse.spender).toBe(MOCK_SPENDER_ADDRESS);
+            expect(parsedResponse.permissionsCount).toBe(0);
+        });
+        it("should list permissions when found", async () => {
+            mockFetchPermissions.mockResolvedValue([mockPermission]);
+            const args = {
+                baseAccount: MOCK_BASE_ACCOUNT,
+            };
+            const response = await actionProvider.listBaseAccountSpendPermissions(mockWallet, args);
+            const parsedResponse = JSON.parse(response);
+            expect(parsedResponse.success).toBe(true);
+            expect(parsedResponse.permissionsCount).toBe(1);
+            expect(parsedResponse.baseAccount).toBe(MOCK_BASE_ACCOUNT);
+            expect(parsedResponse.spender).toBe(MOCK_SPENDER_ADDRESS);
+            expect(parsedResponse.permissions).toHaveLength(1);
+            expect(parsedResponse.permissions[0].permissionIndex).toBe(1);
+            expect(parsedResponse.permissions[0].token).toBe(MOCK_TOKEN_ADDRESS);
+        });
+        it("should normalize addresses properly", async () => {
+            mockFetchPermissions.mockResolvedValue([]);
+            const args = {
+                baseAccount: MOCK_BASE_ACCOUNT.toLowerCase(), // Test address normalization
+            };
+            const response = await actionProvider.listBaseAccountSpendPermissions(mockWallet, args);
+            const parsedResponse = JSON.parse(response);
+            expect(parsedResponse.baseAccount).toBe(MOCK_BASE_ACCOUNT); // Should be checksummed
+        });
+    });
+    describe("spendFromBaseAccountPermission", () => {
+        it("should handle no permissions available", async () => {
+            mockFetchPermissions.mockResolvedValue([]);
+            const args = {
+                baseAccount: MOCK_BASE_ACCOUNT,
+                amount: MOCK_AMOUNT_USD,
+            };
+            const response = await actionProvider.spendFromBaseAccountPermission(mockWallet, args);
+            const parsedResponse = JSON.parse(response);
+            expect(parsedResponse.success).toBe(false);
+            expect(parsedResponse.error).toContain("No spend permissions found for Base Account");
+            expect(parsedResponse.baseAccount).toBe(MOCK_BASE_ACCOUNT);
+            expect(parsedResponse.spender).toBe(MOCK_SPENDER_ADDRESS);
+        });
+        it("should successfully spend from permission", async () => {
+            mockFetchPermissions.mockResolvedValue([mockPermission]);
+            mockGetPermissionStatus.mockResolvedValue(mockPermissionStatus);
+            mockGetTokenDetails.mockResolvedValue(mockTokenDetails);
+            mockPrepareSpendCallData.mockResolvedValue([
+                {
+                    to: "0xSpendContract",
+                    data: "0xspendCallData",
+                    value: "0x0",
+                },
+            ]);
+            const args = {
+                baseAccount: MOCK_BASE_ACCOUNT,
+                amount: 10.5, // 10.5 USDC
+            };
+            const response = await actionProvider.spendFromBaseAccountPermission(mockWallet, args);
+            const parsedResponse = JSON.parse(response);
+            expect(parsedResponse.success).toBe(true);
+            expect(parsedResponse.transactionHash).toBe("0xmockTransactionHash");
+            expect(parsedResponse.amountSpent).toBe("10.5");
+            expect(parsedResponse.tokenAddress).toBe(MOCK_TOKEN_ADDRESS);
+            expect(parsedResponse.baseAccount).toBe(MOCK_BASE_ACCOUNT);
+            expect(parsedResponse.permissionIndex).toBe(1);
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: "0xSpendContract",
+                data: "0xspendCallData",
+                value: BigInt("0x0"),
+            });
+        });
+        it("should handle insufficient allowance", async () => {
+            mockFetchPermissions.mockResolvedValue([mockPermission]);
+            const lowAllowanceStatus = {
+                remainingSpend: BigInt("1000000"), // Only 1 USDC remaining
+                nextPeriodStart: new Date(1700086400 * 1000),
+                isActive: true,
+            };
+            mockGetPermissionStatus.mockResolvedValue(lowAllowanceStatus);
+            mockGetTokenDetails.mockResolvedValue(mockTokenDetails);
+            const args = {
+                baseAccount: MOCK_BASE_ACCOUNT,
+                amount: 10.5, // Trying to spend 10.5 USDC but only 1 available
+            };
+            const response = await actionProvider.spendFromBaseAccountPermission(mockWallet, args);
+            const parsedResponse = JSON.parse(response);
+            expect(parsedResponse.success).toBe(false);
+            expect(parsedResponse.error).toContain("Insufficient remaining allowance");
+            expect(parsedResponse.requestedAmount).toBe("10.5");
+            expect(parsedResponse.availableAmount).toBe("1");
+        });
+    });
+    describe("revokeBaseAccountSpendPermission", () => {
+        it("should handle no permissions to revoke", async () => {
+            mockFetchPermissions.mockResolvedValue([]);
+            const args = {
+                baseAccount: MOCK_BASE_ACCOUNT,
+            };
+            const response = await actionProvider.revokeBaseAccountSpendPermission(mockWallet, args);
+            const parsedResponse = JSON.parse(response);
+            expect(parsedResponse.success).toBe(false);
+            expect(parsedResponse.error).toContain("No spend permissions found for Base Account");
+            expect(parsedResponse.baseAccount).toBe(MOCK_BASE_ACCOUNT);
+            expect(parsedResponse.spender).toBe(MOCK_SPENDER_ADDRESS);
+        });
+        it("should successfully revoke a permission", async () => {
+            mockFetchPermissions.mockResolvedValue([mockPermission]);
+            mockPrepareRevokeCallData.mockResolvedValue({
+                to: "0xRevokeContract",
+                data: "0xrevokeCallData",
+                value: "0x0",
+            });
+            const args = {
+                baseAccount: MOCK_BASE_ACCOUNT,
+                permissionIndex: 1,
+            };
+            const response = await actionProvider.revokeBaseAccountSpendPermission(mockWallet, args);
+            const parsedResponse = JSON.parse(response);
+            expect(parsedResponse.success).toBe(true);
+            expect(parsedResponse.transactionHash).toBe("0xmockTransactionHash");
+            expect(parsedResponse.revokedPermissionIndex).toBe(1);
+            expect(parsedResponse.baseAccount).toBe(MOCK_BASE_ACCOUNT);
+            expect(parsedResponse.spender).toBe(MOCK_SPENDER_ADDRESS);
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: "0xRevokeContract",
+                data: "0xrevokeCallData",
+                value: BigInt("0x0"),
+            });
+        });
+        it("should handle out of range permission index", async () => {
+            mockFetchPermissions.mockResolvedValue([mockPermission]);
+            const args = {
+                baseAccount: MOCK_BASE_ACCOUNT,
+                permissionIndex: 5, // Only 1 permission available
+            };
+            const response = await actionProvider.revokeBaseAccountSpendPermission(mockWallet, args);
+            const parsedResponse = JSON.parse(response);
+            expect(parsedResponse.success).toBe(false);
+            expect(parsedResponse.error).toContain("Permission index 5 is out of range");
+            expect(parsedResponse.availablePermissions).toBe(1);
+        });
+    });
+});

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

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

package/dist/action-providers/baseAccount/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("./baseAccountActionProvider"), exports);
+__exportStar(require("./schemas"), exports);

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

@@ -0,0 +1,43 @@
+import { z } from "zod";
+/**
+ * Input schema for listing Base Account spend permissions action.
+ */
+export declare const ListBaseAccountSpendPermissionsSchema: z.ZodObject<{
+    baseAccount: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    baseAccount: string;
+}, {
+    baseAccount: string;
+}>;
+/**
+ * Input schema for using a Base Account spend permission action.
+ */
+export declare const UseBaseAccountSpendPermissionSchema: z.ZodObject<{
+    baseAccount: z.ZodString;
+    amount: z.ZodOptional<z.ZodNumber>;
+    tokenAddress: z.ZodOptional<z.ZodString>;
+    permissionIndex: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    baseAccount: string;
+    amount?: number | undefined;
+    tokenAddress?: string | undefined;
+    permissionIndex?: number | undefined;
+}, {
+    baseAccount: string;
+    amount?: number | undefined;
+    tokenAddress?: string | undefined;
+    permissionIndex?: number | undefined;
+}>;
+/**
+ * Input schema for revoking a Base Account spend permission action.
+ */
+export declare const RevokeBaseAccountSpendPermissionSchema: z.ZodObject<{
+    baseAccount: z.ZodString;
+    permissionIndex: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    baseAccount: string;
+    permissionIndex?: number | undefined;
+}, {
+    baseAccount: string;
+    permissionIndex?: number | undefined;
+}>;

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RevokeBaseAccountSpendPermissionSchema = exports.UseBaseAccountSpendPermissionSchema = exports.ListBaseAccountSpendPermissionsSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for listing Base Account spend permissions action.
+ */
+exports.ListBaseAccountSpendPermissionsSchema = zod_1.z
+    .object({
+    baseAccount: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The Base Account address to query if it has granted spend permissions"),
+})
+    .strip()
+    .describe("Instructions for listing spend permissions for a Base Account");
+/**
+ * Input schema for using a Base Account spend permission action.
+ */
+exports.UseBaseAccountSpendPermissionSchema = zod_1.z
+    .object({
+    baseAccount: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The Base Account address that has granted the spend permission"),
+    amount: zod_1.z
+        .number()
+        .positive()
+        .optional()
+        .describe("The amount to spend in whole units of the token (e.g. 4.6 for 4.6 tokens). If not provided, will withdraw the full remaining allowance"),
+    tokenAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .optional()
+        .describe("The token contract address. If not provided, will use the first available permission token"),
+    permissionIndex: zod_1.z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("The index of the permission to use (1-based). If not provided, the first permission will be used"),
+})
+    .strip()
+    .describe("Instructions for using a Base Account spend permission");
+/**
+ * Input schema for revoking a Base Account spend permission action.
+ */
+exports.RevokeBaseAccountSpendPermissionSchema = zod_1.z
+    .object({
+    baseAccount: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The Base Account address that has granted the spend permission"),
+    permissionIndex: zod_1.z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("The index of the permission to revoke (1-based). If not provided, the first permission will be revoked"),
+})
+    .strip()
+    .describe("Instructions for revoking a Base Account spend permission");

package/dist/action-providers/baseAccount/types.d.ts

@@ -0,0 +1,17 @@
+export interface PermissionData {
+    account?: string;
+    spender?: string;
+    token?: string;
+    allowance?: bigint | string;
+    period?: number;
+    start?: number;
+    end?: number;
+}
+export interface FetchedPermission {
+    permissionHash?: string;
+    signature?: string;
+    chainId?: number;
+    createdAt?: number;
+    permission?: PermissionData;
+    allowance?: bigint | string;
+}

package/dist/action-providers/baseAccount/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,14 @@
+/**
+ * Convert Unix timestamp to human-readable format
+ *
+ * @param timestamp - Unix timestamp to convert
+ * @returns Human-readable date string
+ */
+export declare function formatTimestamp(timestamp: number): string;
+/**
+ * Convert period in seconds to human-readable format
+ *
+ * @param seconds - Period in seconds to convert
+ * @returns Human-readable period string
+ */
+export declare function formatPeriod(seconds: number): string;

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTimestamp = formatTimestamp;
+exports.formatPeriod = formatPeriod;
+/**
+ * Convert Unix timestamp to human-readable format
+ *
+ * @param timestamp - Unix timestamp to convert
+ * @returns Human-readable date string
+ */
+function formatTimestamp(timestamp) {
+    // Handle special case for maximum timestamp (never expires)
+    // 281474976710655 is the maximum value used in spend permissions to indicate "never expires"
+    if (timestamp >= 281474976710655) {
+        return "Never expires";
+    }
+    // Check if the timestamp would be valid when converted to milliseconds
+    const timestampMs = timestamp * 1000;
+    if (timestampMs > Number.MAX_SAFE_INTEGER) {
+        return "Far future";
+    }
+    const date = new Date(timestampMs);
+    if (isNaN(date.getTime())) {
+        return "Invalid timestamp";
+    }
+    return date.toLocaleString("en-US", {
+        year: "numeric",
+        month: "short",
+        day: "numeric",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        timeZoneName: "short",
+    });
+}
+/**
+ * Convert period in seconds to human-readable format
+ *
+ * @param seconds - Period in seconds to convert
+ * @returns Human-readable period string
+ */
+function formatPeriod(seconds) {
+    const days = Math.floor(seconds / 86400);
+    const hours = Math.floor((seconds % 86400) / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const remainingSeconds = seconds % 60;
+    const parts = [];
+    if (days > 0)
+        parts.push(`${days} day${days !== 1 ? "s" : ""}`);
+    if (hours > 0)
+        parts.push(`${hours} hour${hours !== 1 ? "s" : ""}`);
+    if (minutes > 0)
+        parts.push(`${minutes} minute${minutes !== 1 ? "s" : ""}`);
+    if (remainingSeconds > 0)
+        parts.push(`${remainingSeconds} second${remainingSeconds !== 1 ? "s" : ""}`);
+    return parts.length > 0 ? parts.join(", ") : "0 seconds";
+}

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

@@ -20,6 +20,7 @@ const schemas_1 = require("./schemas");
 const spendPermissionUtils_1 = require("./spendPermissionUtils");
 const swapUtils_1 = require("./swapUtils");
 const viem_1 = require("viem");
+const utils_1 = require("../../utils");
 /**
  * CdpEvmWalletActionProvider is an action provider for CDP EVM Wallet specific actions.
  *
@@ -232,7 +233,7 @@ class CdpEvmWalletActionProvider extends actionProvider_1.ActionProvider {
                 }
             }
             // Execute swap using the all-in-one pattern with retry logic
-            const swapResult = await (0, swapUtils_1.retryWithExponentialBackoff)(async () => {
+            const swapResult = await (0, utils_1.retryWithExponentialBackoff)(async () => {
                 return (await account.swap({
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     network: cdpNetwork,

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

@@ -37,17 +37,19 @@ const cdpEvmWalletActionProvider_1 = require("./cdpEvmWalletActionProvider");
 const schemas_1 = require("./schemas");
 const spendPermissionUtils = __importStar(require("./spendPermissionUtils"));
 const swapUtils = __importStar(require("./swapUtils"));
+const utils = __importStar(require("../../utils"));
 // Mock the CDP SDK and utility functions
 jest.mock("@coinbase/cdp-sdk");
 jest.mock("./spendPermissionUtils");
 jest.mock("./swapUtils");
+jest.mock("../../utils");
 describe("CDP EVM Wallet Action Provider", () => {
     let actionProvider;
     let mockWalletProvider;
     let mockCdpClient;
     let mockAccount;
     const mockGetTokenDetails = swapUtils.getTokenDetails;
-    const mockRetryWithExponentialBackoff = swapUtils.retryWithExponentialBackoff;
+    const mockRetryWithExponentialBackoff = utils.retryWithExponentialBackoff;
     beforeEach(() => {
         jest.clearAllMocks();
         mockAccount = {

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

@@ -18,6 +18,7 @@ const schemas_1 = require("./schemas");
 const spendPermissionUtils_1 = require("./spendPermissionUtils");
 const swapUtils_1 = require("./swapUtils");
 const viem_1 = require("viem");
+const utils_1 = require("../../utils");
 /**
  * CdpSmartWalletActionProvider is an action provider for CDP Smart Wallet specific actions.
  *
@@ -216,7 +217,7 @@ class CdpSmartWalletActionProvider extends actionProvider_1.ActionProvider {
                 }
             }
             // Execute swap using the all-in-one pattern with retry logic
-            const swapResult = await (0, swapUtils_1.retryWithExponentialBackoff)(async () => {
+            const swapResult = await (0, utils_1.retryWithExponentialBackoff)(async () => {
                 return (await walletProvider.smartAccount.swap({
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     network: cdpNetwork,

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

@@ -37,17 +37,19 @@ const cdpSmartWalletActionProvider_1 = require("./cdpSmartWalletActionProvider")
 const schemas_1 = require("./schemas");
 const spendPermissionUtils = __importStar(require("./spendPermissionUtils"));
 const swapUtils = __importStar(require("./swapUtils"));
+const utils = __importStar(require("../../utils"));
 // Mock the CDP SDK and utility functions
 jest.mock("@coinbase/cdp-sdk");
 jest.mock("./spendPermissionUtils");
 jest.mock("./swapUtils");
+jest.mock("../../utils");
 describe("CDP Smart Wallet Action Provider", () => {
     let actionProvider;
     let mockWalletProvider;
     let mockCdpClient;
     let mockSmartAccount;
     const mockGetTokenDetails = swapUtils.getTokenDetails;
-    const mockRetryWithExponentialBackoff = swapUtils.retryWithExponentialBackoff;
+    const mockRetryWithExponentialBackoff = utils.retryWithExponentialBackoff;
     beforeEach(() => {
         jest.clearAllMocks();
         mockSmartAccount = {

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

@@ -21,12 +21,3 @@ export declare function getTokenDetails(walletProvider: EvmWalletProvider, fromT
     fromTokenName: string;
     toTokenName: string;
 }>;
-/**
- * Retry function with exponential backoff
- *
- * @param fn - The function to retry
- * @param maxRetries - Maximum number of retries (default: 3)
- * @param baseDelay - Base delay in milliseconds (default: 1000)
- * @returns Promise that resolves with the function result or rejects with the last error
- */
-export declare function retryWithExponentialBackoff<T>(fn: () => Promise<T>, maxRetries?: number, baseDelay?: number): Promise<T>;