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

package/src/apis/generated/allow-list-api-types.ts

@@ -0,0 +1,288 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+
+export interface paths {
+  "/_health": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /** Health */
+    get: operations["health__health_get"];
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  "/allowlist": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Add Allowlist
+     * @description This route adds a new allowlist
+     */
+    post: operations["add_allowlist_allowlist_post"];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  "/allowed": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /** Allowed */
+    get: operations["allowed_allowed_get"];
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  "/allowlist/{root}": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /** Allowlist */
+    get: operations["allowlist_allowlist__root__get"];
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  "/allowlist/{root}/count": {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /** Allowlist Count */
+    get: operations["allowlist_count_allowlist__root__count_get"];
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+  schemas: {
+    /**
+     * AllowlistEntry
+     * @description Currently matches zora-nft-drops model
+     */
+    AllowlistEntry: {
+      /** User */
+      user: string;
+      /** Price */
+      price: string;
+      /** Maxcanmint */
+      maxCanMint: number;
+    };
+    /** AllowlistRequest */
+    AllowlistRequest: {
+      /** Entries */
+      entries: components["schemas"]["AllowlistEntry"][];
+      /** Contract */
+      contract?: string;
+    };
+    /** HTTPValidationError */
+    HTTPValidationError: {
+      /** Detail */
+      detail?: components["schemas"]["ValidationError"][];
+    };
+    /** ValidationError */
+    ValidationError: {
+      /** Location */
+      loc: (string | number)[];
+      /** Message */
+      msg: string;
+      /** Error Type */
+      type: string;
+    };
+  };
+  responses: never;
+  parameters: never;
+  requestBodies: never;
+  headers: never;
+  pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+  health__health_get: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Successful Response */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          "application/json": unknown;
+        };
+      };
+    };
+  };
+  add_allowlist_allowlist_post: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    requestBody: {
+      content: {
+        "application/json": components["schemas"]["AllowlistRequest"];
+      };
+    };
+    responses: {
+      /** @description Successful Response */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          "application/json": unknown;
+        };
+      };
+      /** @description Validation Error */
+      422: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          "application/json": components["schemas"]["HTTPValidationError"];
+        };
+      };
+    };
+  };
+  allowed_allowed_get: {
+    parameters: {
+      query: {
+        user: string;
+        root: string;
+      };
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Successful Response */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          "application/json": unknown;
+        };
+      };
+      /** @description Validation Error */
+      422: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          "application/json": components["schemas"]["HTTPValidationError"];
+        };
+      };
+    };
+  };
+  allowlist_allowlist__root__get: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        root: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Successful Response */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          "application/json": unknown;
+        };
+      };
+      /** @description Validation Error */
+      422: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          "application/json": components["schemas"]["HTTPValidationError"];
+        };
+      };
+    };
+  };
+  allowlist_count_allowlist__root__count_get: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        root: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Successful Response */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          "application/json": unknown;
+        };
+      };
+      /** @description Validation Error */
+      422: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          "application/json": components["schemas"]["HTTPValidationError"];
+        };
+      };
+    };
+  };
+}

package/src/apis/http-api-base.ts

