@zoralabs/comments-contracts 0.0.1

package/scripts/backfillComments.ts

@@ -0,0 +1,176 @@
+import { WalletClient, PublicClient, Transport, Chain, Account } from "viem";
+import { getChainNamePositionalArg, getChainConfig } from "./utils";
+import { queryCommentsPage, MintComment } from "./queries";
+import {
+  writeCommentsToContract,
+  getBackfillerAccount,
+  filterCommentsThatAreAlreadyOnChain,
+} from "./writeComments";
+
+const queryAndWriteCommentsOfPage = async ({
+  subgraph,
+  pageSize,
+  page,
+  walletClient,
+  publicClient,
+  chainId,
+  backfiller,
+}: {
+  subgraph: string;
+  pageSize: number;
+  page: number;
+  walletClient: WalletClient<Transport, Chain>;
+
+  publicClient: PublicClient;
+  chainId: number;
+  backfiller: Account;
+}): Promise<boolean> => {
+  // query and page through each batch of comments
+  // for each page, write to the comments contract the comment
+  // if there is an empty array, return
+
+  const pagedComments = await queryCommentsPage({
+    subgraph,
+    page,
+    pageSize,
+    skip: 0,
+  });
+
+  if (pagedComments.length === 0) {
+    console.log("no comments returned from query");
+    return false;
+  }
+
+  const filteredComments = await filterCommentsThatAreAlreadyOnChain({
+    publicClient,
+    chainId,
+    comments: pagedComments,
+  });
+
+  if (filteredComments.length === 0) {
+    console.log("no comments returned that are not already on chain");
+    return true;
+  }
+
+  console.log({
+    pagedComments: pagedComments.length,
+    filteredComments: filteredComments.length,
+  });
+
+  const processCommentsInChunks = async (
+    filteredComments: MintComment[],
+    initialChunkSize: number,
+    walletClient: WalletClient<Transport, Chain>,
+    publicClient: PublicClient,
+    chainId: number,
+  ) => {
+    let chunkSize = initialChunkSize;
+
+    while (chunkSize > 0) {
+      try {
+        const chunks: MintComment[][] = [];
+        for (let i = 0; i < filteredComments.length; i += chunkSize) {
+          chunks.push([...filteredComments].slice(i, i + chunkSize));
+        }
+
+        console.log(`processing ${chunks.length} chunks of size ${chunkSize}`);
+
+        for (let index = 0; index < chunks.length; index++) {
+          const chunk = chunks[index];
+          if (chunk.length > 0) {
+            console.log(
+              `writing chunk ${index + 1} of ${chunks.length}, size ${chunk.length}`,
+            );
+            await writeCommentsToContract({
+              comments: chunk,
+              walletClient,
+              publicClient,
+              chainId,
+              account: backfiller,
+              write: true,
+            });
+          }
+        }
+
+        // If we've made it here without errors, we're done
+        return;
+      } catch (error) {
+        console.log(error);
+        console.error(
+          `failed with chunk size ${chunkSize}. Retrying with smaller chunks.`,
+        );
+        chunkSize -= 100;
+      }
+    }
+
+    console.error("failed to process comments even with minimum chunk size.");
+  };
+
+  await processCommentsInChunks(
+    filteredComments,
+    700,
+    walletClient,
+    publicClient,
+    chainId,
+  );
+
+  return true;
+};
+
+const queryAndWriteComments = async ({
+  subgraph,
+  pageSize,
+  walletClient,
+  publicClient,
+  chainId,
+}: {
+  subgraph: string;
+  pageSize: number;
+  walletClient: WalletClient<Transport, Chain>;
+  publicClient: PublicClient;
+  chainId: number;
+}) => {
+  let page = 0;
+
+  const backfiller = getBackfillerAccount();
+
+  while (true) {
+    const gotSomeComments = await queryAndWriteCommentsOfPage({
+      subgraph,
+      pageSize,
+      walletClient,
+      publicClient,
+      chainId,
+      backfiller,
+      page,
+    });
+
+    if (!gotSomeComments) {
+      console.log("done querying comments");
+      break;
+    }
+
+    page += 1;
+  }
+};
+
+const backfillComments = async (chainName: string) => {
+  const { publicClient, walletClient, chainId, subgraph } =
+    await getChainConfig(chainName);
+
+  const pageSize = 1000;
+
+  await queryAndWriteComments({
+    subgraph,
+    pageSize,
+    walletClient,
+    publicClient,
+    chainId,
+  });
+};
+
+export const main = async () => {
+  await backfillComments(getChainNamePositionalArg());
+};
+
+main();

package/scripts/generateCommentsTestData.ts

