@coinbase/agentkit 0.0.0-nightly-20250328174338

package/dist/action-providers/defillama/utils.test.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+describe("DefiLlama Utilities", () => {
+    describe("pruneGetProtocolResponse", () => {
+        it("should handle null input", () => {
+            expect((0, utils_1.pruneGetProtocolResponse)(null)).toBeNull();
+        });
+        it("should not modify objects without time-series data", () => {
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                symbol: "ABC",
+            };
+            const result = (0, utils_1.pruneGetProtocolResponse)(input);
+            expect(result).not.toBeNull();
+            expect(result).toEqual(input);
+        });
+        it("should prune time-series arrays", () => {
+            const timeSeriesData = Array.from({ length: 20 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                totalLiquidityUSD: 1000 + i,
+            }));
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                tvl: [...timeSeriesData],
+            };
+            const result = (0, utils_1.pruneGetProtocolResponse)(input, 5);
+            expect(result).not.toBeNull();
+            if (result) {
+                expect(result.name).toBe("Protocol");
+                expect(result.tvl).toHaveLength(5);
+                const resultDates = result.tvl.map(entry => entry.date);
+                const sortedDates = [...resultDates].sort((a, b) => b - a);
+                expect(resultDates).toEqual(sortedDates);
+            }
+        });
+        it("should prune nested time-series arrays in chainTvls", () => {
+            const timeSeriesData = Array.from({ length: 20 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                totalLiquidityUSD: 1000 + i,
+            }));
+            const tokenTimeSeriesData = Array.from({ length: 20 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                tokens: { ETH: 1000 + i },
+            }));
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                chainTvls: {
+                    Ethereum: {
+                        tvl: [...timeSeriesData],
+                        tokens: [...tokenTimeSeriesData],
+                    },
+                    Polygon: {
+                        tvl: [...timeSeriesData],
+                        tokensInUsd: [...tokenTimeSeriesData],
+                    },
+                },
+            };
+            const result = (0, utils_1.pruneGetProtocolResponse)(input, 3);
+            expect(result).not.toBeNull();
+            if (result) {
+                expect(result.name).toBe("Protocol");
+                expect(result.chainTvls).toBeDefined();
+                if (result.chainTvls) {
+                    expect(result.chainTvls.Ethereum.tvl).toHaveLength(3);
+                    expect(result.chainTvls.Ethereum.tokens).toHaveLength(3);
+                    expect(result.chainTvls.Polygon.tvl).toHaveLength(3);
+                    expect(result.chainTvls.Polygon.tokensInUsd).toHaveLength(3);
+                    const ethereumTvlDates = result.chainTvls.Ethereum.tvl.map(entry => entry.date);
+                    const sortedDates = [...ethereumTvlDates].sort((a, b) => b - a);
+                    expect(ethereumTvlDates).toEqual(sortedDates);
+                }
+            }
+        });
+        it("should respect the maxEntries parameter", () => {
+            const timeSeriesData = Array.from({ length: 50 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                totalLiquidityUSD: 1000 + i,
+            }));
+            const tokenTimeSeriesData = Array.from({ length: 50 }, (_, i) => ({
+                date: Date.now() - i * 86400000,
+                tokens: { ETH: 1000 + i },
+            }));
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                tvl: [...timeSeriesData],
+                tokens: [...tokenTimeSeriesData],
+            };
+            const result1 = (0, utils_1.pruneGetProtocolResponse)(input, 1);
+            expect(result1).not.toBeNull();
+            if (result1) {
+                expect(result1.tvl).toHaveLength(1);
+                expect(result1.tokens).toHaveLength(1);
+            }
+            const result10 = (0, utils_1.pruneGetProtocolResponse)(input, 10);
+            expect(result10).not.toBeNull();
+            if (result10) {
+                expect(result10.tvl).toHaveLength(10);
+                expect(result10.tokens).toHaveLength(10);
+            }
+        });
+        it("should handle arrays without date property", () => {
+            const nonDateArray = Array.from({ length: 20 }, (_, i) => ({
+                value: 1000 + i,
+                name: `Item ${i}`,
+            }));
+            // Using a type assertion for this test case as it's testing a specific behavior
+            const input = {
+                id: "test-protocol",
+                name: "Protocol",
+                tvl: [...nonDateArray],
+            };
+            const result = (0, utils_1.pruneGetProtocolResponse)(input, 5);
+            expect(result).not.toBeNull();
+            if (result) {
+                expect(result.tvl).toHaveLength(5);
+            }
+        });
+    });
+});

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

