Add fork test tooling

.github/workflows/main.yaml

@@ -80,4 +80,20 @@ jobs:
         uses: foundry-rs/foundry-toolchain@v1
 
       - name: Run tests
-        run: forge test -vvv
+        run: forge test --no-match-contract "(Fork)" -vvv
+
+  foundry-fork-tests:
+    name: Foundry Fork tests
+    runs-on: ubuntu-latest
+    env:
+      PROVIDER_URL: ${{ secrets.PROVIDER_URL }}
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: recursive
+
+      - name: Install Foundry
+        uses: foundry-rs/foundry-toolchain@v1
+
+      - name: Run tests
+        run: forge test --match-contract "ForkTest" --fork-url $PROVIDER_URL

.gitignore

@@ -16,3 +16,4 @@ out/
 .vscode
 brownie-deploy/
 .idea
+deployments-fork.json

.gitmodules

@@ -9,7 +9,8 @@
 	url = https://github.com/openzeppelin/openzeppelin-contracts-upgradeable
 [submodule "lib/forge-std"]
 	path = lib/forge-std
-	url = https://github.com/brockelmore/forge-std
+	url = https://github.com/foundry-rs/forge-std
+	branch = 978ac6fadb62f5f0b723c996f64be52eddba6801
 [submodule "lib/prb-math"]
 	path = lib/prb-math
 	url = https://github.com/paulrberg/prb-math

brownie-config.yaml

@@ -3,3 +3,7 @@ dependencies:
   - OpenZeppelin/[email protected]
   - OpenZeppelin/[email protected]
   - paulrberg/[email protected]
+compiler:
+  solc:
+    remappings:
+      - forge-std/=./lib/forge-std/src/

build/deployments.json

@@ -0,0 +1,6 @@
+{
+  "1": {
+    "executions": {},
+    "contracts": {}
+  }
+}

contracts/FixedRateRewardsSource.sol

