@bananapus/address-registry-v6 0.0.2 → 0.0.4

package/README.md

@@ -1,30 +1,74 @@
-# nana-address-registry-v5
+# Juicebox Address Registry
 
-Registry that maps contract addresses to their deployers for frontend trust verification. Supports both `create` (nonce-based) and `create2` (salt+bytecode) deployment verification.
+Knowing who deployed a contract is the first step toward trusting it. This registry lets anyone prove a contract's deployer on-chain -- no access control, no admin keys, just math.
+
+`JBAddressRegistry` maps contract addresses to their deployers using deterministic address computation. Provide the deployer address and deployment parameters, and the registry verifies the relationship and stores it permanently. Frontend clients can then look up any registered contract to see who deployed it, which is especially useful for vetting Juicebox pay and cash-out hooks before interacting with them.
+
+## Deployed Address
+
+`JBAddressRegistry` is deployed at the same address on all supported networks via deterministic `create2` deployment:
+
+```
+0x2d9b78cb37ca724cfb9b32cd8e9a5dc1c88bc7bb
+```
+
+| Network | Chain ID |
+|---------|----------|
+| Ethereum | 1 |
+| Optimism | 10 |
+| Arbitrum | 42161 |
+| Base | 8453 |
+| Ethereum Sepolia | 11155111 |
+| Optimism Sepolia | 11155420 |
+| Arbitrum Sepolia | 421614 |
+| Base Sepolia | 84532 |
 
 ## Architecture
 
 | Contract | Description |
 |----------|-------------|
-| `JBAddressRegistry` | Standalone registry. Computes deployed addresses deterministically from deployer parameters and stores the deployer in `deployerOf`. |
+| `JBAddressRegistry` | Standalone registry. Computes deployed addresses deterministically from deployer parameters and stores the deployer in `deployerOf`. No constructor arguments, no access control, no external dependencies. |
 
-### Supporting Types
+### Interface
 
 | Type | Description |
 |------|-------------|
-| `IJBAddressRegistry` | Interface exposing `deployerOf`, and both `registerAddress` overloads. |
+| `IJBAddressRegistry` | Interface exposing `deployerOf`, both `registerAddress` overloads, and the `AddressRegistered` event. |
 
 ### How It Works
 
-Anyone can register a contract by providing its deployer and deployment parameters (`nonce` for `create`, or `salt` + `bytecode` for `create2`). The registry computes the expected address from these parameters and stores the deployer in `deployerOf[computedAddress]`. Frontend clients can then look up any contract's deployer to verify trust.
+Anyone can register a contract by providing its deployer and deployment parameters:
+
+- **`create` deployments**: Provide the deployer address and the nonce at the time of deployment. The registry reconstructs the address using RLP encoding (the same encoding the EVM uses internally to compute `create` addresses).
+- **`create2` deployments**: Provide the deployer address, the `create2` salt, and the full deployment bytecode (creation code + encoded constructor arguments). The registry computes `keccak256(0xff ++ deployer ++ salt ++ keccak256(bytecode))`.
 
-No access control is needed -- only the correct deployer+parameters can produce a given address, so registrations cannot be faked.
+In both cases, the registry stores the mapping `deployerOf[computedAddress] = deployer` and emits an `AddressRegistered` event. Frontend clients can then look up any contract's deployer to verify trust.
+
+No access control is needed -- only the correct deployer + parameters can produce a given address, so registrations cannot be faked.
+
+### Events
+
+| Event | Fields | Emitted When |
+|-------|--------|-------------|
+| `AddressRegistered` | `address indexed addr`, `address indexed deployer`, `address caller` | A contract address is registered via either `registerAddress` overload. `caller` is `msg.sender`, which may differ from the deployer. |
 
 ### Risks
 
