@zoralabs/protocol-sdk 0.7.0 → 0.7.2-ALLOWLIST.0

package/src/ipfs/ipfs.ts

@@ -0,0 +1,82 @@
+import { CID } from "multiformats/cid";
+
+export type IPFSUrl = `ipfs://${string}`;
+
+export function isCID(str: string | null | undefined): boolean {
+  if (!str) return false;
+
+  try {
+    CID.parse(str);
+    return true;
+  } catch (e) {
+    if (/^(bafy|Qm)/.test(str)) return true;
+    return false;
+  }
+}
+
+export function normalizeIPFSUrl(
+  url: string | null | undefined,
+): IPFSUrl | null {
+  if (!url || typeof url !== "string") return null;
+
+  // Handle urls wrapped in quotes
+  url = url.replace(/"/g, "");
+
+  // Check if already a normalized IPFS url
+  if (isNormalizedIPFSURL(url)) return url as IPFSUrl;
+
+  // Check if url is a CID string
+  if (isCID(url)) return `ipfs://${url}`;
+
+  // If url is not either an ipfs gateway or protocol url
+  if (!isIPFSUrl(url)) return null;
+
+  // If url is already a gateway url, parse and normalize
+  if (isGatewayIPFSUrl(url)) {
+    // Replace leading double-slashes and parse URL
+    const parsed = new URL(url.replace(/^\/\//, "http://"));
+    // Remove IPFS from the URL
+    // http://gateway/ipfs/<CID>?x=y#z -> http://gateway/<CID>?x=y#z
+    parsed.pathname = parsed.pathname.replace(/^\/ipfs\//, "");
+    // Remove the protocol and host from the URL
+    // http://gateway/<CID>?x=y#z -> <CID>?x=y#z
+    const cid = parsed
+      .toString()
+      .replace(`${parsed.protocol}//${parsed.host}/`, "");
+    // Prepend ipfs protocol
+    return `ipfs://${cid}`;
+  }
+
+  return null;
+}
+
+function isNormalizedIPFSURL(url: string | null | undefined): boolean {
+  return url && typeof url === "string" ? url.startsWith("ipfs://") : false;
+}
+
+function isGatewayIPFSUrl(url: string | null | undefined): boolean {
+  if (url && typeof url === "string") {
+    try {
+      const parsed = new URL(url.replace(/^"|'(.*)"|'$/, "$1"));
+      return (
+        !isNormalizedIPFSURL(url) &&
+        parsed &&
+        parsed.pathname.startsWith("/ipfs/")
+      );
+    } catch {
+      return false;
+    }
+  }
+
+  return false;
+}
+
+function isIPFSUrl(url: string | null | undefined): boolean {
+  return url ? isNormalizedIPFSURL(url) || isGatewayIPFSUrl(url) : false;
+}
+
+export function isNormalizeableIPFSUrl(
+  url: string | null | undefined,
+): boolean {
+  return url ? isIPFSUrl(url) || isCID(url) : false;
+}

package/src/ipfs/mimeTypes.ts

@@ -0,0 +1,141 @@
+// text
+const HTML = "text/html";
+const MARKDOWN = "text/markdown";
+const MARKDOWN_UTF8 = "text/markdown; charset=utf-8";
+const TEXT_PLAIN_UTF8 = "text/plain; charset=utf-8";
+export const TEXT_PLAIN = "text/plain";
+const CSV = "text/csv";
+const NUMBERS = ".numbers";
+const EXCEL = ".xlsx";
+const PDF = "application/pdf";
+
+// image
+const JPG = "image/jpg";
+const JPEG = "image/jpeg";
+const PNG = "image/png";
+const WEBP = "image/webp";
+const SVG = "image/svg+xml";
+const TIFF = "image/tiff";
+const GIF = "image/gif";
+
+export const isImage = (mimeType: string | null | undefined) => {
+  if (!mimeType) return false;
+  return [JPG, JPEG, PNG, WEBP, SVG, TIFF, GIF].includes(mimeType);
+};
+
+export enum MediaType {
+  CSV = "CSV",
+  NUMBERS = "NUMBERS",
+  EXCEL = "EXCEL",
+  IMAGE = "IMAGE",
+  VIDEO = "VIDEO",
+  AUDIO = "AUDIO",
+  TIFF = "TIFF",
+  TEXT = "TEXT",
+  PDF = "PDF",
+  MODEL = "MODEL",
+  HTML = "HTML",
+  ZIP = "ZIP",
+  UNKNOWN = "UNKNOWN",
+}
+
+export const DEFAULT_THUMBNAIL_CID_HASHES: { [key: string]: string } = {
+  [MediaType.AUDIO]:
+    "bafkreidir5laqi26ta6ivnpe2zpekgrfcyi4tb5x6vhwmwnledmzxshfb4",
+  [MediaType.VIDEO]:
+    "bafkreifm4edadl3j5luoyvw4p6elxeqd77la7bulee6vhq5gq4chfk32mu",
+  [MediaType.HTML]:
+    "bafkreifgvi6xfwqy2l6g45csyokejpaib52ee7zrw6etrxl2tas4xkkclq",
+  [MediaType.ZIP]:
+    "bafkreihe5rr5jbkwzegisjlhxbb7jw22xw5oilfmgd2re6tz6buo4pasdq", // assuming all zip files are html directories
+  [MediaType.TEXT]:
+    "bafkreiaez25nfgggzrnza2loxf6xueb2esm44pnyjyulwoslnipowrf56q",
+  default: "bafkreihcoahllisbpb4eeypdwtm7go5uh275wxd7wf2tantpxlpjhviok4",
+};
+
+// video
+const MP4 = "video/mp4";
+const QUICKTIME = "video/quicktime";
+const M4V = "video/x-m4v";
+const WEBM = "video/webm";
+
+// audio
+const M4A = "audio/x-m4a";
+const MPEG = "audio/mpeg";
+const MP3 = "audio/mp3";
+const WAV = "audio/wav";
+const VND_WAV = "audio/vnd.wav";
+const VND_WAVE = "audio/vnd.wave";
+const WAVE = "audio/wave";
+const X_WAV = "audio/x-wav";
+const AIFF = "audio/aiff";
+
+// 3D
+const GLTF = "model/gltf+json";
+const GLB = "model/gltf-binary";
+// File extensions, as some files return '' as the mimetype
+const GLTF_EXT = ".gltf";
+const GLB_EXT = ".glb";
+
+// application
+export const JSON_MIME_TYPE = "application/json";
+const ZIP = "application/zip";
+
+const mimeToMediaType = {
+  [HTML]: MediaType.HTML,
+  [JPG]: MediaType.IMAGE,
+  [JPEG]: MediaType.IMAGE,
+  [PNG]: MediaType.IMAGE,
+  [WEBP]: MediaType.IMAGE,
+  [SVG]: MediaType.IMAGE,
+  [TIFF]: MediaType.TIFF,
+  [GIF]: MediaType.IMAGE,
+  [MP4]: MediaType.VIDEO,
+  [WEBM]: MediaType.VIDEO,
+  [QUICKTIME]: MediaType.VIDEO,
+  [M4V]: MediaType.VIDEO,
+  [MPEG]: MediaType.AUDIO,
+  [MP3]: MediaType.AUDIO,
+  [M4A]: MediaType.AUDIO,
+  [VND_WAV]: MediaType.AUDIO,
+  [VND_WAVE]: MediaType.AUDIO,
+  [WAV]: MediaType.AUDIO,
+  [WAVE]: MediaType.AUDIO,
+  [X_WAV]: MediaType.AUDIO,
+  [AIFF]: MediaType.AUDIO,
+  [TEXT_PLAIN]: MediaType.TEXT,
+  [TEXT_PLAIN_UTF8]: MediaType.TEXT,
+  [MARKDOWN]: MediaType.TEXT,
+  [MARKDOWN_UTF8]: MediaType.TEXT,
+  [CSV]: MediaType.CSV,
+  [NUMBERS]: MediaType.NUMBERS,
+  [EXCEL]: MediaType.EXCEL,
+  [PDF]: MediaType.PDF,
+  [ZIP]: MediaType.ZIP,
+  [GLTF]: MediaType.MODEL,
+  [GLTF_EXT]: MediaType.MODEL,
+  [GLB]: MediaType.MODEL,
+  // GLTF returns 'application/json' as the mimetype,
+  // and as the only JSON-encoded media we currently support,
+  // we assume that if the mimetype is JSON, it's a GLTF
+  [JSON_MIME_TYPE]: MediaType.MODEL,
+  [GLB_EXT]: MediaType.MODEL,
+} as const;
+
+/** Return a MediaType for the given mime type. If mime type is unknown you can provide a filename as a fallback, where the type will be guessed based on extension. */
+export function mimeTypeToMedia(mimeType?: string | null) {
+  if (!mimeType) return MediaType.UNKNOWN;
+
+  return (
+    mimeToMediaType[mimeType as keyof typeof mimeToMediaType] ||
+    MediaType.UNKNOWN
+  );
+}
+
+export async function getMimeType(uri?: string) {
+  if (!uri) return uri;
+
+  const res = await fetch(uri, { method: "HEAD" });
+  let mimeType = res.headers.get("content-type");
+  return mimeType;
+}

package/src/ipfs/text-metadata.ts

@@ -0,0 +1,128 @@
+import { TextMetadataFiles } from "./types";
+
+const CHAR_LIMIT = 1111;
+
+const wrapText = ({
+  ctx,
+  text,
+  x,
+  y,
+  maxWidth,
+  lineHeight,
+}: {
+  ctx: CanvasRenderingContext2D;
+  text: string;
+  x: number;
+  y: number;
+  maxWidth: number;
+  lineHeight: number;
+}) => {
+  // Split text into words
+  let words = text.replaceAll("\n", " \n ").split(/ +/);
+  let line = ""; // This will store the text of the current line
+  let testLine = ""; // This will store the text when we add a word, to test if it's too long
+  let lineArray = []; // This is an array of lines, which the function will return
+
+  for (var n = 0; n < words.length; n++) {
+    // Measure text sizing
+    testLine += `${words[n]} `;
+    let metrics = ctx.measureText(testLine);
+    let testWidth = metrics.width;
+    // If the width of this test line is more than the max width
+    if (words[n]?.includes("\n") || (testWidth > maxWidth && n > 0)) {
+      // Then the line is finished, push the current line into "lineArray"
+      lineArray.push({ text: line, x, y });
+      // Start a new line
+      y += lineHeight;
+      // Update line and test line to use this word as the first word on the next line
+      // If it's a newline, then don't add a space
+      if (words[n]?.includes("\n")) {
+        line = ``;
+        testLine = ``;
+      } else {
+        line = `${words[n]} `;
+        testLine = `${words[n]} `;
+      }
+    } else {
+      // Test line is less than the max width, add the word to the current line
+      line += `${words[n]} `;
+    }
+    // Handle a single line...
+    if (n === words.length - 1) {
+      lineArray.push({ text: line, x, y });
+    }
+  }
+  return lineArray;
+};
+
+async function generateTextPreview(text: string): Promise<File> {
+  // Trim the text to a reasonable max length. Prevent crashes if the user pastes a gigantic string
+  const trimmedText = text.trim().slice(0, CHAR_LIMIT);
+
+  const [width, height] = [500, 500];
+  const padding = 20;
+  const dpr = 2;
+
+  const fontFamily = "Inter";
+  const [fontSize, lineHeight] = [16, 24];
+  const [textColor, backgroundColor] = ["black", "white"];
+
+  return new Promise((resolve, reject) => {
+    const canvas = document.createElement("canvas");
+    canvas.width = width * dpr;
+    canvas.height = height * dpr;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      return reject(new Error("Could not create canvas context"));
+    }
+    ctx.fillStyle = backgroundColor;
+    ctx.fillRect(0, 0, width * dpr, width * dpr);
+    ctx.fillStyle = textColor;
+    ctx.font = `${fontSize * dpr}px ${fontFamily}`;
+    const wrapped = wrapText({
+      ctx,
+      text: trimmedText,
+      x: padding * dpr,
+      y: fontSize * dpr + padding * dpr,
+      maxWidth: width * dpr - padding * 2 * dpr,
+      lineHeight: lineHeight * dpr,
+    });
+    wrapped.forEach((line) => ctx.fillText(line.text, line.x, line.y));
+    canvas.toBlob((blob) => {
+      if (!blob) {
+        return reject(new Error("Could not create blob"));
+      }
+      resolve(new File([blob], "thumbnail.png", { type: "image/png" }));
+    });
+  });
+}
+
+function generateTextTitle(text: string) {
+  const firstLine = text.split("\n")[0]!;
+  const firstSentence = firstLine?.split(". ")[0]!;
+
+  if (firstSentence.length > 50) {
+    return firstSentence.slice(0, 50) + "...";
+  }
+
+  return firstSentence;
+}
+
+const toTextFile = (text: string) =>
+  new File([text], "Untitled.txt", { type: "text/plain" });
+
+/** For text nfts, this will generate files that are needed for the metadata json, including the txt.file containing the text, and a thumbnail image containing a preview of the text
+ */
+export async function generateTextNftMetadataFiles(
+  text: string,
+): Promise<TextMetadataFiles> {
+  const name = generateTextTitle(text);
+  const textFile = toTextFile(text);
+  const thumbnailFile = await generateTextPreview(text);
+
+  return {
+    name,
+    mediaUrlFile: textFile,
+    thumbnailFile,
+  };
+}

package/src/ipfs/token-metadata.ts

@@ -0,0 +1,99 @@
+import { getFetchableUrl } from "./gateway";
+import {
+  DEFAULT_THUMBNAIL_CID_HASHES,
+  TEXT_PLAIN,
+  getMimeType,
+  isImage,
+  mimeTypeToMedia,
+} from "./mimeTypes";
+import {
+  MakeMediaMetadataParams,
+  MakeTextMetadataParams,
+  TokenMetadataJson,
+} from "./types";
+
+/**
+ * Takes properties for a text based nft and formats it as proper json metadata
+ * for the token, which should be uploaded to IPFS.
+ * @param parameters - The parameters to format into metadata {@link MakeTextMetadataParams}
+ */
+export const makeTextTokenMetadata = (
+  parameters: MakeTextMetadataParams,
+): TokenMetadataJson => {
+  const { name, textFileUrl, thumbnailUrl, attributes = [] } = parameters;
+
+  const content = textFileUrl
+    ? {
+        mime: TEXT_PLAIN,
+        uri: textFileUrl,
+      }
+    : null;
+
+  const image = thumbnailUrl;
+  const animation_url = textFileUrl;
+
+  return {
+    name,
+    image,
+    animation_url,
+    content,
+    attributes,
+  };
+};
+
+/**
+ * Takes properties for a media based nft (video, image, etc) and formats it as proper json metadata
+ * for the token, which should be uploaded to IPFS.
+ * @param parameters - The parameters to format into metadata {@link MakeMediaMetadataParams}
+ */
+export const makeMediaTokenMetadata = async ({
+  name,
+  description,
+  attributes = [],
+  mediaUrl,
+  thumbnailUrl,
+}: MakeMediaMetadataParams): Promise<TokenMetadataJson> => {
+  const contentUrl = mediaUrl;
+  const fetchableContentUrl = getFetchableUrl(contentUrl);
+
+  if (!fetchableContentUrl)
+    throw new Error(`Content url (${contentUrl}) is not fetchable`);
+
+  const mimeType = await getMimeType(fetchableContentUrl);
+  const mediaType = mimeTypeToMedia(mimeType);
+
+  let image: string | undefined = undefined;
+  let animation_url: string | null = null;
+
+  // If the media is an image, just set the image field
+  // Otherwise we require a thumbnail, set image and animation_url
+  if (isImage(mimeType)) {
+    image = contentUrl;
+  } else {
+    image = thumbnailUrl;
+    animation_url = mediaUrl;
+  }
+
+  // If no image determined, use a fallback placeholder
+  if (!image)
+    image = `ipfs://${
+      DEFAULT_THUMBNAIL_CID_HASHES[mediaType] ||
+      DEFAULT_THUMBNAIL_CID_HASHES.default
+    }`;
+
+  const content = contentUrl
+    ? {
+        mime: mimeType || "application/octet-stream",
+        uri: contentUrl,
+      }
+    : null;
+
+  return {
+    name,
+    description,
+    image,
+    animation_url,
+    content,
+    attributes,
+  };
+};

package/src/ipfs/types.ts

@@ -0,0 +1,54 @@
+export type CreateERC1155TokenAttributes = {
+  trait_type: string;
+  value: string;
+};
+
+export type ContractMetadataJson = {
+  name?: string;
+  description?: string;
+  image?: string;
+};
+
+export type TokenMetadataJson = {
+  name: string;
+  description?: string;
+  /** Primary image file */
+  image?: string;
+  animation_url?: string | null;
+  content?: {
+    mime: string;
+    uri: string;
+  } | null;
+  attributes: Array<CreateERC1155TokenAttributes>;
+};
+
+export type BaseMetadataParams = {
+  /** Token name */
+  name: string;
+  /** Optional description */
+  description?: string;
+  /** Optional attributes to tag the token with */
+  attributes?: CreateERC1155TokenAttributes[];
+};
+
+export type MakeTextMetadataParams = BaseMetadataParams & {
+  /** Ipfs url where media is hosted */
+  textFileUrl: string;
+  /** If thumbnail was generate for text file, thumbnail image url */
+  thumbnailUrl?: string;
+};
+
+export type TextMetadataFiles = {
+  name: string;
+  /** File that holds the text, and is the primary media */
+  mediaUrlFile: File;
+  /** Thumbnail image preview of the text */
+  thumbnailFile: File;
+};
+
+export type MakeMediaMetadataParams = BaseMetadataParams & {
+  /** Ipfs url where media is hosted */
+  mediaUrl: string;
+  /** Ipfs url where thumbnail of media is hosted */
+  thumbnailUrl?: string;
+};

package/src/mint/mint-queries.ts

@@ -27,6 +27,7 @@ import {
 import { makeOnchainMintCall, parseMintCosts } from "./mint-transactions";
 import { buildPremintMintCall } from "src/premint/premint-client";
 import { IPublicClient } from "src/types";
+import { AllowListEntry } from "src/allow-list/types";
 
 export async function getMint({
   params,
@@ -129,11 +130,13 @@ export async function getMintsOfContract({
 
 export async function getMintCosts({
   params,
+  allowListEntry,
   mintGetter,
   premintGetter,
   publicClient,
 }: {
   params: GetMintCostsParameters;
+  allowListEntry?: Pick<AllowListEntry, "price">;
   mintGetter: IOnchainMintGetter;
   premintGetter: IPremintGetter;
   publicClient: IPublicClient;
@@ -150,6 +153,7 @@ export async function getMintCosts({
       mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
       salesConfig: salesConfigAndTokenInfo.salesConfig,
       quantityToMint: BigInt(quantityToMint),
+      allowListEntry,
     });
   }
 
@@ -258,6 +262,7 @@ const makeOnchainPrepareMint =
       salesConfig: result.salesConfig,
       quantityToMint: BigInt(params.quantityToMint),
       mintFeePerQuantity: result.mintFeePerQuantity,
+      allowListEntry: params.allowListEntry,
     }),
   });
 
@@ -286,6 +291,7 @@ const makePremintPrepareMint =
       mintFeePerQuantity: mintFee,
       quantityToMint: BigInt(params.quantityToMint),
       salesConfig: mintable.salesConfig,
+      allowListEntry: params.allowListEntry,
     }),
   });