Remove package-lock.json, update dependencies in package.json, and add new EAS contracts and related configurations. Refactor marketplace components and enhance review functionalities in the Next.js app. Clean up unused block explorer components and improve IPFS handling.

Author: escottalexander

package-lock.json

@@ -12,7 +12,7 @@ interface IListingType {
     function onSale(uint256 listingId, address buyer, bytes calldata data) external payable returns (bool);
     function afterSale(uint256 listingId, address buyer, bytes calldata data) external returns (bool);
 
-    // Pre-buy lifecycle (e.g., escrow setup)
+    // Pre-buy lifecycle (e.g., escrow setup, pre-payment, auction mechanism etc.)
     function beforePreBuy(uint256 listingId, address buyer, bytes calldata data) external returns (bool);
     function onPreBuy(uint256 listingId, address buyer, bytes calldata data) external payable returns (bool);
     function afterPreBuy(uint256 listingId, address buyer, bytes calldata data) external returns (bool);

packages/hardhat/contracts/IListingType.sol

@@ -2,11 +2,7 @@
 pragma solidity >=0.8.0 <0.9.0;
 
 import { IListingType } from "./IListingType.sol";
-
-interface IERC20 {
-    function transfer(address to, uint256 value) external returns (bool);
-    function transferFrom(address from, address to, uint256 value) external returns (bool);
-}
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
 contract SimpleListings is IListingType {
     // Custom errors
@@ -192,12 +188,4 @@ contract SimpleListings is IListingType {
         emit SimpleListingClosed(listingId, caller);
         return true;
     }
-
-    // Backward compatibility
-    function closeListing(uint256 listingId, address caller) external onlyMarketplace returns (bool) {
-        if (!this.beforeClose(listingId, caller, "")) revert BeforeCloseFailed();
-        if (!this.onClose(listingId, caller, "")) revert OnCloseFailed();
-        if (!this.afterClose(listingId, caller, "")) revert AfterCloseFailed();
-        return true;
-    }
 }

packages/hardhat/contracts/SimpleListings.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+
+/**
+ * @title TestERC20
+ * @notice Simple ERC20 with configurable name, symbol and decimals at deploy time.
+ *         Ownership is set to the provided `initialOwner` so minting can be controlled in tests/local.
+ */
+contract TestERC20 is ERC20, Ownable {
+    uint8 private immutable _customDecimals;
+
+    constructor(
+        string memory name_,
+        string memory symbol_,
+        uint8 decimals_,
+        address initialOwner
+    ) ERC20(name_, symbol_) Ownable(initialOwner) {
+        _customDecimals = decimals_;
+    }
+
+    function decimals() public view override returns (uint8) {
+        return _customDecimals;
+    }
+
+    function mint(address to, uint256 amount) external onlyOwner {
+        _mint(to, amount);
+    }
+}
+
+

packages/hardhat/contracts/TestERC20.sol

@@ -0,0 +1,50 @@
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+import { DeployFunction } from "hardhat-deploy/types";
+
+const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  // Only deploy on localhost/hardhat for development convenience
+  const networkName = hre.network.name;
+  if (networkName !== "localhost" && networkName !== "hardhat") {
+    console.log("Skipping TestERC20 deploy on network:", networkName);
+    return;
+  }
+
+  const OWNER = "0xe1CE8616c669Cd3F1EC4598cef01B89331e7D849";
+  const { deployer } = await hre.getNamedAccounts();
+  const { deploy, get, log } = hre.deployments;
+
+  // Token A: 2 decimals
+  const name2 = process.env.TEST_ERC20_2_NAME ?? "Test Token 2d";
+  const symbol2 = process.env.TEST_ERC20_2_SYMBOL ?? "TT2";
+  const decimals2 = 2;
+
+  await deploy("TestERC20_2dec", {
+    contract: "TestERC20",
+    from: deployer,
+    args: [name2, symbol2, decimals2, OWNER],
+    log: true,
+    autoMine: true,
+  });
+
+  const token2 = await get("TestERC20_2dec");
+  log(`TestERC20_2dec deployed at ${token2.address} (name=${name2}, symbol=${symbol2}, decimals=${decimals2})`);
+
+  // Token B: 6 decimals
+  const name6 = process.env.TEST_ERC20_6_NAME ?? "Test Token 6d";
+  const symbol6 = process.env.TEST_ERC20_6_SYMBOL ?? "TT6";
+  const decimals6 = 6;
+
+  await deploy("TestERC20_6dec", {
+    contract: "TestERC20",
+    from: deployer,
+    args: [name6, symbol6, decimals6, OWNER],
+    log: true,
+    autoMine: true,
+  });
+
+  const token6 = await get("TestERC20_6dec");
+  log(`TestERC20_6dec deployed at ${token6.address} (name=${name6}, symbol=${symbol6}, decimals=${decimals6})`);
+};
+
+export default func;
+func.tags = ["TestERC20"];

