@zoralabs/protocol-sdk 0.5.14 → 0.5.15

package/.turbo/turbo-build.log

@@ -7,9 +7,9 @@ $ tsup
 CLI Cleaning output folder
 CJS Build start
 ESM Build start
-CJS dist/index.cjs     58.27 KB
-CJS dist/index.cjs.map 116.71 KB
-CJS ⚡️ Build success in 115ms
-ESM dist/index.js     52.91 KB
-ESM dist/index.js.map 116.68 KB
-ESM ⚡️ Build success in 117ms
+CJS dist/index.cjs     60.89 KB
+CJS dist/index.cjs.map 121.87 KB
+CJS ⚡️ Build success in 106ms
+ESM dist/index.js     55.50 KB
+ESM dist/index.js.map 121.86 KB
+ESM ⚡️ Build success in 125ms

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @zoralabs/protocol-sdk
 
+## 0.5.15
+
+### Patch Changes
+
+- 888168b8: Fix protocol-sdk to point to `isAuthorizedToCreatePremint`
+- 344f452b: Add support for ERC-20 minting on 1155s using ERC20 minters within the function `makePrepareMintTokenParams`.
+
 ## 0.5.14
 
 ### Patch Changes

package/README.md

@@ -9,7 +9,6 @@ Protocol SDK allows developers to create tokens using the Zora Protocol and mint
 - `npm install viem`
 - `npm install `
 
-
 ## Examples
 
 - [Creating a mint from an on-chain contract](#creating-a-mint-from-an-on-chain-contract)
@@ -83,6 +82,44 @@ async function mintNFT({
 }
 ```
 
+### Minting an NFT with an ERC20 minter
+
+If an 1155 token is set to be an ERC20 mint, use the `makePrepareMintTokenParams` the same way as for
+eth based mints. The underlying function should handle preparing arguments for the ERC20 mint.
+
+```ts
+import type { PublicClient } from "viem";
+
+async function mint1155TokenWithERC20Currency(
+  publicClient: PublicClient,
+  minterAddress: Address,
+) {
+  const mintClient = createMintClient({ chain: zora });
+  const exampleCurrency = "0xb6b701878a1f80197dF2c209D0BDd292EA73164D";
+  // nft collection address
+  const targetContract = "0x689bc305456c38656856d12469aed282fbd89fe0";
+  const tokenId = 17;
+  // the NFT token price in WEI value
+  const erc20PricePerToken = 2000000000000000000;
+
+  const tokenParams = await mintClient.makePrepareMintTokenParams({
+    minterAccount: minterAddress,
+    tokenId: tokenId,
+    tokenAddress: targetContract,
+    mintArguments: {
+      mintToAddress: minterAddress,
+      quantityToMint: 1,
+    },
+  });
+
+  const simulationResult = await publicClient.simulateContract(params);
+  const hash = await walletClient.writeContract(simulationResult.request);
+  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+
+  return receipt;
+}
+```
+
 #### Using wagmi
 
 ```tsx
@@ -260,7 +297,10 @@ async function createForFree({
     checkSignature: true,
     // collection info of collection to create
     collection: {
-      contractAdmin: typeof creatorAccount === "string" ? creatorAccount : creatorAccount.address,
+      contractAdmin:
+        typeof creatorAccount === "string"
+          ? creatorAccount
+          : creatorAccount.address,
       contractName: "Testing Contract",
       contractURI:
         "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",

package/dist/constants.d.ts

@@ -33,4 +33,5 @@ export declare const zora721Abi: readonly [{
         readonly type: "uint256";
     }];
 }];
+export declare const NFT_SALE_QUERY = "\nfragment SaleStrategy on SalesStrategyConfig {\n  type\n  fixedPrice {\n    address\n    pricePerToken\n    saleEnd\n    saleStart\n    maxTokensPerAddress\n  }\n  erc20Minter {\n    address\n    pricePerToken\n    currency\n    saleEnd\n    saleStart\n    maxTokensPerAddress\n  }\n}\n\nquery ($id: ID!) {\n  zoraCreateToken(id: $id) {\n    id\n    contract {\n      mintFeePerQuantity\n      salesStrategies(where: {type_in: [\"FIXED_PRICE\", \"ERC_20_MINTER\"]}) {\n        ...SaleStrategy\n      }\n    }\n    salesStrategies(where: {type_in: [\"FIXED_PRICE\", \"ERC_20_MINTER\"]}) {\n      ...SaleStrategy\n    }\n  }\n}\n";
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,yBAAyB,CAAC;AACpD,eAAO,MAAM,sBAAsB,QAAiC,CAAC;AAMrE,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEjE;AAED,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGZ,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,yBAAyB,CAAC;AACpD,eAAO,MAAM,sBAAsB,QAAiC,CAAC;AAMrE,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEjE;AAED,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGZ,CAAC;AAEZ,eAAO,MAAM,cAAc,0nBAkC1B,CAAC"}

package/dist/index.cjs

@@ -89,6 +89,8 @@ async function isAuthorizedToCreatePremint({
   publicClient,
   signer
 }) {
+  if (collection.additionalAdmins.length > 0)
+    throw new Error("additionalAdmins not supported yet.");
   return await publicClient.readContract({
     abi: import_protocol_deployments.zoraCreator1155PremintExecutorImplABI,
     address: getPremintExecutorAddress(),
@@ -391,6 +393,41 @@ var zora721Abi = (0, import_viem2.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
 var import_chains = require("viem/chains");
@@ -476,38 +513,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.
@@ -519,17 +531,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");
     });
   }
 };
@@ -1251,16 +1302,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
     });
   }
