@zoralabs/protocol-sdk 0.11.3-COMMENTS.1 → 0.11.3

package/src/comments/comments.test.ts

@@ -1,223 +0,0 @@
-import { describe, expect } from "vitest";
-import { forkUrls, makeAnvilTest, writeContractWithRetries } from "src/anvil";
-import { base, zoraSepolia } from "viem/chains";
-import {
-  commentsABI,
-  commentsAddress,
-  emptyCommentIdentifier,
-  PermitComment,
-  PermitSparkComment,
-  sparkValue,
-  CommentIdentifier,
-  permitSparkCommentTypedDataDefinition,
-} from "@zoralabs/protocol-deployments";
-import {
-  Address,
-  keccak256,
-  toBytes,
-  zeroAddress,
-  parseEther,
-  TransactionReceipt,
-  parseEventLogs,
-} from "viem";
-import { createCreatorClient } from "src/sdk";
-import { randomNewContract, waitForSuccess } from "src/test-utils";
-import { demoTokenMetadataURI } from "src/create/1155-create-helper.test";
-import { permitCommentTypedDataDefinition } from "@zoralabs/protocol-deployments";
-
-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.comment;
-};
-
-// todo: move this to protocol-deployments
-describe("comments", () => {
-  makeAnvilTest({
-    forkUrl: forkUrls.zoraSepolia,
-    forkBlockNumber: 14918747,
-    anvilChainId: zoraSepolia.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 randomNonce = () =>
-        keccak256(toBytes(Math.round(Math.random() * 1000)));
-      const thirtySecondsFromNow =
-        BigInt(Math.round(new Date().getTime() / 1000)) + 30n;
-
-      // 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,
-        replyTo: emptyCommentIdentifier(),
-      };
-
-      // Generate typed data for signing
-      const typedData = permitCommentTypedDataDefinition(permitComment);
-
-      const commentsAddressForChainId =
-        commentsAddress[chainId as keyof typeof commentsAddress];
-
-      // Verify the typed data is correctly set up
-      expect(typedData.domain!.chainId).toEqual(sourceChainId);
-      expect(typedData.account).toEqual(collectorAddress);
-      expect(typedData.domain!.verifyingContract).toEqual(
-        commentsAddressForChainId,
-      );
-
-      // 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,
-      });
-
-      if (receipt.status !== "success") {
-        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);
-    },
-    20_000,
-  );
-});