@zoralabs/protocol-sdk 0.11.4 → 0.11.6-COMMENTS.0

package/src/create/1155-create-helper.test.ts

@@ -3,7 +3,7 @@ import {
   getContractAddressFromReceipt,
   getTokenIdFromCreateReceipt,
 } from "./1155-create-helper";
-import { createCreatorClient } from "src/sdk";
+import { createCollectorClient, createCreatorClient } from "src/sdk";
 import {
   zoraCreator1155ImplABI,
   zoraTimedSaleStrategyABI,
@@ -12,20 +12,22 @@ import {
 import { waitForSuccess } from "src/test-utils";
 import { Address, erc20Abi, parseEther, PublicClient } from "viem";
 import { makePrepareMint1155TokenParams } from "src/mint/mint-transactions";
-import { forkUrls, makeAnvilTest, writeContractWithRetries } from "src/anvil";
+import {
+  forkUrls,
+  makeAnvilTest,
+  simulateAndWriteContractWithRetries,
+  writeContractWithRetries,
+} from "src/anvil";
 import { zora } from "viem/chains";
 import { AllowList } from "src/allow-list/types";
 import { createAllowList } from "src/allow-list/allow-list-client";
-import { NewContractParams } from "./types";
 import { SubgraphContractGetter } from "./contract-getter";
 import {
   DEFAULT_MINIMUM_MARKET_ETH,
   DEFAULT_MARKET_COUNTDOWN,
 } from "./minter-defaults";
-import {
-  demoContractMetadataURI,
-  demoTokenMetadataURI,
-} from "src/fixtures/contract-setup";
+import { randomNewContract } from "src/test-utils";
+import { demoTokenMetadataURI } from "src/fixtures/contract-setup";
 
 const anvilTest = makeAnvilTest({
   forkUrl: forkUrls.zoraMainnet,
@@ -56,13 +58,6 @@ const minterIsMinterOnToken = async ({
   });
 };
 
-function randomNewContract(): NewContractParams {
-  return {
-    name: `testContract-${Math.round(Math.random() * 1_000_000)}`,
-    uri: demoContractMetadataURI,
-  };
-}
-
 describe("create-helper", () => {
   anvilTest(
     "when no sales config is provided, it creates a new 1155 contract and token using the timed sale strategy",
@@ -143,6 +138,74 @@ describe("create-helper", () => {
             ],
         }),
       ).toBe(true);
+
+      // get secondary info, minimum mints count should be 1111, sale end should be undefined,
+      // market countdown should be 24 hours
+
+      const collectorClient = createCollectorClient({
+        chainId: chain.id,
+        publicClient,
+      });
+
+      const secondaryInfo = await collectorClient.getSecondaryInfo({
+        contract: contractAddress,
+        tokenId: newTokenId,
+      });
+
+      expect(secondaryInfo).toBeDefined();
+      expect(secondaryInfo!.minimumMintsForCountdown).toBe(1111n);
+      expect(secondaryInfo!.secondaryActivated).toBe(false);
+      expect(secondaryInfo!.saleEnd).toBeUndefined();
+      expect(secondaryInfo!.marketCountdown).toBe(24n * 60n * 60n);
+    },
+    20 * 1000,
+  );
+  anvilTest(
+    "when minimumMintsForCountdown is set, it uses that as the minimum mints for countdown",
+    async ({ viemClients: { publicClient, walletClient, chain } }) => {
+      const addresses = await walletClient.getAddresses();
+      const creatorAddress = addresses[0]!;
+
+      const creatorClient = createCreatorClient({
+        chainId: chain.id,
+        publicClient: publicClient,
+      });
+
+      const saleStart = 5n;
+      const contract = randomNewContract();
+      const { parameters, contractAddress, newTokenId } =
+        await creatorClient.create1155({
+          contract,
+          token: {
+            tokenMetadataURI: demoTokenMetadataURI,
+            mintToCreatorCount: 1,
+            salesConfig: {
+              saleStart,
+              minimumMintsForCountdown: 500n,
+              marketCountdown: 100n,
+              type: "timed",
+            },
+          },
+          account: creatorAddress,
+        });
+
+      await simulateAndWriteContractWithRetries({
+        parameters,
+        walletClient,
+        publicClient,
+      });
+
+      const secondaryInfo = await createCollectorClient({
+        chainId: chain.id,
+        publicClient,
+      }).getSecondaryInfo({
+        contract: contractAddress,
+        tokenId: newTokenId,
+      });
+
+      expect(secondaryInfo).toBeDefined();
+      expect(secondaryInfo!.minimumMintsForCountdown).toBe(500n);
+      expect(secondaryInfo!.marketCountdown).toBe(100n);
     },
     20 * 1000,
   );

package/src/create/1155-create-helper.ts

@@ -238,6 +238,7 @@ async function createNew1155ContractAndToken({
         publicClient,
         chainId,
       }),
+    chainId,
   });
 
   return {
@@ -294,6 +295,7 @@ async function createNew1155Token({
     result: newToken.salesConfig,
     tokenId: nextTokenId,
     getContractMintFee: async () => mintFee,
+    chainId,
   });
 
   return {

package/src/create/mint-from-create.ts

@@ -75,6 +75,7 @@ export function makeOnchainPrepareMintFromCreate({
   minter,
   getContractMintFee,
   contractVersion,
+  chainId,
 }: {
   contractAddress: Address;
   tokenId: bigint;
@@ -82,6 +83,7 @@ export function makeOnchainPrepareMintFromCreate({
   minter: Address;
   getContractMintFee: () => Promise<bigint>;
   contractVersion: string;
+  chainId: number;
 }): AsyncPrepareMint {
   return async (params: MintParametersBase): Promise<PrepareMintReturn> => {
     const subgraphSalesConfig = await toSalesStrategyFromSubgraph({
@@ -98,6 +100,7 @@ export function makeOnchainPrepareMintFromCreate({
         ...params,
         tokenContract: contractAddress,
         tokenId,
+        chainId,
       }),
       costs: parseMintCosts({
         allowListEntry: params.allowListEntry,

package/src/create/minter-defaults.ts

@@ -79,24 +79,38 @@ export const parseNameIntoSymbol = (name: string) => {
   return result;
 };
 
+const getMinimumMarketEth = (
+  params: Pick<
+    TimedSaleParamsType,
+    "minimumMarketEth" | "minimumMintsForCountdown"
+  >,
+) => {
+  if (params.minimumMintsForCountdown) {
+    return params.minimumMintsForCountdown * parseEther("0.0000111");
+  }
+  return params.minimumMarketEth || DEFAULT_MINIMUM_MARKET_ETH;
+};
+
 const timedSaleSettingsWithDefaults = (
   params: TimedSaleParamsType,
   contractName: string,
 ): Concrete<TimedSaleParamsType> => {
   // If the name is not provided, try to fetch it from the metadata
   const erc20Name = params.erc20Name || contractName;
-  const symbol = params.erc20Symbol || parseNameIntoSymbol(erc20Name);
-  const start = params.saleStart || 0n;
-  const countdown = params.marketCountdown || DEFAULT_MARKET_COUNTDOWN;
-  const minimumEth = params.minimumMarketEth || DEFAULT_MINIMUM_MARKET_ETH;
+  const minimumMarketEth = getMinimumMarketEth({
+    minimumMarketEth: params.minimumMarketEth,
+    minimumMintsForCountdown: params.minimumMintsForCountdown,
+  });
+  const minimumMintsForCountdown = minimumMarketEth / parseEther("0.0000111");
 
   return {
     type: "timed",
     erc20Name: erc20Name,
-    erc20Symbol: symbol,
-    saleStart: start,
-    marketCountdown: countdown,
-    minimumMarketEth: minimumEth,
+    erc20Symbol: params.erc20Symbol || parseNameIntoSymbol(erc20Name),
+    saleStart: params.saleStart || 0n,
+    marketCountdown: params.marketCountdown || DEFAULT_MARKET_COUNTDOWN,
+    minimumMarketEth,
+    minimumMintsForCountdown,
   };
 };
 

package/src/create/types.ts

@@ -33,12 +33,14 @@ export type TimedSaleParamsType = {
   erc20Name?: string;
   // Symbol of the erc20z token to create for the secondary sale.  If not provided, extracts it from the name.
   erc20Symbol?: string;
-  // Sale start time
+  // Earliest time a token can be minted.  If undefined or 0, then it can be minted immediately.  Defaults to 0n.
   saleStart?: bigint;
-  // Market countdown
+  // Market countdown that will start once the minimum mints for countdown is reached. Defaults to 24 hours.
   marketCountdown?: bigint;
-  // Minimum market ETH amount
+  // Deprecated: Use minimumMintsForCountdown instead.
   minimumMarketEth?: bigint;
+  // Minimum mints that will trigger the countdown.  Defaults to 1111
+  minimumMintsForCountdown?: bigint;
 };
 
 export type Erc20ParamsType = SaleStartAndEnd &

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

@@ -1,16 +1,28 @@
 import { describe, expect, vi } from "vitest";
-import { Address, erc20Abi, parseAbi, parseEther } from "viem";
+import {
+  Address,
+  erc20Abi,
+  parseAbi,
+  parseEther,
+  TransactionReceipt,
+  parseEventLogs,
+} from "viem";
 import { zora, zoraSepolia } from "viem/chains";
-import { zoraCreator1155ImplABI } from "@zoralabs/protocol-deployments";
+import {
+  zoraCreator1155ImplABI,
+  CommentIdentifier,
+  commentsABI,
+  callerAndCommenterABI,
+} from "@zoralabs/protocol-deployments";
 import { forkUrls, makeAnvilTest, writeContractWithRetries } from "src/anvil";
 import { createCollectorClient, createCreatorClient } from "src/sdk";
 import { getAllowListEntry } from "src/allow-list/allow-list-client";
+import { SubgraphMintGetter } from "./subgraph-mint-getter";
+import { new1155ContractVersion } from "src/create/contract-setup";
 import {
   demoContractMetadataURI,
   demoTokenMetadataURI,
-} from "src/create/1155-create-helper.test";
-import { SubgraphMintGetter } from "./subgraph-mint-getter";
-import { new1155ContractVersion } from "src/create/contract-setup";
+} from "src/fixtures/contract-setup";
 import { ISubgraphQuerier } from "src/apis/subgraph-querier";
 import { mockTimedSaleStrategyTokenQueryResult } from "src/fixtures/mint-query-results";
 
@@ -18,52 +30,64 @@ const erc721ABI = parseAbi([
   "function balanceOf(address owner) public view returns (uint256)",
 ] as const);
 
+const getCommentIdentifierFromReceipt = (
+  receipt: TransactionReceipt,
+): CommentIdentifier => {
+  const logs = parseEventLogs({
+    abi: commentsABI,
+    logs: receipt.logs,
+    eventName: "Commented",
+  });
+
+  if (logs.length === 0) {
+    throw new Error("No Commented event found in receipt");
+  }
+
+  return logs[0]!.args.commentIdentifier;
+};
+
 describe("mint-helper", () => {
   makeAnvilTest({
-    forkBlockNumber: 16028671,
-    forkUrl: forkUrls.zoraMainnet,
-    anvilChainId: zora.id,
+    forkBlockNumber: 16028124,
+    forkUrl: forkUrls.zoraSepolia,
+    anvilChainId: zoraSepolia.id,
   })(
-    "mints a new 1155 token",
+    "mints a new 1155 token with a comment",
     async ({ viemClients }) => {
-      const { testClient, walletClient, publicClient } = viemClients;
+      const { testClient, walletClient, publicClient, chain } = viemClients;
       const creatorAccount = (await walletClient.getAddresses())[0]!;
       await testClient.setBalance({
         address: creatorAccount,
         value: parseEther("2000"),
       });
       const targetContract: Address =
-        "0xa2fea3537915dc6c7c7a97a82d1236041e6feb2e";
-      const targetTokenId = 1n;
+        "0xD42557F24034b53e7340A40bb5813eF9Ba88F2b4";
+      const targetTokenId = 3n;
       const collectorClient = createCollectorClient({
-        chainId: zora.id,
+        chainId: chain.id,
         publicClient,
       });
 
-      const {
-        token: mintable,
-        prepareMint,
-        primaryMintActive,
-      } = await collectorClient.getToken({
-        tokenContract: targetContract,
-        mintType: "1155",
-        tokenId: targetTokenId,
-      });
-
-      mintable.maxSupply;
-      mintable.totalMinted;
-      mintable.tokenURI;
-      mintable;
+      const { prepareMint, primaryMintActive } = await collectorClient.getToken(
+        {
+          tokenContract: targetContract,
+          mintType: "1155",
+          tokenId: targetTokenId,
+        },
+      );
 
       expect(primaryMintActive).toBe(true);
       expect(prepareMint).toBeDefined();
 
+      const quantityToMint = 5n;
+
       const { parameters, costs } = prepareMint!({
         minterAccount: creatorAccount,
-        quantityToMint: 1,
+        quantityToMint,
+        mintComment: "This is a fun comment :)",
       });
 
-      expect(costs.totalCostEth).toBe(1n * parseEther("0.000777"));
+      expect(costs.totalCostEth).toBe(quantityToMint * parseEther("0.000111"));
 
       const oldBalance = await publicClient.readContract({
         abi: zoraCreator1155ImplABI,
@@ -84,7 +108,20 @@ describe("mint-helper", () => {
       });
       expect(receipt).to.not.be.null;
       expect(oldBalance).to.be.equal(0n);
-      expect(newBalance).to.be.equal(1n);
+      expect(newBalance).to.be.equal(quantityToMint);
+
+      // search for the Commented event in the logs
+      const commentIdentifier = getCommentIdentifierFromReceipt(receipt);
+
+      expect(commentIdentifier).toBeDefined();
+
+      const logs = parseEventLogs({
+        abi: callerAndCommenterABI,
+        logs: receipt.logs,
+        eventName: "MintedAndCommented",
+      });
+
+      expect(logs.length).toBe(1);
     },
     12 * 1000,
   );

package/src/mint/mint-client.ts

@@ -24,19 +24,22 @@ export class MintClient {
   private readonly publicClient: IPublicClient;
   private readonly mintGetter: IOnchainMintGetter;
   private readonly premintGetter: IPremintGetter;
-
+  private readonly chainId: number;
   constructor({
     publicClient,
     premintGetter,
     mintGetter,
+    chainId,
   }: {
     publicClient: IPublicClient;
     premintGetter: IPremintGetter;
     mintGetter: IOnchainMintGetter;
+    chainId: number;
   }) {
     this.publicClient = publicClient;
     this.mintGetter = mintGetter;
     this.premintGetter = premintGetter;
+    this.chainId = chainId;
   }
 
   /**
@@ -54,6 +57,7 @@ export class MintClient {
       publicClient: this.publicClient,
       mintGetter: this.mintGetter,
       premintGetter: this.premintGetter,
+      chainId: this.chainId,
     });
   }
 
@@ -69,6 +73,7 @@ export class MintClient {
       mintGetter: this.mintGetter,
       premintGetter: this.premintGetter,
       publicClient: this.publicClient,
+      chainId: this.chainId,
     });
   }
 
@@ -87,6 +92,7 @@ export class MintClient {
       mintGetter: this.mintGetter,
       premintGetter: this.premintGetter,
       publicClient: this.publicClient,
+      chainId: this.chainId,
     });
   }
 
@@ -110,17 +116,20 @@ async function mint({
   publicClient,
   mintGetter,
   premintGetter,
+  chainId,
 }: {
   parameters: MakeMintParametersArguments;
   publicClient: IPublicClient;
   mintGetter: IOnchainMintGetter;
   premintGetter: IPremintGetter;
+  chainId: number;
 }): Promise<PrepareMintReturn> {
   const { prepareMint, primaryMintActive } = await getMint({
     params: parameters,
     mintGetter,
     premintGetter,
     publicClient,
+    chainId,
   });
 
   if (!primaryMintActive) {

package/src/mint/mint-queries.ts

@@ -36,11 +36,13 @@ export async function getMint({
   mintGetter,
   premintGetter,
   publicClient,
+  chainId,
 }: {
   params: GetMintParameters;
   mintGetter: IOnchainMintGetter;
   premintGetter: IPremintGetter;
   publicClient: IPublicClient;
+  chainId: number;
 }): Promise<MintableReturn> {
   const { tokenContract } = params;
   if (isOnChainMint(params)) {
@@ -53,7 +55,7 @@ export async function getMint({
       blockTime: blockTime,
     });
 
-    return toMintableReturn(result);
+    return toMintableReturn(result, chainId);
   }
 
   const premint = await premintGetter.get({
@@ -103,17 +105,19 @@ export async function getMintsOfContract({
   mintGetter,
   premintGetter,
   publicClient,
+  chainId,
 }: {
   params: GetMintsOfContractParameters;
   mintGetter: IOnchainMintGetter;
   premintGetter: IPremintGetter;
   publicClient: IPublicClient;
+  chainId: number;
 }): Promise<{ contract?: ContractInfo; tokens: MintableReturn[] }> {
   const onchainMints = (
     await mintGetter.getContractMintable({
       tokenAddress: params.tokenContract,
     })
-  ).map(toMintableReturn);
+  ).map((result) => toMintableReturn(result, chainId));
 
   const offchainMints = await getPremintsOfContractMintable({
     mintGetter,
@@ -270,7 +274,7 @@ function parsePremint({
 }
 
 export const makeOnchainPrepareMint =
-  (result: OnchainSalesConfigAndTokenInfo): PrepareMint =>
+  (result: OnchainSalesConfigAndTokenInfo, chainId: number): PrepareMint =>
   (params: MintParametersBase) => {
     if (!result.salesConfig) {
       throw new Error("No valid sales config found for token");
@@ -280,6 +284,7 @@ export const makeOnchainPrepareMint =
       parameters: makeOnchainMintCall({
         token: result as Concrete<OnchainSalesConfigAndTokenInfo>,
         mintParams: params,
+        chainId,
       }),
       erc20Approval: getRequiredErc20Approvals(params, result.salesConfig),
       costs: parseMintCosts({
@@ -290,7 +295,10 @@ export const makeOnchainPrepareMint =
     };
   };
 
-function toMintableReturn(result: GetMintableReturn): MintableReturn {
+function toMintableReturn(
+  result: GetMintableReturn,
+  chainId: number,
+): MintableReturn {
   const primaryMintActive = result.primaryMintActive;
   if (!primaryMintActive) {
     return {
@@ -306,7 +314,10 @@ function toMintableReturn(result: GetMintableReturn): MintableReturn {
     primaryMintActive,
     primaryMintEnd: result.primaryMintEnd,
     secondaryMarketActive: result.secondaryMarketActive,
-    prepareMint: makeOnchainPrepareMint(result.salesConfigAndTokenInfo),
+    prepareMint: makeOnchainPrepareMint(
+      result.salesConfigAndTokenInfo,
+      chainId,
+    ),
   };
 }
 

package/src/mint/mint-transactions.ts

@@ -11,6 +11,8 @@ import {
   erc20MinterABI,
   zoraCreator1155ImplABI,
   zoraTimedSaleStrategyABI,
+  callerAndCommenterABI,
+  callerAndCommenterAddress,
 } from "@zoralabs/protocol-deployments";
 import { zora721Abi, zora1155LegacyAbi } from "src/constants";
 import {
@@ -32,9 +34,11 @@ import { AllowListEntry } from "src/allow-list/types";
 export function makeOnchainMintCall({
   token,
   mintParams,
+  chainId,
 }: {
   token: Concrete<OnchainSalesConfigAndTokenInfo>;
   mintParams: Omit<MakeMintParametersArgumentsBase, "tokenContract">;
+  chainId: number;
 }): SimulateContractParametersWithAccount {
   if (token.mintType === "721") {
     return makePrepareMint721TokenParams({
@@ -48,6 +52,7 @@ export function makeOnchainMintCall({
     salesConfigAndTokenInfo: token,
     tokenContract: token.contract.address,
     tokenId: token.tokenId!,
+    chainId,
     ...mintParams,
   });
 }
@@ -57,6 +62,69 @@ export type MintableParameters = Pick<
   "contractVersion" | "salesConfig"
 >;
 
+function makeZoraTimedSaleStrategyMintCall({
+  minterAccount,
+  salesConfigAndTokenInfo,
+  mintQuantity,
+  mintTo,
+  tokenContract,
+  tokenId,
+  mintReferral,
+  mintComment,
+  chainId,
+}: {
+  minterAccount: Address | Account;
+  salesConfigAndTokenInfo: Concrete<MintableParameters>;
+  mintQuantity: bigint;
+  mintTo: Address;
+  tokenContract: Address;
+  tokenId: GenericTokenIdTypes;
+  mintReferral?: Address;
+  mintComment?: string;
+  chainId: number;
+}) {
+  // if there is a mint comment, use the caller and commenter
+  if (mintComment && mintComment !== "") {
+    return makeContractParameters({
+      abi: callerAndCommenterABI,
+      address:
+        callerAndCommenterAddress[
+          chainId as keyof typeof callerAndCommenterAddress
+        ],
+      functionName: "timedSaleMintAndComment",
+      account: minterAccount,
+      value:
+        salesConfigAndTokenInfo.salesConfig.mintFeePerQuantity * mintQuantity,
+      args: [
+        mintTo,
+        mintQuantity,
+        tokenContract,
+        tokenId,
+        mintReferral || zeroAddress,
+        mintComment,
+      ],
+    });
+  }
+
+  return makeContractParameters({
+    abi: zoraTimedSaleStrategyABI,
+    functionName: "mint",
+    account: minterAccount,
+    address: salesConfigAndTokenInfo.salesConfig.address,
+    value:
+      salesConfigAndTokenInfo.salesConfig.mintFeePerQuantity * mintQuantity,
+    /* args: mintTo, quantity, collection, tokenId, mintReferral, comment */
+    args: [
+      mintTo,
+      mintQuantity,
+      tokenContract,
+      BigInt(tokenId),
+      mintReferral || zeroAddress,
+      "",
+    ],
+  });
+}
+
 export function makePrepareMint1155TokenParams({
   tokenContract: tokenContract,
   tokenId,
@@ -67,9 +135,11 @@ export function makePrepareMint1155TokenParams({
   mintRecipient,
   quantityToMint,
   allowListEntry,
+  chainId,
 }: {
   salesConfigAndTokenInfo: Concrete<MintableParameters>;
   tokenId: GenericTokenIdTypes;
+  chainId: number;
 } & Pick<
   MakeMintParametersArgumentsBase,
   | "minterAccount"
@@ -101,22 +171,16 @@ export function makePrepareMint1155TokenParams({
   }
 
   if (saleType === "timed") {
-    return makeContractParameters({
-      abi: zoraTimedSaleStrategyABI,
-      functionName: "mint",
-      account: minterAccount,
-      address: salesConfigAndTokenInfo.salesConfig.address,
-      value:
-        salesConfigAndTokenInfo.salesConfig.mintFeePerQuantity * mintQuantity,
-      /* args: mintTo, quantity, collection, tokenId, mintReferral, comment */
-      args: [
-        mintTo,
-        mintQuantity,
-        tokenContract,
-        BigInt(tokenId),
-        mintReferral || zeroAddress,
-        mintComment || "",
-      ],
+    return makeZoraTimedSaleStrategyMintCall({
+      minterAccount,
+      salesConfigAndTokenInfo,
+      mintQuantity,
+      mintTo,
+      tokenContract,
+      tokenId,
+      mintReferral,
+      mintComment,
+      chainId,
     });
   }
 

package/src/sdk.ts

@@ -116,6 +116,7 @@ export function createCollectorClient(
     publicClient: params.publicClient,
     premintGetter: premintGetterToUse,
     mintGetter: mintGetterToUse,
+    chainId: params.chainId,
   });
   const secondaryClient = new SecondaryClient({
     publicClient: params.publicClient,