@coinbase/agentkit 0.1.0

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 {
+    /**
+     * 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 _ - The network to check.
+     * @returns True if the ERC20 action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (_: Network) => boolean;
+}
+export declare const erc20ActionProvider: () => ERC20ActionProvider;

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

@@ -0,0 +1,118 @@
+"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 _ - The network to check.
+         * @returns True if the ERC20 action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (_) => true;
+    }
+    /**
+     * 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()],
+            });
+            return `Balance of ${args.contractAddress} is ${balance}`;
+        }
+        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 {
+            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 {};

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

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const erc20ActionProvider_1 = require("./erc20ActionProvider");
+const schemas_1 = require("./schemas");
+const viem_1 = require("viem");
+const constants_1 = require("./constants");
+const MOCK_AMOUNT = 15;
+const MOCK_CONTRACT_ADDRESS = "0x1234567890123456789012345678901234567890";
+const MOCK_DESTINATION = "0x9876543210987654321098765432109876543210";
+const MOCK_ADDRESS = "0x1234567890123456789012345678901234567890";
+describe("Transfer Schema", () => {
+    it("should successfully parse valid input", () => {
+        const validInput = {
+            amount: MOCK_AMOUNT,
+            contractAddress: MOCK_CONTRACT_ADDRESS,
+            destination: MOCK_DESTINATION,
+        };
+        const result = schemas_1.TransferSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual(validInput);
+    });
+    it("should fail parsing empty input", () => {
+        const emptyInput = {};
+        const result = schemas_1.TransferSchema.safeParse(emptyInput);
+        expect(result.success).toBe(false);
+    });
+});
+describe("Get Balance Action", () => {
+    let mockWallet;
+    const actionProvider = (0, erc20ActionProvider_1.erc20ActionProvider)();
+    beforeEach(async () => {
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            readContract: jest.fn(),
+        };
+        mockWallet.readContract.mockResolvedValue(MOCK_AMOUNT);
+    });
+    it("should successfully respond", async () => {
+        const args = {
+            contractAddress: MOCK_CONTRACT_ADDRESS,
+        };
+        const response = await actionProvider.getBalance(mockWallet, args);
+        expect(mockWallet.readContract).toHaveBeenCalledWith({
+            address: args.contractAddress,
+            abi: constants_1.abi,
+            functionName: "balanceOf",
+            args: [mockWallet.getAddress()],
+        });
+        expect(response).toContain(`Balance of ${MOCK_CONTRACT_ADDRESS} is ${MOCK_AMOUNT}`);
+    });
+    it("should fail with an error", async () => {
+        const args = {
+            contractAddress: MOCK_CONTRACT_ADDRESS,
+        };
+        const error = new Error("Failed to get balance");
+        mockWallet.readContract.mockRejectedValue(error);
+        const response = await actionProvider.getBalance(mockWallet, args);
+        expect(mockWallet.readContract).toHaveBeenCalledWith({
+            address: args.contractAddress,
+            abi: constants_1.abi,
+            functionName: "balanceOf",
+            args: [mockWallet.getAddress()],
+        });
+        expect(response).toContain(`Error getting balance: ${error}`);
+    });
+});
+describe("Transfer Action", () => {
+    const TRANSACTION_HASH = "0xghijkl987654321";
+    let mockWallet;
+    const actionProvider = (0, erc20ActionProvider_1.erc20ActionProvider)();
+    beforeEach(async () => {
+        mockWallet = {
+            sendTransaction: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+        };
+        mockWallet.sendTransaction.mockResolvedValue(TRANSACTION_HASH);
+        mockWallet.waitForTransactionReceipt.mockResolvedValue({});
+    });
+    it("should successfully respond", async () => {
+        const args = {
+            amount: BigInt(MOCK_AMOUNT),
+            contractAddress: MOCK_CONTRACT_ADDRESS,
+            destination: MOCK_DESTINATION,
+        };
+        const response = await actionProvider.transfer(mockWallet, args);
+        expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+            to: args.contractAddress,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: constants_1.abi,
+                functionName: "transfer",
+                args: [args.destination, BigInt(args.amount)],
+            }),
+        });
+        expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledWith(TRANSACTION_HASH);
+        expect(response).toContain(`Transferred ${MOCK_AMOUNT} of ${MOCK_CONTRACT_ADDRESS} to ${MOCK_DESTINATION}`);
+        expect(response).toContain(`Transaction hash for the transfer: ${TRANSACTION_HASH}`);
+    });
+    it("should fail with an error", async () => {
+        const args = {
+            amount: BigInt(MOCK_AMOUNT),
+            contractAddress: MOCK_CONTRACT_ADDRESS,
+            destination: MOCK_DESTINATION,
+        };
+        const error = new Error("Failed to execute transfer");
+        mockWallet.sendTransaction.mockRejectedValue(error);
+        const response = await actionProvider.transfer(mockWallet, args);
+        expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+            to: args.contractAddress,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: constants_1.abi,
+                functionName: "transfer",
+                args: [args.destination, BigInt(args.amount)],
+            }),
+        });
+        expect(response).toContain(`Error transferring the asset: ${error}`);
+    });
+});

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

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

package/dist/action-providers/erc20/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("./erc20ActionProvider"), exports);

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

@@ -0,0 +1,27 @@
+import { z } from "zod";
+/**
+ * Input schema for transfer action.
+ */
+export declare const TransferSchema: z.ZodObject<{
+    amount: z.ZodType<bigint, z.ZodTypeDef, bigint>;
+    contractAddress: z.ZodString;
+    destination: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    amount: bigint;
+    contractAddress: string;
+    destination: string;
+}, {
+    amount: bigint;
+    contractAddress: string;
+    destination: string;
+}>;
+/**
+ * Input schema for get balance action.
+ */
+export declare const GetBalanceSchema: z.ZodObject<{
+    contractAddress: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    contractAddress: string;
+}, {
+    contractAddress: string;
+}>;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetBalanceSchema = exports.TransferSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for transfer action.
+ */
+exports.TransferSchema = zod_1.z
+    .object({
+    amount: zod_1.z.custom().describe("The amount of the asset to transfer"),
+    contractAddress: zod_1.z.string().describe("The contract address of the token to transfer"),
+    destination: zod_1.z.string().describe("The destination to transfer the funds"),
+})
+    .strip()
+    .describe("Instructions for transferring assets");
+/**
+ * Input schema for get balance action.
+ */
+exports.GetBalanceSchema = zod_1.z
+    .object({
+    contractAddress: zod_1.z
+        .string()
+        .describe("The contract address of the token to get the balance for"),
+})
+    .strip()
+    .describe("Instructions for getting wallet balance");

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

@@ -0,0 +1,236 @@
+export declare const ERC721_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly name: "mint";
+    readonly outputs: readonly [];
+    readonly payable: false;
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes4";
+        readonly name: "interfaceId";
+        readonly type: "bytes4";
+    }];
+    readonly name: "supportsInterface";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly name: "Transfer";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "approved";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "uint256";
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly name: "Approval";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "operator";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bool";
+        readonly name: "approved";
+        readonly type: "bool";
+    }];
+    readonly name: "ApprovalForAll";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+    readonly name: "balanceOf";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "balance";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly name: "ownerOf";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }];
+    readonly name: "safeTransferFrom";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly name: "safeTransferFrom";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly name: "transferFrom";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly name: "approve";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "operator";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bool";
+        readonly name: "approved";
+        readonly type: "bool";
+    }];
+    readonly name: "setApprovalForAll";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getApproved";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "operator";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "operator";
+        readonly type: "address";
+    }];
+    readonly name: "isApprovedForAll";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];