Test branch

.github/workflows/scenario-tests.yml

@@ -0,0 +1,20 @@
+name: scenario-test
+
+on:
+  pull_request:
+
+jobs:
+  scenario-test:
+    runs-on: ubuntu-latest
+    steps:     
+    - name: Pull Docker image
+      run: docker pull andlyn/arpanetwork-test:latest
+
+    - name: Run Docker container
+      run: |
+        docker run --name=scenario \
+          andlyn/arpanetwork-test:latest \
+          /bin/bash -c "git config --global url."https://".insteadOf git://; \
+          git clone ${{ github.repositoryUrl }}; \
+          cd BLS-TSS-Network; git fetch origin pull/${{ github.event.pull_request.number }}/head:${{ github.head_ref }}; git checkout ${{ github.head_ref }}; \
+          robot ./"

.gitignore

@@ -33,6 +33,8 @@ solidity/build
 # Custom
 contracts/test/Test.t.sol
 .DS_Store
+/.venv
 *.sqlite
 passwd
+*.pyc
 *.history

contracts/script/ControllerScenarioTest.s.sol

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import {Script} from "forge-std/Script.sol";
+import {Controller} from "../src/Controller.sol";
+import {ControllerProxy} from "../src/ControllerProxy.sol";
+import {IControllerOwner} from "../src/interfaces/IControllerOwner.sol";
+import {Adapter} from "../src/Adapter.sol";
+import {IAdapterOwner} from "../src/interfaces/IAdapterOwner.sol";
+import {Arpa} from "./ArpaLocalTest.sol";
+import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
+import {ERC20} from "openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";
+import {ERC1967Proxy} from "openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+import {Staking} from "Staking-v0.1/Staking.sol";
+
+// solhint-disable-next-line max-states-count
+contract ControllerScenarioTest is Script {
+    uint256 internal _deployerPrivateKey = vm.envUint("ADMIN_PRIVATE_KEY");
+
+    uint256 internal _disqualifiedNodePenaltyAmount = vm.envUint("DISQUALIFIED_NODE_PENALTY_AMOUNT");
+    uint256 internal _defaultNumberOfCommitters = vm.envUint("DEFAULT_NUMBER_OF_COMMITTERS");
+    uint256 internal _defaultDkgPhaseDuration = vm.envUint("DEFAULT_DKG_PHASE_DURATION");
+    uint256 internal _groupMaxCapacity = vm.envUint("GROUP_MAX_CAPACITY");
+    uint256 internal _idealNumberOfGroups = vm.envUint("IDEAL_NUMBER_OF_GROUPS");
+    uint256 internal _pendingBlockAfterQuit = vm.envUint("PENDING_BLOCK_AFTER_QUIT");
+    uint256 internal _dkgPostProcessReward = vm.envUint("DKG_POST_PROCESS_REWARD");
+    uint256 internal _lastOutput = vm.envUint("LAST_OUTPUT");
+
+    uint16 internal _minimumRequestConfirmations = uint16(vm.envUint("MINIMUM_REQUEST_CONFIRMATIONS"));
+    uint32 internal _maxGasLimit = uint32(vm.envUint("MAX_GAS_LIMIT"));
+    uint32 internal _gasAfterPaymentCalculation = uint32(vm.envUint("GAS_AFTER_PAYMENT_CALCULATION"));
+    uint32 internal _gasExceptCallback = uint32(vm.envUint("GAS_EXCEPT_CALLBACK"));
+    uint256 internal _signatureTaskExclusiveWindow = vm.envUint("SIGNATURE_TASK_EXCLUSIVE_WINDOW");
+    uint256 internal _rewardPerSignature = vm.envUint("REWARD_PER_SIGNATURE");
+    uint256 internal _committerRewardPerSignature = vm.envUint("COMMITTER_REWARD_PER_SIGNATURE");
+
+    uint32 internal _fulfillmentFlatFeeEthPPMTier1 = uint32(vm.envUint("FULFILLMENT_FLAT_FEE_ARPA_PPM_TIER1"));
+    uint32 internal _fulfillmentFlatFeeEthPPMTier2 = uint32(vm.envUint("FULFILLMENT_FLAT_FEE_ARPA_PPM_TIER2"));
+    uint32 internal _fulfillmentFlatFeeEthPPMTier3 = uint32(vm.envUint("FULFILLMENT_FLAT_FEE_ARPA_PPM_TIER3"));
+    uint32 internal _fulfillmentFlatFeeEthPPMTier4 = uint32(vm.envUint("FULFILLMENT_FLAT_FEE_ARPA_PPM_TIER4"));
+    uint32 internal _fulfillmentFlatFeeEthPPMTier5 = uint32(vm.envUint("FULFILLMENT_FLAT_FEE_ARPA_PPM_TIER5"));
+    uint24 internal _reqsForTier2 = uint24(vm.envUint("REQS_FOR_TIER2"));
+    uint24 internal _reqsForTier3 = uint24(vm.envUint("REQS_FOR_TIER3"));
+    uint24 internal _reqsForTier4 = uint24(vm.envUint("REQS_FOR_TIER4"));
+    uint24 internal _reqsForTier5 = uint24(vm.envUint("REQS_FOR_TIER5"));
+
+    uint16 internal _flatFeePromotionGlobalPercentage = uint16(vm.envUint("FLAT_FEE_PROMOTION_GLOBAL_PERCENTAGE"));
+    bool internal _isFlatFeePromotionEnabledPermanently = vm.envBool("IS_FLAT_FEE_PROMOTION_ENABLED_PERMANENTLY");
+    uint256 internal _flatFeePromotionStartTimestamp = block.timestamp;
+    uint256 internal _flatFeePromotionEndTimestamp = block.timestamp + 86400;
+
+    uint256 internal _initialMaxPoolSize = vm.envUint("INITIAL_MAX_POOL_SIZE");
+    uint256 internal _initialMaxCommunityStakeAmount = vm.envUint("INITIAL_MAX_COMMUNITY_STAKE_AMOUNT");
+    uint256 internal _minCommunityStakeAmount = vm.envUint("MIN_COMMUNITY_STAKE_AMOUNT");
+    uint256 internal _operatorStakeAmount = vm.envUint("OPERATOR_STAKE_AMOUNT");
+    uint256 internal _minInitialOperatorCount = vm.envUint("MIN_INITIAL_OPERATOR_COUNT");
+    uint256 internal _minRewardDuration = vm.envUint("MIN_REWARD_DURATION");
+    uint256 internal _delegationRateDenominator = vm.envUint("DELEGATION_RATE_DENOMINATOR");
+    uint256 internal _unstakeFreezingDuration = vm.envUint("UNSTAKE_FREEZING_DURATION");
+
+    function run() external {
+        Controller controller;
+        ControllerProxy proxy;
+        ERC1967Proxy adapter;
+        Adapter adapterImpl;
+        Staking staking;
+        IERC20 arpa;
+
+        vm.broadcast(_deployerPrivateKey);
+        arpa = new Arpa();
+
+        Staking.PoolConstructorParams memory params = Staking.PoolConstructorParams(
+            IERC20(address(arpa)),
+            _initialMaxPoolSize,
+            _initialMaxCommunityStakeAmount,
+            _minCommunityStakeAmount,
+            _operatorStakeAmount,
+            _minInitialOperatorCount,
+            _minRewardDuration,
+            _delegationRateDenominator,
+            _unstakeFreezingDuration
+        );
+        vm.broadcast(_deployerPrivateKey);
+        staking = new Staking(params);
+
+        vm.broadcast(_deployerPrivateKey);
+        controller = new Controller();
+
+        vm.broadcast(_deployerPrivateKey);
+        proxy = new ControllerProxy(address(controller));
+
+        vm.broadcast(_deployerPrivateKey);
+        IControllerOwner(address(proxy)).initialize(address(staking), _lastOutput);
+
+        vm.broadcast(_deployerPrivateKey);
+        adapterImpl = new Adapter();
+
+        vm.broadcast(_deployerPrivateKey);
+        adapter =
+            new ERC1967Proxy(address(adapterImpl),abi.encodeWithSignature("initialize(address)",address(proxy)));
+
+        vm.broadcast(_deployerPrivateKey);
+        IControllerOwner(address(proxy)).setControllerConfig(
+            address(staking),
+            address(adapter),
+            _operatorStakeAmount,
+            _disqualifiedNodePenaltyAmount,
+            _defaultNumberOfCommitters,
+            _defaultDkgPhaseDuration,
+            _groupMaxCapacity,
+            _idealNumberOfGroups,
+            _pendingBlockAfterQuit,
+            _dkgPostProcessReward
+        );
+
+        vm.broadcast(_deployerPrivateKey);
+        IAdapterOwner(address(adapter)).setAdapterConfig(
+            _minimumRequestConfirmations,
+            _maxGasLimit,
+            _gasAfterPaymentCalculation,
+            _gasExceptCallback,
+            _signatureTaskExclusiveWindow,
+            _rewardPerSignature,
+            _committerRewardPerSignature
+            );
+
+        vm.broadcast(_deployerPrivateKey);        
+        IAdapterOwner(address(adapter)).setFlatFeeConfig(
+            IAdapterOwner.FeeConfig(
+                _fulfillmentFlatFeeEthPPMTier1,
+                _fulfillmentFlatFeeEthPPMTier2,
+                _fulfillmentFlatFeeEthPPMTier3,
+                _fulfillmentFlatFeeEthPPMTier4,
+                _fulfillmentFlatFeeEthPPMTier5,
+                _reqsForTier2,
+                _reqsForTier3,
+                _reqsForTier4,
+                _reqsForTier5
+            ),
+            _flatFeePromotionGlobalPercentage,
+            _isFlatFeePromotionEnabledPermanently,
+            _flatFeePromotionStartTimestamp,
+            _flatFeePromotionEndTimestamp
+        );
+
+        vm.broadcast(_deployerPrivateKey);
+        staking.setController(address(proxy));
+    }
+}

