@zoralabs/comments-contracts 0.0.1

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@zoralabs/comments-contracts",
+  "version": "0.0.1",
+  "author": "oveddan",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.cjs"
+    }
+  },
+  "devDependencies": {
+    "@turnkey/api-key-stamper": "^0.3.1",
+    "@turnkey/http": "^2.5.1",
+    "@turnkey/viem": "^0.4.4",
+    "@types/node": "^20.1.2",
+    "@wagmi/cli": "^1.0.1",
+    "@zoralabs/chains": "^1.3.1",
+    "@openzeppelin/contracts": "5.0.2",
+    "@openzeppelin/contracts-upgradeable": "5.0.2",
+    "ds-test": "https://github.com/dapphub/ds-test#cd98eff28324bfac652e63a239a60632a761790b",
+    "forge-std": "https://github.com/foundry-rs/forge-std#v1.9.1",
+    "solady": "0.0.132",
+    "glob": "^10.2.2",
+    "pathe": "^1.1.2",
+    "prettier": "^3.0.3",
+    "prettier-plugin-solidity": "^1.3.1",
+    "tsup": "^7.2.0",
+    "tsx": "^3.13.0",
+    "typescript": "^5.2.2",
+    "viem": "^1.10.0",
+    "@zoralabs/tsconfig": "^0.0.1",
+    "@zoralabs/protocol-rewards": "^1.2.4",
+    "@zoralabs/shared-contracts": "^0.0.1",
+    "@zoralabs/sparks-contracts": "^0.2.2",
+    "@zoralabs/zora-1155-contracts": "^2.12.4"
+  },
+  "dependencies": {
+    "abitype": "^1.0.2"
+  },
+  "scripts": {
+    "prettier:check": "prettier --check 'src/**/*.sol' 'test/**/*.sol' 'script/**/*.sol'",
+    "prettier:write": "prettier --write 'src/**/*.sol' 'test/**/*.sol' 'script/**/*.sol'",
+    "test": "forge test -vv",
+    "dev": "FOUNDRY_PROFILE=dev forge test --watch -vvv",
+    "test-gas": "forge test --gas-report",
+    "storage-inspect:check": "./script/storage-check.sh check ZoraTimedSaleStrategyImpl",
+    "storage-inspect:generate": "./script/storage-check.sh generate ZoraTimedSaleStrategyImpl",
+    "build:sizes": "forge build --sizes",
+    "copy-abis": "pnpm tsx script/bundle-abis.ts",
+    "coverage": "FOUNDRY_PROFILE=default forge coverage --report lcov",
+    "build": "pnpm run wagmi:generate && pnpm run copy-abis && pnpm run prettier:write && tsup",
+    "wagmi:generate": "FOUNDRY_PROFILE=dev forge build && wagmi generate",
+    "update-contract-version": "pnpm tsx script/update-contract-version.ts"
+  }
+}

package/remappings.txt

@@ -0,0 +1,8 @@
+ds-test/=node_modules/ds-test/src/
+forge-std/=node_modules/forge-std/src/
+@openzeppelin/=node_modules/@openzeppelin/
+@zoralabs/protocol-rewards/=node_modules/@zoralabs/protocol-rewards/
+@zoralabs/shared-contracts/=node_modules/@zoralabs/shared-contracts/src/
+@zoralabs/sparks-contracts/=node_modules/@zoralabs/sparks-contracts/src/
+@zoralabs/erc20z/=node_modules/@zoralabs/erc20z/src/
+solady/=node_modules/solady/src/

