@coinbase/agentkit 0.0.0-nightly-20250717210412 → 0.0.0-nightly-20250725210423

package/dist/action-providers/weth/wethActionProvider.js

@@ -58,6 +58,30 @@ class WethActionProvider extends actionProvider_1.ActionProvider {
             return `Error wrapping ETH: ${error}`;
         }
     }
+    /**
+     * Unwraps WETH to ETH.
+     *
+     * @param walletProvider - The wallet provider to use for the action.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the transaction hash.
+     */
+    async unwrapEth(walletProvider, args) {
+        try {
+            const hash = await walletProvider.sendTransaction({
+                to: constants_1.WETH_ADDRESS,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.WETH_ABI,
+                    functionName: "withdraw",
+                    args: [BigInt(args.amountToUnwrap)],
+                }),
+            });
+            await walletProvider.waitForTransactionReceipt(hash);
+            return `Unwrapped WETH with transaction hash: ${hash}`;
+        }
+        catch (error) {
+            return `Error unwrapping WETH: ${error}`;
+        }
+    }
 }
 exports.WethActionProvider = WethActionProvider;
 __decorate([
@@ -74,7 +98,7 @@ Important notes:
 - The amount is a string and cannot have any decimal points, since the unit of measurement is wei.
 - Make sure to use the exact amount provided, and if there's any doubt, check by getting more information before continuing with the action.
 - 1 wei = 0.000000000000000001 WETH
-- Minimum purchase amount is 100000000000000 wei (0.0000001 WETH)
+- Minimum purchase amount is 100000000000 wei (0.0000001 WETH)
 - Only supported on the following networks:
   - Base Sepolia (ie, 'base-sepolia')
   - Base Mainnet (ie, 'base', 'base-mainnet')
@@ -85,5 +109,30 @@ Important notes:
     __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], WethActionProvider.prototype, "wrapEth", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "unwrap_eth",
+        description: `
+    This tool can only be used to unwrap WETH to ETH.
+Do not use this tool for any other purpose, or trading other assets.
+
+Inputs:
+- Amount of WETH to unwrap.
+
+Important notes:
+- The amount is a string and cannot have any decimal points, since the unit of measurement is wei.
+- Make sure to use the exact amount provided, and if there's any doubt, check by getting more information before continuing with the action.
+- 1 wei = 0.000000000000000001 WETH
+- Minimum unwrap amount is 100000000000 wei (0.0000001 WETH)
+- Only supported on the following networks:
+  - Base Sepolia (ie, 'base-sepolia')
+  - Base Mainnet (ie, 'base', 'base-mainnet')
+`,
+        schema: schemas_1.UnwrapEthSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], WethActionProvider.prototype, "unwrapEth", null);
 const wethActionProvider = () => new WethActionProvider();
 exports.wethActionProvider = wethActionProvider;

package/dist/action-providers/weth/wethActionProvider.test.js

@@ -21,6 +21,21 @@ describe("Wrap Eth Schema", () => {
         expect(result.success).toBe(false);
     });
 });
+describe("Unwrap Eth Schema", () => {
+    it("should successfully parse valid input", () => {
+        const validInput = {
+            amountToUnwrap: MOCK_AMOUNT,
+        };
+        const result = schemas_1.UnwrapEthSchema.safeParse(validInput);
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual(validInput);
+    });
+    it("should fail parsing empty input", () => {
+        const emptyInput = {};
+        const result = schemas_1.UnwrapEthSchema.safeParse(emptyInput);
+        expect(result.success).toBe(false);
+    });
+});
 describe("Wrap Eth Action", () => {
     let mockWallet;
     const actionProvider = (0, wethActionProvider_1.wethActionProvider)();
@@ -66,6 +81,51 @@ describe("Wrap Eth Action", () => {
         expect(response).toContain(`Error wrapping ETH: ${error}`);
     });
 });
