@coinbase/agentkit 0.0.0-nightly-20250328174338

package/dist/action-providers/morpho/morphoActionProvider.js

@@ -0,0 +1,154 @@
+"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.morphoActionProvider = exports.MorphoActionProvider = exports.SUPPORTED_NETWORKS = void 0;
+const zod_1 = require("zod");
+const decimal_js_1 = require("decimal.js");
+const viem_1 = require("viem");
+const constants_1 = require("../erc20/constants");
+const actionProvider_1 = require("../actionProvider");
+const wallet_providers_1 = require("../../wallet-providers");
+const actionDecorator_1 = require("../actionDecorator");
+const utils_1 = require("../../utils");
+const constants_2 = require("./constants");
+const schemas_1 = require("./schemas");
+exports.SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia"];
+/**
+ * MorphoActionProvider is an action provider for Morpho Vault interactions.
+ */
+class MorphoActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the MorphoActionProvider class.
+     */
+    constructor() {
+        super("morpho", []);
+        /**
+         * Checks if the Morpho action provider supports the given network.
+         *
+         * @param network - The network to check.
+         * @returns True if the Morpho action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (network) => network.protocolFamily === "evm" && exports.SUPPORTED_NETWORKS.includes(network.networkId);
+    }
+    /**
+     * Deposits assets into a Morpho Vault
+     *
+     * @param wallet - The wallet instance to execute the transaction
+     * @param args - The input arguments for the action
+     * @returns A success message with transaction details or an error message
+     */
+    async deposit(wallet, args) {
+        const assets = new decimal_js_1.Decimal(args.assets);
+        if (assets.comparedTo(new decimal_js_1.Decimal(0.0)) != 1) {
+            return "Error: Assets amount must be greater than 0";
+        }
+        try {
+            const decimals = await wallet.readContract({
+                address: args.tokenAddress,
+                abi: constants_1.abi,
+                functionName: "decimals",
+                args: [],
+            });
+            const atomicAssets = (0, viem_1.parseUnits)(args.assets, decimals);
+            const approvalResult = await (0, utils_1.approve)(wallet, args.tokenAddress, args.vaultAddress, atomicAssets);
+            if (approvalResult.startsWith("Error")) {
+                return `Error approving Morpho Vault as spender: ${approvalResult}`;
+            }
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: constants_2.METAMORPHO_ABI,
+                functionName: "deposit",
+                args: [atomicAssets, args.receiver],
+            });
+            const txHash = await wallet.sendTransaction({
+                to: args.vaultAddress,
+                data,
+            });
+            const receipt = await wallet.waitForTransactionReceipt(txHash);
+            return `Deposited ${args.assets} to Morpho Vault ${args.vaultAddress} with transaction hash: ${txHash}\nTransaction receipt: ${JSON.stringify(receipt)}`;
+        }
+        catch (error) {
+            return `Error depositing to Morpho Vault: ${error}`;
+        }
+    }
+    /**
+     * Withdraws assets from a Morpho Vault
+     *
+     * @param wallet - The wallet instance to execute the transaction
+     * @param args - The input arguments for the action
+     * @returns A success message with transaction details or an error message
+     */
+    async withdraw(wallet, args) {
+        if (BigInt(args.assets) <= 0) {
+            return "Error: Assets amount must be greater than 0";
+        }
+        try {
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: constants_2.METAMORPHO_ABI,
+                functionName: "withdraw",
+                args: [BigInt(args.assets), args.receiver, args.receiver],
+            });
+            const txHash = await wallet.sendTransaction({
+                to: args.vaultAddress,
+                data,
+            });
+            const receipt = await wallet.waitForTransactionReceipt(txHash);
+            return `Withdrawn ${args.assets} from Morpho Vault ${args.vaultAddress} with transaction hash: ${txHash}\nTransaction receipt: ${JSON.stringify(receipt)}`;
+        }
+        catch (error) {
+            return `Error withdrawing from Morpho Vault: ${error}`;
+        }
+    }
+}
+exports.MorphoActionProvider = MorphoActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "deposit",
+        description: `
+This tool allows depositing assets into a Morpho Vault. 
+
+It takes:
+- vaultAddress: The address of the Morpho Vault to deposit to
+- assets: The amount of assets to deposit in whole units
+  Examples for WETH:
+  - 1 WETH
+  - 0.1 WETH
+  - 0.01 WETH
+- receiver: The address to receive the shares
+- tokenAddress: The address of the token to approve
+
+Important notes:
+- Make sure to use the exact amount provided. Do not convert units for assets for this action.
+- Please use a token address (example 0x4200000000000000000000000000000000000006) for the tokenAddress field.
+`,
+        schema: schemas_1.DepositSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], MorphoActionProvider.prototype, "deposit", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "withdraw",
+        description: `
+This tool allows withdrawing assets from a Morpho Vault. It takes:
+
+- vaultAddress: The address of the Morpho Vault to withdraw from
+- assets: The amount of assets to withdraw in atomic units (wei)
+- receiver: The address to receive the shares
+`,
+        schema: schemas_1.WithdrawSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], MorphoActionProvider.prototype, "withdraw", null);
+const morphoActionProvider = () => new MorphoActionProvider();
+exports.morphoActionProvider = morphoActionProvider;