-Hooks have token minting access, making malicious hooks dangerous. Clients should warn project owners and users about any potential for unintended or adversarial behavior, especially for unknown hooks.
+Hooks have token minting access, making malicious hooks dangerous. A registered deployer does not guarantee a hook is safe -- it only tells you who deployed it. Clients should warn project owners and users about any potential for unintended or adversarial behavior, especially for unknown hooks.
+
+Deployers can be exploited or act maliciously. Clients should still communicate risk to users even when the deployer is a known entity.
+
+### Limitations
+
+- The `_addressFrom` function for `create` addresses uses RLP encoding that only supports nonces up to `2^32` (4,294,967,295). Higher nonces are silently truncated via `uint32` cast, producing incorrect addresses. In practice, this limit is unreachable.
+- No overwrite protection: registering the same computed address again overwrites the previous deployer. This is safe because only the correct deployer + parameters produce a given address -- a second call with the same inputs just re-registers the same deployer.
+- Registration is permissionless -- anyone can call `registerAddress`, not just the deployer. Security relies entirely on deterministic address computation.
+
+## Deployment
+
+The deploy script uses [Sphinx](https://github.com/sphinx-labs/sphinx) for deterministic multi-chain deployment. The registry is deployed via `create2` with the salt `_JBAddressRegistryV6_`, ensuring the same address on every chain. The script skips deployment if the bytecode is already present at the computed address.
 
-Deployers can be exploited. Clients should still communicate risk to users even when the deployer is registered.
+A helper library `AddressRegistryDeploymentLib` is provided in `script/helpers/` to resolve deployed addresses from Sphinx deployment artifacts at runtime.
 
 ## Install
 
@@ -38,7 +82,7 @@ npm install
 |---------|-------------|
 | `forge build` | Compile contracts |
 | `forge test` | Run unit tests |
-| `FOUNDRY_PROFILE=CI forge test` | Run fork tests |
+| `FOUNDRY_PROFILE=CI forge test` | Run fork tests (requires `RPC_ETHEREUM_MAINNET` env var) |
 | `forge coverage --match-path "./src/*.sol" --report lcov --report summary` | Generate coverage report |
 | `npm run deploy:mainnets` | Propose mainnet deployment via Sphinx |
 | `npm run deploy:testnets` | Propose testnet deployment via Sphinx |

package/SKILLS.md

@@ -1,22 +1,45 @@
-# nana-address-registry-v5
+# Juicebox Address Registry
 
 ## Purpose
 
-Allows anyone to register the deployer of a contract so that frontend clients can verify trust -- primarily for Juicebox pay/cash-out hooks, but works for any contract deployed via `create` or `create2`.
+Allows anyone to register the deployer of a contract so that frontend clients can verify trust -- primarily for Juicebox pay/cash-out hooks, but works for any contract deployed via `create` or `create2`. The contract has no constructor arguments, no access control, no owner, and no external dependencies. Security relies entirely on the mathematical properties of deterministic address computation.
+
+## Deployed Address
+
+Same address on all networks (deterministic `create2` via Sphinx with salt `_JBAddressRegistryV6_`):
+
+```
+0x2d9b78cb37ca724cfb9b32cd8e9a5dc1c88bc7bb
+```
+
+Deployed on: Ethereum, Optimism, Arbitrum, Base, and their Sepolia testnets.
 
 ## Contracts
 
 | Contract | Role |
 |----------|------|
-| `JBAddressRegistry` | Standalone registry with no constructor arguments, no access control, and no external dependencies. |
+| `JBAddressRegistry` | Standalone registry. Stores `mapping(address => address) deployerOf`. Computes addresses deterministically from deployer + deployment params, then writes the mapping. |
 
 ## Key Functions
 
 | Function | Contract | What it does |
 |----------|----------|--------------|
-| `registerAddress(address deployer, uint256 nonce)` | `JBAddressRegistry` | Registers a contract deployed via `create`. Computes address from deployer+nonce using RLP encoding. |
-| `registerAddress(address deployer, bytes32 salt, bytes calldata bytecode)` | `JBAddressRegistry` | Registers a contract deployed via `create2`. Computes `keccak256(0xff ++ deployer ++ salt ++ keccak256(bytecode))`. |
-| `deployerOf(address)` | `JBAddressRegistry` | Returns the registered deployer of a given address. Returns `address(0)` if not registered. |
+| `registerAddress(address deployer, uint256 nonce)` | `JBAddressRegistry` | Registers a contract deployed via `create`. Computes address from deployer + nonce using RLP encoding (`_addressFrom`). Stores `deployerOf[computedAddress] = deployer`. Emits `AddressRegistered`. |
+| `registerAddress(address deployer, bytes32 salt, bytes calldata bytecode)` | `JBAddressRegistry` | Registers a contract deployed via `create2`. Computes `address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), deployer, salt, keccak256(bytecode))))))`. Stores `deployerOf[computedAddress] = deployer`. Emits `AddressRegistered`. |
+| `deployerOf(address addr)` | `JBAddressRegistry` | Returns the registered deployer of `addr`. Returns `address(0)` if not registered. This is a public mapping getter. |
+
+## Events
+
+| Event | Fields | Emitted By |
+|-------|--------|------------|
+| `AddressRegistered(address indexed addr, address indexed deployer, address caller)` | `addr`: the computed contract address. `deployer`: the deployer stored in the mapping. `caller`: `msg.sender` who called `registerAddress` (may differ from deployer). | Both `registerAddress` overloads, via internal `_registerAddress`. |
+
+## Internal Functions
+
+| 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. |
 
 ## Integration Points
 
@@ -24,28 +47,104 @@ Allows anyone to register the deployer of a contract so that frontend clients ca
 |------------|--------|----------|
 | None | -- | This contract is fully standalone with no external dependencies. |
 
+The npm package name is `@bananapus/address-registry-v6`. Import the interface with:
+
+```solidity
+import {IJBAddressRegistry} from "@bananapus/address-registry-v6/src/interfaces/IJBAddressRegistry.sol";
+```
+
 ## Key Types
 
-| Struct/Enum | Key Fields | Used In |
-|-------------|------------|---------|
-| N/A | -- | No custom types. Uses a plain `mapping(address => address)` for storage. |
+| Type | Description |
+|------|-------------|
+| `IJBAddressRegistry` | Interface declaring `deployerOf`, both `registerAddress` overloads, and the `AddressRegistered` event. Pragma `^0.8.0`. |
+| `AddressRegistryDeployment` | Struct in `script/helpers/AddressRegistryDeploymentLib.sol` containing `IJBAddressRegistry registry`. Used by deploy scripts to pass around the deployed instance. |
+
+## Storage Layout
+
+Single slot category:
+
+```
+mapping(address addr => address deployer) public deployerOf;
+```
+
+No arrays, no structs, no linked lists. One mapping, that is all.
+
+## Deployment Details
+
+- Deploy script: `script/Deploy.s.sol`
+- Salt: `bytes32("_JBAddressRegistryV6_")`
+- Deployer proxy: `0x4e59b44847b379578588920cA78FbF26c0B4956C` (Arachnid deterministic deployment proxy)
+- The script checks if code already exists at the computed address and skips deployment if so
+- `AddressRegistryDeploymentLib` (in `script/helpers/`) resolves deployed addresses from Sphinx JSON artifacts by chain ID
 
 ## Gotchas
 
-- The `_addressFrom` function for `create` addresses only supports nonces up to `2^32`. Higher nonces produce incorrect addresses.
-- No overwrite protection: calling `registerAddress` with different parameters that compute to the same address will overwrite the deployer. This is safe because only the correct deployer+parameters can produce a given address.
-- Registration is permissionless -- anyone can call `registerAddress`, not just the deployer. Security relies on deterministic address computation, not access control.
+- **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).
+- **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.
+- **`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).
+- **`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` (exact). 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
+
+```solidity
+import {IJBAddressRegistry} from "@bananapus/address-registry-v6/src/interfaces/IJBAddressRegistry.sol";
+
+// After deploying a hook from a factory contract:
+address hook = address(new MyPayHook(projectId));
+// Factory's nonce was N when it deployed the hook.
+// If this is the factory's first deployment, nonce = 1.
+registry.registerAddress(address(this), 1);
+```
 
-## Example Integration
+## Example: Register a `create2` Deployment
 
 ```solidity
 import {IJBAddressRegistry} from "@bananapus/address-registry-v6/src/interfaces/IJBAddressRegistry.sol";
 
