@coinbase/agentkit 0.4.0 → 0.5.0

package/dist/action-providers/across/acrossActionProvider.test.js

@@ -0,0 +1,391 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const acrossActionProvider_1 = require("./acrossActionProvider");
+const viem_1 = require("viem");
+// Mock the necessary imports and modules
+jest.mock("viem", () => {
+    return {
+        ...jest.requireActual("viem"),
+        createPublicClient: jest.fn(),
+        createWalletClient: jest.fn(() => ({
+            writeContract: jest.fn().mockResolvedValue("0xdepositTxHash"),
+        })),
+        http: jest.fn(),
+        formatUnits: jest.fn().mockImplementation((value, decimals) => {
+            // Simple mock implementation just for testing
+            if (typeof value === "bigint") {
+                if (decimals === 18) {
+                    return (Number(value) / 10 ** 18).toString();
+                }
+                return value.toString();
+            }
+            return value.toString();
+        }),
+        parseUnits: jest.fn().mockImplementation((value, decimals) => {
+            if (decimals === 18) {
+                return BigInt(Number(value) * 10 ** 18);
+            }
+            return BigInt(value);
+        }),
+    };
+});
+jest.mock("viem/accounts", () => ({
+    privateKeyToAccount: jest.fn().mockReturnValue({
+        address: "0x9876543210987654321098765432109876543210",
+    }),
+}));
+// Mock the network module
+jest.mock("../../network", () => {
+    return {
+        ...jest.requireActual("../../network"),
+        NETWORK_ID_TO_VIEM_CHAIN: {
+            "ethereum-mainnet": {
+                id: 1,
+                name: "Ethereum",
+                network: "mainnet",
+            },
+            optimism: {
+                id: 10,
+                name: "Optimism",
+                network: "optimism",
+            },
+            "base-sepolia": {
+                id: 84532,
+                name: "Base Sepolia",
+                network: "base-sepolia",
+            },
+        },
+        CHAIN_ID_TO_NETWORK_ID: {
+            "1": "ethereum-mainnet",
+            "10": "optimism",
+            "84532": "base-sepolia",
+        },
+    };
+});
+// Mock the Across SDK
+const mockCreateAcrossClient = jest.fn();
+jest.mock("@across-protocol/app-sdk", () => ({
+    createAcrossClient: mockCreateAcrossClient,
+}));
+// Default implementation for the createAcrossClient mock
+const defaultClientImplementation = () => ({
+    getSupportedChains: jest.fn().mockResolvedValue([
+        {
+            chainId: 1, // Ethereum
+            name: "Ethereum",
+            network: "mainnet",
+            inputTokens: [
+                {
+                    symbol: "ETH",
+                    address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+                    decimals: 18,
+                },
+                {
+                    symbol: "USDC",
+                    address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+                    decimals: 6,
+                },
+            ],
+        },
+        {
+            chainId: 10, // Optimism
+            name: "Optimism",
+            network: "optimism",
+            inputTokens: [
+                {
+                    symbol: "ETH",
+                    address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+                    decimals: 18,
+                },
+            ],
+        },
+    ]),
+    getAvailableRoutes: jest.fn().mockResolvedValue([
+        {
+            isNative: true,
+            originToken: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+        },
+        {
+            isNative: false,
+            originToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        },
+    ]),
+    getQuote: jest.fn().mockResolvedValue({
+        deposit: {
+            inputAmount: BigInt("1000000000000000000"), // 1 ETH
+            outputAmount: BigInt("990000000000000000"), // 0.99 ETH (1% difference)
+            spokePoolAddress: "0x1234567890123456789012345678901234567890",
+        },
+        limits: {
+            minDeposit: BigInt("100000000000000000"), // 0.1 ETH
+            maxDeposit: BigInt("10000000000000000000"), // 10 ETH
+        },
+    }),
+    simulateDepositTx: jest.fn().mockResolvedValue({
+        request: {
+            address: "0x1234567890123456789012345678901234567890",
+            abi: [],
+            functionName: "deposit",
+            args: [],
+        },
+    }),
+    waitForDepositTx: jest.fn().mockResolvedValue({
+        depositId: "123456",
+    }),
+});
+// Set the default implementation
+mockCreateAcrossClient.mockImplementation(() => {
+    const client = defaultClientImplementation();
+    // Add the chains property to match what the code expects
+    return {
+        ...client,
+        chains: [
+            {
+                id: 1,
+                name: "Ethereum",
+                network: "mainnet",
+            },
+            {
+                id: 10,
+                name: "Optimism",
+                network: "optimism",
+            },
+        ],
+    };
+});
+// Mock the isTestnet function
+jest.mock("./utils", () => ({
+    isAcrossSupportedTestnet: jest.fn().mockReturnValue(false),
+}));
+describe("Across Action Provider", () => {
+    const MOCK_PRIVATE_KEY = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+    const MOCK_INPUT_TOKEN_SYMBOL = "ETH";
+    const MOCK_AMOUNT = "1.0";
+    const MOCK_DESTINATION_CHAIN_ID = "10"; // Optimism
+    const MOCK_RECIPIENT = "0x9876543210987654321098765432109876543210";
+    const MOCK_MAX_SLIPPAGE = 2.0;
+    let mockWallet;
+    let actionProvider;
+    let mockPublicClient;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Reset to default implementation
+        mockCreateAcrossClient.mockImplementation(() => {
+            const client = defaultClientImplementation();
+            // Add the chains property to match what the code expects
+            return {
+                ...client,
+                chains: [
+                    {
+                        id: 1,
+                        name: "Ethereum",
+                        network: "mainnet",
+                    },
+                    {
+                        id: 10,
+                        name: "Optimism",
+                        network: "optimism",
+                    },
+                ],
+            };
+        });
+        mockPublicClient = {
+            getBalance: jest.fn().mockResolvedValue(BigInt("2000000000000000000")), // 2 ETH
+            readContract: jest.fn().mockResolvedValue(BigInt("2000000000000000000")), // 2 ETH or 2 USDC
+            waitForTransactionReceipt: jest.fn().mockResolvedValue({}),
+        };
+        viem_1.createPublicClient.mockReturnValue(mockPublicClient);
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_RECIPIENT),
+            sendTransaction: jest.fn().mockResolvedValue("0xmocktxhash"),
+            waitForTransactionReceipt: jest.fn(),
+            getNetwork: jest.fn().mockReturnValue({
+                chainId: "1", // Ethereum mainnet
+                networkId: "ethereum-mainnet",
+                protocolFamily: "evm",
+            }),
+            getBalance: jest.fn().mockResolvedValue(BigInt("2000000000000000000")), // 2 ETH
+            readContract: jest.fn().mockResolvedValue(BigInt("2000000000000000000")), // 2 ETH/USDC
+        };
+        actionProvider = (0, acrossActionProvider_1.acrossActionProvider)({
+            privateKey: MOCK_PRIVATE_KEY,
+        });
+    });
+    describe("bridgeToken", () => {
+        it("should successfully bridge native ETH", async () => {
+            const args = {
+                inputTokenSymbol: MOCK_INPUT_TOKEN_SYMBOL,
+                amount: MOCK_AMOUNT,
+                destinationChainId: MOCK_DESTINATION_CHAIN_ID,
+                recipient: MOCK_RECIPIENT,
+                maxSplippage: MOCK_MAX_SLIPPAGE,
+            };
+            const response = await actionProvider.bridgeToken(mockWallet, args);
+            // Verify the SDK interactions and response
+            expect(response).toContain("Successfully deposited tokens");
+            expect(response).toContain(`Token: ${MOCK_INPUT_TOKEN_SYMBOL}`);
+            expect(response).toContain("Transaction Hash for deposit: 0xdepositTxHash");
+        });
+        it("should successfully bridge ERC20 tokens", async () => {
+            const args = {
+                inputTokenSymbol: "USDC",
+                amount: "100",
+                destinationChainId: MOCK_DESTINATION_CHAIN_ID,
+                recipient: MOCK_RECIPIENT,
+                maxSplippage: MOCK_MAX_SLIPPAGE,
+            };
+            // Set up mock for approval and deposit transactions
+            mockWallet.sendTransaction
+                .mockResolvedValueOnce("0xapprovalTxHash")
+                .mockResolvedValueOnce("0xdepositTxHash");
+            const response = await actionProvider.bridgeToken(mockWallet, args);
+            // Verify the SDK interactions and response
+            expect(response).toContain("Successfully deposited tokens");
+            expect(response).toContain(`Token: ${args.inputTokenSymbol}`);
+            expect(response).toContain("Transaction Hash for approval: 0xapprovalTxHash");
+            expect(response).toContain("Transaction Hash for deposit: 0xdepositTxHash");
+        });
+        it("should fail when slippage is too high", async () => {
+            // Override the default mock with high slippage for this test only
+            mockCreateAcrossClient.mockImplementationOnce(() => ({
+                getSupportedChains: jest.fn().mockResolvedValue([
+                    {
+                        chainId: 1,
+                        inputTokens: [
+                            {
+                                symbol: "ETH",
+                                address: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+                                decimals: 18,
+                            },
+                        ],
+                    },
+                ]),
+                getAvailableRoutes: jest.fn().mockResolvedValue([
+                    {
+                        isNative: true,
+                        originToken: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+                    },
+                ]),
+                getQuote: jest.fn().mockResolvedValue({
+                    deposit: {
+                        inputAmount: BigInt("1000000000000000000"), // 1 ETH
+                        outputAmount: BigInt("800000000000000000"), // 0.8 ETH (20% difference)
+                        spokePoolAddress: "0x1234567890123456789012345678901234567890",
+                    },
+                    limits: {
+                        minDeposit: BigInt("100000000000000000"),
+                        maxDeposit: BigInt("10000000000000000000"),
+                    },
+                }),
+                simulateDepositTx: jest.fn().mockResolvedValue({
+                    request: {
+                        address: "0x1234567890123456789012345678901234567890",
+                        abi: [],
+                        functionName: "deposit",
+                        args: [],
+                    },
+                }),
+                waitForDepositTx: jest.fn().mockResolvedValue({
+                    depositId: "123456",
+                }),
+            }));
+            // Set a low max slippage
+            const args = {
+                inputTokenSymbol: MOCK_INPUT_TOKEN_SYMBOL,
+                amount: MOCK_AMOUNT,
+                destinationChainId: MOCK_DESTINATION_CHAIN_ID,
+                recipient: MOCK_RECIPIENT,
+                maxSplippage: 0.5, // Only allow 0.5% slippage
+            };
+            const response = await actionProvider.bridgeToken(mockWallet, args);
+            // Verify the error response
+            expect(response).toContain("Error with Across SDK");
+            expect(response).toContain("exceeds the maximum allowed slippage of 0.5%");
+        });
+        it("should handle errors in bridging", async () => {
+            const error = new Error("Insufficient balance");
+            mockWallet.getBalance.mockRejectedValueOnce(error);
+            mockWallet.sendTransaction.mockRejectedValueOnce(error);
+            const args = {
+                inputTokenSymbol: MOCK_INPUT_TOKEN_SYMBOL,
+                amount: MOCK_AMOUNT,
+                destinationChainId: MOCK_DESTINATION_CHAIN_ID,
+                recipient: MOCK_RECIPIENT,
+                maxSplippage: MOCK_MAX_SLIPPAGE,
+            };
+            const response = await actionProvider.bridgeToken(mockWallet, args);
+            expect(response).toContain("Error with Across SDK");
+            expect(response).toContain(error.message);
+        });
+    });
+    describe("checkDepositStatus", () => {
+        beforeEach(() => {
+            global.fetch = jest.fn();
+        });
+        it("should successfully check deposit status", async () => {
+            // Mock successful API response
+            const mockApiResponse = {
+                status: "filled",
+                originChainId: 1,
+                destinationChainId: 10,
+                depositTxHash: "0xdepositTxHash",
+                fillTx: "0xfillTxHash",
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockApiResponse,
+            });
+            const args = {
+                originChainId: "1",
+                depositId: "123456",
+            };
+            const response = await actionProvider.checkDepositStatus(mockWallet, args);
+            const parsedResponse = JSON.parse(response);
+            expect(parsedResponse.status).toEqual("filled");
+            expect(parsedResponse.depositTxInfo.txHash).toEqual("0xdepositTxHash");
+            expect(parsedResponse.fillTxInfo.txHash).toEqual("0xfillTxHash");
+        });
+        it("should handle API errors", async () => {
+            // Mock API error
+            global.fetch.mockResolvedValueOnce({
+                ok: false,
+                status: 404,
+            });
+            const args = {
+                originChainId: "1",
+                depositId: "123456",
+            };
+            const response = await actionProvider.checkDepositStatus(mockWallet, args);
+            expect(response).toContain("Error checking deposit status");
+            expect(response).toContain("404");
+        });
+        it("should handle network errors", async () => {
+            // Mock network error
+            global.fetch.mockRejectedValueOnce(new Error("Network error"));
+            const args = {
+                originChainId: "1",
+                depositId: "123456",
+            };
+            const response = await actionProvider.checkDepositStatus(mockWallet, args);
+            expect(response).toContain("Error checking deposit status");
+            expect(response).toContain("Network error");
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for supported networks", () => {
+            const evmNetwork = {
+                protocolFamily: "evm",
+                networkId: "ethereum",
+                chainId: "1",
+            };
+            expect(actionProvider.supportsNetwork(evmNetwork)).toBe(true);
+        });
+        it("should return false for unsupported networks", () => {
+            const nonEvmNetwork = {
+                protocolFamily: "solana",
+                networkId: "mainnet",
+            };
+            expect(actionProvider.supportsNetwork(nonEvmNetwork)).toBe(false);
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1 @@
+export * from "./acrossActionProvider";

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

@@ -0,0 +1,17 @@
+"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("./acrossActionProvider"), exports);

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+/**
+ * Input schema for bridge token action.
+ */
+export declare const BridgeTokenSchema: z.ZodObject<{
+    destinationChainId: z.ZodString;
+    inputTokenSymbol: z.ZodDefault<z.ZodString>;
+    amount: z.ZodString;
+    recipient: z.ZodOptional<z.ZodString>;
+    maxSplippage: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    amount: string;
+    destinationChainId: string;
+    inputTokenSymbol: string;
+    maxSplippage: number;
+    recipient?: string | undefined;
+}, {
+    amount: string;
+    destinationChainId: string;
+    inputTokenSymbol?: string | undefined;
+    recipient?: string | undefined;
+    maxSplippage?: number | undefined;
+}>;
+/**
+ * Input schema for check deposit status action.
+ */
+export declare const CheckDepositStatusSchema: z.ZodObject<{
+    originChainId: z.ZodOptional<z.ZodString>;
+    depositId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    depositId: string;
+    originChainId?: string | undefined;
+}, {
+    depositId: string;
+    originChainId?: string | undefined;
+}>;

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckDepositStatusSchema = exports.BridgeTokenSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for bridge token action.
+ */
+exports.BridgeTokenSchema = zod_1.z
+    .object({
+    destinationChainId: zod_1.z
+        .string()
+        .describe("The chain ID of the destination chain (e.g. 11155111 for ethereum-sepolia)"),
+    inputTokenSymbol: zod_1.z
+        .string()
+        .describe("The symbol of the token to bridge (e.g., 'ETH', 'WETH', 'USDC')")
+        .default("ETH"),
+    amount: zod_1.z
+        .string()
+        .describe("The amount of tokens to bridge in whole units (e.g. 1.5 WETH, 10 USDC)"),
+    recipient: zod_1.z
+        .string()
+        .optional()
+        .describe("The recipient address on the destination chain (defaults to sender)"),
+    maxSplippage: zod_1.z
+        .number()
+        .optional()
+        .describe("The maximum slippage percentage (e.g. 10 for 10%)")
+        .default(1.5),
+})
+    .strip()
+    .describe("Instructions for bridging tokens across chains using Across Protocol");
+/**
+ * Input schema for check deposit status action.
+ */
+exports.CheckDepositStatusSchema = zod_1.z
+    .object({
+    originChainId: zod_1.z
+        .string()
+        .optional()
+        .describe("The chain ID of the origin chain (defaults to the current chain)"),
+    depositId: zod_1.z
+        .string()
+        .describe("The ID of the deposit to check (returned by the bridge deposit transaction)"),
+})
+    .strip()
+    .describe("Instructions for checking the status of a deposit on Across Protocol");

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

@@ -0,0 +1,7 @@
+/**
+ * Checks if a chain ID corresponds to a testnet network supported by Across
+ *
+ * @param chainId - The blockchain network chain ID
+ * @returns true if the chain ID corresponds to a testnet network supported by Across, false otherwise
+ */
+export declare function isAcrossSupportedTestnet(chainId: number): boolean;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAcrossSupportedTestnet = isAcrossSupportedTestnet;
+/**
+ * Checks if a chain ID corresponds to a testnet network supported by Across
+ *
+ * @param chainId - The blockchain network chain ID
+ * @returns true if the chain ID corresponds to a testnet network supported by Across, false otherwise
+ */
+function isAcrossSupportedTestnet(chainId) {
+    // List of testnet chain IDs
+    const testnetChainIds = [
+        11155111, // Sepolia
+        84532, // Base Sepolia
+        421614, // Arbitrum Sepolia
+        11155420, // Optimism Sepolia
+        919, // Mode Sepolia
+        80002, // Polygon Amoy
+        168587773, // Blast Sepolia
+        4202, // Lisk Sepolia
+        37111, // Lens Sepolia
+        1301, // Unichain Sepolia
+    ];
+    return testnetChainIds.includes(chainId);
+}

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

@@ -133,3 +133,5 @@ export declare const abi: readonly [{
         readonly type: "bool";
     }];
 }];
+export declare const BaseTokenToAssetId: Map<string, string>;
+export declare const BaseSepoliaTokenToAssetId: Map<string, string>;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.abi = void 0;
+exports.BaseSepoliaTokenToAssetId = exports.BaseTokenToAssetId = exports.abi = void 0;
+const coinbase_sdk_1 = require("@coinbase/coinbase-sdk");
 exports.abi = [
     {
         type: "event",
@@ -189,3 +190,13 @@ exports.abi = [
         ],
     },
 ];
+exports.BaseTokenToAssetId = new Map([
+    ["0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf", coinbase_sdk_1.Coinbase.assets.Cbbtc],
+    ["0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", coinbase_sdk_1.Coinbase.assets.Usdc],
+    ["0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42", coinbase_sdk_1.Coinbase.assets.Eurc],
+]);
+exports.BaseSepoliaTokenToAssetId = new Map([
+    ["0xcbB7C0006F23900c38EB856149F799620fcb8A4a", coinbase_sdk_1.Coinbase.assets.Cbbtc],
+    ["0x036CbD53842c5426634e7929541eC2318f3dCF7e", coinbase_sdk_1.Coinbase.assets.Usdc],
+    ["0x808456652fdb597867f38412077A9182bf77359F", coinbase_sdk_1.Coinbase.assets.Eurc],
+]);

package/dist/action-providers/erc20/erc20ActionProvider.js

@@ -70,6 +70,24 @@ class ERC20ActionProvider extends actionProvider_1.ActionProvider {
      */
     async transfer(walletProvider, args) {
         try {
+            // Check if we can do gasless transfer
+            const isCdpWallet = walletProvider.getName() === "cdp_wallet_provider";
+            const network = walletProvider.getNetwork();
+            const tokenAddress = (0, viem_1.getAddress)(args.contractAddress);
+            const canDoGasless = isCdpWallet &&
+                ((network.networkId === "base-mainnet" && constants_1.BaseTokenToAssetId.has(tokenAddress)) ||
+                    (network.networkId === "base-sepolia" && constants_1.BaseSepoliaTokenToAssetId.has(tokenAddress)));
+            if (canDoGasless) {
+                // Cast to CdpWalletProvider to access erc20Transfer
+                const cdpWallet = walletProvider;
+                const assetId = network.networkId === "base-mainnet"
+                    ? constants_1.BaseTokenToAssetId.get(tokenAddress)
+                    : constants_1.BaseSepoliaTokenToAssetId.get(tokenAddress);
+                const hash = await cdpWallet.gaslessERC20Transfer(assetId, args.destination, args.amount);
+                await walletProvider.waitForTransactionReceipt(hash);
+                return `Transferred ${args.amount} of ${args.contractAddress} to ${args.destination} using gasless transfer.\nTransaction hash: ${hash}`;
+            }
+            // Fallback to regular transfer
             const hash = await walletProvider.sendTransaction({
                 to: args.contractAddress,
                 data: (0, viem_1.encodeFunctionData)({

package/dist/action-providers/erc20/erc20ActionProvider.test.js

@@ -74,6 +74,10 @@ describe("Transfer Action", () => {
         mockWallet = {
             sendTransaction: jest.fn(),
             waitForTransactionReceipt: jest.fn(),
+            getName: jest.fn().mockReturnValue("evm_wallet_provider"),
+            getNetwork: jest.fn().mockReturnValue({
+                networkId: "base-mainnet",
+            }),
         };
         mockWallet.sendTransaction.mockResolvedValue(TRANSACTION_HASH);
         mockWallet.waitForTransactionReceipt.mockResolvedValue({});

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

@@ -1,6 +1,7 @@
 export * from "./actionDecorator";
 export * from "./actionProvider";
 export * from "./customActionProvider";
+export * from "./across";
 export * from "./alchemy";
 export * from "./basename";
 export * from "./cdp";
@@ -10,6 +11,7 @@ export * from "./erc20";
 export * from "./erc721";
 export * from "./farcaster";
 export * from "./jupiter";
+export * from "./messari";
 export * from "./pyth";
 export * from "./moonwell";
 export * from "./morpho";

package/dist/action-providers/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./actionDecorator"), exports);
 __exportStar(require("./actionProvider"), exports);
 __exportStar(require("./customActionProvider"), exports);
+__exportStar(require("./across"), exports);
 __exportStar(require("./alchemy"), exports);
 __exportStar(require("./basename"), exports);
 __exportStar(require("./cdp"), exports);
@@ -26,6 +27,7 @@ __exportStar(require("./erc20"), exports);
 __exportStar(require("./erc721"), exports);
 __exportStar(require("./farcaster"), exports);
 __exportStar(require("./jupiter"), exports);
+__exportStar(require("./messari"), exports);
 __exportStar(require("./pyth"), exports);
 __exportStar(require("./moonwell"), exports);
 __exportStar(require("./morpho"), exports);

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

@@ -0,0 +1,17 @@
+/**
+ * Base URL for the Messari API
+ */
+export declare const MESSARI_BASE_URL = "https://api.messari.io/ai/v1";
+/**
+ * Default error message when API key is missing
+ */
+export declare const API_KEY_MISSING_ERROR = "MESSARI_API_KEY is not configured.";
+/**
+ * Rate limits by subscription tier
+ */
+export declare const RATE_LIMITS: {
+    FREE: string;
+    LITE: string;
+    PRO: string;
+    ENTERPRISE: string;
+};

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RATE_LIMITS = exports.API_KEY_MISSING_ERROR = exports.MESSARI_BASE_URL = void 0;
+/**
+ * Base URL for the Messari API
+ */
+exports.MESSARI_BASE_URL = "https://api.messari.io/ai/v1";
+/**
+ * Default error message when API key is missing
+ */
+exports.API_KEY_MISSING_ERROR = "MESSARI_API_KEY is not configured.";
+/**
+ * Rate limits by subscription tier
+ */
+exports.RATE_LIMITS = {
+    FREE: "2 requests per day",
+    LITE: "10 requests per day",
+    PRO: "20 requests per day",
+    ENTERPRISE: "50 requests per day",
+};