@zoralabs/coins-sdk 0.5.0 → 0.5.2

package/src/uploader/providers/zora.ts

@@ -1,8 +1,11 @@
 import { Address } from "viem";
-import { Uploader, UploadResult } from "../types";
+import { Uploader, UploadOptions, UploadResult } from "../types";
 import { getApiKey } from "../../api/api-key";
 import { setCreateUploadJwt } from "../../api/internal";
 
+const JWT_TTL_MS = 1000 * 60 * 60; // 1 hour
+const JWT_FETCH_TIMEOUT_MS = 15_000; // 15 seconds
+
 /**
  * Zora IPFS uploader implementation
  */
@@ -18,7 +21,12 @@ export class ZoraUploader implements Uploader {
   private jwtApiKey: string | undefined;
   private jwtApiKeyExpiresAt: number | undefined;
 
-  async getJWTApiKey() {
+  private invalidateJwt() {
+    this.jwtApiKey = undefined;
+    this.jwtApiKeyExpiresAt = undefined;
+  }
+
+  private async getJWTApiKey(signal?: AbortSignal) {
     if (
       this.jwtApiKey &&
       this.jwtApiKeyExpiresAt &&
@@ -26,36 +34,70 @@ export class ZoraUploader implements Uploader {
     ) {
       return this.jwtApiKey;
     }
-    // Expires in 1 hour
-    this.jwtApiKeyExpiresAt = Date.now() + 1000 * 60 * 60;
 
-    const response = await setCreateUploadJwt({
-      creatorAddress: this.creatorAddress,
-    });
+    const jwtSignal = AbortSignal.timeout(JWT_FETCH_TIMEOUT_MS);
+    const combinedSignal = signal
+      ? AbortSignal.any([signal, jwtSignal])
+      : jwtSignal;
+
+    const response = await setCreateUploadJwt(
+      {
+        creatorAddress: this.creatorAddress,
+      },
+      { signal: combinedSignal },
+    );
     this.jwtApiKey = response.data?.createUploadJwtFromApiKey;
     if (!this.jwtApiKey) {
       throw new Error("Failed to create upload JWT");
     }
 
+    this.jwtApiKeyExpiresAt = Date.now() + JWT_TTL_MS;
+
     return this.jwtApiKey;
   }
 
-  async upload(file: File): Promise<UploadResult> {
-    const jwtApiKey = await this.getJWTApiKey();
+  private buildUploadSignal(options?: UploadOptions): AbortSignal | undefined {
+    const { signal, timeout } = options ?? {};
+    if (signal && timeout) {
+      return AbortSignal.any([signal, AbortSignal.timeout(timeout)]);
+    }
+    if (timeout) {
+      return AbortSignal.timeout(timeout);
+    }
+    return signal;
+  }
+
+  private async doUpload(
+    file: File,
+    jwt: string,
+    signal?: AbortSignal,
+  ): Promise<Response> {
     const formData = new FormData();
     formData.append("file", file, file.name);
 
-    const response = await fetch(
-      "https://ipfs-uploader.zora.co/api/v0/add?cid-version=1",
-      {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${jwtApiKey}`,
-          Accept: "*/*",
-        },
-        body: formData,
+    return fetch("https://ipfs-uploader.zora.co/api/v0/add?cid-version=1", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${jwt}`,
+        Accept: "*/*",
       },
-    );
+      body: formData,
+      signal,
+    });
+  }
+
+  async upload(file: File, options?: UploadOptions): Promise<UploadResult> {
+    const uploadSignal = this.buildUploadSignal(options);
+
+    const jwt = await this.getJWTApiKey(uploadSignal);
+    let response = await this.doUpload(file, jwt, uploadSignal);
+
+    // On 401, refresh the JWT exactly once and retry
+    if (response.status === 401) {
+      this.invalidateJwt();
+      const freshJwt = await this.getJWTApiKey(uploadSignal);
+      response = await this.doUpload(file, freshJwt, uploadSignal);
+    }
 
     if (!response.ok) {
       console.error(await response.text());

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

@@ -10,6 +10,45 @@ global.fetch = mockFetch;
 console.log = vi.fn();
 console.error = vi.fn();
 
+function mockJwtResponse(jwt = "test-jwt-token") {
+  return {
+    ok: true,
+    headers: new Headers({
+      "Content-Type": "application/json",
+      "Content-Length": "1000",
+    }),
+    json: async () => ({
+      createUploadJwtFromApiKey: jwt,
+    }),
+  };
+}
+
+function mockUploadResponse(
+  cid = "bafybeiguslukdujd22p7ix53rcszgbg4ine464g33zk2st3lnjpx4uvmri",
+) {
+  return {
+    ok: true,
+    status: 200,
+    headers: new Headers({
+      "Content-Type": "application/json",
+    }),
+    json: async () => ({
+      cid,
+      size: 100,
+      mimeType: "image/png",
+    }),
+  };
+}
+
+function mock401Response() {
+  return {
+    ok: false,
+    status: 401,
+    statusText: "Unauthorized",
+    text: async () => "Unauthorized",
+  };
+}
+
 describe("ZoraUploader", () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -31,36 +70,15 @@ describe("ZoraUploader", () => {
 
   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",
-          }),
-        });
+        .mockResolvedValueOnce(mockJwtResponse())
+        .mockResolvedValueOnce(mockUploadResponse());
 
       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",
@@ -72,7 +90,6 @@ describe("ZoraUploader", () => {
         }),
       );
 
-      // Verify result
       expect(result).toEqual({
         url: "ipfs://bafybeiguslukdujd22p7ix53rcszgbg4ine464g33zk2st3lnjpx4uvmri",
         size: 100,
@@ -80,23 +97,65 @@ describe("ZoraUploader", () => {
       });
     });
 
-    it("should throw an error if upload fails", async () => {
-      // Mock failed response
+    it("should throw an error if upload fails with non-401 status", async () => {
+      mockFetch.mockResolvedValueOnce(mockJwtResponse()).mockResolvedValueOnce({
+        ok: false,
+        status: 400,
+        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",
+      );
+
+      // Should NOT retry on non-401 errors
+      expect(mockFetch).toHaveBeenCalledTimes(2); // 1 JWT + 1 upload
+    });
+
+    it("should retry once on 401 with a fresh JWT", async () => {
+      mockFetch
+        // First JWT fetch
+        .mockResolvedValueOnce(mockJwtResponse("stale-jwt"))
+        // First upload returns 401
+        .mockResolvedValueOnce(mock401Response())
+        // Second JWT fetch (refresh)
+        .mockResolvedValueOnce(mockJwtResponse("fresh-jwt"))
+        // Retry upload succeeds
+        .mockResolvedValueOnce(mockUploadResponse());
+
+      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);
+
+      expect(mockFetch).toHaveBeenCalledTimes(4); // 2 JWT + 2 upload
+
+      // Verify the retry used the fresh JWT
+      const lastUploadCall = mockFetch.mock.calls[3];
+      expect(lastUploadCall[1].headers.Authorization).toBe("Bearer fresh-jwt");
+
+      expect(result).toEqual({
+        url: "ipfs://bafybeiguslukdujd22p7ix53rcszgbg4ine464g33zk2st3lnjpx4uvmri",
+        size: 100,
+        mimeType: "image/png",
+      });
+    });
+
+    it("should throw if retry after 401 also fails", async () => {
       mockFetch
-        .mockResolvedValueOnce({
-          ok: true,
-          headers: new Headers({
-            "Content-Type": "application/json",
-            "Content-Length": "1000",
-          }),
-          json: async () => ({
-            createUploadJwtFromApiKey: "test-jwt-token",
-          }),
-        })
+        .mockResolvedValueOnce(mockJwtResponse("stale-jwt"))
+        .mockResolvedValueOnce(mock401Response())
+        .mockResolvedValueOnce(mockJwtResponse("also-bad-jwt"))
         .mockResolvedValueOnce({
           ok: false,
-          statusText: "Bad Request",
-          text: async () => "Invalid file",
+          status: 403,
+          statusText: "Forbidden",
+          text: async () => "Forbidden",
         });
 
       setApiKey("test-api-key");
@@ -107,17 +166,78 @@ describe("ZoraUploader", () => {
         "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",
-          }),
-        }),
-      );
+      expect(mockFetch).toHaveBeenCalledTimes(4);
+    });
+
+    it("should reuse cached JWT for subsequent uploads", async () => {
+      mockFetch
+        .mockResolvedValueOnce(mockJwtResponse())
+        .mockResolvedValueOnce(mockUploadResponse())
+        .mockResolvedValueOnce(mockUploadResponse());
+
+      setApiKey("test-api-key");
+      const uploader = new ZoraUploader("0x123");
+      const file1 = new File(["test1"], "test1.png", { type: "image/png" });
+      const file2 = new File(["test2"], "test2.png", { type: "image/png" });
+
+      await uploader.upload(file1);
+      await uploader.upload(file2);
+
+      // Only 1 JWT fetch + 2 uploads
+      expect(mockFetch).toHaveBeenCalledTimes(3);
+    });
+
+    it("should pass signal to upload request", async () => {
+      mockFetch
+        .mockResolvedValueOnce(mockJwtResponse())
+        .mockResolvedValueOnce(mockUploadResponse());
+
+      setApiKey("test-api-key");
+      const uploader = new ZoraUploader("0x123");
+      const file = new File(["test"], "test.png", { type: "image/png" });
+      const controller = new AbortController();
+
+      await uploader.upload(file, { signal: controller.signal });
+
+      const uploadCall = mockFetch.mock.calls[1];
+      expect(uploadCall[1].signal).toBe(controller.signal);
+    });
+
+    it("should pass timeout as AbortSignal to upload request", async () => {
+      mockFetch
+        .mockResolvedValueOnce(mockJwtResponse())
+        .mockResolvedValueOnce(mockUploadResponse());
+
+      setApiKey("test-api-key");
+      const uploader = new ZoraUploader("0x123");
+      const file = new File(["test"], "test.png", { type: "image/png" });
+
+      await uploader.upload(file, { timeout: 30_000 });
+
+      const uploadCall = mockFetch.mock.calls[1];
+      expect(uploadCall[1].signal).toBeDefined();
+    });
+
+    it("should pass combined signal when both signal and timeout are provided", async () => {
+      mockFetch
+        .mockResolvedValueOnce(mockJwtResponse())
+        .mockResolvedValueOnce(mockUploadResponse());
+
+      setApiKey("test-api-key");
+      const uploader = new ZoraUploader("0x123");
+      const file = new File(["test"], "test.png", { type: "image/png" });
+      const controller = new AbortController();
+
+      await uploader.upload(file, {
+        signal: controller.signal,
+        timeout: 30_000,
+      });
+
+      const uploadCall = mockFetch.mock.calls[1];
+      // When both signal and timeout are provided, AbortSignal.any() is used
+      // so the resulting signal is different from the original
+      expect(uploadCall[1].signal).toBeDefined();
+      expect(uploadCall[1].signal).not.toBe(controller.signal);
     });
   });
 

package/src/uploader/types.ts

@@ -13,11 +13,21 @@ export type UploadResult = {
   mimeType: string | undefined;
 };
 
+/**
+ * Options for file upload operations
+ */
+export type UploadOptions = {
+  /** AbortSignal to cancel the upload */
+  signal?: AbortSignal;
+  /** Timeout in milliseconds for the upload request (no default) */
+  timeout?: number;
+};
+
 /**
  * Interface for file uploaders (IPFS, Arweave, etc.)
  */
 export interface Uploader {
-  upload(file: File): Promise<UploadResult>;
+  upload(file: File, options?: UploadOptions): Promise<UploadResult>;
 }
 
 export type CreateMetadataParameters = {