@@ -1268,6 +1322,7 @@ async function makePrepareMintTokenParams({
     salesConfigAndTokenInfo,
     tokenAddress,
     tokenId,
+    mintArguments,
     ...rest
   });
 }
@@ -1300,7 +1355,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,
@@ -1319,24 +1374,49 @@ async function makePrepareMint1155TokenParams({
     salesConfigAndTokenInfo,
     quantityToMint: mintQuantity
   }).totalCost;
-  return makeSimulateContractParamaters({
-    abi: import_protocol_deployments6.zoraCreator1155ImplABI,
-    functionName: "mintWithRewards",
-    account: minterAccount,
-    value: mintValue,
-    address: tokenAddress,
-    /* args: minter, tokenId, quantity, minterArguments, mintReferral */
-    args: [
-      salesConfigAndTokenInfo?.fixedPrice.address || import_protocol_deployments6.zoraCreatorFixedPriceSaleStrategyAddress[999],
-      BigInt(tokenId),
-      mintQuantity,
-      (0, import_viem5.encodeAbiParameters)((0, import_viem5.parseAbiParameters)("address, string"), [
-        mintArguments.mintToAddress,
-        mintArguments.mintComment || ""
-      ]),
-      mintArguments.mintReferral || import_viem5.zeroAddress
-    ]
-  });
+  switch (salesConfigAndTokenInfo.salesConfig.saleType) {
+    case "fixedPrice":
+      const fixedPriceArgs = mintArguments;
+      return makeSimulateContractParamaters({
+        abi: import_protocol_deployments6.zoraCreator1155ImplABI,
+        functionName: "mintWithRewards",
+        account: minterAccount,
+        value: mintValue,
+        address: tokenAddress,
+        /* args: minter, tokenId, quantity, minterArguments, mintReferral */
+        args: [
+          salesConfigAndTokenInfo.salesConfig.address || import_protocol_deployments6.zoraCreatorFixedPriceSaleStrategyAddress[999999999],
+          BigInt(tokenId),
+          mintQuantity,
+          (0, import_viem5.encodeAbiParameters)((0, import_viem5.parseAbiParameters)("address, string"), [
+            fixedPriceArgs.mintToAddress,
+            fixedPriceArgs.mintComment || ""
+          ]),
+          fixedPriceArgs.mintReferral || import_viem5.zeroAddress
+        ]
+      });
+    case "erc20":
+      const erc20Args = mintArguments;
+      return makeSimulateContractParamaters({
+        abi: import_protocol_deployments6.erc20MinterABI,
+        functionName: "mint",
+        account: minterAccount,
+        address: salesConfigAndTokenInfo?.salesConfig.address || import_protocol_deployments6.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 || import_viem5.zeroAddress,
+          erc20Args.mintComment || ""
+        ]
+      });
+    default:
+      throw new MintError("Unsupported sale type");
+  }
 }
 
 // src/create/1155-create-helper.ts