@coinbase/agentkit 0.1.0

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

@@ -0,0 +1,109 @@
+"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.basenameActionProvider = exports.BasenameActionProvider = void 0;
+const viem_1 = require("viem");
+const zod_1 = require("zod");
+const actionProvider_1 = require("../actionProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const constants_1 = require("./constants");
+const schemas_1 = require("./schemas");
+const wallet_providers_1 = require("../../wallet-providers");
+/**
+ * Action provider for registering Basenames.
+ */
+class BasenameActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructs a new BasenameActionProvider.
+     */
+    constructor() {
+        super("basename", []);
+        /**
+         * Checks if the Basename action provider supports the given network.
+         *
+         * @param network - The network to check.
+         * @returns True if the Basename action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (network) => network.networkId === "base-mainnet" || network.networkId === "base-sepolia";
+    }
+    /**
+     * Registers a Basename.
+     *
+     * @param wallet - The wallet to use for the registration.
+     * @param args - The arguments for the registration.
+     * @returns A string indicating the success or failure of the registration.
+     */
+    async register(wallet, args) {
+        const address = wallet.getAddress();
+        const isMainnet = wallet.getNetwork().networkId === "base-mainnet";
+        const suffix = isMainnet ? ".base.eth" : ".basetest.eth";
+        if (!args.basename.endsWith(suffix)) {
+            args.basename += suffix;
+        }
+        const l2ResolverAddress = isMainnet ? constants_1.L2_RESOLVER_ADDRESS_MAINNET : constants_1.L2_RESOLVER_ADDRESS_TESTNET;
+        const addressData = (0, viem_1.encodeFunctionData)({
+            abi: constants_1.L2_RESOLVER_ABI,
+            functionName: "setAddr",
+            args: [(0, viem_1.namehash)(args.basename), address],
+        });
+        const nameData = (0, viem_1.encodeFunctionData)({
+            abi: constants_1.L2_RESOLVER_ABI,
+            functionName: "setName",
+            args: [(0, viem_1.namehash)(args.basename), args.basename],
+        });
+        try {
+            const contractAddress = isMainnet
+                ? constants_1.BASENAMES_REGISTRAR_CONTROLLER_ADDRESS_MAINNET
+                : constants_1.BASENAMES_REGISTRAR_CONTROLLER_ADDRESS_TESTNET;
+            const hash = await wallet.sendTransaction({
+                to: contractAddress,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.REGISTRAR_ABI,
+                    functionName: "register",
+                    args: [
+                        {
+                            name: args.basename.replace(suffix, ""),
+                            owner: address,
+                            duration: constants_1.REGISTRATION_DURATION,
+                            resolver: l2ResolverAddress,
+                            data: [addressData, nameData],
+                            reverseRecord: true,
+                        },
+                    ],
+                }),
+                value: (0, viem_1.parseEther)(args.amount),
+            });
+            await wallet.waitForTransactionReceipt(hash);
+            return `Successfully registered basename ${args.basename} for address ${address}`;
+        }
+        catch (error) {
+            return `Error registering basename: Error: ${error}`;
+        }
+    }
+}
+exports.BasenameActionProvider = BasenameActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "register_basename",
+        description: `
+This tool will register a Basename for the agent. The agent should have a wallet associated to register a Basename.
+When your network ID is 'base-mainnet' (also sometimes known simply as 'base'), the name must end with .base.eth, and when your network ID is 'base-sepolia', it must ends with .basetest.eth.
+Do not suggest any alternatives and never try to register a Basename with another postfix. The prefix of the name must be unique so if the registration of the
+Basename fails, you should prompt to try again with a more unique name.
+`,
+        schema: schemas_1.RegisterBasenameSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], BasenameActionProvider.prototype, "register", null);
+const basenameActionProvider = () => new BasenameActionProvider();
+exports.basenameActionProvider = basenameActionProvider;

package/dist/action-providers/basename/basenameActionProvider.test.d.ts

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

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,41 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { CdpProviderConfig, EvmWalletProvider } 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<EvmWalletProvider> {
+    /**
+     * 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: EvmWalletProvider, args: z.infer<typeof RequestFaucetFundsSchema>): 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 cdpApiActionProvider: (config?: CdpProviderConfig) => CdpApiActionProvider;

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

@@ -0,0 +1,111 @@
+"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 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.
+         *
+         * @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();
+        }
+    }
+    /**
+     * 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) {
+        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) {
+        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();
+            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.
+If no asset ID is provided the faucet defaults to ETH. Faucet is only allowed on 'base-sepolia' and can only provide asset ID 'eth' or 'usdc'.
+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.EvmWalletProvider, 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 {};