@coinbase/agentkit 0.1.0

package/dist/action-providers/wallet/walletActionProvider.js

@@ -0,0 +1,127 @@
+"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.walletActionProvider = exports.WalletActionProvider = void 0;
+const decimal_js_1 = require("decimal.js");
+const zod_1 = require("zod");
+const actionDecorator_1 = require("../actionDecorator");
+const actionProvider_1 = require("../actionProvider");
+const wallet_providers_1 = require("../../wallet-providers");
+const schemas_1 = require("./schemas");
+/**
+ * WalletActionProvider provides actions for getting basic wallet information.
+ */
+class WalletActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the WalletActionProvider.
+     */
+    constructor() {
+        super("wallet", []);
+        /**
+         * Checks if the wallet action provider supports the given network.
+         * Since wallet actions are network-agnostic, this always returns true.
+         *
+         * @param _ - The network to check.
+         * @returns True, as wallet actions are supported on all networks.
+         */
+        this.supportsNetwork = (_) => true;
+    }
+    /**
+     * Gets the details of the connected wallet including address, network, and balance.
+     *
+     * @param walletProvider - The wallet provider to get the details from.
+     * @param _ - Empty args object (not used).
+     * @returns A formatted string containing the wallet details.
+     */
+    async getWalletDetails(walletProvider, _) {
+        try {
+            const address = walletProvider.getAddress();
+            const network = walletProvider.getNetwork();
+            const balance = await walletProvider.getBalance();
+            const name = walletProvider.getName();
+            // Convert balance from Wei to ETH using Decimal for precision
+            const ethBalance = new decimal_js_1.Decimal(balance.toString()).div(new decimal_js_1.Decimal(10).pow(18));
+            return `Wallet Details:
+- Provider: ${name}
+- Address: ${address}
+- Network: 
+  * Protocol Family: ${network.protocolFamily}
+  * Network ID: ${network.networkId || "N/A"}
+  * Chain ID: ${network.chainId || "N/A"}
+- ETH Balance: ${ethBalance.toFixed(6)} ETH
+- Native Balance: ${balance.toString()} WEI`;
+        }
+        catch (error) {
+            return `Error getting wallet details: ${error}`;
+        }
+    }
+    /**
+     * Transfers a specified amount of an asset to a destination onchain.
+     *
+     * @param walletProvider - The wallet provider to transfer from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the transfer details.
+     */
+    async nativeTransfer(walletProvider, args) {
+        try {
+            const result = await walletProvider.nativeTransfer(args.to, args.value);
+            return `Transferred ${args.value} ETH to ${args.to}.\nTransaction hash: ${result}`;
+        }
+        catch (error) {
+            return `Error transferring the asset: ${error}`;
+        }
+    }
+}
+exports.WalletActionProvider = WalletActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_wallet_details",
+        description: `
+    This tool will return the details of the connected wallet including:
+    - Wallet address
+    - Network information (protocol family, network ID, chain ID)
+    - ETH token balance
+    - Native token balance
+    - Wallet provider name
+    `,
+        schema: schemas_1.GetWalletDetailsSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.WalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], WalletActionProvider.prototype, "getWalletDetails", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "native_transfer",
+        description: `
+This tool will transfer native tokens from the wallet to another onchain address.
+
+It takes the following inputs:
+- amount: The amount to transfer in whole units e.g. 1 ETH or 0.00001 ETH
+- destination: The address to receive the funds
+
+Important notes:
+- Ensure sufficient balance of the input asset before transferring
+- Ensure there is sufficient native token balance for gas fees
+`,
+        schema: schemas_1.NativeTransferSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.WalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], WalletActionProvider.prototype, "nativeTransfer", null);
+/**
+ * Factory function to create a new WalletActionProvider instance.
+ *
+ * @returns A new WalletActionProvider instance.
+ */
+const walletActionProvider = () => new WalletActionProvider();
+exports.walletActionProvider = walletActionProvider;

package/dist/action-providers/wallet/walletActionProvider.test.d.ts

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