@@ -49,6 +49,15 @@ export const get = async <T>(url: string) => {
  * @throws Error when HTTP response fails
  */
 export const post = async <T>(url: string, data: any) => {
+  const controller = new AbortController();
+  const { signal } = controller;
+
+  // 30 minute timeout:
+  const timeout = 30 * 60 * 1000;
+
+  // Set a timeout to automatically abort the request
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+
   const response = await fetch(url, {
     method: "POST",
     headers: {
@@ -56,7 +65,10 @@ export const post = async <T>(url: string, data: any) => {
       accept: "application/json",
     },
     body: JSON.stringify(data),
+    signal,
   });
+
+  clearTimeout(timeoutId);
   if (response.status !== 200) {
     let json;
     try {

package/src/create/1155-create-helper.ts

@@ -37,6 +37,23 @@ export const getTokenIdFromCreateReceipt = (
   }
 };
 
+export const getContractAddressFromCreateReceipt = (
+  receipt: TransactionReceipt,
+): Address | undefined => {
+  for (const data of receipt.logs) {
+    try {
+      const decodedLog = decodeEventLog({
+        abi: zoraCreator1155FactoryImplABI,
+        eventName: "SetupNewContract",
+        ...data,
+      });
+      if (decodedLog && decodedLog.eventName === "SetupNewContract") {
+        return decodedLog.args.newContract;
+      }
+    } catch (err: any) {}
+  }
+};
+
 type CreateNew1155TokenReturn = {
   parameters: SimulateContractParameters<
     any,

package/src/create/token-setup.ts

@@ -4,13 +4,17 @@ import {
   zoraCreator1155ImplABI,
   zoraCreatorFixedPriceSaleStrategyABI,
   zoraCreatorFixedPriceSaleStrategyAddress,
+  zoraCreatorMerkleMinterStrategyABI,
+  zoraCreatorMerkleMinterStrategyAddress,
 } from "@zoralabs/protocol-deployments";
 import { Address, encodeFunctionData, zeroAddress, Hex } from "viem";
 import * as semver from "semver";
 import {
+  AllowlistData,
   ContractProps,
   CreateNew1155TokenProps,
   New1155Token,
+  SalesConfigOrAllowList,
   SalesConfigParamsType,
 } from "./types";
 import { OPEN_EDITION_MINT_SIZE } from "src/constants";
@@ -24,16 +28,15 @@ type SetupMintersProps = {
   tokenId: bigint;
   chainId: number;
   fundsRecipient: Address;
-  salesConfig: Concrete<SalesConfigParamsType>;
+  salesConfigOrAllowList: SalesConfigOrAllowList;
 };
 
 // Sales end forever amount (uint64 max)
+const SALE_END_FOREVER = 18446744073709551615n;
 
 const saleSettingsOrDefault = (
   saleSettings?: SalesConfigParamsType,
 ): Concrete<SalesConfigParamsType> => {
-  const SALE_END_FOREVER = 18446744073709551615n;
-
   const DEFAULT_SALE_SETTINGS: Concrete<SalesConfigParamsType> = {
     currency: zeroAddress,
     // Free Mint
@@ -51,6 +54,36 @@ const saleSettingsOrDefault = (
   };
 };
 
+const allowListWithDefaults = (allowlist: AllowlistData) => {
+  const defaultAllowListSettings: Concrete<
+    Omit<AllowlistData, "presaleMerkleRoot">
+  > = {
+    // Sale start time – defaults to beginning of unix time
+    saleStart: 0n,
+    // This is the end of uint64, plenty of time
+    saleEnd: SALE_END_FOREVER,
+  };
+
+  return {
+    ...defaultAllowListSettings,
+    ...allowlist,
+  };
+};
+
+const getSalesConfigOrAllowListWithDefaults = ({
+  salesConfig,
+  allowlist,
+}: Pick<CreateNew1155TokenProps, "salesConfig" | "allowlist">) => {
+  if (!allowlist) {
+    return {
+      salesConfig: saleSettingsOrDefault(salesConfig),
+    };
+  }
+  return {
+    allowlist: allowListWithDefaults(allowlist),
+  };
+};
+
 function applyNew1155Defaults(
   props: CreateNew1155TokenProps,
   ownerAddress: Address,
@@ -68,8 +101,11 @@ function applyNew1155Defaults(
         ? OPEN_EDITION_MINT_SIZE
         : BigInt(props.maxSupply),
     royaltyBPS: props.royaltyBPS || 1000,
-    salesConfig: saleSettingsOrDefault(props.salesConfig),
     tokenMetadataURI: props.tokenMetadataURI,
+    salesConfigOrAllowList: getSalesConfigOrAllowListWithDefaults({
+      salesConfig: props.salesConfig,
+      allowlist: props.allowlist,
+    }),
   };
 }
 
@@ -187,24 +223,84 @@ function setupFixedPriceMinter({
   };
 }
 
-export function setupMinters({ salesConfig, ...rest }: SetupMintersProps): {
+function setupAllowListMinter({
+  chainId,
+  tokenId: nextTokenId,
+  allowlist,
+  fundsRecipient,
+}: {
+  chainId: number;
+  tokenId: bigint;
+  allowlist: Concrete<AllowlistData>;
+  fundsRecipient: Address;
+}) {
+  const merkleSaleStrategyAddress =
+    zoraCreatorMerkleMinterStrategyAddress[
+      chainId as keyof typeof zoraCreatorMerkleMinterStrategyAddress
+    ];
+
+  const merkleApproval = encodeFunctionData({
+    abi: zoraCreator1155ImplABI,
+    functionName: "addPermission",
+    args: [nextTokenId, merkleSaleStrategyAddress, PERMISSION_BITS.MINTER],
+  });
+
+  const merkleRoot = allowlist.presaleMerkleRoot.startsWith("0x")
+    ? allowlist.presaleMerkleRoot
+    : (`0x${allowlist.presaleMerkleRoot}` as Hex);
+
+  const saleData = encodeFunctionData({
+    abi: zoraCreatorMerkleMinterStrategyABI,
+    functionName: "setSale",
+    args: [
+      BigInt(nextTokenId),
+      {
+        presaleStart: allowlist.saleStart,
+        presaleEnd: allowlist.saleEnd,
+        merkleRoot,
+        fundsRecipient: fundsRecipient,
+      },
+    ],
+  });
+
+  const callSaleMerkle = encodeFunctionData({
+    abi: zoraCreator1155ImplABI,
+    functionName: "callSale",
+    args: [BigInt(nextTokenId), merkleSaleStrategyAddress, saleData],
+  });
+
+  return {
+    minter: merkleSaleStrategyAddress,
+    setupActions: [merkleApproval, callSaleMerkle],
+  };
+}
+
+export function setupMinters({
+  salesConfigOrAllowList: { salesConfig, allowlist },
+  ...rest
+}: SetupMintersProps): {
   minter: Address;
   setupActions: Hex[];
 } {
-  if (!salesConfig) throw new Error("No sales config for token");
-  const { currency: currencyAddress } = salesConfig;
-
-  if (currencyAddress === zeroAddress) {
-    return setupFixedPriceMinter({
-      ...salesConfig,
-      ...rest,
-    });
-  } else {
-    return setupErc20Minter({
-      ...salesConfig,
-      ...rest,
-    });
+  if (salesConfig) {
+    const { currency: currencyAddress } = salesConfig;
+
+    if (currencyAddress === zeroAddress) {
+      return setupFixedPriceMinter({
+        ...salesConfig,
+        ...rest,
+      });
+    } else {
+      return setupErc20Minter({
+        ...salesConfig,
+        ...rest,
+      });
+    }
   }
+  return setupAllowListMinter({
+    allowlist: allowlist as Concrete<AllowlistData>,
+    ...rest,
+  });
 }
 
 function buildSetupNewToken({
@@ -335,7 +431,8 @@ export function constructCreate1155TokenCalls(
     tokenId: nextTokenId,
     chainId,
     fundsRecipient: new1155TokenPropsWithDefaults.payoutRecipient,
-    salesConfig: new1155TokenPropsWithDefaults.salesConfig,
+    salesConfigOrAllowList:
+      new1155TokenPropsWithDefaults.salesConfigOrAllowList,
   });
 
   const adminMintCall = makeAdminMintCall({

package/src/create/types.ts

@@ -32,26 +32,54 @@ export type CreateNew1155Params = {
   token: CreateNew1155TokenProps;
 };
 
-export interface CreateNew1155TokenProps {
+export type AllowlistData = {
+  saleStart?: bigint;
+  saleEnd?: bigint;
+  presaleMerkleRoot: `0x${string}`;
+};
+
+export type CreateNew1155TokenProps = {
   maxSupply?: bigint | number;
   tokenMetadataURI: string;
   royaltyBPS?: number;
-  salesConfig?: SalesConfigParamsType;
   createReferral?: Address;
   mintToCreatorCount?: number;
   payoutRecipient?: Address;
-}
+} & (
+  | {
+      salesConfig: SalesConfigParamsType;
+      allowlist?: undefined;
+    }
+  | {
+      salesConfig?: undefined;
+      allowlist: AllowlistData;
+    }
+  | {
+      salesConfig?: undefined;
+      allowlist?: undefined;
+    }
+);
 
 export interface ContractProps {
   nextTokenId: bigint;
   contractVersion: string;
 }
 
+export type SalesConfigOrAllowList =
+  | {
+      salesConfig: Concrete<SalesConfigParamsType>;
+      allowlist?: undefined;
+    }
+  | {
+      salesConfig: undefined;
+      allowlist: Concrete<AllowlistData>;
+    };
+
 export type New1155Token = {
   payoutRecipient: Address;
   createReferral: Address;
   maxSupply: bigint;
   royaltyBPS: number;
-  salesConfig: Concrete<SalesConfigParamsType>;
   tokenMetadataURI: string;
+  salesConfigOrAllowList: SalesConfigOrAllowList;
 };

package/src/index.ts

@@ -29,3 +29,9 @@ export {
 export * from "./create/types";
 
 export * from "./sdk";
+
+export * from "./ipfs";
+
+export { createAllowList } from "./allow-list/allow-list-client";
+
+export * from "./allow-list/types";

package/src/ipfs/arweave.ts

@@ -0,0 +1,5 @@
+export type ArweaveURL = `ar://${string}`;
+
+export function isArweaveURL(url: string | null | undefined): boolean {
+  return url && typeof url === "string" ? url.startsWith("ar://") : false;
+}

package/src/ipfs/gateway.ts

@@ -0,0 +1,48 @@
+import { isArweaveURL } from "./arweave";
+import { isNormalizeableIPFSUrl, normalizeIPFSUrl } from "./ipfs";
+
+const IPFS_GATEWAY = "https://magic.decentralized-content.com";
+
+const ARWEAVE_GATEWAY = "https://arweave.net";
+
+export function arweaveGatewayUrl(normalizedArweaveUrl: string | null) {
+  if (!normalizedArweaveUrl || typeof normalizedArweaveUrl !== "string")
+    return null;
+  return normalizedArweaveUrl.replace("ar://", `${ARWEAVE_GATEWAY}/`);
+}
+
+export function ipfsGatewayUrl(url: string | null) {
+  if (!url || typeof url !== "string") return null;
+  const normalizedIPFSUrl = normalizeIPFSUrl(url);
+  if (normalizedIPFSUrl) {
+    return normalizedIPFSUrl.replace("ipfs://", `${IPFS_GATEWAY}/ipfs/`);
+  }
+  return null;
+}
+
+export function getFetchableUrl(uri: string | null | undefined): string | null {
+  if (!uri || typeof uri !== "string") return null;
+
+  // Prevent fetching from insecure URLs
+  if (uri.startsWith("http://")) return null;
+
+  // If it is an IPFS HTTP or ipfs:// url
+  if (isNormalizeableIPFSUrl(uri)) {
+    // Return a fetchable gateway url
+    return ipfsGatewayUrl(uri);
+  }
+
+  // If it is a ar:// url
+  if (isArweaveURL(uri)) {
+    // Return a fetchable gateway url
+    return arweaveGatewayUrl(uri);
+  }
+
+  // If it is already a url (or blob or data-uri)
+  if (/^(https|data|blob):/.test(uri)) {
+    // Return the URI
+    return uri;
+  }
+
+  return null;
+}

package/src/ipfs/index.ts

@@ -0,0 +1,7 @@
+export {
+  makeMediaTokenMetadata,
+  makeTextTokenMetadata,
+} from "./token-metadata";
+export { generateTextNftMetadataFiles } from "./text-metadata";
+
+export * from "./types";