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

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

@@ -0,0 +1,263 @@
+import { describe, expect } from "vitest";
+import { Address, erc20Abi, parseAbi, parseEther } from "viem";
+import { zora, zoraSepolia } from "viem/chains";
+import { zoraCreator1155ImplABI } from "@zoralabs/protocol-deployments";
+import { forkUrls, makeAnvilTest } from "src/anvil";
+import { createCollectorClient } from "src/sdk";
+
+const erc721ABI = parseAbi([
+  "function balanceOf(address owner) public view returns (uint256)",
+] as const);
+
+describe("mint-helper", () => {
+  makeAnvilTest({
+    forkBlockNumber: 16028671,
+    forkUrl: forkUrls.zoraMainnet,
+    anvilChainId: zora.id,
+  })(
+    "mints a new 1155 token",
+    async ({ viemClients }) => {
+      const { testClient, walletClient, publicClient } = viemClients;
+      const creatorAccount = (await walletClient.getAddresses())[0]!;
+      await testClient.setBalance({
+        address: creatorAccount,
+        value: parseEther("2000"),
+      });
+      const targetContract: Address =
+        "0xa2fea3537915dc6c7c7a97a82d1236041e6feb2e";
+      const targetTokenId = 1n;
+      const collectorClient = createCollectorClient({
+        chainId: zora.id,
+        publicClient,
+      });
+
+      const { token: mintable, prepareMint } = await collectorClient.getToken({
+        tokenContract: targetContract,
+        mintType: "1155",
+        tokenId: targetTokenId,
+      });
+
+      mintable.maxSupply;
+      mintable.totalMinted;
+      mintable.tokenURI;
+      mintable;
+
+      const { parameters, costs } = prepareMint({
+        minterAccount: creatorAccount,
+        quantityToMint: 1,
+      });
+
+      expect(costs.totalCostEth).toBe(1n * parseEther("0.000777"));
+
+      const oldBalance = await publicClient.readContract({
+        abi: zoraCreator1155ImplABI,
+        address: targetContract,
+        functionName: "balanceOf",
+        args: [creatorAccount, targetTokenId],
+      });
+
+      const simulationResult = await publicClient.simulateContract(parameters);
+
+      const hash = await walletClient.writeContract(simulationResult.request);
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      const newBalance = await publicClient.readContract({
+        abi: zoraCreator1155ImplABI,
+        address: targetContract,
+        functionName: "balanceOf",
+        args: [creatorAccount, targetTokenId],
+      });
+      expect(receipt).to.not.be.null;
+      expect(oldBalance).to.be.equal(0n);
+      expect(newBalance).to.be.equal(1n);
+    },
+    12 * 1000,
+  );
+
+  makeAnvilTest({
+    forkUrl: forkUrls.zoraMainnet,
+    forkBlockNumber: 6133407,
+    anvilChainId: zora.id,
+  })(
+    "mints a new 721 token",
+    async ({ viemClients }) => {
+      const { testClient, walletClient, publicClient } = viemClients;
+      const creatorAccount = (await walletClient.getAddresses())[0]!;
+      await testClient.setBalance({
+        address: creatorAccount,
+        value: parseEther("2000"),
+      });
+
+      const targetContract: Address =
+        "0x7aae7e67515A2CbB8585C707Ca6db37BDd3EA839";
+      const collectorClient = createCollectorClient({
+        chainId: zora.id,
+        publicClient,
+      });
+
+      const { prepareMint } = await collectorClient.getToken({
+        tokenContract: targetContract,
+        mintType: "721",
+      });
+
+      const quantityToMint = 3n;
+
+      const { parameters, costs } = prepareMint({
+        minterAccount: creatorAccount,
+        mintRecipient: creatorAccount,
+        quantityToMint,
+      });
+
+      expect(costs.totalPurchaseCost).toBe(quantityToMint * parseEther(".08"));
+      expect(costs.totalCostEth).toBe(
+        quantityToMint * (parseEther("0.08") + parseEther("0.000777")),
+      );
+
+      const oldBalance = await publicClient.readContract({
+        abi: erc721ABI,
+        address: targetContract,
+        functionName: "balanceOf",
+        args: [creatorAccount],
+      });
+
+      const simulated = await publicClient.simulateContract(parameters);
+
+      const hash = await walletClient.writeContract(simulated.request);
+
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      expect(receipt).not.to.be.null;
+
+      const newBalance = await publicClient.readContract({
+        abi: erc721ABI,
+        address: targetContract,
+        functionName: "balanceOf",
+        args: [creatorAccount],
+      });
+
+      expect(oldBalance).to.be.equal(0n);
+      expect(newBalance).to.be.equal(quantityToMint);
+    },
+    12 * 1000,
+  );
+
+  makeAnvilTest({
+    forkUrl: forkUrls.zoraMainnet,
+    forkBlockNumber: 14484183,
+    anvilChainId: zora.id,
+  })(
+    "mints an 1155 token with an ERC20 token",
+    async ({ viemClients }) => {
+      const { testClient, walletClient, publicClient, chain } = viemClients;
+
+      const targetContract: Address =
+        "0x689bc305456c38656856d12469aed282fbd89fe0";
+      const targetTokenId = 16n;
+
+      const minter = createCollectorClient({ chainId: chain.id, publicClient });
+
+      const mockCollector = "0xb6b701878a1f80197dF2c209D0BDd292EA73164D";
+      await testClient.impersonateAccount({
+        address: mockCollector,
+      });
+
+      const { prepareMint } = await minter.getToken({
+        mintType: "1155",
+        tokenContract: targetContract,
+        tokenId: targetTokenId,
+      });
+
+      const quantityToMint = 1n;
+
+      const { parameters, erc20Approval, costs } = prepareMint({
+        minterAccount: mockCollector,
+        quantityToMint,
+      });
+
+      expect(erc20Approval).toBeDefined();
+      expect(costs.totalCostEth).toBe(0n);
+      expect(costs.totalPurchaseCost).toBe(
+        quantityToMint * 1000000000000000000n,
+      );
+      expect(costs.totalPurchaseCostCurrency).toBe(
+        "0xa6b280b42cb0b7c4a4f789ec6ccc3a7609a1bc39",
+      );
+
+      const beforeERC20Balance = await publicClient.readContract({
+        abi: erc20Abi,
+        address: erc20Approval!.erc20,
+        functionName: "balanceOf",
+        args: [mockCollector],
+      });
+
+      // execute the erc20 approval
+      const { request: erc20Request } = await publicClient.simulateContract({
+        abi: erc20Abi,
+        address: erc20Approval!.erc20,
+        functionName: "approve",
+        args: [erc20Approval!.approveTo, erc20Approval!.quantity],
+        account: mockCollector,
+      });
+
+      const approveHash = await walletClient.writeContract(erc20Request);
+      await publicClient.waitForTransactionReceipt({
+        hash: approveHash,
+      });
+
+      const beforeCollector1155Balance = await publicClient.readContract({
+        abi: zoraCreator1155ImplABI,
+        address: targetContract,
+        functionName: "balanceOf",
+        args: [mockCollector, targetTokenId],
+      });
+      expect(beforeCollector1155Balance).to.be.equal(0n);
+
+      // execute the mint
+      const simulationResult = await publicClient.simulateContract(parameters);
+      const hash = await walletClient.writeContract(simulationResult.request);
+      await publicClient.waitForTransactionReceipt({ hash });
+
+      const afterERC20Balance = await publicClient.readContract({
+        abi: erc20Abi,
+        address: erc20Approval!.erc20,
+        functionName: "balanceOf",
+        args: [mockCollector],
+      });
+
+      expect(beforeERC20Balance - afterERC20Balance).to.be.equal(
+        erc20Approval!.quantity,
+      );
+
+      const afterCollector1155Balance = await publicClient.readContract({
+        abi: zoraCreator1155ImplABI,
+        address: targetContract,
+        functionName: "balanceOf",
+        args: [mockCollector, targetTokenId],
+      });
+      expect(afterCollector1155Balance).to.be.equal(quantityToMint);
+    },
+    12 * 1000,
+  );
+
+  makeAnvilTest({
+    forkUrl: forkUrls.zoraSepolia,
+    forkBlockNumber: 10294670,
+    anvilChainId: zoraSepolia.id,
+  })(
+    "gets onchain and premint mintables",
+    async ({ viemClients }) => {
+      const { publicClient, chain } = viemClients;
+
+      const targetContract: Address =
+        "0xa33e4228843092bb0f2fcbb2eb237bcefc1046b3";
+
+      const minter = createCollectorClient({ chainId: chain.id, publicClient });
+
+      const { tokens: mintables, contract } = await minter.getTokensOfContract({
+        tokenContract: targetContract,
+      });
+
+      expect(mintables.length).toBe(4);
+      expect(contract).toBeDefined();
+    },
+    12 * 1000,
+  );
+});