@@ -0,0 +1,247 @@
+import {
+  parseEther,
+  PublicClient,
+  Address,
+  WalletClient,
+  Hex,
+  Chain,
+  Transport,
+  numberToHex,
+  zeroAddress,
+  keccak256,
+  Account,
+} from "viem";
+import { zoraCreator1155ImplABI } from "@zoralabs/zora-1155-contracts";
+import { privateKeyToAccount } from "viem/accounts";
+import { zoraTimedSaleStrategyImplABI } from "./abis";
+import { zoraSepolia } from "viem/chains";
+import { CommentIdentifier } from "../package/types";
+import { getCommentsAddress } from "./getCommentsAddresses";
+import { commentsImplABI } from "../package/wagmiGenerated";
+import { getChainConfig } from "./utils";
+
+const MINT_FEE = parseEther("0.000111");
+const SPARK_VALUE = parseEther("0.000001");
+const TEST_1155_CONTRACT = "0xD42557F24034b53e7340A40bb5813eF9Ba88F2b4";
+const TEST_TOKEN_ID = 3n;
+const ZORA_TIMED_SALE_STRATEGY = "0x777777722D078c97c6ad07d9f36801e653E356Ae";
+const GAS_FEE = parseEther("0.000001");
+
+const getAccountFromEnv = (keyName: string) => {
+  const privateKey = process.env[keyName] as Address;
+  if (!privateKey) {
+    throw new Error(`${keyName} not found in environment`);
+  }
+  return privateKeyToAccount(privateKey);
+};
+
+const waitForReceiptAndEnsureSuccess = async (
+  hash: Hex,
+  publicClient: PublicClient<Transport, Chain>,
+) => {
+  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  if (receipt.status !== "success") {
+    throw new Error("Transaction failed");
+  }
+};
+
+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 balance = await publicClient.readContract({
+    abi: zoraCreator1155ImplABI,
+    address: TEST_1155_CONTRACT,
+    functionName: "balanceOf",
+    args: [commentor.address, TEST_TOKEN_ID],
+  });
+
+  let tx: Hex;
+
+  if (balance === 0n) {
+    console.log("minting token to commentor");
+
+    tx = await walletClient.writeContract({
+      abi: zoraTimedSaleStrategyImplABI,
+      address: ZORA_TIMED_SALE_STRATEGY,
+      functionName: "mint",
+      account,
+      args: [
+        commentor.address,
+        1n,
+        TEST_1155_CONTRACT,
+        TEST_TOKEN_ID,
+        zeroAddress,
+        "",
+      ],
+      value: MINT_FEE,
+    });
+
+    await waitForReceiptAndEnsureSuccess(tx, publicClient);
+  }
+
+  const emptyCommentIdentifier: CommentIdentifier = {
+    commenter: zeroAddress,
+    contractAddress: zeroAddress,
+    tokenId: 0n,
+    nonce: keccak256(numberToHex(0)),
+  } as const;
+
+  console.log("sending 2 sparks worth of eth to commenter");
+
+  // send 2 sparks worth of eth to commenter
+  tx = await walletClient.sendTransaction({
+    account,
+    to: commentor.address,
+    value: (SPARK_VALUE + GAS_FEE) * 2n,
+  });
+  await waitForReceiptAndEnsureSuccess(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,
+  });
+
+  await waitForReceiptAndEnsureSuccess(tx, publicClient);
+
+  console.log("replying to comment");
+
+  tx = await walletClient.writeContract({
+    abi: commentsImplABI,
+    address: commentsAddress,
+    functionName: "comment",
+    account: commentor,
+    args: [
+      replyCommentIdentifier,
+      "This is a test reply",
+      1n,
+      commentIdentifier,
+      zeroAddress,
+    ],
+    value: SPARK_VALUE,
+  });
+
+  await waitForReceiptAndEnsureSuccess(tx, publicClient);
+};
+
+const sparkComment = async ({
+  walletClient,
+  publicClient,
+  commentsAddress,
+  account,
+  sparker,
+  commentIdentifier,
+}: {
+  walletClient: WalletClient<Transport, Chain>;
+  publicClient: PublicClient<Transport, Chain>;
+  commentsAddress: Address;
+  account: Account;
+  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({
+    account,
+    to: sparker.address,
+    value: SPARK_VALUE + GAS_FEE,
+  });
+  await waitForReceiptAndEnsureSuccess(tx, publicClient);
+
+  console.log("sparking comment");
+
+  // spark the comment
+  tx = await walletClient.writeContract({
+    abi: commentsImplABI,
+    address: commentsAddress,
+    functionName: "sparkComment",
+    account: sparker,
+    args: [commentIdentifier, 1n, zeroAddress],
+    value: SPARK_VALUE,
+  });
+
+  await waitForReceiptAndEnsureSuccess(tx, publicClient);
+};
+
+export const generateCommentsTestData = async () => {
+  const { walletClient, publicClient } = await getChainConfig("zora-sepolia");
+
+  const commentsAddress = (await getCommentsAddress(zoraSepolia.id)).COMMENTS;
+
+  const account = getAccountFromEnv("PRIVATE_KEY");
+
+  const commentor = getAccountFromEnv("COMMENTOR_PRIVATE_KEY");
+  const sparker = getAccountFromEnv("SPARKER_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 replyCommentIdentifier: CommentIdentifier = {
+    ...commentIdentifier,
+    nonce: keccak256(numberToHex(2)),
+  };
+
+  await generateTestComments(
+    walletClient,
+    publicClient,
+    commentsAddress,
+    account,
+    commentor,
+    commentIdentifier,
+    replyCommentIdentifier,
+  );
+
+  // spark the comment twice
+  await sparkComment({
+    walletClient,
+    publicClient,
+    commentsAddress,
+    account,
+    sparker,
+    commentIdentifier,
+  });
+
+  await sparkComment({
+    walletClient,
+    publicClient,
+    commentsAddress,
+    account,
+    sparker,
+    commentIdentifier,
+  });
+
+  // spark the reply comment
+  await sparkComment({
+    walletClient,
+    publicClient,
+    commentsAddress,
+    account,
+    sparker,
+    commentIdentifier: replyCommentIdentifier,
+  });
+};
+
+generateCommentsTestData();

package/scripts/getCommentsAddresses.ts

@@ -0,0 +1,10 @@
+import { Address } from "viem";
+import { readFile } from "fs/promises";
+
+export const getCommentsAddress = async (chainId: number) => {
+  const addresses = await readFile(`./addresses/${chainId}.json`, "utf8");
+
+  return JSON.parse(addresses) as {
+    COMMENTS: Address;
+  };
+};

package/scripts/queries.ts

@@ -0,0 +1,73 @@
+import { Address, PublicClient, Hex } from "viem";
+import { commentsImplABI } from "../package/wagmiGenerated";
+
+export type MintComment = {
+  tokenAndContract: {
+    address: Address;
+    tokenId: string;
+  };
+  sender: Address;
+  txn: {
+    id: Hex;
+    block: string;
+    logIndex: string;
+  };
+  timestamp: string;
+  comment: string;
+};
+
+export const queryCommentsPage = async ({
+  subgraph,
+  pageSize,
+  page,
+  skip = 0,
+}: {
+  subgraph: string;
+  pageSize: number;
+  page: number;
+  skip?: number;
+}) => {
+  const query = `
+    query MintComments {
+      mintComments(
+        first: ${pageSize},
+        skip: ${page * pageSize + skip},
+        orderBy: timestamp,
+        orderDirection: asc
+      ) {
+        tokenAndContract {
+          address
+          tokenId
+        }
+        sender
+        txn {
+          id
+          block
+          logIndex
+        }
+        timestamp
+        comment
+      }
+    }
+  `;
+
+  // post to subgraph url with query
+  const response = await fetch(subgraph, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({ query }),
+  });
+
+  const responseJson = await response.json();
+
+  if (!responseJson.data) {
+    console.error("Errored querying graphql");
+    console.error(responseJson);
+  }
+
+  const mintComments = responseJson.data.mintComments;
+
+  return mintComments as MintComment[];
+};

