@bananapus/suckers-v6 0.0.47 → 0.0.49

package/script/helpers/SuckerDeploymentLib.sol

@@ -23,11 +23,10 @@ library SuckerDeploymentLib {
     Vm internal constant vm = Vm(VM_ADDRESS);
 
     function getDeployment(string memory path) internal returns (SuckerDeployment memory deployment) {
-        // get chainId for which we need to get the deployment.
+        // Match the current chain ID to the Sphinx network name used in deployment artifacts.
         uint256 chainId = block.chainid;
 
-        // Deploy to get the constants.
-        // TODO: get constants without deploy.
+        // `SphinxConstants` exposes Sphinx's supported chain ID to network name mapping.
         SphinxConstants sphinxConstants = new SphinxConstants();
         NetworkInfo[] memory networks = sphinxConstants.getNetworkInfoArray();
 
@@ -55,14 +54,13 @@ library SuckerDeploymentLib {
             })
         );
 
-        bytes32 _network = keccak256(abi.encodePacked(networkName));
-        bool _isMainnet = _network == keccak256("ethereum") || _network == keccak256("ethereum_sepolia");
-        // forge-lint: disable-next-line(mixed-case-variable)
-        bool _isOP = _network == keccak256("optimism") || _network == keccak256("optimism_sepolia");
-        bool _isBase = _network == keccak256("base") || _network == keccak256("base_sepolia");
-        bool _isArb = _network == keccak256("arbitrum") || _network == keccak256("arbitrum_sepolia");
+        bytes32 networkHash = keccak256(abi.encodePacked(networkName));
+        bool isMainnet = networkHash == keccak256("ethereum") || networkHash == keccak256("ethereum_sepolia");
+        bool isOp = networkHash == keccak256("optimism") || networkHash == keccak256("optimism_sepolia");
+        bool isBase = networkHash == keccak256("base") || networkHash == keccak256("base_sepolia");
+        bool isArb = networkHash == keccak256("arbitrum") || networkHash == keccak256("arbitrum_sepolia");
 
