@zoralabs/coins-sdk 0.2.3 → 0.2.5

package/src/api/internal.ts

@@ -7,16 +7,16 @@ import { getApiKeyMeta } from "./api-key";
 import { RequestOptionsType } from "./query-types";
 import { RequestResult } from "@hey-api/client-fetch";
 
-type SetCreateUploadJwtQuery = SetCreateUploadJwtData["query"];
+type SetCreateUploadJwtQuery = SetCreateUploadJwtData["body"];
 export type { SetCreateUploadJwtQuery, SetCreateUploadJwtData };
 export type { SetCreateUploadJwtResponse } from "../client/types.gen";
 
 export const setCreateUploadJwt = async (
-  query: SetCreateUploadJwtQuery,
+  body: SetCreateUploadJwtQuery,
   options?: RequestOptionsType<SetCreateUploadJwtData>,
 ): Promise<RequestResult<SetCreateUploadJwtResponse>> => {
   return await setCreateUploadJwtSDK({
-    query,
+    body,
     ...getApiKeyMeta(),
     ...options,
   });

package/src/index.ts

@@ -3,16 +3,12 @@ export {
   createCoinCall,
   getCoinCreateFromLogs,
   DeployCurrency,
+  InitialPurchaseCurrency,
+} from "./actions/createCoin";
+export type {
+  CreateCoinArgs,
+  CoinDeploymentLogArgs,
 } from "./actions/createCoin";
-export type { CreateCoinArgs } from "./actions/createCoin";
-
-export {
-  simulateBuy,
-  tradeCoin,
-  tradeCoinCall,
-  getTradeFromLogs,
-} from "./actions/tradeCoin";
-export type { TradeParams } from "./actions/tradeCoin";
 
 export {
   getOnchainCoinDetails,
@@ -31,6 +27,7 @@ export type { UpdatePayoutRecipientArgs } from "./actions/updatePayoutRecipient"
 export * from "./api/queries";
 export type * from "./api/queries";
 
+// API Explore Actions
 export * from "./api/explore";
 export type * from "./api/explore";
 
@@ -39,3 +36,6 @@ export { setApiKey } from "./api/api-key";
 
 // Metadata Validation Utils
 export * from "./metadata";
+
+// Uploader
+export * from "./uploader";

package/src/metadata/cleanAndValidateMetadataURI.ts

@@ -1,8 +1,4 @@
-export type ValidMetadataURI =
-  | `ipfs://${string}`
-  | `ar://${string}`
-  | `data:${string}`
-  | `https://${string}`;
+import { ValidMetadataURI } from "../uploader/types";
 
 /**
  * Clean the metadata URI to HTTPS format

package/src/metadata/index.ts

@@ -1,7 +1,4 @@
-export {
-  cleanAndValidateMetadataURI,
-  type ValidMetadataURI,
-} from "./cleanAndValidateMetadataURI";
+export { cleanAndValidateMetadataURI } from "./cleanAndValidateMetadataURI";
 export { validateMetadataJSON } from "./validateMetadataJSON";
 export type { ValidMetadataJSON } from "./validateMetadataJSON";
 export { validateMetadataURIContent } from "./validateMetadataURIContent";

package/src/metadata/validateMetadataURIContent.ts

@@ -1,7 +1,5 @@
-import {
-  cleanAndValidateMetadataURI,
-  ValidMetadataURI,
-} from "./cleanAndValidateMetadataURI";
+import { cleanAndValidateMetadataURI } from "./cleanAndValidateMetadataURI";
+import { ValidMetadataURI } from "../uploader/types";
 import { validateMetadataJSON } from "./validateMetadataJSON";
 
 /**

package/src/uploader/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Uploader package for storing files on IPFS and other decentralized storage
+ * @packageDocumentation
+ */
+
+// Export core types
+export * from "./types";
+
+// Export the metadata builder
+export * from "./metadata";
+
+// Export all providers
+export * from "./providers/zora";
+
+export { createMetadataBuilder } from "./metadata";
+export { createZoraUploaderForCreator } from "./providers/zora";

package/src/uploader/metadata.ts

@@ -0,0 +1,214 @@
+import {
+  CreateMetadataParameters,
+  Uploader,
+  UploadResult,
+  ValidMetadataURI,
+} from "./types";
+
+type Metadata = {
+  name: string;
+  symbol: string;
+  description: string;
+  image: string;
+  properties?: Record<string, string>;
+  animation_url?: string;
+  content?: {
+    uri: string;
+    mime: string | undefined;
+  };
+};
+
+export function validateImageMimeType(mimeType: string) {
+  if (
+    ![
+      "image/png",
+      "image/jpeg",
+      "image/jpg",
+      "image/gif",
+      "image/svg+xml",
+    ].includes(mimeType)
+  ) {
+    throw new Error("Image must be a PNG, JPEG, JPG, GIF or SVG");
+  }
+}
+
+export function getURLFromUploadResult(uploadResult: UploadResult) {
+  return new URL(uploadResult.url);
+}
+
+export class CoinMetadataBuilder {
+  private name: string | undefined;
+  private description: string | undefined;
+  private symbol: string | undefined;
+  private imageFile: File | undefined;
+  private imageURL: URL | undefined;
+  private mediaFile: File | undefined;
+  private mediaURL: URL | undefined;
+  private mediaMimeType: string | undefined;
+  private properties: Record<string, string> | undefined;
+
+  withName(name: string) {
+    this.name = name;
+    if (typeof name !== "string") {
+      throw new Error("Name must be a string");
+    }
+
+    return this;
+  }
+
+  withSymbol(symbol: string) {
+    this.symbol = symbol;
+    if (typeof symbol !== "string") {
+      throw new Error("Symbol must be a string");
+    }
+
+    return this;
+  }
+
+  withDescription(description: string) {
+    this.description = description;
+    if (typeof description !== "string") {
+      throw new Error("Description must be a string");
+    }
+
+    return this;
+  }
+
+  withImage(image: File) {
+    if (this.imageURL) {
+      throw new Error("Image URL already set");
+    }
+    if (!(image instanceof File)) {
+      throw new Error("Image must be a File");
+    }
+    validateImageMimeType(image.type);
+    this.imageFile = image;
+
+    return this;
+  }
+
+  withImageURI(imageURI: string) {
+    if (this.imageFile) {
+      throw new Error("Image file already set");
+    }
+    if (typeof imageURI !== "string") {
+      throw new Error("Image URI must be a string");
+    }
+    const url = new URL(imageURI);
+    this.imageURL = url;
+
+    return this;
+  }
+
+  withProperties(properties: Record<string, string>) {
+    for (const [key, value] of Object.entries(properties)) {
+      if (typeof key !== "string") {
+        throw new Error("Property key must be a string");
+      }
+      if (typeof value !== "string") {
+        throw new Error("Property value must be a string");
+      }
+    }
+    if (!this.properties) {
+      this.properties = {};
+    }
+    this.properties = { ...this.properties, ...properties };
+
+    return this;
+  }
+
+  withMedia(media: File) {
+    if (this.mediaURL) {
+      throw new Error("Media URL already set");
+    }
+    if (!(media instanceof File)) {
+      throw new Error("Media must be a File");
+    }
+    this.mediaMimeType = media.type;
+    this.mediaFile = media;
+
+    return this;
+  }
+
+  withMediaURI(mediaURI: string, mediaMimeType: string | undefined) {
+    if (this.mediaFile) {
+      throw new Error("Media file already set");
+    }
+    if (typeof mediaURI !== "string") {
+      throw new Error("Media URI must be a string");
+    }
+    const url = new URL(mediaURI);
+    this.mediaURL = url;
+    this.mediaMimeType = mediaMimeType;
+
+    return this;
+  }
+
+  validate() {
+    if (!this.name) {
+      throw new Error("Name is required");
+    }
+    if (!this.symbol) {
+      throw new Error("Symbol is required");
+    }
+    if (!this.imageFile && !this.imageURL) {
+      throw new Error("Image is required");
+    }
+
+    return this;
+  }
+
+  generateMetadata(): Metadata {
+    return {
+      name: this.name!,
+      symbol: this.symbol!,
+      description: this.description!,
+      image: this.imageURL!.toString(),
+      animation_url: this.mediaURL?.toString(),
+      content: this.mediaURL
+        ? {
+            uri: this.mediaURL?.toString(),
+            mime: this.mediaMimeType,
+          }
+        : undefined,
+      properties: this.properties,
+    };
+  }
+
+  async upload(uploader: Uploader): Promise<{
+    url: ValidMetadataURI;
+    createMetadataParameters: CreateMetadataParameters;
+    metadata: Metadata;
+  }> {
+    this.validate();
+
+    if (this.imageFile) {
+      const uploadResult = await uploader.upload(this.imageFile);
+      this.imageURL = getURLFromUploadResult(uploadResult);
+    }
+    if (this.mediaFile) {
+      const uploadResult = await uploader.upload(this.mediaFile);
+      this.mediaURL = getURLFromUploadResult(uploadResult);
+    }
+    const metadata = this.generateMetadata();
+    const uploadResult = await uploader.upload(
+      new File([JSON.stringify(metadata)], "metadata.json", {
+        type: "application/json",
+      }),
+    );
+
+    return {
+      url: getURLFromUploadResult(uploadResult).toString() as ValidMetadataURI,
+      createMetadataParameters: {
+        name: this.name!,
+        symbol: this.symbol!,
+        uri: uploadResult.url as `ipfs://${string}`,
+      },
+      metadata,
+    };
+  }
+}
+
+export function createMetadataBuilder() {
+  return new CoinMetadataBuilder();
+}

package/src/uploader/providers/zora.ts

@@ -0,0 +1,86 @@
+import { Address } from "viem";
+import { Uploader, UploadResult } from "../types";
+import { getApiKey } from "../../api/api-key";
+import { setCreateUploadJwt } from "../../api/internal";
+
+/**
+ * Zora IPFS uploader implementation
+ */
+export class ZoraUploader implements Uploader {
+  constructor(creatorAddress: Address) {
+    this.creatorAddress = creatorAddress;
+    if (!getApiKey()) {
+      throw new Error("API key is required for metadata interactions");
+    }
+  }
+
+  private creatorAddress: Address;
+  private jwtApiKey: string | undefined;
+  private jwtApiKeyExpiresAt: number | undefined;
+
+  async getJWTApiKey() {
+    if (
+      this.jwtApiKey &&
+      this.jwtApiKeyExpiresAt &&
+      this.jwtApiKeyExpiresAt > Date.now()
+    ) {
+      return this.jwtApiKey;
+    }
+    // Expires in 1 hour
+    this.jwtApiKeyExpiresAt = Date.now() + 1000 * 60 * 60;
+
+    const response = await setCreateUploadJwt({
+      creatorAddress: this.creatorAddress,
+    });
+    this.jwtApiKey = response.data?.createUploadJwtFromApiKey;
+    if (!this.jwtApiKey) {
+      throw new Error("Failed to create upload JWT");
+    }
+
+    return this.jwtApiKey;
+  }
+
+  async upload(file: File): Promise<UploadResult> {
+    const jwtApiKey = await this.getJWTApiKey();
+    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,
+      },
+    );
+
+    if (!response.ok) {
+      console.error(await response.text());
+      throw new Error(`Failed to upload file: ${response.statusText}`);
+    }
+
+    const data = (await response.json()) as {
+      cid: string;
+      size: number | undefined;
+      mimeType: string | undefined;
+    };
+
+    return {
+      url: `ipfs://${data.cid}`,
+      size: data.size,
+      mimeType: data.mimeType,
+    };
+  }
+}
+
+/**
+ * Create a new Zora IPFS uploader
+ */
+export function createZoraUploaderForCreator(
+  creatorAddress: Address,
+): Uploader {
+  return new ZoraUploader(creatorAddress);
+}