feat(bridge): add xdai bridges

Author: shalzz

contracts/src/bridge/IL1Bridge.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+interface IL1Bridge {
+    /**
+     * Sends an arbitrary message from one domain to another.
+     *
+     * @dev The caller needs to pay some ETH to cover the gas costs
+     * of the call on L2. Excess ETH that is not used by gas costs will
+     * be refunded to the `msg.sender` address on L2.
+     *
+     * @notice if a user does not desire immediate redemption, they should
+     * provide a DepositValue of at least CallValue + MaxSubmissionCost.
+     * If they do desire immediate execution, they should provide a DepositValue
+     * of at least CallValue + MaxSubmissionCost + (GasPrice x MaxGas).
+     *
+     * @param _calldata The L2 encoded message data.
+     * @param _maxGas Gas limit for immediate L2 execution attempt.
+     * @param _gasPriceBid L2 Gas price bid for immediate L2 execution attempt.
+     * @return Unique id to track the message request/transaction.
+     */
+    function sendCrossDomainMessage(
+        bytes memory _calldata,
+        uint256 _maxGas,
+        uint256 _gasPriceBid
+    ) external payable returns (uint256);
+
+    function getSubmissionPrice(uint256 _calldatasize) external view returns (uint256);
+
+    function onlyAuthorized(address _sender) external;
+}

contracts/src/bridge/IL2Bridge.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+interface 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 onlyAuthorized(address _sender) external;
+}

contracts/src/bridge/arbitrum/L1Bridge.sol

@@ -6,7 +6,9 @@ import "./interfaces/IInbox.sol";
 import "./interfaces/IOutbox.sol";
 import "./interfaces/IArbRetryableTx.sol";
 
