@zoralabs/coins-sdk 0.2.3 → 0.2.5

package/src/uploader/tests/metadata.test.ts

@@ -0,0 +1,331 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import {
+  CoinMetadataBuilder,
+  validateImageMimeType,
+  getURLFromUploadResult,
+} from "../metadata";
+import { Uploader, UploadResult } from "../types";
+
+enum UploadResultType {
+  Image = "image",
+  Media = "media",
+  Metadata = "metadata",
+}
+
+// Create a mock implementation of the Uploader interface
+const createMockUploader = (resultList: UploadResultType[]) => {
+  // Pre-defined results to return from the upload method
+  const mockImageResult: UploadResult = {
+    url: "ipfs://image-cid",
+    size: 100,
+    mimeType: "image/png",
+  };
+
+  const mockMediaResult: UploadResult = {
+    url: "ipfs://media-cid",
+    size: 200,
+    mimeType: "video/mp4",
+  };
+
+  const mockMetadataResult: UploadResult = {
+    url: "ipfs://metadata-cid",
+    size: 300,
+    mimeType: "application/json",
+  };
+
+  const uploadedFiles: File[] = [];
+  let callCount = 0;
+
+  const mockUploader: Uploader = {
+    upload: vi.fn(async (file: File): Promise<UploadResult> => {
+      uploadedFiles.push(file);
+      callCount++;
+
+      switch (resultList[callCount - 1]) {
+        case UploadResultType.Image:
+          return mockImageResult;
+        case UploadResultType.Media:
+          return mockMediaResult;
+        case UploadResultType.Metadata:
+          return mockMetadataResult;
+        default:
+          throw new Error(`Invalid result type: ${resultList[callCount - 1]}`);
+      }
+    }),
+  };
+
+  return {
+    uploader: mockUploader,
+    uploadedFiles,
+    mockImageResult,
+    mockMediaResult,
+    mockMetadataResult,
+    reset: () => {
+      callCount = 0;
+      uploadedFiles.length = 0;
+      vi.clearAllMocks();
+    },
+  };
+};
+
+describe("validateImageMimeType", () => {
+  it("should not throw for valid image types", () => {
+    const validTypes = [
+      "image/png",
+      "image/jpeg",
+      "image/jpg",
+      "image/gif",
+      "image/svg+xml",
+    ];
+
+    validTypes.forEach((type) => {
+      expect(() => validateImageMimeType(type)).not.toThrow();
+    });
+  });
+
+  it("should throw for invalid image types", () => {
+    const invalidTypes = ["image/webp", "application/pdf", "text/plain"];
+
+    invalidTypes.forEach((type) => {
+      expect(() => validateImageMimeType(type)).toThrow(
+        "Image must be a PNG, JPEG, JPG, GIF or SVG",
+      );
+    });
+  });
+});
+
+describe("getURLFromUploadResult", () => {
+  it("should convert an upload result URL to a URL object", () => {
+    const result: UploadResult = {
+      url: "ipfs://bafybeiguslukdujd22p7ix53rcszgbg4ine464g33zk2st3lnjpx4uvmri",
+      size: 100,
+      mimeType: "image/png",
+    };
+
+    const url = getURLFromUploadResult(result);
+    expect(url).toBeInstanceOf(URL);
+    expect(url.toString()).toBe(
+      "ipfs://bafybeiguslukdujd22p7ix53rcszgbg4ine464g33zk2st3lnjpx4uvmri",
+    );
+  });
+
+  it("should throw for invalid URLs", () => {
+    const result: UploadResult = {
+      url: "invalid-url",
+      size: 100,
+      mimeType: "image/png",
+    };
+
+    expect(() => getURLFromUploadResult(result)).toThrow();
+  });
+});
+
+describe("CoinMetadataBuilder", () => {
+  let mockUploaderData: ReturnType<typeof createMockUploader>;
+  let builder: CoinMetadataBuilder;
+
+  beforeEach(() => {
+    mockUploaderData = createMockUploader([
+      UploadResultType.Image,
+      UploadResultType.Media,
+      UploadResultType.Metadata,
+    ]);
+    builder = new CoinMetadataBuilder();
+  });
+
+  describe("builder methods", () => {
+    it("should set name and return self", () => {
+      const result = builder.withName("Test Coin");
+      expect(result).toBe(builder);
+    });
+
+    it("should set symbol and return self", () => {
+      const result = builder.withSymbol("TEST");
+      expect(result).toBe(builder);
+    });
+
+    it("should set description and return self", () => {
+      const result = builder.withDescription("Test Description");
+      expect(result).toBe(builder);
+    });
+
+    it("should set image file and return self", () => {
+      const imageFile = new File(["test"], "test.png", { type: "image/png" });
+      const result = builder.withImage(imageFile);
+      expect(result).toBe(builder);
+    });
+
+    it("should throw if image URL is already set when setting image file", () => {
+      builder.withImageURI("ipfs://test");
+      const imageFile = new File(["test"], "test.png", { type: "image/png" });
+      expect(() => builder.withImage(imageFile)).toThrow(
+        "Image URL already set",
+      );
+    });
+
+    it("should throw if image file is already set when setting image URI", () => {
+      const imageFile = new File(["test"], "test.png", { type: "image/png" });
+      builder.withImage(imageFile);
+      expect(() => builder.withImageURI("ipfs://test")).toThrow(
+        "Image file already set",
+      );
+    });
+
+    it("should set media file and return self", () => {
+      const mediaFile = new File(["test"], "test.mp4", { type: "video/mp4" });
+      const result = builder.withMedia(mediaFile);
+      expect(result).toBe(builder);
+    });
+
+    it("should throw if media URL is already set when setting media file", () => {
+      builder.withMediaURI("ipfs://test", "video/mp4");
+      const mediaFile = new File(["test"], "test.mp4", { type: "video/mp4" });
+      expect(() => builder.withMedia(mediaFile)).toThrow(
+        "Media URL already set",
+      );
+    });
+
+    it("should throw if media file is already set when setting media URI", () => {
+      const mediaFile = new File(["test"], "test.mp4", { type: "video/mp4" });
+      builder.withMedia(mediaFile);
+      expect(() => builder.withMediaURI("ipfs://test", "video/mp4")).toThrow(
+        "Media file already set",
+      );
+    });
+
+    it("should set properties and return self", () => {
+      const properties = { key1: "value1", key2: "value2" };
+      const result = builder.withProperties(properties);
+      expect(result).toBe(builder);
+    });
+
+    it("should throw if property value is not a string", () => {
+      const properties = { key1: "value1", key2: 123 as any };
+      expect(() => builder.withProperties(properties)).toThrow(
+        "Property value must be a string",
+      );
+    });
+  });
+
+  describe("validate", () => {
+    it("should throw if name is not set", () => {
+      builder
+        .withSymbol("TEST")
+        .withImage(new File(["test"], "test.png", { type: "image/png" }));
+      expect(() => builder.validate()).toThrow("Name is required");
+    });
+
+    it("should throw if symbol is not set", () => {
+      builder
+        .withName("Test Coin")
+        .withImage(new File(["test"], "test.png", { type: "image/png" }));
+      expect(() => builder.validate()).toThrow("Symbol is required");
+    });
+
+    it("should throw if image is not set", () => {
+      builder.withName("Test Coin").withSymbol("TEST");
+      expect(() => builder.validate()).toThrow("Image is required");
+    });
+
+    it("should not throw if all required fields are set", () => {
+      builder
+        .withName("Test Coin")
+        .withSymbol("TEST")
+        .withImage(new File(["test"], "test.png", { type: "image/png" }));
+
+      expect(() => builder.validate()).not.toThrow();
+    });
+  });
+
+  describe("generateMetadata", () => {
+    it("should generate correct metadata", () => {
+      builder
+        .withName("Test Coin")
+        .withSymbol("TEST")
+        .withDescription("Test Description")
+        .withImageURI("ipfs://image-cid")
+        .withMediaURI("ipfs://media-cid", "video/mp4")
+        .withProperties({ key1: "value1", key2: "value2" });
+
+      const metadata = builder.generateMetadata();
+
+      expect(metadata).toEqual({
+        name: "Test Coin",
+        symbol: "TEST",
+        description: "Test Description",
+        image: "ipfs://image-cid",
+        animation_url: "ipfs://media-cid",
+        content: {
+          uri: "ipfs://media-cid",
+          mime: "video/mp4",
+        },
+        properties: { key1: "value1", key2: "value2" },
+      });
+    });
+  });
+
+  describe("upload", () => {
+    it("should upload image, media and metadata", async () => {
+      const imageFile = new File(["test-image"], "test.png", {
+        type: "image/png",
+      });
+      const mediaFile = new File(["test-media"], "test.mp4", {
+        type: "video/mp4",
+      });
+
+      builder
+        .withName("Test Coin")
+        .withSymbol("TEST")
+        .withDescription("Test Description")
+        .withImage(imageFile)
+        .withMedia(mediaFile)
+        .withProperties({ key1: "value1", key2: "value2" });
+
+      const result = await builder.upload(mockUploaderData.uploader);
+
+      // Verify uploader was called 3 times
+      expect(mockUploaderData.uploader.upload).toHaveBeenCalledTimes(3);
+
+      // Verify files were uploaded in the right order
+      expect(mockUploaderData.uploadedFiles[0]).toBe(imageFile);
+      expect(mockUploaderData.uploadedFiles[1]).toBe(mediaFile);
+      expect(mockUploaderData.uploadedFiles[2]?.type).toBe("application/json");
+
+      // Verify result
+      expect(result.url.toString()).toBe("ipfs://metadata-cid");
+    });
+
+    it("should use existing image and media URLs if provided", async () => {
+      mockUploaderData = createMockUploader([UploadResultType.Metadata]);
+      builder = new CoinMetadataBuilder();
+
+      builder
+        .withName("Test Coin")
+        .withSymbol("TEST")
+        .withDescription("Test Description")
+        .withImageURI("ipfs://existing-image")
+        .withMediaURI("ipfs://existing-media", "video/mp4")
+        .withProperties({ key1: "value1", key2: "value2" });
+
+      const result = await builder.upload(mockUploaderData.uploader);
+
+      // Should only upload metadata (1 upload)
+      expect(mockUploaderData.uploader.upload).toHaveBeenCalledTimes(1);
+
+      // The upload should be the metadata
+      expect(mockUploaderData.uploadedFiles[0]?.type).toBe("application/json");
+
+      // Verify result
+      expect(result.url.toString()).toBe("ipfs://metadata-cid");
+    });
+
+    it("should validate before uploading", async () => {
+      // Missing required fields
+      builder.withName("Test Coin");
+
+      await expect(builder.upload(mockUploaderData.uploader)).rejects.toThrow(
+        "Symbol is required",
+      );
+    });
+  });
+});