package/script/CommentsDeployerBase.sol

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import "forge-std/Script.sol";
+
+import {ProxyDeployerScript} from "@zoralabs/shared-contracts/deployment/ProxyDeployerScript.sol";
+import {CommentsImpl} from "../src/CommentsImpl.sol";
+import {IProtocolRewards} from "@zoralabs/protocol-rewards/src/interfaces/IProtocolRewards.sol";
+
+// Temp script
+contract CommentsDeployerBase is ProxyDeployerScript {
+    uint256 internal constant SPARK_VALUE = 0.000001 ether;
+    address internal constant PROTOCOL_REWARDS = 0x7777777F279eba3d3Ad8F4E708545291A6fDBA8B;
+    address internal constant ZORA_TIMED_SALE_STRATEGY = 0x777777722D078c97c6ad07d9f36801e653E356Ae;
+    using stdJson for string;
+
+    struct CommentsDeployment {
+        address comments;
+        address commentsImpl;
+        string commentsVersion;
+    }
+
+    function saveDeployment(CommentsDeployment memory deployment) internal {
+        string memory objectKey = "config";
+
+        vm.serializeAddress(objectKey, "COMMENTS", deployment.comments);
+        string memory result = vm.serializeAddress(objectKey, "COMMENTS_IMPL", deployment.commentsImpl);
+
+        vm.writeJson(result, string.concat("./addresses/", vm.toString(block.chainid), ".json"));
+    }
+
+    function readDeployment() internal view returns (CommentsDeployment memory) {
+        string memory json = vm.readFile(string.concat("./addresses/", vm.toString(block.chainid), ".json"));
+
+        return
+            CommentsDeployment({
+                comments: readAddressOrDefaultToZero(json, "COMMENTS"),
+                commentsImpl: readAddressOrDefaultToZero(json, "COMMENTS_IMPL"),
+                commentsVersion: readStringOrDefaultToEmpty(json, "COMMENTS_VERSION")
+            });
+    }
+
+    function commentsImplCreationCode() internal pure returns (bytes memory) {
+        return abi.encodePacked(type(CommentsImpl).creationCode, abi.encode(SPARK_VALUE, PROTOCOL_REWARDS));
+    }
+
+    function getBackfillerAccount() internal pure returns (address) {
+        // todo: figure out backfiller.  right now this is made from cast wallet new
+        return 0x9AfA68161f094DAEA62816b6264b3D777978a164;
+    }
+
+    function defaultDelegateCommenters() internal pure returns (address[] memory delegateCommenters) {
+        delegateCommenters = new address[](1);
+        delegateCommenters[0] = ZORA_TIMED_SALE_STRATEGY;
+    }
+
+    function deployCommentsImpl() internal returns (CommentsImpl) {
+        return new CommentsImpl(SPARK_VALUE, PROTOCOL_REWARDS);
+    }
+}

package/script/Deploy.s.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import "forge-std/Script.sol";
+
+import {ProxyDeployerScript} from "@zoralabs/shared-contracts/deployment/ProxyDeployerScript.sol";
+import {ImmutableCreate2FactoryUtils} from "@zoralabs/shared-contracts/utils/ImmutableCreate2FactoryUtils.sol";
+import {ProxyDeployerScript, DeterministicDeployerAndCaller, DeterministicContractConfig} from "@zoralabs/shared-contracts/deployment/ProxyDeployerScript.sol";
+import {CommentsImpl} from "../src/CommentsImpl.sol";
+import {CommentsDeployment} from "../src/deployments/CommentsDeployment.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import {CommentsDeployerBase} from "./CommentsDeployerBase.sol";
+
+// Temp script
+contract DeployScript is CommentsDeployerBase {
+    function run() public {
+        CommentsDeployment memory deployment = readDeployment();
+
+        address owner = getProxyAdmin();
+
+        // todo: figure out backfiller.  right now this is made from cast wallet new
+        address backfiller = 0x9AfA68161f094DAEA62816b6264b3D777978a164;
+        address zoraRecipient = getZoraRecipient();
+
+        // get deployed implementation address.  it it's not deployed, revert
+        address implAddress = deployment.commentsImpl;
+
+        if (implAddress.code.length == 0) {
+            revert("Impl not yet deployed.  Make sure to deploy it with DeployImpl.s.sol");
+        }
+
+        vm.startBroadcast();
+
+        // get deployer contract
+        DeterministicDeployerAndCaller deployer = createOrGetDeployerAndCaller();
+
+        // read previously saved deterministic royalties config
+        DeterministicContractConfig memory commentsConfig = readDeterministicContractConfig("comments");
+
+        address[] memory delegateCommenters = defaultDelegateCommenters();
+
+        // build upgrade to and call for comments, with init call
+        bytes memory upgradeToAndCall = abi.encodeWithSelector(
+            UUPSUpgradeable.upgradeToAndCall.selector,
+            implAddress,
+            abi.encodeWithSelector(CommentsImpl.initialize.selector, zoraRecipient, owner, backfiller, delegateCommenters)
+        );
+
+        // sign royalties deployment with turnkey account
+        bytes memory commentsSignature = signDeploymentWithTurnkey(commentsConfig, upgradeToAndCall, deployer);
+
+        // deterministically deploy royalties contract using the signature
+        deployment.comments = deployer.permitSafeCreate2AndCall(
+            commentsSignature,
+            commentsConfig.salt,
+            commentsConfig.creationCode,
+            upgradeToAndCall,
+            commentsConfig.deployedAddress
+        );
+
+        vm.stopBroadcast();
+
+        // save the deployment json
+        saveDeployment(deployment);
+    }
+}