package/dist/action-providers/wallet/walletActionProvider.test.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const walletActionProvider_1 = require("./walletActionProvider");
+const schemas_1 = require("./schemas");
+describe("Wallet Action Provider", () => {
+    const MOCK_ADDRESS = "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83";
+    const MOCK_BALANCE = 1000000000000000000n; // 1 ETH in wei
+    const MOCK_NETWORK = {
+        protocolFamily: "evm",
+        networkId: "base-sepolia",
+        chainId: "123",
+    };
+    const MOCK_PROVIDER_NAME = "TestWallet";
+    const MOCK_TRANSACTION_HASH = "0xghijkl987654321";
+    let mockWallet;
+    const actionProvider = (0, walletActionProvider_1.walletActionProvider)();
+    beforeEach(() => {
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            getNetwork: jest.fn().mockReturnValue(MOCK_NETWORK),
+            getBalance: jest.fn().mockResolvedValue(MOCK_BALANCE),
+            getName: jest.fn().mockReturnValue(MOCK_PROVIDER_NAME),
+            nativeTransfer: jest.fn().mockResolvedValue(MOCK_TRANSACTION_HASH),
+        };
+    });
+    describe("getWalletDetails", () => {
+        it("should successfully get wallet details", async () => {
+            const response = await actionProvider.getWalletDetails(mockWallet, {});
+            expect(mockWallet.getAddress).toHaveBeenCalled();
+            expect(mockWallet.getNetwork).toHaveBeenCalled();
+            expect(mockWallet.getBalance).toHaveBeenCalled();
+            expect(mockWallet.getName).toHaveBeenCalled();
+            const expectedResponse = `Wallet Details:
+- Provider: ${MOCK_PROVIDER_NAME}
+- Address: ${MOCK_ADDRESS}
+- Network: 
+  * Protocol Family: ${MOCK_NETWORK.protocolFamily}
+  * Network ID: ${MOCK_NETWORK.networkId}
+  * Chain ID: ${MOCK_NETWORK.chainId}
+- ETH Balance: 1.000000 ETH
+- Native Balance: ${MOCK_BALANCE.toString()} WEI`;
+            expect(response).toBe(expectedResponse);
+        });
+        it("should handle missing network IDs gracefully", async () => {
+            mockWallet.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+            });
+            const response = await actionProvider.getWalletDetails(mockWallet, {});
+            expect(response).toContain("Network ID: N/A");
+            expect(response).toContain("Chain ID: N/A");
+        });
+        it("should handle errors when getting wallet details", async () => {
+            const error = new Error("Failed to get wallet details");
+            mockWallet.getBalance.mockRejectedValue(error);
+            const response = await actionProvider.getWalletDetails(mockWallet, {});
+            expect(response).toBe(`Error getting wallet details: ${error}`);
+        });
+    });
+    describe("Native Transfer", () => {
+        const MOCK_AMOUNT = "1.5"; // 1.5 ETH
+        const MOCK_DESTINATION = "0x321";
+        it("should successfully parse valid input", () => {
+            const validInput = {
+                to: MOCK_DESTINATION,
+                value: MOCK_AMOUNT,
+            };
+            const result = schemas_1.NativeTransferSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual(validInput);
+            }
+        });
+        it("should fail parsing empty input", () => {
+            const emptyInput = {};
+            const result = schemas_1.NativeTransferSchema.safeParse(emptyInput);
+            expect(result.success).toBe(false);
+        });
+        it("should successfully transfer assets", async () => {
+            const args = {
+                to: MOCK_DESTINATION,
+                value: MOCK_AMOUNT,
+            };
+            const response = await actionProvider.nativeTransfer(mockWallet, args);
+            expect(mockWallet.nativeTransfer).toHaveBeenCalledWith(MOCK_DESTINATION, MOCK_AMOUNT);
+            expect(response).toBe(`Transferred ${MOCK_AMOUNT} ETH to ${MOCK_DESTINATION}.\nTransaction hash: ${MOCK_TRANSACTION_HASH}`);
+        });
+        it("should handle transfer errors", async () => {
+            const args = {
+                to: MOCK_DESTINATION,
+                value: MOCK_AMOUNT,
+            };
+            const error = new Error("Failed to execute transfer");
+            mockWallet.nativeTransfer.mockRejectedValue(error);
+            const response = await actionProvider.nativeTransfer(mockWallet, args);
+            expect(response).toBe(`Error transferring the asset: ${error}`);
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for any network", () => {
+            const evmNetwork = { protocolFamily: "evm", networkId: "base-sepolia" };
+            const solanaNetwork = { protocolFamily: "solana", networkId: "mainnet" };
+            const bitcoinNetwork = { protocolFamily: "bitcoin", networkId: "mainnet" };
+            expect(actionProvider.supportsNetwork(evmNetwork)).toBe(true);
+            expect(actionProvider.supportsNetwork(solanaNetwork)).toBe(true);
+            expect(actionProvider.supportsNetwork(bitcoinNetwork)).toBe(true);
+        });
+    });
+    describe("action provider setup", () => {
+        it("should have the correct name", () => {
+            expect(actionProvider.name).toBe("wallet");
+        });
+        it("should have empty actionProviders array", () => {
+            expect(actionProvider.actionProviders).toEqual([]);
+        });
+    });
+});

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

