@hyperlane-xyz/core 5.0.0 → 5.1.0

package/contracts/libs/StaticWeightedValidatorSetFactory.sol

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+// ============ External Imports ============
+
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
+import {IStaticWeightedMultisigIsm} from "../interfaces/isms/IWeightedMultisigIsm.sol";
+
+// ============ Internal Imports ============
+import {MetaProxy} from "./MetaProxy.sol";
+
+abstract contract StaticWeightedValidatorSetFactory {
+    // ============ Immutables ============
+    address public immutable implementation;
+
+    // ============ Constructor ============
+
+    constructor() {
+        implementation = _deployImplementation();
+    }
+
+    function _deployImplementation() internal virtual returns (address);
+
+    /**
+     * @notice Deploys a StaticWeightedValidatorSet contract address for the given
+     * values
+     * @dev Consider sorting addresses to ensure contract reuse
+     * @param _validators An array of addresses
+     * @param _thresholdWeight The threshold weight value to use
+     * @return set The contract address representing this StaticWeightedValidatorSet
+     */
+    function deploy(
+        IStaticWeightedMultisigIsm.ValidatorInfo[] calldata _validators,
+        uint96 _thresholdWeight
+    ) public returns (address) {
+        (bytes32 _salt, bytes memory _bytecode) = _saltAndBytecode(
+            _validators,
+            _thresholdWeight
+        );
+        address _set = _getAddress(_salt, _bytecode);
+        if (!Address.isContract(_set)) {
+            _set = Create2.deploy(0, _salt, _bytecode);
+        }
+        return _set;
+    }
+
+    /**
+     * @notice Returns the StaticWeightedValidatorSet contract address for the given
+     * values
+     * @dev Consider sorting addresses to ensure contract reuse
+     * @param _validators An array of addresses
+     * @param _thresholdWeight The threshold weight value to use
+     * @return set The contract address representing this StaticWeightedValidatorSet
+     */
+    function getAddress(
+        IStaticWeightedMultisigIsm.ValidatorInfo[] calldata _validators,
+        uint96 _thresholdWeight
+    ) external view returns (address) {
+        (bytes32 _salt, bytes memory _bytecode) = _saltAndBytecode(
+            _validators,
+            _thresholdWeight
+        );
+        return _getAddress(_salt, _bytecode);
+    }
+
+    /**
+     * @notice Returns the StaticWeightedValidatorSet contract address for the given
+     * values
+     * @param _salt The salt used in Create2
+     * @param _bytecode The metaproxy bytecode used in Create2
+     * @return set The contract address representing this StaticWeightedValidatorSet
+     */
+    function _getAddress(
+        bytes32 _salt,
+        bytes memory _bytecode
+    ) internal view returns (address) {
+        bytes32 _bytecodeHash = keccak256(_bytecode);
+        return Create2.computeAddress(_salt, _bytecodeHash);
+    }
+
+    /**
+     * @notice Returns the create2 salt and bytecode for the given values
+     * @param _validators An array of addresses
+     * @param _thresholdWeight The threshold weight value to use
+     * @return _salt The salt used in Create2
+     * @return _bytecode The metaproxy bytecode used in Create2
+     */
+    function _saltAndBytecode(
+        IStaticWeightedMultisigIsm.ValidatorInfo[] calldata _validators,
+        uint96 _thresholdWeight
+    ) internal view returns (bytes32, bytes memory) {
+        bytes memory _metadata = abi.encode(_validators, _thresholdWeight);
+        bytes memory _bytecode = MetaProxy.bytecode(implementation, _metadata);
+        bytes32 _salt = keccak256(_metadata);
+        return (_salt, _bytecode);
+    }
+}

package/contracts/mock/MockArbBridge.sol

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: MIT or Apache-2.0
+pragma solidity ^0.8.13;
+
+contract MockArbSys {
+    event L2ToL1Tx(
+        address caller,
+        address indexed destination,
+        uint256 indexed hash,
+        uint256 indexed position,
+        uint256 arbBlockNum,
+        uint256 ethBlockNum,
+        uint256 timestamp,
+        uint256 callvalue,
+        bytes data
+    );
+
+    function sendTxToL1(
+        address destination,
+        bytes calldata data
+    ) external payable returns (uint256) {
+        emit L2ToL1Tx(
+            msg.sender,
+            destination,
+            uint256(keccak256(data)),
+            42,
+            block.number * 10,
+            block.number,
+            block.timestamp,
+            msg.value,
+            data
+        );
+        return 0;
+    }
+}
+
+contract MockArbBridge {
+    error BridgeCallFailed();
+
+    address public activeOutbox;
+    address public l2ToL1Sender;
+
+    constructor() {
+        activeOutbox = address(this);
+    }
+
+    function setL2ToL1Sender(address _sender) external {
+        l2ToL1Sender = _sender;
+    }
+
+    function bridge() external view returns (address) {
+        return address(this);
+    }
+
+    function executeTransaction(
+        bytes32[] calldata /*proof*/,
+        uint256 /*index*/,
+        address /*l2Sender*/,
+        address to,
+        uint256 /*l2Block*/,
+        uint256 /*l1Block*/,
+        uint256 /*timestamp*/,
+        uint256 value,
+        bytes calldata data
+    ) external payable {
+        (bool success, bytes memory returndata) = to.call{value: value}(data);
+        if (!success) {
+            if (returndata.length > 0) {
+                // solhint-disable-next-line no-inline-assembly
+                assembly {
+                    let returndata_size := mload(returndata)
+                    revert(add(32, returndata), returndata_size)
+                }
+            } else {
+                revert BridgeCallFailed();
+            }
+        }
+    }
+}

