@zoralabs/protocol-sdk 0.11.8 → 0.11.10

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,

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

@@ -1,5 +1,5 @@
 import { describe, expect, vi } from "vitest";
-import { parseEther, Address } from "viem";
+import { parseEther, Address, parseEventLogs } from "viem";
 import { zoraSepolia } from "viem/chains";
 import {
   forkUrls,
@@ -7,13 +7,22 @@ import {
   simulateAndWriteContractWithRetries,
 } from "src/anvil";
 import { createCollectorClient } from "src/sdk";
-import { zoraCreator1155ImplABI } from "@zoralabs/protocol-deployments";
+import {
+  zoraCreator1155ImplABI,
+  commentsABI,
+  callerAndCommenterABI,
+  PermitBuyOnSecondaryAndComment,
+  permitBuyOnSecondaryAndCommentTypedDataDefinition,
+  callerAndCommenterAddress,
+  sparkValue,
+} from "@zoralabs/protocol-deployments";
 import { SubgraphMintGetter } from "src/mint/subgraph-mint-getter";
 import { ERROR_SECONDARY_NOT_STARTED } from "./secondary-client";
 import { ISubgraphQuerier } from "src/apis/subgraph-querier";
 import { mockTimedSaleStrategyTokenQueryResult } from "src/fixtures/mint-query-results";
 import { new1155ContractVersion } from "src/create/contract-setup";
 import { advanceToSaleAndAndLaunchMarket } from "src/fixtures/secondary";
+import { randomNonce } from "src/test-utils";
 
 describe("secondary", () => {
   makeAnvilTest({
@@ -257,4 +266,241 @@ describe("secondary", () => {
     },
     30_000,
   );
+
+  makeAnvilTest({
+    forkBlockNumber: 16339853,
+    forkUrl: forkUrls.zoraSepolia,
+    anvilChainId: zoraSepolia.id,
+  })(
+    "it can buy on secondary with a comment",
+    async ({
+      viemClients: { publicClient, chain, walletClient, testClient },
+    }) => {
+      const collectorAccount = (await walletClient.getAddresses()!)[1]!;
+      const executorAccount = (await walletClient.getAddresses()!)[3]!;
+
+      const mintGetter = new SubgraphMintGetter(chain.id);
+      const contractAddress: Address =
+        "0xd42557f24034b53e7340a40bb5813ef9ba88f2b4";
+      const newTokenId = 4n;
+
+      await testClient.setBalance({
+        address: collectorAccount,
+        value: parseEther("100"),
+      });
+
+      mintGetter.subgraphQuerier.query = vi
+        .fn<ISubgraphQuerier["query"]>()
+        .mockResolvedValue({
+          zoraCreateToken: mockTimedSaleStrategyTokenQueryResult({
+            chainId: chain.id,
+            tokenId: newTokenId,
+            contractAddress,
+            contractVersion:
+              new1155ContractVersion[
+                chain.id as keyof typeof new1155ContractVersion
+              ],
+          }),
+        });
+
+      const collectorClient = createCollectorClient({
+        chainId: chain.id,
+        publicClient,
+        mintGetter,
+      });
+
+      const secondaryInfo = await collectorClient.getSecondaryInfo({
+        contract: contractAddress,
+        tokenId: newTokenId,
+      });
+
+      // mint enough to start the countdown
+      const quantityToMint =
+        secondaryInfo!.minimumMintsForCountdown! - secondaryInfo!.mintCount;
+
+      const { parameters: collectParameters } = await collectorClient.mint({
+        minterAccount: collectorAccount,
+        mintType: "1155",
+        quantityToMint: quantityToMint,
+        tokenId: newTokenId,
+        tokenContract: contractAddress,
+      });
+
+      await simulateAndWriteContractWithRetries({
+        parameters: collectParameters,
+        walletClient,
+        publicClient,
+      });
+
+      await advanceToSaleAndAndLaunchMarket({
+        contractAddress,
+        tokenId: newTokenId,
+        testClient,
+        publicClient,
+        walletClient,
+        collectorClient,
+        chainId: chain.id,
+        account: collectorAccount,
+      });
+
+      const buyResult = await collectorClient.buy1155OnSecondary({
+        account: collectorAccount,
+        quantity: 5n,
+        contract: contractAddress,
+        tokenId: newTokenId,
+        comment: "test comment",
+      });
+
+      const receipt = await simulateAndWriteContractWithRetries({
+        parameters: buyResult.parameters!,
+        walletClient,
+        publicClient,
+      });
+
+      const commentedEvent = parseEventLogs({
+        abi: commentsABI,
+        logs: receipt.logs,
+        eventName: "Commented",
+      });
+
+      expect(commentedEvent[0]).toBeDefined();
+      expect(commentedEvent[0]!.args.text).toBe("test comment");
+
+      const boughtAndCommentedEvent = parseEventLogs({
+        abi: callerAndCommenterABI,
+        logs: receipt.logs,
+        eventName: "SwappedOnSecondaryAndCommented",
+      });
+
+      expect(boughtAndCommentedEvent[0]).toBeDefined();
+      expect(boughtAndCommentedEvent[0]!.args.comment).toBe("test comment");
+      expect(boughtAndCommentedEvent[0]!.args.quantity).toBe(5n);
+      expect(boughtAndCommentedEvent[0]!.args.swapDirection).toBe(0);
+
+      // PERMIT BUY TEST
+      const buyResultASecondTime = await collectorClient.buy1155OnSecondary({
+        account: collectorAccount,
+        quantity: 5n,
+        contract: contractAddress,
+        tokenId: newTokenId,
+        comment: "test comment",
+      });
+
+      const valueToSend = (buyResultASecondTime.price!.wei.total * 105n) / 100n;
+
+      const { timestamp } = await publicClient.getBlock();
+
+      const permitBuy: PermitBuyOnSecondaryAndComment = {
+        collection: contractAddress,
+        tokenId: newTokenId,
+        quantity: 5n,
+        commenter: collectorAccount,
+        comment: "test comment",
+        maxEthToSpend: valueToSend,
+        deadline: timestamp + 30n,
+        sqrtPriceLimitX96: 0n,
+        nonce: randomNonce(),
+        sourceChainId: chain.id,
+        destinationChainId: chain.id,
+      };
+
+      const permitBuySignature = await walletClient.signTypedData(
+        permitBuyOnSecondaryAndCommentTypedDataDefinition(permitBuy),
+      );
+
+      await testClient.setBalance({
+        address: executorAccount,
+        value: parseEther("1"),
+      });
+
+      const { request } = await publicClient.simulateContract({
+        abi: callerAndCommenterABI,
+        address:
+          callerAndCommenterAddress[
+            chain.id as keyof typeof callerAndCommenterAddress
+          ],
+        functionName: "permitBuyOnSecondaryAndComment",
+        args: [permitBuy, permitBuySignature],
+        value: valueToSend,
+        account: executorAccount,
+      });
+
+      await simulateAndWriteContractWithRetries({
+        parameters: request,
+        walletClient,
+        publicClient,
+      });
+
+      // now PERMIT SELL ON SECONDARY TEST
+      const quantityToSell = 3n;
+
+      const sellResult = await collectorClient.sell1155OnSecondary({
+        account: collectorAccount,
+        quantity: quantityToSell,
+        contract: contractAddress,
+        tokenId: newTokenId,
+      });
+
+      expect(sellResult.error).toBeUndefined();
+
+      // approve 1155s for callerAndCommenter to transfer, when selling
+      await simulateAndWriteContractWithRetries({
+        parameters: {
+          abi: zoraCreator1155ImplABI,
+          address: contractAddress,
+          functionName: "setApprovalForAll",
+          account: collectorAccount,
+          args: [
+            callerAndCommenterAddress[
+              chain.id as keyof typeof callerAndCommenterAddress
+            ],
+            true,
+          ],
+        },
+        walletClient,
+        publicClient,
+      });
+
+      // now sell on secondary with comment
+      // by calling the caller and commenter contract
+      // if including a comment, must send sparkValue() as value
+      // function signature:
+      // function sellOnSecondaryAndComment(
+      //   address commenter,
+      //   uint256 quantity,
+      //   address collection,
+      //   uint256 tokenId,
+      //   address payable recipient,
+      //   uint256 minEthToAcquire,
+      //   uint160 sqrtPriceLimitX96,
+      //   string calldata comment
+      // )
+      await simulateAndWriteContractWithRetries({
+        parameters: {
+          abi: callerAndCommenterABI,
+          address:
+            callerAndCommenterAddress[
+              chain.id as keyof typeof callerAndCommenterAddress
+            ],
+          functionName: "sellOnSecondaryAndComment",
+          account: collectorAccount,
+          args: [
+            collectorAccount,
+            quantityToSell,
+            contractAddress,
+            newTokenId,
+            collectorAccount,
+            // sell result with slippage
+            (sellResult.price!.wei.total * 95n) / 100n,
+            0n,
+            "test comment",
+          ],
+          value: sparkValue(),
+        },
+        walletClient,
+        publicClient,
+      });
+    },
+    20_000,
+  );
 });