@zoralabs/comments-contracts 0.0.1 → 0.0.2-COMMENTS.0

package/scripts/generateCommentsTestData.ts

@@ -10,6 +10,8 @@ import {
   zeroAddress,
   keccak256,
   Account,
+  TransactionReceipt,
+  parseEventLogs,
 } from "viem";
 import { zoraCreator1155ImplABI } from "@zoralabs/zora-1155-contracts";
 import { privateKeyToAccount } from "viem/accounts";
@@ -19,6 +21,9 @@ import { CommentIdentifier } from "../package/types";
 import { getCommentsAddress } from "./getCommentsAddresses";
 import { commentsImplABI } from "../package/wagmiGenerated";
 import { getChainConfig } from "./utils";
+// load env variables
+import dotenv from "dotenv";
+dotenv.config();
 
 const MINT_FEE = parseEther("0.000111");
 const SPARK_VALUE = parseEther("0.000001");
@@ -27,7 +32,7 @@ const TEST_TOKEN_ID = 3n;
 const ZORA_TIMED_SALE_STRATEGY = "0x777777722D078c97c6ad07d9f36801e653E356Ae";
 const GAS_FEE = parseEther("0.000001");
 
-const getAccountFromEnv = (keyName: string) => {
+const getAccountFromEnv = ({ keyName }: { keyName: string }) => {
   const privateKey = process.env[keyName] as Address;
   if (!privateKey) {
     throw new Error(`${keyName} not found in environment`);
@@ -35,45 +40,68 @@ const getAccountFromEnv = (keyName: string) => {
   return privateKeyToAccount(privateKey);
 };
 
-const waitForReceiptAndEnsureSuccess = async (
-  hash: Hex,
-  publicClient: PublicClient<Transport, Chain>,
-) => {
+const getCommentIdentifierFromReceipt = ({
+  receipt,
+}: {
+  receipt: TransactionReceipt;
+}): CommentIdentifier => {
+  const logs = parseEventLogs({
+    abi: commentsImplABI,
+    logs: receipt.logs,
+    eventName: "Commented",
+  });
+
+  if (logs.length === 0) {
+    throw new Error("No Commented event found in receipt");
+  }
+
+  return logs[0]!.args.commentIdentifier;
+};
+
+const waitForReceiptAndEnsureSuccess = async ({
+  hash,
+  publicClient,
+}: {
+  hash: Hex;
+  publicClient: PublicClient<Transport, Chain>;
+}) => {
   const receipt = await publicClient.waitForTransactionReceipt({ hash });
   if (receipt.status !== "success") {
     throw new Error("Transaction failed");
   }
+
+  return receipt;
 };
 
-const generateTestComments = async (
-  walletClient: WalletClient<Transport, Chain>,
-  publicClient: PublicClient<Transport, Chain>,
-  commentsAddress: Address,
-  account: Account,
-  commentor: Account,
-  commentIdentifier: CommentIdentifier,
-  replyCommentIdentifier: CommentIdentifier,
-) => {
-  // check if commentor has a mint on 1155
+const mintIfNotOwner = async ({
+  walletClient,
+  publicClient,
+  account,
+  commenter,
+}: {
+  walletClient: WalletClient<Transport, Chain>;
+  publicClient: PublicClient<Transport, Chain>;
+  account: Account;
+  commenter: Account;
+}) => {
+  // check if commenter has a mint on 1155
   const balance = await publicClient.readContract({
     abi: zoraCreator1155ImplABI,
     address: TEST_1155_CONTRACT,
     functionName: "balanceOf",
-    args: [commentor.address, TEST_TOKEN_ID],
+    args: [commenter.address, TEST_TOKEN_ID],
   });
 
-  let tx: Hex;
-
   if (balance === 0n) {
-    console.log("minting token to commentor");
+    console.log("minting token to commenter");
 
-    tx = await walletClient.writeContract({
+    const tx = await walletClient.writeContract({
       abi: zoraTimedSaleStrategyImplABI,
       address: ZORA_TIMED_SALE_STRATEGY,
       functionName: "mint",
       account,
       args: [
-        commentor.address,
+        commenter.address,
         1n,
         TEST_1155_CONTRACT,
         TEST_TOKEN_ID,
@@ -83,8 +111,28 @@ const generateTestComments = async (
       value: MINT_FEE,
     });
 
-    await waitForReceiptAndEnsureSuccess(tx, publicClient);
+    await waitForReceiptAndEnsureSuccess({ hash: tx, publicClient });
   }
+};
+
+const generateTestComments = async ({
+  walletClient,
+  publicClient,
+  commentsAddress,
+  account,
+  commenter,
+  contractAddress,
+  tokenId,
+}: {
+  walletClient: WalletClient<Transport, Chain>;
+  publicClient: PublicClient<Transport, Chain>;
+  commentsAddress: Address;
+  account: Account;
+  commenter: Account;
+  contractAddress: Address;
+  tokenId: bigint;
+}) => {
+  await mintIfNotOwner({ walletClient, publicClient, account, commenter });
 
   const emptyCommentIdentifier: CommentIdentifier = {
     commenter: zeroAddress,
@@ -96,50 +144,106 @@ const generateTestComments = async (
   console.log("sending 2 sparks worth of eth to commenter");
 
   // send 2 sparks worth of eth to commenter
-  tx = await walletClient.sendTransaction({
+  let tx = await walletClient.sendTransaction({
     account,
-    to: commentor.address,
+    to: commenter.address,
     value: (SPARK_VALUE + GAS_FEE) * 2n,
   });
-  await waitForReceiptAndEnsureSuccess(tx, publicClient);
+  await waitForReceiptAndEnsureSuccess({ hash: tx, publicClient });
 
   console.log("commenting");
 
-  tx = await walletClient.writeContract({
-    abi: commentsImplABI,
-    address: commentsAddress,
-    functionName: "comment",
-    account: commentor,
-    args: [
-      commentIdentifier,
-      "This is a test comment",
-      1n,
-      emptyCommentIdentifier,
-      zeroAddress,
-    ],
-    value: SPARK_VALUE,
+  const commentIdentifier = await writeCommentToContract({
+    walletClient,
+    publicClient,
+    commentsAddress,
+    commenter,
+    contractAddress,
+    tokenId,
+    text: "This is a test comment",
+    replyTo: emptyCommentIdentifier,
   });
 
-  await waitForReceiptAndEnsureSuccess(tx, publicClient);
-
   console.log("replying to comment");
 
-  tx = await walletClient.writeContract({
+  const replyCommentIdentifier = await writeCommentToContract({
+    walletClient,
+    publicClient,
+    commentsAddress,
+    commenter,
+    contractAddress,
+    tokenId,
+    text: "This is a test reply",
+    replyTo: commentIdentifier,
+  });
+
+  return { commentIdentifier, replyCommentIdentifier };
+};
+
+const writeCommentToContract = async ({
+  walletClient,
+  publicClient,
+  commentsAddress,
+  commenter,
+  contractAddress,
+  tokenId,
+  text,
+  replyTo,
+}: {
+  walletClient: WalletClient<Transport, Chain>;
+  publicClient: PublicClient<Transport, Chain>;
+  commentsAddress: Address;
+  commenter: Account | Address;
+  contractAddress: Address;
+  tokenId: bigint;
+  text: string;
+  replyTo: CommentIdentifier;
+}): Promise<CommentIdentifier> => {
+  const tx = await walletClient.writeContract({
     abi: commentsImplABI,
     address: commentsAddress,
     functionName: "comment",
-    account: commentor,
+    account: commenter,
     args: [
-      replyCommentIdentifier,
-      "This is a test reply",
-      1n,
-      commentIdentifier,
+      typeof commenter === "string" ? commenter : commenter.address,
+      contractAddress,
+      tokenId,
+      text,
+      replyTo,
+      zeroAddress,
       zeroAddress,
     ],
     value: SPARK_VALUE,
   });
 
-  await waitForReceiptAndEnsureSuccess(tx, publicClient);
+  const receipt = await waitForReceiptAndEnsureSuccess({
+    hash: tx,
+    publicClient,
+  });
+
+  return getCommentIdentifierFromReceipt({ receipt });
+};
+
+const sendSparksEth = async ({
+  walletClient,
+  publicClient,
+  account,
+  recipient,
+  value,
+}: {
+  walletClient: WalletClient<Transport, Chain>;
+  publicClient: PublicClient<Transport, Chain>;
+  account: Account;
+  recipient: Address;
+  value: bigint;
+}) => {
+  console.log("sending sparks worth of eth to recipient + gas");
+  const tx = await walletClient.sendTransaction({
+    account,
+    to: recipient,
+    value,
+  });
+  await waitForReceiptAndEnsureSuccess({ hash: tx, publicClient });
 };
 
 const sparkComment = async ({
@@ -157,19 +261,18 @@ const sparkComment = async ({
   sparker: Account;
   commentIdentifier: CommentIdentifier;
 }) => {
-  console.log("sending sparks worth of eth to sparker + gas");
-  // send sparks worth of eth to sparker + gas
-  let tx = await walletClient.sendTransaction({
+  await sendSparksEth({
+    walletClient,
+    publicClient,
     account,
-    to: sparker.address,
+    recipient: sparker.address,
     value: SPARK_VALUE + GAS_FEE,
   });
-  await waitForReceiptAndEnsureSuccess(tx, publicClient);
 
   console.log("sparking comment");
 
   // spark the comment
-  tx = await walletClient.writeContract({
+  const tx = await walletClient.writeContract({
     abi: commentsImplABI,
     address: commentsAddress,
     functionName: "sparkComment",
@@ -178,7 +281,7 @@ const sparkComment = async ({
     value: SPARK_VALUE,
   });
 
-  await waitForReceiptAndEnsureSuccess(tx, publicClient);
+  await waitForReceiptAndEnsureSuccess({ hash: tx, publicClient });
 };
 
 export const generateCommentsTestData = async () => {
@@ -186,33 +289,21 @@ export const generateCommentsTestData = async () => {
 
   const commentsAddress = (await getCommentsAddress(zoraSepolia.id)).COMMENTS;
 
-  const account = getAccountFromEnv("PRIVATE_KEY");
-
-  const commentor = getAccountFromEnv("COMMENTOR_PRIVATE_KEY");
-  const sparker = getAccountFromEnv("SPARKER_PRIVATE_KEY");
+  const account = getAccountFromEnv({ keyName: "PRIVATE_KEY" });
 
-  // comment and reply to comment
-  const commentIdentifier: CommentIdentifier = {
-    commenter: commentor.address,
-    contractAddress: TEST_1155_CONTRACT,
-    tokenId: TEST_TOKEN_ID,
-    nonce: keccak256(numberToHex(1)),
-  };
+  const commenter = getAccountFromEnv({ keyName: "COMMENTER_PRIVATE_KEY" });
+  const sparker = getAccountFromEnv({ keyName: "SPARKER_PRIVATE_KEY" });
 
-  const replyCommentIdentifier: CommentIdentifier = {
-    ...commentIdentifier,
-    nonce: keccak256(numberToHex(2)),
-  };
-
-  await generateTestComments(
-    walletClient,
-    publicClient,
-    commentsAddress,
-    account,
-    commentor,
-    commentIdentifier,
-    replyCommentIdentifier,
-  );
+  const { commentIdentifier, replyCommentIdentifier } =
+    await generateTestComments({
+      walletClient,
+      publicClient,
+      commentsAddress,
+      account,
+      commenter,
+      contractAddress: TEST_1155_CONTRACT,
+      tokenId: TEST_TOKEN_ID,
+    });
 
   // spark the comment twice
   await sparkComment({