hande provers

mattstam · mattstam · commit 5e9c487a2e15 · 2025-08-28T16:59:44.000-07:00
diff --git a/contracts/src/SuccinctVApp.sol b/contracts/src/SuccinctVApp.sol
@@ -220,13 +220,27 @@ contract SuccinctVApp is
         // Ensure the index has not been marked as claimed.
         if (isClaimed(_index)) revert RewardAlreadyClaimed();
 
+        // Mark the index as claimed.
+        _setClaimed(_index);
+
         // Verify the merkle proof.
         bytes32 node = keccak256(abi.encodePacked(_index, _account, _amount));
         if (!MerkleProof.verify(_merkleProof, rewardsRoot, node)) revert InvalidProof();
 
-        // Mark the index as claimed and transfer the token.
-        _setClaimed(_index);
-        IERC20(prove).safeTransfer(_account, _amount);
+        // Transfer the token.
+        //
+        // If the `_account` is a prover vault, we need to first deposit it to get $iPROVE and then
+        // transfer the $iPROVE to the prover vault. This splits the $PROVE amount amongst all
+        // of the prover stakers.
+        //
+        // Otherwise if the `_account` is not a prover vault, we can just transfer the $PROVE directly.
+        if (ISuccinctStaking(staking).isProver(_account)) {
+            // Deposit $PROVE to mint $iPROVE, sending it to the prover vault.
+            IERC4626(iProve).deposit(_amount, _account);
+        } else {
+            // Transfer the $PROVE from this contract to the `_account` address.
+            IERC20(prove).safeTransfer(_account, _amount);
+        }
 
         // Emit the event.
         emit RewardClaimed(_index, _account, _amount);
diff --git a/contracts/test/SuccinctVApp.reward.t.sol b/contracts/test/SuccinctVApp.reward.t.sol
@@ -6,6 +6,7 @@ import {SuccinctVApp} from "../src/SuccinctVApp.sol";
 import {ISuccinctVApp} from "../src/interfaces/ISuccinctVApp.sol";
 import {Merkle} from "../lib/murky/src/Merkle.sol";
 import {MockERC20} from "./utils/MockERC20.sol";
+import {MockStaking} from "../src/mocks/MockStaking.sol";
 import {PausableUpgradeable} from
     "../lib/openzeppelin-contracts-upgradeable/contracts/utils/PausableUpgradeable.sol";
 