package/src/uploader/tests/providers.test.ts

@@ -0,0 +1,131 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { ZoraUploader, createZoraUploaderForCreator } from "../providers/zora";
+import { setApiKey } from "../../api/api-key";
+
+// Mock the fetch function
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+// Mock console methods
+console.log = vi.fn();
+console.error = vi.fn();
+
+describe("ZoraUploader", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockFetch.mockReset();
+    setApiKey(undefined);
+  });
+
+  describe("constructor", () => {
+    it("should initialize with provided API key", () => {
+      setApiKey("test-api-key");
+      const uploader = new ZoraUploader("0x123");
+      expect(uploader).toBeDefined();
+    });
+
+    it("should throw if no API key is available", () => {
+      expect(() => new ZoraUploader("0x123")).toThrow("API key is required");
+    });
+  });
+
+  describe("upload", () => {
+    it("should successfully upload a file with the zora uploader", async () => {
+      // Mock JWT token creation response
+      mockFetch
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers({
+            "Content-Type": "application/json",
+            "Content-Length": "1000",
+          }),
+          json: async () => ({
+            createUploadJwtFromApiKey: "test-jwt-token",
+          }),
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers({
+            "Content-Type": "application/json",
+          }),
+          json: async () => ({
+            cid: "bafybeiguslukdujd22p7ix53rcszgbg4ine464g33zk2st3lnjpx4uvmri",
+            size: 100,
+            mimeType: "image/png",
+          }),
+        });
+
+      setApiKey("test-api-key");
+      const uploader = new ZoraUploader("0x123");
+      const file = new File(["test"], "test.png", { type: "image/png" });
+      const result = await uploader.upload(file);
+
+      // Verify fetch was called with correct parameters
+      expect(mockFetch).toHaveBeenCalledTimes(2);
+      expect(mockFetch).toHaveBeenCalledWith(
+        "https://ipfs-uploader.zora.co/api/v0/add?cid-version=1",
+        expect.objectContaining({
+          method: "POST",
+          headers: expect.objectContaining({
+            Authorization: "Bearer test-jwt-token",
+          }),
+        }),
+      );
+
+      // Verify result
+      expect(result).toEqual({
+        url: "ipfs://bafybeiguslukdujd22p7ix53rcszgbg4ine464g33zk2st3lnjpx4uvmri",
+        size: 100,
+        mimeType: "image/png",
+      });
+    });
+
+    it("should throw an error if upload fails", async () => {
+      // Mock failed response
+      mockFetch
+        .mockResolvedValueOnce({
+          ok: true,
+          headers: new Headers({
+            "Content-Type": "application/json",
+            "Content-Length": "1000",
+          }),
+          json: async () => ({
+            createUploadJwtFromApiKey: "test-jwt-token",
+          }),
+        })
+        .mockResolvedValueOnce({
+          ok: false,
+          statusText: "Bad Request",
+          text: async () => "Invalid file",
+        });
+
+      setApiKey("test-api-key");
+      const uploader = new ZoraUploader("0x123");
+      const file = new File(["test"], "test.png", { type: "image/png" });
+
+      await expect(uploader.upload(file)).rejects.toThrow(
+        "Failed to upload file",
+      );
+
+      // Verify fetch was called with correct parameters
+      expect(mockFetch).toHaveBeenCalledTimes(2);
+      expect(mockFetch).toHaveBeenCalledWith(
+        "https://ipfs-uploader.zora.co/api/v0/add?cid-version=1",
+        expect.objectContaining({
+          method: "POST",
+          headers: expect.objectContaining({
+            Authorization: "Bearer test-jwt-token",
+          }),
+        }),
+      );
+    });
+  });
+
+  describe("factory function", () => {
+    it("should create a ZoraUploader instance", () => {
+      setApiKey("test-api-key");
+      const uploader = createZoraUploaderForCreator("0x123");
+      expect(uploader).toBeInstanceOf(ZoraUploader);
+    });
+  });
+});

