@croptop/core-v6 0.0.7 → 0.0.10

package/test/Fork.t.sol

@@ -1,58 +1,107 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.17;
 
-import "@bananapus/721-hook-v6/script/helpers/Hook721DeploymentLib.sol";
-import "@bananapus/core-v6/script/helpers/CoreDeploymentLib.sol";
-import "@bananapus/suckers-v6/script/helpers/SuckerDeploymentLib.sol";
+import "forge-std/Test.sol";
 
-import "./../src/CTDeployer.sol";
+// JB core — deploy fresh within fork.
+import {JBPermissions} from "@bananapus/core-v6/src/JBPermissions.sol";
+import {JBProjects} from "@bananapus/core-v6/src/JBProjects.sol";
+import {JBDirectory} from "@bananapus/core-v6/src/JBDirectory.sol";
+import {JBRulesets} from "@bananapus/core-v6/src/JBRulesets.sol";
+import {JBTokens} from "@bananapus/core-v6/src/JBTokens.sol";
+import {JBERC20} from "@bananapus/core-v6/src/JBERC20.sol";
+import {JBSplits} from "@bananapus/core-v6/src/JBSplits.sol";
+import {JBPrices} from "@bananapus/core-v6/src/JBPrices.sol";
+import {JBController} from "@bananapus/core-v6/src/JBController.sol";
+import {JBFundAccessLimits} from "@bananapus/core-v6/src/JBFundAccessLimits.sol";
 import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
+
+// 721 hook — deploy fresh within fork.
+import {JB721TiersHookStore} from "@bananapus/721-hook-v6/src/JB721TiersHookStore.sol";
+import {JB721TiersHook} from "@bananapus/721-hook-v6/src/JB721TiersHook.sol";
+import {JB721TiersHookDeployer} from "@bananapus/721-hook-v6/src/JB721TiersHookDeployer.sol";
+import {JBAddressRegistry} from "@bananapus/address-registry-v6/src/JBAddressRegistry.sol";
+
+// Suckers — deploy fresh within fork.
+import {JBSuckerRegistry} from "@bananapus/suckers-v6/src/JBSuckerRegistry.sol";
+import {JBOptimismSuckerDeployer} from "@bananapus/suckers-v6/src/deployers/JBOptimismSuckerDeployer.sol";
+import {JBOptimismSucker} from "@bananapus/suckers-v6/src/JBOptimismSucker.sol";
+import {JBAddToBalanceMode} from "@bananapus/suckers-v6/src/enums/JBAddToBalanceMode.sol";
+import {IOPMessenger} from "@bananapus/suckers-v6/src/interfaces/IOPMessenger.sol";
+import {IOPStandardBridge} from "@bananapus/suckers-v6/src/interfaces/IOPStandardBridge.sol";
 import {JBSuckerDeployerConfig} from "@bananapus/suckers-v6/src/structs/JBSuckerDeployerConfig.sol";
 import {JBTokenMapping} from "@bananapus/suckers-v6/src/structs/JBTokenMapping.sol";
-import {CTProjectOwner} from "./../src/CTProjectOwner.sol";
-import {CTPublisher} from "./../src/CTPublisher.sol";
+import {IJBSuckerDeployer} from "@bananapus/suckers-v6/src/interfaces/IJBSuckerDeployer.sol";
 
-import "forge-std/Test.sol";
+// Croptop — wildcard import pulls in all structs (CTProjectConfig, CTDeployerAllowedPost, etc.).
+import "./../src/CTDeployer.sol";
+import {CTPublisher} from "./../src/CTPublisher.sol";
 
