@coinbase/agentkit 0.1.0

package/dist/action-providers/cdp/cdpApiActionProvider.test.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdpApiActionProvider_1 = require("./cdpApiActionProvider");
+const schemas_1 = require("./schemas");
+// Mock the entire module
+jest.mock("@coinbase/coinbase-sdk");
+// Get the mocked constructor
+const { ExternalAddress } = jest.requireMock("@coinbase/coinbase-sdk");
+describe("CDP API Action Provider Input Schemas", () => {
+    describe("Address Reputation Schema", () => {
+        it("should successfully parse valid input", () => {
+            const validInput = {
+                address: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                network: "base-mainnet",
+            };
+            const result = schemas_1.AddressReputationSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
+        });
+        it("should fail parsing invalid address", () => {
+            const invalidInput = {
+                address: "invalid-address",
+                network: "base-mainnet",
+            };
+            const result = schemas_1.AddressReputationSchema.safeParse(invalidInput);
+            expect(result.success).toBe(false);
+        });
+    });
+    describe("Request Faucet Funds Schema", () => {
+        it("should successfully parse with optional assetId", () => {
+            const validInput = {
+                assetId: "eth",
+            };
+            const result = schemas_1.RequestFaucetFundsSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
+        });
+        it("should successfully parse without assetId", () => {
+            const validInput = {};
+            const result = schemas_1.RequestFaucetFundsSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
+        });
+    });
+});
+describe("CDP API Action Provider", () => {
+    let actionProvider;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let mockExternalAddressInstance;
+    let mockWallet;
+    beforeEach(() => {
+        // Reset all mocks before each test
+        jest.clearAllMocks();
+        actionProvider = new cdpApiActionProvider_1.CdpApiActionProvider();
+        mockExternalAddressInstance = {
+            reputation: jest.fn(),
+            faucet: jest.fn(),
+        };
+        // Mock the constructor to return our mock instance
+        ExternalAddress.mockImplementation(() => mockExternalAddressInstance);
+        mockWallet = {
+            deployToken: jest.fn(),
+            deployContract: jest.fn(),
+            getAddress: jest.fn().mockReturnValue("0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83"),
+            getNetwork: jest.fn().mockReturnValue({ networkId: "base-sepolia" }),
+        };
+    });
+    describe("addressReputation", () => {
+        it("should successfully check address reputation", async () => {
+            const args = {
+                address: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                network: "base-mainnet",
+            };
+            mockExternalAddressInstance.reputation.mockResolvedValue("Good reputation");
+            const result = await actionProvider.addressReputation(args);
+            expect(ExternalAddress).toHaveBeenCalledWith(args.network, args.address);
+            expect(ExternalAddress).toHaveBeenCalledTimes(1);
+            expect(mockExternalAddressInstance.reputation).toHaveBeenCalled();
+            expect(mockExternalAddressInstance.reputation).toHaveBeenCalledTimes(1);
+            expect(result).toBe("Good reputation");
+        });
+        it("should handle errors when checking reputation", async () => {
+            const args = {
+                address: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                network: "base-mainnet",
+            };
+            const error = new Error("Reputation check failed");
+            mockExternalAddressInstance.reputation.mockRejectedValue(error);
+            const result = await actionProvider.addressReputation(args);
+            expect(ExternalAddress).toHaveBeenCalledWith(args.network, args.address);
+            expect(ExternalAddress).toHaveBeenCalledTimes(1);
+            expect(mockExternalAddressInstance.reputation).toHaveBeenCalled();
+            expect(mockExternalAddressInstance.reputation).toHaveBeenCalledTimes(1);
+            expect(result).toBe(`Error checking address reputation: ${error}`);
+        });
+    });
+    describe("faucet", () => {
+        beforeEach(() => {
+            mockExternalAddressInstance.faucet.mockResolvedValue({
+                wait: jest.fn().mockResolvedValue({
+                    getTransactionLink: jest.fn().mockReturnValue("tx-link"),
+                }),
+            });
+        });
+        it("should successfully request faucet funds with assetId", async () => {
+            const args = {
+                assetId: "eth",
+            };
+            const result = await actionProvider.faucet(mockWallet, args);
+            expect(ExternalAddress).toHaveBeenCalledWith("base-sepolia", mockWallet.getAddress());
+            expect(ExternalAddress).toHaveBeenCalledTimes(1);
+            expect(mockExternalAddressInstance.faucet).toHaveBeenCalledWith("eth");
+            expect(mockExternalAddressInstance.faucet).toHaveBeenCalledTimes(1);
+            expect(result).toContain("Received eth from the faucet");
+            expect(result).toContain("tx-link");
+        });
+        it("should successfully request faucet funds without assetId", async () => {
+            const args = {};
+            const result = await actionProvider.faucet(mockWallet, args);
+            expect(ExternalAddress).toHaveBeenCalledWith("base-sepolia", mockWallet.getAddress());
+            expect(ExternalAddress).toHaveBeenCalledTimes(1);
+            expect(mockExternalAddressInstance.faucet).toHaveBeenCalledWith(undefined);
+            expect(mockExternalAddressInstance.faucet).toHaveBeenCalledTimes(1);
+            expect(result).toContain("Received ETH from the faucet");
+        });
+        it("should handle faucet errors", async () => {
+            const args = {};
+            const error = new Error("Faucet request failed");
+            mockExternalAddressInstance.faucet.mockRejectedValue(error);
+            const result = await actionProvider.faucet(mockWallet, args);
+            expect(result).toBe(`Error requesting faucet funds: ${error}`);
+        });
+    });
+});

