diff --git a/contracts/src/bridge/IL1Bridge.sol b/contracts/src/bridge/IL1Bridge.sol index 817208036..f6792732e 100644 --- a/contracts/src/bridge/IL1Bridge.sol +++ b/contracts/src/bridge/IL1Bridge.sol @@ -2,7 +2,11 @@ pragma solidity ^0.8.0; -interface IL1Bridge { +/** + * This is essentially an interface but defined as an abstract contract + * to declare functions as internal instead of as external + */ +abstract contract IL1Bridge { /** * Sends an arbitrary message from one domain to another. * @@ -24,9 +28,9 @@ interface IL1Bridge { bytes memory _calldata, uint256 _maxGas, uint256 _gasPriceBid - ) external payable returns (uint256); + ) internal virtual returns (uint256); - function getSubmissionPrice(uint256 _calldatasize) external view returns (uint256); + function bridgingCost(uint256 _calldatasize) internal view virtual returns (uint256); - function onlyAuthorized() external; + function onlyCrossChainSender() internal virtual; } diff --git a/contracts/src/bridge/IL2Bridge.sol b/contracts/src/bridge/IL2Bridge.sol index 7eab0cf79..f50db5cb6 100644 --- a/contracts/src/bridge/IL2Bridge.sol +++ b/contracts/src/bridge/IL2Bridge.sol @@ -2,14 +2,18 @@ pragma solidity ^0.8.0; -interface IL2Bridge { +/** + * This is essentially an interface but defined as an abstract contract + * to declare functions as internal instead of as external + */ +abstract contract IL2Bridge { /** * Sends an arbitrary message from one domain to another. * * @param _calldata The L1 encoded message data. * @return Unique id to track the message request/transaction. */ - function sendCrossDomainMessage(bytes memory _calldata) external returns (uint256); + function sendCrossDomainMessage(bytes memory _calldata) internal virtual returns (uint256); - function onlyAuthorized() external; + function onlyCrossChainSender() internal virtual; } diff --git a/contracts/src/bridge/arbitrum/ArbL1Bridge.sol b/contracts/src/bridge/arbitrum/ArbL1Bridge.sol index 7dd394bf9..48a5fa2a3 100644 --- a/contracts/src/bridge/arbitrum/ArbL1Bridge.sol +++ b/contracts/src/bridge/arbitrum/ArbL1Bridge.sol @@ -1,5 +1,13 @@ // SPDX-License-Identifier: MIT +/** + * @authors: [@shalzz] + * @reviewers: [] + * @auditors: [] + * @bounties: [] + * @deployments: [] + */ + pragma solidity ^0.8.0; import "./interfaces/IInbox.sol"; @@ -41,8 +49,8 @@ contract ArbL1Bridge is IL1Bridge { bytes memory _calldata, uint256 _maxGas, uint256 _gasPriceBid - ) external payable returns (uint256) { - uint256 baseSubmissionCost = getSubmissionPrice(_calldata.length); + ) internal override returns (uint256) { + uint256 baseSubmissionCost = bridgingCost(_calldata.length); require(msg.value >= baseSubmissionCost + (_maxGas * _gasPriceBid)); uint256 ticketID = inbox.createRetryableTicket{value: msg.value}( @@ -60,12 +68,12 @@ contract ArbL1Bridge is IL1Bridge { return ticketID; } - function getSubmissionPrice(uint256 _calldatasize) public view returns (uint256) { + function bridgingCost(uint256 _calldatasize) internal view override returns (uint256) { (uint256 submissionCost, ) = arbRetryableTx.getSubmissionPrice(_calldatasize); return submissionCost; } - function onlyAuthorized() external { + function onlyCrossChainSender() internal override { IOutbox outbox = IOutbox(inbox.bridge().activeOutbox()); address l2Sender = outbox.l2ToL1Sender(); require(l2Sender == l2Target, "Only L2 target"); diff --git a/contracts/src/bridge/arbitrum/ArbL2Bridge.sol b/contracts/src/bridge/arbitrum/ArbL2Bridge.sol index a0a216447..2f3b12180 100644 --- a/contracts/src/bridge/arbitrum/ArbL2Bridge.sol +++ b/contracts/src/bridge/arbitrum/ArbL2Bridge.sol @@ -1,5 +1,13 @@ // SPDX-License-Identifier: MIT +/** + * @authors: [@shalzz] + * @reviewers: [] + * @auditors: [] + * @bounties: [] + * @deployments: [] + */ + pragma solidity ^0.8.0; import "./interfaces/IArbSys.sol"; @@ -23,14 +31,14 @@ contract ArbL2Bridge is IL2Bridge { * @param _calldata The L1 encoded message data. * @return Unique id to track the message request/transaction. */ - function sendCrossDomainMessage(bytes memory _calldata) external returns (uint256) { + function sendCrossDomainMessage(bytes memory _calldata) internal override returns (uint256) { uint256 withdrawalId = arbsys.sendTxToL1(l1Target, _calldata); emit L2ToL1TxCreated(withdrawalId); return withdrawalId; } - function onlyAuthorized() external { + function onlyCrossChainSender() internal override { require(msg.sender == AddressAliasHelper.applyL1ToL2Alias(l1Target), "Only L1 target"); } } diff --git a/contracts/src/bridge/xdai/xDaiL1Bridge.sol b/contracts/src/bridge/gnosis-chain/GnosisL1Bridge.sol similarity index 73% rename from contracts/src/bridge/xdai/xDaiL1Bridge.sol rename to contracts/src/bridge/gnosis-chain/GnosisL1Bridge.sol index 99ac7f941..7f9050ce2 100644 --- a/contracts/src/bridge/xdai/xDaiL1Bridge.sol +++ b/contracts/src/bridge/gnosis-chain/GnosisL1Bridge.sol @@ -1,12 +1,20 @@ // SPDX-License-Identifier: MIT +/** + * @authors: [@shalzz] + * @reviewers: [] + * @auditors: [] + * @bounties: [] + * @deployments: [] + */ + pragma solidity ^0.8.0; import "./interfaces/IAMB.sol"; import "../IL1Bridge.sol"; -contract xDaiL1Bridge is IL1Bridge { +contract GnosisL1Bridge is IL1Bridge { address public l2Target; IAMB amb; @@ -19,7 +27,7 @@ contract xDaiL1Bridge is IL1Bridge { bytes memory _calldata, uint256 _maxGas, uint256 _gasPriceBid - ) external payable returns (uint256) { + ) internal override returns (uint256) { bytes32 id = amb.requireToPassMessage(l2Target, _calldata, amb.maxGasPerTx()); return uint256(id); } @@ -28,13 +36,13 @@ contract xDaiL1Bridge is IL1Bridge { * @dev The xDai bridge gas cost doesn't depend on the calldata size * */ - function getSubmissionPrice( + function bridgingCost( uint256 /* _calldatasize */ - ) public view returns (uint256) { + ) internal view override returns (uint256) { return 0; } - function onlyAuthorized() external { + function onlyCrossChainSender() internal override { require(msg.sender == address(amb), "Only AMB allowed"); // require(amb.messageSourceChainId() == foreignChainId, "Only foreign chain allowed"); require(amb.messageSender() == l2Target, "Only foreign gateway allowed"); diff --git a/contracts/src/bridge/xdai/xDaiL2Bridge.sol b/contracts/src/bridge/gnosis-chain/GnosisL2Bridge.sol similarity index 67% rename from contracts/src/bridge/xdai/xDaiL2Bridge.sol rename to contracts/src/bridge/gnosis-chain/GnosisL2Bridge.sol index ce30834c4..d35e07046 100644 --- a/contracts/src/bridge/xdai/xDaiL2Bridge.sol +++ b/contracts/src/bridge/gnosis-chain/GnosisL2Bridge.sol @@ -1,12 +1,20 @@ // SPDX-License-Identifier: MIT +/** + * @authors: [@shalzz] + * @reviewers: [] + * @auditors: [] + * @bounties: [] + * @deployments: [] + */ + pragma solidity ^0.8.0; import "./interfaces/IAMB.sol"; import "../IL2Bridge.sol"; -contract xDaiL2Bridge is IL2Bridge { +contract GnosisL2Bridge is IL2Bridge { address public l1Target; IAMB amb; @@ -15,12 +23,12 @@ contract xDaiL2Bridge is IL2Bridge { amb = _amb; } - function sendCrossDomainMessage(bytes memory _calldata) external returns (uint256) { + function sendCrossDomainMessage(bytes memory _calldata) internal override returns (uint256) { bytes32 id = amb.requireToPassMessage(l1Target, _calldata, amb.maxGasPerTx()); return uint256(id); } - function onlyAuthorized() external { + function onlyCrossChainSender() internal override { require(msg.sender == address(amb), "Only AMB allowed"); // require(amb.messageSourceChainId() == homeChainId, "Only home chain allowed"); require(amb.messageSender() == l1Target, "Only home gateway allowed"); diff --git a/contracts/src/bridge/xdai/interfaces/IAMB.sol b/contracts/src/bridge/gnosis-chain/interfaces/IAMB.sol similarity index 100% rename from contracts/src/bridge/xdai/interfaces/IAMB.sol rename to contracts/src/bridge/gnosis-chain/interfaces/IAMB.sol diff --git a/contracts/src/gateway/BaseForeignGateway.sol b/contracts/src/gateway/BaseForeignGateway.sol index 802e5d907..efa6d0fb8 100644 --- a/contracts/src/gateway/BaseForeignGateway.sol +++ b/contracts/src/gateway/BaseForeignGateway.sol @@ -1,5 +1,13 @@ // SPDX-License-Identifier: MIT +/** + * @authors: [@shalzz] + * @reviewers: [] + * @auditors: [] + * @bounties: [] + * @deployments: [] + */ + pragma solidity ^0.8.0; import "../arbitration/IArbitrable.sol"; @@ -9,33 +17,48 @@ import "./interfaces/IHomeGateway.sol"; import "./interfaces/IForeignGateway.sol"; abstract contract BaseForeignGateway is IL1Bridge, IForeignGateway { + // The global default minimum number of jurors in a dispute. + uint256 public constant MIN_JURORS = 3; + // @dev Note the disputeID needs to start from one as // the KlerosV1 proxy governor depends on this implementation. uint256 internal localDisputeID = 1; - // For now this is just a constant, but we'd probably need to - // implement the same arbitrationCost calculation code we'll have - // in the V2 court. - uint256 internal internalArbitrationCost; + // feeForJuror by subcourtID + uint256[] internal feeForJuror; struct DisputeData { - uint256 id; + uint248 id; + bool ruled; address arbitrable; + uint256 paid; + address forwarder; } mapping(uint256 => bytes32) public disputeIDtoHash; mapping(bytes32 => DisputeData) public disputeHashtoDisputeData; IHomeGateway public homeGateway; uint256 public chainID; + address public governor; modifier onlyFromL2() { - this.onlyAuthorized(); + onlyCrossChainSender(); + _; + } + + modifier onlyByGovernor() { + require(governor == msg.sender, "Access not allowed: Governor only."); _; } - constructor(uint256 _arbitrationCost, IHomeGateway _homeGateway) { - internalArbitrationCost = _arbitrationCost; + constructor( + address _governor, + IHomeGateway _homeGateway, + uint256[] memory _feeForJuror + ) { + governor = _governor; homeGateway = _homeGateway; + feeForJuror = _feeForJuror; uint256 id; assembly { @@ -44,9 +67,20 @@ abstract contract BaseForeignGateway is IL1Bridge, IForeignGateway { chainID = id; } + /** @dev Changes the `feeForJuror` property value of a specified subcourt. + * @param _subcourtID The ID of the subcourt. + * @param _feeForJuror The new value for the `feeForJuror` property value. + */ + function changeSubcourtJurorFee(uint96 _subcourtID, uint256 _feeForJuror) external onlyByGovernor { + feeForJuror[_subcourtID] = _feeForJuror; + } + function createDispute(uint256 _choices, bytes calldata _extraData) external payable returns (uint256 disputeID) { require(msg.value >= arbitrationCost(_extraData), "Not paid enough for arbitration"); + (uint96 subcourtID, ) = extraDataToSubcourtIDMinJurors(_extraData); + uint256 nbVotes = msg.value / feeForJuror[subcourtID]; + disputeID = localDisputeID++; bytes32 disputeHash = keccak256( abi.encodePacked( @@ -55,17 +89,30 @@ abstract contract BaseForeignGateway is IL1Bridge, IForeignGateway { "createDispute", disputeID, arbitrationCost(_extraData), + _choices, _extraData, msg.sender ) ); disputeIDtoHash[disputeID] = disputeHash; - disputeHashtoDisputeData[disputeHash] = DisputeData({id: disputeID, arbitrable: msg.sender}); - bytes4 methodSelector = IHomeGateway.relayCreateDispute.selector; - bytes memory data = abi.encodeWithSelector(methodSelector, disputeHash, _choices, _extraData); + disputeHashtoDisputeData[disputeHash] = DisputeData({ + id: uint248(disputeID), + arbitrable: msg.sender, + paid: msg.value, + forwarder: address(0), + ruled: false + }); + + bytes4 methodSelector = IHomeGateway.handleIncomingDispute.selector; + bytes memory data = abi.encodeWithSelector( + methodSelector, + disputeHash, + _choices, + _extraData, + nbVotes * feeForJuror[subcourtID] // we calculate the min amount required for nbVotes + ); - uint256 bridgeCost = this.getSubmissionPrice(data.length); // We only pay for the submissionPrice gas cost // which is minimum gas cost required for submitting a // arbitrum retryable ticket to the retry buffer for @@ -78,34 +125,54 @@ abstract contract BaseForeignGateway is IL1Bridge, IForeignGateway { // // We do NOT forward the arbitrationCost ETH funds to the HomeGateway yet, // only the calldata. - this.sendCrossDomainMessage{value: bridgeCost}(data, 0, 0); + sendCrossDomainMessage(data, 0, 0); emit DisputeCreation(disputeID, IArbitrable(msg.sender)); } function arbitrationCost(bytes calldata _extraData) public view returns (uint256 cost) { + (uint96 subcourtID, uint256 minJurors) = extraDataToSubcourtIDMinJurors(_extraData); + // Calculate the size of calldata that will be passed to the L2 bridge // as that is a factor for the bridging cost. - // Calldata size of relayCreateDispute: - // relayCreateDispute methodId + - // (createDispute methodId + bytes32 disputeHash + uint256 _choices + bytes _extraData) - // 4 + 4 + 32 + 32 + dynamic - uint256 calldatasize = 82 + _extraData.length; - - uint256 bridgeCost = this.getSubmissionPrice(calldatasize); - return bridgeCost + internalArbitrationCost; + // Calldata size of handleIncomingDispute: + // methodId + bytes32 disputeHash + uint256 _choices + bytes _extraData + uint256 _arbitrationCost) + // 4 + 32 + 32 + dynamic + 32 + uint256 calldatasize = 100 + _extraData.length; + + uint256 bridgeCost = bridgingCost(calldatasize); + uint256 arbCost = feeForJuror[subcourtID] * minJurors; + + return bridgeCost + arbCost; } /** * Relay the rule call from the home gateway to the arbitrable. */ - function relayRule(bytes32 _disputeHash, uint256 _ruling) external onlyFromL2 { - DisputeData memory dispute = disputeHashtoDisputeData[_disputeHash]; + function relayRule( + bytes32 _disputeHash, + uint256 _ruling, + address _forwarder + ) external onlyFromL2 { + DisputeData storage dispute = disputeHashtoDisputeData[_disputeHash]; + + require(!dispute.ruled, "Cannot rule twice"); + dispute.ruled = true; + dispute.forwarder = _forwarder; IArbitrable arbitrable = IArbitrable(dispute.arbitrable); arbitrable.rule(dispute.id, _ruling); } + function withdrawFees(bytes32 _disputeHash) external { + DisputeData storage dispute = disputeHashtoDisputeData[_disputeHash]; + require(dispute.ruled, "Not ruled yet"); + + uint256 amount = dispute.paid; + dispute.paid = 0; + payable(dispute.forwarder).transfer(amount); + } + function foreignDisputeHashToID(bytes32 _disputeHash) external view returns (uint256) { return disputeHashtoDisputeData[_disputeHash].id; } @@ -124,4 +191,24 @@ abstract contract BaseForeignGateway is IL1Bridge, IForeignGateway { function homeBridge(uint256 _disputeID) external view returns (address) { return address(homeGateway); } + + function extraDataToSubcourtIDMinJurors(bytes memory _extraData) + internal + view + returns (uint96 subcourtID, uint256 minJurors) + { + // Note that here we ignore DisputeKitID + if (_extraData.length >= 64) { + assembly { + // solium-disable-line security/no-inline-assembly + subcourtID := mload(add(_extraData, 0x20)) + minJurors := mload(add(_extraData, 0x40)) + } + if (subcourtID >= feeForJuror.length) subcourtID = 0; + if (minJurors == 0) minJurors = MIN_JURORS; + } else { + subcourtID = 0; + minJurors = MIN_JURORS; + } + } } diff --git a/contracts/src/gateway/BaseHomeGateway.sol b/contracts/src/gateway/BaseHomeGateway.sol index e9f9edd42..8c997c295 100644 --- a/contracts/src/gateway/BaseHomeGateway.sol +++ b/contracts/src/gateway/BaseHomeGateway.sol @@ -1,5 +1,13 @@ // SPDX-License-Identifier: MIT +/** + * @authors: [@shalzz] + * @reviewers: [] + * @auditors: [] + * @bounties: [] + * @deployments: [] + */ + pragma solidity ^0.8.0; import "../arbitration/IArbitrator.sol"; @@ -16,8 +24,16 @@ abstract contract BaseHomeGateway is IL2Bridge, IHomeGateway { IArbitrator public arbitrator; uint256 public chainID; + struct RelayedData { + uint256 choices; + uint256 arbitrationCost; + address forwarder; + bytes extraData; + } + mapping(bytes32 => RelayedData) public disputeHashtoRelayedData; + modifier onlyFromL1() { - this.onlyAuthorized(); + onlyCrossChainSender(); _; } @@ -37,23 +53,46 @@ abstract contract BaseHomeGateway is IL2Bridge, IHomeGateway { function rule(uint256 _disputeID, uint256 _ruling) external { require(msg.sender == address(arbitrator), "Only Arbitrator"); + bytes32 disputeHash = disputeIDtoHash[_disputeID]; + RelayedData memory relayedData = disputeHashtoRelayedData[disputeHash]; + bytes4 methodSelector = IForeignGateway.relayRule.selector; - bytes memory data = abi.encodeWithSelector(methodSelector, disputeIDtoHash[_disputeID], _ruling); + bytes memory data = abi.encodeWithSelector(methodSelector, disputeHash, _ruling, relayedData.forwarder); - this.sendCrossDomainMessage(data); + sendCrossDomainMessage(data); } /** - * Relay the createDispute call from the foreign gateway to the arbitrator. + * @dev Handle the cross-chain call from the foreign gateway. + * + * @param _disputeHash disputeHash + * @param _choices number of ruling choices + * @param _extraData extraData + * @param _arbitrationCost We get the actual arbitrationCost paid by the + * arbitrable here in case they paid more than the min arbitrationCost */ - function relayCreateDispute( + function handleIncomingDispute( bytes32 _disputeHash, uint256 _choices, - bytes calldata _extraData + bytes calldata _extraData, + uint256 _arbitrationCost ) external onlyFromL1 { - uint256 disputeID = arbitrator.createDispute(_choices, _extraData); + RelayedData storage relayedData = disputeHashtoRelayedData[_disputeHash]; + relayedData.choices = _choices; + relayedData.extraData = _extraData; + relayedData.arbitrationCost = _arbitrationCost; + } + + function relayCreateDispute(bytes32 _disputeHash) external payable { + RelayedData storage relayedData = disputeHashtoRelayedData[_disputeHash]; + require(relayedData.forwarder == address(0), "Dispute already forwarded"); + + require(msg.value >= relayedData.arbitrationCost, "Not enough arbitration cost paid"); + + uint256 disputeID = arbitrator.createDispute{value: msg.value}(relayedData.choices, relayedData.extraData); disputeIDtoHash[disputeID] = _disputeHash; disputeHashtoID[_disputeHash] = disputeID; + relayedData.forwarder = msg.sender; emit Dispute(arbitrator, disputeID, 0, 0); } diff --git a/contracts/src/gateway/arbitrum/EthereumGateway.sol b/contracts/src/gateway/arbitrum/EthereumToArbitrumGateway.sol similarity index 55% rename from contracts/src/gateway/arbitrum/EthereumGateway.sol rename to contracts/src/gateway/arbitrum/EthereumToArbitrumGateway.sol index e90bde916..a20578c20 100644 --- a/contracts/src/gateway/arbitrum/EthereumGateway.sol +++ b/contracts/src/gateway/arbitrum/EthereumToArbitrumGateway.sol @@ -7,11 +7,12 @@ import "../../bridge/arbitrum/ArbL1Bridge.sol"; import "../interfaces/IForeignGateway.sol"; import "../BaseForeignGateway.sol"; -contract EthereumGateway is BaseForeignGateway, ArbL1Bridge { +contract EthereumToArbitrumGateway is BaseForeignGateway, ArbL1Bridge { constructor( - uint256 _arbitrationCost, + address _governor, IHomeGateway _homeGateway, + uint256[] memory _feeForJuror, address _l2Target, address _inbox - ) BaseForeignGateway(_arbitrationCost, _homeGateway) ArbL1Bridge(_l2Target, _inbox) {} + ) BaseForeignGateway(_governor, _homeGateway, _feeForJuror) ArbL1Bridge(_l2Target, _inbox) {} } diff --git a/contracts/src/gateway/arbitrum/GnosisToEthereumGateway.sol b/contracts/src/gateway/arbitrum/GnosisToEthereumGateway.sol new file mode 100644 index 000000000..4ae3c1222 --- /dev/null +++ b/contracts/src/gateway/arbitrum/GnosisToEthereumGateway.sol @@ -0,0 +1,19 @@ +// SPDX-License-Identifier: MIT + +pragma solidity ^0.8.0; + +import "../../bridge/gnosis-chain/GnosisL1Bridge.sol"; +import "../../bridge/gnosis-chain/interfaces/IAMB.sol"; + +import "../interfaces/IForeignGateway.sol"; +import "../BaseForeignGateway.sol"; + +contract EthereumGateway is BaseForeignGateway, GnosisL1Bridge { + constructor( + address _governor, + IHomeGateway _homeGateway, + uint256[] memory _feeForJuror, + address _l2Target, + IAMB _amb + ) BaseForeignGateway(_governor, _homeGateway, _feeForJuror) GnosisL1Bridge(_l2Target, _amb) {} +} diff --git a/contracts/src/gateway/xdai/xDaiGateway.sol b/contracts/src/gateway/gnosis-chain/GnosisGateway.sol similarity index 54% rename from contracts/src/gateway/xdai/xDaiGateway.sol rename to contracts/src/gateway/gnosis-chain/GnosisGateway.sol index 6effc4b92..062f3551b 100644 --- a/contracts/src/gateway/xdai/xDaiGateway.sol +++ b/contracts/src/gateway/gnosis-chain/GnosisGateway.sol @@ -3,17 +3,17 @@ pragma solidity ^0.8.0; import "../../arbitration/IArbitrator.sol"; -import "../../bridge/xdai/xDaiL2Bridge.sol"; -import "../../bridge/xdai/interfaces/IAMB.sol"; +import "../../bridge/gnosis-chain/GnosisL2Bridge.sol"; +import "../../bridge/gnosis-chain/interfaces/IAMB.sol"; import "../interfaces/IHomeGateway.sol"; import "../BaseHomeGateway.sol"; -contract xDaiGateway is BaseHomeGateway, xDaiL2Bridge { +contract GnosisToEthereumGateway is BaseHomeGateway, GnosisL2Bridge { constructor( IArbitrator _arbitrator, IForeignGateway _foreignGateway, address _l1Target, IAMB _amb - ) BaseHomeGateway(_arbitrator, _foreignGateway) xDaiL2Bridge(_l1Target, _amb) {} + ) BaseHomeGateway(_arbitrator, _foreignGateway) GnosisL2Bridge(_l1Target, _amb) {} } diff --git a/contracts/src/gateway/interfaces/IForeignGateway.sol b/contracts/src/gateway/interfaces/IForeignGateway.sol index 5732f12a9..04de45ba0 100644 --- a/contracts/src/gateway/interfaces/IForeignGateway.sol +++ b/contracts/src/gateway/interfaces/IForeignGateway.sol @@ -13,5 +13,11 @@ interface IForeignGateway is IArbitrator, IForeignEvidence { /** * Relay the rule call from the home gateway to the arbitrable. */ - function relayRule(bytes32 _disputeHash, uint256 _ruling) external; + function relayRule( + bytes32 _disputeHash, + uint256 _ruling, + address _forwarder + ) external; + + function withdrawFees(bytes32 _disputeHash) external; } diff --git a/contracts/src/gateway/interfaces/IHomeGateway.sol b/contracts/src/gateway/interfaces/IHomeGateway.sol index 4f018d9c1..15ce5f498 100644 --- a/contracts/src/gateway/interfaces/IHomeGateway.sol +++ b/contracts/src/gateway/interfaces/IHomeGateway.sol @@ -11,11 +11,14 @@ interface IHomeGateway is IArbitrable, IHomeEvidence { function homeDisputeHashToID(bytes32 _disputeHash) external view returns (uint256); /** - * Relay the createDispute call from the foreign gateway to the arbitrator. + * Handle the cross-chain call from the foreign gateway. */ - function relayCreateDispute( + function handleIncomingDispute( bytes32 _disputeHash, uint256 _choices, - bytes calldata _extraData + bytes calldata _extraData, + uint256 numOfJurors ) external; + + function relayCreateDispute(bytes32 _disputeHash) external payable; } diff --git a/contracts/src/gateway/xdai/EthereumGateway.sol b/contracts/src/gateway/xdai/EthereumGateway.sol deleted file mode 100644 index 44759d8bd..000000000 --- a/contracts/src/gateway/xdai/EthereumGateway.sol +++ /dev/null @@ -1,18 +0,0 @@ -// SPDX-License-Identifier: MIT - -pragma solidity ^0.8.0; - -import "../../bridge/xdai/xDaiL1Bridge.sol"; -import "../../bridge/xdai/interfaces/IAMB.sol"; - -import "../interfaces/IForeignGateway.sol"; -import "../BaseForeignGateway.sol"; - -contract EthereumGateway is BaseForeignGateway, xDaiL1Bridge { - constructor( - uint256 _arbitrationCost, - IHomeGateway _homeGateway, - address _l2Target, - IAMB _amb - ) BaseForeignGateway(_arbitrationCost, _homeGateway) xDaiL1Bridge(_l2Target, _amb) {} -}