+describe("Unwrap Eth Action", () => {
+    let mockWallet;
+    const actionProvider = (0, wethActionProvider_1.wethActionProvider)();
+    beforeEach(async () => {
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            sendTransaction: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+        };
+    });
+    it("should successfully respond", async () => {
+        const args = {
+            amountToUnwrap: MOCK_AMOUNT,
+        };
+        const hash = "0x1234567890123456789012345678901234567890";
+        mockWallet.sendTransaction.mockResolvedValue(hash);
+        const response = await actionProvider.unwrapEth(mockWallet, args);
+        expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+            to: constants_1.WETH_ADDRESS,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: constants_1.WETH_ABI,
+                functionName: "withdraw",
+                args: [BigInt(MOCK_AMOUNT)],
+            }),
+        });
+        expect(response).toContain(`Unwrapped WETH with transaction hash: ${hash}`);
+    });
+    it("should fail with an error", async () => {
+        const args = {
+            amountToUnwrap: MOCK_AMOUNT,
+        };
+        const error = new Error("Failed to unwrap WETH");
+        mockWallet.sendTransaction.mockRejectedValue(error);
+        const response = await actionProvider.unwrapEth(mockWallet, args);
+        expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+            to: constants_1.WETH_ADDRESS,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: constants_1.WETH_ABI,
+                functionName: "withdraw",
+                args: [BigInt(MOCK_AMOUNT)],
+            }),
+        });
+        expect(response).toContain(`Error unwrapping WETH: ${error}`);
+    });
+});
 describe("supportsNetwork", () => {
     const actionProvider = (0, wethActionProvider_1.wethActionProvider)();
     it("should return true for base-mainnet", () => {

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

@@ -15,85 +15,49 @@ export declare const HttpRequestSchema: z.ZodObject<{
     body?: any;
     headers?: Record<string, string> | null | undefined;
 }>;
-export declare const RetryWithX402Schema: z.ZodObject<z.objectUtil.extendShape<{
+export declare const RetryWithX402Schema: z.ZodObject<{
     url: z.ZodString;
     method: z.ZodDefault<z.ZodNullable<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>>>;
-    headers: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
-    body: z.ZodNullable<z.ZodOptional<z.ZodAny>>;
-}, {
-    paymentOption: z.ZodObject<{
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    body: z.ZodOptional<z.ZodAny>;
+    selectedPaymentOption: z.ZodObject<{
         scheme: z.ZodString;
         network: z.ZodString;
         maxAmountRequired: z.ZodString;
-        resource: z.ZodString;
-        description: z.ZodString;
-        mimeType: z.ZodString;
-        outputSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
-        payTo: z.ZodString;
-        maxTimeoutSeconds: z.ZodNumber;
         asset: z.ZodString;
-        extra: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
     }, "strip", z.ZodTypeAny, {
-        description: string;
         scheme: string;
         network: string;
         asset: string;
         maxAmountRequired: string;
-        resource: string;
-        mimeType: string;
-        outputSchema: Record<string, any>;
-        payTo: string;
-        maxTimeoutSeconds: number;
-        extra?: Record<string, any> | null | undefined;
     }, {
-        description: string;
         scheme: string;
         network: string;
         asset: string;
         maxAmountRequired: string;
-        resource: string;
-        mimeType: string;
-        outputSchema: Record<string, any>;
-        payTo: string;
-        maxTimeoutSeconds: number;
-        extra?: Record<string, any> | null | undefined;
     }>;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     method: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | null;
     url: string;
-    paymentOption: {
-        description: string;
+    selectedPaymentOption: {
         scheme: string;
         network: string;
         asset: string;
         maxAmountRequired: string;
-        resource: string;
-        mimeType: string;
-        outputSchema: Record<string, any>;
-        payTo: string;
-        maxTimeoutSeconds: number;
-        extra?: Record<string, any> | null | undefined;
     };
     body?: any;
-    headers?: Record<string, string> | null | undefined;
+    headers?: Record<string, string> | undefined;
 }, {
     url: string;
-    paymentOption: {
-        description: string;
+    selectedPaymentOption: {
         scheme: string;
         network: string;
         asset: string;
         maxAmountRequired: string;
-        resource: string;
-        mimeType: string;
-        outputSchema: Record<string, any>;
-        payTo: string;
-        maxTimeoutSeconds: number;
-        extra?: Record<string, any> | null | undefined;
     };
     method?: "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | null | undefined;
     body?: any;
-    headers?: Record<string, string> | null | undefined;
+    headers?: Record<string, string> | undefined;
 }>;
 export declare const DirectX402RequestSchema: z.ZodObject<{
     url: z.ZodString;

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

@@ -2,9 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DirectX402RequestSchema = exports.RetryWithX402Schema = exports.HttpRequestSchema = void 0;
 const zod_1 = require("zod");
-// Base schema for HTTP requests
-const BaseHttpRequestSchema = zod_1.z.object({
-    url: zod_1.z.string().url().describe("The URL of the API endpoint (can be localhost for development)"),
+// Schema for initial HTTP request
+exports.HttpRequestSchema = zod_1.z
+    .object({
+    url: zod_1.z
+        .string()
+        .url()
+        .describe("The URL of the API endpoint (can be localhost for development)"),
     method: zod_1.z
         .enum(["GET", "POST", "PUT", "DELETE", "PATCH"])
         .nullable()
@@ -15,29 +19,61 @@ const BaseHttpRequestSchema = zod_1.z.object({
         .optional()
         .nullable()
         .describe("Optional headers to include in the request"),
-    body: zod_1.z.any().optional().nullable().describe("Optional request body for POST/PUT/PATCH requests"),
-});
-// Schema for initial HTTP request
-exports.HttpRequestSchema = BaseHttpRequestSchema.strip().describe("Instructions for making a basic HTTP request");
+    body: zod_1.z
+        .any()
+        .optional()
+        .nullable()
+        .describe("Optional request body for POST/PUT/PATCH requests"),
+})
+    .strip()
+    .describe("Instructions for making a basic HTTP request");
 // Schema for retrying a failed request with x402 payment
-exports.RetryWithX402Schema = BaseHttpRequestSchema.extend({
-    paymentOption: zod_1.z
+exports.RetryWithX402Schema = zod_1.z
+    .object({
+    url: zod_1.z
+        .string()
+        .url()
+        .describe("The URL of the API endpoint (can be localhost for development)"),
+    method: zod_1.z
+        .enum(["GET", "POST", "PUT", "DELETE", "PATCH"])
+        .nullable()
+        .default("GET")
+        .describe("The HTTP method to use for the request"),
+    headers: zod_1.z.record(zod_1.z.string()).optional().describe("Optional headers to include in the request"),
+    body: zod_1.z.any().optional().describe("Optional request body for POST/PUT/PATCH requests"),
+    selectedPaymentOption: zod_1.z
         .object({
         scheme: zod_1.z.string(),
         network: zod_1.z.string(),
         maxAmountRequired: zod_1.z.string(),
-        resource: zod_1.z.string(),
-        description: zod_1.z.string(),
-        mimeType: zod_1.z.string(),
-        outputSchema: zod_1.z.record(zod_1.z.any()),
-        payTo: zod_1.z.string(),
-        maxTimeoutSeconds: zod_1.z.number(),
         asset: zod_1.z.string(),
-        extra: zod_1.z.record(zod_1.z.any()).optional().nullable(),
     })
         .describe("The payment option to use for this request"),
 })
     .strip()
     .describe("Instructions for retrying a request with x402 payment after receiving a 402 response");
 // Schema for direct x402 payment request (with warning)
-exports.DirectX402RequestSchema = BaseHttpRequestSchema.strip().describe("Instructions for making an HTTP request with automatic x402 payment handling. WARNING: This bypasses user confirmation - only use when explicitly told to skip confirmation!");
+exports.DirectX402RequestSchema = zod_1.z
+    .object({
+    url: zod_1.z
+        .string()
+        .url()
+        .describe("The URL of the API endpoint (can be localhost for development)"),
+    method: zod_1.z
+        .enum(["GET", "POST", "PUT", "DELETE", "PATCH"])
+        .nullable()
+        .default("GET")
+        .describe("The HTTP method to use for the request"),
+    headers: zod_1.z
+        .record(zod_1.z.string())
+        .optional()
+        .nullable()
+        .describe("Optional headers to include in the request"),
+    body: zod_1.z
+        .any()
+        .optional()
+        .nullable()
+        .describe("Optional request body for POST/PUT/PATCH requests"),
+})
+    .strip()
+    .describe("Instructions for making an HTTP request with automatic x402 payment handling. WARNING: This bypasses user confirmation - only use when explicitly told to skip confirmation!");

package/dist/action-providers/x402/x402ActionProvider.js

@@ -20,7 +20,6 @@ const schemas_1 = require("./schemas");
 const wallet_providers_1 = require("../../wallet-providers");
 const axios_1 = __importDefault(require("axios"));
 const x402_axios_1 = require("x402-axios");
-const types_1 = require("x402/types");
 const SUPPORTED_NETWORKS = ["base-mainnet", "base-sepolia"];
 /**
  * X402ActionProvider provides actions for making HTTP requests, with optional x402 payment handling.
@@ -65,13 +64,12 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
                     data: response.data,
                 }, null, 2);
             }
-            const paymentRequirements = response.data.accepts.map(accept => types_1.PaymentRequirementsSchema.parse(accept));
             return JSON.stringify({
                 status: "error_402_payment_required",
-                acceptablePaymentOptions: paymentRequirements,
+                acceptablePaymentOptions: response.data.accepts,
                 nextSteps: [
                     "Inform the user that the requested server replied with a 402 Payment Required response.",
-                    `The payment options are: ${paymentRequirements.map(option => `${option.asset} ${option.maxAmountRequired} ${option.network}`).join(", ")}`,
+                    `The payment options are: ${response.data.accepts.map(option => `${option.asset} ${option.maxAmountRequired} ${option.network}`).join(", ")}`,
                     "Ask the user if they want to retry the request with payment.",
                     `Use retry_http_request_with_x402 to retry the request with payment.`,
                 ],
@@ -90,20 +88,27 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
      */
     async retryWithX402(walletProvider, args) {
         try {
-            // Validate the payment option matches the URL
-            if (args.paymentOption.resource !== args.url) {
-                return JSON.stringify({
-                    status: "error_invalid_payment_option",
-                    message: "The payment option resource does not match the request URL",
-                    details: {
-                        expected: args.url,
-                        received: args.paymentOption.resource,
-                    },
-                });
-            }
             // Make the request with payment handling
             const account = walletProvider.toSigner();
-            const api = (0, x402_axios_1.withPaymentInterceptor)(axios_1.default.create({}), account);
+            const paymentSelector = (accepts) => {
+                const { scheme, network, maxAmountRequired, asset } = args.selectedPaymentOption;
+                let paymentRequirements = accepts.find(accept => accept.scheme === scheme &&
+                    accept.network === network &&
+                    accept.maxAmountRequired <= maxAmountRequired &&
+                    accept.asset === asset);
+                if (paymentRequirements) {
+                    return paymentRequirements;
+                }
+                paymentRequirements = accepts.find(accept => accept.scheme === scheme &&
+                    accept.network === network &&
+                    accept.maxAmountRequired <= maxAmountRequired &&
+                    accept.asset === asset);
+                if (paymentRequirements) {
+                    return paymentRequirements;
+                }
+                return accepts[0];
+            };
+            const api = (0, x402_axios_1.withPaymentInterceptor)(axios_1.default.create({}), account, paymentSelector);
             const response = await api.request({
                 url: args.url,
                 method: args.method ?? "GET",
@@ -122,9 +127,9 @@ class X402ActionProvider extends actionProvider_1.ActionProvider {
                     url: args.url,
                     method: args.method,
                     paymentUsed: {
-                        network: args.paymentOption.network,
-                        asset: args.paymentOption.asset,
-                        amount: args.paymentOption.maxAmountRequired,
+                        network: args.selectedPaymentOption.network,
+                        asset: args.selectedPaymentOption.asset,
+                        amount: args.selectedPaymentOption.maxAmountRequired,
                     },
                     paymentProof: paymentProof
                         ? {

package/dist/action-providers/x402/x402ActionProvider.test.js

@@ -225,20 +225,15 @@ describe("X402ActionProvider", () => {
             const result = await provider.retryWithX402(mockWalletProvider, {
                 url: "https://www.x402.org/protected",
                 method: "GET",
-                paymentOption: {
+                selectedPaymentOption: {
                     scheme: "exact",
                     network: "base-sepolia",
                     maxAmountRequired: "10000",
-                    resource: "https://www.x402.org/protected",
-                    description: "Access to protected content",
-                    mimeType: "application/json",
-                    payTo: "0x123",
-                    maxTimeoutSeconds: 300,
                     asset: "0x456",
-                    outputSchema: {},
                 },
             });
-            expect(mockWithPaymentInterceptor).toHaveBeenCalledWith(mockAxiosInstance, "mock-signer");
+            // Update expectation to accept the payment selector function
+            expect(mockWithPaymentInterceptor).toHaveBeenCalledWith(mockAxiosInstance, "mock-signer", expect.any(Function));
             const parsedResult = JSON.parse(result);
             expect(parsedResult.status).toBe("success");
             expect(parsedResult.details.paymentProof).toEqual({
@@ -247,26 +242,6 @@ describe("X402ActionProvider", () => {
                 payer: MOCK_PAYMENT_RESPONSE.payer,
             });
         });
-        it("should reject if payment option resource doesn't match URL", async () => {
-            const result = await provider.retryWithX402(mockWalletProvider, {
-                url: "https://www.x402.org/protected",
-                method: "GET",
-                paymentOption: {
-                    scheme: "exact",
-                    network: "base-sepolia",
-                    maxAmountRequired: "10000",
-                    resource: "https://different.url/protected", // Mismatched URL
-                    description: "Access to protected content",
-                    mimeType: "application/json",
-                    payTo: "0x123",
-                    maxTimeoutSeconds: 300,
-                    asset: "0x456",
-                    outputSchema: {},
-                },
-            });
-            const parsedResult = JSON.parse(result);
-            expect(parsedResult.status).toBe("error_invalid_payment_option");
-        });
         it("should handle network errors during payment", async () => {
             const error = new Error("Network error");
             error.isAxiosError = true;
@@ -275,17 +250,11 @@ describe("X402ActionProvider", () => {
             const result = await provider.retryWithX402(mockWalletProvider, {
                 url: "https://www.x402.org/protected",
                 method: "GET",
-                paymentOption: {
+                selectedPaymentOption: {
                     scheme: "exact",
                     network: "base-sepolia",
                     maxAmountRequired: "10000",
-                    resource: "https://www.x402.org/protected",
-                    description: "Access to protected content",
-                    mimeType: "application/json",
-                    payTo: "0x123",
-                    maxTimeoutSeconds: 300,
                     asset: "0x456",
-                    outputSchema: {},
                 },
             });
             const parsedResult = JSON.parse(result);

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

@@ -0,0 +1,3 @@
+export * from "./zoraActionProvider";
+export * from "./schemas";
+export * from "./utils";

package/dist/action-providers/zora/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("./zoraActionProvider"), exports);
+__exportStar(require("./schemas"), exports);
+__exportStar(require("./utils"), exports);

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

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export declare const CreateCoinSchema: z.ZodObject<{
+    name: z.ZodString;
+    symbol: z.ZodString;
+    description: z.ZodString;
+    image: z.ZodString;
+    category: z.ZodDefault<z.ZodString>;
+    payoutRecipient: z.ZodOptional<z.ZodString>;
+    platformReferrer: z.ZodOptional<z.ZodString>;
+    currency: z.ZodDefault<z.ZodEnum<["ZORA", "ETH"]>>;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    name: string;
+    description: string;
+    currency: "ETH" | "ZORA";
+    image: string;
+    category: string;
+    platformReferrer?: string | undefined;
+    payoutRecipient?: string | undefined;
+}, {
+    symbol: string;
+    name: string;
+    description: string;
+    image: string;
+    currency?: "ETH" | "ZORA" | undefined;
+    platformReferrer?: string | undefined;
+    category?: string | undefined;
+    payoutRecipient?: string | undefined;
+}>;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateCoinSchema = void 0;
+const zod_1 = require("zod");
+exports.CreateCoinSchema = zod_1.z
+    .object({
+    name: zod_1.z.string().describe("The name of the coin to create"),
+    symbol: zod_1.z.string().describe("The symbol of the coin to create"),
+    description: zod_1.z.string().describe("The description of the coin"),
+    image: zod_1.z.string().describe("Local image file path or URI (ipfs:// or https://)"),
+    category: zod_1.z
+        .string()
+        .default("social")
+        .describe("The category of the coin, optional, defaults to 'social'"),
+    payoutRecipient: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .optional()
+        .describe("The address that will receive creator earnings, defaults to wallet address"),
+    platformReferrer: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .optional()
+        .describe("The address that will receive platform referrer fees, optional"),
+    currency: zod_1.z
+        .enum(["ZORA", "ETH"])
+        .default("ZORA")
+        .describe("Currency to be used for the trading pair, optional, defaults to 'ZORA'."),
+})
+    .strip()
+    .describe("Instructions for creating a new coin on Zora");

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

@@ -0,0 +1,28 @@
+/**
+ * Configuration for Pinata
+ */
+interface PinataConfig {
+    jwt: string;
+}
+/**
+ * Parameters for generating token URI
+ */
+interface TokenUriParams {
+    name: string;
+    symbol: string;
+    description: string;
+    image: string;
+    category?: string;
+    pinataConfig: PinataConfig;
+}
+/**
+ * Generates a Zora token URI by handling local file or URI
+ *
+ * @param params - Parameters for generating the token URI
+ * @returns A promise that resolves to object containing the IPFS URI
+ */
+export declare function generateZoraTokenUri(params: TokenUriParams): Promise<{
+    uri: string;
+    imageUri: string;
+}>;
+export {};