-        if (_isMainnet || _isOP) {
+        if (isMainnet || isOp) {
             deployment.optimismDeployer = IJBSuckerDeployer(
                 _getDeploymentAddress({
                     path: path,
@@ -73,7 +71,7 @@ library SuckerDeploymentLib {
             );
         }
 
-        if (_isMainnet || _isBase) {
+        if (isMainnet || isBase) {
             deployment.baseDeployer = IJBSuckerDeployer(
                 _getDeploymentAddress({
                     path: path,
@@ -84,7 +82,7 @@ library SuckerDeploymentLib {
             );
         }
 
-        if (_isMainnet || _isArb) {
+        if (isMainnet || isArb) {
             deployment.arbitrumDeployer = IJBSuckerDeployer(
                 _getDeploymentAddress({
                     path: path,

package/src/JBArbitrumSucker.sol

@@ -255,16 +255,17 @@ contract JBArbitrumSucker is JBSucker, IJBArbitrumSucker {
         // If the token is an ERC-20, bridge it to the peer.
         // If the amount is `0` then we do not need to bridge any ERC20.
         if (token != JBConstants.NATIVE_TOKEN && amount != 0) {
+            address gateway;
             uint256 tokenTransportCost;
             uint256 maxSubmissionCostERC20;
             {
                 // Get the exact calldata length the gateway will create for the retryable ticket.
                 // The Arbitrum Inbox validates maxSubmissionCost against this actual payload, not the user data.
-                address gateway = GATEWAYROUTER.getGateway(token);
+                gateway = GATEWAYROUTER.getGateway(token);
                 uint256 outboundCalldataLength =
                     IL1ArbitrumGateway(gateway)
                 .getOutboundCalldata({
-                    _token: token, _from: address(this), _to: _peerAddress(), _amount: amount, _data: bytes("")
+                    token: token, from: address(this), to: _peerAddress(), amount: amount, data: bytes("")
                 }).length;
                 maxSubmissionCostERC20 = ARBINBOX.calculateRetryableSubmissionFee({
                     dataLength: outboundCalldataLength, baseFee: maxFeePerGas
@@ -299,6 +300,8 @@ contract JBArbitrumSucker is JBSucker, IJBArbitrumSucker {
                 gasPriceBid: maxFeePerGas,
                 data: bytes(abi.encode(maxSubmissionCostERC20, bytes("")))
             });
+
+            SafeERC20.forceApprove({token: IERC20(token), spender: gateway, value: 0});
         } else {
             // Ensure we bridge enough for gas costs on L2 side
             if (transportPayment < callTransportCost) {

package/src/JBCCIPSucker.sol

@@ -202,7 +202,7 @@ contract JBCCIPSucker is JBSucker, IAny2EVMMessageReceiver {
     /// @param token The token to bridge the outbox tree for.
     /// @param amount The amount of tokens to bridge.
     /// @param remoteToken Information about the remote token to bridge to.
-    /// @param sucker_message The message root to send to the remote peer.
+    /// @param suckerMessage The message root to send to the remote peer.
     // forge-lint: disable-next-line(mixed-case-function)
     function _sendRootOverAMB(
         uint256 transportPayment,
@@ -210,7 +210,7 @@ contract JBCCIPSucker is JBSucker, IAny2EVMMessageReceiver {
         address token,
         uint256 amount,
         JBRemoteToken memory remoteToken,
-        JBMessageRoot memory sucker_message
+        JBMessageRoot memory suckerMessage
     )
         internal
         virtual
@@ -246,7 +246,7 @@ contract JBCCIPSucker is JBSucker, IAny2EVMMessageReceiver {
             feeToken: feeToken,
             feeTokenPayer: feeToken != address(0) ? _msgSender() : address(0),
             gasLimit: gasLimit,
-            encodedPayload: abi.encode(_CCIP_MSG_TYPE_ROOT, abi.encode(sucker_message)),
+            encodedPayload: abi.encode(_CCIP_MSG_TYPE_ROOT, abi.encode(suckerMessage)),
             tokenAmounts: tokenAmounts,
             refundRecipient: _msgSender()
         });

package/src/JBCeloSucker.sol

@@ -164,6 +164,8 @@ contract JBCeloSucker is JBOptimismSucker {
                 minGasLimit: remoteToken.minGas,
                 extraData: bytes("")
             });
+
+            SafeERC20.forceApprove({token: IERC20(bridgeToken), spender: address(OPBRIDGE), value: 0});
         }
 
         // Send the messenger message with nativeValue = 0.

package/src/JBOptimismSucker.sol

@@ -126,6 +126,8 @@ contract JBOptimismSucker is JBSucker, IJBOptimismSucker {
                 minGasLimit: remoteToken.minGas,
                 extraData: bytes("")
             });
+
+            SafeERC20.forceApprove({token: IERC20(token), spender: address(OPBRIDGE), value: 0});
         } else {
             // Otherwise, the token is the native token, and the amount will be sent as `msg.value`.
             nativeValue = amount;

package/src/JBSucker.sol

@@ -83,6 +83,7 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
     error JBSucker_NoRetainedToRemoteFee(address account);
     error JBSucker_NoRetainedTransportPaymentRefund(address account);
     error JBSucker_RefundFailed(address beneficiary, uint256 amount);
+    error JBSucker_RemoteTokenAlreadyMapped(bytes32 remoteToken, address localToken);
     error JBSucker_TokenAlreadyMapped(address localToken, bytes32 mappedTo);
     error JBSucker_TokenHasInvalidEmergencyHatchState(address token);
     error JBSucker_TokenNotMapped(address token);
@@ -175,6 +176,14 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
     /// @custom:param token The local terminal token to get the inbox for.
     mapping(address token => JBInboxTreeRoot root) internal _inboxOf;
 
+    /// @notice The local token that has reserved each remote token address in this sucker.
+    /// @dev Inbound roots are keyed by `root.token` on the destination chain. Within a single sucker, allowing two
+    /// local tokens to send roots to the same remote token would give them independent source nonces but one shared
+    /// destination inbox, causing stale rejections or root overwrites. Each sucker keeps its own reservation map, so
+    /// separate bridge lanes for the same asset pair can coexist.
+    /// @custom:param remoteToken The remote terminal token address encoded as bytes32.
+    mapping(bytes32 remoteToken => address localToken) internal _localTokenForRemoteToken;
+
     /// @notice The outbox merkle tree for a given token.
     /// @custom:param token The local terminal token to get the outbox for.
     mapping(address token => JBOutboxTree) internal _outboxOf;
@@ -856,23 +865,23 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
     }
 
     /// @notice Initializes the sucker with the project ID.
-    /// @param _projectId The ID of the project (on the local chain) that this sucker is associated with.
-    function initialize(uint256 _projectId) public initializer {
-        _initialize({_projectId: _projectId, remotePeer: bytes32(0)});
+    /// @param initialProjectId The ID of the project (on the local chain) that this sucker is associated with.
+    function initialize(uint256 initialProjectId) public initializer {
+        _initialize({initialProjectId: initialProjectId, remotePeer: bytes32(0)});
     }
 
     /// @notice Initializes the sucker with the project ID and an explicit peer address.
     /// @param localProjectId The ID of the project (on the local chain) that this sucker is associated with.
     /// @param remotePeer The remote peer address. Leave zero to use the default deterministic same-address peer.
     function initialize(uint256 localProjectId, bytes32 remotePeer) public initializer {
-        _initialize({_projectId: localProjectId, remotePeer: remotePeer});
+        _initialize({initialProjectId: localProjectId, remotePeer: remotePeer});
     }
 
     /// @notice Initializes the sucker's project and optional peer address.
-    /// @param _projectId The ID of the project (on the local chain) that this sucker is associated with.
+    /// @param initialProjectId The ID of the project (on the local chain) that this sucker is associated with.
     /// @param remotePeer The remote peer address. Leave zero to use the default deterministic same-address peer.
-    function _initialize(uint256 _projectId, bytes32 remotePeer) internal {
-        _localProjectId = _projectId;
+    function _initialize(uint256 initialProjectId, bytes32 remotePeer) internal {
+        _localProjectId = initialProjectId;
         _peer = remotePeer;
         deployer = _msgSender();
     }
@@ -1031,6 +1040,10 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
     /// after outbox activity, the same local funds could be claimed against two different remote tokens. A
     /// misconfigured mapping therefore requires deploying a new sucker. Re-enabling a previously disabled mapping
     /// (back to the same remote token) is supported.
+    /// @dev Remote tokens are also unique per local token within this sucker. The source side keeps separate
+    /// outboxes/nonces per local token, but the destination side stores roots under the remote token address. Sharing
+    /// one remote token across multiple local tokens in the same sucker would merge those inboxes on the destination
+    /// chain. Separate suckers can still map the same local/remote token pair, letting users choose a bridge lane.
     /// @param map The local and remote terminal token addresses to map, and minimum amount/gas limits for bridging
     /// them.
     /// @param transportPaymentValue The amount of `msg.value` to send for the token mapping.
@@ -1068,6 +1081,16 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
             revert JBSucker_TokenAlreadyMapped({localToken: token, mappedTo: currentMapping.addr});
         }
 
+        // A remote token can back only one local token's outbox in this sucker. Otherwise two independent source
+        // nonces would race into the same destination inbox key (`root.token`), making one token's root stale or
+        // overwriting the other. Other suckers have separate inbox/outbox storage and are unaffected.
+        if (map.remoteToken != bytes32(0)) {
+            address mappedLocalToken = _localTokenForRemoteToken[map.remoteToken];
+            if (mappedLocalToken != address(0) && mappedLocalToken != token) {
+                revert JBSucker_RemoteTokenAlreadyMapped({remoteToken: map.remoteToken, localToken: mappedLocalToken});
+            }
+        }
+
         // No inbox guard needed here. Token remapping only affects the outbound (sending) path —
         // it changes where tokens get bridged TO. Existing inbox claims are resolved against the inbox merkle
         // tree keyed by the local token address. Changing the remote token doesn't invalidate those claims
@@ -1085,6 +1108,17 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
             _sendRoot({transportPayment: transportPaymentValue, token: token, remoteToken: currentMapping});
         }
 
+        // Update the reverse reservation if an unused local token is being remapped to a new remote token.
+        if (
+            map.remoteToken != bytes32(0) && currentMapping.addr != bytes32(0) && currentMapping.addr != map.remoteToken
+                && _localTokenForRemoteToken[currentMapping.addr] == token
+        ) {
+            delete _localTokenForRemoteToken[currentMapping.addr];
+        }
+
+        bytes32 remoteToken = map.remoteToken == bytes32(0) ? currentMapping.addr : map.remoteToken;
+        if (remoteToken != bytes32(0)) _localTokenForRemoteToken[remoteToken] = token;
+
         // Update the token mapping.
         _remoteTokenFor[token] = JBRemoteToken({
             enabled: map.remoteToken != bytes32(0),
@@ -1092,7 +1126,7 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
             minGas: map.minGas,
             // This is done so that a token can be disabled and then enabled again
             // while ensuring the remoteToken never changes (unless it hasn't been used yet)
-            addr: map.remoteToken == bytes32(0) ? currentMapping.addr : map.remoteToken
+            addr: remoteToken
         });
     }
 

package/src/JBSuckerRegistry.sol

@@ -18,6 +18,7 @@ import {IJBSuckerDeployer} from "./interfaces/IJBSuckerDeployer.sol";
 import {IJBSuckerRegistry} from "./interfaces/IJBSuckerRegistry.sol";
 import {JBSuckerDeployerConfig} from "./structs/JBSuckerDeployerConfig.sol";
 import {JBSuckersPair} from "./structs/JBSuckersPair.sol";
+import {PeerValueScratch} from "./structs/PeerValueScratch.sol";
 
 /// @notice The canonical registry that deploys, tracks, and governs cross-chain suckers for Juicebox projects. It
 /// maintains an allowlist of approved deployer contracts, allows multiple active suckers per peer chain for bridge
@@ -210,26 +211,21 @@ contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerR
 
         // Per-chain dedup arrays. The number of suckers per project is small (typically 1-5),
         // so a linear scan is cheaper than a mapping.
-        uint256[] memory chainIds = new uint256[](len);
-        uint256[] memory maxBalances = new uint256[](len);
-        bool[] memory hasActiveValue = new bool[](len);
-        uint256 chainCount;
+        PeerValueScratch memory scratch = _peerValueScratch(len);
 
         for (uint256 i; i < len;) {
             (, uint256 val) = _suckersOf[projectId].tryGet(allSuckers[i]);
             // Include both active and deprecated suckers in aggregate economic views.
             if (val == _SUCKER_EXISTS || val == _SUCKER_DEPRECATED) {
-                try IJBSucker(allSuckers[i]).peerChainBalanceOf(decimals, currency) returns (
+                try IJBSucker(allSuckers[i]).peerChainBalanceOf({decimals: decimals, currency: currency}) returns (
                     JBDenominatedAmount memory amt
                 ) {
                     uint256 chainId = IJBSucker(allSuckers[i]).peerChainId();
-                    chainCount = _recordPeerValue({
-                        chainIds: chainIds,
-                        values: maxBalances,
-                        hasActiveValue: hasActiveValue,
-                        chainCount: chainCount,
+                    scratch.chainCount = _recordPeerValue({
+                        scratch: scratch,
                         chainId: chainId,
                         value: amt.value,
+                        snapshotTimestamp: _snapshotTimestampOf(allSuckers[i]),
                         isActive: val == _SUCKER_EXISTS
                     });
                 } catch {}
@@ -239,9 +235,9 @@ contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerR
             }
         }
 
-        // Sum the per-chain max values.
-        for (uint256 k; k < chainCount;) {
-            balance += maxBalances[k];
+        // Sum the per-chain selected values.
+        for (uint256 k; k < scratch.chainCount;) {
+            balance += scratch.values[k];
             unchecked {
                 ++k;
             }
@@ -271,26 +267,21 @@ contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerR
 
         // Per-chain dedup arrays. The number of suckers per project is small (typically 1-5),
         // so a linear scan is cheaper than a mapping.
-        uint256[] memory chainIds = new uint256[](len);
-        uint256[] memory maxSurplus = new uint256[](len);
-        bool[] memory hasActiveValue = new bool[](len);
-        uint256 chainCount;
+        PeerValueScratch memory scratch = _peerValueScratch(len);
 
         for (uint256 i; i < len;) {
             (, uint256 val) = _suckersOf[projectId].tryGet(allSuckers[i]);
             // Include both active and deprecated suckers in aggregate economic views.
             if (val == _SUCKER_EXISTS || val == _SUCKER_DEPRECATED) {
-                try IJBSucker(allSuckers[i]).peerChainSurplusOf(decimals, currency) returns (
+                try IJBSucker(allSuckers[i]).peerChainSurplusOf({decimals: decimals, currency: currency}) returns (
                     JBDenominatedAmount memory amt
                 ) {
                     uint256 chainId = IJBSucker(allSuckers[i]).peerChainId();
-                    chainCount = _recordPeerValue({
-                        chainIds: chainIds,
-                        values: maxSurplus,
-                        hasActiveValue: hasActiveValue,
-                        chainCount: chainCount,
+                    scratch.chainCount = _recordPeerValue({
+                        scratch: scratch,
                         chainId: chainId,
                         value: amt.value,
+                        snapshotTimestamp: _snapshotTimestampOf(allSuckers[i]),
                         isActive: val == _SUCKER_EXISTS
                     });
                 } catch {}
@@ -300,9 +291,9 @@ contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerR
             }
         }
 
-        // Sum the per-chain max values.
-        for (uint256 k; k < chainCount;) {
-            surplus += maxSurplus[k];
+        // Sum the per-chain selected values.
+        for (uint256 k; k < scratch.chainCount;) {
+            surplus += scratch.values[k];
             unchecked {
                 ++k;
             }
@@ -321,10 +312,7 @@ contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerR
 
         // Per-chain dedup arrays. The number of suckers per project is small (typically 1-5),
         // so a linear scan is cheaper than a mapping.
-        uint256[] memory chainIds = new uint256[](len);
-        uint256[] memory maxSupply = new uint256[](len);
-        bool[] memory hasActiveValue = new bool[](len);
-        uint256 chainCount;
+        PeerValueScratch memory scratch = _peerValueScratch(len);
 
         for (uint256 i; i < len;) {
             (, uint256 val) = _suckersOf[projectId].tryGet(allSuckers[i]);
@@ -332,13 +320,11 @@ contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerR
             if (val == _SUCKER_EXISTS || val == _SUCKER_DEPRECATED) {
                 try IJBSucker(allSuckers[i]).peerChainTotalSupply() returns (uint256 supply) {
                     uint256 chainId = IJBSucker(allSuckers[i]).peerChainId();
-                    chainCount = _recordPeerValue({
-                        chainIds: chainIds,
-                        values: maxSupply,
-                        hasActiveValue: hasActiveValue,
-                        chainCount: chainCount,
+                    scratch.chainCount = _recordPeerValue({
+                        scratch: scratch,
                         chainId: chainId,
                         value: supply,
+                        snapshotTimestamp: _snapshotTimestampOf(allSuckers[i]),
                         isActive: val == _SUCKER_EXISTS
                     });
                 } catch {}
@@ -348,9 +334,9 @@ contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerR
             }
         }
 
-        // Sum the per-chain max values.
-        for (uint256 k; k < chainCount;) {
-            totalSupply += maxSupply[k];
+        // Sum the per-chain selected values.
+        for (uint256 k; k < scratch.chainCount;) {
+            totalSupply += scratch.values[k];
             unchecked {
                 ++k;
             }
@@ -378,58 +364,91 @@ contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerR
         return ERC2771Context._msgSender();
     }
 
+    /// @notice Allocates scratch arrays used to collapse many suckers into one aggregate value per peer chain.
+    /// @dev `len` is the number of suckers being scanned, which is the maximum possible number of distinct peer
+    /// chains. `chainCount` starts at zero and is incremented as new peer chains are discovered.
+    /// @param len The maximum number of peer-chain entries the aggregation can need.
+    /// @return scratch Empty scratch space sized for the current aggregation pass.
+    function _peerValueScratch(uint256 len) internal pure returns (PeerValueScratch memory scratch) {
+        // Allocate each parallel array up front so `_recordPeerValue` can update by index without resizing memory.
+        scratch.chainIds = new uint256[](len);
+        scratch.values = new uint256[](len);
+        scratch.snapshotTimestamps = new uint256[](len);
+        scratch.hasActiveValue = new bool[](len);
+    }
+
     /// @notice Records a project-scoped peer-chain aggregate value.
     /// @dev Callers pass scratch arrays sized from `_suckersOf[projectId].keys()`, so entries are already scoped to
     /// the project being aggregated. For each peer chain, active suckers replace deprecated suckers; deprecated
     /// values are only used as a migration fallback when no active sucker has reported for that chain.
-    /// @param chainIds The peer-chain ids recorded so far.
-    /// @param values The aggregate values recorded so far.
-    /// @param hasActiveValue Whether the recorded value for each index came from an active sucker.
-    /// @param chainCount The number of populated chain entries.
+    /// @param scratch The per-chain aggregate values and freshness keys recorded so far.
     /// @param chainId The peer-chain id to record.
     /// @param value The value to record.
+    /// @param snapshotTimestamp The snapshot freshness key to record.
     /// @param isActive Whether the value came from an active sucker.
     /// @return The updated number of populated chain entries.
     function _recordPeerValue(
-        uint256[] memory chainIds,
-        uint256[] memory values,
-        bool[] memory hasActiveValue,
-        uint256 chainCount,
+        PeerValueScratch memory scratch,
         uint256 chainId,
         uint256 value,
+        uint256 snapshotTimestamp,
         bool isActive
     )
         internal
         pure
         returns (uint256)
     {
-        for (uint256 j; j < chainCount;) {
-            if (chainIds[j] == chainId) {
+        for (uint256 j; j < scratch.chainCount;) {
+            if (scratch.chainIds[j] == chainId) {
                 // Each sucker caches the entire remote chain's state (not a per-sucker share), so multiple
-                // suckers targeting the same chain report redundant snapshots. MAX picks the freshest value
-                // without double-counting — SUM would inflate bonding curve denominators.
+                // suckers targeting the same chain report redundant snapshots. Prefer the freshest source-chain
+                // snapshot; use MAX only as a same-freshness tie-breaker or deprecated fallback.
                 if (isActive) {
-                    if (!hasActiveValue[j] || value > values[j]) values[j] = value;
-                    hasActiveValue[j] = true;
-                } else if (!hasActiveValue[j] && value > values[j]) {
+                    if (
+                        !scratch.hasActiveValue[j] || snapshotTimestamp > scratch.snapshotTimestamps[j]
+                            || (snapshotTimestamp == scratch.snapshotTimestamps[j] && value > scratch.values[j])
+                    ) {
+                        scratch.values[j] = value;
+                        scratch.snapshotTimestamps[j] = snapshotTimestamp;
+                    }
+                    scratch.hasActiveValue[j] = true;
+                } else if (
+                    !scratch.hasActiveValue[j]
+                        && (snapshotTimestamp > scratch.snapshotTimestamps[j]
+                            || (snapshotTimestamp == scratch.snapshotTimestamps[j] && value > scratch.values[j]))
+                ) {
                     // Deprecated suckers only fill the gap until an active value for this chain has been observed.
-                    values[j] = value;
+                    scratch.values[j] = value;
+                    scratch.snapshotTimestamps[j] = snapshotTimestamp;
                 }
-                return chainCount;
+                return scratch.chainCount;
             }
             unchecked {
                 ++j;
             }
         }
 
-        chainIds[chainCount] = chainId;
-        values[chainCount] = value;
-        hasActiveValue[chainCount] = isActive;
+        scratch.chainIds[scratch.chainCount] = chainId;
+        scratch.values[scratch.chainCount] = value;
+        scratch.snapshotTimestamps[scratch.chainCount] = snapshotTimestamp;
+        scratch.hasActiveValue[scratch.chainCount] = isActive;
         unchecked {
-            return chainCount + 1;
+            return scratch.chainCount + 1;
         }
     }
 
+    /// @notice Reads a sucker's snapshot timestamp, returning zero if the sucker does not expose it.
+    /// @dev Older or malformed suckers should not brick aggregate registry views. A zero timestamp makes their value
+    /// lose to any successful fresh read for the same peer chain.
+    /// @param sucker The sucker to query.
+    /// @return timestamp The reported snapshot timestamp, or zero if the call fails.
+    function _snapshotTimestampOf(address sucker) internal view returns (uint256 timestamp) {
+        // Keep aggregate views available even if one registered sucker has a stale ABI or reverts unexpectedly.
+        try IJBSucker(sucker).snapshotTimestamp() returns (uint256 result) {
+            timestamp = result;
+        } catch {}
+    }
+
     //*********************************************************************//
     // ---------------------- public transactions ----------------------- //
     //*********************************************************************//
@@ -564,7 +583,7 @@ contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerR
         }
 
         // Mark the sucker as deprecated (retains mint permission, excluded from active listings).
-        _suckersOf[projectId].set(address(sucker), _SUCKER_DEPRECATED);
+        _suckersOf[projectId].set({key: address(sucker), value: _SUCKER_DEPRECATED});
         emit SuckerDeprecated({projectId: projectId, sucker: address(sucker), caller: _msgSender()});
     }