package/src/uploader/types.ts

@@ -0,0 +1,27 @@
+export type ValidMetadataURI =
+  | `ipfs://${string}`
+  | `ar://${string}`
+  | `data:${string}`
+  | `https://${string}`;
+
+/**
+ * Result from uploading a file to a storage provider
+ */
+export type UploadResult = {
+  url: ValidMetadataURI;
+  size: number | undefined;
+  mimeType: string | undefined;
+};
+
+/**
+ * Interface for file uploaders (IPFS, Arweave, etc.)
+ */
+export interface Uploader {
+  upload(file: File): Promise<UploadResult>;
+}
+
+export type CreateMetadataParameters = {
+  name: string;
+  symbol: string;
+  uri: `ipfs://${string}`;
+};

package/src/utils/getPrepurchaseHook.ts

@@ -0,0 +1,59 @@
+import {
+  encodeBuySupplyWithMultiHopSwapRouterHookCall,
+  wethAddress,
+} from "@zoralabs/protocol-deployments";
+import { InitialPurchaseCurrency } from "../actions/createCoin";
+import { Address, concat, Hex, pad, toHex } from "viem";
+import { ZORA_ADDRESS } from "./poolConfigUtils";
+import { base } from "viem/chains";
+
+const BASE_UDSC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+
+const USDC_ZORA_FEE = 3000;
+const WETH_BASE_FEE = 3000;
+
+const encodeFee = (fee: number) => pad(toHex(fee), { size: 3 });
+
+export const getPrepurchaseHook = async ({
+  payoutRecipient,
+  initialPurchase,
+  chainId,
+}: {
+  initialPurchase: {
+    currency: InitialPurchaseCurrency;
+    amount: bigint;
+    amountOutMinimum?: bigint;
+  };
+  payoutRecipient: Address;
+  chainId: number;
+}) => {
+  if (
+    initialPurchase.currency !== InitialPurchaseCurrency.ETH &&
+    chainId !== base.id
+  ) {
+    throw new Error("Initial purchase currency and/or chain not supported");
+  }
+
+  const path = concat([
+    wethAddress[base.id],
+    encodeFee(WETH_BASE_FEE),
+    BASE_UDSC_ADDRESS,
+    encodeFee(USDC_ZORA_FEE),
+    ZORA_ADDRESS,
+  ]);
+
+  return encodeBuySupplyWithMultiHopSwapRouterHookCall({
+    ethValue: initialPurchase.amount,
+    buyRecipient: payoutRecipient,
+    exactInputParams: {
+      path,
+      amountIn: initialPurchase.amount,
+      amountOutMinimum: initialPurchase.amountOutMinimum || 0n,
+    },
+    chainId: base.id,
+  }) as {
+    hook: Address;
+    hookData: Hex;
+    value: bigint;
+  };
+};