package/dist/action-providers/morpho/morphoActionProvider.test.d.ts

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

package/dist/action-providers/morpho/morphoActionProvider.test.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const utils_1 = require("../../utils");
+const morphoActionProvider_1 = require("./morphoActionProvider");
+const constants_1 = require("./constants");
+const MOCK_VAULT_ADDRESS = "0x1234567890123456789012345678901234567890";
+const MOCK_ATOMIC_ASSETS = "1000000000000000000";
+const MOCK_WHOLE_ASSETS = "1.0";
+const MOCK_RECEIVER_ID = "0x9876543210987654321098765432109876543210";
+const MOCK_TOKEN_ADDRESS = "0x4200000000000000000000000000000000000006";
+const MOCK_TX_HASH = "0xabcdef1234567890";
+const MOCK_RECEIPT = { status: 1, blockNumber: 1234567 };
+const MOCK_DECIMALS = 18;
+jest.mock("../../utils");
+const mockApprove = utils_1.approve;
+describe("Morpho Action Provider", () => {
+    const actionProvider = new morphoActionProvider_1.MorphoActionProvider();
+    let mockWallet;
+    beforeEach(() => {
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_RECEIVER_ID),
+            getNetwork: jest.fn().mockReturnValue({ protocolFamily: "evm", networkId: "1" }),
+            sendTransaction: jest.fn().mockResolvedValue(MOCK_TX_HASH),
+            waitForTransactionReceipt: jest.fn().mockResolvedValue(MOCK_RECEIPT),
+            readContract: jest.fn().mockResolvedValue(MOCK_DECIMALS),
+        };
+        mockApprove.mockResolvedValue("Approval successful");
+    });
+    describe("deposit", () => {
+        it("should successfully deposit to Morpho vault", async () => {
+            const args = {
+                vaultAddress: MOCK_VAULT_ADDRESS,
+                assets: MOCK_WHOLE_ASSETS,
+                receiver: MOCK_RECEIVER_ID,
+                tokenAddress: MOCK_TOKEN_ADDRESS,
+            };
+            const atomicAssets = (0, viem_1.parseEther)(MOCK_WHOLE_ASSETS);
+            const response = await actionProvider.deposit(mockWallet, args);
+            expect(mockApprove).toHaveBeenCalledWith(mockWallet, MOCK_TOKEN_ADDRESS, MOCK_VAULT_ADDRESS, atomicAssets);
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: MOCK_VAULT_ADDRESS,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.METAMORPHO_ABI,
+                    functionName: "deposit",
+                    args: [atomicAssets, MOCK_RECEIVER_ID],
+                }),
+            });
+            expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
+            expect(response).toContain(`Deposited ${MOCK_WHOLE_ASSETS}`);
+            expect(response).toContain(MOCK_TX_HASH);
+            expect(response).toContain(JSON.stringify(MOCK_RECEIPT));
+        });
+        it("should handle errors when depositing", async () => {
+            const args = {
+                vaultAddress: MOCK_VAULT_ADDRESS,
+                assets: MOCK_WHOLE_ASSETS,
+                receiver: MOCK_RECEIVER_ID,
+                tokenAddress: MOCK_TOKEN_ADDRESS,
+            };
+            mockWallet.sendTransaction.mockRejectedValue(new Error("Failed to deposit"));
+            const response = await actionProvider.deposit(mockWallet, args);
+            expect(response).toContain("Error depositing to Morpho Vault: Error: Failed to deposit");
+        });
+    });
+    describe("withdraw", () => {
+        it("should successfully withdraw from Morpho vault", async () => {
+            const args = {
+                vaultAddress: MOCK_VAULT_ADDRESS,
+                assets: MOCK_ATOMIC_ASSETS,
+                receiver: MOCK_RECEIVER_ID,
+            };
+            const response = await actionProvider.withdraw(mockWallet, args);
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: MOCK_VAULT_ADDRESS,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.METAMORPHO_ABI,
+                    functionName: "withdraw",
+                    args: [BigInt(MOCK_ATOMIC_ASSETS), MOCK_RECEIVER_ID, MOCK_RECEIVER_ID],
+                }),
+            });
+            expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledWith(MOCK_TX_HASH);
+            expect(response).toContain(`Withdrawn ${MOCK_ATOMIC_ASSETS}`);
+            expect(response).toContain(MOCK_TX_HASH);
+            expect(response).toContain(JSON.stringify(MOCK_RECEIPT));
+        });
+        it("should handle errors when withdrawing", async () => {
+            const args = {
+                vaultAddress: MOCK_VAULT_ADDRESS,
+                assets: MOCK_ATOMIC_ASSETS,
+                receiver: MOCK_RECEIVER_ID,
+            };
+            mockWallet.sendTransaction.mockRejectedValue(new Error("Failed to withdraw"));
+            const response = await actionProvider.withdraw(mockWallet, args);
+            expect(response).toContain("Error withdrawing from Morpho Vault: Error: Failed to withdraw");
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for Base Mainnet", () => {
+            const result = actionProvider.supportsNetwork({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            expect(result).toBe(true);
+        });
+        it("should return true for Base Sepolia", () => {
+            const result = actionProvider.supportsNetwork({
+                protocolFamily: "evm",
+                networkId: "base-sepolia",
+            });
+            expect(result).toBe(true);
+        });
+        it("should return false for other EVM networks", () => {
+            const result = actionProvider.supportsNetwork({
+                protocolFamily: "evm",
+                networkId: "ethereum",
+            });
+            expect(result).toBe(false);
+        });
+        it("should return false for non-EVM networks", () => {
+            const result = actionProvider.supportsNetwork({
+                protocolFamily: "bitcoin",
+                networkId: "base-mainnet",
+            });
+            expect(result).toBe(false);
+        });
+    });
+});

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+/**
+ * Input schema for Morpho Vault deposit action.
+ */
+export declare const DepositSchema: z.ZodObject<{
+    assets: z.ZodString;
+    receiver: z.ZodString;
+    tokenAddress: z.ZodString;
+    vaultAddress: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    receiver: string;
+    assets: string;
+    tokenAddress: string;
+    vaultAddress: string;
+}, {
+    receiver: string;
+    assets: string;
+    tokenAddress: string;
+    vaultAddress: string;
+}>;
+/**
+ * Input schema for Morpho Vault withdraw action.
+ */
+export declare const WithdrawSchema: z.ZodObject<{
+    vaultAddress: z.ZodString;
+    assets: z.ZodString;
+    receiver: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    receiver: string;
+    assets: string;
+    vaultAddress: string;
+}, {
+    receiver: string;
+    assets: string;
+    vaultAddress: string;
+}>;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithdrawSchema = exports.DepositSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for Morpho Vault deposit action.
+ */
+exports.DepositSchema = zod_1.z
+    .object({
+    assets: zod_1.z
+        .string()
+        .regex(/^\d+(\.\d+)?$/, "Must be a valid integer or decimal value")
+        .describe("The quantity of assets to deposit, in whole units"),
+    receiver: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The address that will own the position on the vault which will receive the shares"),
+    tokenAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The address of the assets token to approve for deposit"),
+    vaultAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The address of the Morpho Vault to deposit to"),
+})
+    .describe("Input schema for Morpho Vault deposit action");
+/**
+ * Input schema for Morpho Vault withdraw action.
+ */
+exports.WithdrawSchema = zod_1.z
+    .object({
+    vaultAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The address of the Morpho Vault to withdraw from"),
+    assets: zod_1.z
+        .string()
+        .regex(/^\d+$/, "Must be a valid whole number")
+        .describe("The amount of assets to withdraw in atomic units e.g. 1"),
+    receiver: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The address to receive the shares"),
+})
+    .strip()
+    .describe("Input schema for Morpho Vault withdraw action");

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./openseaActionProvider"), exports);

