@arbitrum/nitro-contracts 2.0.0 → 3.0.0-alpha.0

package/src/rollup/RollupAdminLogic.sol

@@ -9,22 +9,19 @@ import "./IRollupLogic.sol";
 import "./RollupCore.sol";
 import "../bridge/IOutbox.sol";
 import "../bridge/ISequencerInbox.sol";
-import "../challenge/IChallengeManager.sol";
 import "../libraries/DoubleLogicUUPSUpgradeable.sol";
 import "@openzeppelin/contracts/proxy/beacon/UpgradeableBeacon.sol";
 
-import {NO_CHAL_INDEX} from "../libraries/Constants.sol";
-
 contract RollupAdminLogic is RollupCore, IRollupAdmin, DoubleLogicUUPSUpgradeable {
-    function initialize(Config calldata config, ContractDependencies calldata connectedContracts)
-        external
-        override
-        onlyProxy
-        initializer
-    {
+    using AssertionStateLib for AssertionState;
+    using EnumerableSetUpgradeable for EnumerableSetUpgradeable.AddressSet;
+
+    function initialize(
+        Config calldata config,
+        ContractDependencies calldata connectedContracts
+    ) external override onlyProxy initializer {
         rollupDeploymentBlock = block.number;
         bridge = connectedContracts.bridge;
-        sequencerInbox = connectedContracts.sequencerInbox;
         connectedContracts.bridge.setDelayedInbox(address(connectedContracts.inbox), true);
         connectedContracts.bridge.setSequencerInbox(address(connectedContracts.sequencerInbox));
 
@@ -32,65 +29,91 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, DoubleLogicUUPSUpgradeabl
         outbox = connectedContracts.outbox;
         connectedContracts.bridge.setOutbox(address(connectedContracts.outbox), true);
         rollupEventInbox = connectedContracts.rollupEventInbox;
-        connectedContracts.bridge.setDelayedInbox(
-            address(connectedContracts.rollupEventInbox),
-            true
-        );
 
-        connectedContracts.rollupEventInbox.rollupInitialized(config.chainId, config.chainConfig);
-        connectedContracts.sequencerInbox.addSequencerL2Batch(
-            0,
-            "",
-            1,
-            IGasRefunder(address(0)),
-            0,
-            1
-        );
+        // dont need to connect and initialize the event inbox if it's already been initialized
+        if (!bridge.allowedDelayedInboxes(address(connectedContracts.rollupEventInbox))) {
+            connectedContracts.bridge.setDelayedInbox(
+                address(connectedContracts.rollupEventInbox), true
+            );
+            connectedContracts.rollupEventInbox.rollupInitialized(
+                config.chainId, config.chainConfig
+            );
+        }
+
+        if (connectedContracts.sequencerInbox.totalDelayedMessagesRead() == 0) {
+            connectedContracts.sequencerInbox.addSequencerL2Batch(
+                0, "", 1, IGasRefunder(address(0)), 0, 1
+            );
+        }
 
-        validatorUtils = connectedContracts.validatorUtils;
         validatorWalletCreator = connectedContracts.validatorWalletCreator;
         challengeManager = connectedContracts.challengeManager;
 
-        Node memory node = createInitialNode();
-        initializeCore(node);
-
         confirmPeriodBlocks = config.confirmPeriodBlocks;
-        extraChallengeTimeBlocks = config.extraChallengeTimeBlocks;
         chainId = config.chainId;
         baseStake = config.baseStake;
         wasmModuleRoot = config.wasmModuleRoot;
         // A little over 15 minutes
         minimumAssertionPeriod = 75;
-
-        // the owner can't access the rollup user facet where escrow is redeemable
-        require(config.loserStakeEscrow != _getAdmin(), "INVALID_ESCROW_ADMIN");
-        // this next check shouldn't be an issue if the owner controls an AdminProxy
-        // that accesses the admin facet, but still seems like a good extra precaution
-        require(config.loserStakeEscrow != config.owner, "INVALID_ESCROW_OWNER");
+        // ValidatorAfkBlocks is defaulted to 28 days assuming a 12 seconds block time.
+        // Since it can take 14 days under normal circumstances to confirm an assertion, this means
+        // the validators will have been inactive for a further 14 days before the whitelist is removed.
+        validatorAfkBlocks = 201600;
+        challengeGracePeriodBlocks = config.challengeGracePeriodBlocks;
+
+        // loser stake is now sent directly to loserStakeEscrow, it must not
+        // be address(0) because some token do not allow transfers to address(0)
+        require(config.loserStakeEscrow != address(0), "INVALID_ESCROW_0");
         loserStakeEscrow = config.loserStakeEscrow;
 
         stakeToken = config.stakeToken;
+        anyTrustFastConfirmer = config.anyTrustFastConfirmer;
+
+        bytes32 parentAssertionHash = bytes32(0);
+        bytes32 inboxAcc = bytes32(0);
+        bytes32 genesisHash = RollupLib.assertionHash({
+            parentAssertionHash: parentAssertionHash,
+            afterStateHash: config.genesisAssertionState.hash(),
+            inboxAcc: inboxAcc
+        });
+
+        uint256 currentInboxCount = bridge.sequencerMessageCount();
+        // ensure to move the inbox forward by at least one message
+        if (currentInboxCount == config.genesisInboxCount) {
+            currentInboxCount += 1;
+        }
+        AssertionNode memory initialAssertion = AssertionNodeLib.createAssertion(
+            true,
+            RollupLib.configHash({
+                wasmModuleRoot: wasmModuleRoot,
+                requiredStake: baseStake,
+                challengeManager: address(challengeManager),
+                confirmPeriodBlocks: confirmPeriodBlocks,
+                nextInboxPosition: uint64(currentInboxCount)
+            })
+        );
+        initializeCore(initialAssertion, genesisHash);
+
+        AssertionInputs memory assertionInputs;
+        assertionInputs.afterState = config.genesisAssertionState;
+        emit AssertionCreated(
+            genesisHash,
+            parentAssertionHash,
+            assertionInputs,
+            inboxAcc,
+            currentInboxCount,
+            wasmModuleRoot,
+            baseStake,
+            address(challengeManager),
+            confirmPeriodBlocks
+        );
+        if (_hostChainIsArbitrum) {
+            _assertionCreatedAtArbSysBlock[genesisHash] = ArbSys(address(100)).arbBlockNumber();
+        }
 
         emit RollupInitialized(config.wasmModuleRoot, config.chainId);
     }
 
-    function createInitialNode() private view returns (Node memory) {
-        GlobalState memory emptyGlobalState;
-        bytes32 state = RollupLib.stateHashMem(
-            ExecutionState(emptyGlobalState, MachineStatus.FINISHED),
-            1 // inboxMaxCount - force the first assertion to read a message
-        );
-        return
-            NodeLib.createNode(
-                state,
-                0, // challenge hash (not challengeable)
-                0, // confirm data
-                0, // prev node
-                uint64(block.number), // deadline block (not challengeable)
-                0 // initial node has a node hash of 0
-            );
-    }
-
     /**
      * Functions are only to reach this logic contract if the caller is the owner
      * so there is no need for a redundant onlyOwner check
@@ -100,20 +123,26 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, DoubleLogicUUPSUpgradeabl
      * @notice Add a contract authorized to put messages into this rollup's inbox
      * @param _outbox Outbox contract to add
      */
-    function setOutbox(IOutbox _outbox) external override {
+    function setOutbox(
+        IOutbox _outbox
+    ) external override {
         outbox = _outbox;
         bridge.setOutbox(address(_outbox), true);
-        emit OwnerFunctionCalled(0);
+        emit OutboxSet(address(_outbox));
+        // previously: emit OwnerFunctionCalled(0);
     }
 
     /**
      * @notice Disable an old outbox from interacting with the bridge
      * @param _outbox Outbox contract to remove
      */
-    function removeOldOutbox(address _outbox) external override {
+    function removeOldOutbox(
+        address _outbox
+    ) external override {
         require(_outbox != address(outbox), "CUR_OUTBOX");
         bridge.setOutbox(_outbox, false);
-        emit OwnerFunctionCalled(1);
+        emit OldOutboxRemoved(address(_outbox));
+        // previously: emit OwnerFunctionCalled(1);
     }
 
     /**
@@ -123,19 +152,20 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, DoubleLogicUUPSUpgradeabl
      */
     function setDelayedInbox(address _inbox, bool _enabled) external override {
         bridge.setDelayedInbox(address(_inbox), _enabled);
-        emit OwnerFunctionCalled(2);
+        emit DelayedInboxSet(address(_inbox), _enabled);
+        // previously: emit OwnerFunctionCalled(2);
     }
 
     /**
      * @notice Pause interaction with the rollup contract.
-     * The time spent paused is not incremented in the rollup's timing for node validation.
-     * @dev this function may be frontrun by a validator (ie to create a node before the system is paused).
+     * The time spent paused is not incremented in the rollup's timing for assertion validation.
+     * @dev this function may be frontrun by a validator (ie to create a assertion before the system is paused).
      * The pause should be called atomically with required checks to be sure the system is paused in a consistent state.
-     * The RollupAdmin may execute a check against the Rollup's latest node num or the ChallengeManager, then execute this function atomically with it.
+     * The RollupAdmin may execute a check against the Rollup's latest assertion num or the OldChallengeManager, then execute this function atomically with it.
      */
     function pause() external override {
         _pause();
-        emit OwnerFunctionCalled(3);
+        // previously: emit OwnerFunctionCalled(3);
     }
 
     /**
@@ -143,18 +173,22 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, DoubleLogicUUPSUpgradeabl
      */
     function resume() external override {
         _unpause();
-        emit OwnerFunctionCalled(4);
+        // previously: emit OwnerFunctionCalled(4);
     }
 
     /// @notice allows the admin to upgrade the primary logic contract (ie rollup admin logic, aka this)
     /// @dev this function doesn't revert as this primary logic contract is only
     /// reachable by the proxy's admin
-    function _authorizeUpgrade(address newImplementation) internal override {}
+    function _authorizeUpgrade(
+        address newImplementation
+    ) internal override {}
 
     /// @notice allows the admin to upgrade the secondary logic contract (ie rollup user logic)
     /// @dev this function doesn't revert as this primary logic contract is only
     /// reachable by the proxy's admin
-    function _authorizeSecondaryUpgrade(address newImplementation) internal override {}
+    function _authorizeSecondaryUpgrade(
+        address newImplementation
+    ) internal override {}
 
     /**
      * @notice Set the addresses of the validator whitelist
@@ -168,9 +202,12 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, DoubleLogicUUPSUpgradeabl
         require(_validator.length == _val.length, "WRONG_LENGTH");
 
         for (uint256 i = 0; i < _validator.length; i++) {
-            isValidator[_validator[i]] = _val[i];
+            if (_val[i]) validators.add(_validator[i]);
+            else validators.remove(_validator[i]);
         }
-        emit OwnerFunctionCalled(6);
+
+        emit ValidatorsSet(_validator, _val);
+        // previously: emit OwnerFunctionCalled(6);
     }
 
     /**
@@ -178,216 +215,200 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, DoubleLogicUUPSUpgradeabl
      * @dev it is expected that only the rollup admin can use this facet to set a new owner
      * @param newOwner address of new rollup owner
      */
-    function setOwner(address newOwner) external override {
+    function setOwner(
+        address newOwner
+    ) external override {
         _changeAdmin(newOwner);
-        emit OwnerFunctionCalled(7);
+        // previously: emit OwnerFunctionCalled(7);
     }
 
     /**
      * @notice Set minimum assertion period for the rollup
      * @param newPeriod new minimum period for assertions
      */
-    function setMinimumAssertionPeriod(uint256 newPeriod) external override {
+    function setMinimumAssertionPeriod(
+        uint256 newPeriod
+    ) external override {
         minimumAssertionPeriod = newPeriod;
-        emit OwnerFunctionCalled(8);
+        emit MinimumAssertionPeriodSet(newPeriod);
+        // previously: emit OwnerFunctionCalled(8);
     }
 
     /**
-     * @notice Set number of blocks until a node is considered confirmed
-     * @param newConfirmPeriod new number of blocks
+     * @notice Set validator afk blocks for the rollup
+     * @param  newAfkBlocks new number of blocks before a validator is considered afk (0 to disable)
+     * @dev    ValidatorAfkBlocks is the number of blocks since the last confirmed
+     *         assertion (or its first child) before the validator whitelist is removed.
+     *         It's important that this time is greater than the max amount of time it can take to
+     *         to confirm an assertion via the normal method. Therefore we need it to be greater
+     *         than max(2* confirmPeriod, 2 * challengePeriod) with some additional margin.
      */
-    function setConfirmPeriodBlocks(uint64 newConfirmPeriod) external override {
-        require(newConfirmPeriod > 0, "INVALID_CONFIRM_PERIOD");
-        confirmPeriodBlocks = newConfirmPeriod;
-        emit OwnerFunctionCalled(9);
+    function setValidatorAfkBlocks(
+        uint64 newAfkBlocks
+    ) external override {
+        validatorAfkBlocks = newAfkBlocks;
+        emit ValidatorAfkBlocksSet(newAfkBlocks);
     }
 
     /**
-     * @notice Set number of extra blocks after a challenge
-     * @param newExtraTimeBlocks new number of blocks
+     * @notice Set number of blocks until a assertion is considered confirmed
+     * @param newConfirmPeriod new number of blocks
      */
-    function setExtraChallengeTimeBlocks(uint64 newExtraTimeBlocks) external override {
-        extraChallengeTimeBlocks = newExtraTimeBlocks;
-        emit OwnerFunctionCalled(10);
+    function setConfirmPeriodBlocks(
+        uint64 newConfirmPeriod
+    ) external override {
+        require(newConfirmPeriod > 0, "INVALID_CONFIRM_PERIOD");
+        confirmPeriodBlocks = newConfirmPeriod;
+        emit ConfirmPeriodBlocksSet(newConfirmPeriod);
+        // previously: emit OwnerFunctionCalled(9);
     }
 
     /**
      * @notice Set base stake required for an assertion
      * @param newBaseStake minimum amount of stake required
      */
-    function setBaseStake(uint256 newBaseStake) external override {
+    function setBaseStake(
+        uint256 newBaseStake
+    ) external override {
+        // we do not currently allow base stake to be reduced since as doing so might allow a malicious party
+        // to withdraw some (up to the difference between baseStake and newBaseStake) honest funds from this contract
+        // The sequence of events is as follows:
+        // 1. The malicious party creates a sibling assertion, stake size is currently S
+        // 2. The base stake is then reduced to S'
+        // 3. The malicious party uses a different address to create a child of the malicious assertion, using stake size S'
+        // 4. This allows the malicious party to withdraw the stake S, since assertions with children set the staker to "inactive"
+        require(newBaseStake > baseStake, "BASE_STAKE_MUST_BE_INCREASED");
         baseStake = newBaseStake;
-        emit OwnerFunctionCalled(12);
+        emit BaseStakeSet(newBaseStake);
+        // previously: emit OwnerFunctionCalled(12);
     }
 
-    /**
-     * @notice Set the token used for stake, where address(0) == eth
-     * @dev Before changing the base stake token, you might need to change the
-     * implementation of the Rollup User facet!
-     * @param newStakeToken address of token used for staking
-     */
-    function setStakeToken(address newStakeToken) external override whenPaused {
-        /*
-         * To change the stake token without breaking consistency one would need to:
-         * Pause the system, have all stakers remove their funds,
-         * update the user logic to handle ERC20s, change the stake token, then resume.
-         *
-         * Note: To avoid loss of funds stakers must remove their funds and claim all the
-         * available withdrawable funds before the system is paused.
-         */
-        bool expectERC20Support = newStakeToken != address(0);
-        // this assumes the rollup isn't its own admin. if needed, instead use a ProxyAdmin by OZ!
-        bool actualERC20Support = IRollupUser(address(this)).isERC20Enabled();
-        require(actualERC20Support == expectERC20Support, "NO_USER_LOGIC_SUPPORT");
-        require(stakerCount() == 0, "NO_ACTIVE_STAKERS");
-        require(totalWithdrawableFunds == 0, "NO_PENDING_WITHDRAW");
-        stakeToken = newStakeToken;
-        emit OwnerFunctionCalled(13);
-    }
-
-    /**
-     * @notice Upgrades the implementation of a beacon controlled by the rollup
-     * @param beacon address of beacon to be upgraded
-     * @param newImplementation new address of implementation
-     */
-    function upgradeBeacon(address beacon, address newImplementation) external override {
-        UpgradeableBeacon(beacon).upgradeTo(newImplementation);
-        emit OwnerFunctionCalled(20);
-    }
-
-    function forceResolveChallenge(address[] calldata stakerA, address[] calldata stakerB)
-        external
-        override
-        whenPaused
-    {
-        require(stakerA.length > 0, "EMPTY_ARRAY");
-        require(stakerA.length == stakerB.length, "WRONG_LENGTH");
-        for (uint256 i = 0; i < stakerA.length; i++) {
-            uint64 chall = inChallenge(stakerA[i], stakerB[i]);
-
-            require(chall != NO_CHAL_INDEX, "NOT_IN_CHALL");
-            clearChallenge(stakerA[i]);
-            clearChallenge(stakerB[i]);
-            challengeManager.clearChallenge(chall);
-        }
-        emit OwnerFunctionCalled(21);
-    }
-
-    function forceRefundStaker(address[] calldata staker) external override whenPaused {
+    function forceRefundStaker(
+        address[] calldata staker
+    ) external override whenPaused {
         require(staker.length > 0, "EMPTY_ARRAY");
         for (uint256 i = 0; i < staker.length; i++) {
-            require(_stakerMap[staker[i]].currentChallenge == NO_CHAL_INDEX, "STAKER_IN_CHALL");
+            requireInactiveStaker(staker[i]);
             reduceStakeTo(staker[i], 0);
-            turnIntoZombie(staker[i]);
         }
-        emit OwnerFunctionCalled(22);
+        emit StakersForceRefunded(staker);
+        // previously: emit OwnerFunctionCalled(22);
     }
 
-    function forceCreateNode(
-        uint64 prevNode,
-        uint256 prevNodeInboxMaxCount,
-        Assertion calldata assertion,
-        bytes32 expectedNodeHash
+    function forceCreateAssertion(
+        bytes32 prevAssertionHash,
+        AssertionInputs calldata assertion,
+        bytes32 expectedAssertionHash
     ) external override whenPaused {
-        require(prevNode == latestConfirmed(), "ONLY_LATEST_CONFIRMED");
-
-        createNewNode(assertion, prevNode, prevNodeInboxMaxCount, expectedNodeHash);
-
-        emit OwnerFunctionCalled(23);
+        // To update the wasm module root in the case of a bug:
+        // 0. pause the contract
+        // 1. update the wasm module root in the contract
+        // 2. update the config hash of the assertion after which you wish to use the new wasm module root (functionality not written yet)
+        // 3. force refund the stake of the current leaf assertion(s)
+        // 4. create a new assertion using the assertion with the updated config has as a prev
+        // 5. force confirm it - this is necessary to set latestConfirmed on the correct line
+        // 6. unpause the contract
+
+        // Normally, a new assertion is created using its prev's confirmPeriodBlocks
+        // in the case of a force create, we use the rollup's current confirmPeriodBlocks
+        createNewAssertion(assertion, prevAssertionHash, expectedAssertionHash);
+
+        emit AssertionForceCreated(expectedAssertionHash);
+        // previously: emit OwnerFunctionCalled(23);
     }
 
-    function forceConfirmNode(
-        uint64 nodeNum,
-        bytes32 blockHash,
-        bytes32 sendRoot
+    function forceConfirmAssertion(
+        bytes32 assertionHash,
+        bytes32 parentAssertionHash,
+        AssertionState calldata confirmState,
+        bytes32 inboxAcc
     ) external override whenPaused {
-        // this skips deadline, staker and zombie validation
-        confirmNode(nodeNum, blockHash, sendRoot);
-        emit OwnerFunctionCalled(24);
+        // this skip deadline, prev, challenge validations
+        confirmAssertionInternal(assertionHash, parentAssertionHash, confirmState, inboxAcc);
+        emit AssertionForceConfirmed(assertionHash);
+        // previously: emit OwnerFunctionCalled(24);
     }
 
-    function setLoserStakeEscrow(address newLoserStakerEscrow) external override {
-        // escrow holder can't be proxy admin, since escrow is only redeemable through
-        // the primary user logic contract
-        require(newLoserStakerEscrow != _getAdmin(), "INVALID_ESCROW");
+    function setLoserStakeEscrow(
+        address newLoserStakerEscrow
+    ) external override {
+        // loser stake is now sent directly to loserStakeEscrow, it must not
+        // be address(0) because some token do not allow transfers to address(0)
+        require(newLoserStakerEscrow != address(0), "INVALID_ESCROW_0");
         loserStakeEscrow = newLoserStakerEscrow;
-        emit OwnerFunctionCalled(25);
+        emit LoserStakeEscrowSet(newLoserStakerEscrow);
+        // previously: emit OwnerFunctionCalled(25);
     }
 
     /**
      * @notice Set the proving WASM module root
      * @param newWasmModuleRoot new module root
      */
-    function setWasmModuleRoot(bytes32 newWasmModuleRoot) external override {
+    function setWasmModuleRoot(
+        bytes32 newWasmModuleRoot
+    ) external override {
         wasmModuleRoot = newWasmModuleRoot;
-        emit OwnerFunctionCalled(26);
+        emit WasmModuleRootSet(newWasmModuleRoot);
+        // previously: emit OwnerFunctionCalled(26);
     }
 
     /**
      * @notice set a new sequencer inbox contract
      * @param _sequencerInbox new address of sequencer inbox
      */
-    function setSequencerInbox(address _sequencerInbox) external override {
+    function setSequencerInbox(
+        address _sequencerInbox
+    ) external override {
         bridge.setSequencerInbox(_sequencerInbox);
-        emit OwnerFunctionCalled(27);
+        emit SequencerInboxSet(_sequencerInbox);
+        // previously: emit OwnerFunctionCalled(27);
     }
 
     /**
      * @notice sets the rollup's inbox reference. Does not update the bridge's view.
      * @param newInbox new address of inbox
      */
-    function setInbox(IInboxBase newInbox) external {
+    function setInbox(
+        IInboxBase newInbox
+    ) external {
         inbox = newInbox;
-        emit OwnerFunctionCalled(28);
-    }
-
-    function createNitroMigrationGenesis(Assertion calldata assertion) external whenPaused {
-        bytes32 expectedSendRoot = bytes32(0);
-        uint64 expectedInboxCount = 1;
-
-        require(latestNodeCreated() == 0, "NON_GENESIS_NODES_EXIST");
-        require(GlobalStateLib.isEmpty(assertion.beforeState.globalState), "NOT_EMPTY_BEFORE");
-        require(
-            assertion.beforeState.machineStatus == MachineStatus.FINISHED,
-            "BEFORE_MACHINE_NOT_FINISHED"
-        );
-        // accessors such as state.getSendRoot not available for calldata structs, only memory
-        require(
-            assertion.afterState.globalState.bytes32Vals[1] == expectedSendRoot,
-            "NOT_ZERO_SENDROOT"
-        );
-        require(
-            assertion.afterState.globalState.u64Vals[0] == expectedInboxCount,
-            "INBOX_NOT_AT_ONE"
-        );
-        require(assertion.afterState.globalState.u64Vals[1] == 0, "POSITION_IN_MESSAGE_NOT_ZERO");
-        require(
-            assertion.afterState.machineStatus == MachineStatus.FINISHED,
-            "AFTER_MACHINE_NOT_FINISHED"
-        );
-        bytes32 genesisBlockHash = assertion.afterState.globalState.bytes32Vals[0];
-        createNewNode(assertion, 0, expectedInboxCount, bytes32(0));
-        confirmNode(1, genesisBlockHash, expectedSendRoot);
-        emit OwnerFunctionCalled(29);
+        emit InboxSet(address(newInbox));
+        // previously: emit OwnerFunctionCalled(28);
     }
 
     /**
      * @notice set the validatorWhitelistDisabled flag
      * @param _validatorWhitelistDisabled new value of validatorWhitelistDisabled, i.e. true = disabled
      */
-    function setValidatorWhitelistDisabled(bool _validatorWhitelistDisabled) external {
+    function setValidatorWhitelistDisabled(
+        bool _validatorWhitelistDisabled
+    ) external {
         validatorWhitelistDisabled = _validatorWhitelistDisabled;
-        emit OwnerFunctionCalled(30);
+        emit ValidatorWhitelistDisabledSet(_validatorWhitelistDisabled);
+        // previously: emit OwnerFunctionCalled(30);
     }
 
     /**
      * @notice set the anyTrustFastConfirmer address
-     *         must also call `setValidator` to set the same address as a validator to work
-     *         old fast confirmer need to be removed from the validator list manually
      * @param _anyTrustFastConfirmer new value of anyTrustFastConfirmer
      */
-    function setAnyTrustFastConfirmer(address _anyTrustFastConfirmer) external {
+    function setAnyTrustFastConfirmer(
+        address _anyTrustFastConfirmer
+    ) external {
         anyTrustFastConfirmer = _anyTrustFastConfirmer;
-        emit OwnerFunctionCalled(31);
+        emit AnyTrustFastConfirmerSet(_anyTrustFastConfirmer);
+        // previously: emit OwnerFunctionCalled(31);
+    }
+
+    /**
+     * @notice set a new challengeManager contract
+     * @param _challengeManager new value of challengeManager
+     */
+    function setChallengeManager(
+        address _challengeManager
+    ) external {
+        challengeManager = IEdgeChallengeManager(_challengeManager);
+        emit ChallengeManagerSet(_challengeManager);
+        // previously: emit OwnerFunctionCalled(32);
     }
 }