package/dist/actions/tradeCoin.d.ts

@@ -1,75 +0,0 @@
-import { coinABI } from "@zoralabs/protocol-deployments";
-import { Address, TransactionReceipt, WalletClient, SimulateContractParameters, ContractEventArgsFromTopics } from "viem";
-import { GenericPublicClient } from "src/utils/genericPublicClient";
-export type SellEventArgs = ContractEventArgsFromTopics<typeof coinABI, "CoinSell">;
-export type BuyEventArgs = ContractEventArgsFromTopics<typeof coinABI, "CoinBuy">;
-export type TradeEventArgs = SellEventArgs | BuyEventArgs;
-/**
- * Simulates a buy order to get the expected output amount
- * @param {Object} params - The simulation parameters
- * @param {Address} params.target - The target coin contract address
- * @param {bigint} params.requestedOrderSize - The desired input amount for the buy
- * @param {PublicClient} params.publicClient - The viem public client instance
- * @returns {Promise<{orderSize: bigint, amountOut: bigint}>} The simulated order size and output amount
- */
-export declare function simulateBuy({ target, requestedOrderSize, publicClient, }: {
-    target: Address;
-    requestedOrderSize: bigint;
-    publicClient: GenericPublicClient;
-}): Promise<{
-    orderSize: bigint;
-    amountOut: bigint;
-}>;
-/**
- * Parameters for creating a trade call
- * @typedef {Object} TradeParams
- * @property {'sell' | 'buy'} direction - The trade direction
- * @property {Address} target - The target coin contract address
- * @property {Object} args - The trade arguments
- * @property {Address} args.recipient - The recipient of the trade output
- * @property {bigint} args.orderSize - The size of the order
- * @property {bigint} [args.minAmountOut] - The minimum amount to receive
- * @property {bigint} [args.sqrtPriceLimitX96] - The price limit for the trade
- * @property {Address} [args.tradeReferrer] - The referrer address for the trade
- */
-export type TradeParams = {
-    direction: "sell" | "buy";
-    target: Address;
-    args: {
-        recipient: Address;
-        orderSize: bigint;
-        minAmountOut?: bigint;
-        sqrtPriceLimitX96?: bigint;
-        tradeReferrer?: Address;
-    };
-};
-/**
- * Creates a trade call parameters object for buy or sell
- * @param {TradeParams} params - The trade parameters
- * @returns {SimulateContractParameters} The contract call parameters
- */
-export declare function tradeCoinCall({ target, direction, args: { recipient, orderSize, minAmountOut, sqrtPriceLimitX96, tradeReferrer, }, }: TradeParams): SimulateContractParameters;
-/**
- * Gets the trade event from transaction receipt logs
- * @param {TransactionReceipt} receipt - The transaction receipt containing the logs
- * @param {'buy' | 'sell'} direction - The direction of the trade
- * @returns {TradeEventArgs | undefined} The decoded trade event args if found
- */
-export declare function getTradeFromLogs(receipt: TransactionReceipt, direction: "buy" | "sell"): TradeEventArgs | undefined;
-/**
- * Executes a trade transaction
- * @param {TradeParams} params - The trade parameters
- * @param {PublicClient} publicClient - The viem public client instance
- * @param {WalletClient} walletClient - The viem wallet client instance
- * @returns {Promise<{
- *   hash: `0x${string}`,
- *   receipt: TransactionReceipt,
- *   trade: TradeEventArgs | undefined
- * }>} The transaction result with trade details
- */
-export declare function tradeCoin(params: TradeParams, walletClient: WalletClient, publicClient: GenericPublicClient): Promise<{
-    hash: `0x${string}`;
-    receipt: any;
-    trade: TradeEventArgs | undefined;
-}>;
-//# sourceMappingURL=tradeCoin.d.ts.map

