@coinbase/agentkit 0.9.0 → 0.10.0

package/dist/action-providers/weth/wethActionProvider.js

@@ -58,6 +58,30 @@ class WethActionProvider extends actionProvider_1.ActionProvider {
             return `Error wrapping ETH: ${error}`;
         }
     }
+    /**
+     * Unwraps WETH to ETH.
+     *
+     * @param walletProvider - The wallet provider to use for the action.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the transaction hash.
+     */
+    async unwrapEth(walletProvider, args) {
+        try {
+            const hash = await walletProvider.sendTransaction({
+                to: constants_1.WETH_ADDRESS,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.WETH_ABI,
+                    functionName: "withdraw",
+                    args: [BigInt(args.amountToUnwrap)],
+                }),
+            });
+            await walletProvider.waitForTransactionReceipt(hash);
+            return `Unwrapped WETH with transaction hash: ${hash}`;
+        }
+        catch (error) {
+            return `Error unwrapping WETH: ${error}`;
+        }
+    }
 }
 exports.WethActionProvider = WethActionProvider;
 __decorate([
@@ -74,7 +98,7 @@ Important notes:
 - The amount is a string and cannot have any decimal points, since the unit of measurement is wei.
 - Make sure to use the exact amount provided, and if there's any doubt, check by getting more information before continuing with the action.
 - 1 wei = 0.000000000000000001 WETH
-- Minimum purchase amount is 100000000000000 wei (0.0000001 WETH)
+- Minimum purchase amount is 100000000000 wei (0.0000001 WETH)
 - Only supported on the following networks:
   - Base Sepolia (ie, 'base-sepolia')
   - Base Mainnet (ie, 'base', 'base-mainnet')
@@ -85,5 +109,30 @@ Important notes:
     __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], WethActionProvider.prototype, "wrapEth", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "unwrap_eth",
+        description: `
+    This tool can only be used to unwrap WETH to ETH.
+Do not use this tool for any other purpose, or trading other assets.
+
+Inputs:
+- Amount of WETH to unwrap.
+
+Important notes:
+- The amount is a string and cannot have any decimal points, since the unit of measurement is wei.
+- Make sure to use the exact amount provided, and if there's any doubt, check by getting more information before continuing with the action.
+- 1 wei = 0.000000000000000001 WETH
+- Minimum unwrap amount is 100000000000 wei (0.0000001 WETH)
+- Only supported on the following networks:
+  - Base Sepolia (ie, 'base-sepolia')
+  - Base Mainnet (ie, 'base', 'base-mainnet')
+`,
+        schema: schemas_1.UnwrapEthSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], WethActionProvider.prototype, "unwrapEth", null);
 const wethActionProvider = () => new WethActionProvider();
 exports.wethActionProvider = wethActionProvider;

package/dist/action-providers/weth/wethActionProvider.test.js

@@ -21,6 +21,21 @@ describe("Wrap Eth Schema", () => {
         expect(result.success).toBe(false);
     });
 });
+describe("Unwrap Eth Schema", () => {
+    it("should successfully parse valid input", () => {
+        const validInput = {
+            amountToUnwrap: MOCK_AMOUNT,
+        };
+        const result = schemas_1.UnwrapEthSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual(validInput);
+    });
+    it("should fail parsing empty input", () => {
+        const emptyInput = {};
+        const result = schemas_1.UnwrapEthSchema.safeParse(emptyInput);
+        expect(result.success).toBe(false);
+    });
+});
 describe("Wrap Eth Action", () => {
     let mockWallet;
     const actionProvider = (0, wethActionProvider_1.wethActionProvider)();
@@ -66,6 +81,51 @@ describe("Wrap Eth Action", () => {
         expect(response).toContain(`Error wrapping ETH: ${error}`);
     });
 });
