@zoralabs/protocol-sdk 0.11.0 → 0.11.2

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @zoralabs/protocol-sdk@0.11.0 build /home/runner/work/zora-protocol-private/zora-protocol-private/packages/protocol-sdk
+> @zoralabs/protocol-sdk@0.11.2 build /home/runner/work/zora-protocol-private/zora-protocol-private/packages/protocol-sdk
 > pnpm tsup
 
 CLI Building entry: src/index.ts
@@ -10,9 +10,9 @@ CLI Target: es2021
 CLI Cleaning output folder
 CJS Build start
 ESM Build start
-ESM dist/index.js     216.01 KB
-ESM dist/index.js.map 448.17 KB
-ESM ⚡️ Build success in 355ms
-CJS dist/index.cjs     222.28 KB
-CJS dist/index.cjs.map 449.68 KB
-CJS ⚡️ Build success in 355ms
+CJS dist/index.cjs     224.10 KB
+CJS dist/index.cjs.map 454.19 KB
+CJS ⚡️ Build success in 322ms
+ESM dist/index.js     217.84 KB
+ESM dist/index.js.map 452.19 KB
+ESM ⚡️ Build success in 338ms

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @zoralabs/protocol-sdk
 
+## 0.11.2
+
+### Patch Changes
+
+- 66f33bbb: fix: update secondary swap helper contract address
+- 8d7fdc02: For the functions `getToken` and `getTokensOfContract`, the returned `MintableReturn` type has been updated to provide more information about the primary mint status:
+
+  - Added `primaryMintActive` boolean to indicate if the primary mint is currently active.
+  - Added `primaryMintEnd` optional `bigint` to show the end time of the primary mint, if applicable.
+  - Added `secondaryMarketActive` boolean to indicate if the secondary market is currently active.
+  - Modified `prepareMint` to be conditionally available:
+    - When `primaryMintActive` is `true`, `prepareMint` is available as a `PrepareMint` function.
+    - When `primaryMintActive` is `false`, `prepareMint` is set to `undefined`.
+
+  This allows for developers to know if the primary mint is active or not, and if not, if they should buy on secondary.
+
+- Updated dependencies [66f33bbb]
+  - @zoralabs/protocol-deployments@0.3.4
+
+## 0.11.1
+
+### Patch Changes
+
+- Updated dependencies [b885539f]
+  - @zoralabs/protocol-deployments@0.3.3
+
 ## 0.11.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -2834,100 +2834,123 @@ var getApiNetworkConfigForChain = (chainId) => {
   }
   return networkConfigByChain[chainId];
 };
