@across-protocol/contracts 0.1.0

package/contracts/common/implementation/Lockable.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+/**
+ * @title A contract that provides modifiers to prevent reentrancy to state-changing and view-only methods. This contract
+ * is inspired by https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/ReentrancyGuard.sol
+ * and https://github.com/balancer-labs/balancer-core/blob/master/contracts/BPool.sol.
+ */
+contract Lockable {
+    bool private _notEntered;
+
+    constructor() {
+        // Storing an initial non-zero value makes deployment a bit more expensive, but in exchange the refund on every
+        // call to nonReentrant will be lower in amount. Since refunds are capped to a percentage of the total
+        // transaction's gas, it is best to keep them low in cases like this one, to increase the likelihood of the full
+        // refund coming into effect.
+        _notEntered = true;
+    }
+
+    /**
+     * @dev Prevents a contract from calling itself, directly or indirectly.
+     * Calling a `nonReentrant` function from another `nonReentrant` function is not supported. It is possible to
+     * prevent this from happening by making the `nonReentrant` function external, and making it call a `private`
+     * function that does the actual state modification.
+     */
+    modifier nonReentrant() {
+        _preEntranceCheck();
+        _preEntranceSet();
+        _;
+        _postEntranceReset();
+    }
+
+    /**
+     * @dev Designed to prevent a view-only method from being re-entered during a call to a `nonReentrant()` state-changing method.
+     */
+    modifier nonReentrantView() {
+        _preEntranceCheck();
+        _;
+    }
+
+    // Internal methods are used to avoid copying the require statement's bytecode to every `nonReentrant()` method.
+    // On entry into a function, `_preEntranceCheck()` should always be called to check if the function is being
+    // re-entered. Then, if the function modifies state, it should call `_postEntranceSet()`, perform its logic, and
+    // then call `_postEntranceReset()`.
+    // View-only methods can simply call `_preEntranceCheck()` to make sure that it is not being re-entered.
+    function _preEntranceCheck() internal view {
+        // On the first call to nonReentrant, _notEntered will be true
+        require(_notEntered, "ReentrancyGuard: reentrant call");
+    }
+
+    function _preEntranceSet() internal {
+        // Any calls to nonReentrant after this point will fail
+        _notEntered = false;
+    }
+
+    function _postEntranceReset() internal {
+        // By storing the original value once again, a refund is triggered (see
+        // https://eips.ethereum.org/EIPS/eip-2200)
+        _notEntered = true;
+    }
+}

package/contracts/common/implementation/MultiCaller.sol

@@ -0,0 +1,27 @@
+// This contract is taken from Uniswaps's multi call implementation (https://github.com/Uniswap/uniswap-v3-periphery/blob/main/contracts/base/Multicall.sol)
+// and was modified to be solidity 0.8 compatible. Additionally, the method was restricted to only work with msg.value
+// set to 0 to avoid any nasty attack vectors on function calls that use value sent with deposits.
+pragma solidity ^0.8.0;
+
+/// @title MultiCaller
+/// @notice Enables calling multiple methods in a single call to the contract
+contract MultiCaller {
+    function multicall(bytes[] calldata data) external payable returns (bytes[] memory results) {
+        require(msg.value == 0, "Only multicall with 0 value");
+        results = new bytes[](data.length);
+        for (uint256 i = 0; i < data.length; i++) {
+            (bool success, bytes memory result) = address(this).delegatecall(data[i]);
+
+            if (!success) {
+                // Next 5 lines from https://ethereum.stackexchange.com/a/83577
+                if (result.length < 68) revert();
+                assembly {
+                    result := add(result, 0x04)
+                }
+                revert(abi.decode(result, (string)));
+            }
+
+            results[i] = result;
+        }
+    }
+}

package/contracts/common/implementation/Testable.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+import "./Timer.sol";
+
+/**
+ * @title Base class that provides time overrides, but only if being run in test mode.
+ */
+abstract contract Testable {
+    // If the contract is being run in production, then `timerAddress` will be the 0x0 address.
+    // Note: this variable should be set on construction and never modified.
+    address public timerAddress;
+
+    /**
+     * @notice Constructs the Testable contract. Called by child contracts.
+     * @param _timerAddress Contract that stores the current time in a testing environment.
+     * Must be set to 0x0 for production environments that use live time.
+     */
+    constructor(address _timerAddress) {
+        timerAddress = _timerAddress;
+    }
+
+    /**
+     * @notice Reverts if not running in test mode.
+     */
+    modifier onlyIfTest {
+        require(timerAddress != address(0x0));
+        _;
+    }
+
+    /**
+     * @notice Sets the current time.
+     * @dev Will revert if not running in test mode.
+     * @param time timestamp to set current Testable time to.
+     */
+    function setCurrentTime(uint256 time) external onlyIfTest {
+        Timer(timerAddress).setCurrentTime(time);
+    }
+
+    /**
+     * @notice Gets the current time. Will return the last time set in `setCurrentTime` if running in test mode.
+     * Otherwise, it will return the block timestamp.
+     * @return uint for the current Testable timestamp.
+     */
+    function getCurrentTime() public view virtual returns (uint256) {
+        if (timerAddress != address(0x0)) {
+            return Timer(timerAddress).getCurrentTime();
+        } else {
+            return block.timestamp; // solhint-disable-line not-rely-on-time
+        }
+    }
+}