package/dist/actions/tradeCoin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tradeCoin.d.ts","sourceRoot":"","sources":["../../src/actions/tradeCoin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAEzD,OAAO,EACL,OAAO,EACP,kBAAkB,EAClB,YAAY,EACZ,0BAA0B,EAG1B,2BAA2B,EAE5B,MAAM,MAAM,CAAC;AAEd,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAIpE,MAAM,MAAM,aAAa,GAAG,2BAA2B,CACrD,OAAO,OAAO,EACd,UAAU,CACX,CAAC;AACF,MAAM,MAAM,YAAY,GAAG,2BAA2B,CACpD,OAAO,OAAO,EACd,SAAS,CACV,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG,YAAY,CAAC;AAO1D;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,EAChC,MAAM,EACN,kBAAkB,EAClB,YAAY,GACb,EAAE;IACD,MAAM,EAAE,OAAO,CAAC;IAChB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,YAAY,EAAE,mBAAmB,CAAC;CACnC,GAAG,OAAO,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAwBpD;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,SAAS,EAAE,MAAM,GAAG,KAAK,CAAC;IAC1B,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE;QACJ,SAAS,EAAE,OAAO,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,aAAa,CAAC,EAAE,OAAO,CAAC;KACzB,CAAC;CACH,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,EAC5B,MAAM,EACN,SAAS,EACT,IAAI,EAAE,EACJ,SAAS,EACT,SAAS,EACT,YAAiB,EACjB,iBAAsB,EACtB,aAA2B,GAC5B,GACF,EAAE,WAAW,GAAG,0BAA0B,CAc1C;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,KAAK,GAAG,MAAM,GACxB,cAAc,GAAG,SAAS,CAU5B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,SAAS,CAC7B,MAAM,EAAE,WAAW,EACnB,YAAY,EAAE,YAAY,EAC1B,YAAY,EAAE,mBAAmB;;;;GAgBlC"}