packages/hardhat/deploy/02_deploy_test_erc20.ts

@@ -0,0 +1,40 @@
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+import { DeployFunction } from "hardhat-deploy/types";
+import schemaRegistryArtifact from "@ethereum-attestation-service/eas-contracts/artifacts/contracts/SchemaRegistry.sol/SchemaRegistry.json";
+import easArtifact from "@ethereum-attestation-service/eas-contracts/artifacts/contracts/EAS.sol/EAS.json";
+
+// Deploy EAS core contracts locally (SchemaRegistry and EAS) using artifacts from the npm package
+const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { deployer } = await hre.getNamedAccounts();
+  const { deploy } = hre.deployments;
+
+  // Load artifacts from installed package (json imports)
+  if (hre.network.name != "localhost") {
+    return;
+  }
+
+  const schemaRegistry = await deploy("SchemaRegistry", {
+    from: deployer,
+    log: true,
+    autoMine: true,
+    args: [],
+    contract: {
+      abi: schemaRegistryArtifact.abi,
+      bytecode: schemaRegistryArtifact.bytecode,
+    },
+  });
+
+  await deploy("EAS", {
+    from: deployer,
+    log: true,
+    autoMine: true,
+    args: [schemaRegistry.address],
+    contract: {
+      abi: easArtifact.abi,
+      bytecode: easArtifact.bytecode,
+    },
+  });
+};
+
+export default func;
+func.tags = ["EASLocal", "ReviewSchema"];

packages/hardhat/deploy/04_deploy_eas_local.ts

