@coinbase/agentkit 0.2.3-nightly.20250305.26 → 0.2.3-nightly.20250307.28

package/README.md

@@ -248,6 +248,19 @@ const agent = createReactAgent({
 </table>
 </details>
 <details>
+<summary><strong>Opensea</strong></summary>
+<table width="100%">
+<tr>
+    <td width="200"><code>list_nft</code></td>
+    <td width="768">Lists an NFT for sale on OpenSea.</td>
+</tr>
+<tr>
+    <td width="200"><code>get_nfts_by_account</code></td>
+    <td width="768">Fetches NFTs owned by a specific wallet address on OpenSea.</td>
+</tr>
+</table>
+</details>
+<details>
 <summary><strong>Pyth</strong></summary>
 <table width="100%">
 <tr>

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

@@ -3,10 +3,6 @@ export declare const ERC721_ABI: readonly [{
         readonly internalType: "address";
         readonly name: "to";
         readonly type: "address";
-    }, {
-        readonly internalType: "uint256";
-        readonly name: "tokenId";
-        readonly type: "uint256";
     }];
     readonly name: "mint";
     readonly outputs: readonly [];

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

@@ -3,10 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ERC721_ABI = void 0;
 exports.ERC721_ABI = [
     {
-        inputs: [
-            { internalType: "address", name: "to", type: "address" },
-            { internalType: "uint256", name: "tokenId", type: "uint256" },
-        ],
+        inputs: [{ internalType: "address", name: "to", type: "address" }],
         name: "mint",
         outputs: [],
         payable: false,

package/dist/action-providers/erc721/erc721ActionProvider.js

@@ -46,7 +46,7 @@ class Erc721ActionProvider extends actionProvider_1.ActionProvider {
             const data = (0, viem_1.encodeFunctionData)({
                 abi: constants_1.ERC721_ABI,
                 functionName: "mint",
-                args: [args.destination, 1n],
+                args: [args.destination],
             });
             const hash = await walletProvider.sendTransaction({
                 to: args.contractAddress,

package/dist/action-providers/erc721/erc721ActionProvider.test.js

@@ -34,7 +34,7 @@ describe("ERC721 Action Provider", () => {
                 data: (0, viem_1.encodeFunctionData)({
                     abi: constants_1.ERC721_ABI,
                     functionName: "mint",
-                    args: [MOCK_DESTINATION, 1n],
+                    args: [MOCK_DESTINATION],
                 }),
             });
             expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledWith("0xmockhash");

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

@@ -12,6 +12,7 @@ export * from "./jupiter";
 export * from "./pyth";
 export * from "./moonwell";
 export * from "./morpho";
+export * from "./opensea";
 export * from "./spl";
 export * from "./twitter";
 export * from "./wallet";

package/dist/action-providers/index.js

@@ -28,6 +28,7 @@ __exportStar(require("./jupiter"), exports);
 __exportStar(require("./pyth"), exports);
 __exportStar(require("./moonwell"), exports);
 __exportStar(require("./morpho"), exports);
+__exportStar(require("./opensea"), exports);
 __exportStar(require("./spl"), exports);
 __exportStar(require("./twitter"), exports);
 __exportStar(require("./wallet"), exports);

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 {};

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

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const opensea_js_1 = require("opensea-js");
+const openseaActionProvider_1 = require("./openseaActionProvider");
+jest.mock("opensea-js");
+describe("OpenSea Action Provider", () => {
+    const MOCK_API_KEY = "test-api-key";
+    const MOCK_PRIVATE_KEY = "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+    const MOCK_CONTRACT = "0x1234567890123456789012345678901234567890";
+    const MOCK_TOKEN_ID = "1";
+    const MOCK_PRICE = 0.1;
+    const MOCK_EXPIRATION_DAYS = 90;
+    const MOCK_OPENSEA_BASE_URL = "https://testnets.opensea.io";
+    const MOCK_OPENSEA_CHAIN = "base_sepolia";
+    let actionProvider;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Mock OpenSeaSDK constructor
+        opensea_js_1.OpenSeaSDK.mockImplementation(() => ({
+            createListing: jest.fn(),
+            api: {
+                apiBaseUrl: MOCK_OPENSEA_BASE_URL,
+                getNFTsByAccount: jest.fn(),
+            },
+            chain: MOCK_OPENSEA_CHAIN,
+        }));
+        actionProvider = (0, openseaActionProvider_1.openseaActionProvider)({
+            apiKey: MOCK_API_KEY,
+            privateKey: MOCK_PRIVATE_KEY,
+            networkId: "base-sepolia",
+        });
+    });
+    describe("listNft", () => {
+        it("should successfully list an NFT", async () => {
+            const mockListing = {};
+            const mockCreateListing = jest.fn().mockResolvedValue(mockListing);
+            // Update the mock implementation with the mock function
+            opensea_js_1.OpenSeaSDK.mockImplementation(() => ({
+                createListing: mockCreateListing,
+                api: {
+                    apiBaseUrl: MOCK_OPENSEA_BASE_URL,
+                },
+                chain: MOCK_OPENSEA_CHAIN,
+            }));
+            // Re-create provider with new mock
+            actionProvider = (0, openseaActionProvider_1.openseaActionProvider)({
+                apiKey: MOCK_API_KEY,
+                privateKey: MOCK_PRIVATE_KEY,
+                networkId: "base-sepolia",
+            });
+            const args = {
+                contractAddress: MOCK_CONTRACT,
+                tokenId: MOCK_TOKEN_ID,
+                price: MOCK_PRICE,
+                expirationDays: MOCK_EXPIRATION_DAYS,
+            };
+            const response = await actionProvider.listNft(args);
+            expect(mockCreateListing).toHaveBeenCalledWith(expect.objectContaining({
+                asset: {
+                    tokenId: MOCK_TOKEN_ID,
+                    tokenAddress: MOCK_CONTRACT,
+                },
+                startAmount: MOCK_PRICE,
+                quantity: 1,
+            }));
+            expect(response).toBe(`Successfully listed NFT ${MOCK_CONTRACT} token ${MOCK_TOKEN_ID} for ${MOCK_PRICE} ETH, expiring in ${MOCK_EXPIRATION_DAYS} days. Listing on OpenSea: ${MOCK_OPENSEA_BASE_URL}/assets/${MOCK_OPENSEA_CHAIN}/${MOCK_CONTRACT}/${MOCK_TOKEN_ID}.`);
+        });
+        it("should handle listing errors", async () => {
+            const error = new Error("Listing failed");
+            const mockCreateListing = jest.fn().mockRejectedValue(error);
+            // Update the mock implementation with the mock function
+            opensea_js_1.OpenSeaSDK.mockImplementation(() => ({
+                createListing: mockCreateListing,
+                api: {
+                    apiBaseUrl: MOCK_OPENSEA_BASE_URL,
+                },
+                chain: MOCK_OPENSEA_CHAIN,
+            }));
+            // Re-create provider with new mock
+            actionProvider = (0, openseaActionProvider_1.openseaActionProvider)({
+                apiKey: MOCK_API_KEY,
+                privateKey: MOCK_PRIVATE_KEY,
+                networkId: "base-sepolia",
+            });
+            const args = {
+                contractAddress: MOCK_CONTRACT,
+                tokenId: MOCK_TOKEN_ID,
+                price: MOCK_PRICE,
+                expirationDays: MOCK_EXPIRATION_DAYS,
+            };
+            const response = await actionProvider.listNft(args);
+            expect(response).toContain(`Error listing NFT ${MOCK_CONTRACT} token ${MOCK_TOKEN_ID}`);
+            expect(response).toContain(error.message);
+        });
+    });
+    describe("getNftsByAccount", () => {
+        const MOCK_WALLET_ADDRESS = "0xabcdef1234567890abcdef1234567890abcdef12";
+        const MOCK_NFTS = [
+            {
+                identifier: "1",
+                contract: MOCK_CONTRACT,
+                name: "Test NFT 1",
+            },
+            {
+                identifier: "2",
+                contract: MOCK_CONTRACT,
+                name: "Test NFT 2",
+            },
+        ];
+        it("should successfully fetch NFTs for the specified account", async () => {
+            const mockGetNFTsByAccount = jest.fn().mockResolvedValue({ nfts: MOCK_NFTS });
+            // Update the mock implementation with the mock function
+            opensea_js_1.OpenSeaSDK.mockImplementation(() => ({
+                createListing: jest.fn(),
+                api: {
+                    apiBaseUrl: MOCK_OPENSEA_BASE_URL,
+                    getNFTsByAccount: mockGetNFTsByAccount,
+                },
+                chain: MOCK_OPENSEA_CHAIN,
+            }));
+            // Re-create provider with new mock
+            actionProvider = (0, openseaActionProvider_1.openseaActionProvider)({
+                apiKey: MOCK_API_KEY,
+                privateKey: MOCK_PRIVATE_KEY,
+                networkId: "base-sepolia",
+            });
+            const args = {
+                accountAddress: MOCK_WALLET_ADDRESS,
+            };
+            const response = await actionProvider.getNftsByAccount(args);
+            expect(mockGetNFTsByAccount).toHaveBeenCalledWith(MOCK_WALLET_ADDRESS);
+            expect(response).toBe(JSON.stringify(MOCK_NFTS));
+        });
+        it("should use connected wallet address when no account is specified", async () => {
+            const mockGetNFTsByAccount = jest.fn().mockResolvedValue({ nfts: MOCK_NFTS });
+            // Update the mock implementation with the mock function
+            opensea_js_1.OpenSeaSDK.mockImplementation(() => ({
+                createListing: jest.fn(),
+                api: {
+                    apiBaseUrl: MOCK_OPENSEA_BASE_URL,
+                    getNFTsByAccount: mockGetNFTsByAccount,
+                },
+                chain: MOCK_OPENSEA_CHAIN,
+            }));
+            // Re-create provider with new mock
+            actionProvider = (0, openseaActionProvider_1.openseaActionProvider)({
+                apiKey: MOCK_API_KEY,
+                privateKey: MOCK_PRIVATE_KEY,
+                networkId: "base-sepolia",
+            });
+            const args = {}; // No accountAddress provided
+            const response = await actionProvider.getNftsByAccount(args);
+            // Should use the wallet address from the provider
+            expect(mockGetNFTsByAccount).toHaveBeenCalled();
+            expect(response).toBe(JSON.stringify(MOCK_NFTS));
+        });
+        it("should handle errors when fetching NFTs", async () => {
+            const error = new Error("Failed to fetch NFTs");
+            const mockGetNFTsByAccount = jest.fn().mockRejectedValue(error);
+            // Update the mock implementation with the mock function
+            opensea_js_1.OpenSeaSDK.mockImplementation(() => ({
+                createListing: jest.fn(),
+                api: {
+                    apiBaseUrl: MOCK_OPENSEA_BASE_URL,
+                    getNFTsByAccount: mockGetNFTsByAccount,
+                },
+                chain: MOCK_OPENSEA_CHAIN,
+            }));
+            // Re-create provider with new mock
+            actionProvider = (0, openseaActionProvider_1.openseaActionProvider)({
+                apiKey: MOCK_API_KEY,
+                privateKey: MOCK_PRIVATE_KEY,
+                networkId: "base-sepolia",
+            });
+            const args = {
+                accountAddress: MOCK_WALLET_ADDRESS,
+            };
+            const response = await actionProvider.getNftsByAccount(args);
+            expect(mockGetNFTsByAccount).toHaveBeenCalledWith(MOCK_WALLET_ADDRESS);
+            expect(response).toContain(`Error fetching NFTs for account ${MOCK_WALLET_ADDRESS}`);
+            expect(response).toContain(error.message);
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for supported networks", () => {
+            const baseSepoliaNetwork = {
+                protocolFamily: "evm",
+                networkId: "base-sepolia",
+                chainId: "84532",
+            };
+            expect(actionProvider.supportsNetwork(baseSepoliaNetwork)).toBe(true);
+        });
+        it("should return false for unsupported networks", () => {
+            const fantomNetwork = {
+                protocolFamily: "bitcoin",
+                networkId: "any",
+            };
+            expect(actionProvider.supportsNetwork(fantomNetwork)).toBe(false);
+        });
+    });
+});

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

@@ -0,0 +1,30 @@
+import { z } from "zod";
+/**
+ * Input schema for listing an NFT on OpenSea.
+ */
+export declare const ListNftSchema: z.ZodObject<{
+    contractAddress: z.ZodString;
+    tokenId: z.ZodString;
+    price: z.ZodNumber;
+    expirationDays: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    contractAddress: string;
+    price: number;
+    tokenId: string;
+    expirationDays: number;
+}, {
+    contractAddress: string;
+    price: number;
+    tokenId: string;
+    expirationDays?: number | undefined;
+}>;
+/**
+ * Input schema for getting NFTs from a specific wallet address.
+ */
+export declare const GetNftsByAccountSchema: z.ZodObject<{
+    accountAddress: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    accountAddress?: string | undefined;
+}, {
+    accountAddress?: string | undefined;
+}>;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetNftsByAccountSchema = exports.ListNftSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for listing an NFT on OpenSea.
+ */
+exports.ListNftSchema = zod_1.z
+    .object({
+    contractAddress: zod_1.z.string().nonempty().describe("The NFT contract address to list"),
+    tokenId: zod_1.z.string().nonempty().describe("The tokenID of the NFT to list"),
+    price: zod_1.z.number().positive().describe("The price in ETH to list the NFT for"),
+    expirationDays: zod_1.z
+        .number()
+        .positive()
+        .optional()
+        .default(90)
+        .describe("Number of days the listing should be active for (default: 90)"),
+})
+    .strip()
+    .describe("Input schema for listing an NFT on OpenSea");
+/**
+ * Input schema for getting NFTs from a specific wallet address.
+ */
+exports.GetNftsByAccountSchema = zod_1.z
+    .object({
+    accountAddress: zod_1.z
+        .string()
+        .optional()
+        .describe("The wallet address to fetch NFTs for (defaults to connected wallet if not provided)"),
+})
+    .strip()
+    .describe("Input schema for fetching NFTs by account");

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

@@ -0,0 +1,12 @@
+import { Chain } from "opensea-js";
+/**
+ * Supported Opensea chains
+ */
+export declare const supportedChains: Record<string, Chain>;
+/**
+ * Maps EVM chain IDs to Opensea chain
+ *
+ * @param chainId - The EVM chain ID to map
+ * @returns The corresponding OpenSea Chain enum value
+ */
+export declare const chainIdToOpenseaChain: (chainId: string) => Chain;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chainIdToOpenseaChain = exports.supportedChains = void 0;
+const opensea_js_1 = require("opensea-js");
+/**
+ * Supported Opensea chains
+ */
+exports.supportedChains = {
+    "1": opensea_js_1.Chain.Mainnet,
+    "137": opensea_js_1.Chain.Polygon,
+    "80002": opensea_js_1.Chain.Amoy,
+    "11155111": opensea_js_1.Chain.Sepolia,
+    "8217": opensea_js_1.Chain.Klaytn,
+    "1001": opensea_js_1.Chain.Baobab,
+    "43114": opensea_js_1.Chain.Avalanche,
+    "43113": opensea_js_1.Chain.Fuji,
+    "42161": opensea_js_1.Chain.Arbitrum,
+    "42170": opensea_js_1.Chain.ArbitrumNova,
+    "421614": opensea_js_1.Chain.ArbitrumSepolia,
+    "238": opensea_js_1.Chain.Blast,
+    "168587773": opensea_js_1.Chain.BlastSepolia,
+    "8453": opensea_js_1.Chain.Base,
+    "84532": opensea_js_1.Chain.BaseSepolia,
+    "10": opensea_js_1.Chain.Optimism,
+    "11155420": opensea_js_1.Chain.OptimismSepolia,
+    "7777777": opensea_js_1.Chain.Zora,
+    "999999999": opensea_js_1.Chain.ZoraSepolia,
+    "1329": opensea_js_1.Chain.Sei,
+    "1328": opensea_js_1.Chain.SeiTestnet,
+    "8333": opensea_js_1.Chain.B3,
+    "1993": opensea_js_1.Chain.B3Sepolia,
+    "80094": opensea_js_1.Chain.BeraChain,
+};
+/**
+ * Maps EVM chain IDs to Opensea chain
+ *
+ * @param chainId - The EVM chain ID to map
+ * @returns The corresponding OpenSea Chain enum value
+ */
+const chainIdToOpenseaChain = (chainId) => {
+    const chain = exports.supportedChains[chainId];
+    if (!chain) {
+        throw new Error(`Unsupported chain ID on Opensea: ${chainId}`);
+    }
+    return chain;
+};
+exports.chainIdToOpenseaChain = chainIdToOpenseaChain;

package/dist/wallet-providers/cdpWalletProvider.d.ts

@@ -227,5 +227,11 @@ export declare class CdpWalletProvider extends EvmWalletProvider {
      * @returns The wallet's data.
      */
     exportWallet(): Promise<WalletData>;
+    /**
+     * Gets the wallet.
+     *
+     * @returns The wallet.
+     */
+    getWallet(): Wallet;
 }
 export {};

package/dist/wallet-providers/cdpWalletProvider.js

@@ -381,6 +381,17 @@ class CdpWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         }
         return __classPrivateFieldGet(this, _CdpWalletProvider_cdpWallet, "f").export();
     }
+    /**
+     * Gets the wallet.
+     *
+     * @returns The wallet.
+     */
+    getWallet() {
+        if (!__classPrivateFieldGet(this, _CdpWalletProvider_cdpWallet, "f")) {
+            throw new Error("Wallet not initialized");
+        }
+        return __classPrivateFieldGet(this, _CdpWalletProvider_cdpWallet, "f");
+    }
 }
 exports.CdpWalletProvider = CdpWalletProvider;
 _CdpWalletProvider_cdpWallet = new WeakMap(), _CdpWalletProvider_address = new WeakMap(), _CdpWalletProvider_network = new WeakMap(), _CdpWalletProvider_publicClient = new WeakMap(), _CdpWalletProvider_gasLimitMultiplier = new WeakMap(), _CdpWalletProvider_feePerGasMultiplier = new WeakMap();

package/package.json

@@ -2,7 +2,7 @@
   "name": "@coinbase/agentkit",
   "description": "Coinbase AgentKit core primitives",
   "repository": "https://github.com/coinbase/agentkit",
-  "version": "0.2.3-nightly.20250305.26",
+  "version": "0.2.3-nightly.20250307.28",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -46,6 +46,7 @@
     "@solana/spl-token": "^0.4.12",
     "@solana/web3.js": "^1.98.0",
     "md5": "^2.3.0",
+    "opensea-js": "^7.1.18",
     "reflect-metadata": "^0.2.2",
     "twitter-api-v2": "^1.18.2",
     "viem": "^2.22.16",
@@ -53,21 +54,21 @@
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
-    "@types/secp256k1": "^4.0.6",
     "@types/nunjucks": "^3.2.6",
     "@types/ora": "^3.2.0",
     "@types/prompts": "^2.4.9",
+    "@types/secp256k1": "^4.0.6",
     "http-server": "^14.1.1",
     "jest": "^29.7.0",
     "mock-fs": "^5.2.0",
-    "ts-jest": "^29.2.5",
-    "tsd": "^0.31.2",
-    "typescript": "^5.7.2",
     "nunjucks": "^3.2.4",
     "ora": "^7.0.1",
-    "prompts": "^2.4.2",
     "picocolors": "^1.0.0",
-    "tsx": "^4.7.1"
+    "prompts": "^2.4.2",
+    "ts-jest": "^29.2.5",
+    "tsd": "^0.31.2",
+    "tsx": "^4.7.1",
+    "typescript": "^5.7.2"
   },
   "exports": {
     ".": {