@zoralabs/comments-contracts 0.0.1 → 0.0.2

package/test/mocks/MockDelegateCommenter.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import {IComments} from "../../src/interfaces/IComments.sol";
+import {Mock1155} from "./Mock1155.sol";
+
+contract MockDelegateCommenter {
+    IComments immutable comments;
+    uint256 MINT_FEE = 0.000111 ether;
+    uint256 constant SPARKS_VALUE = 0.000001 ether;
+
+    constructor(address _comments) {
+        comments = IComments(_comments);
+    }
+
+    IComments.CommentIdentifier emptyCommentIdentifier;
+
+    function forwardComment(address collection, uint256 tokenId, string calldata comment) external {
+        comments.delegateComment(msg.sender, collection, tokenId, comment, emptyCommentIdentifier, address(0), address(0));
+    }
+
+    function mintAndCommentWithSpark(
+        uint256 quantity,
+        address collection,
+        uint256 tokenId,
+        string calldata comment,
+        address referrer,
+        uint256 sparksQuantity
+    ) external payable {
+        require(msg.value == SPARKS_VALUE * sparksQuantity + MINT_FEE * quantity, "Invalid value");
+        Mock1155(collection).mint(msg.sender, tokenId, quantity, "");
+
+        // get sparks value to send to comments contract
+        comments.delegateComment{value: SPARKS_VALUE * sparksQuantity}(msg.sender, collection, tokenId, comment, emptyCommentIdentifier, address(0), referrer);
+    }
+}

package/test/mocks/MockIZoraCreator1155.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {IERC1155} from "@openzeppelin/contracts/interfaces/IERC1155.sol";
+import {IZoraCreator1155TypesV1} from "../../src/interfaces/IZoraCreator1155TypesV1.sol";
+
+// For testing without getCreatorRewardRecipient
+interface IZoraCreator1155 is IERC1155, IZoraCreator1155TypesV1 {
+    function isAdminOrRole(address user, uint256 tokenId, uint256 role) external view returns (bool);
+
+    function supportsInterface(bytes4 interfaceId) external view returns (bool);
+
+    function config() external view returns (address owner, uint96 __gap1, address payable fundsRecipient, uint96 __gap2, address transferHook, uint96 __gap3);
+
+    function setFundsRecipient(address payable fundsRecipient) external;
+}

package/test/mocks/MockSecondarySwap.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {ISecondarySwap} from "../../src/interfaces/ISecondarySwap.sol";
+import {Mock1155} from "./Mock1155.sol";
+import {MockZoraTimedSale} from "./MockZoraTimedSale.sol";
+import {IERC1155Receiver} from "@openzeppelin/contracts/interfaces/IERC1155Receiver.sol";
+
+contract MockSecondarySwap is ISecondarySwap {
+    MockZoraTimedSale immutable mockTimedSale;
+
+    constructor(MockZoraTimedSale _mockTimedSale) {
+        mockTimedSale = _mockTimedSale;
+    }
+
+    function buy1155(address erc20zAddress, uint256 num1155ToBuy, address payable recipient, address payable, uint256, uint160) external payable {
+        (address collection, uint256 tokenId) = mockTimedSale.collectionForErc20z(erc20zAddress);
+        if (collection == address(0)) revert("ERC20z not set");
+        Mock1155(collection).mint(recipient, tokenId, num1155ToBuy, "");
+    }
+
+    function onERC1155Received(address, address, uint256 tokenId, uint256, bytes calldata) external view returns (bytes4) {
+        address collection = msg.sender;
+        address erc20zAddress = mockTimedSale.sale(collection, tokenId).erc20zAddress;
+        if (erc20zAddress == address(0)) {
+            revert SaleNotSet();
+        }
+        return IERC1155Receiver.onERC1155Received.selector;
+    }
+}

package/test/mocks/MockZoraTimedSale.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Mock1155} from "./Mock1155.sol";
+import {IZoraTimedSaleStrategy} from "../../src/interfaces/IZoraTimedSaleStrategy.sol";
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract MockERC20z is ERC20 {
+    constructor() ERC20("ERC20z", "ERC20z") {}
+}
+
+contract MockZoraTimedSale is IZoraTimedSaleStrategy {
+    uint256 constant MINT_FEE = 0.000111 ether;
+
+    function mint(address mintTo, uint256 quantity, address collection, uint256 tokenId, address, string calldata) external payable {
+        if (msg.value != MINT_FEE * quantity) revert("Incorrect mint fee");
+        Mock1155(collection).mint{value: msg.value}(mintTo, tokenId, quantity, "");
+    }
+
+    struct CollectionAndTokenId {
+        address collection;
+        uint256 tokenId;
+    }
+
+    mapping(address => mapping(uint256 => address)) internal saleStorage;
+    mapping(address => CollectionAndTokenId) public collectionForErc20z;
+
+    function setSale(address collection, uint256 tokenId) external returns (address erc20z) {
+        erc20z = address(new MockERC20z());
+        saleStorage[collection][tokenId] = erc20z;
+        collectionForErc20z[erc20z] = CollectionAndTokenId(collection, tokenId);
+    }
+
+    function sale(address collection, uint256 tokenId) external view returns (SaleStorage memory _sale) {
+        address erc20z = saleStorage[collection][tokenId];
+        _sale.erc20zAddress = payable(erc20z);
+    }
+}

package/wagmi.config.ts

@@ -8,7 +8,9 @@ export default defineConfig({
       forge: {
         build: false,
       },
-      include: ["CommentsImpl"].map((contractName) => `${contractName}.json`),
+      include: ["CommentsImpl", "CallerAndCommenterImpl"].map(
+        (contractName) => `${contractName}.json`,
+      ),
     }),
   ],
 });

package/abis/ProxyDeployerScript.json

@@ -1,15 +0,0 @@
-[
-  {
-    "type": "function",
-    "name": "IS_SCRIPT",
-    "inputs": [],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  }
-]

package/scripts/backfillComments.ts

@@ -1,176 +0,0 @@
-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/queries.ts

@@ -1,73 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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/writeComments.ts

@@ -1,198 +0,0 @@
-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]);
-};