@coinbase/agentkit 0.0.0-nightly-20250328174338

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

@@ -0,0 +1,131 @@
+"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_DECIMALS = 6;
+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(),
+        };
+    });
+    it("should successfully respond", async () => {
+        mockWallet.readContract.mockResolvedValueOnce(MOCK_AMOUNT);
+        mockWallet.readContract.mockResolvedValueOnce(MOCK_DECIMALS);
+        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 / 10 ** MOCK_DECIMALS}`);
+    });
+    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(),
+            getName: jest.fn().mockReturnValue("evm_wallet_provider"),
+            getNetwork: jest.fn().mockReturnValue({
+                networkId: "base-mainnet",
+            }),
+        };
+        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}`);
+    });
+    describe("supportsNetwork", () => {
+        it("should return true when protocolFamily is evm", () => {
+            expect(actionProvider.supportsNetwork({ protocolFamily: "evm" })).toBe(true);
+        });
+        it("should return false when protocolFamily is not evm", () => {
+            expect(actionProvider.supportsNetwork({ protocolFamily: "solana" })).toBe(false);
+        });
+    });
+});

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, {
+    contractAddress: string;
+    amount: bigint;
+    destination: string;
+}, {
+    contractAddress: string;
+    amount: bigint;
+    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,232 @@
+export declare const ERC721_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }];
+    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";
+}];