+/// @notice Fork tests for Croptop. Deploys all JB infrastructure fresh within a mainnet fork.
 contract ForkTest is Test {
-    /// @notice tracks the deployment of the core contracts for the chain we are deploying to.
-    CoreDeployment core;
-    /// @notice tracks the deployment of the 721 hook contracts for the chain we are deploying to.
-    Hook721Deployment hook;
-    /// @notice tracks the deployment of the sucker contracts for the chain we are deploying to.
-    SuckerDeployment suckers;
+    // ───────────────────────── Mainnet addresses
+    // ──────────────────────────
+
+    // OP L1 bridge contracts (exist on Ethereum mainnet).
+    IOPMessenger constant OP_L1_MESSENGER = IOPMessenger(0x25ace71c97B33Cc4729CF772ae268934F7ab5fA1);
+    IOPStandardBridge constant OP_L1_BRIDGE = IOPStandardBridge(0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1);
+
+    // ───────────────────────── JB core (deployed fresh)
+    // ───────────────────
+
+    address multisig = address(0xBEEF);
+    address trustedForwarder = address(0);
+
+    JBPermissions jbPermissions;
+    JBProjects jbProjects;
+    JBDirectory jbDirectory;
+    JBRulesets jbRulesets;
+    JBTokens jbTokens;
+    JBSplits jbSplits;
+    JBPrices jbPrices;
+    JBFundAccessLimits jbFundAccessLimits;
+    JBController jbController;
+
+    // ───────────────────────── 721 hook (deployed fresh)
+    // ──────────────────
+
+    JB721TiersHookDeployer hookDeployer;
+
+    // ───────────────────────── Suckers (deployed fresh)
+    // ───────────────────
+
+    JBSuckerRegistry suckerRegistry;
+    JBOptimismSuckerDeployer opSuckerDeployer;
+
+    // ───────────────────────── Croptop
+    // ────────────────────────────────────
 
     CTPublisher publisher;
     CTDeployer deployer;
 
-    address TRUSTED_FORWARDER;
-
     function setUp() public {
+        // Skip fork tests when the RPC URL is not available (e.g. in CI).
+        string memory rpcUrl = vm.envOr("RPC_ETHEREUM_MAINNET", string(""));
+        if (bytes(rpcUrl).length == 0) {
+            vm.skip(true);
+            return;
+        }
+
         // Fork ETH mainnet.
-        vm.createSelectFork(vm.rpcUrl("ethereum"), 22_432_742);
+        vm.createSelectFork(rpcUrl);
 
-        // Get the deployment addresses for the nana CORE for this chain.
-        // We want to do this outside of the `sphinx` modifier.
-        core = CoreDeploymentLib.getDeployment(
-            vm.envOr("NANA_CORE_DEPLOYMENT_PATH", string("node_modules/@bananapus/core-v6/deployments/"))
-        );
-        // Get the deployment addresses for the 721 hook contracts for this chain.
-        hook = Hook721DeploymentLib.getDeployment(
-            vm.envOr("NANA_721_DEPLOYMENT_PATH", string("node_modules/@bananapus/721-hook-v6/deployments/"))
-        );
-        // Get the deployment addresses for the suckers contracts for this chain.
-        suckers = SuckerDeploymentLib.getDeployment(
-            vm.envOr("NANA_SUCKERS_DEPLOYMENT_PATH", string("node_modules/@bananapus/suckers-v6/deployments/"))
-        );
+        // Deploy all JB core contracts fresh within the fork.
+        _deployJBCore();
+
+        // Deploy the 721 hook infrastructure.
+        _deploy721Hook();
 
-        // We use the same trusted forwarder as the core deployment.
-        TRUSTED_FORWARDER = core.controller.trustedForwarder();
+        // Deploy the sucker infrastructure.
+        _deploySuckers();
 
         // Deploy the croptop contracts.
-        publisher = new CTPublisher(core.directory, core.permissions, 1, TRUSTED_FORWARDER);
-        deployer = new CTDeployer(
-            core.permissions, core.projects, hook.hook_deployer, publisher, suckers.registry, TRUSTED_FORWARDER
-        );
+        publisher = new CTPublisher(jbDirectory, jbPermissions, 1, trustedForwarder);
+        deployer = new CTDeployer(jbPermissions, jbProjects, hookDeployer, publisher, suckerRegistry, trustedForwarder);
     }
 
     function testDeployProject(address owner) public {
@@ -72,7 +121,7 @@ contract ForkTest is Test {
         CTSuckerDeploymentConfig memory suckerConfig =
             CTSuckerDeploymentConfig({deployerConfigurations: new JBSuckerDeployerConfig[](0), salt: bytes32(0)});
 
-        deployer.deployProjectFor(owner, config, suckerConfig, core.controller);
+        deployer.deployProjectFor(owner, config, suckerConfig, jbController);
     }
 
     function testDeployProjectWithSuckers(address owner, bytes32 salt, bytes32 suckerSalt) public {
@@ -100,15 +149,79 @@ contract ForkTest is Test {
         });
 
         JBSuckerDeployerConfig[] memory deployerConfigurations = new JBSuckerDeployerConfig[](1);
-        deployerConfigurations[0] = JBSuckerDeployerConfig({deployer: suckers.optimismDeployer, mappings: tokens});
+        deployerConfigurations[0] =
+            JBSuckerDeployerConfig({deployer: IJBSuckerDeployer(address(opSuckerDeployer)), mappings: tokens});
 
         CTSuckerDeploymentConfig memory suckerConfig =
             CTSuckerDeploymentConfig({deployerConfigurations: deployerConfigurations, salt: suckerSalt});
 
         // Deploy the project.
-        (uint256 projectId,) = deployer.deployProjectFor(owner, config, suckerConfig, core.controller);
+        (uint256 projectId,) = deployer.deployProjectFor(owner, config, suckerConfig, jbController);
 
         // Check that the projectId has a sucker.
-        assertEq(suckers.registry.suckersOf(projectId).length, deployerConfigurations.length);
+        assertEq(suckerRegistry.suckersOf(projectId).length, deployerConfigurations.length);
+    }
+
+    // ───────────────────────── Internal deployment helpers
+    // ────────────────
+
+    function _deployJBCore() internal {
+        jbPermissions = new JBPermissions(trustedForwarder);
+        jbProjects = new JBProjects(multisig, address(0), trustedForwarder);
+        jbDirectory = new JBDirectory(jbPermissions, jbProjects, multisig);
+        JBERC20 jbErc20 = new JBERC20();
+        jbTokens = new JBTokens(jbDirectory, jbErc20);
+        jbRulesets = new JBRulesets(jbDirectory);
+        jbPrices = new JBPrices(jbDirectory, jbPermissions, jbProjects, multisig, trustedForwarder);
+        jbSplits = new JBSplits(jbDirectory);
+        jbFundAccessLimits = new JBFundAccessLimits(jbDirectory);
+
+        jbController = new JBController(
+            jbDirectory,
+            jbFundAccessLimits,
+            jbPermissions,
+            jbPrices,
+            jbProjects,
+            jbRulesets,
+            jbSplits,
+            jbTokens,
+            address(0), // omnichainRulesetOperator
+            trustedForwarder
+        );
+
+        vm.prank(multisig);
+        jbDirectory.setIsAllowedToSetFirstController(address(jbController), true);
+    }
+
+    function _deploy721Hook() internal {
+        JB721TiersHookStore store = new JB721TiersHookStore();
+        JBAddressRegistry addressRegistry = new JBAddressRegistry();
+
+        JB721TiersHook hookImpl =
+            new JB721TiersHook(jbDirectory, jbPermissions, jbRulesets, store, jbSplits, trustedForwarder);
+
+        hookDeployer = new JB721TiersHookDeployer(hookImpl, store, addressRegistry, trustedForwarder);
+    }
+
+    function _deploySuckers() internal {
+        suckerRegistry = new JBSuckerRegistry(jbDirectory, jbPermissions, multisig, trustedForwarder);
+
+        // Deploy the OP sucker deployer with `multisig` as the configurator.
+        opSuckerDeployer =
+            new JBOptimismSuckerDeployer(jbDirectory, jbPermissions, jbTokens, multisig, trustedForwarder);
+
+        // Configure the OP sucker deployer with L1 bridge addresses.
+        vm.startPrank(multisig);
+        opSuckerDeployer.setChainSpecificConstants(OP_L1_MESSENGER, OP_L1_BRIDGE);
+
+        // Deploy and configure the singleton.
+        JBOptimismSucker singleton = new JBOptimismSucker(
+            opSuckerDeployer, jbDirectory, jbPermissions, jbTokens, JBAddToBalanceMode.ON_CLAIM, trustedForwarder
+        );
+        opSuckerDeployer.configureSingleton(singleton);
+
+        // Allow the deployer in the registry.
+        suckerRegistry.allowSuckerDeployer(address(opSuckerDeployer));
+        vm.stopPrank();
     }
 }

