@coinbase/agentkit 0.9.1 → 0.10.0

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;
+}>;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwapSchema = exports.RequestFaucetFundsV2Schema = void 0;
+exports.UseSpendPermissionSchema = exports.ListSpendPermissionsSchema = exports.SwapSchema = exports.RequestFaucetFundsV2Schema = void 0;
 const zod_1 = require("zod");
 /**
  * Input schema for request faucet funds action.
@@ -26,3 +26,34 @@ exports.SwapSchema = zod_1.z
 })
     .strip()
     .describe("Instructions for swapping tokens");
+/**
+ * Input schema for listing spend permissions action.
+ */
+exports.ListSpendPermissionsSchema = zod_1.z
+    .object({
+    smartAccountAddress: zod_1.z
+        .string()
+        .describe("The smart account address that has granted spend permissions"),
+    network: zod_1.z
+        .string()
+        .optional()
+        .describe("The network to list permissions on (defaults to wallet's network)"),
+})
+    .strip()
+    .describe("Instructions for listing spend permissions for a smart account");
+/**
+ * Input schema for using a spend permission action.
+ */
+exports.UseSpendPermissionSchema = zod_1.z
+    .object({
+    smartAccountAddress: zod_1.z
+        .string()
+        .describe("The smart account address that has granted the spend permission"),
+    value: zod_1.z.string().describe("The amount to spend (in the token's units)"),
+    network: zod_1.z
+        .string()
+        .optional()
+        .describe("The network to perform the spend on (defaults to wallet's network)"),
+})
+    .strip()
+    .describe("Instructions for using a spend permission");

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

@@ -0,0 +1,24 @@
+import { CdpClient, type SpendPermission } from "@coinbase/cdp-sdk";
+import type { Address } from "viem";
+/**
+ * Shared utility functions for spend permission operations.
+ */
+/**
+ * Lists and formats spend permissions for a given smart account and spender.
+ *
+ * @param cdpClient - The CDP client to use for API calls
+ * @param smartAccountAddress - The smart account address to check permissions for
+ * @param spenderAddress - The spender address to filter permissions by
+ * @returns A formatted string containing the spend permissions or an error message
+ */
+export declare function listSpendPermissionsForSpender(cdpClient: CdpClient, smartAccountAddress: Address, spenderAddress: Address): Promise<string>;
+/**
+ * Finds and retrieves the latest valid spend permission for a given spender from a smart account.
+ *
+ * @param cdpClient - The CDP client to use for API calls
+ * @param smartAccountAddress - The smart account address to check permissions for
+ * @param spenderAddress - The spender address to find permissions for
+ * @returns The latest spend permission or throws an error if none found
+ * @throws Error if no permissions found or permission is invalid
+ */
+export declare function findLatestSpendPermission(cdpClient: CdpClient, smartAccountAddress: Address, spenderAddress: Address): Promise<SpendPermission>;

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listSpendPermissionsForSpender = listSpendPermissionsForSpender;
+exports.findLatestSpendPermission = findLatestSpendPermission;
+/**
+ * Shared utility functions for spend permission operations.
+ */
+/**
+ * Lists and formats spend permissions for a given smart account and spender.
+ *
+ * @param cdpClient - The CDP client to use for API calls
+ * @param smartAccountAddress - The smart account address to check permissions for
+ * @param spenderAddress - The spender address to filter permissions by
+ * @returns A formatted string containing the spend permissions or an error message
+ */
+async function listSpendPermissionsForSpender(cdpClient, smartAccountAddress, spenderAddress) {
+    try {
+        // List all spend permissions for the smart account
+        const allPermissions = await cdpClient.evm.listSpendPermissions({
+            address: smartAccountAddress,
+        });
+        // Filter permissions where current wallet is the spender
+        const relevantPermissions = allPermissions.spendPermissions.filter(p => p.permission?.spender.toLowerCase() === spenderAddress.toLowerCase());
+        if (relevantPermissions.length === 0) {
+            return `No spend permissions found for spender ${spenderAddress} on smart account ${smartAccountAddress}`;
+        }
+        // Format the permissions for display
+        const formattedPermissions = relevantPermissions
+            .map((p, index) => {
+            const perm = p.permission;
+            if (!perm)
+                return `${index + 1}. Invalid permission`;
+            return `${index + 1}. Token: ${perm.token}, Allowance: ${perm.allowance}, Period: ${perm.period} seconds, Start: ${perm.start}, End: ${perm.end}`;
+        })
+            .join("\n");
+        return `Found ${relevantPermissions.length} spend permission(s):\n${formattedPermissions}`;
+    }
+    catch (error) {
+        return `Failed to list spend permissions: ${error}`;
+    }
+}
+/**
+ * Finds and retrieves the latest valid spend permission for a given spender from a smart account.
+ *
+ * @param cdpClient - The CDP client to use for API calls
+ * @param smartAccountAddress - The smart account address to check permissions for
+ * @param spenderAddress - The spender address to find permissions for
+ * @returns The latest spend permission or throws an error if none found
+ * @throws Error if no permissions found or permission is invalid
+ */
+async function findLatestSpendPermission(cdpClient, smartAccountAddress, spenderAddress) {
+    const allPermissions = await cdpClient.evm.listSpendPermissions({
+        address: smartAccountAddress,
+    });
+    // Filter permissions where current wallet is the spender
+    const relevantPermissions = allPermissions.spendPermissions.filter(p => p.permission?.spender.toLowerCase() === spenderAddress.toLowerCase());
+    if (relevantPermissions.length === 0) {
+        throw new Error(`No spend permissions found for spender ${spenderAddress} on smart account ${smartAccountAddress}`);
+    }
+    // Use the latest permission (last in the array)
+    const latestPermissionWrapper = relevantPermissions.at(-1);
+    if (!latestPermissionWrapper?.permission) {
+        throw new Error("Invalid spend permission found");
+    }
+    return latestPermissionWrapper.permission;
+}

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

@@ -28,5 +28,6 @@ export * from "./flaunch";
 export * from "./onramp";
 export * from "./vaultsfyi";
 export * from "./x402";
+export * from "./zerion";
 export * from "./zerodev";
 export * from "./zora";

package/dist/action-providers/index.js

@@ -44,5 +44,6 @@ __exportStar(require("./flaunch"), exports);
 __exportStar(require("./onramp"), exports);
 __exportStar(require("./vaultsfyi"), exports);
 __exportStar(require("./x402"), exports);
+__exportStar(require("./zerion"), exports);
 __exportStar(require("./zerodev"), exports);
 __exportStar(require("./zora"), exports);

package/dist/action-providers/zerion/constants.d.ts

@@ -0,0 +1 @@
+export declare const ZERION_V1_BASE_URL = "https://api.zerion.io/v1";

package/dist/action-providers/zerion/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZERION_V1_BASE_URL = void 0;
+exports.ZERION_V1_BASE_URL = "https://api.zerion.io/v1";

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

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

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

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

@@ -0,0 +1,11 @@
+import { z } from "zod";
+/**
+ * Input schema for getting wallet portfolio.
+ */
+export declare const GetWalletPortfolioSchema: z.ZodObject<{
+    walletAddress: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    walletAddress: string;
+}, {
+    walletAddress: string;
+}>;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetWalletPortfolioSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for getting wallet portfolio.
+ */
+exports.GetWalletPortfolioSchema = zod_1.z
+    .object({
+    walletAddress: zod_1.z
+        .string()
+        .describe("The wallet address to fetch portfolio for. Defaults is empty string, which will raise an error later if not provided."),
+})
+    .strip()
+    .describe("Input schema for fetching wallet portfolio");