-// After deploying a hook
-address hook = new MyPayHook();
-registry.registerAddress(address(this), deployerNonce);
+bytes32 salt = keccak256(abi.encode(projectId));
+address hook = address(new MyPayHook{salt: salt}(projectId));
+
+// Bytecode must include constructor arguments.
+bytes memory bytecode = abi.encodePacked(
+    type(MyPayHook).creationCode,
+    abi.encode(projectId)
+);
+registry.registerAddress(address(this), salt, bytecode);
+```
 
-// Frontend can verify
-address deployer = registry.deployerOf(address(hook));
-bool trusted = deployer == KNOWN_DEPLOYER;
+## Example: Frontend Lookup
+
+```solidity
+address deployer = registry.deployerOf(hookAddress);
+if (deployer == address(0)) {
+    // Not registered -- unknown deployer.
+} else if (deployer == TRUSTED_DEPLOYER) {
+    // Deployed by a known, trusted factory.
+} else {
+    // Registered but deployer is not in the trusted set.
+}
 ```
+
+## RLP Encoding Reference (for `create` address computation)
+
+The `_addressFrom` function implements RLP encoding of `[deployer, nonce]` to match how the EVM computes `create` addresses. The encoding varies by nonce size:
+
+| Nonce Range | RLP Prefix | Nonce Encoding |
+|-------------|-----------|----------------|
+| `0` | `0xd6 0x94` | `0x80` (RLP empty byte) |
+| `1 - 0x7f` | `0xd6 0x94` | `uint8(nonce)` |
+| `0x80 - 0xff` | `0xd7 0x94` | `0x81` + `uint8(nonce)` |
+| `0x100 - 0xffff` | `0xd8 0x94` | `0x82` + `uint16(nonce)` |
+| `0x10000 - 0xffffff` | `0xd9 0x94` | `0x83` + `uint24(nonce)` |
+| `0x1000000 - 0xffffffff` | `0xda 0x94` | `0x84` + `uint32(nonce)` |
+| `0x100000000 - 0xffffffffff` | `0xdb 0x94` | `0x85` + `uint40(nonce)` |
+| `0x10000000000 - 0xffffffffffff` | `0xdc 0x94` | `0x86` + `uint48(nonce)` |
+| `0x1000000000000 - 0xffffffffffffff` | `0xdd 0x94` | `0x87` + `uint56(nonce)` |
+| `0x100000000000000 - 0xffffffffffffffff` | `0xde 0x94` | `0x88` + `uint64(nonce)` |
+
+The final address is `keccak256(rlp_encoded_data)` with the low 160 bits extracted.

package/foundry.toml

@@ -1,5 +1,5 @@
 [profile.default]
-solc = '0.8.23'
+solc = '0.8.26'
 evm_version = 'paris'
 optimizer_runs = 10000000
 libs = ["node_modules", "lib"]

package/package.json

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

package/script/Deploy.s.sol

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

package/script/helpers/AddressRegistryDeploymentLib.sol

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

package/slither-ci.config.json

@@ -5,6 +5,6 @@
     "exclude_medium": false,
     "exclude_high": false,
     "disable_color": false,
-    "filter_paths": "(mocks/|test/|node_modules/)",
+    "filter_paths": "(mocks/|test/|node_modules/|lib/)",
     "legacy_ast": false
 }

package/src/JBAddressRegistry.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.23;
+pragma solidity 0.8.26;
 
 import {IJBAddressRegistry} from "./interfaces/IJBAddressRegistry.sol";
 
@@ -12,6 +12,13 @@ import {IJBAddressRegistry} from "./interfaces/IJBAddressRegistry.sol";
 /// @dev The addresses of the deployed contracts are computed deterministically based on the deployer's address, and a
 /// nonce (for `create`) or `create2` salt and deployment bytecode (for `create2`).
 contract JBAddressRegistry is IJBAddressRegistry {
+    //*********************************************************************//
+    // -------------------------------- errors --------------------------- //
+    //*********************************************************************//
+
+    /// @notice Thrown when a nonce exceeds the maximum value supported by the RLP encoding (uint64 max).
+    error JBAddressRegistry_NonceTooLarge(uint256 nonce);
+
     //*********************************************************************//
     // --------------------- public stored properties -------------------- //
     //*********************************************************************//
@@ -59,11 +66,13 @@ contract JBAddressRegistry is IJBAddressRegistry {
     //*********************************************************************//
 
     /// @notice Compute the address of a contract deployed using `create` based on the deployer's address and nonce.
-    /// @dev Taken from https://ethereum.stackexchange.com/a/87840/68134 - this won't work for nonces > 2**32. If
-    /// you reach that nonce please: 1) ping us, because wow 2) use another deployer.
+    /// @dev RLP encoding of [origin, nonce]. Supports nonces up to uint64 max (covers any realistic Ethereum nonce).
+    /// @dev Adapted from https://ethereum.stackexchange.com/a/87840/68134
     /// @param origin The deployer's address.
     /// @param nonce The nonce used to deploy the contract.
     function _addressFrom(address origin, uint256 nonce) internal pure returns (address addr) {
+        if (nonce > type(uint64).max) revert JBAddressRegistry_NonceTooLarge(nonce);
+
         bytes memory data;
         if (nonce == 0x00) {
             data = abi.encodePacked(bytes1(0xd6), bytes1(0x94), origin, bytes1(0x80));
@@ -75,8 +84,16 @@ contract JBAddressRegistry is IJBAddressRegistry {
             data = abi.encodePacked(bytes1(0xd8), bytes1(0x94), origin, bytes1(0x82), uint16(nonce));
         } else if (nonce <= 0xffffff) {
             data = abi.encodePacked(bytes1(0xd9), bytes1(0x94), origin, bytes1(0x83), uint24(nonce));
-        } else {
+        } else if (nonce <= 0xffffffff) {
             data = abi.encodePacked(bytes1(0xda), bytes1(0x94), origin, bytes1(0x84), uint32(nonce));
+        } else if (nonce <= 0xffffffffff) {
+            data = abi.encodePacked(bytes1(0xdb), bytes1(0x94), origin, bytes1(0x85), uint40(nonce));
+        } else if (nonce <= 0xffffffffffff) {
+            data = abi.encodePacked(bytes1(0xdc), bytes1(0x94), origin, bytes1(0x86), uint48(nonce));
+        } else if (nonce <= 0xffffffffffffff) {
+            data = abi.encodePacked(bytes1(0xdd), bytes1(0x94), origin, bytes1(0x87), uint56(nonce));
+        } else {
+            data = abi.encodePacked(bytes1(0xde), bytes1(0x94), origin, bytes1(0x88), uint64(nonce));
         }
         bytes32 hash = keccak256(data);
         assembly {

package/test/JBAddressRegistry.t.sol

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

package/test/JBAddressRegistryEdge.t.sol

@@ -0,0 +1,349 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {Test} from "forge-std/Test.sol";
+import {JBAddressRegistry} from "../src/JBAddressRegistry.sol";
+
+/// @title JBAddressRegistryEdge
+/// @notice Edge case and negative tests for JBAddressRegistry: RLP encoding boundaries,
+///         mismatched parameters, duplicate registrations, and address(0) inputs.
+contract JBAddressRegistryEdge is Test {
+    event AddressRegistered(address indexed addr, address indexed deployer, address caller);
+
+    JBAddressRegistry registry;
+    address deployer = makeAddr("deployer");
+
+    function setUp() public {
+        registry = new JBAddressRegistry();
+    }
+
+    // =========================================================================
+    // RLP encoding boundary tests - verify _addressFrom at each nonce boundary
+    // =========================================================================
+
+    /// @notice Nonce 0: uses 0x80 byte suffix.
+    function test_nonceBoundary_zero() public {
+        _verifyCreateRegistration(deployer, 0);
+    }
+
+    /// @notice Nonce 1: single-byte RLP (nonce <= 0x7f).
+    function test_nonceBoundary_one() public {
+        _verifyCreateRegistration(deployer, 1);
+    }
+
+    /// @notice Nonce 0x7f: upper boundary of single-byte RLP.
+    function test_nonceBoundary_0x7f() public {
+        _verifyCreateRegistration(deployer, 0x7f);
+    }
+
+    /// @notice Nonce 0x80: switches to 2-byte RLP (0x81 prefix).
+    function test_nonceBoundary_0x80() public {
+        _verifyCreateRegistration(deployer, 0x80);
+    }
+
+    /// @notice Nonce 0xff: upper boundary of uint8 nonce.
+    function test_nonceBoundary_0xff() public {
+        _verifyCreateRegistration(deployer, 0xff);
+    }
+
+    /// @notice Nonce 0x100: switches to uint16 encoding.
+    function test_nonceBoundary_0x100() public {
+        _verifyCreateRegistration(deployer, 0x100);
+    }
+
+    /// @notice Nonce 0xffff: upper boundary of uint16 nonce.
+    function test_nonceBoundary_0xffff() public {
+        _verifyCreateRegistration(deployer, 0xffff);
+    }
+
+    /// @notice Nonce 0x10000: switches to uint24 encoding.
+    function test_nonceBoundary_0x10000() public {
+        _verifyCreateRegistration(deployer, 0x10000);
+    }
+
+    /// @notice Nonce 0xffffff: upper boundary of uint24 nonce.
+    function test_nonceBoundary_0xffffff() public {
+        _verifyCreateRegistration(deployer, 0xffffff);
+    }
+
+    /// @notice Nonce 0x1000000: switches to uint32 encoding.
+    function test_nonceBoundary_0x1000000() public {
+        _verifyCreateRegistration(deployer, 0x1000000);
+    }
+
+    /// @notice Nonce at max uint32.
+    function test_nonceBoundary_maxUint32() public {
+        _verifyCreateRegistration(deployer, type(uint32).max);
+    }
+
+    /// @notice Nonce 0x100000000: switches to uint40 encoding.
+    function test_nonceBoundary_0x100000000() public {
+        _verifyCreateRegistration(deployer, 0x100000000);
+    }
+
+    /// @notice Nonce at max uint40.
+    function test_nonceBoundary_maxUint40() public {
+        _verifyCreateRegistration(deployer, type(uint40).max);
+    }
+
+    /// @notice Nonce 0x10000000000: switches to uint48 encoding.
+    function test_nonceBoundary_0x10000000000() public {
+        _verifyCreateRegistration(deployer, 0x10000000000);
+    }
+
+    /// @notice Nonce at max uint48.
+    function test_nonceBoundary_maxUint48() public {
+        _verifyCreateRegistration(deployer, type(uint48).max);
+    }
+
+    /// @notice Nonce 0x1000000000000: switches to uint56 encoding.
+    function test_nonceBoundary_0x1000000000000() public {
+        _verifyCreateRegistration(deployer, 0x1000000000000);
+    }
+
+    /// @notice Nonce at max uint56.
+    function test_nonceBoundary_maxUint56() public {
+        _verifyCreateRegistration(deployer, type(uint56).max);
+    }
+
+    /// @notice Nonce 0x100000000000000: switches to uint64 encoding.
+    function test_nonceBoundary_0x100000000000000() public {
+        _verifyCreateRegistration(deployer, 0x100000000000000);
+    }
+
+    /// @notice Nonce at max uint64 - highest supported nonce. Does not deploy (VM limitation).
+    function test_nonceBoundary_maxUint64() public {
+        // Cannot use _verifyCreateRegistration because vm.setNonce cannot handle uint64.max.
+        // Just verify registerAddress does not revert at the boundary.
+        registry.registerAddress(deployer, type(uint64).max);
+    }
+
+    // =========================================================================
+    // Mismatched parameters - wrong deployer/nonce registers wrong address
+    // =========================================================================
+
+    /// @notice Registering with wrong nonce maps to a different (non-deployed) address.
+    function test_mismatchedNonce_registersDifferentAddress() public {
+        uint64 correctNonce = 5;
+
+        // Set nonce and deploy.
+        vm.setNonce(deployer, correctNonce);
+        vm.prank(deployer);
+        address deployed = address(new MockDeployment());
+
+        // Register with wrong nonce - should map to a different address.
+        uint256 wrongNonce = 6;
+        registry.registerAddress(deployer, wrongNonce);
+
+        // The deployed contract should NOT be mapped (wrong nonce was used).
+        assertEq(
+            registry.deployerOf(deployed), address(0), "Deployed address should not be registered with wrong nonce"
+        );
+    }
+
+    /// @notice Registering with wrong deployer maps to a different address.
+    function test_mismatchedDeployer_registersDifferentAddress() public {
+        address wrongDeployer = makeAddr("wrongDeployer");
+        uint64 nonce = 1;
+
+        vm.setNonce(deployer, nonce);
+        vm.prank(deployer);
+        address deployed = address(new MockDeployment());
+
+        // Register with wrong deployer.
+        registry.registerAddress(wrongDeployer, nonce);
+
+        // The deployed address should not be registered.
+        assertEq(registry.deployerOf(deployed), address(0), "Should not be registered with wrong deployer");
+    }
+
+    // =========================================================================
+    // Duplicate registration - second registration overwrites first
+    // =========================================================================
+
+    /// @notice Registering the same computed address twice overwrites the deployer.
+    function test_duplicateRegistration_overwrites() public {
+        uint64 nonce = 1;
+
+        vm.setNonce(deployer, nonce);
+        vm.prank(deployer);
+        address deployed = address(new MockDeployment());
+
+        // First registration.
+        registry.registerAddress(deployer, nonce);
+        assertEq(registry.deployerOf(deployed), deployer);
+
+        // Register again with a different deployer (same computed address via different params).
+        // Actually, same deployer + nonce = same address. Let's just call register again.
+        address fakeDeployer = makeAddr("fake");
+        registry.registerAddress(fakeDeployer, nonce);
+
+        // The real deployed address still has the correct deployer.
+        // But the address computed from (fakeDeployer, nonce) is a DIFFERENT address.
+        // So deployed's mapping is unchanged.
+        assertEq(registry.deployerOf(deployed), deployer, "Original registration should be unchanged");
+    }
+
+    // =========================================================================
+    // Unregistered address returns address(0)
+    // =========================================================================
+
+    /// @notice deployerOf returns address(0) for unregistered addresses.
+    function test_unregisteredAddress_returnsZero() public {
+        assertEq(registry.deployerOf(address(0xdead)), address(0));
+        assertEq(registry.deployerOf(address(0)), address(0));
+        assertEq(registry.deployerOf(address(this)), address(0));
+    }
+
+    // =========================================================================
+    // Create2 - wrong bytecode maps to wrong address
+    // =========================================================================
+
+    /// @notice Create2 registration with wrong bytecode produces different address.
+    function test_create2_wrongBytecode_registersDifferentAddress() public {
+        Factory factory = new Factory();
+        bytes32 salt = bytes32(uint256(42));
+
+        address deployed = factory.deploy(salt);
+
+        // Register with correct params.
+        registry.registerAddress(address(factory), salt, type(MockDeployment).creationCode);
+        assertEq(registry.deployerOf(deployed), address(factory), "Correct create2 registration should work");
+
+        // Now try registering with wrong bytecode - produces different computed address.
+        bytes memory wrongBytecode = hex"deadbeef";
+        registry.registerAddress(address(factory), salt, wrongBytecode);
+
+        // The deployed address's mapping should be unchanged (wrong bytecode = different address).
+        assertEq(registry.deployerOf(deployed), address(factory), "Original mapping unchanged by wrong bytecode");
+    }
+
+    // =========================================================================
+    // 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.
+        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.
+    }
+
+    // =========================================================================
+    // Event emission
+    // =========================================================================
+
+    /// @notice Verify AddressRegistered event is emitted with correct fields for create.
+    function test_eventEmission_create() public {
+        uint64 nonce = 1;
+        vm.setNonce(deployer, nonce);
+        vm.prank(deployer);
+        address deployed = address(new MockDeployment());
+
+        vm.expectEmit(true, true, true, true);
+        emit AddressRegistered(deployed, deployer, address(this));
+
+        registry.registerAddress(deployer, nonce);
+    }
+
+    /// @notice Verify AddressRegistered event is emitted with correct fields for create2.
+    function test_eventEmission_create2() public {
+        Factory factory = new Factory();
+        bytes32 salt = bytes32(uint256(99));
+        address deployed = factory.deploy(salt);
+
+        vm.expectEmit(true, true, true, true);
+        emit AddressRegistered(deployed, address(factory), address(this));
+
+        registry.registerAddress(address(factory), salt, type(MockDeployment).creationCode);
+    }
+
+    // =========================================================================
+    // Fuzz: any valid nonce produces correct registration
+    // =========================================================================
+
+    /// @notice Fuzz across the uint32 nonce range with full deploy-and-verify.
+    function testFuzz_createRegistration_anyNonce(uint32 nonce) public {
+        _verifyCreateRegistration(deployer, uint256(nonce));
+    }
+
+    /// @notice Fuzz: any nonce within uint64 range should not revert on registerAddress.
+    function testFuzz_registerAddress_anyUint64Nonce(uint64 nonce) public {
+        // Just verify registerAddress does not revert for any uint64 nonce.
+        registry.registerAddress(deployer, uint256(nonce));
+    }
+
+    // =========================================================================
+    // Nonce > uint64 - reverts with NonceTooLarge (L-67 fix extended to uint64)
+    // =========================================================================
+
+    /// @notice Nonces above uint64 max revert instead of silently truncating.
+    function test_nonceAboveUint64_reverts() public {
+        address deployer1 = makeAddr("deployer_overflow");
+        uint256 tooLargeNonce = uint256(type(uint64).max) + 1;
+
+        vm.expectRevert(
+            abi.encodeWithSelector(JBAddressRegistry.JBAddressRegistry_NonceTooLarge.selector, tooLargeNonce)
+        );
+        registry.registerAddress(deployer1, tooLargeNonce);
+    }
+
+    /// @notice Nonces in the uint32-uint64 range now succeed (L-67 fix extended support).
+    function test_nonceInUint40Range_succeeds() public {
+        registry.registerAddress(deployer, uint256(type(uint40).max));
+    }
+
+    // =========================================================================
+    // Helpers
+    // =========================================================================
+
+    /// @dev Deploys a contract at the given nonce and verifies registration.
+    function _verifyCreateRegistration(address _deployer, uint256 nonce) internal {
+        // Set nonce (must be >= current nonce).
+        uint64 currentNonce = vm.getNonce(_deployer);
+        if (nonce < currentNonce) {
+            // Can't set nonce lower than current, use a fresh deployer.
+            _deployer = makeAddr(string.concat("deployer_", vm.toString(nonce)));
+        }
+        if (vm.getNonce(_deployer) != nonce) {
+            // forge-lint: disable-next-line(unsafe-typecast)
+            vm.setNonce(_deployer, uint64(nonce));
+        }
+
+        // Deploy.
+        vm.prank(_deployer);
+        address deployed = address(new MockDeployment());
+
+        // Register.
+        registry.registerAddress(_deployer, nonce);
+
+        // Verify.
+        assertEq(
+            registry.deployerOf(deployed),
+            _deployer,
+            string.concat("Registration failed for nonce ", vm.toString(nonce))
+        );
+    }
+}
+
+contract MockDeployment {
+    string stored = "Hello, world!";
+
+    constructor() {}
+
+    function getFancyData() external view returns (string memory) {
+        return stored;
+    }
+}
+
+contract Factory {
+    function deploy() public returns (address) {
+        return address(new MockDeployment());
+    }
+
+    function deploy(bytes32 _salt) public returns (address) {
+        return address(new MockDeployment{salt: _salt}());
+    }
+}

package/test/JBAddressRegistry_Fork.t.sol

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

package/test/regression/L67_NonceTruncation.t.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.26;
+
+import {Test} from "forge-std/Test.sol";
+import {JBAddressRegistry} from "../../src/JBAddressRegistry.sol";
+
+/// @title L67_NonceTruncation
+/// @notice Regression test for L-67: _addressFrom originally only handled nonces up to uint32 max,
+///         silently truncating larger values. The fix extends RLP encoding to uint64 max and adds
+///         an explicit revert for nonces beyond that range.
+contract L67_NonceTruncation is Test {
+    JBAddressRegistry registry;
+    address deployer = makeAddr("deployer");
+
+    function setUp() public {
+        registry = new JBAddressRegistry();
+    }
+
+    /// @notice Nonce exactly at uint32 max should succeed.
+    function test_nonceAtUint32Max_succeeds() public {
+        registry.registerAddress(deployer, type(uint32).max);
+    }
+
+    /// @notice Nonce one above uint32 max should now succeed (uint64 support added in L-67 fix).
+    function test_nonceAboveUint32Max_succeeds() public {
+        uint256 nonce = uint256(type(uint32).max) + 1;
+        // Should not revert -- the fix extended support to uint64.
+        registry.registerAddress(deployer, nonce);
+    }
+
+    /// @notice Nonce at uint64 max should succeed (upper boundary of support).
+    function test_nonceAtUint64Max_succeeds() public {
+        registry.registerAddress(deployer, type(uint64).max);
+    }
+
+    /// @notice Nonce one above uint64 max should revert with NonceTooLarge.
+    function test_nonceAboveUint64Max_reverts() public {
+        uint256 tooLargeNonce = uint256(type(uint64).max) + 1;
+
+        vm.expectRevert(
+            abi.encodeWithSelector(JBAddressRegistry.JBAddressRegistry_NonceTooLarge.selector, tooLargeNonce)
+        );
+        registry.registerAddress(deployer, tooLargeNonce);
+    }
+
+    /// @notice A nonce at uint256 max should revert with NonceTooLarge.
+    function test_nonceUint256Max_reverts() public {
+        uint256 maxNonce = type(uint256).max;
+
+        vm.expectRevert(abi.encodeWithSelector(JBAddressRegistry.JBAddressRegistry_NonceTooLarge.selector, maxNonce));
+        registry.registerAddress(deployer, maxNonce);
+    }
+
+    /// @notice Fuzz: any nonce above uint64 max should revert.
+    function testFuzz_nonceAboveUint64Max_reverts(uint256 nonce) public {
+        vm.assume(nonce > type(uint64).max);
+
+        vm.expectRevert(abi.encodeWithSelector(JBAddressRegistry.JBAddressRegistry_NonceTooLarge.selector, nonce));
+        registry.registerAddress(deployer, nonce);
+    }
+
+    /// @notice Fuzz: any nonce within uint64 range should succeed (no revert).
+    function testFuzz_nonceWithinUint64Range_succeeds(uint64 nonce) public {
+        registry.registerAddress(deployer, uint256(nonce));
+    }
+}