@coinbase/agentkit 0.2.3-nightly.20250325.54 → 0.2.3-nightly.20250326.56

package/README.md

@@ -137,6 +137,19 @@ const agent = createReactAgent({
 
 ## Action Providers
 <details>
+<summary><strong>Across</strong></summary>
+<table width="100%">
+<tr>
+    <td width="200"><code>bridge_token</code></td>
+    <td width="768">Bridges tokens between supported chains using Across Protocol.</td>
+</tr>
+<tr>
+    <td width="200"><code>check_deposit_status</code></td>
+    <td width="768">Checks the status of a cross-chain bridge deposit on the Across Protocol (mainnet networks only).</td>
+</tr>
+</table>
+</details>
+<details>
 <summary><strong>Basename</strong></summary>
 <table width="100%">
 <tr>

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

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { BridgeTokenSchema, CheckDepositStatusSchema } from "./schemas";
+import { EvmWalletProvider } from "../../wallet-providers";
+/**
+ * Configuration options for the SafeWalletProvider.
+ */
+export interface AcrossActionProviderConfig {
+    /**
+     * Private key of the wallet provider
+     */
+    privateKey: string;
+}
+/**
+ * AcrossActionProvider provides actions for cross-chain bridging via Across Protocol.
+ */
+export declare class AcrossActionProvider extends ActionProvider<EvmWalletProvider> {
+    #private;
+    /**
+     * Constructor for the AcrossActionProvider.
+     *
+     * @param config - The configuration options for the AcrossActionProvider.
+     */
+    constructor(config: AcrossActionProviderConfig);
+    /**
+     * Bridges a token from one chain to another using Across Protocol.
+     *
+     * @param walletProvider - The wallet provider to use for the transaction.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the bridge details.
+     */
+    bridgeToken(walletProvider: EvmWalletProvider, args: z.infer<typeof BridgeTokenSchema>): Promise<string>;
+    /**
+     * Checks the status of a bridge deposit via Across Protocol.
+     *
+     * @param walletProvider - The wallet provider to use for the transaction.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the deposit status details.
+     */
+    checkDepositStatus(walletProvider: EvmWalletProvider, args: z.infer<typeof CheckDepositStatusSchema>): Promise<string>;
+    /**
+     * Checks if the Across action provider supports the given network.
+     *
+     * @param network - The network to check.
+     * @returns True if the Across action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+export declare const acrossActionProvider: (config: AcrossActionProviderConfig) => AcrossActionProvider;

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

@@ -0,0 +1,333 @@
+"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+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 _AcrossActionProvider_privateKey;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acrossActionProvider = exports.AcrossActionProvider = void 0;
+const zod_1 = require("zod");
+const viem_1 = require("viem");
+const actionProvider_1 = require("../actionProvider");
+const network_1 = require("../../network");
+const actionDecorator_1 = require("../actionDecorator");
+const schemas_1 = require("./schemas");
+const wallet_providers_1 = require("../../wallet-providers");
+const utils_1 = require("./utils");
+const accounts_1 = require("viem/accounts");
+const constants_1 = require("../erc20/constants");
+/**
+ * AcrossActionProvider provides actions for cross-chain bridging via Across Protocol.
+ */
+class AcrossActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the AcrossActionProvider.
+     *
+     * @param config - The configuration options for the AcrossActionProvider.
+     */
+    constructor(config) {
+        super("across", []);
+        _AcrossActionProvider_privateKey.set(this, void 0);
+        /**
+         * Checks if the Across action provider supports the given network.
+         *
+         * @param network - The network to check.
+         * @returns True if the Across action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (network) => {
+            // Across only supports EVM-compatible chains
+            return network.protocolFamily === "evm";
+        };
+        __classPrivateFieldSet(this, _AcrossActionProvider_privateKey, config.privateKey, "f");
+        const account = (0, accounts_1.privateKeyToAccount)(__classPrivateFieldGet(this, _AcrossActionProvider_privateKey, "f"));
+        if (!account)
+            throw new Error("Invalid private key");
+    }
+    /**
+     * Bridges a token from one chain to another using Across Protocol.
+     *
+     * @param walletProvider - The wallet provider to use for the transaction.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the bridge details.
+     */
+    async bridgeToken(walletProvider, args) {
+        try {
+            // Use dynamic import to get the Across SDK
+            const acrossModule = await import("@across-protocol/app-sdk");
+            const createAcrossClient = acrossModule.createAcrossClient;
+            // Get recipient address if provided, otherwise use sender
+            const address = walletProvider.getAddress();
+            const recipient = (args.recipient || address);
+            // Get origin chain
+            const originChain = (0, network_1.getChain)(walletProvider.getNetwork().chainId);
+            if (!originChain) {
+                throw new Error(`Unsupported origin chain: ${walletProvider.getNetwork()}`);
+            }
+            // Get destination chain
+            const destinationNetworkId = network_1.CHAIN_ID_TO_NETWORK_ID[Number(args.destinationChainId)];
+            const destinationChain = network_1.NETWORK_ID_TO_VIEM_CHAIN[destinationNetworkId];
+            if (!destinationChain) {
+                throw new Error(`Unsupported destination chain: ${args.destinationChainId}`);
+            }
+            // Sanity checks
+            if (originChain.id === destinationChain.id) {
+                throw new Error("Origin and destination chains cannot be the same");
+            }
+            const useTestnet = (0, utils_1.isAcrossSupportedTestnet)(originChain.id);
+            if (useTestnet !== (0, utils_1.isAcrossSupportedTestnet)(destinationChain.id)) {
+                throw new Error(`Cross-chain transfers between ${originChain.name} and ${destinationChain.name} are not supported.
+           Origin and destination chains must either be both testnets or both mainnets.`);
+            }
+            // Create wallet client
+            const account = (0, accounts_1.privateKeyToAccount)(__classPrivateFieldGet(this, _AcrossActionProvider_privateKey, "f"));
+            if (account.address !== walletProvider.getAddress()) {
+                throw new Error("Private key does not match wallet provider address");
+            }
+            const walletClient = (0, viem_1.createWalletClient)({
+                account,
+                chain: originChain,
+                transport: (0, viem_1.http)(),
+            });
+            // Create Across client
+            const acrossClient = createAcrossClient({
+                chains: [originChain, destinationChain],
+                useTestnet,
+            });
+            // Get chain details to find token information
+            const chainDetails = await acrossClient.getSupportedChains({});
+            const originChainDetails = chainDetails.find(chain => chain.chainId === originChain.id);
+            if (!originChainDetails) {
+                throw new Error(`Origin chain ${originChain.id} not supported by Across Protocol`);
+            }
+            // Find token by symbol on the origin chain
+            const inputTokens = originChainDetails.inputTokens;
+            if (!inputTokens || inputTokens.length === 0) {
+                throw new Error(`No input tokens available on chain ${originChain.id}`);
+            }
+            const tokenInfo = inputTokens.find(token => token.symbol.toUpperCase() === args.inputTokenSymbol.toUpperCase());
+            if (!tokenInfo) {
+                throw new Error(`Token ${args.inputTokenSymbol} not found on chain ${originChain.id}. Available tokens: ${inputTokens.map(t => t.symbol).join(", ")}`);
+            }
+            // Get token address and decimals to parse the amount
+            const inputToken = tokenInfo.address;
+            const decimals = tokenInfo.decimals;
+            const inputAmount = (0, viem_1.parseUnits)(args.amount, decimals);
+            // Check balance
+            const isNative = args.inputTokenSymbol.toUpperCase() === "ETH";
+            if (isNative) {
+                // Check native ETH balance
+                const ethBalance = await walletProvider.getBalance();
+                if (ethBalance < inputAmount) {
+                    throw new Error(`Insufficient balance. Requested to bridge ${(0, viem_1.formatUnits)(inputAmount, decimals)} ${args.inputTokenSymbol} but balance is only ${(0, viem_1.formatUnits)(ethBalance, decimals)} ${args.inputTokenSymbol}`);
+                }
+            }
+            else {
+                // Check ERC20 token balance
+                const tokenBalance = (await walletProvider.readContract({
+                    address: inputToken,
+                    abi: constants_1.abi,
+                    functionName: "balanceOf",
+                    args: [address],
+                }));
+                if (tokenBalance < inputAmount) {
+                    throw new Error(`Insufficient balance. Requested to bridge ${(0, viem_1.formatUnits)(inputAmount, decimals)} ${args.inputTokenSymbol} but balance is only ${(0, viem_1.formatUnits)(tokenBalance, decimals)} ${args.inputTokenSymbol}`);
+                }
+            }
+            // Get available routes
+            const routeInfo = await acrossClient.getAvailableRoutes({
+                originChainId: originChain.id,
+                destinationChainId: destinationChain.id,
+                originToken: inputToken,
+            });
+            // Select the appropriate route for native ETH or ERC20 token
+            const route = routeInfo.find(route => route.isNative === isNative);
+            if (!route) {
+                throw new Error(`No routes available from chain ${originChain.name} to chain ${destinationChain.name} for token ${args.inputTokenSymbol}`);
+            }
+            // Get quote
+            const quote = await acrossClient.getQuote({
+                route,
+                inputAmount,
+                recipient,
+            });
+            // Convert units to readable format
+            const formattedInfo = {
+                minDeposit: (0, viem_1.formatUnits)(quote.limits.minDeposit, decimals),
+                maxDeposit: (0, viem_1.formatUnits)(quote.limits.maxDeposit, decimals),
+                inputAmount: (0, viem_1.formatUnits)(quote.deposit.inputAmount, decimals),
+                outputAmount: (0, viem_1.formatUnits)(quote.deposit.outputAmount, decimals),
+            };
+            // Check if input amount is within valid deposit range
+            if (quote.deposit.inputAmount < quote.limits.minDeposit) {
+                throw new Error(`Input amount ${formattedInfo.inputAmount} ${args.inputTokenSymbol} is below the minimum deposit of ${formattedInfo.minDeposit} ${args.inputTokenSymbol}`);
+            }
+            if (quote.deposit.inputAmount > quote.limits.maxDeposit) {
+                throw new Error(`Input amount ${formattedInfo.inputAmount} ${args.inputTokenSymbol} exceeds the maximum deposit of ${formattedInfo.maxDeposit} ${args.inputTokenSymbol}`);
+            }
+            // Check if output amount is within acceptable slippage limits
+            const actualSlippagePercentage = ((Number(formattedInfo.inputAmount) - Number(formattedInfo.outputAmount)) /
+                Number(formattedInfo.inputAmount)) *
+                100;
+            if (actualSlippagePercentage > args.maxSplippage) {
+                throw new Error(`Output amount has high slippage of ${actualSlippagePercentage.toFixed(2)}%, which exceeds the maximum allowed slippage of ${args.maxSplippage}%. ` +
+                    `Input: ${formattedInfo.inputAmount} ${args.inputTokenSymbol}, Output: ${formattedInfo.outputAmount} ${args.inputTokenSymbol}`);
+            }
+            //Approve ERC20 token if needed
+            let approvalTxHash;
+            if (!isNative) {
+                approvalTxHash = await walletProvider.sendTransaction({
+                    to: inputToken,
+                    data: (0, viem_1.encodeFunctionData)({
+                        abi: constants_1.abi,
+                        functionName: "approve",
+                        args: [quote.deposit.spokePoolAddress, quote.deposit.inputAmount],
+                    }),
+                });
+                await walletProvider.waitForTransactionReceipt(approvalTxHash);
+            }
+            // Simulate the deposit transaction
+            const { request } = await acrossClient.simulateDepositTx({
+                walletClient: walletClient,
+                deposit: quote.deposit,
+            });
+            // Execute the deposit transaction
+            const transactionHash = await walletClient.writeContract(request);
+            // Wait for tx to be mined
+            const { depositId } = await acrossClient.waitForDepositTx({
+                transactionHash,
+                originChainId: originChain.id,
+            });
+            return `
+Successfully deposited tokens:
+- From: Chain ${originChain.id} (${originChain.name})
+- To: Chain ${destinationChain.id} (${destinationChain.name})
+- Token: ${args.inputTokenSymbol} (${inputToken})
+- Input Amount: ${formattedInfo.inputAmount} ${args.inputTokenSymbol}
+- Output Amount: ${formattedInfo.outputAmount} ${args.inputTokenSymbol}
+- Recipient: ${recipient}
+${!isNative ? `- Transaction Hash for approval: ${approvalTxHash}\n` : ""}
+- Transaction Hash for deposit: ${transactionHash}
+- Deposit ID: ${depositId}
+        `;
+        }
+        catch (error) {
+            return `Error with Across SDK: ${error}`;
+        }
+    }
+    /**
+     * Checks the status of a bridge deposit via Across Protocol.
+     *
+     * @param walletProvider - The wallet provider to use for the transaction.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the deposit status details.
+     */
+    async checkDepositStatus(walletProvider, args) {
+        const originChainId = Number(args.originChainId) || Number(walletProvider.getNetwork().chainId);
+        if ((0, utils_1.isAcrossSupportedTestnet)(originChainId)) {
+            throw new Error("Checking deposit status on testnets is currently not supported by the Across API");
+        }
+        try {
+            const response = await fetch(`https://app.across.to/api/deposit/status?originChainId=${originChainId}&depositId=${args.depositId}`, {
+                method: "GET",
+            });
+            if (!response.ok) {
+                throw new Error(`Across API request failed with status ${response.status}`);
+            }
+            const apiData = await response.json();
+            // Get chain names
+            const originChainName = (0, network_1.getChain)(String(apiData.originChainId))?.name || "Unknown Chain";
+            const destinationChainName = (0, network_1.getChain)(String(apiData.destinationChainId))?.name || "Unknown Chain";
+            // Create structured response
+            const structuredResponse = {
+                status: apiData.status || "unknown",
+                depositTxInfo: apiData.depositTxHash
+                    ? {
+                        txHash: apiData.depositTxHash,
+                        chainId: apiData.originChainId,
+                        chainName: originChainName,
+                    }
+                    : null,
+                fillTxInfo: apiData.fillTx
+                    ? {
+                        txHash: apiData.fillTx,
+                        chainId: apiData.destinationChainId,
+                        chainName: destinationChainName,
+                    }
+                    : null,
+                depositRefundTxInfo: apiData.depositRefundTxHash
+                    ? {
+                        txHash: apiData.depositRefundTxHash,
+                        chainId: apiData.originChainId,
+                        chainName: originChainName,
+                    }
+                    : null,
+            };
+            return JSON.stringify(structuredResponse, null, 2);
+        }
+        catch (error) {
+            return `Error checking deposit status: ${error}`;
+        }
+    }
+}
+exports.AcrossActionProvider = AcrossActionProvider;
+_AcrossActionProvider_privateKey = new WeakMap();
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "bridge_token",
+        description: `
+    This tool will bridge tokens from the current chain to another chain using the Across Protocol.
+
+    It takes the following inputs:
+    - destinationChainId: The chain ID of the destination chain (e.g. 8453 for base-mainnet)
+    - inputTokenSymbol: The symbol of the token to bridge (e.g. 'ETH', 'USDC')
+    - amount: The amount of tokens to bridge in whole units (e.g. 1.5 WETH, 10 USDC)
+    - recipient: (Optional) The recipient address on the destination chain (defaults to sender)
+    - maxSplippage: (Optional) The maximum slippage percentage (defaults to 1.5%)
+
+    Important notes:
+    - Origin chain is the currently connected chain of the wallet provider 
+    - Supports cross-chain transfers between EVM-compatible chains for both mainnets and test networks
+    - Testnet deposits are not refunded if not filled on destination chain
+    - Ensure sufficient balance of the input token before bridging
+    - Returns deposit ID that can be used to check the status of the deposit
+    `,
+        schema: schemas_1.BridgeTokenSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], AcrossActionProvider.prototype, "bridgeToken", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "check_deposit_status",
+        description: `
+    This tool will check the status of a cross-chain bridge deposit on the Across Protocol.
+    
+    It takes the following inputs:
+    - originChainId: The chain ID of the origin chain (defaults to the current chain)
+    - depositId: The ID of the deposit to check (returned by the bridge deposit transaction)
+    `,
+        schema: schemas_1.CheckDepositStatusSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], AcrossActionProvider.prototype, "checkDepositStatus", null);
+const acrossActionProvider = (config) => new AcrossActionProvider(config);
+exports.acrossActionProvider = acrossActionProvider;

package/dist/action-providers/across/acrossActionProvider.test.d.ts

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

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

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

package/package.json

@@ -2,7 +2,7 @@
   "name": "@coinbase/agentkit",
   "description": "Coinbase AgentKit core primitives",
   "repository": "https://github.com/coinbase/agentkit",
-  "version": "0.2.3-nightly.20250325.54",
+  "version": "0.2.3-nightly.20250326.56",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -40,6 +40,7 @@
     "typescript"
   ],
   "dependencies": {
+    "@across-protocol/app-sdk": "^0.2.0",
     "@alloralabs/allora-sdk": "^0.1.0",
     "@coinbase/coinbase-sdk": "^0.20.0",
     "@jup-ag/api": "^6.0.39",