@@ -0,0 +1,19 @@
+export declare const WETH_ADDRESS = "0x4200000000000000000000000000000000000006";
+export declare const WETH_ABI: readonly [{
+    readonly inputs: readonly [];
+    readonly name: "deposit";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly name: "balanceOf";
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WETH_ABI = exports.WETH_ADDRESS = void 0;
+exports.WETH_ADDRESS = "0x4200000000000000000000000000000000000006";
+exports.WETH_ABI = [
+    {
+        inputs: [],
+        name: "deposit",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                name: "account",
+                type: "address",
+            },
+        ],
+        name: "balanceOf",
+        outputs: [
+            {
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+];

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

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

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

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

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const WrapEthSchema: z.ZodObject<{
+    amountToWrap: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    amountToWrap: string;
+}, {
+    amountToWrap: string;
+}>;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrapEthSchema = void 0;
+const zod_1 = require("zod");
+exports.WrapEthSchema = zod_1.z
+    .object({
+    amountToWrap: zod_1.z.string().describe("Amount of ETH to wrap in wei"),
+})
+    .strip()
+    .describe("Instructions for wrapping ETH to WETH");

package/dist/action-providers/weth/wethActionProvider.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { WrapEthSchema } from "./schemas";
+import { EvmWalletProvider } from "../../wallet-providers";
+/**
+ * WethActionProvider is an action provider for WETH.
+ */
+export declare class WethActionProvider extends ActionProvider {
+    /**
+     * Constructor for the WethActionProvider.
+     */
+    constructor();
+    /**
+     * Wraps ETH to WETH.
+     *
+     * @param walletProvider - The wallet provider to use for the action.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the transaction hash.
+     */
+    wrapEth(walletProvider: EvmWalletProvider, args: z.infer<typeof WrapEthSchema>): Promise<string>;
+    /**
+     * Checks if the Weth action provider supports the given network.
+     *
+     * @param network - The network to check.
+     * @returns True if the Weth action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+export declare const wethActionProvider: () => WethActionProvider;

package/dist/action-providers/weth/wethActionProvider.js

@@ -0,0 +1,89 @@
+"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.wethActionProvider = exports.WethActionProvider = 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");
+/**
+ * WethActionProvider is an action provider for WETH.
+ */
+class WethActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the WethActionProvider.
+     */
+    constructor() {
+        super("weth", []);
+        /**
+         * Checks if the Weth action provider supports the given network.
+         *
+         * @param network - The network to check.
+         * @returns True if the Weth action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (network) => network.networkId === "base-mainnet" || network.networkId === "base-sepolia";
+    }
+    /**
+     * Wraps ETH to WETH.
+     *
+     * @param walletProvider - The wallet provider to use for the action.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the transaction hash.
+     */
+    async wrapEth(walletProvider, args) {
+        try {
+            const hash = await walletProvider.sendTransaction({
+                to: constants_1.WETH_ADDRESS,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.WETH_ABI,
+                    functionName: "deposit",
+                }),
+                value: BigInt(args.amountToWrap),
+            });
+            await walletProvider.waitForTransactionReceipt(hash);
+            return `Wrapped ETH with transaction hash: ${hash}`;
+        }
+        catch (error) {
+            return `Error wrapping ETH: ${error}`;
+        }
+    }
+}
+exports.WethActionProvider = WethActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "wrap_eth",
+        description: `
+    This tool can only be used to wrap ETH to WETH.
+Do not use this tool for any other purpose, or trading other assets.
+
+Inputs:
+- Amount of ETH to wrap.
+
+Important notes:
+- The amount is a string and cannot have any decimal points, since the unit of measurement is wei.
+- Make sure to use the exact amount provided, and if there's any doubt, check by getting more information before continuing with the action.
+- 1 wei = 0.000000000000000001 WETH
+- Minimum purchase amount is 100000000000000 wei (0.0000001 WETH)
+- Only supported on the following networks:
+  - Base Sepolia (ie, 'base-sepolia')
+  - Base Mainnet (ie, 'base', 'base-mainnet')
+`,
+        schema: schemas_1.WrapEthSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], WethActionProvider.prototype, "wrapEth", null);
+const wethActionProvider = () => new WethActionProvider();
+exports.wethActionProvider = wethActionProvider;

