burn collector split

tac0turtle · tac0turtle · commit c5f845ff18c7 · 2025-11-19T15:14:52.000+01:00
diff --git a/contracts/src/BurnCollector.sol b/contracts/src/BurnCollector.sol
@@ -18,11 +18,18 @@ contract BurnCollector {
     uint256 public minimumAmount;
     uint256 public callFee;
 
+    // Split accounting
+    uint256 public otherBucketBalance;
+    uint256 public burnShareBps; // Basis points (0-10000) for burn share
+
     event SentToCelestia(uint256 amount, bytes32 recipient, bytes32 messageId);
     event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
     event RecipientUpdated(uint32 destinationDomain, bytes32 recipientAddress);
     event MinimumAmountUpdated(uint256 minimumAmount);
     event CallFeeUpdated(uint256 callFee);
+    event BurnShareUpdated(uint256 burnShareBps);
+    event OtherWithdrawn(address indexed recipient, uint256 amount);
+    event FundsSplit(uint256 totalNew, uint256 burnAmount, uint256 otherAmount);
 
     modifier onlyOwner() {
         require(msg.sender == owner, "BurnCollector: caller is not the owner");
@@ -32,6 +39,7 @@ contract BurnCollector {
     constructor(address _hypNativeMinter, address _owner) {
         hypNativeMinter = IHypNativeMinter(_hypNativeMinter);
         owner = _owner;
+        burnShareBps = 10000; // Default to 100% burn
         emit OwnershipTransferred(address(0), _owner);
     }
 
@@ -40,16 +48,31 @@ contract BurnCollector {
     function sendToCelestia() external payable {
         require(msg.value >= callFee, "BurnCollector: insufficient fee");
         
-        uint256 balance = address(this).balance;
-        require(balance >= minimumAmount, "BurnCollector: minimum amount not met");
+        // Calculate new funds available for splitting
+        // Total Balance - Already Allocated to Other Bucket
+        uint256 currentBalance = address(this).balance;
+        require(currentBalance >= otherBucketBalance, "BurnCollector: accounting error");
+        
+        uint256 newFunds = currentBalance - otherBucketBalance;
+        
+        // Calculate split
+        uint256 burnAmount = (newFunds * burnShareBps) / 10000;
+        uint256 otherAmount = newFunds - burnAmount;
 
-        bytes32 messageId = hypNativeMinter.transferRemote{value: balance}(
+        require(burnAmount >= minimumAmount, "BurnCollector: minimum amount not met");
+
+        // Update accounting
+        otherBucketBalance += otherAmount;
+        emit FundsSplit(newFunds, burnAmount, otherAmount);
+
+        // Bridge the burn amount
+        bytes32 messageId = hypNativeMinter.transferRemote{value: burnAmount}(
             destinationDomain,
             recipientAddress,
-            balance
+            burnAmount
         );
 
-        emit SentToCelestia(balance, recipientAddress, messageId);
+        emit SentToCelestia(burnAmount, recipientAddress, messageId);
     }
 
     // Admin functions
@@ -75,4 +98,20 @@ contract BurnCollector {
         callFee = _callFee;
         emit CallFeeUpdated(_callFee);
     }
+
+    function setBurnShare(uint256 _burnShareBps) external onlyOwner {
+        require(_burnShareBps <= 10000, "BurnCollector: invalid bps");
+        burnShareBps = _burnShareBps;
+        emit BurnShareUpdated(_burnShareBps);
+    }
+
+    function withdrawOther(address payable _recipient, uint256 _amount) external onlyOwner {
+        require(_amount <= otherBucketBalance, "BurnCollector: insufficient other balance");
+        otherBucketBalance -= _amount;
+        
+        (bool success, ) = _recipient.call{value: _amount}("");
+        require(success, "BurnCollector: transfer failed");
+        
+        emit OtherWithdrawn(_recipient, _amount);
+    }
 }
diff --git a/contracts/test/BurnCollector.t.sol b/contracts/test/BurnCollector.t.sol
@@ -39,6 +39,7 @@ contract BurnCollectorTest is Test {
         burnCollector.setRecipient(destination, recipient);
         burnCollector.setMinimumAmount(minAmount);
         burnCollector.setCallFee(fee);
+        // Default burn share is 10000 (100%)
     }
 
     function test_Receive() public {
@@ -48,108 +49,139 @@ contract BurnCollectorTest is Test {
         assertEq(address(burnCollector).balance, amount, "Balance mismatch");
     }
 
-    function test_SendToCelestia() public {
-        // Fund the collector with enough to meet minAmount (excluding fee which is added on top)
-        // Actually, the check is address(this).balance >= minAmount.
-        // If we send fee, it adds to balance.
-        // Let's fund it with minAmount first.
+    function test_SendToCelestia_100PercentBurn() public {
+        // Fund with minAmount
         (bool success, ) = address(burnCollector).call{value: minAmount}("");
-        require(success, "Funding failed");
+        require(success);
 
-        // Expect the call to the mock minter
-        // Total sent = existing balance (minAmount) + fee sent in call
         uint256 totalAmount = minAmount + fee;
 
         vm.expectEmit(true, true, true, true, address(mockMinter));
         emit MockHypNativeMinter.TransferRemoteCalled(destination, recipient, totalAmount);
 
-        // Expect the event from BurnCollector
-        vm.expectEmit(true, true, true, true, address(burnCollector));
-        emit BurnCollector.SentToCelestia(totalAmount, recipient, bytes32(uint256(1)));
-
-        // Call as user with fee
         vm.prank(user);
         vm.deal(user, fee);
         burnCollector.sendToCelestia{value: fee}();
 
         assertEq(address(burnCollector).balance, 0, "Collector should be empty");
-        assertEq(address(mockMinter).balance, totalAmount, "Minter should have received funds");
+        assertEq(burnCollector.otherBucketBalance(), 0, "Other bucket should be empty");
     }
 
-    function test_SendToCelestia_InsufficientFee() public {
+    function test_SendToCelestia_Split5050() public {
+        // Set split to 50%
+        burnCollector.setBurnShare(5000);
+
+        // Fund with 2 ether. 
+        // Fee is 0.1 ether.
+        // Total new funds = 2.1 ether.
+        // Burn = 1.05 ether. Other = 1.05 ether.
+        // Min amount is 1 ether, so 1.05 >= 1.0 is OK.
+        uint256 fundAmount = 2 ether;
+        (bool success, ) = address(burnCollector).call{value: fundAmount}("");
+        require(success);
+
+        uint256 totalNew = fundAmount + fee;
+        uint256 expectedBurn = totalNew / 2;
+        uint256 expectedOther = totalNew - expectedBurn;
+
+        vm.expectEmit(true, true, true, true, address(mockMinter));
+        emit MockHypNativeMinter.TransferRemoteCalled(destination, recipient, expectedBurn);
+
         vm.prank(user);
         vm.deal(user, fee);
-        // Send less than fee
-        vm.expectRevert("BurnCollector: insufficient fee");
-        burnCollector.sendToCelestia{value: fee - 1}();
+        burnCollector.sendToCelestia{value: fee}();
+
+        assertEq(address(burnCollector).balance, expectedOther, "Collector should hold other funds");
+        assertEq(burnCollector.otherBucketBalance(), expectedOther, "Other bucket accounting incorrect");
     }
 
-    function test_SendToCelestia_BelowMinAmount() public {
-        // Fund with less than minAmount
-        uint256 amount = minAmount - 0.5 ether;
-        (bool success, ) = address(burnCollector).call{value: amount}("");
-        require(success, "Funding failed");
+    function test_SendToCelestia_AccumulateOther() public {
+        burnCollector.setBurnShare(5000); // 50%
 
-        // Even with fee, if logic checks total balance, we need to be careful.
-        // Logic: require(address(this).balance >= minimumAmount)
-        // If we send fee, balance increases.
-        // Let's assume we want to test when TOTAL balance is still low.
-        // If minAmount is 1 ether. Funding is 0.5. Fee is 0.1. Total 0.6 < 1.0.
+        // First call: 2 ether + 0.1 fee = 2.1 total. 1.05 burn, 1.05 other.
+        (bool success, ) = address(burnCollector).call{value: 2 ether}("");
+        require(success);
         
-        // Reset to clean state for clarity
-        burnCollector = new BurnCollector(address(mockMinter), owner);
-        burnCollector.setRecipient(destination, recipient);
-        burnCollector.setMinimumAmount(1 ether);
-        burnCollector.setCallFee(0.1 ether);
+        vm.prank(user);
+        vm.deal(user, fee);
+        burnCollector.sendToCelestia{value: fee}();
+
+        uint256 firstOther = 1.05 ether;
+        assertEq(burnCollector.otherBucketBalance(), firstOther);
 
-        (success, ) = address(burnCollector).call{value: 0.5 ether}("");
+        // Second call: 2 ether + 0.1 fee = 2.1 total NEW funds.
+        // Previous balance: 1.05. New balance before split: 1.05 + 2.1 = 3.15.
+        // Logic: newFunds = balance (3.15) - otherBucket (1.05) = 2.1. Correct.
+        (success, ) = address(burnCollector).call{value: 2 ether}("");
         require(success);
 
         vm.prank(user);
-        vm.deal(user, 1 ether);
-        vm.expectRevert("BurnCollector: minimum amount not met");
-        burnCollector.sendToCelestia{value: 0.1 ether}();
-    }
+        vm.deal(user, fee);
+        burnCollector.sendToCelestia{value: fee}();
 
-    function test_AdminFunctions() public {
-        // Test setRecipient
-        burnCollector.setRecipient(5678, bytes32(uint256(0xbeef)));
-        assertEq(burnCollector.destinationDomain(), 5678);
-        assertEq(burnCollector.recipientAddress(), bytes32(uint256(0xbeef)));
-
-        // Test setMinimumAmount
-        burnCollector.setMinimumAmount(5 ether);
-        assertEq(burnCollector.minimumAmount(), 5 ether);
-
-        // Test setCallFee
-        burnCollector.setCallFee(1 ether);
-        assertEq(burnCollector.callFee(), 1 ether);
-
-        // Test transferOwnership
-        address newOwner = address(0x2);
-        burnCollector.transferOwnership(newOwner);
-        assertEq(burnCollector.owner(), newOwner);
-
-        // Old owner cannot call anymore
-        vm.expectRevert("BurnCollector: caller is not the owner");
-        burnCollector.setCallFee(2 ether);
+        uint256 secondOther = 1.05 ether;
+        assertEq(burnCollector.otherBucketBalance(), firstOther + secondOther);
+        assertEq(address(burnCollector).balance, firstOther + secondOther);
     }
 
-    function test_AdminAccessControl() public {
-        vm.prank(user);
-        vm.expectRevert("BurnCollector: caller is not the owner");
-        burnCollector.setRecipient(1, bytes32(0));
+    function test_WithdrawOther() public {
+        burnCollector.setBurnShare(5000);
+        (bool success, ) = address(burnCollector).call{value: 2 ether}("");
+        require(success);
 
         vm.prank(user);
-        vm.expectRevert("BurnCollector: caller is not the owner");
-        burnCollector.setMinimumAmount(1);
+        vm.deal(user, fee);
+        burnCollector.sendToCelestia{value: fee}();
+
+        uint256 otherAmount = 1.05 ether;
+        assertEq(burnCollector.otherBucketBalance(), otherAmount);
+
+        // Withdraw half
+        uint256 withdrawAmount = 0.5 ether;
+        address payable recipientAddr = payable(address(0x99));
+        
+        burnCollector.withdrawOther(recipientAddr, withdrawAmount);
+
+        assertEq(burnCollector.otherBucketBalance(), otherAmount - withdrawAmount);
+        assertEq(recipientAddr.balance, withdrawAmount);
+        assertEq(address(burnCollector).balance, otherAmount - withdrawAmount);
+    }
 
+    function test_WithdrawOther_Insufficient() public {
+        burnCollector.setBurnShare(5000);
+        (bool success, ) = address(burnCollector).call{value: 2 ether}("");
+        require(success);
+        
         vm.prank(user);
-        vm.expectRevert("BurnCollector: caller is not the owner");
-        burnCollector.setCallFee(1);
+        vm.deal(user, fee);
+        burnCollector.sendToCelestia{value: fee}();
+
+        uint256 otherAmount = 1.05 ether;
+        
+        vm.expectRevert("BurnCollector: insufficient other balance");
+        burnCollector.withdrawOther(payable(owner), otherAmount + 1);
+    }
+
+    function test_SendToCelestia_BelowMinAmount_AfterSplit() public {
+        burnCollector.setBurnShare(1000); // 10% burn
+        
+        // Fund with 2 ether. Total 2.1.
+        // Burn = 0.21. Other = 1.89.
+        // Min amount is 1.0. 0.21 < 1.0. Should revert.
+        (bool success, ) = address(burnCollector).call{value: 2 ether}("");
+        require(success);
 
         vm.prank(user);
-        vm.expectRevert("BurnCollector: caller is not the owner");
-        burnCollector.transferOwnership(user);
+        vm.deal(user, fee);
+        vm.expectRevert("BurnCollector: minimum amount not met");
+        burnCollector.sendToCelestia{value: fee}();
+    }
+
+    function test_AdminFunctions() public {
+        burnCollector.setBurnShare(5000);
+        assertEq(burnCollector.burnShareBps(), 5000);
+
+        vm.expectRevert("BurnCollector: invalid bps");
+        burnCollector.setBurnShare(10001);
     }
 }