@@ -16,6 +17,9 @@ contract SuccinctVAppRewardsTest is SuccinctVAppTest {
     bytes32[] public rewardLeaves;
     bytes32 public rewardsMerkleRoot;
     Merkle public merkle;
+    
+    // Prover for testing prover rewards.
+    address public testProver;
 
     // Storage slot for rewardsRoot in SuccinctVApp (slot 11 based on contract layout).
     uint256 constant REWARDS_ROOT_SLOT = 11;
@@ -26,13 +30,17 @@ contract SuccinctVAppRewardsTest is SuccinctVAppTest {
     function setUp() public override {
         super.setUp();
 
-        // Set up test rewards data.
+        // Create a test prover.
+        vm.prank(ALICE);
+        testProver = MockStaking(STAKING).createProver(ALICE, STAKER_FEE_BIPS);
+
+        // Set up test rewards data (including a prover).
         rewardAccounts = [
             makeAddr("REWARD_1"),
             makeAddr("REWARD_2"),
             makeAddr("REWARD_3"),
             makeAddr("REWARD_4"),
-            makeAddr("REWARD_5")
+            testProver // Include the prover in rewards
         ];
         rewardAmounts = [1 ether, 2 ether, 3 ether, 4 ether, 5 ether];
 
@@ -91,7 +99,14 @@ contract SuccinctVAppRewardsTest is SuccinctVAppTest {
             SuccinctVApp(VAPP).rewardClaim(i, claimer, amount, proof);
 
             // Check post-claim state.
-            assertEq(MockERC20(PROVE).balanceOf(claimer), amount);
+            if (claimer == testProver) {
+                // For provers, PROVE is converted to iPROVE and sent to prover vault.
+                assertEq(MockERC20(I_PROVE).balanceOf(claimer), amount);
+                assertEq(MockERC20(PROVE).balanceOf(claimer), 0);
+            } else {
+                // For regular accounts, PROVE is sent directly.
+                assertEq(MockERC20(PROVE).balanceOf(claimer), amount);
+            }
             vappBalBefore -= amount;
             assertEq(MockERC20(PROVE).balanceOf(VAPP), vappBalBefore);
             assertEq(SuccinctVApp(VAPP).isClaimed(i), true);
@@ -173,18 +188,23 @@ contract SuccinctVAppRewardsTest is SuccinctVAppTest {
         // Set the rewards root.
         _setRewardsRoot(rewardsMerkleRoot);
 
+        // Test regular account (not a prover).
+        uint256 regularAccountIndex = 0;
+        address regularAccount = rewardAccounts[regularAccountIndex];
+        uint256 amount = rewardAmounts[regularAccountIndex];
+
         // Check initial balances.
         uint256 initialVAppBalance = MockERC20(PROVE).balanceOf(VAPP);
-        uint256 initialClaimerBalance = MockERC20(PROVE).balanceOf(rewardAccounts[0]);
+        uint256 initialClaimerBalance = MockERC20(PROVE).balanceOf(regularAccount);
         assertEq(initialClaimerBalance, 0);
 
         // Claim reward.
-        bytes32[] memory proof = merkle.getProof(rewardLeaves, 0);
-        SuccinctVApp(VAPP).rewardClaim(0, rewardAccounts[0], rewardAmounts[0], proof);
+        bytes32[] memory proof = merkle.getProof(rewardLeaves, regularAccountIndex);
+        SuccinctVApp(VAPP).rewardClaim(regularAccountIndex, regularAccount, amount, proof);
 
         // Verify transfer occurred.
-        assertEq(MockERC20(PROVE).balanceOf(rewardAccounts[0]), rewardAmounts[0]);
-        assertEq(MockERC20(PROVE).balanceOf(VAPP), initialVAppBalance - rewardAmounts[0]);
+        assertEq(MockERC20(PROVE).balanceOf(regularAccount), amount);
+        assertEq(MockERC20(PROVE).balanceOf(VAPP), initialVAppBalance - amount);
     }
 
     function test_RewardClaim_DifferentCaller() public {
@@ -262,4 +282,58 @@ contract SuccinctVAppRewardsTest is SuccinctVAppTest {
         uint256 expectedRemainingBalance = 100 ether - totalClaimed;
         assertEq(MockERC20(PROVE).balanceOf(VAPP), expectedRemainingBalance);
     }
+
+    function test_RewardClaim_ToProverVault() public {
+        // Set the rewards root.
+        _setRewardsRoot(rewardsMerkleRoot);
+
+        // Get the prover index (last one in our array).
+        uint256 proverIndex = rewardAccounts.length - 1;
+        address proverVault = rewardAccounts[proverIndex];
+        uint256 amount = rewardAmounts[proverIndex];
+        
+        // Verify it's recognized as a prover.
+        assertEq(proverVault, testProver);
+
+        // Check initial balances.
+        uint256 initialVAppBalance = MockERC20(PROVE).balanceOf(VAPP);
+        uint256 initialProverPROVEBalance = MockERC20(PROVE).balanceOf(proverVault);
+        uint256 initialProveriPROVEBalance = MockERC20(I_PROVE).balanceOf(proverVault);
+        assertEq(initialProverPROVEBalance, 0);
+        assertEq(initialProveriPROVEBalance, 0);
+
+        // Claim reward for prover.
+        bytes32[] memory proof = merkle.getProof(rewardLeaves, proverIndex);
+        vm.expectEmit(true, true, true, true, VAPP);
+        emit RewardClaimed(proverIndex, proverVault, amount);
+        SuccinctVApp(VAPP).rewardClaim(proverIndex, proverVault, amount, proof);
+
+        // Verify the prover received iPROVE instead of PROVE.
+        assertEq(MockERC20(PROVE).balanceOf(proverVault), 0);
+        assertEq(MockERC20(I_PROVE).balanceOf(proverVault), amount);
+        assertEq(MockERC20(PROVE).balanceOf(VAPP), initialVAppBalance - amount);
+        assertEq(SuccinctVApp(VAPP).isClaimed(proverIndex), true);
+    }
+
+    function test_RewardClaim_MixedAccountTypes() public {
+        // Set the rewards root.
+        _setRewardsRoot(rewardsMerkleRoot);
+
+        // Claim for regular account (index 0).
+        bytes32[] memory proof0 = merkle.getProof(rewardLeaves, 0);
+        SuccinctVApp(VAPP).rewardClaim(0, rewardAccounts[0], rewardAmounts[0], proof0);
+        
+        // Verify regular account received PROVE.
+        assertEq(MockERC20(PROVE).balanceOf(rewardAccounts[0]), rewardAmounts[0]);
+        assertEq(MockERC20(I_PROVE).balanceOf(rewardAccounts[0]), 0);
+
+        // Claim for prover (last index).
+        uint256 proverIndex = rewardAccounts.length - 1;
+        bytes32[] memory proofProver = merkle.getProof(rewardLeaves, proverIndex);
+        SuccinctVApp(VAPP).rewardClaim(proverIndex, testProver, rewardAmounts[proverIndex], proofProver);
+        
+        // Verify prover received iPROVE.
+        assertEq(MockERC20(PROVE).balanceOf(testProver), 0);
+        assertEq(MockERC20(I_PROVE).balanceOf(testProver), rewardAmounts[proverIndex]);
+    }
 }
diff --git a/contracts/test/SuccinctVApp.t.sol b/contracts/test/SuccinctVApp.t.sol
@@ -11,6 +11,7 @@ import {SuccinctGovernor} from "../src/SuccinctGovernor.sol";
 import {ISP1Verifier} from "../lib/sp1-contracts/contracts/src/ISP1Verifier.sol";
 import {FixtureLoader, Fixture, ProofFixtureJson} from "./utils/FixtureLoader.sol";
 import {MockERC20} from "./utils/MockERC20.sol";
+import {MockERC4626} from "./utils/MockERC4626.sol";
 import {ERC1967Proxy} from "../lib/openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol";
 import {Initializable} from "../lib/openzeppelin-contracts/contracts/proxy/utils/Initializable.sol";
 import {IERC20Permit} from
@@ -106,7 +107,7 @@ contract SuccinctVAppTest is Test, FixtureLoader {
 
         // Deploy tokens
         PROVE = address(new MockERC20("Succinct", "PROVE", 18));
-        I_PROVE = address(new MockERC20("Succinct", "iPROVE", 18));
+        I_PROVE = address(new MockERC4626("Succinct", "iPROVE", 18, PROVE));
 
         // Deploy governor
         GOVERNOR = address(
diff --git a/contracts/test/utils/MockERC4626.sol b/contracts/test/utils/MockERC4626.sol
@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {MockERC20} from "./MockERC20.sol";
+import {IERC4626} from "../../lib/openzeppelin-contracts/contracts/interfaces/IERC4626.sol";
+import {IERC20} from "../../lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol";
+
+contract MockERC4626 is MockERC20, IERC4626 {
+    address public immutable asset;
+
+    constructor(
+        string memory name,
+        string memory symbol,
+        uint8 decimals_,
+        address _asset
+    ) MockERC20(name, symbol, decimals_) {
+        asset = _asset;
+    }
+
+    function deposit(uint256 assets, address receiver) public returns (uint256 shares) {
+        // Simple 1:1 conversion for testing.
+        shares = assets;
+        
+        // Transfer assets from sender to this contract.
+        IERC20(asset).transferFrom(msg.sender, address(this), assets);
+        
+        // Mint shares to receiver.
+        _mint(receiver, shares);
+        
+        emit Deposit(msg.sender, receiver, assets, shares);
+        
+        return shares;
+    }
+
+    function mint(uint256 shares, address receiver) public returns (uint256 assets) {
+        assets = shares; // 1:1 conversion
+        IERC20(asset).transferFrom(msg.sender, address(this), assets);
+        _mint(receiver, shares);
+        emit Deposit(msg.sender, receiver, assets, shares);
+        return assets;
+    }
+
+    function withdraw(
+        uint256 assets,
+        address receiver,
+        address owner
+    ) public returns (uint256 shares) {
+        shares = assets; // 1:1 conversion
+        if (msg.sender != owner) {
+            _spendAllowance(owner, msg.sender, shares);
+        }
+        _burn(owner, shares);
+        IERC20(asset).transfer(receiver, assets);
+        emit Withdraw(msg.sender, receiver, owner, assets, shares);
+        return shares;
+    }
+
+    function redeem(
+        uint256 shares,
+        address receiver,
+        address owner
+    ) public returns (uint256 assets) {
+        assets = shares; // 1:1 conversion
+        if (msg.sender != owner) {
+            _spendAllowance(owner, msg.sender, shares);
+        }
+        _burn(owner, shares);
+        IERC20(asset).transfer(receiver, assets);
+        emit Withdraw(msg.sender, receiver, owner, assets, shares);
+        return assets;
+    }
+
+    function totalAssets() public view returns (uint256) {
+        return IERC20(asset).balanceOf(address(this));
+    }
+
+    function convertToShares(uint256 assets) public pure returns (uint256) {
+        return assets; // 1:1 conversion
+    }
+
+    function convertToAssets(uint256 shares) public pure returns (uint256) {
+        return shares; // 1:1 conversion
+    }
+
+    function maxDeposit(address) public pure returns (uint256) {
+        return type(uint256).max;
+    }
+
+    function previewDeposit(uint256 assets) public pure returns (uint256) {
+        return assets; // 1:1 conversion
+    }
+
+    function maxMint(address) public pure returns (uint256) {
+        return type(uint256).max;
+    }
+
+    function previewMint(uint256 shares) public pure returns (uint256) {
+        return shares; // 1:1 conversion
+    }
+
+    function maxWithdraw(address owner) public view returns (uint256) {
+        return balanceOf(owner); // 1:1 conversion
+    }
+
+    function previewWithdraw(uint256 assets) public pure returns (uint256) {
+        return assets; // 1:1 conversion
+    }
+
+    function maxRedeem(address owner) public view returns (uint256) {
+        return balanceOf(owner);
+    }
+
+    function previewRedeem(uint256 shares) public pure returns (uint256) {
+        return shares; // 1:1 conversion
+    }
+}
