@zoralabs/protocol-sdk 0.11.8 → 0.11.10

package/src/comments/comments.test.ts

@@ -0,0 +1,338 @@
+import { describe, expect } from "vitest";
+import { forkUrls, makeAnvilTest, writeContractWithRetries } from "src/anvil";
+import { base, zora } from "viem/chains";
+import {
+  commentsABI,
+  commentsAddress,
+  emptyCommentIdentifier,
+  PermitComment,
+  PermitSparkComment,
+  sparkValue,
+  CommentIdentifier,
+  permitSparkCommentTypedDataDefinition,
+  permitMintAndCommentTypedDataDefinition,
+  PermitMintAndComment,
+  callerAndCommenterAddress as callerAndCommenterAddresses,
+  callerAndCommenterABI,
+  zoraCreator1155ImplABI,
+} from "@zoralabs/protocol-deployments";
+import {
+  Address,
+  zeroAddress,
+  parseEther,
+  TransactionReceipt,
+  parseEventLogs,
+  hashTypedData,
+} from "viem";
+import { createCreatorClient } from "src/sdk";
+import { randomNewContract, waitForSuccess } from "src/test-utils";
+import { permitCommentTypedDataDefinition } from "@zoralabs/protocol-deployments";
+import { demoTokenMetadataURI } from "src/fixtures/contract-setup";
+import { randomNonce, thirtySecondsFromNow } from "src/test-utils";
+
+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;
+};
+
+// todo: move this to protocol-deployments
+describe("comments", () => {
+  makeAnvilTest({
+    forkUrl: forkUrls.zoraMainnet,
+    forkBlockNumber: 21297211,
+    anvilChainId: zora.id,
+  })(
+    "can sign and execute a cross-chain comment, and sign and execute a cross-chain spark comment",
+    async ({
+      viemClients: { publicClient, walletClient, chain, testClient },
+    }) => {
+      // Get the chain ID and set up addresses for different roles
+      const chainId = chain.id;
+      const [
+        collectorAddress,
+        creatorAddress,
+        executorAddress,
+        sparkerAddress,
+      ] = (await walletClient.getAddresses()!) as [
+        Address,
+        Address,
+        Address,
+        Address,
+      ];
+
+      // Create a creator client for interacting with the protocol
+      const creatorClient = createCreatorClient({
+        chainId,
+        publicClient,
+      });
+
+      // Step 1: Create a new 1155 contract and token
+      const { contractAddress, newTokenId, parameters, prepareMint } =
+        await creatorClient.create1155({
+          contract: randomNewContract(),
+          token: {
+            tokenMetadataURI: demoTokenMetadataURI,
+          },
+          account: creatorAddress,
+        });
+
+      // Deploy the new contract
+      const { request } = await publicClient.simulateContract(parameters);
+      await writeContractWithRetries({
+        request,
+        walletClient,
+        publicClient,
+      });
+
+      // Prepare to mint a token
+      const { parameters: collectParameters } = await prepareMint({
+        quantityToMint: 1n,
+        minterAccount: collectorAddress,
+      });
+
+      // Step 2: Mint an 1155 token on the new contract
+      const { request: mintRequest } =
+        await publicClient.simulateContract(collectParameters);
+      await writeContractWithRetries({
+        request: mintRequest,
+        walletClient,
+        publicClient,
+      });
+
+      // Set up cross-chain comment parameters
+      const sourceChainId = base.id; // The chain ID where the comment originates
+
+      const commentsAddressForChainId =
+        commentsAddress[chainId as keyof typeof commentsAddress];
+
+      // Step 3: Prepare a cross-chain comment
+      const permitComment: PermitComment = {
+        sourceChainId,
+        contractAddress,
+        destinationChainId: chainId,
+        tokenId: newTokenId,
+        commenter: collectorAddress,
+        text: "hello world",
+        deadline: thirtySecondsFromNow(),
+        nonce: randomNonce(),
+        referrer: zeroAddress,
+        commenterSmartWallet: zeroAddress,
+        replyTo: emptyCommentIdentifier(),
+      };
+
+      // Generate typed data for signing
+      const typedData = permitCommentTypedDataDefinition(permitComment);
+
+      expect(typedData.domain!.chainId).toEqual(sourceChainId);
+      expect(typedData.account).toEqual(collectorAddress);
+      expect(typedData.domain!.verifyingContract).toEqual(
+        commentsAddressForChainId,
+      );
+      expect(typedData.domain!.verifyingContract).toEqual(
+        commentsAddressForChainId,
+      );
+
+      const hashed = await publicClient.readContract({
+        abi: commentsABI,
+        address: commentsAddressForChainId,
+        functionName: "hashPermitComment",
+        args: [permitComment],
+      });
+
+      expect(hashed).toEqual(hashTypedData(typedData));
+
+      // Ensure the commenter has enough balance for the spark value
+      await testClient.setBalance({
+        address: collectorAddress,
+        value: sparkValue(),
+      });
+
+      // Step 4: Sign the cross-chain comment
+      const signature = await walletClient.signTypedData(typedData);
+
+      // Ensure the executor has enough balance to execute the transaction
+      await testClient.setBalance({
+        address: executorAddress,
+        value: parseEther("1"),
+      });
+
+      // Step 5: Simulate and execute the cross-chain comment
+      const { request: commentRequest } = await publicClient.simulateContract({
+        abi: commentsABI,
+        address: commentsAddressForChainId,
+        functionName: "permitComment",
+        args: [permitComment, signature],
+        account: executorAddress,
+        value: sparkValue(),
+      });
+
+      const commentHash = await walletClient.writeContract(commentRequest);
+      const receipt = await publicClient.waitForTransactionReceipt({
+        hash: commentHash,
+      });
+
+      expect(receipt.status).toBe("success");
+
+      // Extract the comment identifier from the transaction receipt
+      const commentIdentifier = getCommentIdentifierFromReceipt(receipt);
+
+      // Step 6: Prepare a spark (like) for the comment
+      const sparkComment: PermitSparkComment = {
+        sparksQuantity: 3n,
+        sparker: sparkerAddress,
+        deadline: thirtySecondsFromNow(),
+        nonce: randomNonce(),
+        referrer: zeroAddress,
+        sourceChainId,
+        destinationChainId: chainId,
+        comment: commentIdentifier,
+      };
+
+      const sparkTypedData =
+        permitSparkCommentTypedDataDefinition(sparkComment);
+
+      // Step 7: Sign the spark comment
+      const sparkSignature = await walletClient.signTypedData(sparkTypedData);
+
+      // Step 8: Simulate and execute the spark comment
+      const { request: sparkRequest } = await publicClient.simulateContract({
+        abi: commentsABI,
+        address: commentsAddressForChainId,
+        functionName: "permitSparkComment",
+        args: [sparkComment, sparkSignature],
+        account: executorAddress,
+        value: sparkValue() * sparkComment.sparksQuantity,
+      });
+
+      const sparkHash = await walletClient.writeContract(sparkRequest);
+
+      await waitForSuccess(sparkHash, publicClient);
+
+      // Step 9: Verify the spark count
+      const sparkCount = await publicClient.readContract({
+        abi: commentsABI,
+        address: commentsAddressForChainId,
+        functionName: "commentSparksQuantity",
+        args: [commentIdentifier],
+      });
+
+      expect(sparkCount).toEqual(sparkComment.sparksQuantity);
+    },
+    40_000,
+  );
+  makeAnvilTest({
+    forkUrl: forkUrls.zoraMainnet,
+    forkBlockNumber: 21297211,
+    anvilChainId: zora.id,
+  })(
+    "can sign and execute a cross-chain timed sale mint and comment",
+    async ({
+      viemClients: { publicClient, walletClient, chain, testClient },
+    }) => {
+      // Get the chain ID and set up addresses for different roles
+      const chainId = chain.id;
+      const [commenterAddress, executorAddress] =
+        (await walletClient.getAddresses()!) as [Address, Address, Address];
+
+      // Create a creator client for interacting with the protocol
+      const creatorClient = createCreatorClient({
+        chainId,
+        publicClient,
+      });
+
+      // Step 1: Create a new 1155 contract and token
+      const { contractAddress, newTokenId, parameters } =
+        await creatorClient.create1155({
+          contract: randomNewContract(),
+          token: {
+            tokenMetadataURI: demoTokenMetadataURI,
+          },
+          account: commenterAddress,
+        });
+
+      // Deploy the new contract
+      const { request } = await publicClient.simulateContract(parameters);
+      await writeContractWithRetries({
+        request,
+        walletClient,
+        publicClient,
+      });
+
+      // Step 2: Prepare the permit data for timed sale mint and comment
+      const quantity = 3n;
+      const mintReferral = zeroAddress;
+      const comment = "This is a test comment for timed sale mint";
+
+      const permitMintAndComment: PermitMintAndComment = {
+        commenter: commenterAddress,
+        quantity,
+        collection: contractAddress,
+        tokenId: newTokenId,
+        mintReferral,
+        comment,
+        deadline: thirtySecondsFromNow(),
+        nonce: randomNonce(),
+        sourceChainId: chainId,
+        destinationChainId: chainId,
+      };
+
+      // Step 3: Generate the typed data for signing
+      const typedData =
+        permitMintAndCommentTypedDataDefinition(permitMintAndComment);
+
+      // Step 4: Sign the typed data
+      const signature = await walletClient.signTypedData(typedData);
+
+      await testClient.setBalance({
+        address: executorAddress,
+        value: parseEther("1"),
+      });
+
+      // Step 5: Simulate and execute the permitTimedSaleMintAndComment function
+      const callerAndCommenterAddress =
+        callerAndCommenterAddresses[
+          chainId as keyof typeof callerAndCommenterAddresses
+        ];
+      const { request: permitRequest } = await publicClient.simulateContract({
+        abi: callerAndCommenterABI,
+        address: callerAndCommenterAddress,
+        functionName: "permitTimedSaleMintAndComment",
+        args: [permitMintAndComment, signature],
+        account: executorAddress,
+        value: quantity * parseEther("0.000111"),
+      });
+
+      const receipt = await writeContractWithRetries({
+        publicClient,
+        walletClient,
+        request: permitRequest,
+      });
+
+      // Step 6: Verify the comment was created
+      const commentIdentifier = getCommentIdentifierFromReceipt(receipt);
+      expect(commentIdentifier).toBeDefined();
+
+      // Step 7: Verify the token was minted
+      const balance = await publicClient.readContract({
+        abi: zoraCreator1155ImplABI,
+        address: contractAddress,
+        functionName: "balanceOf",
+        args: [commenterAddress, newTokenId],
+      });
+
+      expect(balance).toEqual(quantity);
+    },
+    40_000, // Increased timeout to 30 seconds
+  );
+});

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