package/dist/action-providers/cdp/cdpWalletActionProvider.d.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { CdpWalletProvider, CdpProviderConfig } from "../../wallet-providers";
+import { DeployContractSchema, DeployNftSchema, DeployTokenSchema, TradeSchema } from "./schemas";
+/**
+ * CdpWalletActionProvider is an action provider for Cdp.
+ *
+ * This provider is used for any action that requires a CDP Wallet.
+ */
+export declare class CdpWalletActionProvider extends ActionProvider<CdpWalletProvider> {
+    /**
+     * Constructor for the CdpWalletActionProvider class.
+     *
+     * @param config - The configuration options for the CdpWalletActionProvider.
+     */
+    constructor(config?: CdpProviderConfig);
+    /**
+     * Deploys a contract.
+     *
+     * @param walletProvider - The wallet provider to deploy the contract from
+     * @param args - The input arguments for the action
+     * @returns A message containing the deployed contract address and details
+     */
+    deployContract(walletProvider: CdpWalletProvider, args: z.infer<typeof DeployContractSchema>): Promise<string>;
+    /**
+     * Deploys an NFT (ERC-721) token collection onchain from the wallet.
+     *
+     * @param walletProvider - The wallet provider to deploy the NFT from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the NFT token deployment details.
+     */
+    deployNFT(walletProvider: CdpWalletProvider, args: z.infer<typeof DeployNftSchema>): Promise<string>;
+    /**
+     * Deploys a token.
+     *
+     * @param walletProvider - The wallet provider to deploy the token.
+     * @param args - The arguments for the token deployment.
+     * @returns The deployed token.
+     */
+    deployToken(walletProvider: CdpWalletProvider, args: z.infer<typeof DeployTokenSchema>): Promise<string>;
+    /**
+     * Trades a specified amount of a from asset to a to asset for the wallet.
+     *
+     * @param walletProvider - The wallet provider to trade the asset from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the trade details.
+     */
+    trade(walletProvider: CdpWalletProvider, args: z.infer<typeof TradeSchema>): Promise<string>;
+    /**
+     * Checks if the Cdp action provider supports the given network.
+     *
+     * @param _ - The network to check.
+     * @returns True if the Cdp action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (_: Network) => boolean;
+}
+export declare const cdpWalletActionProvider: (config?: CdpProviderConfig) => CdpWalletActionProvider;

package/dist/action-providers/cdp/cdpWalletActionProvider.js

@@ -0,0 +1,218 @@
+"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.cdpWalletActionProvider = exports.CdpWalletActionProvider = void 0;
+const coinbase_sdk_1 = require("@coinbase/coinbase-sdk");
+const zod_1 = require("zod");
+const actionDecorator_1 = require("../actionDecorator");
+const actionProvider_1 = require("../actionProvider");
+const wallet_providers_1 = require("../../wallet-providers");
+const constants_1 = require("./constants");
+const schemas_1 = require("./schemas");
+/**
+ * CdpWalletActionProvider is an action provider for Cdp.
+ *
+ * This provider is used for any action that requires a CDP Wallet.
+ */
+class CdpWalletActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the CdpWalletActionProvider class.
+     *
+     * @param config - The configuration options for the CdpWalletActionProvider.
+     */
+    constructor(config = {}) {
+        super("cdp_wallet", []);
+        /**
+         * Checks if the Cdp action provider supports the given network.
+         *
+         * @param _ - The network to check.
+         * @returns True if the Cdp action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (_) => true;
+        if (config.apiKeyName && config.apiKeyPrivateKey) {
+            coinbase_sdk_1.Coinbase.configure({ apiKeyName: config.apiKeyName, privateKey: config.apiKeyPrivateKey });
+        }
+        else {
+            coinbase_sdk_1.Coinbase.configureFromJson();
+        }
+    }
+    /**
+     * Deploys a contract.
+     *
+     * @param walletProvider - The wallet provider to deploy the contract from
+     * @param args - The input arguments for the action
+     * @returns A message containing the deployed contract address and details
+     */
+    async deployContract(walletProvider, args) {
+        try {
+            const solidityVersion = constants_1.SolidityVersions[args.solidityVersion];
+            const contract = await walletProvider.deployContract({
+                solidityVersion: solidityVersion,
+                solidityInputJson: args.solidityInputJson,
+                contractName: args.contractName,
+                constructorArgs: args.constructorArgs ?? {},
+            });
+            const result = await contract.wait();
+            return `Deployed contract ${args.contractName} at address ${result.getContractAddress()}. Transaction link: ${result
+                .getTransaction()
+                .getTransactionLink()}`;
+        }
+        catch (error) {
+            return `Error deploying contract: ${error}`;
+        }
+    }
+    /**
+     * Deploys an NFT (ERC-721) token collection onchain from the wallet.
+     *
+     * @param walletProvider - The wallet provider to deploy the NFT from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the NFT token deployment details.
+     */
+    async deployNFT(walletProvider, args) {
+        try {
+            const nftContract = await walletProvider.deployNFT({
+                name: args.name,
+                symbol: args.symbol,
+                baseURI: args.baseURI,
+            });
+            const result = await nftContract.wait();
+            const transaction = result.getTransaction();
+            const networkId = walletProvider.getNetwork().networkId;
+            const contractAddress = result.getContractAddress();
+            return [
+                `Deployed NFT Collection ${args.name}:`,
+                `- to address ${contractAddress}`,
+                `- on network ${networkId}.`,
+                `Transaction hash: ${transaction.getTransactionHash()}`,
+                `Transaction link: ${transaction.getTransactionLink()}`,
+            ].join("\n");
+        }
+        catch (error) {
+            return `Error deploying NFT: ${error}`;
+        }
+    }
+    /**
+     * Deploys a token.
+     *
+     * @param walletProvider - The wallet provider to deploy the token.
+     * @param args - The arguments for the token deployment.
+     * @returns The deployed token.
+     */
+    async deployToken(walletProvider, args) {
+        try {
+            const tokenContract = await walletProvider.deployToken({
+                name: args.name,
+                symbol: args.symbol,
+                totalSupply: args.totalSupply,
+            });
+            const result = await tokenContract.wait();
+            return `Deployed ERC20 token contract ${args.name} (${args.symbol}) with total supply of ${args.totalSupply} tokens at address ${result.getContractAddress()}. Transaction link: ${result
+                .getTransaction()
+                .getTransactionLink()}`;
+        }
+        catch (error) {
+            return `Error deploying token: ${error}`;
+        }
+    }
+    /**
+     * Trades a specified amount of a from asset to a to asset for the wallet.
+     *
+     * @param walletProvider - The wallet provider to trade the asset from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the trade details.
+     */
+    async trade(walletProvider, args) {
+        try {
+            const tradeResult = await walletProvider.createTrade({
+                amount: args.amount,
+                fromAssetId: args.fromAssetId,
+                toAssetId: args.toAssetId,
+            });
+            const result = await tradeResult.wait();
+            return `Traded ${args.amount} of ${args.fromAssetId} for ${result.getToAmount()} of ${args.toAssetId}.\nTransaction hash for the trade: ${result
+                .getTransaction()
+                .getTransactionHash()}\nTransaction link for the trade: ${result
+                .getTransaction()
+                .getTransactionLink()}`;
+        }
+        catch (error) {
+            return `Error trading assets: ${error}`;
+        }
+    }
+}
+exports.CdpWalletActionProvider = CdpWalletActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "deploy_contract",
+        description: `
+Deploys smart contract with required args: solidity version (string), solidity input json (string), contract name (string), and optional constructor args (Dict[str, Any])
+
+Input json structure:
+{"language":"Solidity","settings":{"remappings":[],"outputSelection":{"*":{"*":["abi","evm.bytecode"]}}},"sources":{}}
+
+You must set the outputSelection to {"*":{"*":["abi","evm.bytecode"]}} in the settings. The solidity version must be >= 0.8.0 and <= 0.8.28.
+
+Sources should contain one or more contracts with the following structure:
+{"contract_name.sol":{"content":"contract code"}}
+
+The contract code should be escaped. Contracts cannot import from external contracts but can import from one another.
+
+Constructor args are required if the contract has a constructor. They are a key-value
+map where the key is the arg name and the value is the arg value. Encode uint/int/bytes/string/address values as strings, boolean values as true/false. For arrays/tuples, encode based on contained type.`,
+        schema: schemas_1.DeployContractSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.CdpWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], CdpWalletActionProvider.prototype, "deployContract", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "deploy_nft",
+        description: `This tool will deploy an NFT (ERC-721) contract onchain from the wallet. 
+  It takes the name of the NFT collection, the symbol of the NFT collection, and the base URI for the token metadata as inputs.`,
+        schema: schemas_1.DeployNftSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.CdpWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], CdpWalletActionProvider.prototype, "deployNFT", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "deploy_token",
+        description: `This tool will deploy an ERC20 token smart contract. It takes the token name, symbol, and total supply as input. 
+The token will be deployed using the wallet's default address as the owner and initial token holder.`,
+        schema: schemas_1.DeployTokenSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.CdpWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], CdpWalletActionProvider.prototype, "deployToken", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "trade",
+        description: `This tool will trade a specified amount of a 'from asset' to a 'to asset' for the wallet.
+It takes the following inputs:
+- The amount of the 'from asset' to trade
+- The from asset ID to trade 
+- The asset ID to receive from the trade
+
+Important notes:
+- Trades are only supported on mainnet networks (ie, 'base-mainnet', 'base', 'ethereum-mainnet', 'ethereum', etc.)
+- Never allow trades on any non-mainnet network (ie, 'base-sepolia', 'ethereum-sepolia', etc.)
+- When selling a native asset (e.g. 'eth' on base-mainnet), ensure there is sufficient balance to pay for the trade AND the gas cost of this trade`,
+        schema: schemas_1.TradeSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.CdpWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], CdpWalletActionProvider.prototype, "trade", null);
+const cdpWalletActionProvider = (config = {}) => new CdpWalletActionProvider(config);
+exports.cdpWalletActionProvider = cdpWalletActionProvider;