@@ -90,10 +90,6 @@ contract FixedRateRewardsSource is Governable, Initializable {
     function previewRewards() public view returns (uint256 rewardAmount) {
         RewardConfig memory _config = rewardConfig;
 
-        if (_config.lastCollect == 0) {
-            return 0;
-        }
-
         rewardAmount = (block.timestamp - _config.lastCollect) * _config.rewardsPerSecond;
         uint256 balance = IERC20(rewardToken).balanceOf(address(this));
         if (rewardAmount > balance) {
@@ -139,6 +135,11 @@ contract FixedRateRewardsSource is Governable, Initializable {
         // Update storage
         RewardConfig storage _config = rewardConfig;
         emit RewardsPerSecondChanged(_rewardsPerSecond, _config.rewardsPerSecond);
+        if (_config.rewardsPerSecond == 0) {
+            // When changing rate from zero to non-zero,
+            // Update lastCollect timestamp as well
+            _config.lastCollect = uint64(block.timestamp);
+        }
         _config.rewardsPerSecond = _rewardsPerSecond;
     }
 }

contracts/Governance.sol

@@ -16,12 +16,12 @@ contract Governance is
     GovernorPreventLateQuorum
 {
     constructor(ERC20Votes _token, TimelockController _timelock)
-        Governor("OUSD Governance")
-        GovernorSettings(1, /* 1 block */ 17280, /* ~3 days (86400 / 15) * 3 */ 10000000 * 1e18 /* 10 mio veOgv */ )
+        Governor("Origin DeFi Governance")
+        GovernorSettings(1, /* 1 block */ 14416, /* ~2 days (86400 / 12) * 2 */ 100000 * 1e18 /* 100k xOGN */ )
         GovernorVotes(_token)
         GovernorVotesQuorumFraction(20) // Default quorum denominator is 100, so 20/100 or 20%
         GovernorTimelockControl(_timelock)
-        GovernorPreventLateQuorum(11520) // ~2 days (86400 / 15) * 2
+        GovernorPreventLateQuorum(7208) // ~1 days (86400 / 12)
     {}
 
     // The following functions are overrides required by Solidity.

contracts/OgvStaking.sol

@@ -228,7 +228,7 @@ contract OgvStaking is ERC20Votes {
     /// @param duration number of seconds to stake for
     /// @return points staking points that would be returned
     /// @return end staking period end date
-    function previewPoints(uint256 amount, uint256 duration) public view returns (uint256, uint256) {
+    function previewPoints(uint256 amount, uint256 duration) public pure returns (uint256, uint256) {
         revert StakingDisabled();
     }
 

contracts/interfaces/IMintableERC20.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.10;
+
+interface IMintableERC20 {
+    function mint(address to, uint256 amount) external;
+    function balanceOf(address owner) external view returns (uint256);
+    function totalSupply() external view returns (uint256);
+    function transfer(address to, uint256 amount) external returns (bool);
+    function approve(address spender, uint256 allowance) external;
+}

contracts/interfaces/IOGNGovernance.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.10;
+
+interface IOGNGovernance {
+    function state(uint256 proposalId) external view returns (uint256);
+    function proposalCount() external view returns (uint256);
+    function queue(uint256 proposalId) external;
+    function execute(uint256 proposalId) external;
+    function propose(
+        address[] memory targets,
+        string[] memory signatures,
+        bytes[] memory calldatas,
+        string memory description
+    ) external returns (uint256);
+}

contracts/tests/MockRewardsSource.sol

@@ -4,7 +4,7 @@ pragma solidity 0.8.10;
 contract MockRewardsSource {
     constructor() {}
 
-    function previewRewards() external view returns (uint256) {
+    function previewRewards() external pure returns (uint256) {
         return 0;
     }
 

contracts/tests/TestToken.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.4;
 import "../GovernanceToken.sol";
 
 contract TestToken is OriginDollarGovernance {
-    function proof() public {
+    function proof() public pure {
         revert("Upgraded");
     }
 }

contracts/utils/Addresses.sol

@@ -6,14 +6,17 @@ library Addresses {
     address public constant STRATEGIST = 0xF14BBdf064E3F67f51cd9BD646aE3716aD938FDC;
     address public constant GOVERNOR_FIVE = 0x3cdD07c16614059e66344a7b579DAB4f9516C0b6;
 
+    address public constant OGN_GOVERNOR = 0x72426BA137DEC62657306b12B1E869d43FeC6eC7;
+    address public constant GOV_MULTISIG = 0xbe2AB3d3d8F6a32b96414ebbd865dBD276d3d899;
+
     address public constant INITIAL_DEPLOYER = address(0x1001);
     address public constant OGN = 0x8207c1FfC5B6804F6024322CcF34F29c3541Ae26;
     address public constant OGV = 0x9c354503C38481a7A7a51629142963F98eCC12D0;
     address public constant OGV_REWARDS_PROXY = 0x7d82E86CF1496f9485a8ea04012afeb3C7489397;
     address public constant VEOGV = 0x0C4576Ca1c365868E162554AF8e385dc3e7C66D9;
 
-    address public constant OUSD_BUYBACK = address(34);
-    address public constant OETH_BUYBACK = address(35);
-    address public constant OUSD_BUYBACK_IMPL = address(34);
-    address public constant OETH_BUYBACK_IMPL = address(35);
+    address public constant OUSD_BUYBACK = 0xD7B28d06365b85933c64E11e639EA0d3bC0e3BaB;
+    address public constant OETH_BUYBACK = 0xFD6c58850caCF9cCF6e8Aee479BFb4Df14a362D2;
+    address public constant OUSD_BUYBACK_IMPL = 0x386d8fEC5b6d5B5E36a48A376644e36239dB65d6;
+    address public constant OETH_BUYBACK_IMPL = 0x4F11d31f781B57051764a3823b24d520626b4833;
 }

contracts/utils/GovFive.sol

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.10;
+
+import {Vm} from "forge-std/Vm.sol";
+import {Addresses} from "contracts/utils/Addresses.sol";
+import "forge-std/console.sol";
+
+import "OpenZeppelin/[email protected]/contracts/utils/Strings.sol";
+
+library GovFive {
+    struct GovFiveAction {
+        address receiver;
+        string fullsig;
+        bytes data;
+    }
+
+    struct GovFiveProposal {
+        string name;
+        string description;
+        GovFiveAction[] actions;
+    }
+
+    function setName(GovFiveProposal storage prop, string memory name) internal {
+        prop.name = name;
+    }
+
+    function setDescription(GovFiveProposal storage prop, string memory description) internal {
+        prop.description = description;
+    }
+
+    function action(GovFiveProposal storage prop, address receiver, string memory fullsig, bytes memory data)
+        internal
+    {
+        prop.actions.push(GovFiveAction({receiver: receiver, fullsig: fullsig, data: data}));
+    }
+
+    function printTxData(GovFiveProposal storage prop) internal {
+        console.log("-----------------------------------");
+        console.log("Create following tx on Gnosis safe:");
+        console.log("-----------------------------------");
+        for (uint256 i = 0; i < prop.actions.length; i++) {
+            GovFiveAction memory propAction = prop.actions[i];
+            bytes memory sig = abi.encodePacked(bytes4(keccak256(bytes(propAction.fullsig))));
+
+            console.log("### Tx", i + 1);
+            console.log("Address:", propAction.receiver);
+            console.log("Data:");
+            console.logBytes(abi.encodePacked(sig, propAction.data));
+        }
+    }
+
+    function execute(GovFiveProposal storage prop) internal {
+        address VM_ADDRESS = address(uint160(uint256(keccak256("hevm cheat code"))));
+        Vm vm = Vm(VM_ADDRESS);
+        for (uint256 i = 0; i < prop.actions.length; i++) {
+            GovFiveAction memory propAction = prop.actions[i];
+            bytes memory sig = abi.encodePacked(bytes4(keccak256(bytes(propAction.fullsig))));
+            vm.prank(Addresses.TIMELOCK);
+            (bool success, bytes memory data) = propAction.receiver.call(abi.encodePacked(sig, propAction.data));
+            if (!success) {
+                console.log(propAction.fullsig);
+                revert("Multisig action failed");
+            }
+        }
+    }
+}

foundry.toml

@@ -3,9 +3,12 @@ src = 'contracts'
 test = 'tests'
 remappings = [
   "contracts/=./contracts",
+  "script/=./script",
+  "tests/=./tests",
   "OpenZeppelin/openzeppelin-contracts@02fcc75bb7f35376c22def91b0fb9bc7a50b9458/=./lib/openzeppelin-contracts",
   "OpenZeppelin/openzeppelin-contracts-upgradeable@a16f26a063cd018c4c986832c3df332a131f53b9/=./lib/openzeppelin-contracts-upgradeable",
   "OpenZeppelin/[email protected]/=./lib/openzeppelin-contracts",
   "OpenZeppelin/[email protected]/=./lib/openzeppelin-contracts-upgradeable",
   "paulrberg/[email protected]/=./lib/prb-math"
 ]
+fs_permissions = [{ access = "read-write", path = "./build"}]

script/deploy/DeployManager.sol

@@ -0,0 +1,146 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity 0.8.10;
+
+import "forge-std/Script.sol";
+import "OpenZeppelin/[email protected]/contracts/utils/Strings.sol";
+
+import {BaseMainnetScript} from "./mainnet/BaseMainnetScript.sol";
+
+import {XOGNSetupScript} from "./mainnet/010_xOGNSetupScript.sol";
+import {OgnOgvMigrationScript} from "./mainnet/011_OgnOgvMigrationScript.sol";
+import {XOGNGovernanceScript} from "./mainnet/012_xOGNGovernanceScript.sol";
+
+contract DeployManager is Script {
+    mapping(string => address) public deployedContracts;
+    mapping(string => bool) public scriptsExecuted;
+
+    function isForked() public view returns (bool) {
+        return vm.isContext(VmSafe.ForgeContext.ScriptDryRun) || vm.isContext(VmSafe.ForgeContext.Test)
+            || vm.isContext(VmSafe.ForgeContext.TestGroup);
+    }
+
+    function getDeploymentFilePath() public view returns (string memory) {
+        return isForked() ? getForkDeploymentFilePath() : getMainnetDeploymentFilePath();
+    }
+
+    function getMainnetDeploymentFilePath() public view returns (string memory) {
+        return string(abi.encodePacked(vm.projectRoot(), "/build/deployments.json"));
+    }
+
+    function getForkDeploymentFilePath() public view returns (string memory) {
+        return string(abi.encodePacked(vm.projectRoot(), "/build/deployments-fork.json"));
+    }
+
+    function setUp() external {
+        string memory chainIdStr = Strings.toString(block.chainid);
+        string memory chainIdKey = string(abi.encodePacked(".", chainIdStr));
+
+        string memory mainnetFilePath = getMainnetDeploymentFilePath();
+        if (!vm.isFile(mainnetFilePath)) {
+            // Create mainnet deployment file if it doesn't exist
+            vm.writeFile(
+                mainnetFilePath,
+                string(abi.encodePacked('{ "', chainIdStr, '": { "executions": {}, "contracts": {} } }'))
+            );
+        } else if (!vm.keyExistsJson(vm.readFile(mainnetFilePath), chainIdKey)) {
+            // Create network entry if it doesn't exist
+            vm.writeJson(
+                vm.serializeJson(chainIdStr, '{ "executions": {}, "contracts": {} }'), mainnetFilePath, chainIdKey
+            );
+        }
+
+        if (isForked()) {
+            // Duplicate Mainnet File
+            vm.writeFile(getForkDeploymentFilePath(), vm.readFile(mainnetFilePath));
+        }
+    }
+
+    function run() external {
+        // TODO: Use vm.readDir to recursively build this?
+        _runDeployFile(new XOGNSetupScript());
+        _runDeployFile(new OgnOgvMigrationScript());
+        _runDeployFile(new XOGNGovernanceScript());
+    }
+
+    function _runDeployFile(BaseMainnetScript deployScript) internal {
+        string memory chainIdStr = Strings.toString(block.chainid);
+        string memory chainIdKey = string(abi.encodePacked(".", chainIdStr));
+
+        string memory contractsKey = string(abi.encodePacked(chainIdKey, ".contracts"));
+        string memory executionsKey = string(abi.encodePacked(chainIdKey, ".executions"));
+
+        string memory deploymentsFilePath = getDeploymentFilePath();
+        string memory fileContents = vm.readFile(deploymentsFilePath);
+
+        /**
+         * Execution History
+         */
+        string memory currentExecutions = "";
+        string[] memory executionKeys = vm.parseJsonKeys(fileContents, executionsKey);
+
+        for (uint256 i = 0; i < executionKeys.length; ++i) {
+            uint256 deployedTimestamp =
+                vm.parseJsonUint(fileContents, string(abi.encodePacked(executionsKey, ".", executionKeys[i])));
+
+            currentExecutions = vm.serializeUint(executionsKey, executionKeys[i], deployedTimestamp);
+            scriptsExecuted[executionKeys[i]] = true;
+        }
+
+        if (scriptsExecuted[deployScript.DEPLOY_NAME()]) {
+            // TODO: Handle any active governance proposal
+            console.log("Skipping already deployed script");
+            return;
+        }
+
+        /**
+         * Pre-deployment
+         */
+        string memory networkDeployments = "";
+        string[] memory existingContracts = vm.parseJsonKeys(fileContents, contractsKey);
+        for (uint256 i = 0; i < existingContracts.length; ++i) {
+            address deployedAddr =
+                vm.parseJsonAddress(fileContents, string(abi.encodePacked(contractsKey, ".", existingContracts[i])));
+
+            networkDeployments = vm.serializeAddress(contractsKey, existingContracts[i], deployedAddr);
+
+            deployedContracts[existingContracts[i]] = deployedAddr;
+
+            deployScript.preloadDeployedContract(existingContracts[i], deployedAddr);
+        }
+
+        // Deployment
+        deployScript.setUp();
+        deployScript.run();
+
+        /**
+         * Post-deployment
+         */
+        BaseMainnetScript.DeployRecord[] memory records = deployScript.getAllDeployRecords();
+
+        for (uint256 i = 0; i < records.length; ++i) {
+            string memory name = records[i].name;
+            address addr = records[i].addr;
+
+            console.log(string(abi.encodePacked("> Recorded Deploy of ", name, " at")), addr);
+            networkDeployments = vm.serializeAddress(contractsKey, name, addr);
+            deployedContracts[name] = addr;
+        }
+
+        vm.writeJson(networkDeployments, deploymentsFilePath, contractsKey);
+        console.log("> Deployment addresses stored.");
+
+        /**
+         * Write Execution History
+         */
+        currentExecutions = vm.serializeUint(executionsKey, deployScript.DEPLOY_NAME(), block.timestamp);
+
+        // Sleep 0.5s so that the previous write is complete
+        vm.sleep(500);
+        vm.writeJson(currentExecutions, deploymentsFilePath, executionsKey);
+        console.log("> Deploy script execution complete.");
+    }
+
+    function getDeployment(string calldata contractName) external view returns (address) {
+        return deployedContracts[contractName];
+    }
+}