@zoralabs/protocol-sdk 0.11.1 → 0.11.3-COMMENTS.0

package/src/mint/subgraph-mint-getter.ts

@@ -6,15 +6,19 @@ import {
   IOnchainMintGetter,
   SaleType,
   OnchainMintable,
-  OnchainSalesConfigAndTokenInfo,
   OnchainSalesStrategies,
+  GetMintableReturn,
 } from "./types";
 import {
   buildContractTokensQuery,
   buildNftTokenSalesQuery,
   buildPremintsOfContractQuery,
+  ERC20SaleStrategyResult,
+  FixedPriceSaleStrategyResult,
+  PresaleSalesStrategyResult,
   SalesStrategyResult,
   TokenQueryResult,
+  ZoraTimedMinterSaleStrategyResult,
 } from "./subgraph-queries";
 import { SubgraphGetter } from "src/apis/subgraph-getter";
 
@@ -24,90 +28,133 @@ export const getApiNetworkConfigForChain = (chainId: number): NetworkConfig => {
   }
   return networkConfigByChain[chainId]!;
 };
+type ParsedSalesConfig = {
+  salesStrategy: OnchainSalesStrategies;
+  saleActive: boolean;
+  saleEnd: bigint | undefined;
+  secondaryMarketActive?: boolean;
+};
 
-function parseSalesConfig(
-  targetStrategy: SalesStrategyResult,
+function parseFixedPriceSalesConfig(
+  fixedPrice: FixedPriceSaleStrategyResult["fixedPrice"],
   contractMintFee: bigint,
-): OnchainSalesStrategies {
-  if (targetStrategy.type === "FIXED_PRICE")
-    return {
+  blockTime: bigint,
+): ParsedSalesConfig {
+  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,
-    };
+    },
+    saleEnd,
+    saleActive:
+      BigInt(fixedPrice.saleStart) <= blockTime && BigInt(saleEnd) > blockTime,
+  };
+}
 
-  if (targetStrategy.type === "ERC_20_MINTER") {
-    return {
+function parseERC20SalesConfig(
+  erc20Minter: ERC20SaleStrategyResult["erc20Minter"],
+  blockTime: bigint,
+): ParsedSalesConfig {
+  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: PresaleSalesStrategyResult["presale"],
+  contractMintFee: bigint,
+  blockTime: bigint,
+): ParsedSalesConfig {
+  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 {
+    },
+    saleEnd,
+    saleActive:
+      BigInt(presale.presaleStart) <= blockTime && saleEnd > blockTime,
+  };
+}
+
+function parseZoraTimedSalesConfig(
+  zoraTimedMinter: ZoraTimedMinterSaleStrategyResult["zoraTimedMinter"],
+  blockTime: bigint,
+): ParsedSalesConfig {
+  const saleEnd = BigInt(zoraTimedMinter.saleEnd);
+  const hasSaleEnd = saleEnd > 0n;
+  return {
+    salesStrategy: {
       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)
+      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)
         : undefined,
-      minimumMarketEth: targetStrategy.zoraTimedMinter.minimumMarketEth
-        ? BigInt(targetStrategy.zoraTimedMinter.minimumMarketEth)
+      minimumMarketEth: zoraTimedMinter.minimumMarketEth
+        ? BigInt(zoraTimedMinter.minimumMarketEth)
         : undefined,
-    };
-  }
-
-  throw new Error("Unknown saleType");
-}
-
-function getSaleEnd(a: SalesStrategyResult) {
-  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);
+    },
+    saleEnd: hasSaleEnd ? saleEnd : undefined,
+    secondaryMarketActive: zoraTimedMinter.secondaryActivated,
+    saleActive:
+      BigInt(zoraTimedMinter.saleStart) <= blockTime &&
+      (hasSaleEnd ? saleEnd > blockTime : true),
+  };
 }
 