@@ -0,0 +1,113 @@
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+import { DeployFunction } from "hardhat-deploy/types";
+import * as fs from "fs";
+import * as path from "path";
+import schemaRegArtifact from "@ethereum-attestation-service/eas-contracts/artifacts/contracts/SchemaRegistry.sol/SchemaRegistry.json";
+
+// Registers a local review schema on the deployed SchemaRegistry and logs the schema UID
+// Schema: uint8 rating,string comment
+const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
+  const { deployer } = await hre.getNamedAccounts();
+
+  const chainId = await hre.getChainId();
+  const KNOWN_SCHEMA_REGISTRY: Record<string, string> = {
+    // Mainnets
+    "1": "0xA7b39296258348C78294F95B872b282326A97BDF", // Ethereum mainnet
+    "10": "0x4200000000000000000000000000000000000020", // Optimism
+    "8453": "0x4200000000000000000000000000000000000020", // Base
+    "42161": "0xA310da9c5B885E7fb3fbA9D66E9Ba6Df512b78eB", // Arbitrum One
+    // Testnets
+    "11155111": "0x0a7E2Ff54e76B8E6659aedc9103FB21c038050D0", // Sepolia
+    "11155420": "0x4200000000000000000000000000000000000020", // Optimism Sepolia
+    "84532": "0x4200000000000000000000000000000000000020", // Base Sepolia
+    "420": "0x4200000000000000000000000000000000000020", // Optimism Goerli
+  };
+
+  const KNOWN_EAS: Record<string, string> = {
+    // Mainnets
+    "1": "0xA1207F3BBa224E2c9c3c6D5aF63D0eb1582Ce587", // Ethereum mainnet
+    "10": "0x4200000000000000000000000000000000000021", // Optimism
+    "8453": "0x4200000000000000000000000000000000000021", // Base
+    "42161": "0xbD75f629A22Dc1ceD33dDA0b68c546A1c035c458", // Arbitrum One
+    // Testnets
+    "11155111": "0xC2679fBD37d54388Ce493F1DB75320D236e1815e", // Sepolia
+    "11155420": "0x4200000000000000000000000000000000000021", // Optimism Sepolia
+    "84532": "0x4200000000000000000000000000000000000021", // Base Sepolia
+    "420": "0x4200000000000000000000000000000000000021", // Optimism Goerli
+  };
+
+  let schemaRegistryAddress: string;
+  if (hre.network.name === "localhost") {
+    schemaRegistryAddress = (await hre.deployments.get("SchemaRegistry")).address;
+  } else if (KNOWN_SCHEMA_REGISTRY[chainId]) {
+    schemaRegistryAddress = KNOWN_SCHEMA_REGISTRY[chainId];
+  } else {
+    throw new Error(`SchemaRegistry address unknown for chainId ${chainId}. Add it to KNOWN_SCHEMA_REGISTRY.`);
+  }
+
+  const signer = await hre.ethers.getSigner(deployer);
+  const schemaRegistry = new hre.ethers.Contract(schemaRegistryAddress, schemaRegArtifact.abi, signer);
+
+  // New schema links reviews to a specific sale via listingId and counterparty
+  // Recipient of the attestation is the reviewee address
+  const schema = "uint256 listingId,uint8 rating,string commentIPFSHash";
+  const revocable = true;
+  const resolver = hre.ethers.ZeroAddress;
+
+  let uid: string | undefined;
+  try {
+    const tx = await (schemaRegistry as any).register(schema, resolver, revocable);
+    const receipt = await tx.wait();
+    console.log("🧾 Review schema registered. TX:", receipt?.hash);
+    // Parse Registered event to get UID
+    const iface = new hre.ethers.Interface(schemaRegArtifact.abi);
+    for (const log of receipt?.logs || []) {
+      try {
+        const parsed = iface.parseLog(log);
+        if (parsed?.name === "Registered") {
+          uid = parsed.args?.uid as string;
+          break;
+        }
+      } catch {}
+    }
+  } catch {
+    console.log("ℹ️  Schema likely already registered; computing UID.");
+  }
+  if (!uid) {
+    // Compute with encodePacked to mirror contract logic
+    const packed = hre.ethers.solidityPacked(["string", "address", "bool"], [schema, resolver, revocable]);
+    uid = hre.ethers.keccak256(packed);
+  }
+  console.log("🆔 Review schema UID:", uid);
+
+  // Determine EAS address for output helper file
+  let easAddressOut = "";
+  if (hre.network.name === "localhost") {
+    easAddressOut = (await hre.deployments.get("EAS")).address;
+  } else if (KNOWN_EAS[chainId]) {
+    easAddressOut = KNOWN_EAS[chainId];
+  }
+
+  // Always write a generic helper json for frontend/backends regardless of network
+  const nextjsOutPath = path.resolve(hre.config.paths.root, "../nextjs/contracts/easConfig.json");
+  const nextjsOut = {
+    chainId: await hre.getChainId(),
+    schemaRegistry: schemaRegistryAddress,
+    eas: easAddressOut,
+    reviewSchemaUid: uid,
+  };
+  fs.writeFileSync(nextjsOutPath, JSON.stringify(nextjsOut, null, 2), { encoding: "utf-8" });
+
+  const indexerOutPath = path.resolve(hre.config.paths.root, "../indexer/src/easConfig.json");
+  const indexerOut = {
+    chainId: await hre.getChainId(),
+    schemaRegistry: schemaRegistryAddress,
+    eas: easAddressOut,
+    reviewSchemaUid: uid,
+  };
+  fs.writeFileSync(indexerOutPath, JSON.stringify(indexerOut, null, 2), { encoding: "utf-8" });
+  console.log("📝 Wrote EAS generic config:", nextjsOutPath, indexerOutPath);
+};
+
+export default func;
+func.tags = ["EASLocal", "ReviewSchema"];

packages/hardhat/deploy/05_register_review_schema.ts

@@ -22,6 +22,7 @@
     "verify": "hardhat etherscan-verify"
   },
   "dependencies": {
+    "@ethereum-attestation-service/eas-contracts": "^1.8.0",
     "@inquirer/password": "^4.0.2",
     "@openzeppelin/contracts": "~5.0.2",
     "@typechain/ethers-v6": "~0.5.1",