-function parseSalesConfig(targetStrategy, contractMintFee) {
-  if (targetStrategy.type === "FIXED_PRICE")
-    return {
+function parseFixedPriceSalesConfig(fixedPrice, contractMintFee, blockTime) {
+  const saleEnd = BigInt(fixedPrice.saleEnd);
+  return {
+    salesStrategy: {
       saleType: "fixedPrice",
-      ...targetStrategy.fixedPrice,
-      maxTokensPerAddress: BigInt(
-        targetStrategy.fixedPrice.maxTokensPerAddress
-      ),
-      pricePerToken: BigInt(targetStrategy.fixedPrice.pricePerToken),
+      ...fixedPrice,
+      maxTokensPerAddress: BigInt(fixedPrice.maxTokensPerAddress),
+      pricePerToken: BigInt(fixedPrice.pricePerToken),
       mintFeePerQuantity: contractMintFee
-    };
-  if (targetStrategy.type === "ERC_20_MINTER") {
-    return {
+    },
+    saleEnd,
+    saleActive: BigInt(fixedPrice.saleStart) <= blockTime && BigInt(saleEnd) > blockTime
+  };
+}
+function parseERC20SalesConfig(erc20Minter, blockTime) {
+  const saleEnd = BigInt(erc20Minter.saleEnd);
+  return {
+    salesStrategy: {
       saleType: "erc20",
-      ...targetStrategy.erc20Minter,
-      maxTokensPerAddress: BigInt(
-        targetStrategy.erc20Minter.maxTokensPerAddress
-      ),
-      pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken),
+      ...erc20Minter,
+      maxTokensPerAddress: BigInt(erc20Minter.maxTokensPerAddress),
+      pricePerToken: BigInt(erc20Minter.pricePerToken),
       mintFeePerQuantity: 0n
-    };
-  }
-  if (targetStrategy.type === "PRESALE") {
-    return {
+    },
+    saleEnd,
+    saleActive: BigInt(erc20Minter.saleStart) <= blockTime && saleEnd > blockTime
+  };
+}
+function parsePresaleSalesConfig(presale, contractMintFee, blockTime) {
+  const saleEnd = BigInt(presale.presaleEnd);
+  return {
+    salesStrategy: {
       saleType: "allowlist",
-      address: targetStrategy.presale.address,
-      merkleRoot: targetStrategy.presale.merkleRoot,
-      saleStart: targetStrategy.presale.presaleStart,
-      saleEnd: targetStrategy.presale.presaleEnd,
+      address: presale.address,
+      merkleRoot: presale.merkleRoot,
+      saleStart: presale.presaleStart,
+      saleEnd: presale.presaleEnd,
       mintFeePerQuantity: contractMintFee
-    };
-  }
-  if (targetStrategy.type === "ZORA_TIMED") {
-    return {
-      saleType: "timed",
-      address: targetStrategy.zoraTimedMinter.address,
-      mintFee: BigInt(targetStrategy.zoraTimedMinter.mintFee),
-      saleStart: targetStrategy.zoraTimedMinter.saleStart,
-      saleEnd: targetStrategy.zoraTimedMinter.saleEnd,
-      erc20Z: targetStrategy.zoraTimedMinter.erc20Z.id,
-      pool: targetStrategy.zoraTimedMinter.erc20Z.pool,
-      secondaryActivated: targetStrategy.zoraTimedMinter.secondaryActivated,
-      mintFeePerQuantity: BigInt(targetStrategy.zoraTimedMinter.mintFee),
-      marketCountdown: targetStrategy.zoraTimedMinter.marketCountdown ? BigInt(targetStrategy.zoraTimedMinter.marketCountdown) : void 0,
-      minimumMarketEth: targetStrategy.zoraTimedMinter.minimumMarketEth ? BigInt(targetStrategy.zoraTimedMinter.minimumMarketEth) : void 0
-    };
-  }
-  throw new Error("Unknown saleType");
+    },
+    saleEnd,
+    saleActive: BigInt(presale.presaleStart) <= blockTime && saleEnd > blockTime
+  };
 }