package/dist/action-providers/weth/wethActionProvider.test.d.ts

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

package/dist/action-providers/weth/wethActionProvider.test.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schemas_1 = require("./schemas");
+const viem_1 = require("viem");
+const constants_1 = require("./constants");
+const wethActionProvider_1 = require("./wethActionProvider");
+const MOCK_AMOUNT = "15";
+const MOCK_ADDRESS = "0x1234567890123456789012345678901234543210";
+describe("Wrap Eth Schema", () => {
+    it("should successfully parse valid input", () => {
+        const validInput = {
+            amountToWrap: MOCK_AMOUNT,
+        };
+        const result = schemas_1.WrapEthSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual(validInput);
+    });
+    it("should fail parsing empty input", () => {
+        const emptyInput = {};
+        const result = schemas_1.WrapEthSchema.safeParse(emptyInput);
+        expect(result.success).toBe(false);
+    });
+});
+describe("Wrap Eth Action", () => {
+    let mockWallet;
+    const actionProvider = (0, wethActionProvider_1.wethActionProvider)();
+    beforeEach(async () => {
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            sendTransaction: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+        };
+    });
+    it("should successfully respond", async () => {
+        const args = {
+            amountToWrap: MOCK_AMOUNT,
+        };
+        const hash = "0x1234567890123456789012345678901234567890";
+        mockWallet.sendTransaction.mockResolvedValue(hash);
+        const response = await actionProvider.wrapEth(mockWallet, args);
+        expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+            to: constants_1.WETH_ADDRESS,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: constants_1.WETH_ABI,
+                functionName: "deposit",
+            }),
+            value: BigInt(MOCK_AMOUNT),
+        });
+        expect(response).toContain(`Wrapped ETH with transaction hash: ${hash}`);
+    });
+    it("should fail with an error", async () => {
+        const args = {
+            amountToWrap: MOCK_AMOUNT,
+        };
+        const error = new Error("Failed to wrap ETH");
+        mockWallet.sendTransaction.mockRejectedValue(error);
+        const response = await actionProvider.wrapEth(mockWallet, args);
+        expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+            to: constants_1.WETH_ADDRESS,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: constants_1.WETH_ABI,
+                functionName: "deposit",
+            }),
+            value: BigInt(MOCK_AMOUNT),
+        });
+        expect(response).toContain(`Error wrapping ETH: ${error}`);
+    });
+});
+describe("supportsNetwork", () => {
+    const actionProvider = (0, wethActionProvider_1.wethActionProvider)();
+    it("should return true for base-mainnet", () => {
+        const result = actionProvider.supportsNetwork({
+            protocolFamily: "evm",
+            networkId: "base-mainnet",
+        });
+        expect(result).toBe(true);
+    });
+    it("should return true for base-sepolia", () => {
+        const result = actionProvider.supportsNetwork({
+            protocolFamily: "evm",
+            networkId: "base-sepolia",
+        });
+        expect(result).toBe(true);
+    });
+    it("should return false for non-base networks", () => {
+        const result = actionProvider.supportsNetwork({
+            protocolFamily: "evm",
+            networkId: "ethereum-mainnet",
+        });
+        expect(result).toBe(false);
+    });
+});

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

@@ -0,0 +1,15 @@
+import type { Abi } from "abitype";
+export declare const SUPPORTED_NETWORKS: string[];
+export declare const WOW_FACTORY_ABI: Abi;
+export declare const WOW_ABI: Abi;
+export declare const WOW_FACTORY_CONTRACT_ADDRESSES: Record<string, string>;
+export declare const ADDRESSES: Record<string, Record<string, string>>;
+export declare const GENERIC_TOKEN_METADATA_URI = "ipfs://QmY1GqprFYvojCcUEKgqHeDj9uhZD9jmYGrQTfA9vAE78J";
+/**
+ * Gets the Zora Wow ERC20 Factory contract address for the specified network.
+ *
+ * @param network - The network ID to get the contract address for
+ * @returns The contract address for the specified network
+ * @throws Error if the specified network is not supported
+ */
+export declare function getFactoryAddress(network: string): string;