package/dist/action-providers/opensea/openseaActionProvider.d.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { ListNftSchema, GetNftsByAccountSchema } from "./schemas";
+import { Network } from "../../network";
+import { EvmWalletProvider } from "../../wallet-providers";
+/**
+ * Configuration options for the OpenseaActionProvider.
+ */
+export interface OpenseaActionProviderConfig {
+    /**
+     * OpenSea API Key.
+     */
+    apiKey?: string;
+    /**
+     * The network ID to use for the OpenseaActionProvider.
+     */
+    networkId?: string;
+    /**
+     * The private key to use for the OpenseaActionProvider.
+     */
+    privateKey?: string;
+}
+/**
+ * OpenseaActionProvider is an action provider for OpenSea marketplace interactions.
+ */
+export declare class OpenseaActionProvider extends ActionProvider<EvmWalletProvider> {
+    private readonly apiKey;
+    private walletWithProvider;
+    private openseaSDK;
+    private openseaBaseUrl;
+    /**
+     * Constructor for the OpenseaActionProvider class.
+     *
+     * @param config - The configuration options for the OpenseaActionProvider.
+     */
+    constructor(config?: OpenseaActionProviderConfig);
+    /**
+     * Lists an NFT for sale on OpenSea.
+     *
+     * @param args - The input arguments for the action.
+     * @returns A message containing the listing details.
+     */
+    listNft(args: z.infer<typeof ListNftSchema>): Promise<string>;
+    /**
+     * Fetch NFTs of a specific wallet address.
+     *
+     * @param args - The input arguments for the action.
+     * @returns A JSON string containing the NFTs or error message
+     */
+    getNftsByAccount(args: z.infer<typeof GetNftsByAccountSchema>): Promise<string>;
+    /**
+     * Checks if the Opensea action provider supports the given network.
+     *
+     * @param network - The network to check.
+     * @returns True if the Opensea action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+export declare const openseaActionProvider: (config?: OpenseaActionProviderConfig) => OpenseaActionProvider;

package/dist/action-providers/opensea/openseaActionProvider.js

@@ -0,0 +1,146 @@
+"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.openseaActionProvider = exports.OpenseaActionProvider = void 0;
+const zod_1 = require("zod");
+const actionProvider_1 = require("../actionProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const schemas_1 = require("./schemas");
+const opensea_js_1 = require("opensea-js");
+const network_1 = require("../../network");
+const ethers_1 = require("ethers");
+const utils_1 = require("./utils");
+/**
+ * OpenseaActionProvider is an action provider for OpenSea marketplace interactions.
+ */
+class OpenseaActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the OpenseaActionProvider class.
+     *
+     * @param config - The configuration options for the OpenseaActionProvider.
+     */
+    constructor(config = {}) {
+        super("opensea", []);
+        /**
+         * Checks if the Opensea action provider supports the given network.
+         *
+         * @param network - The network to check.
+         * @returns True if the Opensea action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (network) => network.chainId !== undefined && utils_1.supportedChains[network.chainId] !== undefined;
+        const apiKey = config.apiKey || process.env.OPENSEA_API_KEY;
+        if (!apiKey) {
+            throw new Error("OPENSEA_API_KEY is not configured.");
+        }
+        this.apiKey = apiKey;
+        const chainId = network_1.NETWORK_ID_TO_CHAIN_ID[config.networkId || "base-sepolia"];
+        const provider = ethers_1.ethers.getDefaultProvider(parseInt(chainId));
+        const walletWithProvider = new ethers_1.Wallet(config.privateKey, provider);
+        this.walletWithProvider = walletWithProvider;
+        const openseaSDK = new opensea_js_1.OpenSeaSDK(walletWithProvider, {
+            chain: (0, utils_1.chainIdToOpenseaChain)(chainId),
+            apiKey: this.apiKey,
+        });
+        this.openseaSDK = openseaSDK;
+        this.openseaBaseUrl = this.openseaSDK.api.apiBaseUrl.replace("-api", "").replace("api", "");
+    }
+    /**
+     * Lists an NFT for sale on OpenSea.
+     *
+     * @param args - The input arguments for the action.
+     * @returns A message containing the listing details.
+     */
+    async listNft(args) {
+        try {
+            const expirationTime = Math.round(Date.now() / 1000 + args.expirationDays * 24 * 60 * 60);
+            await this.openseaSDK.createListing({
+                asset: {
+                    tokenId: args.tokenId,
+                    tokenAddress: args.contractAddress,
+                },
+                startAmount: args.price,
+                quantity: 1,
+                paymentTokenAddress: "0x0000000000000000000000000000000000000000", // ETH
+                expirationTime,
+                accountAddress: this.walletWithProvider.address,
+            });
+            const listingLink = `${this.openseaBaseUrl}/assets/${this.openseaSDK.chain}/${args.contractAddress}/${args.tokenId}`;
+            return `Successfully listed NFT ${args.contractAddress} token ${args.tokenId} for ${args.price} ETH, expiring in ${args.expirationDays} days. Listing on OpenSea: ${listingLink}.`;
+        }
+        catch (error) {
+            return `Error listing NFT ${args.contractAddress} token ${args.tokenId} for ${args.price} ETH using account ${this.walletWithProvider.address}: ${error}`;
+        }
+    }
+    /**
+     * Fetch NFTs of a specific wallet address.
+     *
+     * @param args - The input arguments for the action.
+     * @returns A JSON string containing the NFTs or error message
+     */
+    async getNftsByAccount(args) {
+        try {
+            const address = args.accountAddress || this.walletWithProvider.address;
+            const { nfts } = await this.openseaSDK.api.getNFTsByAccount(address);
+            return JSON.stringify(nfts);
+        }
+        catch (error) {
+            const address = args.accountAddress || this.walletWithProvider.address;
+            return `Error fetching NFTs for account ${address}: ${error}`;
+        }
+    }
+}
+exports.OpenseaActionProvider = OpenseaActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "list_nft",
+        description: `
+This tool will list an NFT for sale on the OpenSea marketplace. 
+EVM networks are supported on mainnet and testnets.
+
+It takes the following inputs:
+- contractAddress: The NFT contract address to list
+- tokenId: The ID of the NFT to list
+- price: The price in ETH for which the NFT will be listed
+- expirationDays: (Optional) Number of days the listing should be active for (default: 90)
+
+Important notes:
+- The wallet must own the NFT
+- Price is in ETH (e.g., 1.5 for 1.5 ETH). This is the amount the seller will receive if the NFT is sold. It is not required to have this amount in the wallet.
+- Listing the NFT requires approval for OpenSea to manage the entire NFT collection:  
+  - If the collection is not already approved, an onchain transaction is required, which will incur gas fees.  
+  - If already approved, listing is gasless and does not require any onchain transaction. 
+  - EVM networks are supported on mainnet and testnets, for example: base-mainnet and base-sepolia.
+  `,
+        schema: schemas_1.ListNftSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], OpenseaActionProvider.prototype, "listNft", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_nfts_by_account",
+        description: `
+This tool will fetch NFTs owned by a specific wallet address on OpenSea.
+
+It takes the following inputs:
+- accountAddress: (Optional) The wallet address to fetch NFTs for. If not provided, uses the connected wallet address.
+
+The tool will return a JSON string containing the NFTs owned by the specified address.
+    `,
+        schema: schemas_1.GetNftsByAccountSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], OpenseaActionProvider.prototype, "getNftsByAccount", null);
+const openseaActionProvider = (config) => new OpenseaActionProvider(config);
+exports.openseaActionProvider = openseaActionProvider;

package/dist/action-providers/opensea/openseaActionProvider.test.d.ts

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