package/contracts/mock/MockERC4626YieldSharing.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol";
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/interfaces/IERC20.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+/**
+ * @title MockERC4626YieldSharing
+ * @dev Mock ERC4626 vault for testing yield sharing with the owner of the vault
+ * @dev This is a simplified version of the Aave v3 vault here
+ * https://github.com/aave/Aave-Vault/blob/main/src/ATokenVault.sol
+ */
+contract MockERC4626YieldSharing is ERC4626, Ownable {
+    using Math for uint256;
+
+    uint256 public constant SCALE = 1e18;
+    uint256 public fee;
+    uint256 public accumulatedFees;
+    uint256 public lastVaultBalance;
+
+    constructor(
+        address _asset,
+        string memory _name,
+        string memory _symbol,
+        uint256 _initialFee
+    ) ERC4626(IERC20(_asset)) ERC20(_name, _symbol) {
+        fee = _initialFee;
+    }
+
+    function setFee(uint256 newFee) external onlyOwner {
+        require(newFee <= SCALE, "Fee too high");
+        fee = newFee;
+    }
+
+    function _accrueYield() internal {
+        uint256 newVaultBalance = IERC20(asset()).balanceOf(address(this));
+        if (newVaultBalance > lastVaultBalance) {
+            uint256 newYield = newVaultBalance - lastVaultBalance;
+            uint256 newFees = newYield.mulDiv(fee, SCALE, Math.Rounding.Down);
+            accumulatedFees += newFees;
+            lastVaultBalance = newVaultBalance;
+        }
+    }
+
+    function deposit(
+        uint256 assets,
+        address receiver
+    ) public override returns (uint256) {
+        lastVaultBalance += assets;
+        return super.deposit(assets, receiver);
+    }
+
+    function redeem(
+        uint256 shares,
+        address receiver,
+        address owner
+    ) public override returns (uint256) {
+        _accrueYield();
+        return super.redeem(shares, receiver, owner);
+    }
+
+    function getClaimableFees() public view returns (uint256) {
+        uint256 newVaultBalance = IERC20(asset()).balanceOf(address(this));
+
+        if (newVaultBalance <= lastVaultBalance) {
+            return accumulatedFees;
+        }
+
+        uint256 newYield = newVaultBalance - lastVaultBalance;
+        uint256 newFees = newYield.mulDiv(fee, SCALE, Math.Rounding.Down);
+
+        return accumulatedFees + newFees;
+    }
+
+    function totalAssets() public view override returns (uint256) {
+        return IERC20(asset()).balanceOf(address(this)) - getClaimableFees();
+    }
+}

package/contracts/mock/MockHyperlaneEnvironment.sol