contracts/script/GetRandomNumberScenarioTest.s.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.18;
+
+import {Script} from "forge-std/Script.sol";
+import {IAdapter} from "../src/interfaces/IAdapter.sol";
+import {GetRandomNumberExample} from "../src/user/examples/GetRandomNumberExample.sol";
+
+contract GetRandomNumberScenarioTestScript is Script {
+    function run() external {
+        GetRandomNumberExample getRandomNumberExample;
+        IAdapter adapter;
+
+        uint256 plentyOfEthBalance = vm.envUint("PLENTY_OF_ETH_BALANCE");
+        address adapterAddress = vm.envAddress("ADAPTER_ADDRESS");
+        uint256 userPrivateKey = vm.envUint("USER_PRIVATE_KEY");
+
+        adapter = IAdapter(adapterAddress);
+
+        vm.startBroadcast(userPrivateKey);
+        getRandomNumberExample = new GetRandomNumberExample(
+            adapterAddress
+        );
+        uint64 subId = adapter.createSubscription();
+
+        adapter.fundSubscription{value: plentyOfEthBalance}(subId);
+
+        adapter.addConsumer(subId, address(getRandomNumberExample));
+
+        getRandomNumberExample.setCallbackGasConfig(2000000, 1500000000);
+
+    }
+}