@@ -21,16 +21,13 @@ import {
 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,
@@ -61,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",
@@ -461,6 +451,8 @@ describe("create-helper", () => {
 
       const pricePerToken = parseEther("0.01");
 
+      const blockTime = (await publicClient.getBlock()).timestamp;
+
       const {
         parameters: request,
         contractAddress: collectionAddress,
@@ -473,6 +465,7 @@ describe("create-helper", () => {
           tokenMetadataURI: demoTokenMetadataURI,
           salesConfig: {
             pricePerToken,
+            saleStart: blockTime,
           },
         },
         account: creatorAddress,
@@ -517,6 +510,7 @@ describe("create-helper", () => {
           },
         },
         quantityToMint,
+        chainId: chain.id,
       });
 
       const { request: collectSimulation } =

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

@@ -18,12 +18,12 @@ export const DEFAULT_MARKET_COUNTDOWN = BigInt(24 * 60 * 60);
 // Sales end forever amount (uint64 max)
 export const SALE_END_FOREVER = 18446744073709551615n;
 
-const DEFAULT_SALE_START_AND_END: Concrete<SaleStartAndEnd> = {
-  // Sale start time – defaults to beginning of unix time
-  saleStart: 0n,
+const DEFAULT_SALE_START_AND_END = (): Concrete<SaleStartAndEnd> => ({
+  // Sale start time – defaults to current time in seconds
+  saleStart: BigInt(Math.floor(new Date().getTime() / 1000)),
   // This is the end of uint64, plenty of time
   saleEnd: SALE_END_FOREVER,
-};
+});
 
 const DEFAULT_MAX_TOKENS_PER_ADDRESS: Concrete<MaxTokensPerAddress> = {
   maxTokensPerAddress: 0n,
@@ -32,7 +32,7 @@ const DEFAULT_MAX_TOKENS_PER_ADDRESS: Concrete<MaxTokensPerAddress> = {
 const erc20SaleSettingsWithDefaults = (
   params: Erc20ParamsType,
 ): Concrete<Erc20ParamsType> => ({
-  ...DEFAULT_SALE_START_AND_END,
+  ...DEFAULT_SALE_START_AND_END(),
   ...DEFAULT_MAX_TOKENS_PER_ADDRESS,
   ...params,
 });
@@ -41,7 +41,7 @@ const allowListWithDefaults = (
   allowlist: AllowListParamType,
 ): Concrete<AllowListParamType> => {
   return {
-    ...DEFAULT_SALE_START_AND_END,
+    ...DEFAULT_SALE_START_AND_END(),
     ...allowlist,
   };
 };
@@ -49,7 +49,7 @@ const allowListWithDefaults = (
 const fixedPriceSettingsWithDefaults = (
   params: FixedPriceParamsType,
 ): Concrete<FixedPriceParamsType> => ({
-  ...DEFAULT_SALE_START_AND_END,
+  ...DEFAULT_SALE_START_AND_END(),
   ...DEFAULT_MAX_TOKENS_PER_ADDRESS,
   type: "fixedPrice",
   ...params,

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) {