@coinbase/agentkit 0.9.0 → 0.10.0

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

@@ -0,0 +1,242 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdpEvmWalletActionProvider_1 = require("./cdpEvmWalletActionProvider");
+const schemas_1 = require("./schemas");
+const spendPermissionUtils = __importStar(require("./spendPermissionUtils"));
+// Mock the CDP SDK and utility functions
+jest.mock("@coinbase/cdp-sdk");
+jest.mock("./spendPermissionUtils");
+describe("CDP EVM Wallet Action Provider", () => {
+    let actionProvider;
+    let mockWalletProvider;
+    let mockCdpClient;
+    let mockAccount;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockAccount = {
+            useSpendPermission: jest.fn(),
+            address: "0x1234567890123456789012345678901234567890",
+        };
+        mockCdpClient = {
+            evm: {
+                listSpendPermissions: jest.fn(),
+                getAccount: jest.fn(),
+            },
+        };
+        mockWalletProvider = {
+            getNetwork: jest.fn(),
+            getAddress: jest.fn(),
+            getClient: jest.fn(),
+        };
+        actionProvider = new cdpEvmWalletActionProvider_1.CdpEvmWalletActionProvider();
+    });
+    describe("listSpendPermissions", () => {
+        const mockArgs = {
+            smartAccountAddress: "0xabcd1234567890123456789012345678901234567890",
+        };
+        beforeEach(() => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-sepolia",
+            });
+            mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
+            mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+        });
+        it("should successfully list spend permissions for EVM wallets", async () => {
+            const expectedResult = "Found 2 spend permission(s):\n1. Token: USDC, Allowance: 500, Period: 1800 seconds, Start: 111111, End: 222222\n2. Token: ETH, Allowance: 1000, Period: 3600 seconds, Start: 123456, End: 234567";
+            spendPermissionUtils.listSpendPermissionsForSpender.mockResolvedValue(expectedResult);
+            const result = await actionProvider.listSpendPermissions(mockWalletProvider, mockArgs);
+            expect(spendPermissionUtils.listSpendPermissionsForSpender).toHaveBeenCalledWith(mockCdpClient, mockArgs.smartAccountAddress, "0x1234567890123456789012345678901234567890");
+            expect(result).toBe(expectedResult);
+        });
+        it("should return error message for non-EVM networks", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "svm",
+                networkId: "solana-devnet",
+            });
+            const result = await actionProvider.listSpendPermissions(mockWalletProvider, mockArgs);
+            expect(result).toBe("Spend permissions are currently only supported on EVM networks.");
+            expect(spendPermissionUtils.listSpendPermissionsForSpender).not.toHaveBeenCalled();
+        });
+        it("should handle utility function errors gracefully", async () => {
+            spendPermissionUtils.listSpendPermissionsForSpender.mockResolvedValue("Failed to list spend permissions: Network error");
+            const result = await actionProvider.listSpendPermissions(mockWalletProvider, mockArgs);
+            expect(result).toBe("Failed to list spend permissions: Network error");
+        });
+        it("should validate input schema", () => {
+            const validInput = { smartAccountAddress: "0xabcd1234567890123456789012345678901234567890" };
+            const invalidInput = { wrongField: "0xabcd1234567890123456789012345678901234567890" };
+            expect(() => schemas_1.ListSpendPermissionsSchema.parse(validInput)).not.toThrow();
+            expect(() => schemas_1.ListSpendPermissionsSchema.parse(invalidInput)).toThrow();
+        });
+    });
+    describe("useSpendPermission", () => {
+        const mockArgs = {
+            smartAccountAddress: "0xabcd1234567890123456789012345678901234567890",
+            value: "2500",
+        };
+        beforeEach(() => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-sepolia",
+            });
+            mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
+            mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+            mockCdpClient.evm.getAccount.mockResolvedValue(mockAccount);
+        });
+        it("should successfully use spend permission for EVM wallets", async () => {
+            const mockPermission = {
+                spender: "0x1234567890123456789012345678901234567890",
+                token: "USDC",
+                allowance: "5000",
+                period: 7200,
+                start: 111111,
+                end: 333333,
+            };
+            const mockSpendResult = {
+                status: "completed",
+                transactionHash: "0xdef456789",
+            };
+            spendPermissionUtils.findLatestSpendPermission.mockResolvedValue(mockPermission);
+            mockAccount.useSpendPermission.mockResolvedValue(mockSpendResult);
+            const result = await actionProvider.useSpendPermission(mockWalletProvider, mockArgs);
+            expect(spendPermissionUtils.findLatestSpendPermission).toHaveBeenCalledWith(mockCdpClient, mockArgs.smartAccountAddress, "0x1234567890123456789012345678901234567890");
+            expect(mockCdpClient.evm.getAccount).toHaveBeenCalledWith({
+                address: "0x1234567890123456789012345678901234567890",
+            });
+            expect(mockAccount.useSpendPermission).toHaveBeenCalledWith({
+                spendPermission: mockPermission,
+                value: BigInt(2500),
+                network: "base-sepolia",
+            });
+            expect(result).toBe("Successfully spent 2500 tokens using spend permission. Transaction hash: 0xdef456789");
+        });
+        it("should handle different network conversions", async () => {
+            const testCases = [
+                { networkId: "base-sepolia", expected: "base-sepolia" },
+                { networkId: "base-mainnet", expected: "base" },
+                { networkId: "ethereum-sepolia", expected: "ethereum-sepolia" },
+                { networkId: "ethereum-mainnet", expected: "ethereum" },
+            ];
+            const mockPermission = { spender: "0x1234", token: "ETH" };
+            const mockSpendResult = { status: "completed" };
+            spendPermissionUtils.findLatestSpendPermission.mockResolvedValue(mockPermission);
+            mockAccount.useSpendPermission.mockResolvedValue(mockSpendResult);
+            for (const testCase of testCases) {
+                jest.clearAllMocks();
+                mockWalletProvider.getNetwork.mockReturnValue({
+                    protocolFamily: "evm",
+                    networkId: testCase.networkId,
+                });
+                mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+                mockCdpClient.evm.getAccount.mockResolvedValue(mockAccount);
+                await actionProvider.useSpendPermission(mockWalletProvider, mockArgs);
+                expect(mockAccount.useSpendPermission).toHaveBeenCalledWith({
+                    spendPermission: mockPermission,
+                    value: BigInt(2500),
+                    network: testCase.expected,
+                });
+            }
+        });
+        it("should handle unknown networks by passing them as-is", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "polygon-mainnet",
+            });
+            const mockPermission = { spender: "0x1234", token: "MATIC" };
+            const mockSpendResult = { status: "completed" };
+            spendPermissionUtils.findLatestSpendPermission.mockResolvedValue(mockPermission);
+            mockAccount.useSpendPermission.mockResolvedValue(mockSpendResult);
+            await actionProvider.useSpendPermission(mockWalletProvider, mockArgs);
+            expect(mockAccount.useSpendPermission).toHaveBeenCalledWith({
+                spendPermission: mockPermission,
+                value: BigInt(2500),
+                network: "polygon-mainnet",
+            });
+        });
+        it("should return error message for non-EVM networks", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "svm",
+                networkId: "solana-devnet",
+            });
+            const result = await actionProvider.useSpendPermission(mockWalletProvider, mockArgs);
+            expect(result).toBe("Spend permissions are currently only supported on EVM networks.");
+        });
+        it("should handle spend permission not found error", async () => {
+            spendPermissionUtils.findLatestSpendPermission.mockRejectedValue(new Error("No spend permissions found for spender"));
+            const result = await actionProvider.useSpendPermission(mockWalletProvider, mockArgs);
+            expect(result).toBe("Failed to use spend permission: Error: No spend permissions found for spender");
+        });
+        it("should handle account creation failure", async () => {
+            spendPermissionUtils.findLatestSpendPermission.mockResolvedValue({
+                spender: "0x1234",
+                token: "ETH",
+            });
+            mockCdpClient.evm.getAccount.mockRejectedValue(new Error("Account not found"));
+            const result = await actionProvider.useSpendPermission(mockWalletProvider, mockArgs);
+            expect(result).toBe("Failed to use spend permission: Error: Account not found");
+        });
+        it("should handle account use permission failure", async () => {
+            const mockPermission = { spender: "0x1234", token: "ETH" };
+            spendPermissionUtils.findLatestSpendPermission.mockResolvedValue(mockPermission);
+            mockAccount.useSpendPermission.mockRejectedValue(new Error("Insufficient allowance"));
+            const result = await actionProvider.useSpendPermission(mockWalletProvider, mockArgs);
+            expect(result).toBe("Failed to use spend permission: Error: Insufficient allowance");
+        });
+        it("should validate input schema", () => {
+            const validInput = {
+                smartAccountAddress: "0xabcd1234567890123456789012345678901234567890",
+                value: "1000",
+            };
+            const invalidInput = {
+                smartAccountAddress: "not-an-address",
+                value: -100,
+            };
+            expect(() => schemas_1.UseSpendPermissionSchema.parse(validInput)).not.toThrow();
+            expect(() => schemas_1.UseSpendPermissionSchema.parse(invalidInput)).toThrow();
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for EVM networks", () => {
+            const evmNetwork = { protocolFamily: "evm", networkId: "base-sepolia" };
+            expect(actionProvider.supportsNetwork(evmNetwork)).toBe(true);
+        });
+        it("should return false for non-EVM networks", () => {
+            const svmNetwork = { protocolFamily: "svm", networkId: "solana-devnet" };
+            expect(actionProvider.supportsNetwork(svmNetwork)).toBe(false);
+        });
+    });
+});

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

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { CdpSmartWalletProvider } from "../../wallet-providers/cdpSmartWalletProvider";
+import { ActionProvider } from "../actionProvider";
+import { UseSpendPermissionSchema, ListSpendPermissionsSchema } from "./schemas";
+import type { Network } from "../../network";
+/**
+ * CdpSmartWalletActionProvider is an action provider for CDP Smart Wallet specific actions.
+ *
+ * This provider is scoped specifically to CdpSmartWalletProvider and provides actions
+ * that are optimized for smart wallet functionality.
+ */
+export declare class CdpSmartWalletActionProvider extends ActionProvider<CdpSmartWalletProvider> {
+    #private;
+    /**
+     * Constructor for the CdpSmartWalletActionProvider class.
+     */
+    constructor();
+    /**
+     * Lists spend permissions for a smart account.
+     *
+     * @param walletProvider - The smart wallet provider to use for listing permissions.
+     * @param args - The input arguments for listing spend permissions.
+     * @returns A list of spend permissions available to the current wallet.
+     */
+    listSpendPermissions(walletProvider: CdpSmartWalletProvider, args: z.infer<typeof ListSpendPermissionsSchema>): Promise<string>;
+    /**
+     * Uses a spend permission to transfer tokens from a smart account to the current smart wallet.
+     *
+     * @param walletProvider - The smart wallet provider to use for the spend operation.
+     * @param args - The input arguments for using the spend permission.
+     * @returns A confirmation message with transaction details.
+     */
+    useSpendPermission(walletProvider: CdpSmartWalletProvider, args: z.infer<typeof UseSpendPermissionSchema>): Promise<string>;
+    /**
+     * Checks if the smart wallet action provider supports the given network.
+     *
+     * @param _  - The network to check.
+     * @returns True if the smart wallet action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (_: Network) => boolean;
+}
+export declare const cdpSmartWalletActionProvider: () => CdpSmartWalletActionProvider;

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

@@ -0,0 +1,132 @@
+"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 __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _CdpSmartWalletActionProvider_instances, _CdpSmartWalletActionProvider_getCdpSdkNetwork;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cdpSmartWalletActionProvider = exports.CdpSmartWalletActionProvider = void 0;
+const zod_1 = require("zod");
+const cdpSmartWalletProvider_1 = require("../../wallet-providers/cdpSmartWalletProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const actionProvider_1 = require("../actionProvider");
+const schemas_1 = require("./schemas");
+const spendPermissionUtils_1 = require("./spendPermissionUtils");
+/**
+ * CdpSmartWalletActionProvider is an action provider for CDP Smart Wallet specific actions.
+ *
+ * This provider is scoped specifically to CdpSmartWalletProvider and provides actions
+ * that are optimized for smart wallet functionality.
+ */
+class CdpSmartWalletActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the CdpSmartWalletActionProvider class.
+     */
+    constructor() {
+        super("cdp_smart_wallet", []);
+        _CdpSmartWalletActionProvider_instances.add(this);
+        /**
+         * Checks if the smart wallet action provider supports the given network.
+         *
+         * @param _  - The network to check.
+         * @returns True if the smart wallet action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (_) => {
+            return true;
+        };
+    }
+    /**
+     * Lists spend permissions for a smart account.
+     *
+     * @param walletProvider - The smart wallet provider to use for listing permissions.
+     * @param args - The input arguments for listing spend permissions.
+     * @returns A list of spend permissions available to the current wallet.
+     */
+    async listSpendPermissions(walletProvider, args) {
+        const network = walletProvider.getNetwork();
+        if (network.protocolFamily === "evm") {
+            const spenderAddress = walletProvider.getAddress();
+            return await (0, spendPermissionUtils_1.listSpendPermissionsForSpender)(walletProvider.getClient(), args.smartAccountAddress, spenderAddress);
+        }
+        else {
+            return "Spend permissions are currently only supported on EVM networks.";
+        }
+    }
+    /**
+     * Uses a spend permission to transfer tokens from a smart account to the current smart wallet.
+     *
+     * @param walletProvider - The smart wallet provider to use for the spend operation.
+     * @param args - The input arguments for using the spend permission.
+     * @returns A confirmation message with transaction details.
+     */
+    async useSpendPermission(walletProvider, args) {
+        const network = walletProvider.getNetwork();
+        const cdpNetwork = __classPrivateFieldGet(this, _CdpSmartWalletActionProvider_instances, "m", _CdpSmartWalletActionProvider_getCdpSdkNetwork).call(this, network.networkId);
+        if (network.protocolFamily === "evm") {
+            try {
+                const permission = await (0, spendPermissionUtils_1.findLatestSpendPermission)(walletProvider.getClient(), args.smartAccountAddress, walletProvider.getAddress());
+                const spendResult = await walletProvider.smartAccount.useSpendPermission({
+                    spendPermission: permission,
+                    value: BigInt(args.value),
+                    network: cdpNetwork,
+                });
+                return `Successfully spent ${args.value} tokens using spend permission. Status: ${spendResult.status}`;
+            }
+            catch (error) {
+                throw new Error(`Failed to use spend permission: ${error}`);
+            }
+        }
+        else {
+            throw new Error("Spend permissions are currently only supported on EVM networks.");
+        }
+    }
+}
+exports.CdpSmartWalletActionProvider = CdpSmartWalletActionProvider;
+_CdpSmartWalletActionProvider_instances = new WeakSet(), _CdpSmartWalletActionProvider_getCdpSdkNetwork = function _CdpSmartWalletActionProvider_getCdpSdkNetwork(networkId) {
+    switch (networkId) {
+        case "base-sepolia":
+            return "base-sepolia";
+        case "base-mainnet":
+            return "base";
+        default:
+            throw new Error(`Unsupported network for smart wallets: ${networkId}`);
+    }
+};
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "list_spend_permissions",
+        description: `This tool lists spend permissions that have been granted to the current smart wallet by another smart account.
+It takes a smart account address and returns spend permissions where the current smart wallet is the spender.
+This is useful to see what spending allowances have been granted before using them.
+This action is specifically designed for smart wallets.`,
+        schema: schemas_1.ListSpendPermissionsSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [cdpSmartWalletProvider_1.CdpSmartWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], CdpSmartWalletActionProvider.prototype, "listSpendPermissions", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "use_spend_permission",
+        description: `This tool uses a spend permission to spend tokens on behalf of a smart account that the current smart wallet has permission to spend.
+It automatically finds the latest valid spend permission granted by the smart account to the current smart wallet and uses it to spend the specified amount.
+The smart account must have previously granted a spend permission to the current smart wallet using createSpendPermission.
+This action is specifically designed for smart wallets and uses the smart account directly for optimal performance.`,
+        schema: schemas_1.UseSpendPermissionSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [cdpSmartWalletProvider_1.CdpSmartWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], CdpSmartWalletActionProvider.prototype, "useSpendPermission", null);
+const cdpSmartWalletActionProvider = () => new CdpSmartWalletActionProvider();
+exports.cdpSmartWalletActionProvider = cdpSmartWalletActionProvider;

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

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

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

