feat(extension): Add OptimisticAuctionRebalanceExtension

contracts/adapters/AuctionRebalanceExtension.sol

@@ -49,8 +49,8 @@ contract AuctionRebalanceExtension is BaseExtension {
 
     /* ============ State Variables ============ */
 
-    ISetToken public setToken;
-    IAuctionRebalanceModuleV1 public auctionModule;  // AuctionRebalanceModuleV1
+    ISetToken public immutable setToken;
+    IAuctionRebalanceModuleV1 public immutable auctionModule;  // AuctionRebalanceModuleV1
 
     /* ============ Constructor ============ */
 
@@ -88,6 +88,7 @@ contract AuctionRebalanceExtension is BaseExtension {
         uint256 _positionMultiplier
     )
         external
+        virtual
         onlyOperator
     {
         address[] memory currentComponents = setToken.getComponents();

contracts/interfaces/IIdentifierWhitelist.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.4;
+
+interface IIdentifierWhitelist {
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+    event SupportedIdentifierAdded(bytes32 indexed identifier);
+    event SupportedIdentifierRemoved(bytes32 indexed identifier);
+
+    function addSupportedIdentifier(bytes32 identifier) external;
+    function isIdentifierSupported(bytes32 identifier) external view returns (bool);
+    function owner() external view returns (address);
+    function removeSupportedIdentifier(bytes32 identifier) external;
+    function renounceOwnership() external;
+    function transferOwnership(address newOwner) external;
+}

contracts/interfaces/OptimisticOracleV3Interface.sol

@@ -39,6 +39,15 @@ interface OptimisticOracleV3Interface {
         uint256 finalFee; // Final fee of the currency.
     }
 
+    /**
+     * @notice Disputes an assertion. Depending on how the assertion was configured, this may either escalate to the UMA
+     * DVM or the configured escalation manager for arbitration.
+     * @dev The caller must approve this contract to spend at least bond amount of currency for the associated assertion.
+     * @param assertionId unique identifier for the assertion to dispute.
+     * @param disputer receives bonds back at settlement.
+     */
+    function disputeAssertion(bytes32 assertionId, address disputer) external;
+
     /**
      * @notice Returns the default identifier used by the Optimistic Oracle V3.
      * @return The default identifier.
@@ -167,4 +176,4 @@ interface OptimisticOracleV3Interface {
     );
 
     event AdminPropertiesSet(IERC20 defaultCurrency, uint64 defaultLiveness, uint256 burnedBondPercentage);
-}
+}

contracts/lib/AssetAllowList.sol

@@ -0,0 +1,147 @@
+/*
+    Copyright 2023 Index Coop
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+    SPDX-License-Identifier: Apache License, Version 2.0
+*/
+
+pragma solidity 0.6.10;
+import { AddressArrayUtils } from "./AddressArrayUtils.sol";
+
+/**
+ * @title AssetAllowList
+ * @author Index Coop
+ *
+ * Abstract contract that allows inheriting contracts to restrict the assets that can be traded to, wrapped to, or claimed
+ */
+abstract contract AssetAllowList {
+    using AddressArrayUtils for address[];
+
+    /* ============ Events ============ */
+
+    event AllowedAssetAdded(
+        address indexed _asset
+    );
+
+    event AllowedAssetRemoved(
+        address indexed _asset
+    );
+
+    event UseAssetAllowlistUpdated(
+        bool _status
+    );
+
+    /* ============ State Variables ============ */
+
+    // Boolean indicating wether to use asset allow list
+    bool public useAssetAllowlist;
+
+    // Mapping keeping track of allowed assets
+    mapping(address => bool) public assetAllowlist;
+
+    // List of allowed assets
+    address[] internal allowedAssets;
+
+    /* ============ Modifiers ============ */
+
+    modifier onlyAllowedAssets(address[] memory _assets) {
+        require(
+            _areAllowedAssets(_assets),
+            "Invalid asset"
+        );
+        _;
+    }
+
+    /* ============ Constructor ============ */
+
+    /**
+     * Set state variables and map asset pairs to their oracles
+     *
+     * @param _allowedAssets           Array of allowed assets 
+     * @param _useAssetAllowlist       Bool indicating whether to use asset allow list
+     */
+    constructor(address[] memory _allowedAssets, bool _useAssetAllowlist) public {
+        _addAllowedAssets(_allowedAssets);
+        _updateUseAssetAllowlist(_useAssetAllowlist);
+    }
+
+    /* ============ External Functions ============ */
+
+    function getAllowedAssets() external view returns(address[] memory) {
+        return allowedAssets;
+    }
+
+    /* ============ Internal Functions ============ */
+
+
+    /**
+     * Add new assets that can be traded to, wrapped to, or claimed
+     *
+     * @param _assets           New asset to add
+     */
+    function _addAllowedAssets(address[] memory _assets) internal {
+        for (uint256 i = 0; i < _assets.length; i++) {
+            address asset = _assets[i];
+
+            require(!assetAllowlist[asset], "Asset already added");
+
+            allowedAssets.push(asset);
+
+            assetAllowlist[asset] = true;
+
+            emit AllowedAssetAdded(asset);
+        }
+    }
+
+    /**
+     * Remove asset(s) so that it/they can't be traded to, wrapped to, or claimed
+     *
+     * @param _assets           Asset(s) to remove
+     */
+    function _removeAllowedAssets(address[] memory _assets) internal {
+        for (uint256 i = 0; i < _assets.length; i++) {
+            address asset = _assets[i];
+
+            require(assetAllowlist[asset], "Asset not already added");
+
+            allowedAssets.removeStorage(asset);
+
+            assetAllowlist[asset] = false;
+
+            emit AllowedAssetRemoved(asset);
+        }
+    }
+
+    /**
+     * Toggle useAssetAllowlist on and off. When false asset allowlist is ignored
+     * when true it is enforced.
+     *
+     * @param _useAssetAllowlist           Bool indicating whether to use asset allow list
+     */
+    function _updateUseAssetAllowlist(bool _useAssetAllowlist) internal {
+        useAssetAllowlist = _useAssetAllowlist;
+
+        emit UseAssetAllowlistUpdated(_useAssetAllowlist);
+    }
+
+    /// @notice Check that all assets in array are allowed to be treated
+    /// @dev ca be bypassed by setting the useAssetAllowlist to false (default)
+    function _areAllowedAssets(address[] memory _assets) internal view returns(bool) {
+        if (!useAssetAllowlist) { return true; }
+        for (uint256 i = 0; i < _assets.length; i++) {
+            if (!assetAllowlist[_assets[i]]) { return false; }
+        }
+        return true;
+    }
+}

contracts/mocks/OptimisticOracleV3Mock.sol

@@ -21,11 +21,16 @@ interface callbackInterface {
  * tradeoffs, enabling the notion of "sovereign security".
  */
 contract OptimisticOracleV3Mock is OptimisticOracleV3Interface {
+    address public asserter;
     // Mock implementation of defaultIdentifier
     function defaultIdentifier() public view override returns (bytes32) {
         return (bytes32("helloWorld"));
     }
 
+    function setAsserter(address _asserter) public {
+        asserter = _asserter;
+    }
+
     // Mock implementation of getAssertion
     function getAssertion(bytes32 ) public view override returns (Assertion memory) {
         return (Assertion({
@@ -36,7 +41,7 @@ contract OptimisticOracleV3Mock is OptimisticOracleV3Interface {
                 assertingCaller: address(0),
                 escalationManager: address(0)
             }),
-            asserter: address(0),
+            asserter: asserter,
             assertionTime: uint64(0),
             settled: false,
             currency: IERC20(address(0)),
@@ -80,6 +85,10 @@ contract OptimisticOracleV3Mock is OptimisticOracleV3Interface {
         return (false);
     }
 
+    function disputeAssertion(bytes32 assertionId, address disputer) external override {
+        revert("Not implemented");
+    }
+
     // Mock implementation of getMinimumBond
     function getMinimumBond(address ) public view override returns (uint256) {
         return (uint256(0));
@@ -95,4 +104,4 @@ contract OptimisticOracleV3Mock is OptimisticOracleV3Interface {
         callbackInterface(target).assertionResolvedCallback(assertionId, truthfully);
     }
 
-}
+}