@arbitrum/nitro-contracts 3.1.1 → 3.2.0

package/src/precompiles/ArbOwnerPublic.sol

@@ -12,11 +12,9 @@ interface ArbOwnerPublic {
         address addr
     ) external view returns (bool);
 
-    /**
-     * @notice Rectify the list of chain owners
-     * If successful, emits ChainOwnerRectified event
-     * Available in ArbOS version 11
-     */
+    /// @notice Rectify the list of chain owners
+    /// @notice If successful, emits ChainOwnerRectified event
+    /// @notice Available in ArbOS version 11 and above
     function rectifyChainOwner(
         address ownerToRectify
     ) external;
@@ -24,14 +22,19 @@ interface ArbOwnerPublic {
     /// @notice Retrieves the list of chain owners
     function getAllChainOwners() external view returns (address[] memory);
 
+    /// @notice Retrieves the timestamp from when the native token management
+    /// modifications are enabled.
+    /// @notice Available in ArbOS version 50 and above
+    function getNativeTokenManagementFrom() external view returns (uint64);
+
     /// @notice See if the user is a native token owner
-    /// Available in ArbOS version 41
+    /// @notice Available in ArbOS version 41 and above
     function isNativeTokenOwner(
         address addr
     ) external view returns (bool);
 
     /// @notice Retrieves the list of native token owners
-    /// Available in ArbOS version 41
+    /// @notice Available in ArbOS version 41 and above
     function getAllNativeTokenOwners() external view returns (address[] memory);
 
     /// @notice Gets the network fee collector
@@ -41,20 +44,23 @@ interface ArbOwnerPublic {
     function getInfraFeeAccount() external view returns (address);
 
     /// @notice Get the Brotli compression level used for fast compression
+    /// @notice Available in ArbOS version 20 and above
     function getBrotliCompressionLevel() external view returns (uint64);
 
+    /// @notice Get how much L1 charges per non-zero byte of calldata
+    /// @notice Available in ArbOS version 50 and above
+    function getParentGasFloorPerToken() external view returns (uint64);
+
     /// @notice Get the next scheduled ArbOS version upgrade and its activation timestamp.
-    /// Returns (0, 0) if no ArbOS upgrade is scheduled.
-    /// Available in ArbOS version 20.
+    /// @notice Returns (0, 0) if no ArbOS upgrade is scheduled.
+    /// @notice Available in ArbOS version 20 and above
     function getScheduledUpgrade()
         external
         view
         returns (uint64 arbosVersion, uint64 scheduledForTimestamp);
 
-    /**
-     * @notice Checks if the increased calldata price feature (EIP-7623) is enabled
-     * Available in ArbOS version 40 with default as false
-     */
+    /// @notice Checks if the increased calldata price feature (EIP-7623) is enabled
+    /// @notice Available in ArbOS version 40 with default as false
     function isCalldataPriceIncreaseEnabled() external view returns (bool);
 
     event ChainOwnerRectified(address rectifiedOwner);

package/src/precompiles/ArbWasm.sol

@@ -7,6 +7,7 @@ pragma solidity >=0.4.21 <0.9.0;
 /**
  * @title Methods for managing user programs
  * @notice Precompiled contract that exists in every Arbitrum chain at 0x0000000000000000000000000000000000000071.
+ * @notice Available in ArbOS version 30 and above
  */
 interface ArbWasm {
     /// @notice Activate a wasm program

package/src/precompiles/ArbWasmCache.sol

@@ -7,6 +7,7 @@ pragma solidity >=0.4.21 <0.9.0;
 /**
  * @title Methods for managing Stylus caches
  * @notice Precompiled contract that exists in every Arbitrum chain at 0x0000000000000000000000000000000000000072.
+ * @notice Available in ArbOS version 30 and above
  */
 interface ArbWasmCache {
     /// @notice See if the user is a cache manager.
@@ -19,6 +20,7 @@ interface ArbWasmCache {
     function allCacheManagers() external view returns (address[] memory managers);
 
     /// @dev Deprecated, replaced with cacheProgram
+    /// @notice Available in ArbOS version 30 only
     function cacheCodehash(
         bytes32 codehash
     ) external;
@@ -27,6 +29,7 @@ interface ArbWasmCache {
     /// @notice Reverts if the programs have expired.
     /// @notice Caller must be a cache manager or chain owner.
     /// @notice If you're looking for how to bid for position, interact with the chain's cache manager contract.
+    /// @notice Available in ArbOS version 31 and above
     function cacheProgram(
         address addr
     ) external;

package/src/precompiles/ArbosActs.sol

@@ -44,5 +44,15 @@ interface ArbosActs {
         uint256 l1BaseFeeWei
     ) external;
 
+    function batchPostingReportV2(
+        uint256 batchTimestamp,
+        address batchPosterAddress,
+        uint64 batchNumber,
+        uint64 batchCalldataLength,
+        uint64 batchCalldataNonZeros,
+        uint64 batchExtraGas,
+        uint256 l1BaseFeeWei
+    ) external;
+
     error CallerNotArbOS();
 }

package/src/precompiles/LICENSE.md

@@ -0,0 +1,116 @@
+Business Source License 1.1
+
+License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+
+-----------------------------------------------------------------------------
+
+Parameters
+
+Licensor:             Offchain Labs
+
+Licensed Work:        Arbitrum Nitro Contracts
+                      The Licensed Work is (c) 2021-2024 Offchain Labs
+
+Additional Use Grant: You may use the Licensed Work in a production environment solely
+                      to provide a point of interface to permit end users or applications
+                      utilizing the Covered Arbitrum Chains to interact and query the
+                      state of a Covered Arbitrum Chain, including without limitation
+                      validating the correctness of the posted chain state, or to deploy
+                      and operate (x) a blockchain that settles to a Covered Arbitrum Chain
+                      or (y) a blockchain in accordance with, and subject to, the [Arbitrum
+                      Expansion Program Term of Use](https://docs.arbitrum.foundation/aep/ArbitrumExpansionProgramTerms.pdf). For purposes of this
+                      Additional Use Grant, the "Covered Arbitrum Chains" are 
+                      (a) Arbitrum One (chainid:42161), Arbitrum Nova (chainid:42170), 
+                      Arbitrum Rinkeby testnet/Rinkarby (chainid:421611),Arbitrum Nitro
+                      Goerli testnet (chainid:421613), and Arbitrum Sepolia Testnet
+                      (chainid:421614); (b) any future blockchains authorized to be
+                      designated as Covered Arbitrum Chains by the decentralized autonomous
+                      organization governing the Arbitrum network; and (c) any “Layer 3”
+                      Arbitrum-based blockchain that is built on and settles to another
+                      Covered Arbitrum Chain.
+
+
+
+Change Date:          Dec 31, 2028
+
+Change License:       Apache License Version 2.0
+
+-----------------------------------------------------------------------------
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited
+production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph
+above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.
+
+MariaDB hereby grants you permission to use this License’s text to license
+your works, and to refer to it using the trademark "Business Source License",
+as long as you comply with the Covenants of Licensor below.
+
+-----------------------------------------------------------------------------
+
+Covenants of Licensor
+
+In consideration of the right to use this License’s text and the "Business
+Source License" name and trademark, Licensor covenants to MariaDB, and to all
+other recipients of the licensed work to be provided by Licensor:
+
+1. To specify as the Change License the GPL Version 2.0 or any later version,
+   or a license that is compatible with GPL Version 2.0 or a later version,
+   where "compatible" means that software provided under the Change License can
+   be included in a program with software provided under GPL Version 2.0 or a
+   later version. Licensor may specify additional Change Licenses without
+   limitation.
+
+2. To either: (a) specify an additional grant of rights to use that does not
+   impose any additional restriction on the right granted in this License, as
+   the Additional Use Grant; or (b) insert the text "None".
+
+3. To specify a Change Date.
+
+4. Not to modify this License in any other way.
+
+-----------------------------------------------------------------------------
+
+Notice
+
+The Business Source License (this document, or the "License") is not an Open
+Source license. However, the Licensed Work will eventually be made available
+under an Open Source License, as stated in this License.

package/src/precompiles/README.md

@@ -0,0 +1,11 @@
+# Nitro Precompile Interfaces
+
+Solidity interfaces for Arbitrum Nitro precompiled contracts.
+
+## Overview
+
+This repository contains the Solidity interface definitions for Arbitrum Nitro's precompiled contracts.
+
+## License
+
+Licensed under BUSL-1.1. See individual files for specific license information.

package/src/precompiles/foundry.toml

@@ -0,0 +1,20 @@
+[profile.default]
+src = ''
+
+[fmt]
+line_length = 100
+tab_width = 4
+bracket_spacing = false
+int_types = "long"
+multiline_func_header = "params_first"
+quote_style = "double"
+number_underscore = "preserve"
+hex_underscore = "remove"
+single_line_statement_blocks = "preserve"
+override_spacing = false
+wrap_comments = false
+ignore = []
+contract_new_lines = false
+sort_imports = false
+
+# See more config options https://github.com/foundry-rs/foundry/tree/master/config

package/src/precompiles/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@arbitrum/nitro-precompile-interfaces",
+  "version": "41.0.0",
+  "description": "Solidity interfaces for Arbitrum Nitro precompiled contracts",
+  "author": "Offchain Labs, Inc.",
+  "license": "BUSL-1.1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/offchainlabs/nitro-precompile-interfaces.git"
+  },
+  "files": [
+    "*.sol",
+    "README.md",
+    "LICENSE.md"
+  ],
+  "bugs": {
+    "url": "https://github.com/offchainlabs/nitro-precompile-interfaces/issues"
+  },
+  "scripts": {
+    "build": "forge build",
+    "format": "forge fmt"
+  },
+  "private": false
+}

package/src/precompiles/yarn.lock

@@ -0,0 +1,4 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+

package/src/rollup/AbsRollupEventInbox.sol

@@ -50,11 +50,17 @@ abstract contract AbsRollupEventInbox is
 
     function rollupInitialized(
         uint256 chainId,
-        string calldata chainConfig
+        string calldata chainConfig,
+        uint256 dataCostEstimate
     ) external override onlyRollup {
         require(bytes(chainConfig).length > 0, "EMPTY_CHAIN_CONFIG");
         uint8 initMsgVersion = 1;
-        uint256 currentDataCost = _currentDataCostToReport();
+        uint256 currentDataCost;
+        if (dataCostEstimate != 0) {
+            currentDataCost = dataCostEstimate;
+        } else {
+            currentDataCost = _currentDataCostToReport();
+        }
         bytes memory initMsg =
             abi.encodePacked(chainId, initMsgVersion, currentDataCost, chainConfig);
         uint256 num = _enqueueInitializationMsg(initMsg);

package/src/rollup/BOLDUpgradeAction.sol

@@ -8,7 +8,6 @@ import "@openzeppelin/contracts-upgradeable/utils/Create2Upgradeable.sol";
 import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
 import "./RollupProxy.sol";
 import "./RollupLib.sol";
-import "./RollupAdminLogic.sol";
 
 struct Node {
     // Hash of the state of the chain as of this node
@@ -392,7 +391,8 @@ contract BOLDUpgradeAction {
             anyTrustFastConfirmer: address(0), // fast confirmer would be migrated from the old rollup if existed
             numBigStepLevel: NUM_BIGSTEP_LEVEL,
             challengeGracePeriodBlocks: CHALLENGE_GRACE_PERIOD_BLOCKS,
-            bufferConfig: bufferConfig
+            bufferConfig: bufferConfig,
+            dataCostEstimate: 0
         });
     }
 

package/src/rollup/BridgeCreator.sol

@@ -18,7 +18,7 @@ import "../bridge/IBridge.sol";
 import "@openzeppelin/contracts/access/Ownable.sol";
 import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
 
-contract BridgeCreator is Ownable {
+contract BridgeCreator {
     BridgeTemplates public ethBasedTemplates;
     BridgeTemplates public erc20BasedTemplates;
 
@@ -45,25 +45,11 @@ contract BridgeCreator is Ownable {
     constructor(
         BridgeTemplates memory _ethBasedTemplates,
         BridgeTemplates memory _erc20BasedTemplates
-    ) Ownable() {
+    ) {
         ethBasedTemplates = _ethBasedTemplates;
         erc20BasedTemplates = _erc20BasedTemplates;
     }
 
-    function updateTemplates(
-        BridgeTemplates calldata _newTemplates
-    ) external onlyOwner {
-        ethBasedTemplates = _newTemplates;
-        emit TemplatesUpdated();
-    }
-
-    function updateERC20Templates(
-        BridgeTemplates calldata _newTemplates
-    ) external onlyOwner {
-        erc20BasedTemplates = _newTemplates;
-        emit ERC20TemplatesUpdated();
-    }
-
     function _createBridge(
         bytes32 create2Salt,
         address adminProxy,

package/src/rollup/Config.sol

@@ -38,6 +38,8 @@ struct Config {
     uint8 numBigStepLevel;
     uint64 challengeGracePeriodBlocks;
     BufferConfig bufferConfig;
+    /// @notice Parent chain's base fee estimate for rollup initialization, if 0 block.basefee will be used
+    uint256 dataCostEstimate;
 }
 
 struct ContractDependencies {

package/src/rollup/IRollupAdmin.sol

@@ -150,10 +150,22 @@ interface IRollupAdmin {
     ) external;
 
     /**
-     * @notice Set base stake required for an assertion
-     * @param newBaseStake maximum avmgas to be used per block
+     * @notice Decrease the base stake required for creating an assertion
+     * @dev    Can only be called on permissioned chains with whitelist enabled
+     *         Can only be called when there is exactly one stake on a pending assertion - this ensures a linear chain of assertions
+     *         Cannot be called immediately after genesis since there are no pending assertions
+     *         After decreasing the base stake the current staker will still have full stake locked up. They can release it by creating a new staker with the
+     *         new smaller amount, and using it to create a child of the latest pending assertion. This will make the old staker inactive and withdrawable.
+     * @param newBaseStake New base stake to be set. Must be less than current base stake, otherwise use increaseBaseStake
+     * @param latestNextInboxPosition The nextInboxPosition of the only pending latestStakedAssertion
      */
-    function setBaseStake(
+    function decreaseBaseStake(uint256 newBaseStake, uint64 latestNextInboxPosition) external;
+
+    /**
+     * @notice Increase the base stake required for creating an assertion
+     * @param newBaseStake New base stake to be set. Must be greater than current base stake, otherwise use reduceBaseStake
+     */
+    function increaseBaseStake(
         uint256 newBaseStake
     ) external;
 

package/src/rollup/IRollupEventInbox.sol

@@ -17,5 +17,9 @@ interface IRollupEventInbox {
 
     function updateRollupAddress() external;
 
-    function rollupInitialized(uint256 chainId, string calldata chainConfig) external;
+    function rollupInitialized(
+        uint256 chainId,
+        string calldata chainConfig,
+        uint256 l1BaseFeeEstimate
+    ) external;
 }

package/src/rollup/RollupAdminLogic.sol

@@ -10,7 +10,6 @@ import "./RollupCore.sol";
 import "../bridge/IOutbox.sol";
 import "../bridge/ISequencerInbox.sol";
 import "../libraries/DoubleLogicUUPSUpgradeable.sol";
-import "@openzeppelin/contracts/proxy/beacon/UpgradeableBeacon.sol";
 
 contract RollupAdminLogic is RollupCore, IRollupAdmin, DoubleLogicUUPSUpgradeable {
     using AssertionStateLib for AssertionState;
@@ -36,7 +35,7 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, DoubleLogicUUPSUpgradeabl
                 address(connectedContracts.rollupEventInbox), true
             );
             connectedContracts.rollupEventInbox.rollupInitialized(
-                config.chainId, config.chainConfig
+                config.chainId, config.chainConfig, config.dataCostEstimate
             );
         }
 
@@ -264,20 +263,80 @@ contract RollupAdminLogic is RollupCore, IRollupAdmin, DoubleLogicUUPSUpgradeabl
     }
 
     /**
-     * @notice Set base stake required for an assertion
-     * @param newBaseStake minimum amount of stake required
+     * @inheritdoc IRollupAdmin
      */
-    function setBaseStake(
-        uint256 newBaseStake
+    function decreaseBaseStake(
+        uint256 newBaseStake,
+        uint64 latestNextInboxPosition
     ) external override {
-        // we do not currently allow base stake to be reduced since as doing so might allow a malicious party
+        require(newBaseStake < baseStake, "BASE_STAKE_NOT_DECREASED");
+
+        // if we're decreasing the stake we need to be more careful not to 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'
+        // 2. The base stake is then decreased 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");
+
+        // for this reason the base stake can only be decreased on permissioned chains where the creation of pending assertions can be controlled
+        // In a permissionless setting, it's possible for a staker to DOS base stake decrease by creating themselves as a staker.
+        // we can do a basic safety check to ensure that we're in the permissioned setting by checking that there is only one
+        // staker on a pending assertion. It could be that we're in the permissionless setting and that pending assertion is a malicious one
+        // but we assume that the rollup admin will ensure that's not the case before calling this function by checking that a staker they trust is
+        // on a correct pending assertion.
+        require(validatorWhitelistDisabled == false, "DECREASE_ONLY_FOR_PERMISSIONED_CHAINS");
+
+        bytes32 currentConfigHash = RollupLib.configHash({
+            wasmModuleRoot: wasmModuleRoot,
+            requiredStake: baseStake,
+            challengeManager: address(challengeManager),
+            confirmPeriodBlocks: confirmPeriodBlocks,
+            nextInboxPosition: uint64(latestNextInboxPosition)
+        });
+
+        uint256 pendingCount = 0;
+        uint64 nStakers = stakerCount();
+        for (uint64 i = 0; i < nStakers; i++) {
+            bytes32 latestStaked = latestStakedAssertion(getStakerAddress(i));
+            AssertionNode storage latestAssertion = getAssertionStorage(latestStaked);
+            if (latestAssertion.status == AssertionStatus.Pending) {
+                // check that in overwriting the config hash, we'll only be updating the required stake field
+                require(latestAssertion.configHash == currentConfigHash, "EXPIRED_CONFIG_HASH");
+                // In order to support transitioning from permissioned to permissionless, we need to ensure that after the transition
+                // a malicious party cannot created decreased stake assertions as children of historical (even confirmed) assertions.
+                // To avoid this an additional check has been added in RollupUserLogic.createNewAssertion to ensure that the base stake
+                // is always >= the required stake of the prev assertion. Having added this check we also need to override the config hash of
+                // the latest staked assertion so that children can be created from it in the normal way. We do that below
+                latestAssertion.configHash = RollupLib.configHash({
+                    wasmModuleRoot: wasmModuleRoot,
+                    requiredStake: newBaseStake,
+                    challengeManager: address(challengeManager),
+                    confirmPeriodBlocks: confirmPeriodBlocks,
+                    nextInboxPosition: uint64(latestNextInboxPosition)
+                });
+
+                pendingCount++;
+            }
+
+            require(pendingCount <= 1, "TOO_MANY_PENDING_STAKERS");
+        }
+
+        // we need to have a non zero pending count to ensure that exactly one config hash was updated
+        // if no config hashes are updated then no new assertions will be created, since they will all trigger STAKE_TOO_LOW
+        require(pendingCount == 1, "PENDING_ASSERTION_NOT_UPDATED");
+
+        baseStake = newBaseStake;
+        emit BaseStakeSet(newBaseStake);
+    }
+
+    /**
+     * @inheritdoc IRollupAdmin
+     */
+    function increaseBaseStake(
+        uint256 newBaseStake
+    ) external override {
+        require(newBaseStake > baseStake, "BASE_STAKE_NOT_INCREASED");
         baseStake = newBaseStake;
         emit BaseStakeSet(newBaseStake);
         // previously: emit OwnerFunctionCalled(12);

package/src/rollup/RollupCore.sol

@@ -171,7 +171,7 @@ abstract contract RollupCore is IRollupCore, PausableUpgradeable {
      */
     function getStakerAddress(
         uint64 stakerNum
-    ) external view override returns (address) {
+    ) public view override returns (address) {
         return _stakerList[stakerNum];
     }
 
@@ -576,6 +576,11 @@ abstract contract RollupCore is IRollupCore, PausableUpgradeable {
         }
     }
 
+    /**
+     * @notice Returns an empty genesis assertion hash
+     * @dev In chains that were created with a non-empty genesis state, this function
+     *      will return a different value than the actual genesis assertion hash.
+     */
     function genesisAssertionHash() external pure returns (bytes32) {
         GlobalState memory emptyGlobalState;
         AssertionState memory emptyAssertionState =

package/src/rollup/RollupCreator.sol

@@ -13,6 +13,8 @@ import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.so
 import "@openzeppelin/contracts/access/Ownable.sol";
 import {DeployHelper} from "./DeployHelper.sol";
 import {SafeERC20, IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {OneStepProofEntry, IOneStepProofEntry, IOneStepProver} from "../osp/OneStepProofEntry.sol";
+import {OneStepProverHostIo} from "../osp/OneStepProverHostIo.sol";
 
 contract RollupCreator is Ownable {
     using SafeERC20 for IERC20;
@@ -42,6 +44,7 @@ contract RollupCreator is Ownable {
         address[] batchPosters;
         address batchPosterManager;
         IFeeTokenPricer feeTokenPricer;
+        address customOsp;
     }
 
     BridgeCreator public bridgeCreator;
@@ -55,7 +58,29 @@ contract RollupCreator is Ownable {
 
     DeployHelper public l2FactoriesDeployer;
 
-    constructor() Ownable() {}
+    constructor(
+        address initialOwner,
+        BridgeCreator _bridgeCreator,
+        IOneStepProofEntry _osp,
+        IEdgeChallengeManager _challengeManagerLogic,
+        IRollupAdmin _rollupAdminLogic,
+        IRollupUser _rollupUserLogic,
+        IUpgradeExecutor _upgradeExecutorLogic,
+        address _validatorWalletCreator,
+        DeployHelper _l2FactoriesDeployer
+    ) Ownable() {
+        setTemplates(
+            _bridgeCreator,
+            _osp,
+            _challengeManagerLogic,
+            _rollupAdminLogic,
+            _rollupUserLogic,
+            _upgradeExecutorLogic,
+            _validatorWalletCreator,
+            _l2FactoriesDeployer
+        );
+        _transferOwnership(initialOwner);
+    }
 
     // creator receives back excess fees (for deploying L2 factories) so it can refund the caller
     receive() external payable {}
@@ -69,7 +94,7 @@ contract RollupCreator is Ownable {
         IUpgradeExecutor _upgradeExecutorLogic,
         address _validatorWalletCreator,
         DeployHelper _l2FactoriesDeployer
-    ) external onlyOwner {
+    ) public onlyOwner {
         bridgeCreator = _bridgeCreator;
         osp = _osp;
         challengeManagerTemplate = _challengeManagerLogic;
@@ -85,7 +110,8 @@ contract RollupCreator is Ownable {
     function createChallengeManager(
         address rollupAddr,
         address proxyAdminAddr,
-        Config memory config
+        Config memory config,
+        address customOsp
     ) internal returns (IEdgeChallengeManager) {
         IEdgeChallengeManager challengeManager = IEdgeChallengeManager(
             address(
@@ -98,7 +124,7 @@ contract RollupCreator is Ownable {
         challengeManager.initialize({
             _assertionChain: IAssertionChain(rollupAddr),
             _challengePeriodBlocks: config.confirmPeriodBlocks,
-            _oneStepProofEntry: osp,
+            _oneStepProofEntry: customOsp == address(0) ? osp : IOneStepProofEntry(customOsp),
             layerZeroBlockEdgeHeight: config.layerZeroBlockEdgeHeight,
             layerZeroBigStepEdgeHeight: config.layerZeroBigStepEdgeHeight,
             layerZeroSmallStepEdgeHeight: config.layerZeroSmallStepEdgeHeight,
@@ -132,6 +158,8 @@ contract RollupCreator is Ownable {
      *          - maxFeePerGasForRetryables price bid for L2 execution.
      *          - batchPosters  The list of batch poster addresses, not used when set to empty list
      *          - batchPosterManager The address which has the ability to rotate batch poster keys
+     *          - feeTokenPricer Fee token pricer contract for converting custom fee token to ETH
+     *          - customOsp Custom OSP address, if set to address(0) the default OSP will be used
      * @return The address of the newly created rollup
      */
     function createRollup(
@@ -191,8 +219,9 @@ contract RollupCreator is Ownable {
             deployParams.feeTokenPricer
         );
 
-        IEdgeChallengeManager challengeManager =
-            createChallengeManager(address(rollup), address(proxyAdmin), deployParams.config);
+        IEdgeChallengeManager challengeManager = createChallengeManager(
+            address(rollup), address(proxyAdmin), deployParams.config, deployParams.customOsp
+        );
 
         // deploy and init upgrade executor
         address upgradeExecutor = _deployUpgradeExecutor(deployParams.config.owner, proxyAdmin);

package/src/rollup/RollupUserLogic.sol

@@ -184,6 +184,12 @@ contract RollupUserLogic is RollupCore, UUPSNotUpgradeable, IRollupUser {
             "INSUFFICIENT_STAKE"
         );
 
+        // the new assertion will be created with requiredStake equal to the baseStake
+        // however, for the reasons explained in RollupAdminLogic.decreaseBaseStake we cannot allow an assertion to be created
+        // base stake than it's prev. In order to reduce the base stake the config hash of the latest assertion
+        // must be overridden, this occurs in the RollupAdminLogic.decreaseBaseStake function
+        require(baseStake >= assertion.beforeStateData.configData.requiredStake, "STAKE_TOO_LOW");
+
         bytes32 prevAssertion = RollupLib.assertionHash(
             assertion.beforeStateData.prevPrevAssertionHash,
             assertion.beforeState,