@@ -0,0 +1,199 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdpSmartWalletActionProvider_1 = require("./cdpSmartWalletActionProvider");
+const schemas_1 = require("./schemas");
+const spendPermissionUtils = __importStar(require("./spendPermissionUtils"));
+// Mock the CDP SDK and utility functions
+jest.mock("@coinbase/cdp-sdk");
+jest.mock("./spendPermissionUtils");
+describe("CDP Smart Wallet Action Provider", () => {
+    let actionProvider;
+    let mockWalletProvider;
+    let mockCdpClient;
+    let mockSmartAccount;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockSmartAccount = {
+            useSpendPermission: jest.fn(),
+            address: "0x1234567890123456789012345678901234567890",
+        };
+        mockCdpClient = {
+            evm: {
+                listSpendPermissions: jest.fn(),
+            },
+        };
+        mockWalletProvider = {
+            getNetwork: jest.fn(),
+            getAddress: jest.fn(),
+            getClient: jest.fn(),
+            smartAccount: mockSmartAccount,
+        };
+        actionProvider = new cdpSmartWalletActionProvider_1.CdpSmartWalletActionProvider();
+    });
+    describe("listSpendPermissions", () => {
+        const mockArgs = {
+            smartAccountAddress: "0xabcd1234567890123456789012345678901234567890",
+        };
+        beforeEach(() => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-sepolia",
+            });
+            mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
+            mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+        });
+        it("should successfully list spend permissions for EVM networks", async () => {
+            const expectedResult = "Found 1 spend permission(s):\n1. Token: ETH, Allowance: 1000, Period: 3600 seconds, Start: 123456, End: 234567";
+            spendPermissionUtils.listSpendPermissionsForSpender.mockResolvedValue(expectedResult);
+            const result = await actionProvider.listSpendPermissions(mockWalletProvider, mockArgs);
+            expect(spendPermissionUtils.listSpendPermissionsForSpender).toHaveBeenCalledWith(mockCdpClient, mockArgs.smartAccountAddress, "0x1234567890123456789012345678901234567890");
+            expect(result).toBe(expectedResult);
+        });
+        it("should return error message for non-EVM networks", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "svm",
+                networkId: "solana-devnet",
+            });
+            const result = await actionProvider.listSpendPermissions(mockWalletProvider, mockArgs);
+            expect(result).toBe("Spend permissions are currently only supported on EVM networks.");
+            expect(spendPermissionUtils.listSpendPermissionsForSpender).not.toHaveBeenCalled();
+        });
+        it("should validate input schema", () => {
+            const validInput = { smartAccountAddress: "0xabcd1234567890123456789012345678901234567890" };
+            const invalidInput = { invalidField: "invalid" };
+            expect(() => schemas_1.ListSpendPermissionsSchema.parse(validInput)).not.toThrow();
+            expect(() => schemas_1.ListSpendPermissionsSchema.parse(invalidInput)).toThrow();
+        });
+    });
+    describe("useSpendPermission", () => {
+        const mockArgs = {
+            smartAccountAddress: "0xabcd1234567890123456789012345678901234567890",
+            value: "1000",
+        };
+        beforeEach(() => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-sepolia",
+            });
+            mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
+            mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+        });
+        it("should successfully use spend permission for EVM networks", async () => {
+            const mockPermission = {
+                spender: "0x1234567890123456789012345678901234567890",
+                token: "ETH",
+                allowance: "1000",
+                period: 3600,
+                start: 123456,
+                end: 234567,
+            };
+            const mockSpendResult = {
+                status: "completed",
+                transactionHash: "0xabcd1234",
+            };
+            spendPermissionUtils.findLatestSpendPermission.mockResolvedValue(mockPermission);
+            mockSmartAccount.useSpendPermission.mockResolvedValue(mockSpendResult);
+            const result = await actionProvider.useSpendPermission(mockWalletProvider, mockArgs);
+            expect(spendPermissionUtils.findLatestSpendPermission).toHaveBeenCalledWith(mockCdpClient, mockArgs.smartAccountAddress, "0x1234567890123456789012345678901234567890");
+            expect(mockSmartAccount.useSpendPermission).toHaveBeenCalledWith({
+                spendPermission: mockPermission,
+                value: BigInt(1000),
+                network: "base-sepolia",
+            });
+            expect(result).toBe("Successfully spent 1000 tokens using spend permission. Status: completed");
+        });
+        it("should handle base-mainnet network conversion", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            const mockPermission = { spender: "0x1234", token: "ETH" };
+            const mockSpendResult = { status: "completed" };
+            spendPermissionUtils.findLatestSpendPermission.mockResolvedValue(mockPermission);
+            mockSmartAccount.useSpendPermission.mockResolvedValue(mockSpendResult);
+            await actionProvider.useSpendPermission(mockWalletProvider, mockArgs);
+            expect(mockSmartAccount.useSpendPermission).toHaveBeenCalledWith({
+                spendPermission: mockPermission,
+                value: BigInt(1000),
+                network: "base",
+            });
+        });
+        it("should throw error for unsupported networks", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "ethereum-mainnet",
+            });
+            await expect(actionProvider.useSpendPermission(mockWalletProvider, mockArgs)).rejects.toThrow("Unsupported network for smart wallets: ethereum-mainnet");
+        });
+        it("should return error message for non-EVM networks", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "svm",
+                networkId: "solana-devnet",
+            });
+            await expect(actionProvider.useSpendPermission(mockWalletProvider, mockArgs)).rejects.toThrow("Unsupported network for smart wallets: solana-devnet");
+        });
+        it("should handle spend permission not found error", async () => {
+            spendPermissionUtils.findLatestSpendPermission.mockRejectedValue(new Error("No spend permissions found"));
+            await expect(actionProvider.useSpendPermission(mockWalletProvider, mockArgs)).rejects.toThrow("Failed to use spend permission: Error: No spend permissions found");
+        });
+        it("should handle smart account use permission failure", async () => {
+            const mockPermission = { spender: "0x1234", token: "ETH" };
+            spendPermissionUtils.findLatestSpendPermission.mockResolvedValue(mockPermission);
+            mockSmartAccount.useSpendPermission.mockRejectedValue(new Error("Transaction failed"));
+            await expect(actionProvider.useSpendPermission(mockWalletProvider, mockArgs)).rejects.toThrow("Failed to use spend permission: Error: Transaction failed");
+        });
+        it("should validate input schema", () => {
+            const validInput = {
+                smartAccountAddress: "0xabcd1234567890123456789012345678901234567890",
+                value: "1000",
+            };
+            const invalidInput = {
+                wrongField: "0xabcd1234567890123456789012345678901234567890",
+                // Missing required fields
+            };
+            expect(() => schemas_1.UseSpendPermissionSchema.parse(validInput)).not.toThrow();
+            expect(() => schemas_1.UseSpendPermissionSchema.parse(invalidInput)).toThrow();
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for any network", () => {
+            const evmNetwork = { protocolFamily: "evm", networkId: "base-sepolia" };
+            const svmNetwork = { protocolFamily: "svm", networkId: "solana-devnet" };
+            expect(actionProvider.supportsNetwork(evmNetwork)).toBe(true);
+            expect(actionProvider.supportsNetwork(svmNetwork)).toBe(true);
+        });
+    });
+});

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