package/script/DeployImpl.s.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import "forge-std/console2.sol";
+
+import {CommentsDeployerBase} from "./CommentsDeployerBase.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+
+contract DeployImpl is CommentsDeployerBase {
+    function run() public {
+        CommentsDeployment memory config = readDeployment();
+        vm.startBroadcast();
+
+        config.commentsImpl = address(deployCommentsImpl());
+
+        vm.stopBroadcast();
+
+        console2.log("CommentsImpl deployed, to upgrade:");
+        console2.log("target:", config.comments);
+        console2.log("calldata:");
+        console2.logBytes(abi.encodeWithSelector(UUPSUpgradeable.upgradeToAndCall.selector, config.commentsImpl, ""));
+        console2.log("multisig:", getProxyAdmin());
+
+        saveDeployment(config);
+    }
+}

package/script/DeployNonDeterministic.s.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import "forge-std/Script.sol";
+
+import {ProxyDeployerScript} from "@zoralabs/shared-contracts/deployment/ProxyDeployerScript.sol";
+import {ImmutableCreate2FactoryUtils} from "@zoralabs/shared-contracts/utils/ImmutableCreate2FactoryUtils.sol";
+import {ProxyDeployerScript, DeterministicDeployerAndCaller, DeterministicContractConfig} from "@zoralabs/shared-contracts/deployment/ProxyDeployerScript.sol";
+import {Comments} from "../src/proxy/Comments.sol";
+import {CommentsImpl} from "../src/CommentsImpl.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import {CommentsDeployerBase} from "./CommentsDeployerBase.sol";
+
+contract DeployNonDeterministic is CommentsDeployerBase {
+    function run() public {
+        CommentsDeployment memory deployment = readDeployment();
+
+        address owner = getProxyAdmin();
+
+        // todo: figure out backfiller.  right now this is made from cast wallet new
+        address backfiller = 0x9AfA68161f094DAEA62816b6264b3D777978a164;
+        address zoraRecipient = getZoraRecipient();
+
+        vm.startBroadcast();
+        // deploy comments backfiller
+
+        address implAddress = address(deployCommentsImpl());
+
+        Comments comments = new Comments(implAddress);
+
+        address[] memory delegateCommenters = defaultDelegateCommenters();
+
+        CommentsImpl(payable(address(comments))).initialize(zoraRecipient, owner, backfiller, delegateCommenters);
+
+        vm.stopBroadcast();
+
+        deployment.comments = address(comments);
+        deployment.commentsImpl = implAddress;
+
+        // save the deployment json
+        saveDeployment(deployment);
+    }
+}

package/script/GenerateDeterministicParams.s.sol

