@coinbase/agentkit 0.0.0-nightly-20250328174338

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

@@ -0,0 +1,298 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERC721_ABI = void 0;
+exports.ERC721_ABI = [
+    {
+        inputs: [{ internalType: "address", name: "to", type: "address" }],
+        name: "mint",
+        outputs: [],
+        payable: false,
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "bytes4",
+                name: "interfaceId",
+                type: "bytes4",
+            },
+        ],
+        name: "supportsInterface",
+        outputs: [
+            {
+                internalType: "bool",
+                name: "",
+                type: "bool",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "from",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "to",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "uint256",
+                name: "tokenId",
+                type: "uint256",
+            },
+        ],
+        name: "Transfer",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "owner",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "approved",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "uint256",
+                name: "tokenId",
+                type: "uint256",
+            },
+        ],
+        name: "Approval",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "address",
+                name: "owner",
+                type: "address",
+            },
+            {
+                indexed: true,
+                internalType: "address",
+                name: "operator",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "bool",
+                name: "approved",
+                type: "bool",
+            },
+        ],
+        name: "ApprovalForAll",
+        type: "event",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "owner",
+                type: "address",
+            },
+        ],
+        name: "balanceOf",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "balance",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "uint256",
+                name: "tokenId",
+                type: "uint256",
+            },
+        ],
+        name: "ownerOf",
+        outputs: [
+            {
+                internalType: "address",
+                name: "owner",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "from",
+                type: "address",
+            },
+            {
+                internalType: "address",
+                name: "to",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "tokenId",
+                type: "uint256",
+            },
+            {
+                internalType: "bytes",
+                name: "data",
+                type: "bytes",
+            },
+        ],
+        name: "safeTransferFrom",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "from",
+                type: "address",
+            },
+            {
+                internalType: "address",
+                name: "to",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "tokenId",
+                type: "uint256",
+            },
+        ],
+        name: "safeTransferFrom",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "from",
+                type: "address",
+            },
+            {
+                internalType: "address",
+                name: "to",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "tokenId",
+                type: "uint256",
+            },
+        ],
+        name: "transferFrom",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "to",
+                type: "address",
+            },
+            {
+                internalType: "uint256",
+                name: "tokenId",
+                type: "uint256",
+            },
+        ],
+        name: "approve",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "operator",
+                type: "address",
+            },
+            {
+                internalType: "bool",
+                name: "approved",
+                type: "bool",
+            },
+        ],
+        name: "setApprovalForAll",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "uint256",
+                name: "tokenId",
+                type: "uint256",
+            },
+        ],
+        name: "getApproved",
+        outputs: [
+            {
+                internalType: "address",
+                name: "operator",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "owner",
+                type: "address",
+            },
+            {
+                internalType: "address",
+                name: "operator",
+                type: "address",
+            },
+        ],
+        name: "isApprovedForAll",
+        outputs: [
+            {
+                internalType: "bool",
+                name: "",
+                type: "bool",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+];

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

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { EvmWalletProvider } from "../../wallet-providers";
+import { GetBalanceSchema, MintSchema, TransferSchema } from "./schemas";
+import { Network } from "../../network";
+/**
+ * Erc721ActionProvider is an action provider for Erc721 contract interactions.
+ */
+export declare class Erc721ActionProvider extends ActionProvider<EvmWalletProvider> {
+    /**
+     * Constructor for the Erc721ActionProvider class.
+     */
+    constructor();
+    /**
+     * Mints an NFT (ERC-721) to a specified destination address onchain.
+     *
+     * @param walletProvider - The wallet provider to mint the NFT from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the NFT mint details.
+     */
+    mint(walletProvider: EvmWalletProvider, args: z.infer<typeof MintSchema>): Promise<string>;
+    /**
+     * Transfers an NFT (ERC721 token) to a destination address.
+     *
+     * @param walletProvider - The wallet provider to transfer the NFT 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>;
+    /**
+     * Gets the NFT balance for a given address and contract.
+     *
+     * @param walletProvider - The wallet provider to check the balance with.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the NFT balance details.
+     */
+    getBalance(walletProvider: EvmWalletProvider, args: z.infer<typeof GetBalanceSchema>): Promise<string>;
+    /**
+     * Checks if the Erc721 action provider supports the given network.
+     *
+     * @param network - The network to check.
+     * @returns True if the Erc721 action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+export declare const erc721ActionProvider: () => Erc721ActionProvider;

package/dist/action-providers/erc721/erc721ActionProvider.js

@@ -0,0 +1,164 @@
+"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.erc721ActionProvider = exports.Erc721ActionProvider = void 0;
+const zod_1 = require("zod");
+const actionProvider_1 = require("../actionProvider");
+const wallet_providers_1 = require("../../wallet-providers");
+const actionDecorator_1 = require("../actionDecorator");
+const schemas_1 = require("./schemas");
+const constants_1 = require("./constants");
+const viem_1 = require("viem");
+/**
+ * Erc721ActionProvider is an action provider for Erc721 contract interactions.
+ */
+class Erc721ActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the Erc721ActionProvider class.
+     */
+    constructor() {
+        super("erc721", []);
+        /**
+         * Checks if the Erc721 action provider supports the given network.
+         *
+         * @param network - The network to check.
+         * @returns True if the Erc721 action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (network) => network.protocolFamily === "evm";
+    }
+    /**
+     * Mints an NFT (ERC-721) to a specified destination address onchain.
+     *
+     * @param walletProvider - The wallet provider to mint the NFT from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the NFT mint details.
+     */
+    async mint(walletProvider, args) {
+        try {
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.ERC721_ABI,
+                functionName: "mint",
+                args: [args.destination],
+            });
+            const hash = await walletProvider.sendTransaction({
+                to: args.contractAddress,
+                data,
+            });
+            await walletProvider.waitForTransactionReceipt(hash);
+            return `Successfully minted NFT ${args.contractAddress} to ${args.destination}`;
+        }
+        catch (error) {
+            return `Error minting NFT ${args.contractAddress} to ${args.destination}: ${error}`;
+        }
+    }
+    /**
+     * Transfers an NFT (ERC721 token) to a destination address.
+     *
+     * @param walletProvider - The wallet provider to transfer the NFT from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the transfer details.
+     */
+    async transfer(walletProvider, args) {
+        try {
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.ERC721_ABI,
+                functionName: "transferFrom",
+                args: [args.fromAddress, args.destination, BigInt(args.tokenId)],
+            });
+            const hash = await walletProvider.sendTransaction({
+                to: args.contractAddress,
+                data,
+            });
+            await walletProvider.waitForTransactionReceipt(hash);
+            return `Successfully transferred NFT ${args.contractAddress} with tokenId ${args.tokenId} to ${args.destination}`;
+        }
+        catch (error) {
+            return `Error transferring NFT ${args.contractAddress} with tokenId ${args.tokenId} to ${args.destination}: ${error}`;
+        }
+    }
+    /**
+     * Gets the NFT balance for a given address and contract.
+     *
+     * @param walletProvider - The wallet provider to check the balance with.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the NFT balance details.
+     */
+    async getBalance(walletProvider, args) {
+        try {
+            const address = args.address || walletProvider.getAddress();
+            const balance = await walletProvider.readContract({
+                address: args.contractAddress,
+                abi: constants_1.ERC721_ABI,
+                functionName: "balanceOf",
+                args: [address],
+            });
+            return `Balance of NFTs for contract ${args.contractAddress} at address ${address} is ${balance}`;
+        }
+        catch (error) {
+            return `Error getting NFT balance for contract ${args.contractAddress}: ${error}`;
+        }
+    }
+}
+exports.Erc721ActionProvider = Erc721ActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "mint",
+        description: `
+This tool will mint an NFT (ERC-721) to a specified destination address onchain via a contract invocation. 
+It takes the contract address of the NFT onchain and the destination address onchain that will receive the NFT as inputs. 
+Do not use the contract address as the destination address. If you are unsure of the destination address, please ask the user before proceeding.
+`,
+        schema: schemas_1.MintSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], Erc721ActionProvider.prototype, "mint", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "transfer",
+        description: `
+This tool will transfer an NFT (ERC721 token) from the wallet to another onchain address.
+
+It takes the following inputs:
+- contractAddress: The NFT contract address
+- tokenId: The ID of the specific NFT to transfer
+- destination: Onchain address to send the NFT
+
+Important notes:
+- Ensure you have ownership of the NFT before attempting transfer
+- Ensure there is sufficient native token balance for gas fees
+- The wallet must either own the NFT or have approval to transfer it
+`,
+        schema: schemas_1.TransferSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], Erc721ActionProvider.prototype, "transfer", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_balance",
+        description: `
+This tool will check the NFT (ERC721 token) balance for a given address.
+
+It takes the following inputs:
+- contractAddress: The NFT contract address to check balance for
+- address: (Optional) The address to check NFT balance for. If not provided, uses the wallet's address
+`,
+        schema: schemas_1.GetBalanceSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], Erc721ActionProvider.prototype, "getBalance", null);
+const erc721ActionProvider = () => new Erc721ActionProvider();
+exports.erc721ActionProvider = erc721ActionProvider;

