Kintsu

if (batchDepositRequest.assets > batchWithdrawRequest.assets) {            // Net ingress            uint96 bondedAmountEvm = _doBonding(batchDepositRequest.assets - batchWithdrawRequest.assets, _totalPooled);            uint96 dust = batchDepositRequest.assets - bondedAmountEvm;            if (dust > 0) {                batchDepositRequests[_currentBatchId + 1].assets = dust;            }            batchSubmission.unbondingThaw = _safeIncrease(batchSubmission.unbondingThaw, _cooldowns.unbondingFreezeFromBonding);        } else if (batchWithdrawRequest.assets > batchDepositRequest.assets) {            // Net egress            if (block.timestamp <= batchSubmission.unbondingThaw) revert UnbondingFreeze();            uint96 unbondedAmountEvm = _doUnbonding(batchWithdrawRequest.assets - batchDepositRequest.assets, _totalPooled);

if (batchDepositRequest.assets > batchWithdrawRequest.assets) {            // Net ingress-           uint96 bondedAmountEvm = _doBonding(batchDepositRequest.assets, _totalPooled);+           uint96 bondedAmountEvm = _doBonding(batchDepositRequest.assets - batchWithdrawRequest.assets, _totalPooled);            uint96 dust = batchDepositRequest.assets - bondedAmountEvm;            if (dust > 0) {                batchDepositRequests[_currentBatchId + 1].assets = dust;            }            batchSubmission.unbondingThaw = _safeIncrease(batchSubmission.unbondingThaw, _cooldowns.unbondingFreezeFromBonding);        } else if (batchWithdrawRequest.assets > batchDepositRequest.assets) {            // Net egress            if (block.timestamp <= batchSubmission.unbondingThaw) revert UnbondingFreeze();-           uint96 unbondedAmountEvm = _doUnbonding(batchWithdrawRequest.assets, _totalPooled);+           uint96 unbondedAmountEvm = _doUnbonding(batchWithdrawRequest.assets - batchDepositRequest.assets, _totalPooled);

function requestUnlock(uint96 shares) external whenNotPaused {        ExitFee memory _exitFee = exitFee; // shadow (SLOAD 1 slot)
        uint96 sharesToToll = uint96(uint256(shares) * _exitFee.bips / BIPS);        uint96 sharesToUser = uint96(uint256(shares) - sharesToToll);        if (sharesToUser == 0) revert NoChange();
        _updateFees();
        uint96 spotValue = convertToAssets(sharesToUser);        if (spotValue == 0) revert MinimumUnlock();
        uint40 _currentBatchId = currentBatchId; // shadow
        // Update user's unlock requests        userUnlockRequests[msg.sender].push(UnlockRequest({            shares: sharesToUser,            spotValue: spotValue,            batchId: _currentBatchId        }));
        // Update current batch        Batch memory _batchWithdrawRequest = batchWithdrawRequests[_currentBatchId]; // shadow (SLOAD 1 slot)        _batchWithdrawRequest.assets += spotValue;        _batchWithdrawRequest.shares += sharesToUser;        batchWithdrawRequests[_currentBatchId] = _batchWithdrawRequest;
        // Escrow toll        if (sharesToToll > 0) {            _exitFee.escrowShares += sharesToToll;            exitFee = _exitFee;        }
        // Escrow shares        token.transferFrom(msg.sender, address(this), sharesToUser);

function mintProtocolShares(address to) external whenNotPaused onlyRole(ROLE_FEE_CLAIMER) {        _updateFees();
        uint96 shares = managementFee.virtualSharesSnapshot + exitFee.escrowShares;        if (shares == 0) revert NoChange();
        managementFee.virtualSharesSnapshot = 0;        exitFee.escrowShares = 0;        token.mint(to, shares);

function test_depositDustAmount() public setRoles setNodesAndWeights {        vm.startPrank(user);        vault.deposit{value: 1 ether}(user);        vault.requestUnlock(1 ether - 1e10 + 1); // such that amountToBond is 0        vault.submitBatch();
        // check dust for current batch, it's 1 ether when it should be 1e10 - 1        (uint96 assets,) = vault.batchDepositRequests(1);        assertEq(assets, 1 ether);    }

- uint96 dust = batchDepositRequest.assets - bondedAmountEvm;+ uint96 dust = batchDepositRequest.assets - batchWithdrawalRequest.assets - bondedAmountEvm;

- uint96 dust = batchWithdrawRequest.assets - bondedAmountEvm;+ uint96 dust = batchWithdrawRequest.assets - batchDepositRequest.assets - bondedAmountEvm;

function _getImbalances(Node[] memory nodes, uint96 newTotalPooled)        private        view        returns (            uint96 overAllocation,            uint96 underAllocation,            uint96[] memory overAllocations,            uint96[] memory underAllocations        )    {        uint256 _totalWeight = Registry.totalWeight; // shadow
        uint256 len = nodes.length;        overAllocations = new uint96[](len);        underAllocations = new uint96[](len);
        for (uint256 i; i < len; ++i) {            uint256 stakedAmountCurrent = nodes[i].staked;            uint256 stakedAmountOptimal = _totalWeight > 0 ? uint256(nodes[i].weight) * uint256(newTotalPooled) / _totalWeight : 0;

function test_syncAfterDepositBeforeWithdraw() public setRoles setNodesAndWeights {        vm.startPrank(user);        vault.deposit{value: 1 ether}(user);        vault.submitBatch();                        // appreciate share price        writer.addStakingReward{value: 0.01 ether}(address(vault));                // may be advantageous to sync after calling deposit        uint96 sharesReceived = vault.deposit{value: 1 ether}(user);        uint96 sharesValue = vault.convertToAssets(sharesReceived);        vault.syncStaking();        uint96 newSharesValue = vault.convertToAssets(sharesReceived);        assertGt(newSharesValue, sharesValue);                        // likewise, for withdraw, may be advantageous to sync before calling withdraw        writer.addStakingReward{value: 0.01 ether}(address(vault));        uint96 sharesToWithdraw = 0.1 ether;        sharesValue = vault.convertToAssets(sharesToWithdraw);        vault.syncStaking();        newSharesValue = vault.convertToAssets(sharesToWithdraw);        assertGt(newSharesValue, sharesValue);}

function test_firstDepositorInflationAttack() public setRoles setNodesAndWeights {        address attacker = makeAddr("attacker");        vm.deal(attacker, 100 ether);
        vm.startPrank(attacker);        vault.deposit{value: 0.01 ether}(attacker);        sHype.approve(address(vault), type(uint256).max);        vault.requestUnlock(0.01 ether - 1);        vault.submitBatch();                // attacker deposits a large amount to inflate sHype share price        vault.contributeToPool{value: 90 ether}(attacker);
        // user deposits 1 ether, gets 0 shares        vm.startPrank(user);        uint96 actualShares = vault.deposit{value: 1 ether}(user);        assertEq(actualShares, 0);   }

function _doUnbonding(uint96 amount, uint96 _totalPooled) private returns (uint96 unbondSummationEvm) {        Node[] memory _nodes = Registry.nodes; // shadow (SLOAD 2n-nodes slots)        uint256 n = _nodes.length;        (uint96 overAllocation,, uint96[] memory overAllocations,) = _getImbalances(_nodes, _totalPooled - amount);
        // Amount to withdraw from over-allocated agents        uint256 phase1 = amount < overAllocation ? amount : overAllocation;
        // Remaining amount to withdraw equitably from all agents        uint256 phase2 = amount - phase1;

function test_exitFee() public setRoles setNodesAndWeights setExitFee {        vm.startPrank(user);        vault.deposit{value: 1 ether}(user);        uint256 userBalanceBefore = sHype.balanceOf(user);        vault.requestUnlock(0.1 ether);        // should have pulled the full share amount from the user        uint256 userBalanceAfterRequest = sHype.balanceOf(user);        assertEq(userBalanceAfterRequest, userBalanceBefore - 0.1 ether);        // escrowed shares should have increased        (uint40 bips, uint96 escrowedShares) = vault.exitFee();        assertEq(escrowedShares, 0.1 ether * bips / 10_000);        // as escrowed shares have already been minted, shouldn't affect mintableProtocolShares()        assertEq(vault.mintableProtocolShares(), 0);                        // if user cancels, will not be refunded exit fee        vault.cancelUnlockRequest(0);        uint256 userBalanceAfterCancel = sHype.balanceOf(user);        uint256 expectedRefundAmount = 0.1 ether - escrowedShares;        assertEq(userBalanceAfterCancel, userBalanceAfterRequest + expectedRefundAmount);                        vm.startPrank(privileged);        vault.mintProtocolShares(receiver);        // should have transferred escrowed shares to receiver        assertEq(sHype.balanceOf(receiver), escrowedShares);        assertEq(vault.mintableProtocolShares(), 0);        // escrowedShares should have been zeroed        (, escrowedShares) = vault.exitFee();        assertEq(escrowedShares, 0);}

function contributeToPool(address benefactor) external payable {        if (msg.value > type(uint96).max) revert DepositOverflow();        batchDepositRequests[currentBatchId].assets += uint96(msg.value);        emit Contribution(msg.value, benefactor);    }

function contributeToPool(address benefactor) external payable {        if (msg.value > type(uint96).max) revert DepositOverflow();+       totalPooled += uint96(msg.value);        batchDepositRequests[currentBatchId].assets += uint96(msg.value);        emit Contribution(msg.value, benefactor);    }