@coinbase/agentkit 0.0.0-nightly-20250328174338

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 network - The network to check.
+     * @returns True if the Cdp action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+export declare const cdpWalletActionProvider: (config?: CdpProviderConfig) => CdpWalletActionProvider;

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

@@ -0,0 +1,224 @@
+"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 package_json_1 = require("../../../package.json");
+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 network - The network to check.
+         * @returns True if the Cdp action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (network) => network.protocolFamily === "evm";
+        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 });
+        }
+    }
+    /**
+     * 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,267 @@
+"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}`);
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true when protocolFamily is evm", () => {
+            expect(actionProvider.supportsNetwork({ protocolFamily: "evm" })).toBe(true);
+        });
+        it("should return false when protocolFamily is not evm", () => {
+            expect(actionProvider.supportsNetwork({ protocolFamily: "solana" })).toBe(false);
+        });
+    });
+});

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

@@ -0,0 +1,31 @@
+export declare const SolidityVersions: {
+    readonly "0.8.28": "0.8.28+commit.7893614a";
+    readonly "0.8.27": "0.8.27+commit.40a35a09";
+    readonly "0.8.26": "0.8.26+commit.8a97fa7a";
+    readonly "0.8.25": "0.8.25+commit.b61c2a91";
+    readonly "0.8.24": "0.8.24+commit.e11b9ed9";
+    readonly "0.8.23": "0.8.23+commit.f704f362";
+    readonly "0.8.22": "0.8.22+commit.4fc1097e";
+    readonly "0.8.21": "0.8.21+commit.d9974bed";
+    readonly "0.8.20": "0.8.20+commit.a1b79de6";
+    readonly "0.8.19": "0.8.19+commit.7dd6d404";
+    readonly "0.8.18": "0.8.18+commit.87f61d96";
+    readonly "0.8.17": "0.8.17+commit.8df45f5f";
+    readonly "0.8.16": "0.8.16+commit.07a7930e";
+    readonly "0.8.15": "0.8.15+commit.e14f2714";
+    readonly "0.8.14": "0.8.14+commit.80d49f37";
+    readonly "0.8.13": "0.8.13+commit.abaa5c0e";
+    readonly "0.8.12": "0.8.12+commit.f00d7308";
+    readonly "0.8.11": "0.8.11+commit.d7f03943";
+    readonly "0.8.10": "0.8.10+commit.fc410830";
+    readonly "0.8.9": "0.8.9+commit.e5eed63a";
+    readonly "0.8.8": "0.8.8+commit.dddeac2f";
+    readonly "0.8.7": "0.8.7+commit.e28d00a7";
+    readonly "0.8.6": "0.8.6+commit.11564f7e";
+    readonly "0.8.5": "0.8.5+commit.a4f2e591";
+    readonly "0.8.4": "0.8.4+commit.c7e474f2";
+    readonly "0.8.3": "0.8.3+commit.8d00100c";
+    readonly "0.8.2": "0.8.2+commit.661d1103";
+    readonly "0.8.1": "0.8.1+commit.df193b15";
+    readonly "0.8.0": "0.8.0+commit.c7dfd78e";
+};

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolidityVersions = void 0;
+exports.SolidityVersions = {
+    "0.8.28": "0.8.28+commit.7893614a",
+    "0.8.27": "0.8.27+commit.40a35a09",
+    "0.8.26": "0.8.26+commit.8a97fa7a",
+    "0.8.25": "0.8.25+commit.b61c2a91",
+    "0.8.24": "0.8.24+commit.e11b9ed9",
+    "0.8.23": "0.8.23+commit.f704f362",
+    "0.8.22": "0.8.22+commit.4fc1097e",
+    "0.8.21": "0.8.21+commit.d9974bed",
+    "0.8.20": "0.8.20+commit.a1b79de6",
+    "0.8.19": "0.8.19+commit.7dd6d404",
+    "0.8.18": "0.8.18+commit.87f61d96",
+    "0.8.17": "0.8.17+commit.8df45f5f",
+    "0.8.16": "0.8.16+commit.07a7930e",
+    "0.8.15": "0.8.15+commit.e14f2714",
+    "0.8.14": "0.8.14+commit.80d49f37",
+    "0.8.13": "0.8.13+commit.abaa5c0e",
+    "0.8.12": "0.8.12+commit.f00d7308",
+    "0.8.11": "0.8.11+commit.d7f03943",
+    "0.8.10": "0.8.10+commit.fc410830",
+    "0.8.9": "0.8.9+commit.e5eed63a",
+    "0.8.8": "0.8.8+commit.dddeac2f",
+    "0.8.7": "0.8.7+commit.e28d00a7",
+    "0.8.6": "0.8.6+commit.11564f7e",
+    "0.8.5": "0.8.5+commit.a4f2e591",
+    "0.8.4": "0.8.4+commit.c7e474f2",
+    "0.8.3": "0.8.3+commit.8d00100c",
+    "0.8.2": "0.8.2+commit.661d1103",
+    "0.8.1": "0.8.1+commit.df193b15",
+    "0.8.0": "0.8.0+commit.c7dfd78e",
+};

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

@@ -0,0 +1,3 @@
+export * from "./schemas";
+export * from "./cdpApiActionProvider";
+export * from "./cdpWalletActionProvider";

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

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