-function getSaleEnd(a) {
-  if (a.type === "FIXED_PRICE")
-    return BigInt(a.fixedPrice.saleEnd);
-  if (a.type === "ERC_20_MINTER")
-    return BigInt(a.erc20Minter.saleEnd);
-  if (a.type === "ZORA_TIMED")
-    return BigInt(a.zoraTimedMinter.saleEnd);
-  return BigInt(a.presale.presaleEnd);
+function parseZoraTimedSalesConfig(zoraTimedMinter, blockTime) {
+  const saleEnd = BigInt(zoraTimedMinter.saleEnd);
+  const hasSaleEnd = saleEnd > 0n;
+  return {
+    salesStrategy: {
+      saleType: "timed",
+      address: zoraTimedMinter.address,
+      mintFee: BigInt(zoraTimedMinter.mintFee),
+      saleStart: zoraTimedMinter.saleStart,
+      saleEnd: zoraTimedMinter.saleEnd,
+      erc20Z: zoraTimedMinter.erc20Z.id,
+      pool: zoraTimedMinter.erc20Z.pool,
+      secondaryActivated: zoraTimedMinter.secondaryActivated,
+      mintFeePerQuantity: BigInt(zoraTimedMinter.mintFee),
+      marketCountdown: zoraTimedMinter.marketCountdown ? BigInt(zoraTimedMinter.marketCountdown) : void 0,
+      minimumMarketEth: zoraTimedMinter.minimumMarketEth ? BigInt(zoraTimedMinter.minimumMarketEth) : void 0
+    },
+    saleEnd: hasSaleEnd ? saleEnd : void 0,
+    secondaryMarketActive: zoraTimedMinter.secondaryActivated,
+    saleActive: BigInt(zoraTimedMinter.saleStart) <= blockTime && (hasSaleEnd ? saleEnd > blockTime : true)
+  };
 }
-function strategyIsStillValid(strategy, blockTime) {
-  if (strategy.type === "FIXED_PRICE") {
-    return BigInt(strategy.fixedPrice.saleEnd) > blockTime;
-  }
-  if (strategy.type === "ERC_20_MINTER") {
-    return BigInt(strategy.erc20Minter.saleEnd) > blockTime;
-  }
-  if (strategy.type === "ZORA_TIMED") {
-    return BigInt(strategy.zoraTimedMinter.saleEnd) === 0n || BigInt(strategy.zoraTimedMinter.saleEnd) > blockTime;
+function parseSalesConfig(targetStrategy, contractMintFee, blockTime) {
+  switch (targetStrategy.type) {
+    case "FIXED_PRICE":
+      return parseFixedPriceSalesConfig(
+        targetStrategy.fixedPrice,
+        contractMintFee,
+        blockTime
+      );
+    case "ERC_20_MINTER":
+      return parseERC20SalesConfig(targetStrategy.erc20Minter, blockTime);
+    case "PRESALE":
+      return parsePresaleSalesConfig(
+        targetStrategy.presale,
+        contractMintFee,
+        blockTime
+      );
+    case "ZORA_TIMED":
+      return parseZoraTimedSalesConfig(
+        targetStrategy.zoraTimedMinter,
+        blockTime
+      );
+    default:
+      throw new Error("Unknown saleType");
   }
-  return BigInt(strategy.presale.presaleEnd) > blockTime;
 }
 function getTargetStrategy({
   tokenId,
   preferredSaleType,
   token,
-  blockTime
+  blockTime,
+  contractMintFee
 }) {
   const allStrategies = (typeof tokenId !== "undefined" ? token.salesStrategies : token.contract.salesStrategies) || [];
-  const stillValidSalesStrategies = allStrategies.filter(
-    (strategy) => strategyIsStillValid(strategy, blockTime)
+  const parsedStrategies = allStrategies.map(
+    (strategy) => parseSalesConfig(strategy, contractMintFee, blockTime)
+  );
+  const stillValidSalesStrategies = parsedStrategies.filter(
+    (strategy) => strategy.saleActive
   );
   const saleStrategies = stillValidSalesStrategies.sort(
-    (a, b) => getSaleEnd(a) > getSaleEnd(b) ? 1 : -1
+    (a, b) => (a.saleEnd ?? 0n) > (b.saleEnd ?? 0n) ? 1 : -1
   );
   let targetStrategy;
   if (!preferredSaleType) {
     return saleStrategies[0];
   } else {
-    const mappedSaleType = preferredSaleType === "erc20" ? "ERC_20_MINTER" : "FIXED_PRICE";
     targetStrategy = saleStrategies.find(
-      (strategy) => strategy.type === mappedSaleType
+      ({ salesStrategy }) => salesStrategy.saleType === preferredSaleType
     );
     if (!targetStrategy) {
       const targetStrategy2 = saleStrategies.find(
-        (strategy) => strategy.type === "FIXED_PRICE" || strategy.type === "ERC_20_MINTER"
+        ({ salesStrategy }) => salesStrategy.saleType === "timed" || salesStrategy.saleType === "fixedPrice" || salesStrategy.saleType === "erc20"
       );
       if (!targetStrategy2)
         throw new Error("Cannot find valid sale strategy");
@@ -3004,7 +3027,7 @@ var SubgraphMintGetter = class extends SubgraphGetter {
     })) || [];
   }
 };
-function getTargetStrategyAndMintFee({
+function getTargetStrategyAndMintFeeAndSaleActive({
   token,
   tokenId,
   preferredSaleType,
@@ -3015,12 +3038,10 @@ function getTargetStrategyAndMintFee({
     tokenId,
     preferredSaleType,
     token,
-    blockTime
+    blockTime,
+    contractMintFee: defaultMintFee
   });
-  if (!targetStrategy)
-    return void 0;
-  const salesConfig = parseSalesConfig(targetStrategy, defaultMintFee);
-  return salesConfig;
+  return targetStrategy;
 }
 function parseTokenQueryResult({
   token,
@@ -3029,7 +3050,7 @@ function parseTokenQueryResult({
   defaultMintFee,
   blockTime
 }) {
-  const salesConfig = getTargetStrategyAndMintFee({
+  const salesStrategyAndMintInfo = getTargetStrategyAndMintFeeAndSaleActive({
     token,
     tokenId,
     preferredSaleType,
@@ -3040,8 +3061,13 @@ function parseTokenQueryResult({
     token
   });
   return {
-    ...tokenInfo,
-    salesConfig
+    salesConfigAndTokenInfo: {
+      ...tokenInfo,
+      salesConfig: salesStrategyAndMintInfo?.salesStrategy
+    },
+    primaryMintActive: salesStrategyAndMintInfo?.saleActive ?? false,
+    primaryMintEnd: salesStrategyAndMintInfo?.saleEnd,
+    secondaryMarketActive: salesStrategyAndMintInfo?.secondaryMarketActive ?? false
   };
 }
 function parseTokenInfo({
@@ -4050,7 +4076,7 @@ async function getMintCosts({
   if (isOnChainMint(params)) {
     const tokenId = is1155Mint(params) ? params.tokenId : void 0;
     const blockTime = (await publicClient.getBlock()).timestamp;
-    const salesConfigAndTokenInfo = await mintGetter.getMintable({
+    const { salesConfigAndTokenInfo } = await mintGetter.getMintable({
       tokenId,
       tokenAddress: collection,
       blockTime
@@ -4109,6 +4135,10 @@ async function getPremintsOfContractMintable({
     });
   });
 }
+function isPrimaryMintActive(premint) {
+  const currentTime = (/* @__PURE__ */ new Date()).getTime() / 1e3;
+  return premint.premintConfig.tokenConfig.mintStart < currentTime;
+}
 function parsePremint({
   premint,
   mintFee
@@ -4155,27 +4185,58 @@ var makeOnchainPrepareMint = (result) => (params) => {
   };
 };
 function toMintableReturn(result) {
-  return { token: result, prepareMint: makeOnchainPrepareMint(result) };
+  const primaryMintActive = result.primaryMintActive;
+  if (!primaryMintActive) {
+    return {
+      token: result.salesConfigAndTokenInfo,
+      primaryMintActive,
+      primaryMintEnd: result.primaryMintEnd,
+      secondaryMarketActive: result.secondaryMarketActive,
+      prepareMint: void 0
+    };
+  }
+  return {
+    token: result.salesConfigAndTokenInfo,
+    primaryMintActive,
+    primaryMintEnd: result.primaryMintEnd,
+    secondaryMarketActive: result.secondaryMarketActive,
+    prepareMint: makeOnchainPrepareMint(result.salesConfigAndTokenInfo)
+  };
 }
-var makePremintPrepareMint = (mintable, mintFee, premint) => (params) => ({
-  parameters: buildPremintMintCall({
-    mintArguments: params,
-    mintFee,
-    premint
-  }),
-  costs: parseMintCosts({
-    quantityToMint: BigInt(params.quantityToMint),
-    salesConfig: mintable.salesConfig,
-    allowListEntry: params.allowListEntry
-  })
-});
+var makePremintPrepareMint = (mintable, mintFee, premint) => {
+  return (params) => {
+    return {
+      parameters: buildPremintMintCall({
+        mintArguments: params,
+        mintFee,
+        premint
+      }),
+      costs: parseMintCosts({
+        quantityToMint: BigInt(params.quantityToMint),
+        salesConfig: mintable.salesConfig,
+        allowListEntry: params.allowListEntry
+      })
+    };
+  };
+};
 function toPremintMintReturn({
   premint,
   mintFee
 }) {
   const mintable = parsePremint({ premint, mintFee });
+  const primaryMintActive = isPrimaryMintActive(premint.premint);
+  if (!primaryMintActive) {
+    return {
+      token: mintable,
+      primaryMintActive,
+      prepareMint: void 0,
+      secondaryMarketActive: false
+    };
+  }
   return {
     token: mintable,
+    primaryMintActive,
+    secondaryMarketActive: false,
     prepareMint: makePremintPrepareMint(mintable, mintFee, premint)
   };
 }
@@ -4271,12 +4332,15 @@ async function mint({
   mintGetter,
   premintGetter
 }) {
-  const { prepareMint } = await getMint({
+  const { prepareMint, primaryMintActive } = await getMint({
     params: parameters,
     mintGetter,
     premintGetter,
     publicClient
   });
+  if (!primaryMintActive) {
+    throw new Error("Primary mint is not active");
+  }
   return prepareMint({
     minterAccount: parameters.minterAccount,
     quantityToMint: parameters.quantityToMint,