@coinbase/agentkit 0.3.0 → 0.5.0

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>
@@ -192,6 +205,23 @@ const agent = createReactAgent({
 </table>
 </details>
 <details>
+<summary><strong>DefiLlama</strong></summary>
+<table width="100%">
+<tr>
+    <td width="200"><code>find_protocol</code></td>
+    <td width="768">Searches for DeFi protocols on DefiLlama by name, returning protocol metadata including TVL, chain, and category.</td>
+</tr>
+<tr>
+    <td width="200"><code>get_protocol</code></td>
+    <td width="768">Fetches detailed information about a specific protocol from DefiLlama, including TVL, description, and historical data.</td>
+</tr>
+<tr>
+    <td width="200"><code>get_token_prices</code></td>
+    <td width="768">Fetches current token prices from DefiLlama for specified token addresses with chain prefixes.</td>
+</tr>
+</table>
+</details>
+<details>
 <summary><strong>ERC20</strong></summary>
 <table width="100%">
 <tr>
@@ -235,6 +265,15 @@ const agent = createReactAgent({
 </table>
 </details>
 <details>
+<summary><strong>Messari</strong></summary>
+<table width="100%">
+<tr>
+    <td width="200"><code>research_question</code></td>
+    <td width="768">Queries Messari AI for comprehensive crypto research across news, market data, protocol information, and more.</td>
+</tr>
+</table>
+</details>
+<details>
 <summary><strong>Morpho</strong></summary>
 <table width="100%">
 <tr>
@@ -607,24 +646,61 @@ const walletProvider = new ViemWalletProvider(client, {
 
 ### PrivyWalletProvider
 
-The `PrivyWalletProvider` is a wallet provider that uses [Privy Server Wallets](https://docs.privy.io/guide/server-wallets/). This implementation extends the `ViemWalletProvider`.
+The `PrivyWalletProvider` is a wallet provider that uses [Privy Server Wallets](https://docs.privy.io/guide/server-wallets/) or [Privy Embedded Wallets](https://docs.privy.io/guide/embedded-wallets/). This implementation extends the `EvmWalletProvider`.
+
+#### Server Wallet Configuration
 
 ```typescript
-import { PrivyWalletProvider, PrivyWalletConfig } from "@coinbase/agentkit";
+import { PrivyWalletProvider } from "@coinbase/agentkit";
 
-// Configure Wallet Provider
-const config: PrivyWalletConfig = {
+// Configure Server Wallet Provider
+const config = {
     appId: "PRIVY_APP_ID",
     appSecret: "PRIVY_APP_SECRET",
     chainId: "84532", // base-sepolia
     walletId: "PRIVY_WALLET_ID", // optional, otherwise a new wallet will be created
-    authorizationPrivateKey: PRIVY_WALLET_AUTHORIZATION_PRIVATE_KEY, // optional, required if your account is using authorization keys
-    authorizationKeyId: PRIVY_WALLET_AUTHORIZATION_KEY_ID, // optional, only required to create a new wallet if walletId is not provided
+    authorizationPrivateKey: "PRIVY_WALLET_AUTHORIZATION_PRIVATE_KEY", // optional, required if your account is using authorization keys
+    authorizationKeyId: "PRIVY_WALLET_AUTHORIZATION_KEY_ID", // optional, only required to create a new wallet if walletId is not provided
+};
+
+const walletProvider = await PrivyWalletProvider.configureWithWallet(config);
+```
+
+#### Delegated Embedded Wallet Configuration
+
+You can also use Privy's embedded wallets with delegation for agent actions. This allows your agent to use wallets that have been delegated transaction signing authority by users.
+
+```typescript
+import { PrivyWalletProvider } from "@coinbase/agentkit";
+
+// Configure Embedded Wallet Provider
+const config = {
+    appId: "PRIVY_APP_ID",
+    appSecret: "PRIVY_APP_SECRET",
+    authorizationPrivateKey: "PRIVY_WALLET_AUTHORIZATION_PRIVATE_KEY",
+    walletId: "PRIVY_DELEGATED_WALLET_ID", // The ID of the wallet that was delegated to your server
+    networkId: "base-mainnet", // or any supported network
+    walletType: "embedded" // Specify "embedded" to use the embedded wallet provider
 };
 
 const walletProvider = await PrivyWalletProvider.configureWithWallet(config);
 ```
 
+### Prerequisites
+
+Before using this wallet provider, you need to:
+
+1. Set up Privy in your application
+2. Enable server delegated actions
+3. Have users delegate permissions to your server
+4. Obtain the delegated wallet ID
+
+For more information on setting up Privy and enabling delegated actions, see [Privy's documentation](https://docs.privy.io/guide/embedded/server-delegated-actions).
+
+### Supported Operations
+
+The `PrivyEvmDelegatedEmbeddedWalletProvider` supports all standard wallet operations including transaction signing, message signing, and native transfers, using the wallet that was delegated to your server.
+
 #### Authorization Keys
 
 Privy offers the option to use authorization keys to secure your server wallets.
@@ -640,12 +716,19 @@ The `PrivyWalletProvider` can export wallet information by calling the `exportWa
 ```typescript
 const walletData = await walletProvider.exportWallet();
 
-// walletData will be in the following format:
+// For server wallets, walletData will be in the following format:
 {
     walletId: string;
     authorizationKey: string | undefined;
     chainId: string | undefined;
 }
+
+// For embedded wallets, walletData will be in the following format:
+{
+    walletId: string;
+    networkId: string;
+    chainId: string | undefined;
+}
 ```
 
 ### SmartWalletProvider

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