@@ -1,2 +1,5 @@
 export * from "./schemas";
 export * from "./cdpApiActionProvider";
+export * from "./cdpSmartWalletActionProvider";
+export * from "./cdpEvmWalletActionProvider";
+export * from "./spendPermissionUtils";

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

@@ -16,3 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./schemas"), exports);
 __exportStar(require("./cdpApiActionProvider"), exports);
+__exportStar(require("./cdpSmartWalletActionProvider"), exports);
+__exportStar(require("./cdpEvmWalletActionProvider"), exports);
+__exportStar(require("./spendPermissionUtils"), exports);

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

@@ -28,3 +28,32 @@ export declare const SwapSchema: z.ZodObject<{
     toAssetId: string;
     network?: string | undefined;
 }>;
+/**
+ * Input schema for listing spend permissions action.
+ */
+export declare const ListSpendPermissionsSchema: z.ZodObject<{
+    smartAccountAddress: z.ZodString;
+    network: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    smartAccountAddress: string;
+    network?: string | undefined;
+}, {
+    smartAccountAddress: string;
+    network?: string | undefined;
+}>;
+/**
+ * Input schema for using a spend permission action.
+ */
+export declare const UseSpendPermissionSchema: z.ZodObject<{
+    smartAccountAddress: z.ZodString;
+    value: z.ZodString;
+    network: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    smartAccountAddress: string;
+    network?: string | undefined;
+}, {
+    value: string;
+    smartAccountAddress: string;
+    network?: string | undefined;
+}>;