package/dist/action-providers/cdp/cdpWalletActionProvider.test.d.ts

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

package/dist/action-providers/cdp/cdpWalletActionProvider.test.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdpWalletActionProvider_1 = require("./cdpWalletActionProvider");
+const schemas_1 = require("./schemas");
+// Mock the entire module
+jest.mock("@coinbase/coinbase-sdk");
+// Get the mocked constructor
+const { ExternalAddress } = jest.requireMock("@coinbase/coinbase-sdk");
+describe("CDP Wallet Action Provider Input Schemas", () => {
+    describe("Deploy NFT Schema", () => {
+        it("should successfully parse valid input", () => {
+            const validInput = {
+                baseURI: "https://www.test.xyz/metadata/",
+                name: "Test Token",
+                symbol: "TEST",
+            };
+            const result = schemas_1.DeployNftSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
+        });
+        it("should fail parsing empty input", () => {
+            const emptyInput = {};
+            const result = schemas_1.DeployNftSchema.safeParse(emptyInput);
+            expect(result.success).toBe(false);
+        });
+    });
+    describe("Deploy Token Schema", () => {
+        it("should successfully parse valid input", () => {
+            const validInput = {
+                name: "Test Token",
+                symbol: "TEST",
+                totalSupply: 1000000000000000000n,
+            };
+            const result = schemas_1.DeployTokenSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
+        });
+    });
+    describe("Deploy Contract Schema", () => {
+        it("should successfully parse valid input", () => {
+            const validInput = {
+                solidityVersion: "0.8.0",
+                solidityInputJson: "{}",
+                contractName: "Test Contract",
+                constructorArgs: {},
+            };
+            const result = schemas_1.DeployContractSchema.safeParse(validInput);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(validInput);
+        });
+        it("should fail parsing empty input", () => {
+            const emptyInput = {};
+            const result = schemas_1.DeployContractSchema.safeParse(emptyInput);
+            expect(result.success).toBe(false);
+        });
+    });
+});
+describe("CDP Wallet Action Provider", () => {
+    let actionProvider;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let mockExternalAddressInstance;
+    let mockWallet;
+    beforeEach(() => {
+        // Reset all mocks before each test
+        jest.clearAllMocks();
+        actionProvider = new cdpWalletActionProvider_1.CdpWalletActionProvider();
+        mockExternalAddressInstance = {
+            reputation: jest.fn(),
+            faucet: jest.fn(),
+        };
+        // Mock the constructor to return our mock instance
+        ExternalAddress.mockImplementation(() => mockExternalAddressInstance);
+        mockWallet = {
+            createTrade: jest.fn(),
+            deployToken: jest.fn(),
+            deployContract: jest.fn(),
+            getAddress: jest.fn().mockReturnValue("0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83"),
+            getNetwork: jest.fn().mockReturnValue({ networkId: "base-sepolia" }),
+        };
+    });
+    describe("deployNft", () => {
+        let mockWallet;
+        const MOCK_NFT_BASE_URI = "https://www.test.xyz/metadata/";
+        const MOCK_NFT_NAME = "Test Token";
+        const MOCK_NFT_SYMBOL = "TEST";
+        const CONTRACT_ADDRESS = "0x123456789abcdef";
+        const NETWORK_ID = "base-sepolia";
+        const TRANSACTION_HASH = "0xghijkl987654321";
+        const TRANSACTION_LINK = `https://etherscan.io/tx/${TRANSACTION_HASH}`;
+        beforeEach(() => {
+            mockWallet = {
+                deployNFT: jest.fn().mockResolvedValue({
+                    wait: jest.fn().mockResolvedValue({
+                        getContractAddress: jest.fn().mockReturnValue(CONTRACT_ADDRESS),
+                        getTransaction: jest.fn().mockReturnValue({
+                            getTransactionHash: jest.fn().mockReturnValue(TRANSACTION_HASH),
+                            getTransactionLink: jest.fn().mockReturnValue(TRANSACTION_LINK),
+                        }),
+                    }),
+                }),
+                getNetwork: jest.fn().mockReturnValue({ networkId: NETWORK_ID }),
+            };
+        });
+        it("should successfully deploy an NFT", async () => {
+            const args = {
+                name: MOCK_NFT_NAME,
+                symbol: MOCK_NFT_SYMBOL,
+                baseURI: MOCK_NFT_BASE_URI,
+            };
+            const result = await actionProvider.deployNFT(mockWallet, args);
+            expect(mockWallet.deployNFT).toHaveBeenCalledWith(args);
+            expect(result).toContain(`Deployed NFT Collection ${MOCK_NFT_NAME}:`);
+            expect(result).toContain(`- to address ${CONTRACT_ADDRESS}`);
+            expect(result).toContain(`- on network ${NETWORK_ID}`);
+            expect(result).toContain(`Transaction hash: ${TRANSACTION_HASH}`);
+            expect(result).toContain(`Transaction link: ${TRANSACTION_LINK}`);
+        });
+        it("should handle deployment errors", async () => {
+            const args = {
+                name: MOCK_NFT_NAME,
+                symbol: MOCK_NFT_SYMBOL,
+                baseURI: MOCK_NFT_BASE_URI,
+            };
+            const error = new Error("An error has occurred");
+            mockWallet.deployNFT.mockRejectedValue(error);
+            const result = await actionProvider.deployNFT(mockWallet, args);
+            expect(mockWallet.deployNFT).toHaveBeenCalledWith(args);
+            expect(result).toBe(`Error deploying NFT: ${error}`);
+        });
+    });
+    describe("deployToken", () => {
+        beforeEach(() => {
+            mockWallet = {
+                deployToken: jest.fn().mockResolvedValue({
+                    wait: jest.fn().mockResolvedValue({
+                        getContractAddress: jest.fn().mockReturnValue("0x123"),
+                        getTransaction: jest.fn().mockReturnValue({
+                            getTransactionLink: jest.fn().mockReturnValue("tx-link"),
+                        }),
+                    }),
+                }),
+            };
+        });
+        it("should successfully deploy a token", async () => {
+            const args = {
+                name: "Test Token",
+                symbol: "TEST",
+                totalSupply: 1000000000000000000n,
+            };
+            const result = await actionProvider.deployToken(mockWallet, args);
+            expect(mockWallet.deployToken).toHaveBeenCalledWith(args);
+            expect(mockWallet.deployToken).toHaveBeenCalledTimes(1);
+            expect(result).toContain("Deployed ERC20 token contract Test Token (TEST) with total supply of 1000000000000000000 tokens at address 0x123. Transaction link: tx-link");
+        });
+        it("should handle errors when deploying a token", async () => {
+            const args = {
+                name: "Test Token",
+                symbol: "TEST",
+                totalSupply: 1000000000000000000n,
+            };
+            const error = new Error("Token deployment failed");
+            mockWallet.deployToken.mockRejectedValue(error);
+            const result = await actionProvider.deployToken(mockWallet, args);
+            expect(result).toBe(`Error deploying token: ${error}`);
+        });
+    });
+    describe("deployContract", () => {
+        const CONTRACT_ADDRESS = "0x123456789abcdef";
+        const TRANSACTION_LINK = "https://etherscan.io/tx/0xghijkl987654321";
+        const MOCK_CONTRACT_NAME = "Test Contract";
+        const MOCK_SOLIDITY_VERSION = "0.8.0";
+        const MOCK_SOLIDITY_INPUT_JSON = "{}";
+        const MOCK_CONSTRUCTOR_ARGS = { arg1: "value1", arg2: "value2" };
+        beforeEach(() => {
+            mockWallet.deployContract.mockResolvedValue({
+                wait: jest.fn().mockResolvedValue({
+                    getContractAddress: jest.fn().mockReturnValue(CONTRACT_ADDRESS),
+                    getTransaction: jest.fn().mockReturnValue({
+                        getTransactionLink: jest.fn().mockReturnValue(TRANSACTION_LINK),
+                    }),
+                }),
+            });
+        });
+        it("should successfully deploy a contract", async () => {
+            const args = {
+                solidityVersion: MOCK_SOLIDITY_VERSION,
+                solidityInputJson: MOCK_SOLIDITY_INPUT_JSON,
+                contractName: MOCK_CONTRACT_NAME,
+                constructorArgs: MOCK_CONSTRUCTOR_ARGS,
+            };
+            const response = await actionProvider.deployContract(mockWallet, args);
+            expect(mockWallet.deployContract).toHaveBeenCalledWith({
+                solidityVersion: "0.8.0+commit.c7dfd78e",
+                solidityInputJson: MOCK_SOLIDITY_INPUT_JSON,
+                contractName: MOCK_CONTRACT_NAME,
+                constructorArgs: MOCK_CONSTRUCTOR_ARGS,
+            });
+            expect(response).toContain(`Deployed contract ${MOCK_CONTRACT_NAME} at address ${CONTRACT_ADDRESS}`);
+            expect(response).toContain(`Transaction link: ${TRANSACTION_LINK}`);
+        });
+        it("should handle deployment errors", async () => {
+            const args = {
+                solidityVersion: MOCK_SOLIDITY_VERSION,
+                solidityInputJson: MOCK_SOLIDITY_INPUT_JSON,
+                contractName: MOCK_CONTRACT_NAME,
+                constructorArgs: MOCK_CONSTRUCTOR_ARGS,
+            };
+            const error = new Error("An error has occurred");
+            mockWallet.deployContract.mockRejectedValue(error);
+            const response = await actionProvider.deployContract(mockWallet, args);
+            expect(mockWallet.deployContract).toHaveBeenCalledWith({
+                solidityVersion: "0.8.0+commit.c7dfd78e",
+                solidityInputJson: MOCK_SOLIDITY_INPUT_JSON,
+                contractName: MOCK_CONTRACT_NAME,
+                constructorArgs: MOCK_CONSTRUCTOR_ARGS,
+            });
+            expect(response).toBe(`Error deploying contract: ${error}`);
+        });
+    });
+    describe("trade", () => {
+        const TRANSACTION_HASH = "0xghijkl987654321";
+        const TRANSACTION_LINK = "https://etherscan.io/tx/0xghijkl987654321";
+        const TO_AMOUNT = "100";
+        beforeEach(() => {
+            mockWallet.createTrade.mockResolvedValue({
+                wait: jest.fn().mockResolvedValue({
+                    getTransaction: jest.fn().mockReturnValue({
+                        getTransactionHash: jest.fn().mockReturnValue(TRANSACTION_HASH),
+                        getTransactionLink: jest.fn().mockReturnValue(TRANSACTION_LINK),
+                    }),
+                    getToAmount: jest.fn().mockReturnValue(TO_AMOUNT),
+                }),
+            });
+        });
+        it("should successfully trade assets", async () => {
+            const args = {
+                amount: 1n,
+                fromAssetId: "eth",
+                toAssetId: "usdc",
+            };
+            const result = await actionProvider.trade(mockWallet, args);
+            expect(mockWallet.createTrade).toHaveBeenCalledWith(args);
+            expect(result).toContain(`Traded ${args.amount} of ${args.fromAssetId} for ${TO_AMOUNT} of ${args.toAssetId}`);
+            expect(result).toContain(`Transaction hash for the trade: ${TRANSACTION_HASH}`);
+            expect(result).toContain(`Transaction link for the trade: ${TRANSACTION_LINK}`);
+        });
+        it("should handle trade errors", async () => {
+            const args = {
+                amount: 1000000000000000000n,
+                fromAssetId: "eth",
+                toAssetId: "usdc",
+            };
+            const error = new Error("An error has occurred");
+            mockWallet.createTrade.mockRejectedValue(error);
+            const result = await actionProvider.trade(mockWallet, args);
+            expect(result).toBe(`Error trading assets: ${error}`);
+        });
+    });
+});