@@ -0,0 +1,55 @@
+// spdx-license-identifier: mit
+pragma solidity ^0.8.20;
+
+import "forge-std/Script.sol";
+
+import {LibString} from "solady/utils/LibString.sol";
+import {ImmutableCreate2FactoryUtils} from "@zoralabs/shared-contracts/utils/ImmutableCreate2FactoryUtils.sol";
+import {ProxyDeployerScript, DeterministicDeployerAndCaller, DeterministicContractConfig} from "@zoralabs/shared-contracts/deployment/ProxyDeployerScript.sol";
+import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
+import {Comments} from "../src/proxy/Comments.sol";
+
+/// @dev This script saves the current bytecode, and initialization parameters for the Sparks proxy,
+/// which then need to be populated with a salt and expected address, which can be achieved by
+/// running the printed create2crunch command.  The resulting config only needs to be generated once
+/// and is reusable for all chains.
+contract GenerateDeterministicParams is ProxyDeployerScript {
+    function mineForCommentsAddress(DeterministicDeployerAndCaller deployer, address caller) private returns (DeterministicContractConfig memory config) {
+        // get proxy creation code
+        // get the expected init code for the proxy from the uupsProxyDeployer
+        bytes memory initCode = deployer.proxyCreationCode(type(Comments).creationCode);
+        bytes32 initCodeHash = keccak256(initCode);
+
+        // uupsProxyDeployer is deployer
+        (bytes32 salt, address expectedAddress) = mineSalt(address(deployer), initCodeHash, "7777777", caller);
+
+        // test deployment
+        // Create2.deploy(0, salt, initCode);
+
+        console2.log("salt");
+        console2.log(vm.toString(salt));
+
+        config.salt = salt;
+        config.deployedAddress = expectedAddress;
+        config.creationCode = initCode;
+        config.constructorArgs = deployer.proxyConstructorArgs();
+        config.contractName = "Comments";
+        config.deploymentCaller = caller;
+    }
+
+    function run() public {
+        address caller = vm.envAddress("DEPLOYER");
+
+        vm.startBroadcast();
+
+        // create a proxy deployer, which we can use to generated determistic addresses and corresponding params.
+        // proxy deployer code is based on code saved to file from running the script SaveProxyDeployerConfig.s.sol
+        DeterministicDeployerAndCaller deployer = createOrGetDeployerAndCaller();
+
+        vm.stopBroadcast();
+
+        DeterministicContractConfig memory commentsConfig = mineForCommentsAddress(deployer, caller);
+
+        saveDeterministicContractConfig(commentsConfig, "comments");
+    }
+}

package/script/bundle-abis.ts

@@ -0,0 +1,109 @@
+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/storage-check.sh

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+
+set -e
+
+generate() {
+  file=$1
+  if [[ $func == "generate" ]]; then
+    echo "Creating storage layout diagrams for the following contracts: $contracts"
+    echo "..."
+  fi
+
+  echo "=======================" > "$file"
+  echo "👁👁 STORAGE LAYOUT snapshot 👁👁" >"$file"
+  echo "=======================" >> "$file"
+# shellcheck disable=SC2068
+  for contract in ${contracts[@]}
+  do
+    { echo -e "\n======================="; echo "➡ $contract" ; echo -e "=======================\n"; } >> "$file"
+    FOUNDRY_PROFILE=dev forge inspect --pretty "$contract" storage-layout >> "$file"
+  done
+  if [[ $func == "generate" ]]; then
+    echo "Storage layout snapshot stored at $file"
+  fi
+}
+
+if ! command -v forge &> /dev/null
+then
+    echo "forge could not be found. Please install forge by running:"
+    echo "curl -L https://foundry.paradigm.xyz | bash"
+    exit
+fi
+
+# shellcheck disable=SC2124
+contracts="${@:2}"
+func=$1
+filename=.storage-layout
+new_filename=.storage-layout.temp
+
+if [[ $func == "check" ]]; then
+  generate $new_filename
+  if ! cmp -s .storage-layout $new_filename ; then
+    echo "storage-layout test: fails ❌"
+    echo "The following lines are different:"
+    diff -a --suppress-common-lines "$filename" "$new_filename"
+    rm $new_filename
+    exit 1
+  else
+    echo "storage-layout test: passes ✅"
+    rm $new_filename
+    exit 0
+  fi
+elif [[ $func == "generate" ]]; then
+  generate "$filename"
+else
+  echo "unknown command. Use 'generate' or 'check' as the first argument."
+  exit 1
+fi

package/script/update-contract-version.ts

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

package/scripts/abis.ts

@@ -0,0 +1,3 @@
+export const zoraTimedSaleStrategyImplABI = [
+  "function mint(address mintTo, uint256 quantity, address collection, uint256 tokenId, address mintReferral, string calldata comment) external returns (uint256)",
+] as const;