SIP-167 Introduces an L2 governance bridge

.solcover.js

@@ -10,7 +10,6 @@ module.exports = {
 		'legacy',
 		'EscrowChecker.sol',
 		'ExchangeRatesWithoutInvPricing.sol',
-		'IssuerWithoutLiquidations.sol',
 		'EmptyEtherWrapper.sol',
 	],
 	providerOptions: {

contracts/MixinSystemSettings.sol

@@ -27,6 +27,7 @@ contract MixinSystemSettings is MixinResolver {
     bytes32 internal constant SETTING_CROSS_DOMAIN_ESCROW_GAS_LIMIT = "crossDomainEscrowGasLimit";
     bytes32 internal constant SETTING_CROSS_DOMAIN_REWARD_GAS_LIMIT = "crossDomainRewardGasLimit";
     bytes32 internal constant SETTING_CROSS_DOMAIN_WITHDRAWAL_GAS_LIMIT = "crossDomainWithdrawalGasLimit";
+    bytes32 internal constant SETTING_CROSS_DOMAIN_RELAY_GAS_LIMIT = "crossDomainRelayGasLimit";
     bytes32 internal constant SETTING_ETHER_WRAPPER_MAX_ETH = "etherWrapperMaxETH";
     bytes32 internal constant SETTING_ETHER_WRAPPER_MINT_FEE_RATE = "etherWrapperMintFeeRate";
     bytes32 internal constant SETTING_ETHER_WRAPPER_BURN_FEE_RATE = "etherWrapperBurnFeeRate";
@@ -47,7 +48,7 @@ contract MixinSystemSettings is MixinResolver {
 
     bytes32 internal constant CONTRACT_FLEXIBLESTORAGE = "FlexibleStorage";
 
-    enum CrossDomainMessageGasLimits {Deposit, Escrow, Reward, Withdrawal}
+    enum CrossDomainMessageGasLimits {Deposit, Escrow, Reward, Withdrawal, Relay}
 
     constructor(address _resolver) internal MixinResolver(_resolver) {}
 
@@ -69,6 +70,8 @@ contract MixinSystemSettings is MixinResolver {
             return SETTING_CROSS_DOMAIN_REWARD_GAS_LIMIT;
         } else if (gasLimitType == CrossDomainMessageGasLimits.Withdrawal) {
             return SETTING_CROSS_DOMAIN_WITHDRAWAL_GAS_LIMIT;
+        } else if (gasLimitType == CrossDomainMessageGasLimits.Relay) {
+            return SETTING_CROSS_DOMAIN_RELAY_GAS_LIMIT;
         } else {
             revert("Unknown gas limit type");
         }

contracts/OwnerRelayOnEthereum.sol

@@ -0,0 +1,87 @@
+pragma solidity ^0.5.16;
+pragma experimental ABIEncoderV2;
+
+// Inheritance
+import "./Owned.sol";
+import "./MixinSystemSettings.sol";
+
+// Internal references
+import "./interfaces/IOwnerRelayOnOptimism.sol";
+import "@eth-optimism/contracts/iOVM/bridge/messaging/iAbs_BaseCrossDomainMessenger.sol";
+
+contract OwnerRelayOnEthereum is MixinSystemSettings, Owned {
+    /* ========== ADDRESS RESOLVER CONFIGURATION ========== */
+
+    bytes32 private constant CONTRACT_EXT_MESSENGER = "ext:Messenger";
+    bytes32 private constant CONTRACT_OVM_OWNER_RELAY_ON_OPTIMISM = "ovm:OwnerRelayOnOptimism";
+
+    // ========== CONSTRUCTOR ==========
+
+    constructor(address _owner, address _resolver) public Owned(_owner) MixinSystemSettings(_resolver) {}
+
+    /* ========== INTERNALS ============ */
+
+    function _messenger() private view returns (iAbs_BaseCrossDomainMessenger) {
+        return iAbs_BaseCrossDomainMessenger(requireAndGetAddress(CONTRACT_EXT_MESSENGER));
+    }
+
+    function _ownerRelayOnOptimism() private view returns (address) {
+        return requireAndGetAddress(CONTRACT_OVM_OWNER_RELAY_ON_OPTIMISM);
+    }
+
+    function _getCrossDomainGasLimit(uint32 crossDomainGasLimit) private view returns (uint32) {
+        // Use specified crossDomainGasLimit if specified value is not zero.
+        // otherwise use the default in SystemSettings.
+        return
+            crossDomainGasLimit != 0
+                ? crossDomainGasLimit
+                : uint32(getCrossDomainMessageGasLimit(CrossDomainMessageGasLimits.Relay));
+    }
+
+    /* ========== VIEWS ========== */
+
+    function resolverAddressesRequired() public view returns (bytes32[] memory addresses) {
+        bytes32[] memory existingAddresses = MixinSystemSettings.resolverAddressesRequired();
+        bytes32[] memory newAddresses = new bytes32[](2);
+        newAddresses[0] = CONTRACT_EXT_MESSENGER;
+        newAddresses[1] = CONTRACT_OVM_OWNER_RELAY_ON_OPTIMISM;
+        addresses = combineArrays(existingAddresses, newAddresses);
+    }
+
+    /* ========== RESTRICTED ========== */
+
+    function initiateRelay(
+        address target,
+        bytes calldata payload,
+        uint32 crossDomainGasLimit // If zero, uses default value in SystemSettings
+    ) external onlyOwner {
+        IOwnerRelayOnOptimism ownerRelayOnOptimism;
+        bytes memory messageData = abi.encodeWithSelector(ownerRelayOnOptimism.finalizeRelay.selector, target, payload);
+
+        _messenger().sendMessage(_ownerRelayOnOptimism(), messageData, _getCrossDomainGasLimit(crossDomainGasLimit));
+
+        emit RelayInitiated(target, payload);
+    }
+
+    function initiateRelayBatch(
+        address[] calldata targets,
+        bytes[] calldata payloads,
+        uint32 crossDomainGasLimit // If zero, uses default value in SystemSettings
+    ) external onlyOwner {
+        // First check that the length of the arguments match
+        require(targets.length == payloads.length, "Argument length mismatch");
+
+        IOwnerRelayOnOptimism ownerRelayOnOptimism;
+        bytes memory messageData =
+            abi.encodeWithSelector(ownerRelayOnOptimism.finalizeRelayBatch.selector, targets, payloads);
+
+        _messenger().sendMessage(_ownerRelayOnOptimism(), messageData, _getCrossDomainGasLimit(crossDomainGasLimit));
+
+        emit RelayBatchInitiated(targets, payloads);
+    }
+
+    /* ========== EVENTS ========== */
+
+    event RelayInitiated(address target, bytes payload);
+    event RelayBatchInitiated(address[] targets, bytes[] payloads);
+}

contracts/OwnerRelayOnOptimism.sol

@@ -0,0 +1,90 @@
+pragma solidity ^0.5.16;
+pragma experimental ABIEncoderV2;
+
+// Inheritance
+import "./MixinResolver.sol";
+import "./TemporarilyOwned.sol";
+import "./interfaces/IOwnerRelayOnOptimism.sol";
+
+// Internal references
+import "@eth-optimism/contracts/iOVM/bridge/messaging/iAbs_BaseCrossDomainMessenger.sol";
+
+contract OwnerRelayOnOptimism is MixinResolver, TemporarilyOwned, IOwnerRelayOnOptimism {
+    /* ========== ADDRESS RESOLVER CONFIGURATION ========== */
+
+    bytes32 private constant CONTRACT_EXT_MESSENGER = "ext:Messenger";
+    bytes32 private constant CONTRACT_BASE_OWNER_RELAY_ON_ETHEREUM = "base:OwnerRelayOnEthereum";
+
+    /* ========== CONSTRUCTOR ============ */
+
+    constructor(
+        address _resolver,
+        address _temporaryOwner,
+        uint _ownershipDuration
+    ) public MixinResolver(_resolver) TemporarilyOwned(_temporaryOwner, _ownershipDuration) {}
+
+    /* ========== INTERNALS ============ */
+
+    function _messenger() private view returns (iAbs_BaseCrossDomainMessenger) {
+        return iAbs_BaseCrossDomainMessenger(requireAndGetAddress(CONTRACT_EXT_MESSENGER));
+    }
+
+    function _ownerRelayOnEthereum() private view returns (address) {
+        return requireAndGetAddress(CONTRACT_BASE_OWNER_RELAY_ON_ETHEREUM);
+    }
+
+    function _relayCall(address target, bytes memory payload) private {
+        // solhint-disable avoid-low-level-calls
+        (bool success, bytes memory result) = target.call(payload);
+
+        require(success, string(abi.encode("xChain call failed:", result)));
+    }
+
+    function _onlyAllowMessengerAndL1Relayer() internal view {
+        iAbs_BaseCrossDomainMessenger messenger = _messenger();
+
+        require(msg.sender == address(messenger), "Sender is not the messenger");
+        require(messenger.xDomainMessageSender() == _ownerRelayOnEthereum(), "L1 sender is not the owner relay");
+    }
+
+    modifier onlyMessengerAndL1Relayer() {
+        _onlyAllowMessengerAndL1Relayer();
+        _;
+    }
+
+    /* ========== VIEWS ========== */
+
+    function resolverAddressesRequired() public view returns (bytes32[] memory addresses) {
+        addresses = new bytes32[](2);
+        addresses[0] = CONTRACT_EXT_MESSENGER;
+        addresses[1] = CONTRACT_BASE_OWNER_RELAY_ON_ETHEREUM;
+    }
+
+    /* ========== EXTERNAL ========== */
+
+    function directRelay(address target, bytes calldata payload) external onlyTemporaryOwner {
+        _relayCall(target, payload);
+
+        emit DirectRelay(target, payload);
+    }
+
+    function finalizeRelay(address target, bytes calldata payload) external onlyMessengerAndL1Relayer {
+        _relayCall(target, payload);
+
+        emit RelayFinalized(target, payload);
+    }
+
+    function finalizeRelayBatch(address[] calldata targets, bytes[] calldata payloads) external onlyMessengerAndL1Relayer {
+        for (uint256 i = 0; i < targets.length; i++) {
+            _relayCall(targets[i], payloads[i]);
+        }
+
+        emit RelayBatchFinalized(targets, payloads);
+    }
+
+    /* ========== EVENTS ========== */
+
+    event DirectRelay(address target, bytes payload);
+    event RelayFinalized(address target, bytes payload);
+    event RelayBatchFinalized(address[] targets, bytes[] payloads);
+}

contracts/SynthetixBridgeEscrow.sol

@@ -5,7 +5,7 @@ import "./Owned.sol";
 import "./MixinResolver.sol";
 import "./interfaces/ISynthetixBridgeEscrow.sol";
 
-// External references.
+// Internal references.
 import "openzeppelin-solidity-2.3.0/contracts/token/ERC20/SafeERC20.sol";
 
 contract SynthetixBridgeEscrow is Owned, ISynthetixBridgeEscrow {

contracts/TemporarilyOwned.sol

@@ -0,0 +1,46 @@
+pragma solidity ^0.5.16;
+
+contract TemporarilyOwned {
+    address public temporaryOwner;
+    address public nominatedOwner;
+    uint public expiryTime;
+
+    constructor(address _temporaryOwner, uint _ownershipDuration) public {
+        require(_temporaryOwner != address(0), "Temp owner address cannot be 0");
+        require(_ownershipDuration > 0, "Duration cannot be 0");
+
+        temporaryOwner = _temporaryOwner;
+        expiryTime = block.timestamp + _ownershipDuration;
+    }
+
+    function setNewExpiryTime(uint _duration) external onlyTemporaryOwner {
+        require(block.timestamp + _duration < expiryTime, "New expiry time must be sooner than it currently is");
+        expiryTime = block.timestamp + _duration;
+    }
+
+    function nominateNewOwner(address _owner) external onlyTemporaryOwner {
+        nominatedOwner = _owner;
+        emit OwnerNominated(_owner);
+    }
+
+    function acceptOwnership() external {
+        require(block.timestamp < expiryTime, "Ownership expired");
+        require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
+        emit OwnerChanged(temporaryOwner, nominatedOwner);
+        temporaryOwner = nominatedOwner;
+        nominatedOwner = address(0);
+    }
+
+    modifier onlyTemporaryOwner {
+        _onlyTemporaryOwner();
+        _;
+    }
+
+    function _onlyTemporaryOwner() private view {
+        require(block.timestamp < expiryTime, "Ownership expired");
+        require(msg.sender == temporaryOwner, "Only executable by temp owner");
+    }
+
+    event OwnerNominated(address newOwner);
+    event OwnerChanged(address oldOwner, address newOwner);
+}

contracts/interfaces/IOwnerRelayOnOptimism.sol

@@ -0,0 +1,8 @@
+pragma solidity >=0.4.24;
+pragma experimental ABIEncoderV2;
+
+interface IOwnerRelayOnOptimism {
+    function finalizeRelay(address target, bytes calldata payload) external;
+
+    function finalizeRelayBatch(address[] calldata target, bytes[] calldata payloads) external;
+}

contracts/test-helpers/TestableTempOwned.sol

@@ -0,0 +1,16 @@
+pragma solidity ^0.5.16;
+
+import "../TemporarilyOwned.sol";
+
+contract TestableTempOwned is TemporarilyOwned {
+    uint public testValue;
+
+    constructor(address _temporaryOwner, uint _ownershipDuration)
+        public
+        TemporarilyOwned(_temporaryOwner, _ownershipDuration)
+    {}
+
+    function setTestValue(uint _testValue) external onlyTemporaryOwner {
+        testValue = _testValue;
+    }
+}

hardhat.config.js

@@ -64,6 +64,6 @@ module.exports = {
 		outputFile: 'test-gas-used.log',
 	},
 	mocha: {
-		timeout: 90e3, // 90s
+		timeout: 120e3, // 120s
 	},
 };

hardhat/tasks/task-interact.js

@@ -361,7 +361,6 @@ task('interact', 'Interact with a deployed Synthetix instance from the command l
 					const txPromise = contract[abiItemName](...inputs, overrides);
 					result = await _sendTx({
 						txPromise,
-						provider,
 					});
 
 					if (result.success) {

hardhat/tasks/task-status/statusActions.js

@@ -318,7 +318,6 @@ const actions = {
 
 		const Issuer = getContract({
 			contract: 'Issuer',
-			source: useOvm ? 'IssuerWithoutLiquidations' : 'Issuer',
 			network,
 			useOvm,
 			provider,

index.js

@@ -112,6 +112,7 @@ const knownAccounts = {
 // The solidity defaults are managed here in the same format they will be stored, hence all
 // numbers are converted to strings and those with 18 decimals are also converted to wei amounts
 const defaults = {
+	TEMP_OWNER_DEFAULT_DURATION: 60 * 60 * 24 * 60, // 60 days
 	WAITING_PERIOD_SECS: (60 * 5).toString(), // 5 mins
 	PRICE_DEVIATION_THRESHOLD_FACTOR: w3utils.toWei('3'),
 	TRADING_REWARDS_ENABLED: false,
@@ -156,6 +157,7 @@ const defaults = {
 	CROSS_DOMAIN_ESCROW_GAS_LIMIT: `${8e6}`,
 	CROSS_DOMAIN_REWARD_GAS_LIMIT: `${8e6}`,
 	CROSS_DOMAIN_WITHDRAWAL_GAS_LIMIT: `${3e6}`,
+	CROSS_DOMAIN_RELAY_GAS_LIMIT: `${8e6}`,
 
 	COLLATERAL_MANAGER: {
 		SYNTHS: ['sUSD', 'sBTC', 'sETH'],

publish/deployed/local-ovm/config.json

@@ -155,6 +155,9 @@
 	"WETH": {
 		"deploy": true
 	},
+	"OwnerRelayOnOptimism": {
+		"deploy": true
+	},
 	"SynthRedeemer": {
 		"deploy": true
 	}

publish/deployed/local/config.json

@@ -383,6 +383,9 @@
 	"WETH": {
 		"deploy": true
 	},
+	"OwnerRelayOnEthereum": {
+		"deploy": true
+	},
 	"SynthRedeemer": {
 		"deploy": true
 	}

publish/releases.json

@@ -359,6 +359,14 @@
 			"released": "base",
 			"sources": ["DebtCache"]
 		},
+		{
+			"sip": 167,
+			"layer": "both",
+			"sources": {
+				"base": ["OwnerRelayOnEthereum", "SystemSettings"],
+				"ovm": ["Issuer", "OwnerRelayOnOptimism", "SystemSettings"]
+			}
+		},
 		{
 			"sip": 158,
 			"layer": "base",