@coinbase/agentkit 0.10.2 → 0.10.3

package/dist/action-providers/x402/x402ActionProvider.test.js

@@ -37,9 +37,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const x402ActionProvider_1 = require("./x402ActionProvider");
+const wallet_providers_1 = require("../../wallet-providers");
 const axios_1 = __importDefault(require("axios"));
 const x402axios = __importStar(require("x402-axios"));
 const x402Verify = __importStar(require("x402/verify"));
+const utils = __importStar(require("./utils"));
 // Mock external facilitator dependency
 jest.mock("@coinbase/x402", () => ({
     facilitator: {},
@@ -48,6 +50,7 @@ jest.mock("@coinbase/x402", () => ({
 jest.mock("axios");
 jest.mock("x402-axios");
 jest.mock("x402/verify");
+jest.mock("./utils");
 // Create mock functions
 const mockRequest = jest.fn();
 // Create a complete mock axios instance
@@ -90,6 +93,10 @@ const mockAxios = {
 const mockWithPaymentInterceptor = jest.fn().mockReturnValue(mockAxiosInstance);
 const mockDecodeXPaymentResponse = jest.fn();
 const mockUseFacilitator = jest.fn();
+const mockIsUsdcAsset = jest.fn();
+const mockConvertWholeUnitsToAtomic = jest.fn();
+const mockFormatPaymentOption = jest.fn();
+const mockGetX402Network = jest.fn();
 // Override the mocked modules
 axios_1.default.create = mockAxios.create;
 axios_1.default.request = mockRequest;
@@ -98,11 +105,25 @@ axios_1.default.isAxiosError = mockAxios.isAxiosError;
 jest.mocked(x402axios.withPaymentInterceptor).mockImplementation(mockWithPaymentInterceptor);
 jest.mocked(x402axios.decodeXPaymentResponse).mockImplementation(mockDecodeXPaymentResponse);
 jest.mocked(x402Verify.useFacilitator).mockImplementation(mockUseFacilitator);
-// Mock wallet provider
-const makeMockWalletProvider = (networkId) => ({
-    toSigner: jest.fn().mockReturnValue("mock-signer"),
-    getNetwork: jest.fn().mockReturnValue({ protocolFamily: "evm", networkId }),
+// Mock utils functions
+jest.mocked(utils.isUsdcAsset).mockImplementation(mockIsUsdcAsset);
+jest.mocked(utils.convertWholeUnitsToAtomic).mockImplementation(mockConvertWholeUnitsToAtomic);
+jest.mocked(utils.formatPaymentOption).mockImplementation(mockFormatPaymentOption);
+jest.mocked(utils.getX402Network).mockImplementation(mockGetX402Network);
+jest.mocked(utils.handleHttpError).mockImplementation((error, url) => {
+    return JSON.stringify({
+        error: true,
+        message: error instanceof Error ? error.message : "Network error",
+        url: url,
+    });
 });
+// Mock wallet provider
+const makeMockWalletProvider = (networkId) => {
+    const mockProvider = Object.create(wallet_providers_1.EvmWalletProvider.prototype);
+    mockProvider.toSigner = jest.fn().mockReturnValue("mock-signer");
+    mockProvider.getNetwork = jest.fn().mockReturnValue({ protocolFamily: "evm", networkId });
+    return mockProvider;
+};
 // Sample responses based on real examples
 const MOCK_PAYMENT_INFO_RESPONSE = {
     paymentRequired: true,
@@ -150,6 +171,11 @@ describe("X402ActionProvider", () => {
             .mockImplementation((error) => Boolean(error &&
             typeof error === "object" &&
             ("isAxiosError" in error || "response" in error || "request" in error)));
+        // Reset all utility mocks to default behavior
+        mockGetX402Network.mockImplementation(network => network.networkId);
+        mockIsUsdcAsset.mockReturnValue(false);
+        mockConvertWholeUnitsToAtomic.mockResolvedValue("100000");
+        mockFormatPaymentOption.mockResolvedValue("mocked payment option");
     });
     afterEach(() => {
         jest.clearAllMocks();
@@ -167,8 +193,12 @@ describe("X402ActionProvider", () => {
             const network = { protocolFamily: "evm", networkId: "ethereum" };
             expect(provider.supportsNetwork(network)).toBe(false);
         });
-        it("should not support non-EVM networks", () => {
-            const network = { protocolFamily: "solana", networkId: "mainnet" };
+        it("should support SVM networks", () => {
+            const network = { protocolFamily: "svm", networkId: "solana-mainnet" };
+            expect(provider.supportsNetwork(network)).toBe(true);
+        });
+        it("should not support non-EVM/SVM networks", () => {
+            const network = { protocolFamily: "bitcoin", networkId: "mainnet" };
             expect(provider.supportsNetwork(network)).toBe(false);
         });
     });
@@ -190,6 +220,8 @@ describe("X402ActionProvider", () => {
             expect(parsedResult.data).toEqual({ message: "Success" });
         });
         it("should handle 402 responses with payment options", async () => {
+            mockGetX402Network.mockReturnValue("base-sepolia");
+            mockFormatPaymentOption.mockResolvedValue("10000 USDC on base-sepolia network");
             mockRequest.mockResolvedValue({
                 status: 402,
                 data: MOCK_PAYMENT_INFO_RESPONSE.data,
@@ -241,6 +273,7 @@ describe("X402ActionProvider", () => {
                 ],
             });
             mockUseFacilitator.mockReturnValue({ list: mockList });
+            mockGetX402Network.mockReturnValue("base-sepolia");
             const result = await provider.discoverX402Services(makeMockWalletProvider("base-sepolia"), {});
             const parsed = JSON.parse(result);
             expect(parsed.success).toBe(true);
@@ -299,6 +332,14 @@ describe("X402ActionProvider", () => {
                 ],
             });
             mockUseFacilitator.mockReturnValue({ list: mockList });
+            // Mock the utility functions for this test
+            mockGetX402Network.mockReturnValue("base-sepolia");
+            mockIsUsdcAsset.mockReturnValue(true); // All assets are USDC
+            mockConvertWholeUnitsToAtomic
+                .mockResolvedValueOnce("100000") // 0.1 USDC in atomic units
+                .mockResolvedValueOnce("100000")
+                .mockResolvedValueOnce("100000");
+            mockFormatPaymentOption.mockResolvedValue("formatted payment option");
             const result = await provider.discoverX402Services(makeMockWalletProvider("base-sepolia"), {
                 maxUsdcPrice: 0.1,
             });
@@ -319,6 +360,7 @@ describe("X402ActionProvider", () => {
     describe("retryHttpRequestWithX402", () => {
         it("should successfully retry with payment", async () => {
             mockDecodeXPaymentResponse.mockReturnValue(MOCK_PAYMENT_RESPONSE);
+            mockGetX402Network.mockReturnValue("base-sepolia");
             mockRequest.mockResolvedValue({
                 status: 200,
                 statusText: "OK",
@@ -353,6 +395,7 @@ describe("X402ActionProvider", () => {
             error.isAxiosError = true;
             error.request = {};
             mockRequest.mockRejectedValue(error);
+            mockGetX402Network.mockReturnValue("base-sepolia");
             const result = await provider.retryWithX402(makeMockWalletProvider("base-sepolia"), {
                 url: "https://www.x402.org/protected",
                 method: "GET",
@@ -395,6 +438,7 @@ describe("X402ActionProvider", () => {
             });
         });
         it("should handle successful non-payment requests", async () => {
+            mockDecodeXPaymentResponse.mockReturnValue(null); // No payment made
             mockRequest.mockResolvedValue({
                 status: 200,
                 statusText: "OK",

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

@@ -0,0 +1,64 @@
+export declare const YELAY_BACKEND_URL = "https://lite.api.yelay.io/v2";
+export declare const RETAIL_POOL_ID = 10;
+export declare const YELAY_VAULT_ABI: {
+    type: string;
+    name: string;
+    inputs: {
+        name: string;
+        type: string;
+        internalType: string;
+    }[];
+    outputs: {
+        name: string;
+        type: string;
+        internalType: string;
+    }[];
+    stateMutability: string;
+}[];
+export declare const YIELD_EXTRACTOR_ABI: ({
+    inputs: {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: never[];
+    stateMutability: string;
+    type: string;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+})[];
+export declare const CONTRACTS_BY_CHAIN: {
+    readonly 1: {
+        readonly YieldExtractor: "0x226239384EB7d78Cdf279BA6Fb458E2A4945E275";
+    };
+    readonly 146: {
+        readonly YieldExtractor: "0xB84B621D3da3E5e47A1927883C685455Ad731D7C";
+    };
+    readonly 8453: {
+        readonly YieldExtractor: "0x4d6a89dc55d8bacc0cbc3824bd7e44fa051c3958";
+    };
+    readonly 42161: {
+        readonly YieldExtractor: "0x79b7e90F1BAe837362DBD2c83Bd0715c2De5E47f";
+    };
+    readonly 43114: {
+        readonly YieldExtractor: "0x98732e2FEb854bAd400D4b5336f4439E7E53fe88";
+    };
+};

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

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTRACTS_BY_CHAIN = exports.YIELD_EXTRACTOR_ABI = exports.YELAY_VAULT_ABI = exports.RETAIL_POOL_ID = exports.YELAY_BACKEND_URL = void 0;
+exports.YELAY_BACKEND_URL = "https://lite.api.yelay.io/v2";
+exports.RETAIL_POOL_ID = 10;
+exports.YELAY_VAULT_ABI = [
+    {
+        type: "function",
+        name: "deposit",
+        inputs: [
+            { name: "assets", type: "uint256", internalType: "uint256" },
+            { name: "projectId", type: "uint256", internalType: "uint256" },
+            { name: "receiver", type: "address", internalType: "address" },
+        ],
+        outputs: [{ name: "shares", type: "uint256", internalType: "uint256" }],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        name: "redeem",
+        inputs: [
+            { name: "shares", type: "uint256", internalType: "uint256" },
+            { name: "projectId", type: "uint256", internalType: "uint256" },
+            { name: "receiver", type: "address", internalType: "address" },
+        ],
+        outputs: [{ name: "assets", type: "uint256", internalType: "uint256" }],
+        stateMutability: "nonpayable",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "account",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "id",
+                type: "uint256",
+            },
+        ],
+        name: "balanceOf",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+];
+exports.YIELD_EXTRACTOR_ABI = [
+    {
+        inputs: [
+            {
+                components: [
+                    { internalType: "address", name: "yelayLiteVault", type: "address" },
+                    {
+                        internalType: "uint256",
+                        name: "projectId",
+                        type: "uint256",
+                    },
+                    {
+                        internalType: "uint256",
+                        name: "cycle",
+                        type: "uint256",
+                    },
+                    {
+                        internalType: "uint256",
+                        name: "yieldSharesTotal",
+                        type: "uint256",
+                    },
+                    {
+                        internalType: "bytes32[]",
+                        name: "proof",
+                        type: "bytes32[]",
+                    },
+                ],
+                internalType: "struct YieldExtractor.ClaimRequest[]",
+                name: "data",
+                type: "tuple[]",
+            },
+        ],
+        name: "claim",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "user",
+                type: "address",
+            },
+            {
+                internalType: "address",
+                name: "yelayLiteVault",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "poolID",
+                type: "uint256",
+            },
+        ],
+        name: "yieldSharesClaimed",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+];
+exports.CONTRACTS_BY_CHAIN = {
+    1: {
+        YieldExtractor: "0x226239384EB7d78Cdf279BA6Fb458E2A4945E275",
+    },
+    146: {
+        YieldExtractor: "0xB84B621D3da3E5e47A1927883C685455Ad731D7C",
+    },
+    8453: {
+        YieldExtractor: "0x4d6a89dc55d8bacc0cbc3824bd7e44fa051c3958",
+    },
+    42161: {
+        YieldExtractor: "0x79b7e90F1BAe837362DBD2c83Bd0715c2De5E47f",
+    },
+    43114: {
+        YieldExtractor: "0x98732e2FEb854bAd400D4b5336f4439E7E53fe88",
+    },
+};

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

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

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

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

@@ -0,0 +1,47 @@
+import { z } from "zod";
+/**
+ * Input schema for Yelay Vault deposit action.
+ */
+export declare const YelayDepositSchema: z.ZodObject<{
+    assets: z.ZodString;
+    vaultAddress: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    assets: string;
+    vaultAddress: string;
+}, {
+    assets: string;
+    vaultAddress: string;
+}>;
+/**
+ * Input schema for Yelay Vault redeem action.
+ */
+export declare const YelayRedeemSchema: z.ZodObject<{
+    assets: z.ZodString;
+    vaultAddress: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    assets: string;
+    vaultAddress: string;
+}, {
+    assets: string;
+    vaultAddress: string;
+}>;
+/**
+ * Input schema for Yelay Vault claim action.
+ */
+export declare const YelayClaimSchema: z.ZodObject<{
+    vaultAddress: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    vaultAddress: string;
+}, {
+    vaultAddress: string;
+}>;
+/**
+ * Input schema for Yelay Vault balance action.
+ */
+export declare const YelayBalanceSchema: z.ZodObject<{
+    vaultAddress: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    vaultAddress: string;
+}, {
+    vaultAddress: string;
+}>;

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YelayBalanceSchema = exports.YelayClaimSchema = exports.YelayRedeemSchema = exports.YelayDepositSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for Yelay Vault deposit action.
+ */
+exports.YelayDepositSchema = zod_1.z
+    .object({
+    assets: zod_1.z
+        .string()
+        .regex(/^\d+(\.\d+)?$/, "Must be a valid integer or decimal value")
+        .describe("The quantity of assets to deposit"),
+    vaultAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The vault address which will receive the shares"),
+})
+    .describe("Input schema for Yelay Vault deposit action");
+/**
+ * Input schema for Yelay Vault redeem action.
+ */
+exports.YelayRedeemSchema = zod_1.z
+    .object({
+    assets: zod_1.z
+        .string()
+        .regex(/^\d+(\.\d+)?$/, "Must be a valid integer or decimal value")
+        .describe("The amount of assets to redeem"),
+    vaultAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The vault address from which will redeem the shares"),
+})
+    .strip()
+    .describe("Input schema for Yelay Vault redeem action");
+/**
+ * Input schema for Yelay Vault claim action.
+ */
+exports.YelayClaimSchema = zod_1.z
+    .object({
+    vaultAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The vault address from which will claim yield"),
+})
+    .strip()
+    .describe("Input schema for Yelay Vault claim action");
+/**
+ * Input schema for Yelay Vault balance action.
+ */
+exports.YelayBalanceSchema = zod_1.z
+    .object({
+    vaultAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The vault address where deposit was made"),
+})
+    .strip()
+    .describe("Input schema for Yelay Vault balance action");

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

@@ -0,0 +1,24 @@
+export type VaultsDetailsResponse = {
+    address: `0x${string}`;
+    name: string;
+    underlying: `0x${string}`;
+    decimals: number;
+    chainId: ChainId;
+};
+export type APYResponse = {
+    vault: `0x${string}`;
+    startBlock: number;
+    finishBlock: number;
+    startTimestamp: number;
+    finishTimestamp: number;
+    yield: string;
+    apy: string;
+};
+export type ClaimRequest = {
+    yelayLiteVault: `0x${string}`;
+    projectId: number;
+    cycle: number;
+    yieldSharesTotal: string;
+    proof: string[];
+};
+export type ChainId = "1" | "146" | "8453" | "42161" | "43114";

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

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

package/dist/action-providers/yelay/yelayActionProvider.d.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { EvmWalletProvider } from "../../wallet-providers";
+import { YelayClaimSchema, YelayDepositSchema, YelayRedeemSchema, YelayBalanceSchema } from "./schemas";
+/**
+ * YelayActionProvider provides actions for yelay operations.
+ *
+ * @description
+ * This provider is designed to work with EvmWalletProvider for blockchain interactions.
+ * It supports all evm networks.
+ */
+export declare class YelayActionProvider extends ActionProvider<EvmWalletProvider> {
+    /**
+     * Constructor for the YelayActionProvider.
+     */
+    constructor();
+    /**
+     * Gets the details of the Yelay vaults with their last week APY.
+     *
+     * @param wallet - The wallet instance to get chainId
+     * @returns A formatted string containing the list of vaults with their APY.
+     */
+    getVaults(wallet: EvmWalletProvider): Promise<string>;
+    /**
+     * Deposits assets into a Yelay Vault
+     *
+     * @param wallet - The wallet instance to execute the transaction
+     * @param args - The input arguments for the action
+     * @returns A success message with transaction details or an error message
+     */
+    deposit(wallet: EvmWalletProvider, args: z.infer<typeof YelayDepositSchema>): Promise<string>;
+    /**
+     * Redeems assets from a Yelay Vault
+     *
+     * @param wallet - The wallet instance to execute the transaction
+     * @param args - The input arguments for the action
+     * @returns A success message with transaction details or an error message
+     */
+    redeem(wallet: EvmWalletProvider, args: z.infer<typeof YelayRedeemSchema>): Promise<string>;
+    /**
+     * Claims yield from Yelay
+     *
+     * @param wallet - The wallet instance to execute the transaction
+     * @param args - The input arguments for the action
+     * @returns A success message with transaction details or an error message
+     */
+    claim(wallet: EvmWalletProvider, args: z.infer<typeof YelayClaimSchema>): Promise<string>;
+    /**
+     * Gets user balance from Yelay
+     *
+     * @param wallet - The wallet instance to execute the transaction
+     * @param args - The input arguments for the action
+     * @returns A success message with user postion, generated and claimedyield
+     */
+    getBalance(wallet: EvmWalletProvider, args: z.infer<typeof YelayBalanceSchema>): 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;
+}
+/**
+ * Creates a new YelayActionProvider instance
+ *
+ * @returns A new YelayActionProvider instance
+ */
+export declare const yelayActionProvider: () => YelayActionProvider;