package/contracts/common/implementation/Timer.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+/**
+ * @title Universal store of current contract time for testing environments.
+ */
+contract Timer {
+    uint256 private currentTime;
+
+    constructor() {
+        currentTime = block.timestamp; // solhint-disable-line not-rely-on-time
+    }
+
+    /**
+     * @notice Sets the current time.
+     * @dev Will revert if not running in test mode.
+     * @param time timestamp to set `currentTime` to.
+     */
+    function setCurrentTime(uint256 time) external {
+        currentTime = time;
+    }
+
+    /**
+     * @notice Gets the currentTime variable set in the Timer.
+     * @return uint256 for the current Testable timestamp.
+     */
+    function getCurrentTime() public view returns (uint256) {
+        return currentTime;
+    }
+}

package/contracts/common/interfaces/AddressWhitelistInterface.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.0;
+
+interface AddressWhitelistInterface {
+    function addToWhitelist(address newElement) external;
+
+    function removeFromWhitelist(address newElement) external;
+
+    function isOnWhitelist(address newElement) external view returns (bool);
+
+    function getWhitelist() external view returns (address[] memory);
+}

package/contracts/external/avm/AVM_CrossDomainEnabled.sol

@@ -0,0 +1,43 @@
+// Copied logic from https://github.com/makerdao/arbitrum-dai-bridge/blob/34acc39bc6f3a2da0a837ea3c5dbc634ec61c7de/contracts/l2/L2CrossDomainEnabled.sol
+// with a change to the solidity version.
+
+pragma solidity ^0.8.0;
+
+import "./interfaces/ArbSys.sol";
+
+abstract contract AVM_CrossDomainEnabled {
+    event SentCrossDomainMessage(address indexed from, address indexed to, uint256 indexed id, bytes data);
+
+    modifier onlyFromCrossDomainAccount(address l1Counterpart) {
+        require(msg.sender == applyL1ToL2Alias(l1Counterpart), "ONLY_COUNTERPART_GATEWAY");
+        _;
+    }
+
+    uint160 constant offset = uint160(0x1111000000000000000000000000000000001111);
+
+    // l1 addresses are transformed during l1->l2 calls. See https://developer.offchainlabs.com/docs/l1_l2_messages#address-aliasing for more information.
+    function applyL1ToL2Alias(address l1Address) internal pure returns (address l2Address) {
+        l2Address = address(uint160(l1Address) + offset);
+    }
+
+    // Sends a message to L1 via the ArbSys contract. See https://developer.offchainlabs.com/docs/arbsys.
+    // After the Arbitrum chain advances some set amount of time, ArbOS gathers all outgoing messages, Merklizes them,
+    // and publishes the root as an OutboxEntry in the chain's outbox. Note that this happens "automatically";
+    // i.e., it requires no additional action from the user. After the Outbox entry is published on the L1 chain,
+    // the user (or anybody) can compute the Merkle proof of inclusion of their outgoing message. Anytime after the
+    // dispute window passes (~7 days), any user can execute the L1 message by calling Outbox.executeTransaction;
+    // if it reverts, it can be re-executed any number of times and with no upper time-bound.
+    // To read more about the L2 --> L1 lifecycle, see: https://developer.offchainlabs.com/docs/l1_l2_messages#explanation.
+    function sendCrossDomainMessage(
+        address user,
+        address to,
+        bytes memory data
+    ) internal returns (uint256) {
+        // note: this method doesn't support sending ether to L1 together with a call
+        uint256 id = ArbSys(address(100)).sendTxToL1(to, data);
+
+        emit SentCrossDomainMessage(user, to, id, data);
+
+        return id;
+    }
+}

package/contracts/external/avm/interfaces/ArbSys.sol