package/test/regression/H19_FeeEvasion.t.sol

@@ -7,6 +7,7 @@ import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.s
 import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
 import {IJBTerminal} from "@bananapus/core-v6/src/interfaces/IJBTerminal.sol";
 import {IJBOwnable} from "@bananapus/ownable-v6/src/interfaces/IJBOwnable.sol";
+import {IJB721Hook} from "@bananapus/721-hook-v6/src/interfaces/IJB721Hook.sol";
 import {IJB721TiersHook} from "@bananapus/721-hook-v6/src/interfaces/IJB721TiersHook.sol";
 import {IJB721TiersHookStore} from "@bananapus/721-hook-v6/src/interfaces/IJB721TiersHookStore.sol";
 import {JB721Tier} from "@bananapus/721-hook-v6/src/structs/JB721Tier.sol";
@@ -19,7 +20,7 @@ import {CTAllowedPost} from "../../src/structs/CTAllowedPost.sol";
 import {CTPost} from "../../src/structs/CTPost.sol";
 
 /// @title H19_FeeEvasion
-/// @notice Regression test for H-19: fee evasion for existing tier mints.
+/// @notice Fee evasion for existing tier mints.
 ///         Before the fix, a user could set post.price = 0 for an existing tier
 ///         to evade the 5% Croptop fee entirely. The fix reads the actual tier price
 ///         from the store for existing tiers.
