feat: Allow double-checking distributors

Author: keyvank

script/Init.s.sol

@@ -19,47 +19,8 @@ contract BETHScript is Script {
     WORM public worm;
     Staking public staking;
 
-    uint256 constant PREMINE = 5851677.070643683978082748 ether;
-
     function setUp() public {}
 
-    function newNonVested(uint256 id, address owner, uint256 amount) internal pure returns (Distributor.Share memory) {
-        return Distributor.Share({
-            id: id, owner: owner, tge: amount, startTime: 0, initialAmount: 0, amountPerSecond: 0, totalCap: amount
-        });
-    }
-
-    function newVested(
-        uint256 id,
-        address owner,
-        uint256 tgeBips,
-        uint256 amount,
-        uint256 blockTimestamp,
-        uint256 cliffPeriodInMonths,
-        uint256 vestingInMonths
-    ) internal pure returns (Distributor.Share memory) {
-        require(tgeBips <= 10000, "TGE should be in basis points");
-        require(cliffPeriodInMonths <= vestingInMonths, "Cliff period incorrect");
-        uint256 startTime = blockTimestamp + (cliffPeriodInMonths * 4 weeks);
-        uint256 tgeAmount = amount * tgeBips / 10000;
-        uint256 amountAfterTge = amount - tgeAmount;
-        uint256 initialAmount = amountAfterTge * cliffPeriodInMonths / vestingInMonths;
-        uint256 amountPerSecond = (amountAfterTge - initialAmount) / ((vestingInMonths - cliffPeriodInMonths) * 30 days);
-        return Distributor.Share({
-            id: id,
-            owner: owner,
-            tge: tgeAmount,
-            startTime: startTime,
-            initialAmount: initialAmount,
-            amountPerSecond: amountPerSecond,
-            totalCap: amount
-        });
-    }
-
-    function ofPremine(uint256 bipsA, uint256 bipsB) internal pure returns (uint256) {
-        return PREMINE * bipsA * bipsB / 100_000_000;
-    }
-
     function run() public {
         vm.startBroadcast();
 

script/Mainnet.s.sol

@@ -10,7 +10,7 @@ import {SpendVerifier} from "../src/SpendVerifier.sol";
 import {IVerifier} from "../src/interfaces/IVerifier.sol";
 import {IRewardPool} from "../src/interfaces/IRewardPool.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import {Distributor} from "../src/distributors/Distributor.sol";
+import {Distributor, newVested} from "../src/distributors/Distributor.sol";
 import {StaticDistributor} from "../src/distributors/StaticDistributor.sol";
 import {DynamicDistributor} from "../src/distributors/DynamicDistributor.sol";
 
@@ -23,109 +23,63 @@ contract BETHScript is Script {
 
     function setUp() public {}
 
-    function newNonVested(uint256 id, address owner, uint256 amount) internal pure returns (Distributor.Share memory) {
-        return Distributor.Share({
-            id: id, owner: owner, tge: amount, startTime: 0, initialAmount: 0, amountPerSecond: 0, totalCap: amount
-        });
-    }
-
-    function newVested(
-        uint256 id,
-        address owner,
-        uint256 tgeBips,
-        uint256 amount,
-        uint256 blockTimestamp,
-        uint256 cliffPeriodInMonths,
-        uint256 vestingInMonths
-    ) internal pure returns (Distributor.Share memory) {
-        require(tgeBips <= 10000, "TGE should be in basis points");
-        require(cliffPeriodInMonths <= vestingInMonths, "Cliff period incorrect");
-        uint256 startTime = blockTimestamp + (cliffPeriodInMonths * 4 weeks);
-        uint256 tgeAmount = amount * tgeBips / 10000;
-        uint256 amountAfterTge = amount - tgeAmount;
-        uint256 initialAmount = amountAfterTge * cliffPeriodInMonths / vestingInMonths;
-        uint256 amountPerSecond = (amountAfterTge - initialAmount) / ((vestingInMonths - cliffPeriodInMonths) * 30 days);
-        return Distributor.Share({
-            id: id,
-            owner: owner,
-            tge: tgeAmount,
-            startTime: startTime,
-            initialAmount: initialAmount,
-            amountPerSecond: amountPerSecond,
-            totalCap: amount
-        });
-    }
-
     function ofPremine(uint256 bipsA, uint256 bipsB) internal pure returns (uint256) {
         return PREMINE * bipsA * bipsB / 100_000_000;
     }
 
     function run() public {
         vm.startBroadcast();
 
-        uint256 startingTimestamp = block.timestamp;
+        uint256 startingTimestamp = 1771855200; // 23 Feb 2PM UTC
 
         address bethMainnet = 0x5624344235607940d4d4EE76Bf8817d403EB9Cf8;
         address eip7503DotEth = 0x8DC77b145d7009752D6947B3CF6D983caFA1C0Bb;
         address keyvankDotEth = 0x372abB165e3283C4E71ce68eFBA2934FEA5bFF45;
 
-        uint256 numStaticShares = 7;
+        uint256 numStaticShares = 9;
         Distributor.Share[] memory staticShares = new Distributor.Share[](numStaticShares);
 
-        staticShares[0] = newNonVested(0, eip7503DotEth, ofPremine(4000, 10000)); // 40% LP/ICO
+        uint256 lpIcoTotal = ofPremine(4000, 10000);
 
         // Team member #1
-        staticShares[1] = newVested(1, keyvankDotEth, 0, ofPremine(2400, 8000), block.timestamp, 6, 36);
+        staticShares[0] = newVested(1, keyvankDotEth, 0, ofPremine(2400, 9000), startingTimestamp, 6, 36);
         // Team member #2
-        staticShares[2] = newVested(2, keyvankDotEth, 0, ofPremine(2400, 1000), block.timestamp, 6, 36);
-        // Team member #2
-        staticShares[3] = newVested(3, keyvankDotEth, 0, ofPremine(2400, 1000), block.timestamp, 6, 36);
+        staticShares[1] = newVested(
+            2, address(0xBF44aa57e71a9dBa931058064438876AC7841bfa), 0, ofPremine(2400, 425), startingTimestamp, 6, 36
+        );
+        // Team member #3
+        staticShares[2] = newVested(3, eip7503DotEth, 0, ofPremine(2400, 300), startingTimestamp, 6, 36);
+        // Team member #4
+        staticShares[3] = newVested(
+            4, address(0x82C11504D17E26653214741f93e8400F15f88B13), 0, ofPremine(2400, 200), startingTimestamp, 6, 36
+        );
+        // Team member #5
+        staticShares[4] = newVested(5, eip7503DotEth, 0, ofPremine(2400, 50), startingTimestamp, 6, 36);
+        // Team member #6
+        staticShares[5] = newVested(6, eip7503DotEth, 0, ofPremine(2400, 25), startingTimestamp, 6, 36);
 
         // Advisors
-        staticShares[4] = newVested(4, eip7503DotEth, 0, ofPremine(100, 10000), block.timestamp, 6, 36);
+        staticShares[6] = newVested(7, eip7503DotEth, 0, ofPremine(100, 10000), startingTimestamp, 6, 36);
 
         // Private investor
-        staticShares[5] = newVested(5, eip7503DotEth, 0, ofPremine(800, 10000), block.timestamp, 6, 36);
+        staticShares[7] = newVested(
+            8, address(0x3693c57508606cC7f26b7Db3827a8eCebC628c66), 0, ofPremine(800, 10000), startingTimestamp, 6, 36
+        );
 
         // Foundation treasury
-        staticShares[6] = newVested(6, eip7503DotEth, 50, ofPremine(1200, 10000), block.timestamp, 3, 36);
+        staticShares[8] = newVested(9, eip7503DotEth, 500, ofPremine(1200, 10000), startingTimestamp, 3, 36);
 
         uint256 staticsPremine = 0;
         for (uint256 i = 0; i < numStaticShares; i++) {
             staticsPremine += staticShares[i].totalCap;
         }
-        uint256 dynamicsPremine = PREMINE - staticsPremine;
+        uint256 dynamicsPremine = PREMINE - staticsPremine - lpIcoTotal;
 
         require(877751 ether <= dynamicsPremine && dynamicsPremine <= 877752 ether, "Dynamics premine not in range!");
 
-        beth = BETH(bethMainnet);
-
-        require(staticsPremine + dynamicsPremine == PREMINE, "Invalid premine!");
-        worm = new WORM(IERC20(beth), msg.sender, staticsPremine + dynamicsPremine, startingTimestamp);
-        require(worm.balanceOf(msg.sender) == PREMINE, "Invalid WORM amount minted for deployer!");
-
-        staking = new Staking(IERC20(worm), IERC20(beth), 7 days, startingTimestamp);
-        beth.initRewardPool(IRewardPool(staking));
-
         StaticDistributor staticDist = new StaticDistributor(IERC20(worm), staticShares);
-        worm.transfer(address(staticDist), staticsPremine);
-        require(worm.balanceOf(address(staticDist)) == staticsPremine, "Invalid WORM balance for static distributor!");
-        require(
-            worm.balanceOf(msg.sender) == PREMINE - staticsPremine,
-            "Invalid WORM balance after transfer to static distributor!"
-        );
-
         DynamicDistributor dynamicDist =
-            new DynamicDistributor(IERC20(worm), block.timestamp + (3 * 30 days), address(0xa11ce));
-        worm.transfer(address(dynamicDist), dynamicsPremine);
-        require(worm.balanceOf(address(dynamicDist)) == dynamicsPremine, "Invalid WORM balance for static distributor!");
-        require(worm.balanceOf(msg.sender) == 0, "Invalid WORM balance after transfer to dynamic distributor!");
-
-        require(worm.totalSupply() == PREMINE, "Invalid WORM total supply!");
-
-        console.log("BETH", address(beth));
-        console.log("WORM", address(worm));
-        console.log("Staking", address(staking));
+            new DynamicDistributor(IERC20(worm), startingTimestamp + (3 * 30 days), address(0xa11ce));
 
         vm.stopBroadcast();
     }

src/distributors/Distributor.sol

@@ -6,6 +6,34 @@ import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
 import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
 
+function newVested(
+    uint256 id,
+    address owner,
+    uint256 tgeBips,
+    uint256 amount,
+    uint256 blockTimestamp,
+    uint256 cliffPeriodInMonths,
+    uint256 vestingInMonths
+) pure returns (Distributor.Share memory) {
+    require(tgeBips <= 10000, "TGE should be in basis points");
+    require(cliffPeriodInMonths <= vestingInMonths, "Cliff period incorrect");
+    uint256 startTime = blockTimestamp + (cliffPeriodInMonths * 30 days);
+    uint256 tgeAmount = amount * tgeBips / 10000;
+    uint256 amountAfterTge = amount - tgeAmount;
+    uint256 initialAmount = amountAfterTge * cliffPeriodInMonths / vestingInMonths;
+    uint256 amountPerSecond = (amountAfterTge - initialAmount) / ((vestingInMonths - cliffPeriodInMonths) * 30 days);
+    return Distributor.Share({
+        id: id,
+        owner: owner,
+        tge: tgeAmount,
+        tgeStartTime: 0,
+        startTime: startTime,
+        initialAmount: initialAmount,
+        amountPerSecond: amountPerSecond,
+        totalCap: amount
+    });
+}
+
 contract Distributor is ReentrancyGuard {
     using SafeERC20 for IERC20;
 
@@ -18,9 +46,10 @@ contract Distributor is ReentrancyGuard {
     struct Share {
         uint256 id; // Unique identifier for the share
         address owner; // Address that can claim this share's emissions
-        uint256 tge; // Amount claimable right after reveal
-        uint256 startTime; // Timestamp when share starts
-        uint256 initialAmount; // Amount of token immediately released
+        uint256 tgeStartTime; // TGE amount claimable after this time
+        uint256 tge; // Amount claimable without waiting for cliff
+        uint256 startTime; // Timestamp when cliff period ends and lump sum is released
+        uint256 initialAmount; // Amount of token immediately released (Cliff lump sum)
         uint256 amountPerSecond; // Amount of token generated per second
         uint256 totalCap; // Maximum total amount that can ever be claimed
     }
@@ -36,20 +65,33 @@ contract Distributor is ReentrancyGuard {
     }
 
     /**
-     * @notice Computes the total tokens that should be claimable for a share at the current time.
+     * @notice Computes the total tokens that should be claimable for a share at the given time.
      * @param _shareId ID of the share.
+     * @param _timestamp Timestamp.
      * @return claimable Total amount that *should* have been emitted so far.
      */
-    function calculateClaimable(uint256 _shareId) public view returns (uint256) {
+    function calculateClaimableAtTimestamp(uint256 _shareId, uint256 _timestamp) public view returns (uint256) {
         Share storage share = shares[_shareId];
-        uint256 claimable = share.tge;
-        if (block.timestamp >= share.startTime) {
+        uint256 claimable = 0;
+        if (_timestamp >= share.tgeStartTime) {
+            claimable += share.tge;
+        }
+        if (_timestamp >= share.startTime) {
             claimable += share.initialAmount;
-            claimable += share.amountPerSecond * (block.timestamp - share.startTime);
+            claimable += share.amountPerSecond * (_timestamp - share.startTime);
         }
         return Math.min(claimable, share.totalCap);
     }
 
+    /**
+     * @notice Computes the total tokens that should be claimable for a share at the current time.
+     * @param _shareId ID of the share.
+     * @return claimable Total amount that *should* have been emitted so far.
+     */
+    function calculateClaimable(uint256 _shareId) public view returns (uint256) {
+        return calculateClaimableAtTimestamp(_shareId, block.timestamp);
+    }
+
     /**
      * @notice Changes the owner of a share.
      * @param _shareId ID of the share.

test/DynamicDistributor.t.sol

@@ -52,6 +52,7 @@ contract DynamicDistributorTest is Test {
         Distributor.Share memory share = Distributor.Share({
             id: 1,
             owner: alice,
+            tgeStartTime: 0,
             tge: 100 ether,
             startTime: START,
             initialAmount: 0,
@@ -63,14 +64,15 @@ contract DynamicDistributorTest is Test {
 
         vm.prank(alice);
         distributor.reveal(share, sig);
-        (, address owner,,,,,) = distributor.shares(1);
+        (, address owner,,,,,,) = distributor.shares(1);
         assertEq(owner, alice);
     }
 
     function test_RevealFailsWithInvalidSigner() public {
         Distributor.Share memory share = Distributor.Share({
             id: 1,
             owner: alice,
+            tgeStartTime: 0,
             tge: 0,
             startTime: START,
             initialAmount: 0,
@@ -92,6 +94,7 @@ contract DynamicDistributorTest is Test {
         Distributor.Share memory share = Distributor.Share({
             id: 1,
             owner: alice,
+            tgeStartTime: 0,
             tge: 0,
             startTime: START,
             initialAmount: 0,
@@ -109,6 +112,7 @@ contract DynamicDistributorTest is Test {
         Distributor.Share memory share = Distributor.Share({
             id: 1,
             owner: alice,
+            tgeStartTime: 0,
             tge: 50 ether,
             startTime: START,
             initialAmount: 50 ether,
@@ -133,6 +137,7 @@ contract DynamicDistributorTest is Test {
         Distributor.Share memory share = Distributor.Share({
             id: 1,
             owner: alice,
+            tgeStartTime: 0,
             tge: 0,
             startTime: START,
             initialAmount: 0,