@bananapus/suckers-v6 0.0.5 → 0.0.6

package/SKILLS.md

@@ -31,7 +31,7 @@ Cross-chain token and fund bridging for Juicebox V6 projects, using merkle trees
 | `claim(claimData)` | `JBSucker` | Verifies a merkle proof against the inbox tree, marks the leaf as executed (prevents double-spend), mints project tokens for the beneficiary via `IJBController.mintTokensOf` (with `useReservedPercent: false`), and optionally adds terminal tokens to the project's balance if `ADD_TO_BALANCE_MODE == ON_CLAIM`. |
 | `claim(claims[])` | `JBSucker` | Batch version -- iterates and calls `claim(JBClaim)` for each. |
 | `mapToken(map)` | `JBSucker` | Maps a local terminal token to a remote token. Requires `MAP_SUCKER_TOKEN` permission. Setting `remoteToken` to `bytes32(0)` disables bridging and sends a final root to flush remaining outbox. Cannot remap to a different remote token once outbox has entries (prevents double-spend). Can re-enable a previously disabled token to the same remote address. Reverts if emergency hatch is active for the token. |
-| `mapTokens(maps[])` | `JBSucker` | Batch version of `mapToken`. Splits `msg.value` evenly across mappings that need a final root flush (disable with pending outbox entries). |
+| `mapTokens(maps[])` | `JBSucker` | Batch version of `mapToken`. Splits `msg.value` evenly across mappings that need a final root flush (disable with pending outbox entries). Refunds any remainder (dust) from integer division back to the caller on a best-effort basis (L-47). |
 | `addOutstandingAmountToBalance(token)` | `JBSucker` | Manually adds received terminal tokens to the project's balance via the primary terminal's `addToBalanceOf`. Only callable when `ADD_TO_BALANCE_MODE == MANUAL`. |
 | `enableEmergencyHatchFor(tokens)` | `JBSucker` | Opens emergency hatch for specified tokens (irreversible). Sets `emergencyHatch = true` and `enabled = false` on each token's `JBRemoteToken`. Requires `SUCKER_SAFETY` permission from the project owner. |
 | `exitThroughEmergencyHatch(claimData)` | `JBSucker` | Lets users reclaim tokens on the chain they deposited, using their **outbox** proof (not inbox). Only works when emergency hatch is open for the token OR sucker is `SENDING_DISABLED`/`DEPRECATED`. Only allows exit for leaves with index >= `numberOfClaimsSent` (leaves not yet sent to remote). Decreases `outbox.balance`. Uses a separate execution bitmap slot (derived from `keccak256(abi.encode(terminalToken))`) to avoid collision with inbox claim tracking. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/suckers-v6",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -19,8 +19,8 @@
   },
   "dependencies": {
     "@arbitrum/nitro-contracts": "github:OffchainLabs/nitro-contracts",
-    "@bananapus/core-v6": "^0.0.5",
-    "@bananapus/permission-ids-v6": "^0.0.3",
+    "@bananapus/core-v6": "^0.0.9",
+    "@bananapus/permission-ids-v6": "^0.0.4",
     "@chainlink/contracts-ccip": "^1.5.0",
     "@chainlink/local": "github:smartcontractkit/chainlink-local",
     "@openzeppelin/contracts": "^5.2.0",
@@ -28,6 +28,6 @@
     "solady": "^0.1.8"
   },
   "devDependencies": {
-    "@sphinx-labs/plugins": "^0.33.1"
+    "@sphinx-labs/plugins": "^0.33.2"
   }
 }

package/src/JBSucker.sol

@@ -491,6 +491,16 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
             // slither-disable-next-line msg-value-loop
             _mapToken({map: maps[i], transportPaymentValue: numberToDisable > 0 ? msg.value / numberToDisable : 0});
         }
