@zoralabs/comments-contracts 0.0.1

package/scripts/utils.ts

@@ -0,0 +1,127 @@
+import {
+  createPublicClient,
+  http,
+  Chain,
+  createWalletClient,
+  PublicClient,
+  WalletClient,
+  Transport,
+} from "viem";
+import * as chains from "viem/chains";
+import { getChain } from "@zoralabs/chains";
+
+export const makeClientsForChain = async (
+  chainName: string,
+): Promise<{
+  publicClient: PublicClient;
+  walletClient: WalletClient<Transport, Chain>;
+  chainId: number;
+}> => {
+  const configuredChain = await getChain(chainName);
+
+  if (configuredChain.id === 9999999) {
+    configuredChain.id = chains.zoraSepolia.id;
+  }
+
+  if (!configuredChain) {
+    throw new Error(`No chain config found for chain name ${chainName}`);
+  }
+
+  const chainConfig = Object.values(chains).find(
+    (x) => x.id === configuredChain.id,
+  );
+
+  if (!chainConfig) {
+    throw new Error(`No chain config found for chain id ${configuredChain.id}`);
+  }
+
+  const rpcUrl = configuredChain.rpcUrl;
+
+  if (!rpcUrl) {
+    throw new Error(`No RPC found for chain id ${configuredChain.id}`);
+  }
+
+  return {
+    publicClient: createPublicClient({
+      transport: http(),
+      chain: {
+        ...chainConfig,
+        rpcUrls: {
+          default: {
+            http: [rpcUrl],
+          },
+          public: {
+            http: [rpcUrl],
+          },
+        },
+      },
+    }) as PublicClient,
+    walletClient: createWalletClient({
+      transport: http(),
+      chain: {
+        ...chainConfig,
+        rpcUrls: {
+          default: {
+            http: [rpcUrl],
+          },
+          public: {
+            http: [rpcUrl],
+          },
+        },
+      },
+    }),
+    chainId: configuredChain.id as number,
+  };
+};
+
+export const makeWalletClientForChain = async (chainName: string) => {
+  const configuredChain = await getChain(chainName);
+
+  if (configuredChain.id === 9999999) {
+    configuredChain.id = chains.zoraSepolia.id;
+  }
+};
+export function getChainNamePositionalArg() {
+  // parse chain id as first argument:
+  const chainName = process.argv[2];
+
+  if (!chainName) {
+    throw new Error("Must provide chain name as first argument");
+  }
+
+  return chainName;
+}
+
+const CONFIG_BASE =
+  "https://api.goldsky.com/api/public/project_clhk16b61ay9t49vm6ntn4mkz/subgraphs";
+
+export function getSubgraph(name: string, version: string = "stable"): string {
+  return `${CONFIG_BASE}/${name}/${version}/gn`;
+}
+
+const subgraphChainName = (chainName: string) => {
+  if (chainName === "zora") {
+    return "zora-mainnet";
+  }
+  if (chainName === "base") {
+    return "base-mainnet";
+  }
+
+  return chainName;
+};
+
+export async function getChainConfig(chainName: string) {
+  const subgraph = getSubgraph(
+    `zora-create-${subgraphChainName(chainName)}`,
+    "stable",
+  );
+  const { publicClient, walletClient, chainId } =
+    await makeClientsForChain(chainName);
+
+  return {
+    publicClient: publicClient as PublicClient<Transport, Chain>,
+    walletClient: walletClient as WalletClient<Transport, Chain>,
+    chainId,
+    subgraph,
+  };
+}

package/scripts/writeComments.ts