package/dist/action-providers/erc721/erc721ActionProvider.test.d.ts

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

package/dist/action-providers/erc721/erc721ActionProvider.test.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const erc721ActionProvider_1 = require("./erc721ActionProvider");
+const constants_1 = require("./constants");
+describe("ERC721 Action Provider", () => {
+    const MOCK_ADDRESS = "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83";
+    const MOCK_CONTRACT = "0x1234567890123456789012345678901234567890";
+    const MOCK_DESTINATION = "0x9876543210987654321098765432109876543210";
+    const MOCK_TOKEN_ID = "123";
+    let mockWallet;
+    const actionProvider = (0, erc721ActionProvider_1.erc721ActionProvider)();
+    beforeEach(() => {
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            getNetwork: jest.fn().mockReturnValue({ protocolFamily: "evm" }),
+            sendTransaction: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+            readContract: jest.fn(),
+            call: jest.fn(),
+        };
+        mockWallet.sendTransaction.mockResolvedValue("0xmockhash");
+        mockWallet.waitForTransactionReceipt.mockResolvedValue({});
+    });
+    describe("mint", () => {
+        it("should successfully mint an NFT", async () => {
+            const args = {
+                contractAddress: MOCK_CONTRACT,
+                destination: MOCK_DESTINATION,
+            };
+            const response = await actionProvider.mint(mockWallet, args);
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: MOCK_CONTRACT,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.ERC721_ABI,
+                    functionName: "mint",
+                    args: [MOCK_DESTINATION],
+                }),
+            });
+            expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledWith("0xmockhash");
+            expect(response).toBe(`Successfully minted NFT ${MOCK_CONTRACT} to ${MOCK_DESTINATION}`);
+        });
+        it("should handle mint errors", async () => {
+            const error = new Error("Mint failed");
+            mockWallet.sendTransaction.mockRejectedValue(error);
+            const args = {
+                contractAddress: MOCK_CONTRACT,
+                destination: MOCK_DESTINATION,
+            };
+            const response = await actionProvider.mint(mockWallet, args);
+            expect(response).toBe(`Error minting NFT ${MOCK_CONTRACT} to ${MOCK_DESTINATION}: ${error}`);
+        });
+    });
+    describe("transfer", () => {
+        it("should successfully transfer an NFT", async () => {
+            const args = {
+                contractAddress: MOCK_CONTRACT,
+                destination: MOCK_DESTINATION,
+                tokenId: MOCK_TOKEN_ID,
+                fromAddress: MOCK_ADDRESS,
+            };
+            const response = await actionProvider.transfer(mockWallet, args);
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: MOCK_CONTRACT,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.ERC721_ABI,
+                    functionName: "transferFrom",
+                    args: [MOCK_ADDRESS, MOCK_DESTINATION, BigInt(MOCK_TOKEN_ID)],
+                }),
+            });
+            expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledWith("0xmockhash");
+            expect(response).toBe(`Successfully transferred NFT ${MOCK_CONTRACT} with tokenId ${MOCK_TOKEN_ID} to ${MOCK_DESTINATION}`);
+        });
+        it("should handle transfer errors", async () => {
+            const error = new Error("Transfer failed");
+            mockWallet.sendTransaction.mockRejectedValue(error);
+            const args = {
+                contractAddress: MOCK_CONTRACT,
+                destination: MOCK_DESTINATION,
+                tokenId: MOCK_TOKEN_ID,
+                fromAddress: MOCK_ADDRESS,
+            };
+            const response = await actionProvider.transfer(mockWallet, args);
+            expect(response).toBe(`Error transferring NFT ${MOCK_CONTRACT} with tokenId ${MOCK_TOKEN_ID} to ${MOCK_DESTINATION}: ${error}`);
+        });
+    });
+    describe("getBalance", () => {
+        const MOCK_BALANCE = 1;
+        beforeEach(() => {
+            mockWallet.readContract.mockResolvedValue(MOCK_BALANCE);
+            mockWallet.getAddress.mockReturnValue(MOCK_ADDRESS);
+        });
+        it("should successfully get the NFT balance", async () => {
+            const args = {
+                contractAddress: MOCK_CONTRACT,
+                address: MOCK_ADDRESS,
+            };
+            const response = await actionProvider.getBalance(mockWallet, args);
+            expect(mockWallet.readContract).toHaveBeenCalledWith({
+                address: MOCK_CONTRACT,
+                abi: constants_1.ERC721_ABI,
+                functionName: "balanceOf",
+                args: [MOCK_ADDRESS],
+            });
+            expect(response).toBe(`Balance of NFTs for contract ${MOCK_CONTRACT} at address ${MOCK_ADDRESS} is 1`);
+        });
+        it("should handle get balance errors", async () => {
+            const error = new Error("Get balance failed");
+            mockWallet.readContract.mockRejectedValue(error);
+            const args = {
+                contractAddress: MOCK_CONTRACT,
+                address: MOCK_ADDRESS,
+            };
+            const response = await actionProvider.getBalance(mockWallet, args);
+            expect(mockWallet.readContract).toHaveBeenCalledWith({
+                address: MOCK_CONTRACT,
+                abi: constants_1.ERC721_ABI,
+                functionName: "balanceOf",
+                args: [MOCK_ADDRESS],
+            });
+            expect(response).toBe(`Error getting NFT balance for contract ${MOCK_CONTRACT}: ${error}`);
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for EVM networks", () => {
+            const result = actionProvider.supportsNetwork({ protocolFamily: "evm", networkId: "any" });
+            expect(result).toBe(true);
+        });
+        it("should return false for non-EVM networks", () => {
+            const result = actionProvider.supportsNetwork({
+                protocolFamily: "bitcoin",
+                networkId: "any",
+            });
+            expect(result).toBe(false);
+        });
+    });
+});

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

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

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