@coinbase/agentkit 0.0.0-nightly-20250328174338

package/dist/action-providers/basename/basenameActionProvider.test.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const basenameActionProvider_1 = require("./basenameActionProvider");
+const constants_1 = require("./constants");
+const schemas_1 = require("./schemas");
+const coinbase_sdk_1 = require("@coinbase/coinbase-sdk");
+const MOCK_AMOUNT = "0.123";
+const MOCK_BASENAME = "test-basename";
+describe("Register Basename Input", () => {
+    it("should successfully parse valid input", () => {
+        const validInput = {
+            amount: MOCK_AMOUNT,
+            basename: MOCK_BASENAME,
+        };
+        const result = schemas_1.RegisterBasenameSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual(validInput);
+    });
+    it("should fail parsing empty input", () => {
+        const emptyInput = {};
+        const result = schemas_1.RegisterBasenameSchema.safeParse(emptyInput);
+        expect(result.success).toBe(false);
+    });
+});
+describe("Register Basename Action", () => {
+    /**
+     * This is the default network.
+     */
+    const NETWORK_ID = coinbase_sdk_1.Coinbase.networks.BaseMainnet;
+    /**
+     * This is a 40 character hexadecimal string that requires lowercase alpha characters.
+     */
+    const ADDRESS_ID = "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83";
+    let mockWallet;
+    const actionProvider = (0, basenameActionProvider_1.basenameActionProvider)();
+    beforeEach(() => {
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(ADDRESS_ID),
+            getNetwork: jest.fn().mockReturnValue({ networkId: NETWORK_ID }),
+            sendTransaction: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+        };
+        mockWallet.sendTransaction.mockResolvedValue("some-hash");
+        mockWallet.waitForTransactionReceipt.mockResolvedValue({});
+    });
+    it(`should Successfully respond with ${MOCK_BASENAME}.base.eth for network: ${coinbase_sdk_1.Coinbase.networks.BaseMainnet}`, async () => {
+        const args = {
+            amount: MOCK_AMOUNT,
+            basename: MOCK_BASENAME,
+        };
+        const name = `${MOCK_BASENAME}.base.eth`;
+        mockWallet.getNetwork.mockReturnValue({
+            protocolFamily: "evm",
+            networkId: coinbase_sdk_1.Coinbase.networks.BaseMainnet,
+        });
+        const response = await actionProvider.register(mockWallet, args);
+        expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+            to: constants_1.BASENAMES_REGISTRAR_CONTROLLER_ADDRESS_MAINNET,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: constants_1.REGISTRAR_ABI,
+                functionName: "register",
+                args: [
+                    {
+                        name: MOCK_BASENAME,
+                        owner: ADDRESS_ID,
+                        duration: constants_1.REGISTRATION_DURATION,
+                        resolver: constants_1.L2_RESOLVER_ADDRESS_MAINNET,
+                        data: [
+                            (0, viem_1.encodeFunctionData)({
+                                abi: constants_1.L2_RESOLVER_ABI,
+                                functionName: "setAddr",
+                                args: [(0, viem_1.namehash)(name), ADDRESS_ID],
+                            }),
+                            (0, viem_1.encodeFunctionData)({
+                                abi: constants_1.L2_RESOLVER_ABI,
+                                functionName: "setName",
+                                args: [(0, viem_1.namehash)(name), name],
+                            }),
+                        ],
+                        reverseRecord: true,
+                    },
+                ],
+            }),
+            value: (0, viem_1.parseEther)(MOCK_AMOUNT),
+        });
+        expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledWith("some-hash");
+        expect(response).toContain(`Successfully registered basename ${MOCK_BASENAME}.base.eth`);
+        expect(response).toContain(`for address ${ADDRESS_ID}`);
+    });
+    it(`should Successfully respond with ${MOCK_BASENAME}.basetest.eth for any other network`, async () => {
+        const args = {
+            amount: MOCK_AMOUNT,
+            basename: MOCK_BASENAME,
+        };
+        const name = `${MOCK_BASENAME}.basetest.eth`;
+        mockWallet.getNetwork.mockReturnValue({
+            protocolFamily: "evm",
+            networkId: "anything-else",
+        });
+        const response = await actionProvider.register(mockWallet, args);
+        expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+            to: constants_1.BASENAMES_REGISTRAR_CONTROLLER_ADDRESS_TESTNET,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: constants_1.REGISTRAR_ABI,
+                functionName: "register",
+                args: [
+                    {
+                        name: MOCK_BASENAME,
+                        owner: ADDRESS_ID,
+                        duration: constants_1.REGISTRATION_DURATION,
+                        resolver: constants_1.L2_RESOLVER_ADDRESS_TESTNET,
+                        data: [
+                            (0, viem_1.encodeFunctionData)({
+                                abi: constants_1.L2_RESOLVER_ABI,
+                                functionName: "setAddr",
+                                args: [(0, viem_1.namehash)(name), ADDRESS_ID],
+                            }),
+                            (0, viem_1.encodeFunctionData)({
+                                abi: constants_1.L2_RESOLVER_ABI,
+                                functionName: "setName",
+                                args: [(0, viem_1.namehash)(name), name],
+                            }),
+                        ],
+                        reverseRecord: true,
+                    },
+                ],
+            }),
+            value: (0, viem_1.parseEther)(MOCK_AMOUNT),
+        });
+        expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledWith("some-hash");
+        expect(response).toContain(`Successfully registered basename ${MOCK_BASENAME}.basetest.eth`);
+        expect(response).toContain(`for address ${ADDRESS_ID}`);
+    });
+    it("should fail with an error", async () => {
+        const args = {
+            amount: MOCK_AMOUNT,
+            basename: MOCK_BASENAME,
+        };
+        const error = new Error("Failed to register basename");
+        mockWallet.sendTransaction.mockRejectedValue(error);
+        await actionProvider.register(mockWallet, args);
+        expect(mockWallet.sendTransaction).toHaveBeenCalled();
+        expect(`Error registering basename: ${error}`);
+    });
+});

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