package/scripts/queryAndSaveComments.ts

@@ -0,0 +1,48 @@
+import { getChainNamePositionalArg } from "./utils";
+import { getChainConfig } from "./utils";
+import { queryCommentsPage } from "./queries";
+import { saveComments } from "./savedCommentsDump";
+
+export const queryAndSaveComments = async (chainName: string) => {
+  const { subgraph } = await getChainConfig(chainName);
+
+  const pageSize = 1000;
+  let page = 0;
+
+  // iterate over all pages until comments are empty
+  const batchSize = 20;
+  let hasMoreComments = true;
+
+  // Clear the file at the beginning
+  await saveComments(chainName, []);
+
+  while (hasMoreComments) {
+    const batchPromises = Array.from({ length: batchSize }, (_, i) =>
+      queryCommentsPage({
+        subgraph,
+        pageSize: pageSize,
+        page: page + i,
+      }),
+    );
+
+    const batchResults = await Promise.all(batchPromises);
+
+    for (let i = 0; i < batchResults.length; i++) {
+      const commentsPage = batchResults[i];
+      if (commentsPage.length > 0) {
+        console.log(`Queried page ${page}: ${commentsPage.length} comments`);
+        await saveComments(chainName, commentsPage, true); // Use append mode
+        page++;
+      } else {
+        hasMoreComments = false;
+        break;
+      }
+    }
+  }
+};
+
+export const main = async () => {
+  await queryAndSaveComments(getChainNamePositionalArg());
+};
+
+main();

