@bananapus/address-registry-v6 0.0.14 → 0.0.16

package/AUDIT_INSTRUCTIONS.md

@@ -6,7 +6,7 @@ You are auditing a permissionless address registry for Juicebox V6. The contract
 
 | Setting | Value |
 |---------|-------|
-| Solidity version | ^0.8.26 |
+| Solidity version | 0.8.28 |
 | EVM target | cancun |
 | Optimizer | enabled, 200 runs |
 | via-IR | not enabled |

package/CHANGE_LOG.md

@@ -6,18 +6,32 @@ This document describes all changes between `nana-address-registry` (v5) and `na
 
 - **Nonce range extended from `uint32` to `uint64`**: Fixes silent address miscalculation for large nonces — previously truncated without error, now correctly RLP-encodes up to `uint64` and reverts above.
 - **New `NonceTooLarge` error**: Explicit revert replaces silent truncation for nonces exceeding `uint64.max`.
+- **New `ZeroDeployer` error**: Both `registerAddress` overloads revert if `deployer == address(0)`.
 - **No ABI-breaking changes**: Interface and function signatures are identical — only the internal nonce encoding logic changed.
 
+## ABI Status
+
+This repo is intentionally close to ABI-stable across v5 → v6:
+- external function selectors are unchanged;
+- event signature is unchanged;
+- the ABI-surface additions that most off-chain tooling will notice are the new custom errors `JBAddressRegistry_NonceTooLarge(uint256)` and `JBAddressRegistry_ZeroDeployer()`.
+
+For most integrations, this is an import/address upgrade rather than a contract-interface rewrite.
+
 ---
 
 ## 1. Breaking Changes
 
-- **Solidity version bump**: `0.8.23` → `^0.8.26`. Contracts compiled against v5 ABIs will still be compatible (no ABI-level breaking changes), but the compiler version requirement has changed.
+- **Solidity version bump**: `0.8.23` → `0.8.28`. Contracts compiled against v5 ABIs will still be compatible (no ABI-level breaking changes), but the compiler version requirement has changed.
 - **Nonce range extended from `uint32` to `uint64`**: In v5, the `_addressFrom` function silently produced incorrect addresses for nonces at or above `2^32`. In v6, nonces up to `uint64.max` are correctly RLP-encoded, and nonces above `uint64.max` revert with `JBAddressRegistry_NonceTooLarge`. Any off-chain tooling that assumed the `uint32` ceiling must be updated.
 
 ## 2. New Features
 
 - **Extended nonce support (uint40 through uint64)**: Four new RLP encoding branches handle nonces in the ranges `uint40`, `uint48`, `uint56`, and `uint64`, covering any realistic Ethereum account nonce.
+- **No calling-pattern changes**: Both registration flows remain the same:
+  - `registerAddress(address deployer, uint256 nonce)` for `create`
+  - `registerAddress(address deployer, bytes32 salt, bytes memory bytecode)` for `create2`
+  Off-chain callers do not need new arguments or a new event subscription pattern.
 
 ## 3. Event Changes
 
@@ -32,10 +46,24 @@ event AddressRegistered(address indexed addr, address indexed deployer, address
 | Error | v5 | v6 |
 |---|---|---|
 | `JBAddressRegistry_NonceTooLarge(uint256 nonce)` | Does not exist | **Added** — reverts when `nonce > type(uint64).max` |
+| `JBAddressRegistry_ZeroDeployer()` | Does not exist | **Added** — reverts when `deployer == address(0)` in either `registerAddress` overload |
+
+Unchanged and still relevant:
+- `JBAddressRegistry_AlreadyRegistered(address addr)` still guards duplicate registration attempts.
 
 In v5, passing a nonce larger than `uint32` fell through to the `else` branch, which cast the nonce to `uint32`, silently truncating it and producing an incorrect address. v6 replaces this silent truncation with an explicit revert.
 
-## 5. Implementation Changes (Non-Interface)
+## 5. Function Surface
+
+All external function signatures are unchanged, which means ABI consumers can usually migrate by swapping package/import paths:
+
+| Function | v5 | v6 | Integration impact |
+|---|---|---|---|
+| `deployerOf(address)` | Same | Same | No code changes beyond import/address updates |
+| `registerAddress(address,uint256)` | Same | Same | `create` registration still works; high nonces now succeed through `uint64.max` |
+| `registerAddress(address,bytes32,bytes)` | Same | Same | `create2` flow unchanged |
+
+## 6. Implementation Changes (Non-Interface)
 
 ### `_addressFrom` — RLP nonce encoding
 
@@ -82,13 +110,21 @@ The v6 interface (`IJBAddressRegistry`) adds full NatDoc documentation that was
 
 No function signatures, parameter types, or return types changed.
 
-## 6. Migration Table
+## 7. Migration Table
 
 | v5 | v6 | Action Required |
 |---|---|---|
 | `IJBAddressRegistry` | `IJBAddressRegistry` | **None** — ABI-identical. Update import path only. |
-| `JBAddressRegistry` | `JBAddressRegistry` | **None** — ABI-compatible. Deploy new instance compiled with Solidity ^0.8.26. |
+| `JBAddressRegistry` | `JBAddressRegistry` | **None** — ABI-compatible. Deploy new instance compiled with Solidity 0.8.28. |
 | `registerAddress(address, uint256)` | `registerAddress(address, uint256)` | **None** — signature unchanged. Nonces > `uint32` now work correctly; nonces > `uint64` now revert instead of silently producing wrong addresses. |
 | `registerAddress(address, bytes32, bytes)` | `registerAddress(address, bytes32, bytes)` | **None** — signature unchanged. |
 | `deployerOf(address)` | `deployerOf(address)` | **None** — signature unchanged. |
 | (no error) | `JBAddressRegistry_NonceTooLarge(uint256)` | **New** — callers passing nonces > `uint64.max` must handle this revert. |
+| (no error) | `JBAddressRegistry_ZeroDeployer()` | **New** — callers passing `address(0)` as deployer must handle this revert. |
+
+Practical migration checklist:
+- Update the package/import path from v5 to v6.
+- Keep existing ABI encoders/decoders; the external surface is unchanged.
+- If you predict `create` addresses off-chain, remove any hardcoded `uint32` nonce ceiling assumption.
+- Handle `JBAddressRegistry_NonceTooLarge` if you expose arbitrary nonce input to users or tooling.
+- Handle `JBAddressRegistry_ZeroDeployer` if callers might pass `address(0)` as the deployer.

package/SKILLS.md

@@ -39,15 +39,17 @@ Deployed on: Ethereum, Optimism, Arbitrum, Base, and their Sepolia testnets.
 | Function | What it does |
 |----------|--------------|
 | `_addressFrom(address origin, uint256 nonce) returns (address)` | Computes `create` address using RLP encoding. Handles 10 nonce ranges: `0`, `1-0x7f`, `0x80-0xff`, `0x100-0xffff`, `0x10000-0xffffff`, `0x1000000-0xffffffff`, `0x100000000-0xffffffffff`, `0x10000000000-0xffffffffffff`, `0x1000000000000-0xffffffffffffff`, `0x100000000000000-0xffffffffffffffff`. Reverts with `JBAddressRegistry_NonceTooLarge` for nonces above `uint64` max. Uses `keccak256` of the RLP-encoded `[origin, nonce]` and extracts the low 160 bits via assembly. |
-| `_registerAddress(address addr, address deployer)` | Writes `deployerOf[addr] = deployer` and emits `AddressRegistered`. Shared by both public `registerAddress` overloads. |
+| `_registerAddress(address addr, address deployer)` | Reverts with `JBAddressRegistry_ZeroDeployer` if `deployer == address(0)`. Reverts with `JBAddressRegistry_AlreadyRegistered` if `deployerOf[addr] != address(0)`. Otherwise writes `deployerOf[addr] = deployer` and emits `AddressRegistered`. Shared by both public `registerAddress` overloads. |
 
 ## Errors
 
 | Error | Defined In | Trigger Condition |
 |-------|-----------|-------------------|
 | `JBAddressRegistry_NonceTooLarge(uint256 nonce)` | `JBAddressRegistry` | `registerAddress(deployer, nonce)` is called with a `nonce` greater than `type(uint64).max` (18,446,744,073,709,551,615). Reverts inside `_addressFrom` before any state change. In practice unreachable since no EOA or contract can reach this nonce. |
+| `JBAddressRegistry_AlreadyRegistered(address addr)` | `JBAddressRegistry` | Either `registerAddress` overload is called with parameters that compute to an address already present in `deployerOf`. Reverts inside `_registerAddress` before any state change. |
+| `JBAddressRegistry_ZeroDeployer()` | `JBAddressRegistry` | Either `registerAddress` overload is called with `deployer == address(0)`. Reverts inside `_registerAddress` before any state change. |
 
-This is the only custom error in the contract. The `create2` overload of `registerAddress` has no revert paths (invalid parameters silently compute the wrong address).
+Both `registerAddress` overloads can revert with `JBAddressRegistry_ZeroDeployer` (if `deployer == address(0)`) and `JBAddressRegistry_AlreadyRegistered` (if the computed address was previously registered). The `create` overload can additionally revert with `JBAddressRegistry_NonceTooLarge`. Invalid `create2` parameters (wrong salt or bytecode) do not revert — they silently compute the wrong address.
 
 ## Integration Points
 
@@ -89,13 +91,13 @@ No arrays, no structs, no linked lists. One mapping, that is all.
 ## Gotchas
 
 - **Nonce limit**: `_addressFrom` supports nonces up to `uint64` max (18,446,744,073,709,551,615). Nonces above this revert with `JBAddressRegistry_NonceTooLarge`. In practice this limit is unreachable.
-- **No overwrite protection**: Calling `registerAddress` with parameters that compute to an already-registered address will overwrite the `deployerOf` entry. This is safe because only the correct deployer + parameters produce a given address. But be aware that the same address can be "re-registered" by anyone at any time (with the same result).
+- **No overwrite — duplicate reverts**: Calling `registerAddress` with parameters that compute to an already-registered address reverts with `JBAddressRegistry_AlreadyRegistered`. Only the first registration is accepted.
 - **Permissionless**: Anyone can call `registerAddress`, not just the deployer. `msg.sender` is recorded in the event as `caller` but is NOT stored in the mapping. Only the computed deployer is stored.
 - **No validation**: The registry does not check that `addr` has code deployed, or that the deployer is a real deployer. It purely does math and stores the result. If you pass wrong parameters, it silently registers a mapping for the wrong address. Frontends MUST verify `addr.code.length > 0` (or `extcodesize(addr) > 0` in assembly) before trusting a registry entry.
-- **`deployerOf` returns `address(0)` for unregistered addresses**: This is the default mapping value, not a sentinel. There is no way to distinguish "never registered" from "registered with deployer = address(0)" (though the latter would require someone to call `registerAddress(address(0), ...)` deliberately).
+- **`deployerOf` returns `address(0)` for unregistered addresses**: This is the default mapping value, not a sentinel. Since `JBAddressRegistry_ZeroDeployer` prevents registering `address(0)` as a deployer, `deployerOf[addr] == address(0)` reliably means "not registered".
 - **`create2` bytecode must include constructor args**: When registering a `create2` deployment, the `bytecode` parameter must be the full creation bytecode including ABI-encoded constructor arguments: `abi.encodePacked(type(Contract).creationCode, abi.encode(arg1, arg2, ...))`. Omitting constructor args will compute the wrong address.
 - **Contract nonces start at 1**: When using the `create` overload to register a contract deployed by another contract, remember that contract nonces start at 1 (not 0 like EOAs). The first contract deployed by a factory is at nonce 1.
-- **Solidity version**: The implementation uses `pragma solidity ^0.8.26`. The interface uses `pragma solidity ^0.8.0` (flexible) so it can be imported by any 0.8.x consumer.
+- **Solidity version**: The implementation uses `pragma solidity 0.8.28`. The interface uses `pragma solidity ^0.8.0` (flexible) so it can be imported by any 0.8.x consumer.
 
 ## Example: Register a `create` Deployment
 

package/STYLE_GUIDE.md

@@ -21,7 +21,7 @@ One contract/interface/struct/enum per file. Name the file after the type it con
 
 ```solidity
 // Contracts — pin to exact version