@@ -0,0 +1,79 @@
+// Copied logic from https://github.com/makerdao/arbitrum-dai-bridge/blob/54a2109a97c5b1504824c6317d358e2d2733b5a3/contracts/arbitrum/ArbSys.sol
+// with changes only to the solidity version and comments.
+
+pragma solidity ^0.8.0;
+
+/**
+ * @notice Precompiled contract that exists in every Arbitrum chain at address(100),
+ * 0x0000000000000000000000000000000000000064. Exposes a variety of system-level functionality. ArbSys provides
+ * systems functionality useful to some Arbitrum contracts. Any contract running on an Arbitrum Chain can call the
+ * chain's ArbSys.
+ */
+interface ArbSys {
+    /**
+     * @notice Get internal version number identifying an ArbOS build
+     * @return version number as int
+     */
+    function arbOSVersion() external pure returns (uint256);
+
+    function arbChainID() external view returns (uint256);
+
+    /**
+     * @notice Get Arbitrum block number (distinct from L1 block number; Arbitrum genesis block has block number 0)
+     * @return block number as int
+     */
+    function arbBlockNumber() external view returns (uint256);
+
+    /**
+     * @notice Send given amount of Eth to dest from sender.
+     * This is a convenience function, which is equivalent to calling sendTxToL1 with empty calldataForL1.
+     * @param destination recipient address on L1
+     * @return unique identifier for this L2-to-L1 transaction.
+     */
+    function withdrawEth(address destination) external payable returns (uint256);
+
+    /**
+     * @notice Send a transaction to L1
+     * @param destination recipient address on L1
+     * @param calldataForL1 (optional) calldata for L1 contract call
+     * @return a unique identifier for this L2-to-L1 transaction.
+     */
+    function sendTxToL1(address destination, bytes calldata calldataForL1) external payable returns (uint256);
+
+    /**
+     * @notice get the number of transactions issued by the given external account or the account sequence number of the given contract
+     * @param account target account
+     * @return the number of transactions issued by the given external account or the account sequence number of the given contract
+     */
+    function getTransactionCount(address account) external view returns (uint256);
+
+    /**
+     * @notice get the value of target L2 storage slot
+     * This function is only callable from address 0 to prevent contracts from being able to call it
+     * @param account target account
+     * @param index target index of storage slot
+     * @return stotage value for the given account at the given index
+     */
+    function getStorageAt(address account, uint256 index) external view returns (uint256);
+
+    /**
+     * @notice check if current call is coming from l1
+     * @return true if the caller of this was called directly from L1
+     */
+    function isTopLevelCall() external view returns (bool);
+
+    event EthWithdrawal(address indexed destAddr, uint256 amount);
+
+    event L2ToL1Transaction(
+        address caller,
+        address indexed destination,
+        uint256 indexed uniqueId,
+        uint256 indexed batchNumber,
+        uint256 indexInBatch,
+        uint256 arbBlockNum,
+        uint256 ethBlockNum,
+        uint256 timestamp,
+        uint256 callvalue,
+        bytes data
+    );
+}

package/contracts/external/avm/interfaces/iArbitrum_Inbox.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+
+pragma solidity ^0.8.0;
+
+interface IBridge {
+    function activeOutbox() external view returns (address);
+}
+
+interface iArbitrum_Inbox {
+    // Retryable tickets are the Arbitrum protocol’s canonical method for passing generalized messages from Ethereum to
+    // Arbitrum. A retryable ticket is an L2 message encoded and delivered by L1; if gas is provided, it will be executed
+    // immediately. If no gas is provided or the execution reverts, it will be placed in the L2 retry buffer,
+    // where any user can re-execute for some fixed period (roughly one week).
+    // Retryable tickets are created by calling Inbox.createRetryableTicket.
+    // More details here: https://developer.offchainlabs.com/docs/l1_l2_messages#ethereum-to-arbitrum-retryable-tickets
+    function createRetryableTicketNoRefundAliasRewrite(
+        address destAddr,
+        uint256 l2CallValue,
+        uint256 maxSubmissionCost,
+        address excessFeeRefundAddress,
+        address callValueRefundAddress,
+        uint256 maxGas,
+        uint256 gasPriceBid,
+        bytes calldata data
+    ) external payable returns (uint256);
+
+    function bridge() external view returns (address);
+}

package/contracts/external/avm/interfaces/iArbitrum_Outbox.sol

@@ -0,0 +1,26 @@
+// Copied logic from https://github.com/OffchainLabs/arbitrum-tutorials/blob/4761fa1ba1f1eca95e8c03f24f1442ed5aecd8bd/packages/arb-shared-dependencies/contracts/Outbox.sol
+// with changes only to the solidity version.
+
+// SPDX-License-Identifier: Apache-2.0
+
+/*
+ * Copyright 2021, Offchain Labs, Inc.
+ *
+ * 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.
+ */
+
+pragma solidity ^0.8.0;
+
+interface iArbitrum_Outbox {
+    function l2ToL1Sender() external view returns (address);
+}