-contract L1Bridge {
+import "../IL1Bridge.sol";
+
+contract L1Bridge is IL1Bridge {
     address public l2Target;
     IInbox public inbox;
     IArbRetryableTx constant arbRetryableTx = IArbRetryableTx(address(110));
@@ -41,6 +43,7 @@ contract L1Bridge {
         uint256 _gasPriceBid
     ) external payable returns (uint256) {
         uint256 baseSubmissionCost = getSubmissionPrice(_calldata.length);
+        require(msg.value >= baseSubmissionCost);
 
         uint256 ticketID = inbox.createRetryableTicket{value: msg.value}(
             l2Target,

contracts/src/bridge/arbitrum/L2Bridge.sol

@@ -5,7 +5,9 @@ pragma solidity ^0.8.0;
 import "./interfaces/IArbSys.sol";
 import "./AddressAliasHelper.sol";
 
-contract L2Bridge {
+import "../IL2Bridge.sol";
+
+contract L2Bridge is IL2Bridge {
     address public l1Target;
     IArbSys constant arbsys = IArbSys(address(100));
 

contracts/src/bridge/xdai/L1Bridge.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "./interfaces/IAMB.sol";
+
+import "../IL1Bridge.sol";
+
+contract L1Bridge is IL1Bridge {
+    address public l2Target;
+    IAMB amb;
+
+    constructor(address _l2Target, IAMB _amb) {
+        l2Target = _l2Target;
+        amb = _amb;
+    }
+
+    function sendCrossDomainMessage(
+        bytes memory _calldata,
+        uint256 _maxGas,
+        uint256 _gasPriceBid
+    ) external payable returns (uint256) {
+        bytes32 id = amb.requireToPassMessage(l2Target, _calldata, amb.maxGasPerTx());
+        return uint256(id);
+    }
+
+    /**
+     * @dev The xDai bridge gas cost doesn't depend on the calldata size
+     *
+     */
+    function getSubmissionPrice(
+        uint256 /* _calldatasize */
+    ) public view returns (uint256) {
+        return 0;
+    }
+
+    function onlyAuthorized(address _sender) external {
+        require(_sender == address(amb), "Only AMB allowed");
+        //require(amb.messageSourceChainId() == homeChainId, "Only home chain allowed");
+        require(amb.messageSender() == l2Target, "Only home proxy allowed");
+    }
+}

contracts/src/bridge/xdai/L2Bridge.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+import "./interfaces/IAMB.sol";
+
+import "../IL2Bridge.sol";
+
+contract L2Bridge is IL2Bridge {
+    address public l1Target;
+    IAMB amb;
+
+    constructor(address _l1Target, IAMB _amb) {
+        l1Target = _l1Target;
+        amb = _amb;
+    }
+
+    function sendCrossDomainMessage(bytes memory _calldata) external returns (uint256) {
+        bytes32 id = amb.requireToPassMessage(l1Target, _calldata, amb.maxGasPerTx());
+        return uint256(id);
+    }
+
+    function onlyAuthorized(address _sender) external {
+        require(_sender == address(amb), "Only AMB allowed");
+        //require(amb.messageSourceChainId() == homeChainId, "Only home chain allowed");
+        require(amb.messageSender() == l1Target, "Only home proxy allowed");
+    }
+}

contracts/src/bridge/xdai/interfaces/IAMB.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IAMB {
+    function requireToPassMessage(
+        address _contract,
+        bytes memory _data,
+        uint256 _gas
+    ) external returns (bytes32);
+
+    function maxGasPerTx() external view returns (uint256);
+
+    function messageSender() external view returns (address);
+
+    function messageSourceChainId() external view returns (bytes32);
+
+    function messageId() external view returns (bytes32);
+}

contracts/src/gateway/arbitrum/ArbitrumGateway.sol

@@ -3,7 +3,7 @@
 pragma solidity ^0.8.0;
 
 import "../../arbitration/IArbitrator.sol";
-import "../../bridge/arbitrum/L2Bridge.sol";
+import "../../bridge/IL2Bridge.sol";
 
 import "../IHomeGateway.sol";
 import "../IForeignGateway.sol";
@@ -12,7 +12,7 @@ import "../IHomeEvidence.sol";
 
 contract ArbitrumGateway is IHomeGateway, IHomeEvidence {
     // L2 bridge with the ForeignGateway as the l1target
-    L2Bridge internal l2bridge;
+    IL2Bridge internal l2bridge;
 
     mapping(uint256 => bytes32) public disputeIDtoHash;
     mapping(bytes32 => uint256) public disputeHashtoID;
@@ -28,7 +28,7 @@ contract ArbitrumGateway is IHomeGateway, IHomeEvidence {
 
     constructor(
         IArbitrator _arbitrator,
-        L2Bridge _l2bridge,
+        IL2Bridge _l2bridge,
         IForeignGateway _foreignGateway
     ) {
         arbitrator = _arbitrator;

contracts/src/gateway/arbitrum/EthereumGateway.sol

@@ -3,7 +3,7 @@
 pragma solidity ^0.8.0;
 
 import "../../arbitration/IArbitrable.sol";
-import "../../bridge/arbitrum/L1Bridge.sol";
+import "../../bridge/IL1Bridge.sol";
 
 import "../IHomeGateway.sol";
 import "../IForeignGateway.sol";
@@ -12,7 +12,7 @@ import "../IForeignEvidence.sol";
 
 contract EthereumGateway is IForeignGateway, IForeignEvidence {
     // L1 bridge with the HomeGateway as the l2target
-    L1Bridge internal l1bridge;
+    IL1Bridge internal l1bridge;
     uint256 internal localDisputeID;
 
     // For now this is just a constant, but we'd probably need to
@@ -37,7 +37,7 @@ contract EthereumGateway is IForeignGateway, IForeignEvidence {
 
     constructor(
         uint256 _arbitrationCost,
-        L1Bridge _l1bridge,
+        IL1Bridge _l1bridge,
         IHomeGateway _homeGateway
     ) {
         internalArbitrationCost = _arbitrationCost;