E2E EpochManager test + Epoch truffle migrations & Anvil L2 migration build fix

packages/protocol/contractPackages.ts

@@ -48,13 +48,24 @@ export const SOLIDITY_08_PACKAGE = {
   proxiesPath: '/', // Proxies are still with 0.5 contracts
   // Proxies shouldn't have to be added to a list manually
   // https://github.com/celo-org/celo-monorepo/issues/10555
-  contracts: ['GasPriceMinimum', 'FeeCurrencyDirectory', 'CeloUnreleasedTreasure', 'Validators'],
+  contracts: [
+    'GasPriceMinimum',
+    'FeeCurrencyDirectory',
+    'CeloUnreleasedTreasure',
+    'Validators',
+    'EpochManager',
+    'EpochManagerEnabler',
+    'ScoreManager',
+  ],
   proxyContracts: [
     'GasPriceMinimumProxy',
     'FeeCurrencyDirectoryProxy',
     'MentoFeeCurrencyAdapterV1',
     'CeloUnreleasedTreasureProxy',
     'ValidatorsProxy',
+    'EpochManagerProxy',
+    'EpochManagerEnablerProxy',
+    'ScoreManagerProxy',
   ],
   truffleConfig: 'truffle-config0.8.js',
 } satisfies ContractPackage

packages/protocol/contracts-0.8/common/EpochManager.sol

@@ -50,9 +50,14 @@ contract EpochManager is
   uint256 private currentEpochNumber;
   address[] public elected;
 
+  struct ProcessedGroup {
+    bool processed;
+    uint256 epochRewards;
+  }
+
   // TODO this should be able to get deleted easily
   // maybe even having it in a stadalone contract
-  mapping(address => bool) public processedGroups;
+  mapping(address => ProcessedGroup) public processedGroups;
 
   EpochProcessState public epochProcessing;
   mapping(uint256 => Epoch) private epochs;
@@ -181,6 +186,7 @@ contract EpochManager is
     // TODO complete this function
     require(isOnEpochProcess(), "Epoch process is not started");
     // finalize epoch
+    // TODO last block should be the block before and timestamp from previous block
     epochs[currentEpochNumber].lastBlock = block.number - 1;
     // start new epoch
     currentEpochNumber++;