+describe("Unwrap Eth Action", () => {
+    let mockWallet;
+    const actionProvider = (0, wethActionProvider_1.wethActionProvider)();
+    beforeEach(async () => {
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            sendTransaction: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+        };
+    });
+    it("should successfully respond", async () => {
+        const args = {
+            amountToUnwrap: MOCK_AMOUNT,
+        };
+        const hash = "0x1234567890123456789012345678901234567890";
+        mockWallet.sendTransaction.mockResolvedValue(hash);
+        const response = await actionProvider.unwrapEth(mockWallet, args);
+        expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+            to: constants_1.WETH_ADDRESS,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: constants_1.WETH_ABI,
+                functionName: "withdraw",
+                args: [BigInt(MOCK_AMOUNT)],
+            }),
+        });
+        expect(response).toContain(`Unwrapped WETH with transaction hash: ${hash}`);
+    });
+    it("should fail with an error", async () => {
+        const args = {
+            amountToUnwrap: MOCK_AMOUNT,
+        };
+        const error = new Error("Failed to unwrap WETH");
+        mockWallet.sendTransaction.mockRejectedValue(error);
+        const response = await actionProvider.unwrapEth(mockWallet, args);
+        expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+            to: constants_1.WETH_ADDRESS,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: constants_1.WETH_ABI,
+                functionName: "withdraw",
+                args: [BigInt(MOCK_AMOUNT)],
+            }),
+        });
+        expect(response).toContain(`Error unwrapping WETH: ${error}`);
+    });
+});
 describe("supportsNetwork", () => {
     const actionProvider = (0, wethActionProvider_1.wethActionProvider)();
     it("should return true for base-mainnet", () => {

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");

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

@@ -0,0 +1,125 @@
+export interface ZerionFungiblePositionsResponse {
+    links: {
+        self: string;
+    };
+    data: ZerionFungiblePosition[];
+}
+export interface ZerionPortfolioResponse {
+    links: {
+        self: string;
+    };
+    data: ZerionPortfolio;
+}
+export interface ZerionPortfolio {
+    type: string;
+    id: string;
+    attributes: PortfolioAttributes;
+}
+export interface PortfolioAttributes {
+    positions_distribution_by_type: {
+        wallet: number;
+        deposited: number;
+        borrowed: number;
+        locked: number;
+        staked: number;
+    };
+    positions_distribution_by_chain: {
+        [key: string]: number;
+    };
+    total: {
+        positions: number;
+    };
+    changes: {
+        absolute_1d: number;
+        percent_1d: number;
+    };
+}
+export interface ZerionFungiblePosition {
+    type: string;
+    id: string;
+    attributes: FungibleAttributes;
+    relationships: Relationships;
+}
+export interface FungibleAttributes {
+    parent: null | string;
+    protocol: null | string;
+    pool_address?: string;
+    group_id?: string;
+    name: string;
+    position_type: PositionType;
+    quantity: Quantity;
+    value: number | null;
+    price: number;
+    changes: Changes | null;
+    fungible_info: FungibleInfo;
+    flags: AttributesFlags;
+    updated_at: Date;
+    updated_at_block: number | null;
+    application_metadata?: ApplicationMetadata;
+}
+export interface ApplicationMetadata {
+    name: string;
+    icon: Icon;
+    url: string;
+}
+export interface Icon {
+    url: string;
+}
+export interface Changes {
+    absolute_1d: number;
+    percent_1d: number;
+}
+export interface AttributesFlags {
+    displayable: boolean;
+    is_trash: boolean;
+}
+export interface FungibleInfo {
+    name: string;
+    symbol: string;
+    icon: Icon | null;
+    flags: FungibleInfoFlags;
+    implementations: Implementation[];
+}
+export interface FungibleInfoFlags {
+    verified: boolean;
+}
+export interface Implementation {
+    chain_id: string;
+    address: null | string;
+    decimals: number;
+}
+export declare enum PositionType {
+    Deposit = "deposit",
+    Reward = "reward",
+    Staked = "staked",
+    Wallet = "wallet"
+}
+export interface Quantity {
+    int: string;
+    decimals: number;
+    float: number;
+    numeric: string;
+}
+export interface Relationships {
+    chain: Chain;
+    dapp?: Dapp;
+    fungible: Chain;
+}
+export interface Dapp {
+    data: Data;
+}
+export interface Chain {
+    links: {
+        related: string;
+    };
+    data: Data;
+}
+export interface Data {
+    type: DataType;
+    id: string;
+}
+export declare enum DataType {
+    Chains = "chains",
+    Dapps = "dapps",
+    Fungibles = "fungibles"
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataType = exports.PositionType = void 0;
+var PositionType;
+(function (PositionType) {
+    PositionType["Deposit"] = "deposit";
+    PositionType["Reward"] = "reward";
+    PositionType["Staked"] = "staked";
+    PositionType["Wallet"] = "wallet";
+})(PositionType || (exports.PositionType = PositionType = {}));
+var DataType;
+(function (DataType) {
+    DataType["Chains"] = "chains";
+    DataType["Dapps"] = "dapps";
+    DataType["Fungibles"] = "fungibles";
+})(DataType || (exports.DataType = DataType = {}));

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

@@ -0,0 +1,3 @@
+import { ZerionFungiblePosition, ZerionPortfolio } from "./types";
+export declare const formatPortfolioData: (data: ZerionPortfolio) => string;
+export declare const formatPositionsData: (data: ZerionFungiblePosition[]) => string;

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPositionsData = exports.formatPortfolioData = void 0;
+const formatPortfolioData = (data) => {
+    // Total value
+    const totalValue = data.attributes.total.positions;
+    const totalValueStr = `$${totalValue.toFixed(2)}`;
+    // 24h change
+    const changePercent = data.attributes.changes.percent_1d;
+    const changeStr = `${changePercent.toFixed(2)}%`;
+    // Positions by type (filter out 0)
+    const types = Object.entries(data.attributes.positions_distribution_by_type)
+        .filter(([_, v]) => v > 0)
+        .map(([type, value]) => `${type}: $${value.toFixed(2)}`)
+        .join(", ");
+    // Positions by chain (top 5 by value)
+    const topChains = Object.entries(data.attributes.positions_distribution_by_chain)
+        .sort(([, a], [, b]) => b - a)
+        .slice(0, 5)
+        .map(([chain, value]) => `${chain}: $${value.toFixed(2)}`)
+        .join(", ");
+    // Final summary string
+    return `Wallet Portfolio Overview:
+- Total Value: ${totalValueStr}
+- 24h Change: ${changeStr}
+- Position Types: ${types}
+- Top Chains: ${topChains}`;
+};
+exports.formatPortfolioData = formatPortfolioData;
+const formatPositionsData = (data) => {
+    const filtered = data.filter(pos => pos.attributes.value !== null);
+    // Sort by value (descending)
+    const sorted = filtered.sort((a, b) => b.attributes.value - a.attributes.value);
+    const lines = [];
+    let totalValue = 0;
+    for (const pos of sorted) {
+        const { value, position_type, fungible_info, application_metadata } = pos.attributes;
+        const chain = pos.relationships.chain.data.id;
+        const protocolLine = application_metadata?.name ? `via ${application_metadata.name}` : "";
+        lines.push(`- ${fungible_info.symbol} (${fungible_info.name}) on ${chain} — $${value.toFixed(2)} [${position_type}${protocolLine ? " " + protocolLine : ""}]`);
+        totalValue += value;
+    }
+    return `Total Value: $${totalValue.toFixed(2)}\n\nToken Positions (>$1):\n${lines.join("\n")}`;
+};
+exports.formatPositionsData = formatPositionsData;

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

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { Network } from "../../network";
+import { ActionProvider } from "../actionProvider";
+import { GetWalletPortfolioSchema } from "./schemas";
+/**
+ * Configuration options for the ZerionActionProvider.
+ */
+export interface ZerionActionProviderConfig {
+    /**
+     * Zerion API Key. Request new at https://zerion.io/api
+     */
+    apiKey?: string;
+}
+/**
+ * ZerionActionProvider provides actions for zerion operations.
+ *
+ * @description
+ * This provider is designed to provide EVM-based operations.
+ * It supports all EVM-based networks.
+ */
+export declare class ZerionActionProvider extends ActionProvider {
+    private readonly apiKey;
+    /**
+     * Constructor for the ZerionActionProvider.
+     *
+     * @param config - The configuration options for the ZerionActionProvider.
+     */
+    constructor(config?: ZerionActionProviderConfig);
+    /**
+     * Fetches and summarizes a crypto wallet's portfolio in USD.
+     *
+     * @param args - Arguments defined by GetWalletPortfolioSchema
+     * @returns A promise that resolves to a string describing the action result
+     */
+    getPortfolioOverview(args: z.infer<typeof GetWalletPortfolioSchema>): Promise<string>;
+    /**
+     * Retrieves and summarizes a wallet's fungible token holdings.
+     *
+     * @param args - Arguments defined by GetWalletPortfolioSchema
+     * @returns A promise that resolves to a string describing the action result
+     */
+    getFungiblePositions(args: z.infer<typeof GetWalletPortfolioSchema>): Promise<string>;
+    /**
+     * Checks if this provider supports the given network.
+     *
+     * @param network - The network to check support for
+     * @returns True if the network is supported
+     */
+    supportsNetwork(network: Network): boolean;
+}
+/**
+ * Factory function to create a new ZerionActionProvider instance.
+ *
+ * @param config - The configuration options for the ZerionActionProvider.
+ * @returns A new ZerionActionProvider instance
+ */
+export declare const zerionActionProvider: (config?: ZerionActionProviderConfig) => ZerionActionProvider;

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

@@ -0,0 +1,159 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zerionActionProvider = exports.ZerionActionProvider = void 0;
+const viem_1 = require("viem");
+const zod_1 = require("zod");
+const actionDecorator_1 = require("../actionDecorator");
+const actionProvider_1 = require("../actionProvider");
+const constants_1 = require("./constants");
+const schemas_1 = require("./schemas");
+const utils_1 = require("./utils");
+/**
+ * ZerionActionProvider provides actions for zerion operations.
+ *
+ * @description
+ * This provider is designed to provide EVM-based operations.
+ * It supports all EVM-based networks.
+ */
+class ZerionActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the ZerionActionProvider.
+     *
+     * @param config - The configuration options for the ZerionActionProvider.
+     */
+    constructor(config = {}) {
+        super("zerion", []);
+        const apiKey = config.apiKey || process.env.ZERION_API_KEY;
+        if (!apiKey) {
+            throw new Error("ZERION_API_KEY is not configured.");
+        }
+        const encodedKey = Buffer.from(`${apiKey}:`).toString("base64");
+        this.apiKey = encodedKey;
+    }
+    /**
+     * Fetches and summarizes a crypto wallet's portfolio in USD.
+     *
+     * @param args - Arguments defined by GetWalletPortfolioSchema
+     * @returns A promise that resolves to a string describing the action result
+     */
+    async getPortfolioOverview(args) {
+        try {
+            const address = args.walletAddress || "";
+            if (!(0, viem_1.isAddress)(address)) {
+                return `Invalid wallet address: ${address}`;
+            }
+            const options = {
+                method: "GET",
+                headers: {
+                    accept: "application/json",
+                    authorization: `Basic ${this.apiKey}`,
+                },
+            };
+            const url = `${constants_1.ZERION_V1_BASE_URL}/wallets/${args.walletAddress}/portfolio?filter[positions]=no_filter&currency=usd`;
+            const response = await fetch(url, options);
+            const { data } = await response.json();
+            return (0, utils_1.formatPortfolioData)(data);
+        }
+        catch (error) {
+            return `Error fetching portfolio overview for wallet ${args.walletAddress}: ${error}`;
+        }
+    }
+    /**
+     * Retrieves and summarizes a wallet's fungible token holdings.
+     *
+     * @param args - Arguments defined by GetWalletPortfolioSchema
+     * @returns A promise that resolves to a string describing the action result
+     */
+    async getFungiblePositions(args) {
+        try {
+            const address = args.walletAddress || "";
+            if (!(0, viem_1.isAddress)(address)) {
+                return `Invalid wallet address: ${address}`;
+            }
+            const options = {
+                method: "GET",
+                headers: {
+                    accept: "application/json",
+                    authorization: `Basic ${this.apiKey}`,
+                },
+            };
+            const url = `${constants_1.ZERION_V1_BASE_URL}/wallets/${args.walletAddress}/positions?filter[positions]=no_filter&currency=usd&filter[trash]=only_non_trash&sort=value`;
+            const response = await fetch(url, options);
+            const { data } = await response.json();
+            return (0, utils_1.formatPositionsData)(data);
+        }
+        catch (error) {
+            return `Error fetching fungible positions for wallet ${args.walletAddress}: ${error}`;
+        }
+    }
+    /**
+     * Checks if this provider supports the given network.
+     *
+     * @param network - The network to check support for
+     * @returns True if the network is supported
+     */
+    supportsNetwork(network) {
+        // all protocol networks
+        return network.protocolFamily === "evm";
+    }
+}
+exports.ZerionActionProvider = ZerionActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_portfolio_overview",
+        description: `
+    Fetches and summarizes a crypto wallet's portfolio in USD. 
+    The tool returns a human-readable overview of the wallet's total value, value distribution across blockchains, position types (e.g., staked, deposited), and 24-hour performance change. 
+    Useful for providing quick insights into a wallet's DeFi and cross-chain holdings.
+    Input:
+    - walletAddress: The wallet address to fetch portfolio overview for.
+    Output a structured text summary with:
+    - Total portfolio value in USD
+    - 24h percentage change in value
+    - Breakdown of value by position types (e.g., wallet, deposited, staked, locked, borrowed)
+    - Top 5 chains by value distribution
+  `,
+        schema: schemas_1.GetWalletPortfolioSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], ZerionActionProvider.prototype, "getPortfolioOverview", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_fungible_positions",
+        description: `
+    Retrieves and summarizes a wallet's fungible token holdings. 
+    For each token, it includes metadata such as symbol, name, holding value, associated protocol (if applicable), and the type of position (e.g., deposit, wallet, reward). 
+    The summary also reports the total USD value of all qualifying token positions.
+    Input:
+    - walletAddress: The wallet address to fetch fungible positions for.
+    Output a readable text summary including:
+    - All token positions
+    - For each: token name, symbol, USD value, chain, position type
+    - If applicable: protocol used and type of action (e.g. staked, deposited via protocol)
+    - A final total value in USD across all included positions
+  `,
+        schema: schemas_1.GetWalletPortfolioSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], ZerionActionProvider.prototype, "getFungiblePositions", null);
+/**
+ * Factory function to create a new ZerionActionProvider instance.
+ *
+ * @param config - The configuration options for the ZerionActionProvider.
+ * @returns A new ZerionActionProvider instance
+ */
+const zerionActionProvider = (config) => new ZerionActionProvider(config);
+exports.zerionActionProvider = zerionActionProvider;

package/dist/action-providers/zerion/zerionActionProvider.test.d.ts

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