package/src/mint/mint-queries.ts

@@ -27,7 +27,6 @@ import {
 import { makeOnchainMintCall, parseMintCosts } from "./mint-transactions";
 import { buildPremintMintCall } from "src/premint/premint-client";
 import { IPublicClient } from "src/types";
-import { AllowListEntry } from "src/allow-list/types";
 
 export async function getMint({
   params,
@@ -130,13 +129,11 @@ export async function getMintsOfContract({
 
 export async function getMintCosts({
   params,
-  allowListEntry,
   mintGetter,
   premintGetter,
   publicClient,
 }: {
   params: GetMintCostsParameters;
-  allowListEntry?: Pick<AllowListEntry, "price">;
   mintGetter: IOnchainMintGetter;
   premintGetter: IPremintGetter;
   publicClient: IPublicClient;
@@ -153,7 +150,6 @@ export async function getMintCosts({
       mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
       salesConfig: salesConfigAndTokenInfo.salesConfig,
       quantityToMint: BigInt(quantityToMint),
-      allowListEntry,
     });
   }
 
@@ -262,7 +258,6 @@ const makeOnchainPrepareMint =
       salesConfig: result.salesConfig,
       quantityToMint: BigInt(params.quantityToMint),
       mintFeePerQuantity: result.mintFeePerQuantity,
-      allowListEntry: params.allowListEntry,
     }),
   });
 
@@ -291,7 +286,6 @@ const makePremintPrepareMint =
       mintFeePerQuantity: mintFee,
       quantityToMint: BigInt(params.quantityToMint),
       salesConfig: mintable.salesConfig,
-      allowListEntry: params.allowListEntry,
     }),
   });
 