@@ -48,7 +49,7 @@ contract H19_FeeEvasion is Test {
         // Mock hook.owner().
         vm.mockCall(hookAddr, abi.encodeWithSelector(IJBOwnable.owner.selector), abi.encode(hookOwner));
         // Mock hook.PROJECT_ID().
-        vm.mockCall(hookAddr, abi.encodeWithSelector(IJB721TiersHook.PROJECT_ID.selector), abi.encode(hookProjectId));
+        vm.mockCall(hookAddr, abi.encodeWithSelector(IJB721Hook.PROJECT_ID.selector), abi.encode(hookProjectId));
         // Mock hook.STORE().
         vm.mockCall(hookAddr, abi.encodeWithSelector(IJB721TiersHook.STORE.selector), abi.encode(hookStoreAddr));
 

package/test/regression/L52_StaleTierIdMapping.t.sol

@@ -6,6 +6,7 @@ import "forge-std/Test.sol";
 import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
 import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
 import {IJBOwnable} from "@bananapus/ownable-v6/src/interfaces/IJBOwnable.sol";
+import {IJB721Hook} from "@bananapus/721-hook-v6/src/interfaces/IJB721Hook.sol";
 import {IJB721TiersHook} from "@bananapus/721-hook-v6/src/interfaces/IJB721TiersHook.sol";
 import {IJB721TiersHookStore} from "@bananapus/721-hook-v6/src/interfaces/IJB721TiersHookStore.sol";
 import {JB721Tier} from "@bananapus/721-hook-v6/src/structs/JB721Tier.sol";
@@ -18,7 +19,7 @@ import {CTAllowedPost} from "../../src/structs/CTAllowedPost.sol";
 import {CTPost} from "../../src/structs/CTPost.sol";
 
 /// @title L52_StaleTierIdMapping
-/// @notice Regression test for L-52: stale tierIdForEncodedIPFSUriOf mapping after external tier removal.
+/// @notice Stale tierIdForEncodedIPFSUriOf mapping after external tier removal.
 ///         When a tier is removed externally via adjustTiers(), the publisher's mapping still pointed
 ///         to the removed tier ID, blocking re-creation. The fix clears the stale mapping and allows
 ///         the post to fall through to new-tier creation.
@@ -45,7 +46,7 @@ contract L52_StaleTierIdMapping is Test {
         // Mock hook.owner().
         vm.mockCall(hookAddr, abi.encodeWithSelector(IJBOwnable.owner.selector), abi.encode(hookOwner));
         // Mock hook.PROJECT_ID().
-        vm.mockCall(hookAddr, abi.encodeWithSelector(IJB721TiersHook.PROJECT_ID.selector), abi.encode(hookProjectId));
+        vm.mockCall(hookAddr, abi.encodeWithSelector(IJB721Hook.PROJECT_ID.selector), abi.encode(hookProjectId));
         // Mock hook.STORE().
         vm.mockCall(hookAddr, abi.encodeWithSelector(IJB721TiersHook.STORE.selector), abi.encode(hookStoreAddr));
 
@@ -158,7 +159,7 @@ contract L52_StaleTierIdMapping is Test {
             abi.encode(false)
         );
 
-        // Mock tierOf for tier 1 so the H-19 price lookup succeeds.
+        // Mock tierOf for tier 1 so the existing-tier price lookup succeeds.
         JB721Tier memory tier = JB721Tier({
             id: 1,
             price: 0.1 ether,

package/test/regression/M6_DuplicateUriFeeEvasion.t.sol

@@ -0,0 +1,312 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import "forge-std/Test.sol";
+
+import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
+import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
+import {IJBTerminal} from "@bananapus/core-v6/src/interfaces/IJBTerminal.sol";
+import {IJBOwnable} from "@bananapus/ownable-v6/src/interfaces/IJBOwnable.sol";
+import {IJB721Hook} from "@bananapus/721-hook-v6/src/interfaces/IJB721Hook.sol";
+import {IJB721TiersHook} from "@bananapus/721-hook-v6/src/interfaces/IJB721TiersHook.sol";
+import {IJB721TiersHookStore} from "@bananapus/721-hook-v6/src/interfaces/IJB721TiersHookStore.sol";
+import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
+import {JBSplit} from "@bananapus/core-v6/src/structs/JBSplit.sol";
+import {JBPermissionIds} from "@bananapus/permission-ids-v6/src/JBPermissionIds.sol";
+
+import {CTPublisher} from "../../src/CTPublisher.sol";
+import {CTAllowedPost} from "../../src/structs/CTAllowedPost.sol";
+import {CTPost} from "../../src/structs/CTPost.sol";
+
+/// @title M6_DuplicateUriFeeEvasion
+/// @notice Duplicate encodedIPFSUri in a single mintFrom batch
+///         enables fee evasion. Before the fix, a second post with the same URI would read
+///         a stale tierIdForEncodedIPFSUriOf mapping (written by _setupPosts for the first
+///         post but not yet committed to the store), causing store.tierOf() to return price=0,
+///         so the fee was computed on 1x the price instead of 2x.
+///         The fix reverts with CTPublisher_DuplicatePost when duplicate URIs appear in a batch.
+contract M6_DuplicateUriFeeEvasion is Test {
+    CTPublisher publisher;
+
+    IJBPermissions permissions = IJBPermissions(makeAddr("permissions"));
+    IJBDirectory directory = IJBDirectory(makeAddr("directory"));
+
+    address hookOwner = makeAddr("hookOwner");
+    address hookAddr = makeAddr("hook");
+    address hookStoreAddr = makeAddr("hookStore");
+    address terminalAddr = makeAddr("terminal");
+    address feeTerminalAddr = makeAddr("feeTerminal");
+    address poster = makeAddr("poster");
+
+    uint256 feeProjectId = 1;
+    uint256 hookProjectId = 42;
+
+    function setUp() public {
+        publisher = new CTPublisher(directory, permissions, feeProjectId, address(0));
+
+        // Mock hook.owner().
+        vm.mockCall(hookAddr, abi.encodeWithSelector(IJBOwnable.owner.selector), abi.encode(hookOwner));
+        // Mock hook.PROJECT_ID().
+        vm.mockCall(hookAddr, abi.encodeWithSelector(IJB721Hook.PROJECT_ID.selector), abi.encode(hookProjectId));
+        // Mock hook.STORE().
+        vm.mockCall(hookAddr, abi.encodeWithSelector(IJB721TiersHook.STORE.selector), abi.encode(hookStoreAddr));
+
+        // Mock permissions to return true by default.
+        vm.mockCall(
+            address(permissions), abi.encodeWithSelector(IJBPermissions.hasPermission.selector), abi.encode(true)
+        );
+
+        // Fund poster.
+        vm.deal(poster, 100 ether);
+    }
+
+    function _configureCategory() internal {
+        CTAllowedPost[] memory posts = new CTAllowedPost[](1);
+        posts[0] = CTAllowedPost({
+            hook: hookAddr,
+            category: 5,
+            minimumPrice: 0.01 ether,
+            minimumTotalSupply: 1,
+            maximumTotalSupply: 1000,
+            maximumSplitPercent: 0,
+            allowedAddresses: new address[](0)
+        });
+
+        vm.prank(hookOwner);
+        publisher.configurePostingCriteriaFor(posts);
+    }
+
+    function _setupMintMocks() internal {
+        vm.mockCall(
+            hookStoreAddr, abi.encodeWithSelector(IJB721TiersHookStore.maxTierIdOf.selector), abi.encode(uint256(0))
+        );
+        vm.mockCall(hookAddr, abi.encodeWithSelector(IJB721TiersHook.adjustTiers.selector), abi.encode());
+        vm.mockCall(hookAddr, abi.encodeWithSelector(bytes4(keccak256("METADATA_ID_TARGET()"))), abi.encode(address(0)));
+        vm.mockCall(
+            address(directory),
+            abi.encodeWithSelector(IJBDirectory.primaryTerminalOf.selector, hookProjectId),
+            abi.encode(terminalAddr)
+        );
+        vm.mockCall(
+            address(directory),
+            abi.encodeWithSelector(IJBDirectory.primaryTerminalOf.selector, feeProjectId),
+            abi.encode(feeTerminalAddr)
+        );
+        vm.mockCall(terminalAddr, "", abi.encode(uint256(0)));
+        vm.mockCall(feeTerminalAddr, "", abi.encode(uint256(0)));
+    }
+
+    // =========================================================================
+    // Test 1: Duplicate URI in batch reverts with CTPublisher_DuplicatePost
+    // =========================================================================
+    /// @notice Sending two posts with the same encodedIPFSUri in a single mintFrom batch
+    ///         must revert with CTPublisher_DuplicatePost.
+    function test_duplicateUriInBatch_reverts() public {
+        _configureCategory();
+        _setupMintMocks();
+
+        bytes32 duplicateUri = keccak256("same-content");
+
+        CTPost[] memory posts = new CTPost[](2);
+        posts[0] = CTPost({
+            encodedIPFSUri: duplicateUri,
+            totalSupply: 10,
+            price: 0.1 ether,
+            category: 5,
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+        posts[1] = CTPost({
+            encodedIPFSUri: duplicateUri, // Same URI as posts[0].
+            totalSupply: 10,
+            price: 0.1 ether,
+            category: 5,
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+
+        vm.prank(poster);
+        vm.expectRevert(abi.encodeWithSelector(CTPublisher.CTPublisher_DuplicatePost.selector, duplicateUri));
+        publisher.mintFrom{value: 1 ether}(IJB721TiersHook(hookAddr), posts, poster, poster, "", "");
+    }
+
+    // =========================================================================
+    // Test 2: Three posts, first and third duplicate — reverts
+    // =========================================================================
+    /// @notice Duplicates do not need to be adjacent to be caught.
+    function test_duplicateUriNonAdjacent_reverts() public {
+        _configureCategory();
+        _setupMintMocks();
+
+        bytes32 duplicateUri = keccak256("content-A");
+        bytes32 uniqueUri = keccak256("content-B");
+
+        CTPost[] memory posts = new CTPost[](3);
+        posts[0] = CTPost({
+            encodedIPFSUri: duplicateUri,
+            totalSupply: 10,
+            price: 0.1 ether,
+            category: 5,
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+        posts[1] = CTPost({
+            encodedIPFSUri: uniqueUri, // Different URI.
+            totalSupply: 10,
+            price: 0.1 ether,
+            category: 5,
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+        posts[2] = CTPost({
+            encodedIPFSUri: duplicateUri, // Same as posts[0].
+            totalSupply: 10,
+            price: 0.1 ether,
+            category: 5,
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+
+        vm.prank(poster);
+        vm.expectRevert(abi.encodeWithSelector(CTPublisher.CTPublisher_DuplicatePost.selector, duplicateUri));
+        publisher.mintFrom{value: 1 ether}(IJB721TiersHook(hookAddr), posts, poster, poster, "", "");
+    }
+
+    // =========================================================================
+    // Test 3: Two posts with different URIs succeed
+    // =========================================================================
+    /// @notice Two posts with distinct encodedIPFSUri values should not revert
+    ///         (at least not with the duplicate error).
+    function test_distinctUrisInBatch_succeeds() public {
+        _configureCategory();
+        _setupMintMocks();
+
+        CTPost[] memory posts = new CTPost[](2);
+        posts[0] = CTPost({
+            encodedIPFSUri: keccak256("content-1"),
+            totalSupply: 10,
+            price: 0.1 ether,
+            category: 5,
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+        posts[1] = CTPost({
+            encodedIPFSUri: keccak256("content-2"),
+            totalSupply: 10,
+            price: 0.1 ether,
+            category: 5,
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+
+        // Should not revert with CTPublisher_DuplicatePost.
+        // May succeed fully or revert downstream in mocks, but never with the duplicate error.
+        vm.prank(poster);
+        try publisher.mintFrom{value: 1 ether}(IJB721TiersHook(hookAddr), posts, poster, poster, "", "") {}
+        catch (bytes memory reason) {
+            // Ensure it did NOT revert with CTPublisher_DuplicatePost.
+            assertTrue(
+                keccak256(reason)
+                    != keccak256(
+                        abi.encodeWithSelector(CTPublisher.CTPublisher_DuplicatePost.selector, keccak256("content-1"))
+                    ),
+                "should not revert with duplicate post error for content-1"
+            );
+            assertTrue(
+                keccak256(reason)
+                    != keccak256(
+                        abi.encodeWithSelector(CTPublisher.CTPublisher_DuplicatePost.selector, keccak256("content-2"))
+                    ),
+                "should not revert with duplicate post error for content-2"
+            );
+        }
+    }
+
+    // =========================================================================
+    // Test 4: Single post (no duplicates possible) succeeds
+    // =========================================================================
+    /// @notice A single post should never trigger the duplicate check.
+    function test_singlePost_noDuplicateError() public {
+        _configureCategory();
+        _setupMintMocks();
+
+        CTPost[] memory posts = new CTPost[](1);
+        posts[0] = CTPost({
+            encodedIPFSUri: keccak256("sole-content"),
+            totalSupply: 10,
+            price: 0.1 ether,
+            category: 5,
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+
+        vm.prank(poster);
+        try publisher.mintFrom{value: 1 ether}(IJB721TiersHook(hookAddr), posts, poster, poster, "", "") {}
+        catch (bytes memory reason) {
+            assertTrue(
+                keccak256(reason)
+                    != keccak256(
+                        abi.encodeWithSelector(
+                            CTPublisher.CTPublisher_DuplicatePost.selector, keccak256("sole-content")
+                        )
+                    ),
+                "should not revert with duplicate post error"
+            );
+        }
+    }
+
+    // =========================================================================
+    // Test 5: Fuzz — batch of 2 posts, duplicate iff URIs match
+    // =========================================================================
+    /// @notice Fuzz test: when two URIs are equal the call must revert with
+    ///         CTPublisher_DuplicatePost; when they differ it must not.
+    function testFuzz_duplicateDetection(bytes32 uri1, bytes32 uri2) public {
+        vm.assume(uri1 != bytes32(""));
+        vm.assume(uri2 != bytes32(""));
+
+        _configureCategory();
+        _setupMintMocks();
+
+        CTPost[] memory posts = new CTPost[](2);
+        posts[0] = CTPost({
+            encodedIPFSUri: uri1,
+            totalSupply: 10,
+            price: 0.1 ether,
+            category: 5,
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+        posts[1] = CTPost({
+            encodedIPFSUri: uri2,
+            totalSupply: 10,
+            price: 0.1 ether,
+            category: 5,
+            splitPercent: 0,
+            splits: new JBSplit[](0)
+        });
+
+        if (uri1 == uri2) {
+            // Must revert with duplicate error.
+            vm.prank(poster);
+            vm.expectRevert(abi.encodeWithSelector(CTPublisher.CTPublisher_DuplicatePost.selector, uri1));
+            publisher.mintFrom{value: 1 ether}(IJB721TiersHook(hookAddr), posts, poster, poster, "", "");
+        } else {
+            // Must NOT revert with duplicate error. May still revert for other reasons
+            // (e.g. mocked terminal behavior), but not CTPublisher_DuplicatePost.
+            vm.prank(poster);
+            try publisher.mintFrom{value: 1 ether}(IJB721TiersHook(hookAddr), posts, poster, poster, "", "") {}
+            catch (bytes memory reason) {
+                assertTrue(
+                    keccak256(reason)
+                        != keccak256(abi.encodeWithSelector(CTPublisher.CTPublisher_DuplicatePost.selector, uri1)),
+                    "should not revert with duplicate post error for uri1"
+                );
+                assertTrue(
+                    keccak256(reason)
+                        != keccak256(abi.encodeWithSelector(CTPublisher.CTPublisher_DuplicatePost.selector, uri2)),
+                    "should not revert with duplicate post error for uri2"
+                );
+            }
+        }
+    }
+}