@@ -0,0 +1,137 @@
+export declare const abi: readonly [{
+    readonly type: "event";
+    readonly name: "Approval";
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "Transfer";
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "allowance";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "spender";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "approve";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "balanceOf";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "decimals";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint8";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "name";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "symbol";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "totalSupply";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "transfer";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "recipient";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "transferFrom";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "sender";
+        readonly type: "address";
+    }, {
+        readonly name: "recipient";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly outputs: 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

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSepoliaTokenToAssetId = exports.BaseTokenToAssetId = exports.abi = void 0;
+const coinbase_sdk_1 = require("@coinbase/coinbase-sdk");
+exports.abi = [
+    {
+        type: "event",
+        name: "Approval",
+        inputs: [
+            {
+                indexed: true,
+                name: "owner",
+                type: "address",
+            },
+            {
+                indexed: true,
+                name: "spender",
+                type: "address",
+            },
+            {
+                indexed: false,
+                name: "value",
+                type: "uint256",
+            },
+        ],
+    },
+    {
+        type: "event",
+        name: "Transfer",
+        inputs: [
+            {
+                indexed: true,
+                name: "from",
+                type: "address",
+            },
+            {
+                indexed: true,
+                name: "to",
+                type: "address",
+            },
+            {
+                indexed: false,
+                name: "value",
+                type: "uint256",
+            },
+        ],
+    },
+    {
+        type: "function",
+        name: "allowance",
+        stateMutability: "view",
+        inputs: [
+            {
+                name: "owner",
+                type: "address",
+            },
+            {
+                name: "spender",
+                type: "address",
+            },
+        ],
+        outputs: [
+            {
+                type: "uint256",
+            },
+        ],
+    },
+    {
+        type: "function",
+        name: "approve",
+        stateMutability: "nonpayable",
+        inputs: [
+            {
+                name: "spender",
+                type: "address",
+            },
+            {
+                name: "amount",
+                type: "uint256",
+            },
+        ],
+        outputs: [
+            {
+                type: "bool",
+            },
+        ],
+    },
+    {
+        type: "function",
+        name: "balanceOf",
+        stateMutability: "view",
+        inputs: [
+            {
+                name: "account",
+                type: "address",
+            },
+        ],
+        outputs: [
+            {
+                type: "uint256",
+            },
+        ],
+    },
+    {
+        type: "function",
+        name: "decimals",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [
+            {
+                type: "uint8",
+            },
+        ],
+    },
+    {
+        type: "function",
+        name: "name",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [
+            {
+                type: "string",
+            },
+        ],
+    },
+    {
+        type: "function",
+        name: "symbol",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [
+            {
+                type: "string",
+            },
+        ],
+    },
+    {
+        type: "function",
+        name: "totalSupply",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [
+            {
+                type: "uint256",
+            },
+        ],
+    },
+    {
+        type: "function",
+        name: "transfer",
+        stateMutability: "nonpayable",
+        inputs: [
+            {
+                name: "recipient",
+                type: "address",
+            },
+            {
+                name: "amount",
+                type: "uint256",
+            },
+        ],
+        outputs: [
+            {
+                type: "bool",
+            },
+        ],
+    },
+    {
+        type: "function",
+        name: "transferFrom",
+        stateMutability: "nonpayable",
+        inputs: [
+            {
+                name: "sender",
+                type: "address",
+            },
+            {
+                name: "recipient",
+                type: "address",
+            },
+            {
+                name: "amount",
+                type: "uint256",
+            },
+        ],
+        outputs: [
+            {
+                type: "bool",
+            },
+        ],
+    },
+];
+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.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { GetBalanceSchema, TransferSchema } from "./schemas";
+import { EvmWalletProvider } from "../../wallet-providers";
+/**
+ * ERC20ActionProvider is an action provider for ERC20 tokens.
+ */
+export declare class ERC20ActionProvider extends ActionProvider<EvmWalletProvider> {
+    /**
+     * Constructor for the ERC20ActionProvider.
+     */
+    constructor();
+    /**
+     * Gets the balance of an ERC20 token.
+     *
+     * @param walletProvider - The wallet provider to get the balance from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the balance.
+     */
+    getBalance(walletProvider: EvmWalletProvider, args: z.infer<typeof GetBalanceSchema>): Promise<string>;
+    /**
+     * Transfers a specified amount of an ERC20 token to a destination onchain.
+     *
+     * @param walletProvider - The wallet provider to transfer the asset from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the transfer details.
+     */
+    transfer(walletProvider: EvmWalletProvider, args: z.infer<typeof TransferSchema>): Promise<string>;
+    /**
+     * Checks if the ERC20 action provider supports the given network.
+     *
+     * @param network - The network to check.
+     * @returns True if the ERC20 action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+export declare const erc20ActionProvider: () => ERC20ActionProvider;

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

@@ -0,0 +1,142 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.erc20ActionProvider = exports.ERC20ActionProvider = void 0;
+const zod_1 = require("zod");
+const actionProvider_1 = require("../actionProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const schemas_1 = require("./schemas");
+const constants_1 = require("./constants");
+const viem_1 = require("viem");
+const wallet_providers_1 = require("../../wallet-providers");
+/**
+ * ERC20ActionProvider is an action provider for ERC20 tokens.
+ */
+class ERC20ActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the ERC20ActionProvider.
+     */
+    constructor() {
+        super("erc20", []);
+        /**
+         * Checks if the ERC20 action provider supports the given network.
+         *
+         * @param network - The network to check.
+         * @returns True if the ERC20 action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (network) => network.protocolFamily === "evm";
+    }
+    /**
+     * Gets the balance of an ERC20 token.
+     *
+     * @param walletProvider - The wallet provider to get the balance from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the balance.
+     */
+    async getBalance(walletProvider, args) {
+        try {
+            const balance = await walletProvider.readContract({
+                address: args.contractAddress,
+                abi: constants_1.abi,
+                functionName: "balanceOf",
+                args: [walletProvider.getAddress()],
+            });
+            const decimals = await walletProvider.readContract({
+                address: args.contractAddress,
+                abi: constants_1.abi,
+                functionName: "decimals",
+                args: [],
+            });
+            return `Balance of ${args.contractAddress} is ${(0, viem_1.formatUnits)(balance, decimals)}`;
+        }
+        catch (error) {
+            return `Error getting balance: ${error}`;
+        }
+    }
+    /**
+     * Transfers a specified amount of an ERC20 token to a destination onchain.
+     *
+     * @param walletProvider - The wallet provider to transfer the asset from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the transfer details.
+     */
+    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)({
+                    abi: constants_1.abi,
+                    functionName: "transfer",
+                    args: [args.destination, BigInt(args.amount)],
+                }),
+            });
+            await walletProvider.waitForTransactionReceipt(hash);
+            return `Transferred ${args.amount} of ${args.contractAddress} to ${args.destination}.\nTransaction hash for the transfer: ${hash}`;
+        }
+        catch (error) {
+            return `Error transferring the asset: ${error}`;
+        }
+    }
+}
+exports.ERC20ActionProvider = ERC20ActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_balance",
+        description: `
+    This tool will get the balance of an ERC20 asset in the wallet. It takes the contract address as input.
+    `,
+        schema: schemas_1.GetBalanceSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], ERC20ActionProvider.prototype, "getBalance", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "transfer",
+        description: `
+    This tool will transfer an ERC20 token from the wallet to another onchain address.
+
+It takes the following inputs:
+- amount: The amount to transfer
+- contractAddress: The contract address of the token to transfer
+- destination: Where to send the funds (can be an onchain address, ENS 'example.eth', or Basename 'example.base.eth')
+
+Important notes:
+- Ensure sufficient balance of the input asset before transferring
+- When sending native assets (e.g. 'eth' on base-mainnet), ensure there is sufficient balance for the transfer itself AND the gas cost of this transfer
+    `,
+        schema: schemas_1.TransferSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], ERC20ActionProvider.prototype, "transfer", null);
+const erc20ActionProvider = () => new ERC20ActionProvider();
+exports.erc20ActionProvider = erc20ActionProvider;

package/dist/action-providers/erc20/erc20ActionProvider.test.d.ts

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