@@ -0,0 +1,198 @@
+import {
+  Address,
+  WalletClient,
+  PublicClient,
+  toHex,
+  BaseError,
+  ContractFunctionRevertedError,
+  ExecutionRevertedError,
+  TransactionExecutionError,
+  ContractFunctionExecutionError,
+  Account,
+  Hex,
+  Chain,
+  Transport,
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { getCommentsAddress } from "./getCommentsAddresses";
+import { commentsImplABI } from "../package/wagmiGenerated";
+import { CommentIdentifier } from "../package/types";
+import { MintComment } from "./queries";
+
+const blockAndLogIndexToId = (
+  blockString: string,
+  logIndexString: string,
+): Hex => {
+  const blockNumber = BigInt(blockString);
+  const logIndex = BigInt(logIndexString);
+
+  // Use a larger shift (192 bits instead of 128)
+  const blockAndLogIndex = (blockNumber << 200n) | logIndex;
+
+  return toHex(blockAndLogIndex, { size: 32 });
+};
+
+export const getBackfillerAccount = () => {
+  const privateKey = process.env.PRIVATE_KEY as Address;
+  return privateKeyToAccount(privateKey);
+};
+
+const parseError = (err: Error) => {
+  if (err instanceof BaseError) {
+    const revertError = err.walk(
+      (_err) =>
+        _err instanceof ContractFunctionRevertedError ||
+        _err instanceof ExecutionRevertedError ||
+        _err instanceof TransactionExecutionError ||
+        _err instanceof ContractFunctionExecutionError,
+    );
+    if (
+      revertError instanceof ContractFunctionRevertedError ||
+      revertError instanceof ExecutionRevertedError ||
+      revertError instanceof TransactionExecutionError ||
+      revertError instanceof ContractFunctionExecutionError
+    ) {
+      // @ts-ignore
+      const errorName = revertError.data?.errorName ?? "";
+      console.error("reverted", {
+        errorName,
+        // details: revertError.details,
+        message: revertError.message,
+        shortMessage: revertError.shortMessage,
+      });
+
+      throw err;
+    }
+  }
+
+  console.error("Unknown error", err.name);
+};
+
+function toCommentIdentifier(comment: MintComment): CommentIdentifier {
+  return {
+    commenter: comment.sender,
+    contractAddress: comment.tokenAndContract.address,
+    tokenId: BigInt(comment.tokenAndContract.tokenId),
+    nonce: blockAndLogIndexToId(comment.txn.block, comment.txn.logIndex),
+  };
+}
+
+export const writeCommentsToContract = async ({
+  comments,
+  walletClient,
+  publicClient,
+  chainId,
+  account,
+  write = true,
+}: {
+  comments: MintComment[];
+  walletClient: WalletClient<Transport, Chain>;
+  publicClient: PublicClient;
+  chainId: number;
+  account: Account;
+  // if the transaction should be written to the chain
+  write?: boolean;
+}) => {
+  const commentsAddress = (await getCommentsAddress(chainId)).COMMENTS;
+
+  const commentIdentifiers = comments.map((comment): CommentIdentifier => {
+    try {
+      return {
+        commenter: comment.sender,
+        contractAddress: comment.tokenAndContract.address,
+        tokenId: BigInt(comment.tokenAndContract.tokenId),
+        nonce: blockAndLogIndexToId(comment.txn.block, comment.txn.logIndex),
+      };
+    } catch (err) {
+      console.error("Failed to parse comment", comment);
+      throw err;
+    }
+  });
+
+  const texts = comments.map((comment) => comment.comment);
+
+  const timestamps = comments.map((comment) => BigInt(comment.timestamp));
+
+  const originalTransactionHashes = comments.map((comment) => comment.txn.id);
+
+  if (!write) {
+    console.log("simulating");
+
+    try {
+      const simulated = await publicClient.simulateContract({
+        abi: commentsImplABI,
+        address: commentsAddress,
+        functionName: "backfillBatchAddComment",
+        args: [
+          commentIdentifiers,
+          texts,
+          timestamps,
+          originalTransactionHashes,
+        ],
+        account,
+      });
+
+      console.log("simulated:", {
+        gas: simulated.request.gas,
+        gasPrice: simulated.request.gasPrice,
+      });
+    } catch (err) {
+      parseError(err);
+    }
+    return;
+  }
+
+  console.log("writing comments");
+
+  let hash;
+
+  try {
+    hash = await walletClient.writeContract({
+      abi: commentsImplABI,
+      address: commentsAddress,
+      functionName: "backfillBatchAddComment",
+      args: [commentIdentifiers, texts, timestamps, originalTransactionHashes],
+      account,
+    });
+  } catch (err) {
+    parseError(err);
+    return;
+  }
+
+  const receipt = await publicClient.waitForTransactionReceipt({
+    hash,
+  });
+
+  if (receipt.status !== "success") {
+    throw new Error("Transaction failed");
+  }
+
+  console.log("wrote comments", {
+    status: receipt.status,
+    gasUsed: receipt.gasUsed,
+  });
+};
+
+export const filterCommentsThatAreAlreadyOnChain = async ({
+  comments,
+  chainId,
+  publicClient,
+}: {
+  comments: MintComment[];
+  chainId: number;
+  publicClient: PublicClient;
+}) => {
+  const commentsAddress = (await getCommentsAddress(chainId)).COMMENTS;
+
+  const result = await publicClient.multicall({
+    allowFailure: false,
+    contracts: comments.map((comment) => ({
+      abi: commentsImplABI,
+      address: commentsAddress,
+      functionName: "hashAndCheckCommentExists",
+      args: [toCommentIdentifier(comment)],
+    })),
+  });
+
+  return comments.filter((_, index) => !result[index][1]);
+};

package/slither.config.json

@@ -0,0 +1,7 @@
+{
+    "filter_paths": "(node_modules/,test/)",
+    "solc_remaps": [
+        "@zoralabs/=node_modules/@zoralabs/",
+        "@openzeppelin/=node_modules/@openzeppelin/"
+    ]
+}