@zoralabs/comments-contracts 0.0.2 → 0.0.3

package/src/CommentsImpl.sol

@@ -4,11 +4,13 @@ pragma solidity ^0.8.23;
 import {AccessControlUpgradeable} from "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
 import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
+import {IERC165} from "@openzeppelin/contracts/interfaces/IERC165.sol";
 import {IHasContractName} from "@zoralabs/shared-contracts/interfaces/IContractMetadata.sol";
 import {ContractVersionBase} from "./version/ContractVersionBase.sol";
 import {IZoraCreator1155} from "./interfaces/IZoraCreator1155.sol";
 import {IComments} from "./interfaces/IComments.sol";
-import {IProtocolRewards} from "@zoralabs/protocol-rewards/src/interfaces/IProtocolRewards.sol";
+import {ICoinComments} from "./interfaces/ICoinComments.sol";
+import {IProtocolRewards} from "@zoralabs/shared-contracts/interfaces/IProtocolRewards.sol";
 import {UnorderedNoncesUpgradeable} from "@zoralabs/shared-contracts/utils/UnorderedNoncesUpgradeable.sol";
 import {EIP712UpgradeableWithChainId} from "./utils/EIP712UpgradeableWithChainId.sol";
 import {SignatureChecker} from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
@@ -365,31 +367,45 @@ contract CommentsImpl is
     }
 
     function _accountOrSmartWalletIsTokenAdmin(address contractAddress, uint256 tokenId, address user, address smartWallet) internal view returns (bool) {
-        if (_isTokenAdmin(contractAddress, tokenId, user)) {
-            return true;
-        }
-        if (smartWallet != address(0)) {
-            return _isTokenAdmin(contractAddress, tokenId, smartWallet);
+        bool isCoin = _isCoinComment(contractAddress, tokenId);
+
+        if (isCoin) {
+            return ICoinComments(contractAddress).isOwner(user) || (smartWallet != address(0) && ICoinComments(contractAddress).isOwner(smartWallet));
+        } else {
+            return _isTokenAdmin(contractAddress, tokenId, user) || (smartWallet != address(0) && _isTokenAdmin(contractAddress, tokenId, smartWallet));
         }
-        return false;
     }
 
     function _accountOrSmartWalletIsTokenHolder(address contractAddress, uint256 tokenId, address user, address smartWallet) internal view returns (bool) {
-        if (_isTokenHolder(contractAddress, tokenId, user)) {
-            return true;
-        }
-        if (smartWallet != address(0)) {
-            return _isTokenHolder(contractAddress, tokenId, smartWallet);
+        bool isCoin = _isCoinComment(contractAddress, tokenId);
+
+        if (isCoin) {
+            return
+                ICoinComments(contractAddress).balanceOf(user) >= 1e18 ||
+                (smartWallet != address(0) && ICoinComments(contractAddress).balanceOf(smartWallet) >= 1e18);
+        } else {
+            return _isTokenHolder(contractAddress, tokenId, user) || (smartWallet != address(0) && _isTokenHolder(contractAddress, tokenId, smartWallet));
         }
-        return false;
     }
 
     function _isTokenAdmin(address contractAddress, uint256 tokenId, address user) internal view returns (bool) {
-        return IZoraCreator1155(contractAddress).isAdminOrRole(user, tokenId, PERMISSION_BIT_ADMIN);
+        try IZoraCreator1155(contractAddress).isAdminOrRole(user, tokenId, PERMISSION_BIT_ADMIN) returns (bool isAdmin) {
+            return isAdmin;
+        } catch {
+            return false;
+        }
     }
 
     function _isTokenHolder(address contractAddress, uint256 tokenId, address user) internal view returns (bool) {
-        return IERC1155(contractAddress).balanceOf(user, tokenId) > 0;
+        try IERC1155(contractAddress).balanceOf(user, tokenId) returns (uint256 balance) {
+            return balance > 0;
+        } catch {
+            return false;
+        }
+    }
+
+    function _isCoinComment(address contractAddress, uint256 tokenId) internal view returns (bool) {
+        return tokenId == 0 && IERC165(contractAddress).supportsInterface(type(ICoinComments).interfaceId);
     }
 
     function _getCommentSparksRecipient(CommentIdentifier memory commentIdentifier, CommentIdentifier memory replyTo) internal view returns (address) {
@@ -629,6 +645,18 @@ contract CommentsImpl is
         }
     }
 
+    function _getCoinPayoutRecipient(address contractAddress, uint256 tokenId) internal view returns (address) {
+        if (_isCoinComment(contractAddress, tokenId)) {
+            try ICoinComments(contractAddress).payoutRecipient() returns (address payoutRecipient) {
+                return payoutRecipient;
+            } catch {
+                return address(0);
+            }
+        }
+
+        return address(0);
+    }
+
     function _getFundsRecipient(address contractAddress) internal view returns (address) {
         try IZoraCreator1155(contractAddress).config() returns (address, uint96, address payable fundsRecipient, uint96, address, uint96) {
             if (fundsRecipient != address(0)) {
@@ -654,6 +682,11 @@ contract CommentsImpl is
     }
 
     function _getCreatorRewardRecipient(CommentIdentifier memory commentIdentifier) internal view returns (address) {
+        address payoutRecipient = _getCoinPayoutRecipient(commentIdentifier.contractAddress, commentIdentifier.tokenId);
+        if (payoutRecipient != address(0)) {
+            return payoutRecipient;
+        }
+
         address creatorRecipient = _tryGetCreatorRewardRecipient(commentIdentifier);
         if (creatorRecipient != address(0)) {
             return creatorRecipient;

package/src/interfaces/ICoinComments.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface ICoinComments {
+    function isOwner(address) external view returns (bool);
+    function payoutRecipient() external view returns (address);
+    function balanceOf(address) external view returns (uint256);
+}

package/src/version/ContractVersionBase.sol

@@ -9,6 +9,6 @@ import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersion
 contract ContractVersionBase is IVersionedContract {
     /// @notice The version of the contract
     function contractVersion() external pure override returns (string memory) {
-        return "0.0.2";
+        return "0.0.3";
     }
 }

package/test/Comments.t.sol

@@ -616,4 +616,70 @@ contract CommentsTest is CommentsTestBase {
         vm.expectRevert(abi.encodeWithSignature("AccessControlUnauthorizedAccount(address,bytes32)", notAdmin, no_role));
         comments.grantRole(BACKFILLER_ROLE, newBackfiller);
     }
+
+    function testCommentAsCoinAdmin() public {
+        IComments.CommentIdentifier memory expectedCommentId = _expectedCommentIdentifier(address(mockCoin), tokenId0, tokenAdmin);
+
+        vm.prank(tokenAdmin);
+        IComments.CommentIdentifier memory commentId = comments.comment(
+            tokenAdmin,
+            address(mockCoin),
+            tokenId0,
+            "test comment",
+            emptyCommentIdentifier,
+            address(0),
+            address(0)
+        );
+
+        (bytes32 commentIdHash, bool exists) = comments.hashAndCheckCommentExists(commentId);
+
+        assertEq(exists, true);
+        assertEq(commentIdHash, comments.hashCommentIdentifier(expectedCommentId));
+        assertEq(comments.commentSparksQuantity(commentId), 0);
+    }
+
+    function testCommentAsCoinHolder() public {
+        address commenter = makeAddr("commenter");
+
+        mockCoin.mint(commenter, 1e18);
+        vm.deal(commenter, SPARKS_VALUE);
+
+        IComments.CommentIdentifier memory expectedCommentId = _expectedCommentIdentifier(address(mockCoin), tokenId0, commenter);
+
+        vm.prank(commenter);
+        IComments.CommentIdentifier memory commentId = comments.comment{value: SPARKS_VALUE}(
+            commenter,
+            address(mockCoin),
+            tokenId0,
+            "test comment",
+            emptyCommentIdentifier,
+            address(0),
+            address(0)
+        );
+
+        (bytes32 commentIdHash, bool exists) = comments.hashAndCheckCommentExists(commentId);
+        assertEq(exists, true);
+        assertEq(commentIdHash, comments.hashCommentIdentifier(expectedCommentId));
+
+        uint256 zoraReward = (SPARKS_VALUE * (ZORA_REWARD_PCT + REFERRER_REWARD_PCT)) / BPS_TO_PERCENT_2_DECIMAL_PERCISION;
+        assertEq(protocolRewards.balanceOf(tokenAdmin), SPARKS_VALUE - zoraReward);
+    }
+
+    function testRevertCommentAsCoinHolderWithoutSparks() public {
+        address commenter = makeAddr("commenter");
+        mockCoin.mint(commenter, 1e18);
+
+        vm.expectRevert(abi.encodeWithSignature("MustSendAtLeastOneSpark()"));
+        vm.prank(commenter);
+        comments.comment(commenter, address(mockCoin), tokenId0, "test comment", emptyCommentIdentifier, address(0), address(0));
+    }
+
+    function testRevertCommentAsNonCoinHolder() public {
+        address nonHolder = makeAddr("nonHolder");
+        vm.deal(nonHolder, SPARKS_VALUE);
+
+        vm.expectRevert(abi.encodeWithSignature("NotTokenHolderOrAdmin()"));
+        vm.prank(nonHolder);
+        comments.comment{value: SPARKS_VALUE}(nonHolder, address(mockCoin), tokenId0, "test comment", emptyCommentIdentifier, address(0), address(0));
+    }
 }

package/test/CommentsTestBase.sol

@@ -7,12 +7,14 @@ import {CommentsImpl} from "../src/CommentsImpl.sol";
 import {Comments} from "../src/proxy/Comments.sol";
 import {IComments} from "../src/interfaces/IComments.sol";
 import {Mock1155} from "./mocks/Mock1155.sol";
+import {MockCoin} from "./mocks/MockCoin.sol";
 import {ProtocolRewards} from "./mocks/ProtocolRewards.sol";
 
 contract CommentsTestBase is Test {
     CommentsImpl internal comments;
     CommentsImpl internal commentsImpl;
     Mock1155 internal mock1155;
+    MockCoin internal mockCoin;
 
     uint256 internal constant SPARKS_VALUE = 0.000001 ether;
 
@@ -30,6 +32,7 @@ contract CommentsTestBase is Test {
     address internal sparker;
     uint256 internal sparkerPrivateKey;
 
+    uint256 internal tokenId0 = 0;
     uint256 internal tokenId1 = 1;
     uint256 internal tokenId2 = 2;
 
@@ -52,6 +55,10 @@ contract CommentsTestBase is Test {
 
         (collectorWithToken, collectorWithTokenPrivateKey) = makeAddrAndKey("collectorWithToken");
         (sparker, sparkerPrivateKey) = makeAddrAndKey("sparker");
+
+        address[] memory owners = new address[](1);
+        owners[0] = tokenAdmin;
+        mockCoin = new MockCoin(tokenAdmin, owners);
     }
 
     function _expectedCommentIdentifier(

package/test/Comments_permit.t.sol

@@ -7,7 +7,7 @@ import {CommentsImpl} from "../src/CommentsImpl.sol";
 import {Comments} from "../src/proxy/Comments.sol";
 import {IComments} from "../src/interfaces/IComments.sol";
 import {Mock1155} from "./mocks/Mock1155.sol";
-import {IProtocolRewards} from "@zoralabs/protocol-rewards/src/interfaces/IProtocolRewards.sol";
+import {IProtocolRewards} from "@zoralabs/shared-contracts/interfaces/IProtocolRewards.sol";
 import {ProtocolRewards} from "./mocks/ProtocolRewards.sol";
 import {CommentsTestBase} from "./CommentsTestBase.sol";
 import {UnorderedNoncesUpgradeable} from "@zoralabs/shared-contracts/utils/UnorderedNoncesUpgradeable.sol";

package/test/Comments_smartWallet.t.sol

@@ -149,4 +149,101 @@ contract Comments_smartWallet is CommentsTestBase {
             referrer: address(0)
         });
     }
+
+    function test_commentWithSmartWalletOwner_whenCoinHolder() public {
+        address smartWallet = address(new MockMultiOwnable(address(collectorWithoutToken)));
+
+        mockCoin.mint(smartWallet, 1e18);
+
+        IComments.CommentIdentifier memory expectedCommentId = _expectedCommentIdentifier(address(mockCoin), tokenId0, collectorWithoutToken);
+
+        vm.deal(collectorWithoutToken, SPARKS_VALUE);
+        vm.prank(collectorWithoutToken);
+        comments.comment{value: SPARKS_VALUE}({
+            commenter: collectorWithoutToken,
+            contractAddress: address(mockCoin),
+            tokenId: tokenId0,
+            text: "test comment",
+            replyTo: emptyCommentIdentifier,
+            commenterSmartWallet: smartWallet,
+            referrer: address(0)
+        });
+
+        (, bool exists) = comments.hashAndCheckCommentExists(expectedCommentId);
+        assertTrue(exists);
+    }
+
+    function test_commentWithSmartWalletOwner_whenCoinOwner() public {
+        address smartWallet = address(new MockMultiOwnable(address(tokenAdmin)));
+
+        IComments.CommentIdentifier memory expectedCommentId = _expectedCommentIdentifier(address(mockCoin), tokenId0, tokenAdmin);
+
+        vm.prank(tokenAdmin);
+        comments.comment({
+            commenter: tokenAdmin,
+            contractAddress: address(mockCoin),
+            tokenId: tokenId0,
+            text: "test comment",
+            replyTo: emptyCommentIdentifier,
+            commenterSmartWallet: smartWallet,
+            referrer: address(0)
+        });
+
+        (, bool exists) = comments.hashAndCheckCommentExists(expectedCommentId);
+        assertTrue(exists);
+    }
+
+    function test_commentWithSmartWalletOwner_revertsWhenNotCoinHolder() public {
+        address smartWallet = address(new MockMultiOwnable(address(collectorWithoutToken)));
+
+        vm.expectRevert(abi.encodeWithSelector(IComments.NotTokenHolderOrAdmin.selector));
+        vm.prank(collectorWithoutToken);
+        vm.deal(collectorWithoutToken, SPARKS_VALUE);
+        comments.comment{value: SPARKS_VALUE}({
+            commenter: collectorWithoutToken,
+            contractAddress: address(mockCoin),
+            tokenId: tokenId0,
+            text: "test comment",
+            replyTo: emptyCommentIdentifier,
+            commenterSmartWallet: smartWallet,
+            referrer: address(0)
+        });
+    }
+
+    function test_commentWithSmartWalletOwner_revertsWhenNotCoinSmartWalletOwner() public {
+        address smartWallet = address(new MockMultiOwnable(address(makeAddr("notOwner"))));
+
+        mockCoin.mint(smartWallet, 1e18);
+
+        vm.expectRevert(IComments.NotSmartWalletOwner.selector);
+        vm.prank(collectorWithoutToken);
+        vm.deal(collectorWithoutToken, SPARKS_VALUE);
+        comments.comment{value: SPARKS_VALUE}({
+            commenter: collectorWithoutToken,
+            contractAddress: address(mockCoin),
+            tokenId: tokenId0,
+            text: "test comment",
+            replyTo: emptyCommentIdentifier,
+            commenterSmartWallet: smartWallet,
+            referrer: address(0)
+        });
+    }
+
+    function test_commentWithSmartWalletOwner_revertsWhenNotCoinSmartWallet() public {
+        address smartWallet = makeAddr("smartWallet");
+
+        mockCoin.mint(smartWallet, 1e18);
+
+        vm.expectRevert(IComments.NotSmartWallet.selector);
+        vm.prank(collectorWithoutToken);
+        comments.comment({
+            commenter: collectorWithoutToken,
+            contractAddress: address(mockCoin),
+            tokenId: tokenId0,
+            text: "test comment",
+            replyTo: emptyCommentIdentifier,
+            commenterSmartWallet: smartWallet,
+            referrer: address(0)
+        });
+    }
 }

package/test/mocks/MockCoin.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import {IERC165} from "@openzeppelin/contracts/interfaces/IERC165.sol";
+import {ICoinComments} from "../../src/interfaces/ICoinComments.sol";
+
+contract MockCoin is ICoinComments, IERC165, ERC20 {
+    using EnumerableSet for EnumerableSet.AddressSet;
+
+    address internal _payoutRecipient;
+    EnumerableSet.AddressSet internal _owners;
+
+    constructor(address payoutRecipient_, address[] memory owners_) ERC20("MockCoin", "MC") {
+        _payoutRecipient = payoutRecipient_;
+
+        for (uint256 i; i < owners_.length; i++) {
+            _owners.add(owners_[i]);
+        }
+    }
+
+    function mint(address to, uint256 amount) public {
+        _mint(to, amount);
+    }
+
+    function balanceOf(address account) public view override(ERC20, ICoinComments) returns (uint256) {
+        return super.balanceOf(account);
+    }
+
+    function payoutRecipient() public view override(ICoinComments) returns (address) {
+        return _payoutRecipient;
+    }
+
+    function isOwner(address account) public view override(ICoinComments) returns (bool) {
+        return _owners.contains(account);
+    }
+
+    function supportsInterface(bytes4 interfaceId) public pure returns (bool) {
+        return type(ICoinComments).interfaceId == interfaceId;
+    }
+}

package/script/bundle-abis.ts

@@ -1,109 +0,0 @@
-import { promises as fs } from "fs";
-import { basename, extname, join, resolve } from "pathe";
-import { glob } from "glob";
-import { ContractConfig } from "@wagmi/cli";
-
-const defaultExcludes = [
-  "Common.sol/**",
-  "Components.sol/**",
-  "Script.sol/**",
-  "StdAssertions.sol/**",
-  "StdInvariant.sol/**",
-  "StdError.sol/**",
-  "StdCheats.sol/**",
-  "StdMath.sol/**",
-  "StdJson.sol/**",
-  "StdStorage.sol/**",
-  "StdUtils.sol/**",
-  "Vm.sol/**",
-  "console.sol/**",
-  "console2.sol/**",
-  "test.sol/**",
-  "**.s.sol/*.json",
-  "**.t.sol/*.json",
-];
-
-// design inspired by https://github.com/wagmi-dev/wagmi/blob/main/packages/cli/src/plugins/foundry.ts
-
-export const readContracts = async ({
-  deployments = {} as any,
-  exclude = defaultExcludes,
-  include = ["*.json"],
-  namePrefix = "",
-  project_ = "./",
-}) => {
-  // get all the files in ./out
-  function getContractName(artifactPath: string, usePrefix = true) {
-    const filename = basename(artifactPath);
-    const extension = extname(artifactPath);
-    return `${usePrefix ? namePrefix : ""}${filename.replace(extension, "")}`;
-  }
-
-  async function getContract(artifactPath: string) {
-    const artifact = JSON.parse(await fs.readFile(artifactPath, "utf-8"));
-    return {
-      abi: artifact.abi,
-      address: (deployments as Record<string, ContractConfig["address"]>)[
-        getContractName(artifactPath, false)
-      ],
-      name: getContractName(artifactPath),
-    };
-  }
-
-  async function getArtifactPaths(artifactsDirectory: string) {
-    return await glob([
-      ...include.map((x) => `${artifactsDirectory}/**/${x}`),
-      ...exclude.map((x) => `!${artifactsDirectory}/**/${x}`),
-    ]);
-  }
-
-  const project = resolve(process.cwd(), project_ ?? "");
-
-  const config = {
-    out: "out",
-    src: "src",
-  };
-
-  const artifactsDirectory = join(project, config.out);
-
-  const artifactPaths = await getArtifactPaths(artifactsDirectory);
-  const contracts = [];
-  for (const artifactPath of artifactPaths) {
-    const contract = await getContract(artifactPath);
-    if (!contract.abi?.length) continue;
-    contracts.push(contract);
-  }
-  return contracts;
-};
-
-async function saveContractsAbisJson(contracts: { abi: any; name: string }[]) {
-  // for each contract, write abi to ./abis/{contractName}.json
-
-  const abisFolder = "./abis";
-
-  // mkdir - p ./abis:
-  await fs.mkdir(abisFolder, { recursive: true });
-  // remove abis folder:
-  await fs.rm(abisFolder, { recursive: true });
-  // add it back
-  // mkdir - p ./abis:
-  await fs.mkdir(abisFolder, { recursive: true });
-
-  // now write abis:
-  await Promise.all(
-    contracts.map(async (contract) => {
-      const abiJson = JSON.stringify(contract.abi, null, 2);
-      const abiJsonPath = `${abisFolder}/${contract.name}.json`;
-
-      await fs.writeFile(abiJsonPath, abiJson);
-    }),
-  );
-}
-
-async function main() {
-  const contracts = await readContracts({});
-
-  await saveContractsAbisJson(contracts);
-}
-
-main();

package/script/update-contract-version.ts

@@ -1,63 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { promisify } from "util";
-import { fileURLToPath } from "url";
-
-const readFileAsync = promisify(fs.readFile);
-const writeFileAsync = promisify(fs.writeFile);
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const makePackageVersionFile = async (version: string): Promise<void> => {
-  console.log("updating contract version to ", version);
-  // read the version from the root package.json:
-
-  const packageVersionCode = `// This file is automatically generated by code; do not manually update
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.23;
-
-import {IVersionedContract} from "@zoralabs/shared-contracts/interfaces/IVersionedContract.sol";
-
-/// @title ContractVersionBase
-/// @notice Base contract for versioning contracts
-contract ContractVersionBase is IVersionedContract {
-    /// @notice The version of the contract
-    function contractVersion() external pure override returns (string memory) {
-        return "${version}";
-    }
-}
-`;
-
-  // write the file to __dirname__/../src/version/ContractVersionBase.sol:
-  const filePath = path.join(
-    __dirname,
-    "..",
-    "src",
-    "version",
-    "ContractVersionBase.sol",
-  );
-
-  console.log("generated contract version code:", packageVersionCode);
-  console.log("writing file to", filePath);
-
-  await writeFileAsync(filePath, packageVersionCode);
-};
-
-const getVersion = async (): Promise<string> => {
-  // read package.json file, parse json, then get version:
-  const packageJson = JSON.parse(
-    await readFileAsync(path.join(__dirname, "..", "package.json"), "utf-8"),
-  );
-
-  return packageJson.version;
-};
-
-const main = async (): Promise<void> => {
-  const version = await getVersion();
-  await makePackageVersionFile(version);
-};
-
-main().catch((error) => {
-  console.error("Error updating contract version:", error);
-});