contracts/script/StakeOperatorScenarioTest.s.sol

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import {Script} from "forge-std/Script.sol";
+import {Staking} from "Staking-v0.1/Staking.sol";
+import {Arpa} from "./ArpaLocalTest.sol";
+
+contract StakeOperatorScenarioTestScript is Script {
+    uint256 internal _deployerPrivateKey = vm.envUint("ADMIN_PRIVATE_KEY");
+    uint256 internal _userPrivateKey = vm.envUint("USER_PRIVATE_KEY");
+
+    address internal _stakingAddress = vm.envAddress("STAKING_ADDRESS");
+    address internal _arpaAddress = vm.envAddress("ARPA_ADDRESS");
+
+    uint256 internal _rewardAmount = vm.envUint("REWARD_AMOUNT");
+    uint256 internal _operatorStakeAmount = vm.envUint("OPERATOR_STAKE_AMOUNT");
+
+    address[] internal _operators;
+    string internal _mnemonic = vm.envString("STAKING_NODES_MNEMONIC");
+    uint32 internal _stakingNodesIndexOffset = uint32(vm.envUint("STAKING_NODES_INDEX_OFFSET"));
+    uint32 internal _stakingNodesIndexLength = 10;
+    bool internal _isStakeUser = vm.envBool("IS_STAKE_USER");
+
+    Staking internal _staking;
+    Arpa internal _arpa;
+
+    function run() external {
+        _arpa = Arpa(_arpaAddress);
+        _staking = Staking(_stakingAddress);
+
+        // add operators
+        for (uint32 i = _stakingNodesIndexOffset; i < _stakingNodesIndexOffset + _stakingNodesIndexLength; i++) {
+            address operator = vm.rememberKey(vm.deriveKey(_mnemonic, i));
+            _operators.push(operator);
+
+            address payable toOperator = payable(operator);
+            vm.broadcast(_deployerPrivateKey);
+            toOperator.transfer(1 ether);
+        }
+
+        vm.broadcast(_deployerPrivateKey);
+        _staking.addOperators(_operators);
+
+        // start the _staking pool
+        vm.broadcast(_deployerPrivateKey);
+        _arpa.mint(vm.addr(_deployerPrivateKey), _rewardAmount);
+
+        vm.broadcast(_deployerPrivateKey);
+        _arpa.approve(address(_staking), _rewardAmount);
+
+
+        // let a user stake to accumulate some rewards
+        if (_isStakeUser) {
+            vm.broadcast(_deployerPrivateKey);
+            _staking.start(_rewardAmount, 30 days);
+            vm.rememberKey(_userPrivateKey);
+            _stake(vm.addr(_userPrivateKey));
+        }
+
+    }
+
+    function _stake(address sender) internal {
+        vm.broadcast(sender);
+        _arpa.mint(sender, _operatorStakeAmount);
+
+        vm.broadcast(sender);
+        _arpa.approve(address(_staking), _operatorStakeAmount);
+
+        vm.broadcast(sender);
+        _staking.stake(_operatorStakeAmount);
+    }
+}

