@zoralabs/protocol-sdk 0.5.14 → 0.5.15

package/dist/index.js

@@ -26,6 +26,8 @@ async function isAuthorizedToCreatePremint({
   publicClient,
   signer
 }) {
+  if (collection.additionalAdmins.length > 0)
+    throw new Error("additionalAdmins not supported yet.");
   return await publicClient.readContract({
     abi: preminterAbi,
     address: getPremintExecutorAddress(),
@@ -331,6 +333,41 @@ var zora721Abi = parseAbi([
   "function mintWithRewards(address recipient, uint256 quantity, string calldata comment, address mintReferral) external payable",
   "function zoraFeeForAmount(uint256 amount) public view returns (address, uint256)"
 ]);
+var NFT_SALE_QUERY = `
+fragment SaleStrategy on SalesStrategyConfig {
+  type
+  fixedPrice {
+    address
+    pricePerToken
+    saleEnd
+    saleStart
+    maxTokensPerAddress
+  }
+  erc20Minter {
+    address
+    pricePerToken
+    currency
+    saleEnd
+    saleStart
+    maxTokensPerAddress
+  }
+}
+
+query ($id: ID!) {
+  zoraCreateToken(id: $id) {
+    id
+    contract {
+      mintFeePerQuantity
+      salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
+        ...SaleStrategy
+      }
+    }
+    salesStrategies(where: {type_in: ["FIXED_PRICE", "ERC_20_MINTER"]}) {
+      ...SaleStrategy
+    }
+  }
+}
+`;
 
 // src/apis/chain-constants.ts
 import {
@@ -426,38 +463,13 @@ var MintAPIClient = class {
   }
   async getSalesConfigAndTokenInfo({
     tokenAddress,
-    tokenId
+    tokenId,
+    saleType
   }) {
     const { retries: retries2, post: post2 } = this.httpClient;
     return retries2(async () => {
       const response = await post2(this.networkConfig.subgraphUrl, {
-        query: `
-          fragment SaleStrategy on SalesStrategyConfig {
-            type
-            fixedPrice {
-              address
-              pricePerToken
-              saleEnd
-              saleStart
-              maxTokensPerAddress
-            }
-          }
-
-          query ($id: ID!) {
-            zoraCreateToken(id: $id) {
-              id
-              contract {
-                mintFeePerQuantity
-                salesStrategies(where: { type: "FIXED_PRICE" }) {
-                  ...SaleStrategy
-                }
-              }
-              salesStrategies(where: { type: "FIXED_PRICE" }) {
-                ...SaleStrategy
-              }
-            }
-          }
-        `,
+        query: NFT_SALE_QUERY,
         variables: {
           id: tokenId !== void 0 ? (
             // Generic Token ID types all stringify down to the base numeric equivalent.
@@ -469,17 +481,56 @@ var MintAPIClient = class {
       if (!token) {
         throw new Error("Cannot find a token to mint");
       }
-      const saleStrategies = tokenId !== void 0 ? token.salesStrategies : token.contract.salesStrategies;
-      const fixedPrice = saleStrategies?.sort(
-        (a, b) => BigInt(a.fixedPrice.saleEnd) > BigInt(b.fixedPrice.saleEnd) ? 1 : -1
-      )?.find(() => true)?.fixedPrice;
-      if (!fixedPrice) {
-        throw new Error("Cannot find fixed price sale strategy");
+      const allStrategies = (typeof tokenId !== "undefined" ? token.salesStrategies : token.contract.salesStrategies) || [];
+      const saleStrategies = allStrategies.sort(
+        (a, b) => BigInt(
+          a.type === "ERC_20_MINTER" ? a.erc20Minter.saleEnd : a.fixedPrice.saleEnd
+        ) > BigInt(
+          b.type === "FIXED_PRICE" ? b.fixedPrice.saleEnd : b.erc20Minter.saleEnd
+        ) ? 1 : -1
+      );
+      let targetStrategy;
+      if (!saleType) {
+        targetStrategy = saleStrategies[0];
+        if (!targetStrategy) {
+          throw new Error("Cannot find sale strategy");
+        }
+      } else {
+        const mappedSaleType = saleType === "erc20" ? "ERC_20_MINTER" : "FIXED_PRICE";
+        targetStrategy = saleStrategies.find(
+          (strategy) => strategy.type === mappedSaleType
+        );
+        if (!targetStrategy) {
+          throw new Error(`Cannot find sale strategy for ${mappedSaleType}`);
+        }
+      }
+      if (targetStrategy.type === "FIXED_PRICE") {
+        return {
+          salesConfig: {
+            saleType: "fixedPrice",
+            ...targetStrategy.fixedPrice,
+            maxTokensPerAddress: BigInt(
+              targetStrategy.fixedPrice.maxTokensPerAddress
+            ),
+            pricePerToken: BigInt(targetStrategy.fixedPrice.pricePerToken)
+          },
+          mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity)
+        };
       }
-      return {
-        fixedPrice,
-        mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity)
-      };
+      if (targetStrategy.type === "ERC_20_MINTER") {
+        return {
+          salesConfig: {
+            saleType: "erc20",
+            ...targetStrategy.erc20Minter,
+            maxTokensPerAddress: BigInt(
+              targetStrategy.erc20Minter.maxTokensPerAddress
+            ),
+            pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken)
+          },
+          mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity)
+        };
+      }
+      throw new Error("Invalid saleType");
     });
   }
 };
@@ -1167,6 +1218,8 @@ import {
   http as http2
 } from "viem";
 import {
+  erc20MinterABI,
+  erc20MinterAddress,
   zoraCreator1155ImplABI as zoraCreator1155ImplABI2,
   zoraCreatorFixedPriceSaleStrategyAddress as zoraCreatorFixedPriceSaleStrategyAddress2
 } from "@zoralabs/protocol-deployments";
@@ -1212,16 +1265,19 @@ async function makePrepareMintTokenParams({
   apiClient,
   tokenId,
   tokenAddress,
+  mintArguments,
   ...rest
 }) {
   const salesConfigAndTokenInfo = await apiClient.getSalesConfigAndTokenInfo({
     tokenId,
-    tokenAddress
+    tokenAddress,
+    saleType: mintArguments.saleType
   });
   if (tokenId === void 0) {
     return makePrepareMint721TokenParams({
       salesConfigAndTokenInfo,
       tokenAddress,
+      mintArguments,
       ...rest
     });
   }
@@ -1229,6 +1285,7 @@ async function makePrepareMintTokenParams({
     salesConfigAndTokenInfo,
     tokenAddress,
     tokenId,
+    mintArguments,
     ...rest
   });
 }
@@ -1261,7 +1318,7 @@ function getMintCosts({
   quantityToMint
 }) {
   const mintFeeForTokens = salesConfigAndTokenInfo.mintFeePerQuantity * quantityToMint;
-  const tokenPurchaseCost = BigInt(salesConfigAndTokenInfo.fixedPrice.pricePerToken) * quantityToMint;
+  const tokenPurchaseCost = BigInt(salesConfigAndTokenInfo.salesConfig.pricePerToken) * quantityToMint;
   return {
     mintFee: mintFeeForTokens,
     tokenPurchaseCost,
@@ -1280,24 +1337,49 @@ async function makePrepareMint1155TokenParams({
     salesConfigAndTokenInfo,
     quantityToMint: mintQuantity
   }).totalCost;
-  return makeSimulateContractParamaters({
-    abi: zoraCreator1155ImplABI2,
-    functionName: "mintWithRewards",
-    account: minterAccount,
-    value: mintValue,
-    address: tokenAddress,
-    /* args: minter, tokenId, quantity, minterArguments, mintReferral */
-    args: [
-      salesConfigAndTokenInfo?.fixedPrice.address || zoraCreatorFixedPriceSaleStrategyAddress2[999],
-      BigInt(tokenId),
-      mintQuantity,
-      encodeAbiParameters(parseAbiParameters("address, string"), [
-        mintArguments.mintToAddress,
-        mintArguments.mintComment || ""
-      ]),
-      mintArguments.mintReferral || zeroAddress3
-    ]
-  });
+  switch (salesConfigAndTokenInfo.salesConfig.saleType) {
+    case "fixedPrice":
+      const fixedPriceArgs = mintArguments;
+      return makeSimulateContractParamaters({
+        abi: zoraCreator1155ImplABI2,
+        functionName: "mintWithRewards",
+        account: minterAccount,
+        value: mintValue,
+        address: tokenAddress,
+        /* args: minter, tokenId, quantity, minterArguments, mintReferral */
+        args: [
+          salesConfigAndTokenInfo.salesConfig.address || zoraCreatorFixedPriceSaleStrategyAddress2[999999999],
+          BigInt(tokenId),
+          mintQuantity,
+          encodeAbiParameters(parseAbiParameters("address, string"), [
+            fixedPriceArgs.mintToAddress,
+            fixedPriceArgs.mintComment || ""
+          ]),
+          fixedPriceArgs.mintReferral || zeroAddress3
+        ]
+      });
+    case "erc20":
+      const erc20Args = mintArguments;
+      return makeSimulateContractParamaters({
+        abi: erc20MinterABI,
+        functionName: "mint",
+        account: minterAccount,
+        address: salesConfigAndTokenInfo?.salesConfig.address || erc20MinterAddress[999999999],
+        /* args: mintTo, quantity, tokenAddress, tokenId, totalValue, currency, mintReferral, comment */
+        args: [
+          mintArguments.mintToAddress,
+          mintQuantity,
+          tokenAddress,
+          BigInt(tokenId),
+          salesConfigAndTokenInfo.salesConfig.pricePerToken,
+          salesConfigAndTokenInfo.salesConfig.currency,
+          erc20Args.mintReferral || zeroAddress3,
+          erc20Args.mintComment || ""
+        ]
+      });
+    default:
+      throw new MintError("Unsupported sale type");
+  }
 }
 
 // src/create/1155-create-helper.ts