@@ -189,27 +195,36 @@ contract EpochManager is
 
     for (uint i = 0; i < elected.length; i++) {
       address group = getValidators().getValidatorsGroup(elected[i]);
-      if (!processedGroups[group]) {
+      if (!processedGroups[group].processed) {
         epochProcessing.toProcessGroups++;
-        processedGroups[group] = true;
+        uint256 groupScore = getScoreReader().getGroupScore(group);
+        // We need to precompute epoch rewards for each group since computation depends on total active votes for all groups.
+        uint256 epochRewards = getElection().getGroupEpochRewards(
+          group,
+          epochProcessing.totalRewardsVoter,
+          groupScore
+        );
+        processedGroups[group] = ProcessedGroup(true, epochRewards);
       }
     }
 
     require(epochProcessing.toProcessGroups == groups.length, "number of groups does not match");
 
-    for (uint i = 0; i < groups.length; i++) {
+    // since we are adding values it makes sense to start from the end
+    for (uint ii = groups.length; ii > 0; ii--) {
+      uint256 i = ii - 1;
+      ProcessedGroup storage processedGroup = processedGroups[groups[i]];
       // checks that group is actually from elected group
-      require(processedGroups[groups[i]], "group not processed");
-      // by doing this, we avoid processing a group twice
-      delete processedGroups[groups[i]];
-      // TODO what happens to uptime?
-      uint256 groupScore = getScoreReader().getGroupScore(groups[i]);
-      uint256 epochRewards = getElection().getGroupEpochRewards(
+      require(processedGroup.processed, "group not processed");
+      getElection().distributeEpochRewards(
         groups[i],
-        epochProcessing.totalRewardsVoter,
-        groupScore
+        processedGroup.epochRewards,
+        lessers[i],
+        greaters[i]
       );
-      getElection().distributeEpochRewards(groups[i], epochRewards, lessers[i], greaters[i]);
+
+      // by doing this, we avoid processing a group twice
+      delete processedGroups[groups[i]];
     }
     getCeloUnreleasedTreasure().release(
       registry.getAddressForOrDie(GOVERNANCE_REGISTRY_ID),
@@ -220,7 +235,7 @@ contract EpochManager is
       epochProcessing.totalRewardsCarbonFund
     );
     // run elections
-    elected = getElection().electNValidatorSigners(10, 20);
+    elected = getElection().electValidatorSigners();
     // TODO check how to nullify stuct
     epochProcessing.status = EpochProcessStatus.NotStarted;
   }

packages/protocol/contracts-0.8/common/EpochManagerEnabler.sol

@@ -11,6 +11,7 @@ import "../../contracts/governance/interfaces/IEpochRewards.sol";
 
 contract EpochManagerEnabler is Initializable, UsingPrecompiles, UsingRegistry {
   uint256 public lastKnownEpochNumber;
+  uint256 public lastKnownFirstBlockOfEpoch;
   address[] public lastKnownElectedAccounts;
 
   /**
@@ -33,10 +34,11 @@ contract EpochManagerEnabler is Initializable, UsingPrecompiles, UsingRegistry {
    */
   function initEpochManager() external onlyL2 {
     require(lastKnownEpochNumber != 0, "lastKnownEpochNumber not set.");
+    require(lastKnownFirstBlockOfEpoch != 0, "lastKnownFirstBlockOfEpoch not set.");
     require(lastKnownElectedAccounts.length > 0, "lastKnownElectedAccounts not set.");
     getEpochManager().initializeSystem(
       lastKnownEpochNumber,
-      _getFirstBlockOfEpoch(lastKnownEpochNumber),
+      lastKnownFirstBlockOfEpoch,
       lastKnownElectedAccounts
     );
   }
@@ -48,8 +50,8 @@ contract EpochManagerEnabler is Initializable, UsingPrecompiles, UsingRegistry {
     lastKnownEpochNumber = getEpochNumber();
 
     uint256 numberElectedValidators = numberValidatorsInCurrentSet();
-
     lastKnownElectedAccounts = new address[](numberElectedValidators);
+    lastKnownFirstBlockOfEpoch = _getFirstBlockOfEpoch(lastKnownEpochNumber);
 
     for (uint256 i = 0; i < numberElectedValidators; i++) {
       // TODO: document how much gas this takes for 110 signers
@@ -60,6 +62,17 @@ contract EpochManagerEnabler is Initializable, UsingPrecompiles, UsingRegistry {
     }
   }
 
+  /**
+   * @notice Returns the storage, major, minor, and patch version of the contract.
+   * @return Storage version of the contract.
+   * @return Major version of the contract.
+   * @return Minor version of the contract.
+   * @return Patch version of the contract.
+   */
+  function getVersionNumber() external pure returns (uint256, uint256, uint256, uint256) {
+    return (1, 1, 0, 0);
+  }
+
   function getFirstBlockOfEpoch(uint256 currentEpoch) external view returns (uint256) {
     return _getFirstBlockOfEpoch(currentEpoch);
   }

packages/protocol/contracts-0.8/common/interfaces/IScoreManager.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+pragma solidity >=0.5.13 <0.9.0;
+
+interface IScoreManager {
+  function setGroupScore(address group, uint256 score) external;
+  function setValidatorScore(address validator, uint256 score) external;
+  function getValidatorScore(address validator) external view returns (uint256);
+  function getGroupScore(address validator) external view returns (uint256);
+  function owner() external view returns (address);
+}

packages/protocol/contracts-0.8/common/test/MockCeloToken.sol

@@ -54,7 +54,4 @@ contract MockCeloToken08 {
   function totalSupply() public view returns (uint256) {
     return totalSupply_;
   }
-  function allocatedSupply() public view returns (uint256) {
-    return CELO_SUPPLY_CAP - L2_INITIAL_STASH_BALANCE;
-  }
 }

packages/protocol/contracts-0.8/common/test/MockEpochManager.sol

@@ -67,4 +67,12 @@ contract MockEpochManager is IEpochManager {
   function getElected() external view returns (address[] memory) {
     return elected;
   }
+
+  function getEpochProcessingState()
+    external
+    view
+    returns (uint256, uint256, uint256, uint256, uint256)
+  {
+    return (0, 0, 0, 0, 0);
+  }
 }

packages/protocol/contracts-0.8/governance/Validators.sol

@@ -166,6 +166,11 @@ contract Validators is
     _;
   }
 
+  modifier onlyEpochManager() {
+    require(msg.sender == address(getEpochManager()), "Only epoch manager can call");
+    _;
+  }
+
   /**
    * @notice Sets initialized == true on implementation contracts
    * @param test Set to true to skip implementation initialization
@@ -514,7 +519,7 @@ contract Validators is
   }
 
   /**
-   * @notice Adds the first member to a group's list of members and marks it eligible for election.
+   * @notice Adds the first member to a group's list of members and marks the group eligible for election.
    * @param validator The validator to add to the group
    * @param lesser The address of the group that has received fewer votes than this group.
    * @param greater The address of the group that has received more votes than this group.
@@ -647,6 +652,19 @@ contract Validators is
     group.slashInfo.lastSlashed = block.timestamp;
   }
 
+  function mintStableToEpochManager(
+    uint256 amount
+  ) external onlyL2 nonReentrant onlyRegisteredContract(EPOCH_MANAGER_REGISTRY_ID) {
+    require(amount > 0, "mint amount is zero.");
+    require(
+      IStableToken(getStableToken()).mint(
+        registry.getAddressForOrDie(EPOCH_MANAGER_REGISTRY_ID),
+        amount
+      ),
+      "mint failed to epoch manager"
+    );
+  }
+
   /**
    * @notice Allows the EpochManager contract to mint stable token for itself.
    * @param amount The amount to be minted.

packages/protocol/contracts/common/interfaces/IEpochManager.sol

@@ -18,4 +18,9 @@ interface IEpochManager {
   function getElected() external view returns (address[] memory);
   function epochManagerEnabler() external view returns (address);
   function epochDuration() external view returns (uint256);
+  function firstKnownEpoch() external view returns (uint256);
+  function getEpochProcessingState()
+    external
+    view
+    returns (uint256, uint256, uint256, uint256, uint256);
 }

packages/protocol/contracts/common/proxies/EpochManagerEnablerProxy.sol

@@ -0,0 +1,6 @@
+pragma solidity ^0.5.13;
+
+import "../Proxy.sol";
+
+/* solhint-disable-next-line no-empty-blocks */
+contract EpochManagerEnablerProxy is Proxy {}

packages/protocol/contracts/common/proxies/EpochManagerProxy.sol

@@ -0,0 +1,6 @@
+pragma solidity ^0.5.13;
+
+import "../Proxy.sol";
+
+/* solhint-disable-next-line no-empty-blocks */
+contract EpochManagerProxy is Proxy {}

packages/protocol/contracts/common/proxies/ScoreManagerProxy.sol

@@ -0,0 +1,6 @@
+pragma solidity ^0.5.13;
+
+import "../Proxy.sol";
+
+/* solhint-disable-next-line no-empty-blocks */
+contract ScoreManagerProxy is Proxy {}

packages/protocol/contracts/governance/Election.sol

@@ -957,7 +957,7 @@ contract Election is
     uint256 value,
     address lesser,
     address greater
-  ) internal onlyL1 {
+  ) internal {
     if (votes.total.eligible.contains(group)) {
       uint256 newVoteTotal = votes.total.eligible.getValue(group).add(value);
       votes.total.eligible.update(group, newVoteTotal, lesser, greater);

packages/protocol/foundry.toml

@@ -37,6 +37,7 @@ fs_permissions = [
     ]
 
 [profile.devchain] # Special profile for the tests that require an anvil devchain
+test = 'test-sol/devchain'
 match_path = "**/test-sol/devchain/**"
 no_match_path = "{**/test/BLS12Passthrough.sol,**/test/RandomTest.sol}"
 

packages/protocol/lib/proxy-utils.ts

@@ -42,27 +42,33 @@ export async function setAndInitializeImplementation(
   },
   ...args: any[]
 ) {
-  const callData = web3.eth.abi.encodeFunctionCall(initializerAbi, args)
-  if (txOptions.from != null) {
-    // The proxied contract needs to be funded prior to initialization
-    if (txOptions.value != null) {
-      // Proxy's fallback fn expects the contract's implementation to be set already
-      // So we set the implementation first, send the funding, and then set and initialize again.
-      await retryTx(proxy._setImplementation, [implementationAddress, { from: txOptions.from }])
-      await retryTx(web3.eth.sendTransaction, [
-        {
-          from: txOptions.from,
-          to: proxy.address,
-          value: txOptions.value,
-        },
+  try {
+
+
+    const callData = web3.eth.abi.encodeFunctionCall(initializerAbi, args)
+    if (txOptions.from != null) {
+      // The proxied contract needs to be funded prior to initialization
+      if (txOptions.value != null) {
+        // Proxy's fallback fn expects the contract's implementation to be set already
+        // So we set the implementation first, send the funding, and then set and initialize again.
+        await retryTx(proxy._setImplementation, [implementationAddress, { from: txOptions.from }])
+        await retryTx(web3.eth.sendTransaction, [
+          {
+            from: txOptions.from,
+            to: proxy.address,
+            value: txOptions.value,
+          },
+        ])
+      }
+      return retryTx(proxy._setAndInitializeImplementation, [
+        implementationAddress,
+        callData as any,
+        { from: txOptions.from },
       ])
+    } else {
+      return retryTx(proxy._setAndInitializeImplementation, [implementationAddress, callData as any])
     }
-    return retryTx(proxy._setAndInitializeImplementation, [
-      implementationAddress,
-      callData as any,
-      { from: txOptions.from },
-    ])
-  } else {
-    return retryTx(proxy._setAndInitializeImplementation, [implementationAddress, callData as any])
+  } catch (error) {
+    console.log("errror", error);
   }
 }

packages/protocol/lib/web3-utils.ts

@@ -207,6 +207,12 @@ export async function _setInitialProxyImplementation<
   return receipt.tx
 }
 
+export const getProxiedContract = async (contractName: string, contractPackage: ContractPackage) => {
+  const artifactsObject = ArtifactsSingleton.getInstance(contractPackage, artifacts)
+  /* eslint-disable-next-line */
+  return await getDeployedProxiedContract(contractName, artifactsObject)
+}
+
 export async function getDeployedProxiedContract<ContractInstance extends Truffle.ContractInstance>(
   contractName: string,
   customArtifacts: any

packages/protocol/migrationsConfig.js

@@ -77,6 +77,10 @@ const DefaultConfig = {
     carbonOffsettingFraction: 1 / 1000,
     frozen: false,
   },
+  epochManager: {
+    newEpochDuration: 100,
+    carbonOffsettingPartner: '0x0000000000000000000000000000000000000000',
+  },
   exchange: {
     spread: 5 / 1000,
     reserveFraction: 1 / 100,
@@ -165,6 +169,9 @@ const DefaultConfig = {
     numRequiredConfirmations: 1,
     numInternalRequiredConfirmations: 1,
   },
+  scoreManager: {
+    newEpochDuration: 100,
+  },
   stableToken: {
     decimals: 18,
     goldPrice: 1,

packages/protocol/migrations_sol/Migration.s.sol

@@ -1131,10 +1131,11 @@ contract Migration is Script, UsingRegistry, MigrationsConstants {
       bytes16(0x05050505050505050505050505050506),
       bytes16(0x06060606060606060606060606060607)
     );
+
     (bytes memory ecdsaPubKey, , , ) = _generateEcdsaPubKeyWithSigner(accountAddress, validatorKey);
     getValidators().registerValidator(ecdsaPubKey, newBlsPublicKey, newBlsPop);
     getValidators().affiliate(groupToAffiliate);
-    console.log("Done registering validatora");
+    console.log("Done registering validators");
 
     vm.stopBroadcast();
     return accountAddress;