-pragma solidity ^0.8.26;
+pragma solidity 0.8.28;
 
 // Interfaces, structs, enums — caret for forward compatibility
 pragma solidity ^0.8.0;
@@ -326,7 +326,7 @@ Standard config across all repos:
 
 ```toml
 [profile.default]
-solc = '0.8.26'
+solc = '0.8.28'
 evm_version = 'cancun'
 optimizer_runs = 200
 libs = ["node_modules", "lib"]

package/foundry.toml

@@ -1,5 +1,5 @@
 [profile.default]
-solc = '0.8.26'
+solc = '0.8.28'
 evm_version = 'cancun'
 optimizer_runs = 200
 libs = ["node_modules", "lib"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/address-registry-v6",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "license": "MIT",
   "repository": {
     "type": "git",

package/script/Deploy.s.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.26;
+pragma solidity 0.8.28;
 
 import {Sphinx} from "@sphinx-labs/contracts/contracts/foundry/SphinxPlugin.sol";
 import {Script} from "forge-std/Script.sol";

package/script/helpers/AddressRegistryDeploymentLib.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.26;
+pragma solidity 0.8.28;
 
 import {stdJson} from "forge-std/Script.sol";
 import {Vm} from "forge-std/Vm.sol";

package/src/JBAddressRegistry.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.26;
+pragma solidity 0.8.28;
 
 import {IJBAddressRegistry} from "./interfaces/IJBAddressRegistry.sol";
 
@@ -23,6 +23,9 @@ contract JBAddressRegistry is IJBAddressRegistry {
     /// @notice Thrown when a nonce exceeds the maximum value supported by the RLP encoding (uint64 max).
     error JBAddressRegistry_NonceTooLarge(uint256 nonce);
 
+    /// @notice Thrown when attempting to register with `address(0)` as the deployer.
+    error JBAddressRegistry_ZeroDeployer();
+
     //*********************************************************************//
     // --------------------- public stored properties -------------------- //
     //*********************************************************************//
@@ -124,6 +127,7 @@ contract JBAddressRegistry is IJBAddressRegistry {
     /// @param addr The deployed contract's address.
     /// @param deployer The deployer's address.
     function _registerAddress(address addr, address deployer) internal {
+        if (deployer == address(0)) revert JBAddressRegistry_ZeroDeployer();
         if (deployerOf[addr] != address(0)) revert JBAddressRegistry_AlreadyRegistered(addr);
 
         deployerOf[addr] = deployer;

package/test/JBAddressRegistry.t.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.26;
+pragma solidity 0.8.28;
 
 import {Test} from "forge-std/Test.sol";
 import {JBAddressRegistry} from "../src/JBAddressRegistry.sol";

package/test/JBAddressRegistryEdge.t.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.26;
+pragma solidity 0.8.28;
 
 import {Test} from "forge-std/Test.sol";
 import {JBAddressRegistry} from "../src/JBAddressRegistry.sol";
@@ -235,13 +235,16 @@ contract JBAddressRegistryEdge is Test {
     // address(0) deployer
     // =========================================================================
 
-    /// @notice Registration with address(0) as deployer succeeds (permissionless).
-    function test_zeroAddressDeployer_succeeds() public {
-        // This should not revert - the registry is permissionless and doesn't validate.
+    /// @notice Registration with address(0) as deployer reverts with `ZeroDeployer`.
+    function test_zeroAddressDeployer_reverts() public {
+        vm.expectRevert(JBAddressRegistry.JBAddressRegistry_ZeroDeployer.selector);
         registry.registerAddress(address(0), 1);
+    }
 
-        // The computed address for (address(0), nonce=1) gets mapped to address(0).
-        // We just verify no revert and the mapping is set.
+    /// @notice Create2 registration with address(0) as deployer reverts with `ZeroDeployer`.
+    function test_zeroAddressDeployer_create2_reverts() public {
+        vm.expectRevert(JBAddressRegistry.JBAddressRegistry_ZeroDeployer.selector);
+        registry.registerAddress(address(0), bytes32(uint256(42)), hex"60006000f3");
     }
 
     // =========================================================================

package/test/JBAddressRegistry_Fork.t.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.26;
+pragma solidity 0.8.28;
 
 import {Test} from "forge-std/Test.sol";
 import {JBAddressRegistry} from "../src/JBAddressRegistry.sol";

package/test/audit/ZeroDeployerRegistration.t.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+import {Test} from "forge-std/Test.sol";
+
+import {JBAddressRegistry} from "src/JBAddressRegistry.sol";
+
+contract ZeroDeployerRegistrationTest is Test {
+    JBAddressRegistry internal registry;
+
+    function setUp() public {
+        registry = new JBAddressRegistry();
+    }
+
+    /// @notice Registering with `address(0)` as the deployer via `create` reverts with `ZeroDeployer`.
+    function test_createRegistrationWithZeroDeployerReverts() external {
+        uint256 nonce = 1;
+
+        vm.expectRevert(JBAddressRegistry.JBAddressRegistry_ZeroDeployer.selector);
+        registry.registerAddress(address(0), nonce);
+    }
+
+    /// @notice Registering with `address(0)` as the deployer via `create2` reverts with `ZeroDeployer`.
+    function test_create2RegistrationWithZeroDeployerReverts() external {
+        bytes32 salt = keccak256("salt");
+        bytes memory bytecode = hex"60006000f3";
+
+        vm.expectRevert(JBAddressRegistry.JBAddressRegistry_ZeroDeployer.selector);
+        registry.registerAddress(address(0), salt, bytecode);
+    }
+}

package/test/regression/NonceTruncation.t.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.26;
+pragma solidity 0.8.28;
 
 import {Test} from "forge-std/Test.sol";
 import {JBAddressRegistry} from "../../src/JBAddressRegistry.sol";