contracts/script/TestFeeConfig.s.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import {Script} from "forge-std/Script.sol";
+import {Controller} from "../src/Controller.sol";
+import {IControllerOwner} from "../src/interfaces/IControllerOwner.sol";
+import {Adapter} from "../src/Adapter.sol";
+import {IAdapterOwner} from "../src/interfaces/IAdapterOwner.sol";
+import {Arpa} from "./ArpaLocalTest.sol";
+import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
+import {ERC20} from "openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";
+import {ERC1967Proxy} from "openzeppelin-contracts/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+import {Staking} from "Staking-v0.1/Staking.sol";
+
+// solhint-disable-next-line max-states-count
+contract TestFeeConfigScript is Script {
+    uint256 internal _deployerPrivateKey = vm.envUint("DEPLOY_PRIVATE_KEY");
+
+    uint32 internal _fulfillmentFlatFeeEthPPMTier1 = uint32(vm.envUint("FULFILLMENT_FLAT_FEE_ARPA_PPM_TIER1"));
+    uint32 internal _fulfillmentFlatFeeEthPPMTier2 = uint32(vm.envUint("FULFILLMENT_FLAT_FEE_ARPA_PPM_TIER2"));
+    uint32 internal _fulfillmentFlatFeeEthPPMTier3 = uint32(vm.envUint("FULFILLMENT_FLAT_FEE_ARPA_PPM_TIER3"));
+    uint32 internal _fulfillmentFlatFeeEthPPMTier4 = uint32(vm.envUint("FULFILLMENT_FLAT_FEE_ARPA_PPM_TIER4"));
+    uint32 internal _fulfillmentFlatFeeEthPPMTier5 = uint32(vm.envUint("FULFILLMENT_FLAT_FEE_ARPA_PPM_TIER5"));
+    uint24 internal _reqsForTier2 = uint24(vm.envUint("REQS_FOR_TIER2"));
+    uint24 internal _reqsForTier3 = uint24(vm.envUint("REQS_FOR_TIER3"));
+    uint24 internal _reqsForTier4 = uint24(vm.envUint("REQS_FOR_TIER4"));
+    uint24 internal _reqsForTier5 = uint24(vm.envUint("REQS_FOR_TIER5"));
+
+    uint16 internal _flatFeePromotionGlobalPercentage = uint16(vm.envUint("FLAT_FEE_PROMOTION_GLOBAL_PERCENTAGE"));
+    bool internal _isFlatFeePromotionEnabledPermanently = vm.envBool("IS_FLAT_FEE_PROMOTION_ENABLED_PERMANENTLY");
+    uint256 internal _flatFeePromotionStartTimestamp = block.timestamp;
+    uint256 internal _flatFeePromotionEndTimestamp = block.timestamp + 120;
+
+
+    address internal _controllerAddress = vm.envAddress("CONTROLLER_ADDRESS");
+    address internal _stakingAddress = vm.envAddress("STAKING_ADDRESS");
+    address internal _adapterAddress = vm.envAddress("ADAPTER_ADDRESS");
+
+    function run() external {
+        vm.broadcast(_deployerPrivateKey);
+        IAdapterOwner(_adapterAddress).setReferralConfig(
+            true,
+            2,
+            2
+        );
+    }
+}