+
+        // Refund any remainder from integer division so dust wei isn't stuck in the contract.
+        if (numberToDisable > 0) {
+            uint256 remainder = msg.value % numberToDisable;
+            if (remainder > 0) {
+                // Best-effort refund — don't revert if caller can't accept ETH.
+                // slither-disable-next-line low-level-calls,unchecked-lowlevel
+                _msgSender().call{value: remainder}("");
+            }
+        }
     }
 
     /// @notice Enables the emergency hatch for a list of tokens, allowing users to exit on the chain they deposited on.

package/test/regression/L47_MapTokensDust.t.sol

@@ -0,0 +1,242 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import "forge-std/Test.sol";
+
+import "../../src/JBSucker.sol";
+import {LibClone} from "solady/src/utils/LibClone.sol";
+import {MerkleLib} from "../../src/utils/MerkleLib.sol";
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+
+/// @notice Regression test for L-47: mapTokens msg.value dust from integer division.
+/// When `msg.value / numberToDisable` has a remainder, the dust wei must be refunded to the caller.
+contract L47_MapTokensDustTest is Test {
+    address constant DIRECTORY = address(600);
+    address constant PERMISSIONS = address(800);
+    address constant TOKENS = address(700);
+    address constant CONTROLLER = address(900);
+    address constant PROJECT = address(1000);
+    address constant FORWARDER = address(1100);
+
+    address tokenA = makeAddr("tokenA");
+    address tokenB = makeAddr("tokenB");
+    address tokenC = makeAddr("tokenC");
+
+    bytes32 remoteA = bytes32(uint256(1));
+    bytes32 remoteB = bytes32(uint256(2));
+    bytes32 remoteC = bytes32(uint256(3));
+
+    uint256 projectId = 1;
+
+    function setUp() public {
+        vm.label(DIRECTORY, "MOCK_DIRECTORY");
+        vm.label(PERMISSIONS, "MOCK_PERMISSIONS");
+        vm.label(TOKENS, "MOCK_TOKENS");
+        vm.label(CONTROLLER, "MOCK_CONTROLLER");
+        vm.label(PROJECT, "MOCK_PROJECT");
+
+        // Mock DIRECTORY.PROJECTS() and ownerOf for all tests.
+        vm.mockCall(DIRECTORY, abi.encodeCall(IJBDirectory.PROJECTS, ()), abi.encode(PROJECT));
+        vm.mockCall(PROJECT, abi.encodeCall(IERC721.ownerOf, (projectId)), abi.encode(address(this)));
+
+        // Allow any caller to pass the MAP_SUCKER_TOKEN permission check.
+        vm.mockCall(PERMISSIONS, abi.encodeWithSelector(IJBPermissions.hasPermission.selector), abi.encode(true));
+    }
+
+    /// @notice When mapTokens disables multiple tokens and msg.value is not evenly divisible,
+    ///         the remainder (dust) must be refunded to the caller.
+    function test_mapTokensDustRefunded() external {
+        L47TestSucker sucker = _createTestSucker(projectId, "");
+
+        // Set up two tokens that are currently mapped and have unsent outbox entries,
+        // so disabling them (remoteToken=0) triggers _sendRoot which needs transport payment.
+
+        // Token A: mapped with unsent claims (tree.count=1, numberOfClaimsSent=0).
+        sucker.test_setRemoteToken(
+            tokenA,
+            JBRemoteToken({enabled: true, emergencyHatch: false, minGas: 200_000, addr: remoteA, minBridgeAmount: 0})
+        );
+        sucker.test_setOutboxTreeCount(tokenA, 1);
+        // numberOfClaimsSent defaults to 0, so 0 != 1 means this token will be counted.
+
+        // Token B: mapped with unsent claims.
+        sucker.test_setRemoteToken(
+            tokenB,
+            JBRemoteToken({enabled: true, emergencyHatch: false, minGas: 200_000, addr: remoteB, minBridgeAmount: 0})
+        );
+        sucker.test_setOutboxTreeCount(tokenB, 1);
+
+        // Token C: mapped with unsent claims.
+        sucker.test_setRemoteToken(
+            tokenC,
+            JBRemoteToken({enabled: true, emergencyHatch: false, minGas: 200_000, addr: remoteC, minBridgeAmount: 0})
+        );
+        sucker.test_setOutboxTreeCount(tokenC, 1);
+
+        // Build maps to disable all three tokens (remoteToken = 0).
+        JBTokenMapping[] memory maps = new JBTokenMapping[](3);
+        maps[0] = JBTokenMapping({localToken: tokenA, minGas: 200_000, remoteToken: bytes32(0), minBridgeAmount: 0});
+        maps[1] = JBTokenMapping({localToken: tokenB, minGas: 200_000, remoteToken: bytes32(0), minBridgeAmount: 0});
+        maps[2] = JBTokenMapping({localToken: tokenC, minGas: 200_000, remoteToken: bytes32(0), minBridgeAmount: 0});
+
+        // Send 10 wei with 3 tokens to disable: 10 / 3 = 3 each, remainder = 1 wei.
+        uint256 msgValue = 10;
+        uint256 expectedRemainder = msgValue % 3; // 1 wei
+
+        address caller = makeAddr("caller");
+        vm.deal(caller, msgValue);
+
+        uint256 callerBalanceBefore = caller.balance;
+
+        vm.prank(caller);
+        sucker.mapTokens{value: msgValue}(maps);
+
+        uint256 callerBalanceAfter = caller.balance;
+
+        // The caller should have received the 1 wei remainder back.
+        assertEq(callerBalanceAfter, callerBalanceBefore - msgValue + expectedRemainder, "Dust remainder not refunded");
+    }
+
+    /// @notice When msg.value is evenly divisible, no refund is needed and nothing reverts.
+    function test_mapTokensNoDustWhenEvenlyDivisible() external {
+        L47TestSucker sucker = _createTestSucker(projectId, "");
+
+        sucker.test_setRemoteToken(
+            tokenA,
+            JBRemoteToken({enabled: true, emergencyHatch: false, minGas: 200_000, addr: remoteA, minBridgeAmount: 0})
+        );
+        sucker.test_setOutboxTreeCount(tokenA, 1);
+
+        sucker.test_setRemoteToken(
+            tokenB,
+            JBRemoteToken({enabled: true, emergencyHatch: false, minGas: 200_000, addr: remoteB, minBridgeAmount: 0})
+        );
+        sucker.test_setOutboxTreeCount(tokenB, 1);
+
+        JBTokenMapping[] memory maps = new JBTokenMapping[](2);
+        maps[0] = JBTokenMapping({localToken: tokenA, minGas: 200_000, remoteToken: bytes32(0), minBridgeAmount: 0});
+        maps[1] = JBTokenMapping({localToken: tokenB, minGas: 200_000, remoteToken: bytes32(0), minBridgeAmount: 0});
+
+        // 10 / 2 = 5 each, no remainder.
+        uint256 msgValue = 10;
+
+        address caller = makeAddr("caller");
+        vm.deal(caller, msgValue);
+
+        uint256 callerBalanceBefore = caller.balance;
+
+        vm.prank(caller);
+        sucker.mapTokens{value: msgValue}(maps);
+
+        uint256 callerBalanceAfter = caller.balance;
+
+        // No remainder, so caller balance should just decrease by msgValue.
+        assertEq(callerBalanceAfter, callerBalanceBefore - msgValue, "Balance should decrease by exact msgValue");
+    }
+
+    /// @notice Fuzz test: for any msg.value and any numberToDisable (1-10), dust is always refunded.
+    function test_mapTokensDustFuzz(uint256 msgValue) external {
+        // Bound to avoid overflow and keep test tractable. Use 3 tokens to disable.
+        msgValue = bound(msgValue, 0, 10 ether);
+        uint256 numberToDisable = 3;
+        uint256 expectedRemainder = msgValue % numberToDisable;
+
+        L47TestSucker sucker = _createTestSucker(projectId, "fuzz");
+
+        sucker.test_setRemoteToken(
+            tokenA,
+            JBRemoteToken({enabled: true, emergencyHatch: false, minGas: 200_000, addr: remoteA, minBridgeAmount: 0})
+        );
+        sucker.test_setOutboxTreeCount(tokenA, 1);
+
+        sucker.test_setRemoteToken(
+            tokenB,
+            JBRemoteToken({enabled: true, emergencyHatch: false, minGas: 200_000, addr: remoteB, minBridgeAmount: 0})
+        );
+        sucker.test_setOutboxTreeCount(tokenB, 1);
+
+        sucker.test_setRemoteToken(
+            tokenC,
+            JBRemoteToken({enabled: true, emergencyHatch: false, minGas: 200_000, addr: remoteC, minBridgeAmount: 0})
+        );
+        sucker.test_setOutboxTreeCount(tokenC, 1);
+
+        JBTokenMapping[] memory maps = new JBTokenMapping[](3);
+        maps[0] = JBTokenMapping({localToken: tokenA, minGas: 200_000, remoteToken: bytes32(0), minBridgeAmount: 0});
+        maps[1] = JBTokenMapping({localToken: tokenB, minGas: 200_000, remoteToken: bytes32(0), minBridgeAmount: 0});
+        maps[2] = JBTokenMapping({localToken: tokenC, minGas: 200_000, remoteToken: bytes32(0), minBridgeAmount: 0});
+
+        address caller = makeAddr("caller");
+        vm.deal(caller, msgValue);
+
+        uint256 callerBalanceBefore = caller.balance;
+
+        vm.prank(caller);
+        sucker.mapTokens{value: msgValue}(maps);
+
+        uint256 callerBalanceAfter = caller.balance;
+
+        assertEq(
+            callerBalanceAfter, callerBalanceBefore - msgValue + expectedRemainder, "Dust remainder not refunded (fuzz)"
+        );
+    }
+
+    function _createTestSucker(uint256 _projectId, bytes32 salt) internal returns (L47TestSucker) {
+        L47TestSucker singleton = new L47TestSucker(
+            IJBDirectory(DIRECTORY),
+            IJBPermissions(PERMISSIONS),
+            IJBTokens(TOKENS),
+            JBAddToBalanceMode.MANUAL,
+            FORWARDER
+        );
+        vm.label(address(singleton), "SUCKER_SINGLETON");
+
+        L47TestSucker sucker = L47TestSucker(payable(address(LibClone.cloneDeterministic(address(singleton), salt))));
+        vm.label(address(sucker), "SUCKER");
+        sucker.initialize(_projectId);
+
+        return sucker;
+    }
+}
+
+contract L47TestSucker is JBSucker {
+    constructor(
+        IJBDirectory directory,
+        IJBPermissions permissions,
+        IJBTokens tokens,
+        JBAddToBalanceMode addToBalanceMode,
+        address forwarder
+    )
+        JBSucker(directory, permissions, tokens, addToBalanceMode, forwarder)
+    {}
+
+    function _sendRootOverAMB(
+        uint256,
+        uint256,
+        address,
+        uint256,
+        JBRemoteToken memory,
+        JBMessageRoot memory
+    )
+        internal
+        override
+    {}
+
+    function _isRemotePeer(address sender) internal view override returns (bool valid) {
+        return sender == _toAddress(peer());
+    }
+
+    function peerChainId() external view virtual override returns (uint256) {
+        return block.chainid;
+    }
+
+    /// @notice Set the remote token mapping for testing.
+    function test_setRemoteToken(address localToken, JBRemoteToken memory remoteToken) external {
+        _remoteTokenFor[localToken] = remoteToken;
+    }
+
+    /// @notice Set the outbox tree count for testing (simulates unsent claims).
+    function test_setOutboxTreeCount(address token, uint256 count) external {
+        _outboxOf[token].tree.count = count;
+    }
+}