package/src/mint/mint-transactions.ts

@@ -5,13 +5,12 @@ import {
   zeroAddress,
   Account,
   SimulateContractParameters,
-  Hex,
 } from "viem";
 import {
   erc20MinterABI,
   zoraCreator1155ImplABI,
 } from "@zoralabs/protocol-deployments";
-import { zora721Abi } from "src/constants";
+import { zora721Abi, zora1155LegacyAbi } from "src/constants";
 import {
   GenericTokenIdTypes,
   SimulateContractParametersWithAccount,
@@ -22,7 +21,6 @@ import { MakeMintParametersArgumentsBase } from "./types";
 
 import { contractSupportsNewMintFunction } from "./utils";
 import { OnchainSalesConfigAndTokenInfo } from "./types";
-import { AllowListEntry } from "src/allow-list/types";
 
 export function makeOnchainMintCall({
   token,
@@ -61,7 +59,6 @@ export function makePrepareMint1155TokenParams({
   mintReferral,
   mintRecipient,
   quantityToMint,
-  allowListEntry,
 }: {
   salesConfigAndTokenInfo: MintableParameters;
   tokenId: GenericTokenIdTypes;
@@ -73,7 +70,6 @@ export function makePrepareMint1155TokenParams({
   | "mintReferral"
   | "quantityToMint"
   | "mintRecipient"
-  | "allowListEntry"
 >): SimulateContractParameters<any, any, any, any, any, Address | Account> {
   const mintQuantity = BigInt(quantityToMint || 1);
 
@@ -81,7 +77,7 @@ export function makePrepareMint1155TokenParams({
 
   const saleType = salesConfigAndTokenInfo.salesConfig.saleType;
 
-  if (saleType === "fixedPrice" || saleType === "allowlist") {
+  if (saleType === "fixedPrice") {
     return makeEthMintCall({
       mintComment,
       minterAccount,
@@ -91,7 +87,6 @@ export function makePrepareMint1155TokenParams({
       salesConfigAndTokenInfo,
       tokenContract,
       tokenId,
-      allowListEntry,
     });
   }
 
@@ -142,7 +137,6 @@ function makePrepareMint721TokenParams({
     mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
     salesConfig: salesConfigAndTokenInfo.salesConfig,
     quantityToMint: actualQuantityToMint,
-    allowListEntry: undefined,
   }).totalCostEth;
 
   return makeContractParameters({
@@ -160,37 +154,6 @@ function makePrepareMint721TokenParams({
   });
 }
 
-function makeFixedPriceMinterArguments({
-  mintTo,
-  mintComment,
-}: {
-  mintTo: Address;
-  mintComment?: string;
-}) {
-  return encodeAbiParameters(parseAbiParameters("address, string"), [
-    mintTo,
-    mintComment || "",
-  ]);
-}
-
-function makeAllowListMinterArguments({
-  mintTo,
-  allowListEntry,
-}: {
-  mintTo: Address;
-  allowListEntry: AllowListEntry;
-}) {
-  return encodeAbiParameters(
-    parseAbiParameters("address, uint256, uint256, bytes32[]"),
-    [
-      mintTo,
-      BigInt(allowListEntry.maxCanMint),
-      allowListEntry.price,
-      allowListEntry.proof,
-    ],
-  );
-}
-
 function makeEthMintCall({
   tokenContract,
   tokenId,
@@ -200,7 +163,6 @@ function makeEthMintCall({
   mintReferral,
   mintQuantity,
   mintTo,
-  allowListEntry,
 }: {
   minterAccount: Account | Address;
   tokenContract: Address;
@@ -210,26 +172,17 @@ function makeEthMintCall({
   mintQuantity: bigint;
   mintComment?: string;
   mintReferral?: Address;
-  allowListEntry?: AllowListEntry;
 }): SimulateContractParametersWithAccount {
   const mintValue = parseMintCosts({
     mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
     salesConfig: salesConfigAndTokenInfo.salesConfig,
     quantityToMint: mintQuantity,
-    allowListEntry,
   }).totalCostEth;
 
-  const saleType = salesConfigAndTokenInfo.salesConfig.saleType;
-  let minterArguments: Hex;
-
-  if (saleType === "fixedPrice") {
-    minterArguments = makeFixedPriceMinterArguments({ mintTo, mintComment });
-  } else if (saleType === "allowlist") {
-    if (!allowListEntry) throw new Error("Missing allowListEntry");
-    minterArguments = makeAllowListMinterArguments({ mintTo, allowListEntry });
-  } else {
-    throw new Error("Unsupported sale type");
-  }
+  const minterArguments = encodeAbiParameters(
+    parseAbiParameters("address, string"),
+    [mintTo, mintComment || ""],
+  );
 
   // if based on contract version it has the new mint function,
   // call the new mint function.
@@ -254,7 +207,7 @@ function makeEthMintCall({
 
   // otherwise call the deprecated mint function
   return makeContractParameters({
-    abi: zoraCreator1155ImplABI,
+    abi: zora1155LegacyAbi,
     functionName: "mintWithRewards",
     account: minterAccount,
     value: mintValue,
@@ -270,37 +223,18 @@ function makeEthMintCall({
   });
 }
 
-function paidMintCost(
-  salesConfig: SaleStrategies,
-  allowListEntry?: Pick<AllowListEntry, "price">,
-) {
-  if (
-    salesConfig.saleType === "erc20" ||
-    salesConfig.saleType === "fixedPrice"
-  ) {
-    return salesConfig.pricePerToken;
-  }
-
-  if (allowListEntry) return allowListEntry.price;
-
-  return 0n;
-}
-
 export function parseMintCosts({
   salesConfig,
   mintFeePerQuantity,
   quantityToMint,
-  allowListEntry,
 }: {
   salesConfig: SaleStrategies;
   mintFeePerQuantity: bigint;
   quantityToMint: bigint;
-  allowListEntry: Pick<AllowListEntry, "price"> | undefined;
 }): MintCosts {
   const mintFeeForTokens = mintFeePerQuantity * quantityToMint;
 
-  const tokenPurchaseCost =
-    paidMintCost(salesConfig, allowListEntry) * quantityToMint;
+  const tokenPurchaseCost = BigInt(salesConfig.pricePerToken) * quantityToMint;
 
   const totalPurchaseCostCurrency = isErc20SaleStrategy(salesConfig)
     ? salesConfig.currency

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

@@ -16,12 +16,14 @@ import {
 import { querySubgraphWithRetries } from "src/utils";
 import {
   buildContractTokensQuery,
+  buildGetDefaultMintPriceQuery,
   buildNftTokenSalesQuery,
   buildPremintsOfContractQuery,
   ISubgraphQuery,
   SalesStrategyResult,
   TokenQueryResult,
 } from "./subgraph-queries";
+import * as semver from "semver";
 
 export const getApiNetworkConfigForChain = (chainId: number): NetworkConfig => {
   if (!networkConfigByChain[chainId]) {
@@ -53,23 +55,14 @@ function parseSalesConfig(
       pricePerToken: BigInt(targetStrategy.erc20Minter.pricePerToken),
     };
   }
-  if (targetStrategy.type === "PRESALE") {
-    return {
-      saleType: "allowlist",
-      address: targetStrategy.presale.address,
-      merkleRoot: targetStrategy.presale.merkleRoot,
-      saleStart: targetStrategy.presale.presaleStart,
-      saleEnd: targetStrategy.presale.presaleEnd,
-    };
-  }
 
   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);
-  return BigInt(a.presale.presaleEnd);
+  return BigInt(
+    a.type === "ERC_20_MINTER" ? a.erc20Minter.saleEnd : a.fixedPrice.saleEnd,
+  );
 }
 
 function getTargetStrategy({
@@ -115,6 +108,7 @@ function getTargetStrategy({
 
   return targetStrategy;
 }
+
 export class SubgraphMintGetter implements IOnchainMintGetter {
   httpClient: IHttpClient;
   networkConfig: NetworkConfig;
@@ -124,6 +118,18 @@ export class SubgraphMintGetter implements IOnchainMintGetter {
     this.networkConfig = getApiNetworkConfigForChain(chainId);
   }
 
+  async getContractMintFee(contract: TokenQueryResult["contract"]) {
+    const storedMintFee = BigInt(contract.mintFeePerQuantity);
+    if (!contractUsesMintCardsForMintFee(contract.contractVersion)) {
+      return storedMintFee;
+    }
+    const defaultMintFee = await this.querySubgraphWithRetries(
+      buildGetDefaultMintPriceQuery({}),
+    );
+
+    return defaultMintFee || storedMintFee;
+  }
+
   async querySubgraphWithRetries<T>({
     query,
     variables,
@@ -155,8 +161,11 @@ export class SubgraphMintGetter implements IOnchainMintGetter {
       throw new Error("Cannot find token");
     }
 
+    const defaultMintFee = await this.getContractMintFee(token.contract);
+
     return parseTokenQueryResult({
-      token,
+      token: token,
+      defaultMintFee,
       tokenId,
       preferredSaleType: saleType,
     });
@@ -175,7 +184,9 @@ export class SubgraphMintGetter implements IOnchainMintGetter {
       }),
     );
 
-    if (!tokens) return [];
+    if (!tokens || tokens.length === 0) return [];
+
+    const defaultMintFee = await this.getContractMintFee(tokens[0]!.contract);
 
     return tokens
       .filter((x) => x.tokenId !== "0")
@@ -184,6 +195,7 @@ export class SubgraphMintGetter implements IOnchainMintGetter {
           token,
           tokenId: token.tokenId,
           preferredSaleType,
+          defaultMintFee,
         }),
       );
   }
@@ -212,10 +224,12 @@ function parseTokenQueryResult({
   token,
   tokenId,
   preferredSaleType,
+  defaultMintFee,
 }: {
   token: TokenQueryResult;
   tokenId?: GenericTokenIdTypes;
   preferredSaleType?: SaleType;
+  defaultMintFee: bigint;
 }): OnchainSalesConfigAndTokenInfo {
   const targetStrategy = getTargetStrategy({
     tokenId,
@@ -223,7 +237,7 @@ function parseTokenQueryResult({
     token,
   });
 
-  const tokenInfo = parseTokenInfo(token);
+  const tokenInfo = parseTokenInfo(token, defaultMintFee);
 
   const salesConfig = parseSalesConfig(targetStrategy);
 
@@ -237,7 +251,17 @@ function parseTokenQueryResult({
   };
 }
 
-function parseTokenInfo(token: TokenQueryResult): OnchainMintable {
+const contractUsesMintCardsForMintFee = (contractVersion: string) => {
+  const semVerContractVersion = semver.coerce(contractVersion)?.raw;
+  if (!semVerContractVersion) return false;
+
+  return semver.gte(semVerContractVersion, "2.9.0");
+};
+
+function parseTokenInfo(
+  token: TokenQueryResult,
+  defaultMintFee: bigint,
+): OnchainMintable {
   return {
     contract: {
       address: token.contract.address,
@@ -250,7 +274,7 @@ function parseTokenInfo(token: TokenQueryResult): OnchainMintable {
     creator: token.creator,
     totalMinted: BigInt(token.totalMinted),
     maxSupply: BigInt(token.maxSupply),
-    mintFeePerQuantity: BigInt(token.contract.mintFeePerQuantity),
+    mintFeePerQuantity: defaultMintFee,
     contractVersion: token.contract.contractVersion,
   };
 }