@bananapus/suckers-v6 0.0.66 → 0.0.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/suckers-v6",
-  "version": "0.0.66",
+  "version": "0.0.67",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/JBArbitrumSucker.sol

@@ -81,7 +81,7 @@ contract JBArbitrumSucker is JBSucker, IJBArbitrumSucker {
 
     /// @notice Returns the chain on which the peer is located.
     /// @return chainId of the peer.
-    function peerChainId() external view virtual override returns (uint256) {
+    function peerChainId() public view virtual override returns (uint256) {
         uint256 chainId = block.chainid;
         if (chainId == ARBChains.ETH_CHAINID) return ARBChains.ARB_CHAINID;
         if (chainId == ARBChains.ARB_CHAINID) return ARBChains.ETH_CHAINID;

package/src/JBBaseSucker.sol

@@ -40,7 +40,7 @@ contract JBBaseSucker is JBOptimismSucker {
 
     /// @notice Returns the chain on which the peer is located.
     /// @return chainId of the peer.
-    function peerChainId() external view virtual override returns (uint256) {
+    function peerChainId() public view virtual override returns (uint256) {
         uint256 chainId = block.chainid;
         if (chainId == 1) return 8453;
         if (chainId == 8453) return 1;

package/src/JBCCIPSucker.sol

@@ -119,7 +119,7 @@ contract JBCCIPSucker is JBSucker, IAny2EVMMessageReceiver {
 
     /// @notice Returns the chain on which the peer is located.
     /// @return chainId The chain ID of the peer.
-    function peerChainId() external view virtual override returns (uint256 chainId) {
+    function peerChainId() public view virtual override returns (uint256 chainId) {
         return REMOTE_CHAIN_ID;
     }
 

package/src/JBOptimismSucker.sol

@@ -64,7 +64,7 @@ contract JBOptimismSucker is JBSucker, IJBOptimismSucker {
 
     /// @notice Returns the chain on which the peer is located.
     /// @return chainId of the peer.
-    function peerChainId() external view virtual override returns (uint256) {
+    function peerChainId() public view virtual override returns (uint256) {
         uint256 chainId = block.chainid;
         if (chainId == 1) return 10;
         if (chainId == 10) return 1;

package/src/JBSucker.sol

@@ -40,6 +40,7 @@ import {JBDenominatedAmount} from "./structs/JBDenominatedAmount.sol";
 import {JBInboxTreeRoot} from "./structs/JBInboxTreeRoot.sol";
 import {JBMessageRoot} from "./structs/JBMessageRoot.sol";
 import {JBOutboxTree} from "./structs/JBOutboxTree.sol";
+import {JBPeerChainValue} from "./structs/JBPeerChainValue.sol";
 import {JBRemoteToken} from "./structs/JBRemoteToken.sol";
 import {JBTokenMapping} from "./structs/JBTokenMapping.sol";
 
@@ -773,10 +774,6 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
         return _outboxOf[token];
     }
 
-    /// @notice Returns the chain on which the peer is located.
-    /// @return chain ID of the peer.
-    function peerChainId() external view virtual returns (uint256);
-
     /// @notice The peer chain balance, converted from the source denomination to the requested currency and decimal
     /// precision using the local JBPrices oracle.
     /// @param decimals The decimal precision for the returned value.
@@ -792,6 +789,28 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
         });
     }
 
+    /// @notice The peer chain balance bundled with the peer chain ID and snapshot freshness key.
+    /// @dev Lets aggregators (e.g. `JBSuckerRegistry`) read the value, the peer chain it belongs to, and its
+    /// freshness in one call instead of three separate staticcalls. The `value` is identical to
+    /// `peerChainBalanceOf`.
+    /// @param decimals The decimal precision for the returned value.
+    /// @param currency The currency to normalize to (e.g. `uint256(uint160(JBConstants.NATIVE_TOKEN))` for ETH).
+    /// @return A `JBPeerChainValue` with the converted balance, peer chain ID, and snapshot freshness key.
+    function peerChainBalanceValueOf(
+        uint256 decimals,
+        uint256 currency
+    )
+        external
+        view
+        returns (JBPeerChainValue memory)
+    {
+        return JBPeerChainValue({
+            value: _convertPeerValue({source: _peerChainBalance, decimals: decimals, currency: currency}),
+            peerChainId: peerChainId(),
+            snapshotTimestamp: snapshotTimestamp
+        });
+    }
+
     /// @notice The peer chain surplus, converted from the source denomination to the requested currency and decimal
     /// precision using the local JBPrices oracle.
     /// @param decimals The decimal precision for the returned value.
@@ -807,6 +826,39 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
         });
     }
 
+    /// @notice The peer chain surplus bundled with the peer chain ID and snapshot freshness key.
+    /// @dev Lets aggregators (e.g. `JBSuckerRegistry`) read the value, the peer chain it belongs to, and its
+    /// freshness in one call instead of three separate staticcalls. The `value` is identical to
+    /// `peerChainSurplusOf`.
+    /// @param decimals The decimal precision for the returned value.
+    /// @param currency The currency to normalize to (e.g. `uint256(uint160(JBConstants.NATIVE_TOKEN))` for ETH).
+    /// @return A `JBPeerChainValue` with the converted surplus, peer chain ID, and snapshot freshness key.
+    function peerChainSurplusValueOf(
+        uint256 decimals,
+        uint256 currency
+    )
+        external
+        view
+        returns (JBPeerChainValue memory)
+    {
+        return JBPeerChainValue({
+            value: _convertPeerValue({source: _peerChainSurplus, decimals: decimals, currency: currency}),
+            peerChainId: peerChainId(),
+            snapshotTimestamp: snapshotTimestamp
+        });
+    }
+
+    /// @notice The peer chain total supply bundled with the peer chain ID and snapshot freshness key.
+    /// @dev Lets aggregators (e.g. `JBSuckerRegistry`) read the value, the peer chain it belongs to, and its
+    /// freshness in one call instead of three separate staticcalls. The `value` is identical to
+    /// `peerChainTotalSupply`.
+    /// @return A `JBPeerChainValue` with the total supply, peer chain ID, and snapshot freshness key.
+    function peerChainTotalSupplyValue() external view returns (JBPeerChainValue memory) {
+        return JBPeerChainValue({
+            value: peerChainTotalSupply, peerChainId: peerChainId(), snapshotTimestamp: snapshotTimestamp
+        });
+    }
+
     /// @notice Information about the token on the remote chain that the given token on the local chain is mapped to.
     /// @param token The local terminal token to get the remote token for.
     /// @return The remote token mapping for the given local token.
@@ -841,6 +893,12 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
         return amount;
     }
 
+    /// @notice Returns the chain on which the peer is located.
+    /// @dev `public` (not `external`) so the combined peer-chain views in this contract can read it internally
+    /// without a self-call; subclasses implement the bridge-specific chain ID.
+    /// @return chain ID of the peer.
+    function peerChainId() public view virtual returns (uint256);
+
     /// @notice The peer sucker on the remote chain, as a bytes32 for cross-VM compatibility.
     /// @dev Defaults to `_toBytes32(address(this))`, assuming deterministic cross-chain deployment via CREATE2. The
     /// deployer (`JBSuckerDeployer`) uses `salt = keccak256(abi.encodePacked(_msgSender(), salt))` to ensure

package/src/JBSuckerRegistry.sol

@@ -11,7 +11,7 @@ import {ERC2771Context} from "@openzeppelin/contracts/metatx/ERC2771Context.sol"
 import {Context} from "@openzeppelin/contracts/utils/Context.sol";
 import {EnumerableMap} from "@openzeppelin/contracts/utils/structs/EnumerableMap.sol";
 
-import {JBDenominatedAmount} from "./structs/JBDenominatedAmount.sol";
+import {JBPeerChainValue} from "./structs/JBPeerChainValue.sol";
 import {JBSuckerState} from "./enums/JBSuckerState.sol";
 import {IJBSucker} from "./interfaces/IJBSucker.sol";
 import {IJBSuckerDeployer} from "./interfaces/IJBSuckerDeployer.sol";
@@ -231,16 +231,12 @@ contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerR
             (, 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: decimals, currency: currency}) returns (
-                    JBDenominatedAmount memory amt
+                // One call returns the value, peer chain ID, and snapshot freshness key together.
+                try IJBSucker(allSuckers[i]).peerChainBalanceValueOf({decimals: decimals, currency: currency}) returns (
+                    JBPeerChainValue memory read
                 ) {
-                    uint256 chainId = _peerChainIdOf(IJBSucker(allSuckers[i]));
-                    scratch.chainCount = _recordPeerValue({
-                        scratch: scratch,
-                        chainId: chainId,
-                        value: amt.value,
-                        snapshotTimestamp: _snapshotTimestampOf(allSuckers[i]),
-                        isActive: val == _SUCKER_EXISTS
+                    scratch.chainCount = _recordPeerChainValue({
+                        scratch: scratch, read: read, sucker: allSuckers[i], isActive: val == _SUCKER_EXISTS
                     });
                 } catch {}
             }
@@ -287,16 +283,12 @@ contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerR
             (, 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: decimals, currency: currency}) returns (
-                    JBDenominatedAmount memory amt
+                // One call returns the value, peer chain ID, and snapshot freshness key together.
+                try IJBSucker(allSuckers[i]).peerChainSurplusValueOf({decimals: decimals, currency: currency}) returns (
+                    JBPeerChainValue memory read
                 ) {
-                    uint256 chainId = _peerChainIdOf(IJBSucker(allSuckers[i]));
-                    scratch.chainCount = _recordPeerValue({
-                        scratch: scratch,
-                        chainId: chainId,
-                        value: amt.value,
-                        snapshotTimestamp: _snapshotTimestampOf(allSuckers[i]),
-                        isActive: val == _SUCKER_EXISTS
+                    scratch.chainCount = _recordPeerChainValue({
+                        scratch: scratch, read: read, sucker: allSuckers[i], isActive: val == _SUCKER_EXISTS
                     });
                 } catch {}
             }
@@ -332,14 +324,10 @@ contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerR
             (, 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]).peerChainTotalSupply() returns (uint256 supply) {
-                    uint256 chainId = _peerChainIdOf(IJBSucker(allSuckers[i]));
-                    scratch.chainCount = _recordPeerValue({
-                        scratch: scratch,
-                        chainId: chainId,
-                        value: supply,
-                        snapshotTimestamp: _snapshotTimestampOf(allSuckers[i]),
-                        isActive: val == _SUCKER_EXISTS
+                // One call returns the value, peer chain ID, and snapshot freshness key together.
+                try IJBSucker(allSuckers[i]).peerChainTotalSupplyValue() returns (JBPeerChainValue memory read) {
+                    scratch.chainCount = _recordPeerChainValue({
+                        scratch: scratch, read: read, sucker: allSuckers[i], isActive: val == _SUCKER_EXISTS
                     });
                 } catch {}
             }
@@ -459,16 +447,34 @@ contract JBSuckerRegistry is ERC2771Context, Ownable, JBPermissioned, IJBSuckerR
         }
     }
 
-    /// @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 {}
+    /// @notice Records a combined peer-chain read (value, peer chain ID, snapshot freshness key) from one sucker.
+    /// @dev A wrapper over `_recordPeerValue` that unpacks the single-call `JBPeerChainValue` read and enforces the
+    /// same non-zero peer-chain requirement the registry applies everywhere else. The peer-chain check reverts here
+    /// (inside the caller's `try` success body, so the revert propagates) to preserve the prior behavior where a
+    /// sucker reporting a zero peer chain ID fails the whole aggregate view.
+    /// @param scratch The per-chain aggregate values and freshness keys recorded so far.
+    /// @param read The combined value, peer chain ID, and snapshot freshness key returned by the sucker.
+    /// @param sucker The sucker the read came from, used only for the zero-peer-chain error.
+    /// @param isActive Whether the value came from an active sucker.
+    /// @return The updated number of populated chain entries.
+    function _recordPeerChainValue(
+        PeerValueScratch memory scratch,
+        JBPeerChainValue memory read,
+        address sucker,
+        bool isActive
+    )
+        internal
+        pure
+        returns (uint256)
+    {
+        if (read.peerChainId == 0) revert JBSuckerRegistry_ZeroPeerChainId({sucker: sucker});
+        return _recordPeerValue({
+            scratch: scratch,
+            chainId: read.peerChainId,
+            value: read.value,
+            snapshotTimestamp: read.snapshotTimestamp,
+            isActive: isActive
+        });
     }
 
     //*********************************************************************//

package/src/interfaces/IJBSucker.sol

@@ -9,6 +9,7 @@ import {JBClaim} from "../structs/JBClaim.sol";
 import {JBDenominatedAmount} from "../structs/JBDenominatedAmount.sol";
 import {JBInboxTreeRoot} from "../structs/JBInboxTreeRoot.sol";
 import {JBOutboxTree} from "../structs/JBOutboxTree.sol";
+import {JBPeerChainValue} from "../structs/JBPeerChainValue.sol";
 import {JBRemoteToken} from "../structs/JBRemoteToken.sol";
 import {JBSuckerState} from "../enums/JBSuckerState.sol";
 import {JBTokenMapping} from "../structs/JBTokenMapping.sol";
@@ -160,6 +161,14 @@ interface IJBSucker is IERC165 {
     /// @return A `JBDenominatedAmount` with the converted value.
     function peerChainBalanceOf(uint256 decimals, uint256 currency) external view returns (JBDenominatedAmount memory);
 
+    /// @notice The peer chain balance bundled with the peer chain ID and snapshot freshness key.
+    /// @dev Lets aggregators read the value, the peer chain it belongs to, and its freshness in one call. The
+    /// `value` matches `peerChainBalanceOf`.
+    /// @param decimals The decimal precision for the returned value.
+    /// @param currency The currency to normalize to.
+    /// @return A `JBPeerChainValue` with the converted balance, peer chain ID, and snapshot freshness key.
+    function peerChainBalanceValueOf(uint256 decimals, uint256 currency) external view returns (JBPeerChainValue memory);
+
     /// @notice The aggregate peer chain surplus, normalized to a desired currency and decimal precision using JBPrices.
     /// @dev The surplus is stored as ETH-denominated (18 decimals) and converted to the requested currency/decimals
     /// using the local JBPrices oracle.
@@ -168,12 +177,26 @@ interface IJBSucker is IERC165 {
     /// @return A `JBDenominatedAmount` with the converted value.
     function peerChainSurplusOf(uint256 decimals, uint256 currency) external view returns (JBDenominatedAmount memory);
 
+    /// @notice The peer chain surplus bundled with the peer chain ID and snapshot freshness key.
+    /// @dev Lets aggregators read the value, the peer chain it belongs to, and its freshness in one call. The
+    /// `value` matches `peerChainSurplusOf`.
+    /// @param decimals The decimal precision for the returned value.
+    /// @param currency The currency to normalize to.
+    /// @return A `JBPeerChainValue` with the converted surplus, peer chain ID, and snapshot freshness key.
+    function peerChainSurplusValueOf(uint256 decimals, uint256 currency) external view returns (JBPeerChainValue memory);
+
     /// @notice The last known total token supply on the peer chain, updated each time a bridge message is received.
     /// @dev Used by data hooks to compute `effectiveTotalSupply = localSupply + sum(peerChainTotalSupply)` across all
     /// suckers, preventing cash out tax bypass on chains where a holder dominates the local supply.
     /// @return The peer chain's total supply.
     function peerChainTotalSupply() external view returns (uint256);
 
+    /// @notice The peer chain total supply bundled with the peer chain ID and snapshot freshness key.
+    /// @dev Lets aggregators read the value, the peer chain it belongs to, and its freshness in one call. The
+    /// `value` matches `peerChainTotalSupply`.
+    /// @return A `JBPeerChainValue` with the total supply, peer chain ID, and snapshot freshness key.
+    function peerChainTotalSupplyValue() external view returns (JBPeerChainValue memory);
+
     /// @notice The ID of the project on the local chain that this sucker is associated with.
     /// @return The project ID.
     function projectId() external view returns (uint256);

package/src/structs/JBPeerChainValue.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @notice A single peer-chain aggregate read bundled with the keys the registry needs to dedupe and rank it.
+/// @dev Returned by the sucker's combined peer-chain views so the registry can read the value, the peer chain it
+/// belongs to, and its snapshot freshness in one call instead of three separate staticcalls.
+/// @custom:member value The requested peer-chain amount (balance, surplus, or total supply), already converted to the
+/// caller's currency and decimals where applicable.
+/// @custom:member peerChainId The chain ID of the remote peer this snapshot describes.
+/// @custom:member snapshotTimestamp The freshness key of the snapshot the value came from.
+struct JBPeerChainValue {
+    uint256 value;
+    uint256 peerChainId;
+    uint256 snapshotTimestamp;
+}