package/scripts/queryQuantityOfComments.ts

@@ -0,0 +1,53 @@
+import { getChainConfig } from "./utils";
+import { queryCommentsPage } from "./queries";
+import { getChainNamePositionalArg } from "./utils";
+
+export const queryQuantityOfComments = async (chainName: string) => {
+  const { subgraph } = await getChainConfig(chainName);
+
+  // do a breadth first search to find the total number of comments;
+  // we want to find the lowest page that has comments, and from that page, we know
+  // the total number of comments
+
+  // midpoint is 500k, we go up to 1 million
+
+  const low = 100_000 / pageSize;
+  const high = 2_000_000 / pageSize;
+
+  const { page, quantity } = await search(low, high, subgraph);
+
+  console.log(`Found last page ${page} with ${quantity} comments`);
+
+  const totalComments = page * pageSize + quantity;
+
+  console.log(`Total comments: ${totalComments}`);
+};
+
+const pageSize = 1000;
+
+// recursive binary search to find the last page of comments
+const search = async (low: number, high: number, subgraph: string) => {
+  const midpoint = Math.floor(low + (high - low) / 2);
+  const commentsPage = await queryCommentsPage({
+    subgraph,
+    pageSize,
+    page: midpoint,
+  });
+  console.log(
+    `Found ${commentsPage.length} comments on page ${midpoint}, comments so far ${midpoint * pageSize}`,
+  );
+  if (commentsPage.length === 0) {
+    return await search(low, midpoint, subgraph);
+    ``;
+  }
+  if (commentsPage.length < pageSize) {
+    return { page: midpoint, quantity: commentsPage.length };
+  }
+  return await search(midpoint, high, subgraph);
+};
+
+const main = async () => {
+  await queryQuantityOfComments(getChainNamePositionalArg());
+};
+
+main();

package/scripts/signDeployAndCall.ts

@@ -0,0 +1,51 @@
+import { Hex, Address } from "viem";
+import { loadTurnkeyAccount } from "./turnkey";
+
+const loadParameters = () => {
+  const [, , chainId, salt, creationCode, init, deployerAddress] = process.argv;
+
+  return {
+    chainId: +chainId,
+    salt: salt as Hex,
+    creationCode: creationCode as Hex,
+    init: init as Hex,
+    deployerAddress: deployerAddress as Address,
+  };
+};
+
+/// Deploy the mints manager and 1155 contract deteriministically using turnkey
+async function main() {
+  const parameters = loadParameters();
+
+  const turnkeyAccount = await loadTurnkeyAccount();
+
+  // "create(bytes32 salt,bytes code,bytes postCreateCall,uint256 postCreateCallValue)");
+  const signature = await turnkeyAccount.signTypedData({
+    types: {
+      create: [
+        { name: "salt", type: "bytes32" },
+        { name: "code", type: "bytes" },
+        { name: "postCreateCall", type: "bytes" },
+      ],
+    },
+    primaryType: "create",
+    message: {
+      code: parameters.creationCode,
+      salt: parameters.salt,
+      postCreateCall: parameters.init,
+    },
+    domain: {
+      chainId: parameters.chainId,
+      name: "DeterministicDeployerAndCaller",
+      version: "1",
+      verifyingContract: parameters.deployerAddress,
+    },
+  });
+
+  console.log(signature);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/scripts/turnkey.ts

@@ -0,0 +1,36 @@
+import { TurnkeyClient } from "@turnkey/http";
+import { ApiKeyStamper } from "@turnkey/api-key-stamper";
+import { createAccount } from "@turnkey/viem";
+
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+import * as path from "path";
+import * as dotenv from "dotenv";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+dotenv.config({ path: path.resolve(__dirname, "../.env") });
+
+export const loadTurnkeyAccount = async () => {
+  const httpClient = new TurnkeyClient(
+    {
+      baseUrl: "https://api.turnkey.com",
+    },
+    // This uses API key credentials.
+    // If you're using passkeys, use `@turnkey/webauthn-stamper` to collect webauthn signatures:
+    new ApiKeyStamper({
+      apiPublicKey: process.env.TURNKEY_API_PUBLIC_KEY!,
+      apiPrivateKey: process.env.TURNKEY_API_PRIVATE_KEY!,
+    }),
+  );
+
+  // Create the Viem custom account
+  return await createAccount({
+    client: httpClient,
+    organizationId: process.env.TURNKEY_ORGANIZATION_ID!,
+    signWith: process.env.TURNKEY_PRIVATE_KEY_ID!,
+    // optional; will be fetched from Turnkey if not provided
+    ethereumAddress: process.env.TURNKEY_TARGET_ADDRESS!,
+  });
+};