Hop

1// SPDX-License-Identifier: MIT
2
3pragma solidity 0.6.12;
4pragma experimental ABIEncoderV2;
5
6import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
7import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
8import "./Bridge.sol";
9import "./L2_Bridge.sol";
10
11/**
12 * @dev L1_Bridge is responsible for the bonding and challenging of TransferRoots. All TransferRoots
13 * originate in the L1_Bridge through `bondTransferRoot` and are propagated up to destination L2s.
14 */
15
16abstract contract L1_Bridge is Bridge {
17    using SafeERC20 for IERC20;
18
19    struct TransferBond {
20        address bonder;
21        uint256 createdAt;
22        uint256 totalAmount;
23        uint256 challengeStartTime;
24        address challenger;
25        bool challengeResolved;
26    }
27
28    /* ========== Constants ========== */
29
30    address constant ETH_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
31
32    /* ========== State ========== */
33
34    address public immutable token;
35    mapping(uint256 => mapping(bytes32 => uint256)) public transferRootCommittedAt;
36    mapping(bytes32 => TransferBond) public transferBonds;
37    mapping(uint256 => mapping(address => uint256)) public timeSlotToAmountBonded;
38    mapping(uint256 => uint256) public chainBalance;
39
40    /* ========== Config State ========== */
41
42    mapping(uint256 => address) public xDomainConnectors;
43    mapping(uint256 => bool) public isChainIdPaused;
44    uint256 public challengePeriod = 1 days;
45    uint256 public challengeResolutionPeriod = 10 days;
46    uint256 public minTransferRootBondDelay = 15 minutes;
47    
48    uint256 public constant CHALLENGE_AMOUNT_DIVISOR = 10;
49    uint256 public constant TIME_SLOT_SIZE = 4 hours;
50
51    /* ========== Events ========== */
52
53    event TransferSentToL2(
54        uint256 indexed chainId,
55        address indexed recipient,
56        uint256 amount,
57        uint256 tokenIndex,
58        uint256 amountOutMin,
59        uint256 deadline,
60        address indexed relayer,
61        uint256 relayerFee
62    );
63
64    event TransferRootBonded (
65        bytes32 indexed root,
66        uint256 amount,
67        uint256 destinationChainid
68    );
69
70    event TransferRootConfirmed(
71        uint256 indexed originChainId,
72        uint256 indexed destinationChainId,
73        bytes32 indexed rootHash,
74        uint256 totalAmount
75    );
76
77    event TransferBondChallenged(
78        bytes32 indexed transferRootId,
79        bytes32 indexed rootHash,
80        uint256 originalAmount
81    );
82
83    event ChallengeResolved(
84        bytes32 indexed transferRootId,
85        bytes32 indexed rootHash,
86        uint256 originalAmount
87    );
88
89    /* ========== Modifiers ========== */
90
91    modifier onlyL2Bridge(uint256 chainId) {
92        require(msg.sender == xDomainConnectors[chainId], "L1_BRG: Caller must be bridge connector");
93        _;
94    }
95
96    constructor (
97        IBonderRegistry _registry,
98        address _token
99    )
100        public
101        Bridge(_registry)
102    {
103        token = _token;
104    }
105
106    /* ========== Send Functions ========== */
107
108    /**
109     * @notice `swapData` should contain all 0s when no swap is intended at the destination.
110     * @notice `amount` is the total amount the user wants to send including the relayer fee
111     * @dev Send tokens to a supported layer-2 to mint hToken and optionally swap the hToken in the
112     * AMM at the destination.
113     * @param chainId The chainId of the destination chain
114     * @param recipient The address receiving funds at the destination
115     * @param amount The amount being sent
116     * @param swapData The `tokenIndex`, `amountOutMin`, and `deadline` used for swaps
117     * @param relayer The address of the relayer at the destination.
118     * @param relayerFee The amount distributed to the relayer at the destination. This is subtracted from the `amount`.
119     */
120    function sendToL2(
121        uint256 chainId,
122        address recipient,
123        uint256 amount,
124        SwapData calldata swapData,
125        address relayer,
126        uint256 relayerFee
127    )
128        external
129        payable
130    {
131        address xDomainConnector = xDomainConnectors[chainId];
132        require(xDomainConnector != address(0), "L1_BRG: chainId not supported");
133        require(isChainIdPaused[chainId] == false, "L1_BRG: Sends to this chainId are paused");
134        require(amount > 0, "L1_BRG: Must transfer a non-zero amount");
135        require(amount >= relayerFee, "L1_BRG: Relayer fee cannot exceed amount");
136
137        _transferToBridge(msg.sender, amount);
138
139        chainBalance[chainId] = chainBalance[chainId].add(amount);
140
141        uint256 forwardedValue;
142        if (token == ETH_ADDRESS) {
143            forwardedValue = msg.value.sub(amount, "L1_BRG: Value is less than amount");
144        } else {
145            forwardedValue = msg.value;
146        }
147
148        L2_Bridge(xDomainConnector).distribute(
149            recipient,
150            amount,
151            swapData,
152            relayer,
153            relayerFee
154        );
155
156        emit TransferSentToL2(
157            chainId,
158            recipient,
159            amount,
160            swapData.tokenIndex,
161            swapData.amountOutMin,
162            swapData.deadline,
163            relayer,
164            relayerFee
165        );
166    }
167
168    /* ========== TransferRoot Functions ========== */
169
170    /**
171     * @dev Setting a TransferRoot is a two step process.
172     * @dev   1. The TransferRoot is bonded with `bondTransferRoot`. Withdrawals can now begin on L1
173     * @dev      and recipient L2's
174     * @dev   2. The TransferRoot is confirmed after `confirmTransferRoot` is called by the l2 bridge
175     * @dev      where the TransferRoot originated.
176     */
177
178    /**
179     * @dev Used by the Bonder to bond a TransferRoot and propagate it up to destination L2s
180     * @param rootHash The Merkle root of the TransferRoot Merkle tree
181     * @param destinationChainId The id of the destination chain
182     * @param totalAmount The amount destined for the destination chain
183     */
184    function bondTransferRoot(
185        bytes32 rootHash,
186        uint256 destinationChainId,
187        uint256 totalAmount
188    )
189        external
190        onlyBonder
191        requirePositiveBalance
192    {
193        _bondTransferRoot(rootHash, destinationChainId, totalAmount);
194    }
195
196    /**
197     * @dev Convenience function used by the Bonder to bond a TransferRoot and immediately settle it on L1
198     * @param rootHash The Merkle root of the TransferRoot Merkle tree
199     * @param destinationChainId The id of the destination chain
200     * @param transferIds All transferIds in the TransferRoot in order
201     * @param totalAmount The amount destined for the destination chain
202     */
203    function bondTransferRootAndSettle(
204        bytes32 rootHash,
205        uint256 destinationChainId,
206        // transferIds _must_ be calldata or it will be mutated by Lib_MerkleTree.getMerkleRoot
207        bytes32[] calldata transferIds,
208        uint256 totalAmount
209    )
210        external
211        onlyBonder
212        requirePositiveBalance
213    {
214        require(destinationChainId == getChainId(), "L1_BRG: bondTransferRootAndSettle is for L1 only");
215        _bondTransferRoot(rootHash, destinationChainId, totalAmount);
216        settleBondedWithdrawals(msg.sender, transferIds, totalAmount);
217    }
218

JavaScript Tests