@@ -0,0 +1,52 @@
+export declare const BASENAMES_REGISTRAR_CONTROLLER_ADDRESS_MAINNET = "0x4cCb0BB02FCABA27e82a56646E81d8c5bC4119a5";
+export declare const BASENAMES_REGISTRAR_CONTROLLER_ADDRESS_TESTNET = "0x49aE3cC2e3AA768B1e5654f5D3C6002144A59581";
+export declare const L2_RESOLVER_ADDRESS_MAINNET = "0xC6d566A56A1aFf6508b41f6c90ff131615583BCD";
+export declare const L2_RESOLVER_ADDRESS_TESTNET = "0x6533C94869D28fAA8dF77cc63f9e2b2D6Cf77eBA";
+export declare const REGISTRATION_DURATION = 31557600n;
+export declare const L2_RESOLVER_ABI: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: never[];
+    stateMutability: string;
+    type: string;
+}[];
+export declare const REGISTRAR_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "string";
+            readonly name: "name";
+            readonly type: "string";
+        }, {
+            readonly internalType: "address";
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "duration";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "address";
+            readonly name: "resolver";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes[]";
+            readonly name: "data";
+            readonly type: "bytes[]";
+        }, {
+            readonly internalType: "bool";
+            readonly name: "reverseRecord";
+            readonly type: "bool";
+        }];
+        readonly internalType: "struct RegistrarController.RegisterRequest";
+        readonly name: "request";
+        readonly type: "tuple";
+    }];
+    readonly name: "register";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}];

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REGISTRAR_ABI = exports.L2_RESOLVER_ABI = exports.REGISTRATION_DURATION = exports.L2_RESOLVER_ADDRESS_TESTNET = exports.L2_RESOLVER_ADDRESS_MAINNET = exports.BASENAMES_REGISTRAR_CONTROLLER_ADDRESS_TESTNET = exports.BASENAMES_REGISTRAR_CONTROLLER_ADDRESS_MAINNET = void 0;
+// Contract addresses
+exports.BASENAMES_REGISTRAR_CONTROLLER_ADDRESS_MAINNET = "0x4cCb0BB02FCABA27e82a56646E81d8c5bC4119a5";
+exports.BASENAMES_REGISTRAR_CONTROLLER_ADDRESS_TESTNET = "0x49aE3cC2e3AA768B1e5654f5D3C6002144A59581";
+exports.L2_RESOLVER_ADDRESS_MAINNET = "0xC6d566A56A1aFf6508b41f6c90ff131615583BCD";
+exports.L2_RESOLVER_ADDRESS_TESTNET = "0x6533C94869D28fAA8dF77cc63f9e2b2D6Cf77eBA";
+// Default registration duration (1 year in seconds)
+exports.REGISTRATION_DURATION = 31557600n;
+// Relevant ABI for L2 Resolver Contract.
+exports.L2_RESOLVER_ABI = [
+    {
+        inputs: [
+            { internalType: "bytes32", name: "node", type: "bytes32" },
+            { internalType: "address", name: "a", type: "address" },
+        ],
+        name: "setAddr",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "bytes32", name: "node", type: "bytes32" },
+            { internalType: "string", name: "newName", type: "string" },
+        ],
+        name: "setName",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+];
+// Relevant ABI for Basenames Registrar Controller Contract.
+exports.REGISTRAR_ABI = [
+    {
+        inputs: [
+            {
+                components: [
+                    {
+                        internalType: "string",
+                        name: "name",
+                        type: "string",
+                    },
+                    {
+                        internalType: "address",
+                        name: "owner",
+                        type: "address",
+                    },
+                    {
+                        internalType: "uint256",
+                        name: "duration",
+                        type: "uint256",
+                    },
+                    {
+                        internalType: "address",
+                        name: "resolver",
+                        type: "address",
+                    },
+                    {
+                        internalType: "bytes[]",
+                        name: "data",
+                        type: "bytes[]",
+                    },
+                    {
+                        internalType: "bool",
+                        name: "reverseRecord",
+                        type: "bool",
+                    },
+                ],
+                internalType: "struct RegistrarController.RegisterRequest",
+                name: "request",
+                type: "tuple",
+            },
+        ],
+        name: "register",
+        outputs: [],
+        stateMutability: "payable",
+        type: "function",
+    },
+];

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

