Merge pull request #532 from autonomys/add-treasury-contract

feat: add treasury contract

Author: jfrank-summit

packages/contracts/src/AutoDriveTreasury.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+
+contract AutoDriveTreasury is Ownable2Step, ReentrancyGuard {
+    // ExistentialDeposit deposit amount for Mainnet Auto-EVM
+    uint256 public minimumBalance = 1e12 wei;
+
+    event FundsWithdrawn(address indexed recipient, uint256 amount);
+    event MinimumBalanceUpdated(
+        uint256 oldMinimumBalance,
+        uint256 newMinimumBalance
+    );
+
+    error InsufficientBalance(uint256 balance, uint256 minimumRequired);
+    error InvalidRecipient(address recipient);
+    error InvalidMinimumBalance(uint256 minimumBalance);
+
+    constructor(address initialOwner) Ownable(initialOwner) {}
+
+    /**
+     * @notice Allows the owner to withdraw all funds leaving at least the minimum balance
+     * @param recipient The address to receive the withdrawn funds
+     */
+    function withdraw(address payable recipient) public onlyOwner nonReentrant {
+        if (recipient == address(0)) {
+            revert InvalidRecipient(recipient);
+        }
+
+        uint256 balance = address(this).balance;
+        if (balance <= minimumBalance) {
+            revert InsufficientBalance(balance, minimumBalance);
+        }
+
+        uint256 withdrawAmount = balance - minimumBalance;
+
+        Address.sendValue(recipient, withdrawAmount);
+        emit FundsWithdrawn(recipient, withdrawAmount);
+    }
+
+    /**
+     * @notice Allows the owner to update the minimum balance requirement
+     * @param newMinimumBalance The new minimum balance to maintain
+     */
+    function setMinimumBalance(uint256 newMinimumBalance) public onlyOwner {
+        if (newMinimumBalance > address(this).balance) {
+            revert InvalidMinimumBalance(newMinimumBalance);
+        }
+
+        uint256 oldMinimumBalance = minimumBalance;
+        minimumBalance = newMinimumBalance;
+        emit MinimumBalanceUpdated(oldMinimumBalance, newMinimumBalance);
+    }
+
+    /**
+     * @notice Allows the contract to receive ETH
+     */
+    receive() external payable {}
+}

packages/contracts/test/AutoDriveTreasury.t.sol

@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import {Test} from "forge-std/Test.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {AutoDriveTreasury} from "../src/AutoDriveTreasury.sol";
+
+contract AutoDriveTreasuryTest is Test {
+    AutoDriveTreasury public treasury;
+
+    function setUp() public {
+        treasury = new AutoDriveTreasury(address(this));
+    }
+
+    function testWithdrawSuccessLeavesMinimumBalance() public {
+        uint256 min = treasury.minimumBalance();
+        uint256 fundAmount = min + 3 ether;
+
+        // fund contract
+        (bool ok, ) = payable(address(treasury)).call{value: fundAmount}("");
+        assertTrue(ok);
+
+        address payable recipient = payable(address(0xB0B));
+        uint256 beforeRecipient = recipient.balance;
+
+        treasury.withdraw(recipient);
+
+        assertEq(address(treasury).balance, min);
+        assertEq(recipient.balance, beforeRecipient + (fundAmount - min));
+    }
+
+    function testWithdrawRevertsWhenBalanceLTEMinimum() public {
+        uint256 min = treasury.minimumBalance();
+
+        // fund to exactly minimum
+        (bool ok, ) = payable(address(treasury)).call{value: min}("");
+        assertTrue(ok);
+
+        address payable recipient = payable(address(0xB0B));
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                AutoDriveTreasury.InsufficientBalance.selector,
+                address(treasury).balance,
+                min
+            )
+        );
+        treasury.withdraw(recipient);
+    }
+
+    function testWithdrawRevertsOnZeroRecipient() public {
+        uint256 min = treasury.minimumBalance();
+        uint256 fundAmount = min + 1 ether;
+        (bool ok, ) = payable(address(treasury)).call{value: fundAmount}("");
+        assertTrue(ok);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                AutoDriveTreasury.InvalidRecipient.selector,
+                address(0)
+            )
+        );
+        treasury.withdraw(payable(address(0)));
+    }
+
+    function testTwoStepOwnershipTransfer() public {
+        address initialOwner = address(this);
+        address newOwner = address(0xBEEF);
+        address stranger = address(0xCAFE);
+
+        // Initiate two-step transfer
+        treasury.transferOwnership(newOwner);
+        assertEq(treasury.owner(), initialOwner);
+        assertEq(treasury.pendingOwner(), newOwner);
+
+        // Only pending owner can accept
+        vm.prank(stranger);
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                Ownable.OwnableUnauthorizedAccount.selector,
+                stranger
+            )
+        );
+        treasury.acceptOwnership();
+
+        // Pending owner accepts
+        vm.prank(newOwner);
+        treasury.acceptOwnership();
+        assertEq(treasury.owner(), newOwner);
+        assertEq(treasury.pendingOwner(), address(0));
+
+        // Old owner can no longer use onlyOwner
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                Ownable.OwnableUnauthorizedAccount.selector,
+                initialOwner
+            )
+        );
+        treasury.transferOwnership(stranger);
+
+        // New owner can initiate new transfer
+        vm.prank(newOwner);
+        treasury.transferOwnership(stranger);
+        assertEq(treasury.pendingOwner(), stranger);
+    }
+
+    function testSetMinimumBalanceUpdatesAndRevertsIfAboveBalance() public {
+        // balance initially 0, so only 0 is allowed
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                AutoDriveTreasury.InvalidMinimumBalance.selector,
+                1
+            )
+        );
+        treasury.setMinimumBalance(1);
+
+        // fund and then set to a value <= balance
+        (bool ok, ) = payable(address(treasury)).call{value: 2 ether}("");
+        assertTrue(ok);
+
+        uint256 oldMin = treasury.minimumBalance();
+        uint256 newMin = 1 ether;
+        treasury.setMinimumBalance(newMin);
+        assertEq(treasury.minimumBalance(), newMin);
+
+        // sanity: minimum changed from previous
+        assertTrue(oldMin != newMin);
+    }
+
+    receive() external payable {}
+}