-function strategyIsStillValid(
-  strategy: SalesStrategyResult,
+function parseSalesConfig(
+  targetStrategy: SalesStrategyResult,
+  contractMintFee: bigint,
   blockTime: bigint,
-): boolean {
-  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
-    );
+): ParsedSalesConfig {
+  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({
@@ -115,39 +162,45 @@ function getTargetStrategy({
   preferredSaleType,
   token,
   blockTime,
+  contractMintFee,
 }: {
   tokenId?: GenericTokenIdTypes;
   preferredSaleType?: SaleType;
   token: TokenQueryResult;
   blockTime: bigint;
-}): SalesStrategyResult | undefined {
+  contractMintFee: bigint;
+}): ParsedSalesConfig | undefined {
   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.saleEnd ?? 0n) > (b.saleEnd ?? 0n) ? 1 : -1,
   );
 
-  let targetStrategy: SalesStrategyResult | undefined;
+  let targetStrategy: ParsedSalesConfig | undefined;
 
   if (!preferredSaleType) {
     return saleStrategies[0];
   } else {
-    const mappedSaleType =
-      preferredSaleType === "erc20" ? "ERC_20_MINTER" : "FIXED_PRICE";
     targetStrategy = saleStrategies.find(
-      (strategy: SalesStrategyResult) => strategy.type === mappedSaleType,
+      ({ salesStrategy }) => salesStrategy.saleType === preferredSaleType,
     );
     if (!targetStrategy) {
       const targetStrategy = saleStrategies.find(
-        (strategy: SalesStrategyResult) =>
-          strategy.type === "FIXED_PRICE" || strategy.type === "ERC_20_MINTER",
+        ({ salesStrategy }) =>
+          salesStrategy.saleType === "timed" ||
+          salesStrategy.saleType === "fixedPrice" ||
+          salesStrategy.saleType === "erc20",
       );
       if (!targetStrategy) throw new Error("Cannot find valid sale strategy");
       return targetStrategy;
@@ -249,7 +302,7 @@ export class SubgraphMintGetter
   }
 }
 
-function getTargetStrategyAndMintFee({
+function getTargetStrategyAndMintFeeAndSaleActive({
   token,
   tokenId,
   preferredSaleType,
@@ -267,13 +320,10 @@ function getTargetStrategyAndMintFee({
     preferredSaleType: preferredSaleType,
     token,
     blockTime,
+    contractMintFee: defaultMintFee,
   });
 
-  if (!targetStrategy) return undefined;
-
-  const salesConfig = parseSalesConfig(targetStrategy, defaultMintFee);
-
-  return salesConfig;
+  return targetStrategy;
 }
 
 function parseTokenQueryResult({
@@ -288,8 +338,8 @@ function parseTokenQueryResult({
   preferredSaleType?: SaleType;
   defaultMintFee: bigint;
   blockTime: bigint;
-}): OnchainSalesConfigAndTokenInfo {
-  const salesConfig = getTargetStrategyAndMintFee({
+}): GetMintableReturn {
+  const salesStrategyAndMintInfo = getTargetStrategyAndMintFeeAndSaleActive({
     token,
     tokenId,
     preferredSaleType,
@@ -302,8 +352,14 @@ function parseTokenQueryResult({
   });
 
   return {
-    ...tokenInfo,
-    salesConfig,
+    salesConfigAndTokenInfo: {
+      ...tokenInfo,
+      salesConfig: salesStrategyAndMintInfo?.salesStrategy,
+    },
+    primaryMintActive: salesStrategyAndMintInfo?.saleActive ?? false,
+    primaryMintEnd: salesStrategyAndMintInfo?.saleEnd,
+    secondaryMarketActive:
+      salesStrategyAndMintInfo?.secondaryMarketActive ?? false,
   };
 }
 
@@ -311,7 +367,7 @@ function parseTokenInfo({
   token,
 }: {
   token: TokenQueryResult;
-}): OnchainMintable {
+}): Omit<OnchainMintable, "primaryMintActive" | "primaryMintEnd"> {
   return {
     contract: {
       address: token.contract.address,

package/src/mint/types.ts

@@ -226,17 +226,24 @@ export type SalesConfigAndTokenInfo =
   | OnchainSalesConfigAndTokenInfo
   | PremintMintable;
 
+export type GetMintableReturn = {
+  salesConfigAndTokenInfo: OnchainSalesConfigAndTokenInfo;
+  secondaryMarketActive: boolean;
+  primaryMintActive: boolean;
+  primaryMintEnd?: bigint;
+};
+
 export interface IOnchainMintGetter {
   getMintable(params: {
     tokenAddress: Address;
     tokenId?: GenericTokenIdTypes;
     preferredSaleType?: SaleType;
     blockTime: bigint;
-  }): Promise<OnchainSalesConfigAndTokenInfo>;
+  }): Promise<GetMintableReturn>;
 
   getContractMintable(params: {
     tokenAddress: Address;
-  }): Promise<OnchainSalesConfigAndTokenInfo[]>;
+  }): Promise<GetMintableReturn[]>;
 
   getContractPremintTokenIds(params: {
     tokenAddress: Address;
@@ -280,6 +287,17 @@ export type AsyncPrepareMint = (
 export type MintableReturn = {
   /** Token information */
   token: SalesConfigAndTokenInfo;
-  /** Function that takes a quantity of items to mint and returns a prepared transaction and the costs to mint that quantity */
-  prepareMint: PrepareMint;
-};
+  /** If the primary mint is active, the end time of the primary mint, if there is an end time */
+  primaryMintEnd?: bigint;
+  secondaryMarketActive: boolean;
+} & (
+  | {
+      primaryMintActive: true;
+      /** Function that takes a quantity of items to mint and returns a prepared transaction and the costs to mint that quantity.  If the primary mint is not active, it will be undefined. */
+      prepareMint: PrepareMint;
+    }
+  | {
+      primaryMintActive: false;
+      prepareMint?: undefined;
+    }
+);

package/src/rewards/rewards-client.test.ts

@@ -22,7 +22,7 @@ import { advanceToSaleAndAndLaunchMarket } from "src/secondary/secondary-client.
 
 describe("rewardsClient", () => {
   makeAnvilTest({
-    forkBlockNumber: 13914833,
+    forkBlockNumber: 14653556,
     forkUrl: forkUrls.zoraSepolia,
     anvilChainId: zoraSepolia.id,
   })(
@@ -117,7 +117,7 @@ describe("rewardsClient", () => {
     30_000,
   );
   makeAnvilTest({
-    forkBlockNumber: 13914833,
+    forkBlockNumber: 14653556,
     forkUrl: forkUrls.zoraSepolia,
     anvilChainId: zoraSepolia.id,
   })(

package/src/secondary/secondary-client.test.ts

@@ -80,7 +80,7 @@ export async function advanceToSaleAndAndLaunchMarket({
 
 describe("secondary", () => {
   makeAnvilTest({
-    forkBlockNumber: 13914833,
+    forkBlockNumber: 14653556,
     forkUrl: forkUrls.zoraSepolia,
     anvilChainId: zoraSepolia.id,
   })(
@@ -128,7 +128,7 @@ describe("secondary", () => {
   );
 
   makeAnvilTest({
-    forkBlockNumber: 13914833,
+    forkBlockNumber: 14653556,
     forkUrl: forkUrls.zoraSepolia,
     anvilChainId: zoraSepolia.id,
   })(
@@ -199,6 +199,13 @@ describe("secondary", () => {
         account: collectorAccount,
       });
 
+      const balanceBefore = await publicClient.readContract({
+        abi: zoraCreator1155ImplABI,
+        address: contractAddress,
+        functionName: "balanceOf",
+        args: [collectorAccount, newTokenId],
+      });
+
       // now get the price ot buy on secondary
       const quantityToBuy = 1000n;
 
@@ -236,7 +243,7 @@ describe("secondary", () => {
         args: [collectorAccount, newTokenId],
       });
 
-      expect(balance).toBe(quantityToBuy + quantityToMint);
+      expect(balance - balanceBefore).toBe(quantityToBuy);
 
       // now sell 10_000n tokens
       const quantityToSell = 10_000n;