@@ -8,8 +8,8 @@ import "../test/TestIsm.sol";
 import {TypeCasts} from "../libs/TypeCasts.sol";
 
 contract MockHyperlaneEnvironment {
-    uint32 originDomain;
-    uint32 destinationDomain;
+    uint32 public originDomain;
+    uint32 public destinationDomain;
 
     mapping(uint32 => MockMailbox) public mailboxes;
     mapping(uint32 => TestInterchainGasPaymaster) public igps;

package/contracts/mock/MockOptimism.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {CallLib} from "../middleware/libs/Call.sol";
+import {TypeCasts} from "../libs/TypeCasts.sol";
+import {ICrossDomainMessenger} from "../interfaces/optimism/ICrossDomainMessenger.sol";
+import {IOptimismPortal} from "../interfaces/optimism/IOptimismPortal.sol";
+
+// for both L1 and L2
+contract MockOptimismMessenger is ICrossDomainMessenger {
+    address public xDomainMessageSender;
+    address public PORTAL;
+
+    function sendMessage(
+        address _target,
+        bytes calldata _message,
+        uint32 _gasLimit
+    ) external payable {}
+
+    function relayMessage(
+        uint256 /*_nonce*/,
+        address /*_sender*/,
+        address _target,
+        uint256 _value,
+        uint256 /*_minGasLimit*/,
+        bytes calldata _message
+    ) external payable {
+        CallLib.Call memory call = CallLib.Call(
+            TypeCasts.addressToBytes32(_target),
+            _value,
+            _message
+        );
+        CallLib.call(call);
+    }
+
+    function OTHER_MESSENGER() external view returns (address) {}
+
+    function setXDomainMessageSender(address _sender) external {
+        xDomainMessageSender = _sender;
+    }
+
+    function setPORTAL(address _portal) external {
+        PORTAL = _portal;
+    }
+}
+
+// mock deployment on L1
+contract MockOptimismPortal is IOptimismPortal {
+    error WithdrawalTransactionFailed();
+
+    function finalizeWithdrawalTransaction(
+        WithdrawalTransaction memory _tx
+    ) external {
+        CallLib.Call memory call = CallLib.Call(
+            TypeCasts.addressToBytes32(_tx.target),
+            _tx.value,
+            _tx.data
+        );
+        CallLib.call(call);
+    }
+}

package/contracts/test/ERC20Test.sol

@@ -31,6 +31,10 @@ contract ERC20Test is ERC20 {
     function mintTo(address account, uint256 amount) public {
         _mint(account, amount);
     }
+
+    function burnFrom(address account, uint256 amount) public {
+        _burn(account, amount);
+    }
 }
 
 contract FiatTokenTest is ERC20Test, IFiatToken {

package/contracts/test/ERC4626/ERC4626Test.sol

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity >=0.8.0;
+
 import "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol";
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import "@openzeppelin/contracts/interfaces/IERC20.sol";

package/contracts/token/extensions/HypERC4626.sol

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+import {IXERC20} from "../interfaces/IXERC20.sol";
+import {HypERC20} from "../HypERC20.sol";
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
+import {Message} from "../../libs/Message.sol";
+import {TokenMessage} from "../libs/TokenMessage.sol";
+import {TokenRouter} from "../libs/TokenRouter.sol";
+
+/**
+ * @title Hyperlane ERC20 Rebasing Token
+ * @author Abacus Works
+ */
+contract HypERC4626 is HypERC20 {
+    using Math for uint256;
+    using Message for bytes;
+    using TokenMessage for bytes;
+
+    uint256 public constant PRECISION = 1e10;
+    uint32 public immutable collateralDomain;
+    uint256 public exchangeRate; // 1e10
+
+    constructor(
+        uint8 _decimals,
+        address _mailbox,
+        uint32 _collateralDomain
+    ) HypERC20(_decimals, _mailbox) {
+        collateralDomain = _collateralDomain;
+        exchangeRate = 1e10;
+        _disableInitializers();
+    }
+
+    /// Override to send shares instead of assets from synthetic
+    /// @inheritdoc TokenRouter
+    function _transferRemote(
+        uint32 _destination,
+        bytes32 _recipient,
+        uint256 _amountOrId,
+        uint256 _value,
+        bytes memory _hookMetadata,
+        address _hook
+    ) internal virtual override returns (bytes32 messageId) {
+        uint256 _shares = assetsToShares(_amountOrId);
+        _transferFromSender(_shares);
+        bytes memory _tokenMessage = TokenMessage.format(
+            _recipient,
+            _shares,
+            bytes("")
+        );
+
+        messageId = _Router_dispatch(
+            _destination,
+            _value,
+            _tokenMessage,
+            _hookMetadata,
+            _hook
+        );
+
+        emit SentTransferRemote(_destination, _recipient, _amountOrId);
+    }
+
+    function _handle(
+        uint32 _origin,
+        bytes32 _sender,
+        bytes calldata _message
+    ) internal virtual override {
+        if (_origin == collateralDomain) {
+            exchangeRate = abi.decode(_message.metadata(), (uint256));
+        }
+        super._handle(_origin, _sender, _message);
+    }
+
+    // Override to send shares locally instead of assets
+    function transfer(
+        address to,
+        uint256 amount
+    ) public virtual override returns (bool) {
+        address owner = _msgSender();
+        _transfer(owner, to, assetsToShares(amount));
+        return true;
+    }
+
+    function shareBalanceOf(address account) public view returns (uint256) {
+        return super.balanceOf(account);
+    }
+
+    function balanceOf(
+        address account
+    ) public view virtual override returns (uint256) {
+        uint256 _balance = super.balanceOf(account);
+        return sharesToAssets(_balance);
+    }
+
+    function assetsToShares(uint256 _amount) public view returns (uint256) {
+        return _amount.mulDiv(PRECISION, exchangeRate);
+    }
+
+    function sharesToAssets(uint256 _shares) public view returns (uint256) {
+        return _shares.mulDiv(exchangeRate, PRECISION);
+    }
+}

package/contracts/token/extensions/HypERC4626Collateral.sol

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol";
+import {TokenMessage} from "../libs/TokenMessage.sol";
+import {HypERC20Collateral} from "../HypERC20Collateral.sol";
+import {TypeCasts} from "../../libs/TypeCasts.sol";
+
+/**
+ * @title Hyperlane ERC4626 Token Collateral with deposits collateral to a vault
+ * @author Abacus Works
+ */
+contract HypERC4626Collateral is HypERC20Collateral {
+    using TypeCasts for address;
+    using TokenMessage for bytes;
+    using Math for uint256;
+
+    // Address of the ERC4626 compatible vault
+    ERC4626 public immutable vault;
+    uint256 public constant PRECISION = 1e10;
+    bytes32 public constant NULL_RECIPIENT =
+        0x0000000000000000000000000000000000000000000000000000000000000001;
+
+    constructor(
+        ERC4626 _vault,
+        address _mailbox
+    ) HypERC20Collateral(_vault.asset(), _mailbox) {
+        vault = _vault;
+    }
+
+    function initialize(
+        address _hook,
+        address _interchainSecurityModule,
+        address _owner
+    ) public override initializer {
+        _MailboxClient_initialize(_hook, _interchainSecurityModule, _owner);
+    }
+
+    function _transferRemote(
+        uint32 _destination,
+        bytes32 _recipient,
+        uint256 _amount,
+        uint256 _value,
+        bytes memory _hookMetadata,
+        address _hook
+    ) internal virtual override returns (bytes32 messageId) {
+        // Can't override _transferFromSender only because we need to pass shares in the token message
+        _transferFromSender(_amount);
+        uint256 _shares = _depositIntoVault(_amount);
+        uint256 _exchangeRate = PRECISION.mulDiv(
+            vault.totalAssets(),
+            vault.totalSupply(),
+            Math.Rounding.Down
+        );
+        bytes memory _tokenMetadata = abi.encode(_exchangeRate);
+
+        bytes memory _tokenMessage = TokenMessage.format(
+            _recipient,
+            _shares,
+            _tokenMetadata
+        );
+
+        messageId = _Router_dispatch(
+            _destination,
+            _value,
+            _tokenMessage,
+            _hookMetadata,
+            _hook
+        );
+
+        emit SentTransferRemote(_destination, _recipient, _shares);
+    }
+
+    /**
+     * @dev Deposits into the vault and increment assetDeposited
+     * @param _amount amount to deposit into vault
+     */
+    function _depositIntoVault(uint256 _amount) internal returns (uint256) {
+        wrappedToken.approve(address(vault), _amount);
+        return vault.deposit(_amount, address(this));
+    }
+
+    /**
+     * @dev Transfers `_amount` of `wrappedToken` from this contract to `_recipient`, and withdraws from vault
+     * @inheritdoc HypERC20Collateral
+     */
+    function _transferTo(
+        address _recipient,
+        uint256 _amount,
+        bytes calldata
+    ) internal virtual override {
+        // withdraw with the specified amount of shares
+        vault.redeem(_amount, _recipient, address(this));
+    }
+
+    /**
+     * @dev Update the exchange rate on the synthetic token by accounting for additional yield accrued to the underlying vault
+     * @param _destinationDomain domain of the vault
+     */
+    function rebase(uint32 _destinationDomain) public payable {
+        // force a rebase with an empty transfer to 0x1
+        _transferRemote(
+            _destinationDomain,
+            NULL_RECIPIENT,
+            0,
+            msg.value,
+            bytes(""),
+            address(0)
+        );
+    }
+}

package/contracts/token/extensions/{HypERC20CollateralVaultDeposit.sol → HypERC4626OwnerCollateral.sol}

@@ -1,13 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity >=0.8.0;
+
 import "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol";
 import {HypERC20Collateral} from "../HypERC20Collateral.sol";
 
 /**
- * @title Hyperlane ERC20 Token Collateral with deposits collateral to a vault
+ * @title Hyperlane ERC20 Token Collateral with deposits collateral to a vault, the yield goes to the owner
  * @author ltyu
  */
-contract HypERC20CollateralVaultDeposit is HypERC20Collateral {
+contract HypERC4626OwnerCollateral is HypERC20Collateral {
     // Address of the ERC4626 compatible vault
     ERC4626 public immutable vault;