@@ -0,0 +1,2 @@
+export * from "./basenameActionProvider";
+export * from "./schemas";

package/dist/action-providers/basename/index.js

@@ -0,0 +1,18 @@
+"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("./basenameActionProvider"), exports);
+__exportStar(require("./schemas"), exports);

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

@@ -0,0 +1,14 @@
+import { z } from "zod";
+/**
+ * Input schema for registering a Basename.
+ */
+export declare const RegisterBasenameSchema: z.ZodObject<{
+    basename: z.ZodString;
+    amount: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    amount: string;
+    basename: string;
+}, {
+    basename: string;
+    amount?: string | undefined;
+}>;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegisterBasenameSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for registering a Basename.
+ */
+exports.RegisterBasenameSchema = zod_1.z
+    .object({
+    basename: zod_1.z.string().describe("The Basename to assign to the agent"),
+    amount: zod_1.z.string().default("0.002").describe("The amount of ETH to pay for registration"),
+})
+    .strip()
+    .describe("Instructions for registering a Basename");

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

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { CdpProviderConfig, WalletProvider } from "../../wallet-providers";
+import { AddressReputationSchema, RequestFaucetFundsSchema } from "./schemas";
+/**
+ * CdpApiActionProvider is an action provider for CDP API.
+ *
+ * This provider is used for any action that uses the CDP API, but does not require a CDP Wallet.
+ */
+export declare class CdpApiActionProvider extends ActionProvider<WalletProvider> {
+    /**
+     * Constructor for the CdpApiActionProvider class.
+     *
+     * @param config - The configuration options for the CdpApiActionProvider.
+     */
+    constructor(config?: CdpProviderConfig);
+    /**
+     * Check the reputation of an address.
+     *
+     * @param args - The input arguments for the action
+     * @returns A string containing reputation data or error message
+     */
+    addressReputation(args: z.infer<typeof AddressReputationSchema>): Promise<string>;
+    /**
+     * Requests test tokens from the faucet for the default address in the wallet.
+     *
+     * @param walletProvider - The wallet provider to request funds from.
+     * @param args - The input arguments for the action.
+     * @returns A confirmation message with transaction details.
+     */
+    faucet(walletProvider: WalletProvider, args: z.infer<typeof RequestFaucetFundsSchema>): Promise<string>;
+    /**
+     * Checks if the Cdp action provider supports the given network.
+     *
+     * NOTE: Network scoping is done at the action implementation level
+     *
+     * @param _ - The network to check.
+     * @returns True if the Cdp action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (_: Network) => boolean;
+}
+export declare const cdpApiActionProvider: (config?: CdpProviderConfig) => CdpApiActionProvider;

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

@@ -0,0 +1,128 @@
+"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.cdpApiActionProvider = exports.CdpApiActionProvider = void 0;
+const package_json_1 = require("../../../package.json");
+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 schemas_1 = require("./schemas");
+/**
+ * CdpApiActionProvider is an action provider for CDP API.
+ *
+ * This provider is used for any action that uses the CDP API, but does not require a CDP Wallet.
+ */
+class CdpApiActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the CdpApiActionProvider class.
+     *
+     * @param config - The configuration options for the CdpApiActionProvider.
+     */
+    constructor(config = {}) {
+        super("cdp_api", []);
+        /**
+         * Checks if the Cdp action provider supports the given network.
+         *
+         * NOTE: Network scoping is done at the action implementation level
+         *
+         * @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?.replace(/\\n/g, "\n"),
+                source: "agentkit",
+                sourceVersion: package_json_1.version,
+            });
+        }
+        else {
+            coinbase_sdk_1.Coinbase.configureFromJson({ source: "agentkit", sourceVersion: package_json_1.version });
+        }
+    }
+    /**
+     * Check the reputation of an address.
+     *
+     * @param args - The input arguments for the action
+     * @returns A string containing reputation data or error message
+     */
+    async addressReputation(args) {
+        if (args.network.includes("solana")) {
+            return "Address reputation is only supported on Ethereum networks.";
+        }
+        try {
+            const address = new coinbase_sdk_1.ExternalAddress(args.network, args.address);
+            const reputation = await address.reputation();
+            return reputation.toString();
+        }
+        catch (error) {
+            return `Error checking address reputation: ${error}`;
+        }
+    }
+    /**
+     * Requests test tokens from the faucet for the default address in the wallet.
+     *
+     * @param walletProvider - The wallet provider to request funds from.
+     * @param args - The input arguments for the action.
+     * @returns A confirmation message with transaction details.
+     */
+    async faucet(walletProvider, args) {
+        const network = walletProvider.getNetwork();
+        if (network.networkId !== "base-sepolia" && network.networkId !== "solana-devnet") {
+            return `Faucet is only allowed on 'base-sepolia' or 'solana-devnet'.`;
+        }
+        try {
+            const address = new coinbase_sdk_1.ExternalAddress(walletProvider.getNetwork().networkId, walletProvider.getAddress());
+            const faucetTx = await address.faucet(args.assetId || undefined);
+            const result = await faucetTx.wait({ timeoutSeconds: 60 });
+            return `Received ${args.assetId || "ETH"} from the faucet. Transaction: ${result.getTransactionLink()}`;
+        }
+        catch (error) {
+            return `Error requesting faucet funds: ${error}`;
+        }
+    }
+}
+exports.CdpApiActionProvider = CdpApiActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "address_reputation",
+        description: `
+This tool checks the reputation of an address on a given network. It takes:
+
+- network: The network to check the address on (e.g. "base-mainnet")
+- address: The Ethereum address to check
+`,
+        schema: schemas_1.AddressReputationSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], CdpApiActionProvider.prototype, "addressReputation", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "request_faucet_funds",
+        description: `This tool will request test tokens from the faucet for the default address in the wallet. It takes the wallet and asset ID as input.
+Faucet is only allowed on 'base-sepolia' or 'solana-devnet'.
+If fauceting on 'base-sepolia', user can only provide asset ID 'eth' or 'usdc', if no asset ID is provided, the faucet will default to 'eth'.
+If fauceting on 'solana-devnet', user can only provide asset ID 'sol', if no asset ID is provided, the faucet will default to 'sol'.
+You are not allowed to faucet with any other network or asset ID. If you are on another network, suggest that the user sends you some ETH
+from another wallet and provide the user with your wallet details.`,
+        schema: schemas_1.RequestFaucetFundsSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.WalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], CdpApiActionProvider.prototype, "faucet", null);
+const cdpApiActionProvider = (config = {}) => new CdpApiActionProvider(config);
+exports.cdpApiActionProvider = cdpApiActionProvider;

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

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

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

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdpApiActionProvider_1 = require("./cdpApiActionProvider");
+const schemas_1 = require("./schemas");
+jest.mock("@coinbase/coinbase-sdk");
+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}`);
+        });
+        it("should return error if not on Ethereum network", async () => {
+            const args = {
+                address: "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83",
+                network: "solana-devnet",
+            };
+            const result = await actionProvider.addressReputation(args);
+            expect(result).toBe("Address reputation is only supported on Ethereum networks.");
+        });
+    });
+    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}`);
+        });
+        it("should return error if not on base-sepolia or solana-devnet", async () => {
+            mockWallet.getNetwork.mockReturnValue({ networkId: "solana-mainnet", protocolFamily: "svm" });
+            const args = {};
+            const result = await actionProvider.faucet(mockWallet, args);
+            expect(result).toBe("Faucet is only allowed on 'base-sepolia' or 'solana-devnet'.");
+        });
+    });
+});