@hyperlane-xyz/core 1.5.4-beta0 → 1.5.5-beta0

package/contracts/isms/multisig/ValidatorAnnounce.sol

@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import {IValidatorAnnounce} from "../../interfaces/IValidatorAnnounce.sol";
+import {IMailbox} from "../../interfaces/IMailbox.sol";
+import {TypeCasts} from "../../libs/TypeCasts.sol";
+import {MailboxClient} from "../../client/MailboxClient.sol";
+
+// ============ External Imports ============
+import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
+import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+
+/**
+ * @title ValidatorAnnounce
+ * @notice Stores the location(s) of validator signed checkpoints
+ */
+contract ValidatorAnnounce is MailboxClient, IValidatorAnnounce {
+    // ============ Libraries ============
+
+    using EnumerableSet for EnumerableSet.AddressSet;
+    using TypeCasts for address;
+
+    // ============ Public Storage ============
+
+    // The set of validators that have announced
+    EnumerableSet.AddressSet private validators;
+    // Storage locations of validator signed checkpoints
+    mapping(address => string[]) private storageLocations;
+    // Mapping to prevent the same announcement from being registered
+    // multiple times.
+    mapping(bytes32 => bool) private replayProtection;
+
+    // ============ Events ============
+
+    /**
+     * @notice Emitted when a new validator announcement is made
+     * @param validator The address of the announcing validator
+     * @param storageLocation The storage location being announced
+     */
+    event ValidatorAnnouncement(
+        address indexed validator,
+        string storageLocation
+    );
+
+    // ============ Constructor ============
+
+    constructor(address _mailbox) MailboxClient(_mailbox) {}
+
+    // ============ External Functions ============
+
+    /**
+     * @notice Announces a validator signature storage location
+     * @param _storageLocation Information encoding the location of signed
+     * checkpoints
+     * @param _signature The signed validator announcement
+     * @return True upon success
+     */
+    function announce(
+        address _validator,
+        string calldata _storageLocation,
+        bytes calldata _signature
+    ) external returns (bool) {
+        // Ensure that the same storage metadata isn't being announced
+        // multiple times for the same validator.
+        bytes32 _replayId = keccak256(
+            abi.encodePacked(_validator, _storageLocation)
+        );
+        require(replayProtection[_replayId] == false, "replay");
+        replayProtection[_replayId] = true;
+
+        // Verify that the signature matches the declared validator
+        bytes32 _announcementDigest = getAnnouncementDigest(_storageLocation);
+        address _signer = ECDSA.recover(_announcementDigest, _signature);
+        require(_signer == _validator, "!signature");
+
+        // Store the announcement
+        if (!validators.contains(_validator)) {
+            validators.add(_validator);
+        }
+        storageLocations[_validator].push(_storageLocation);
+        emit ValidatorAnnouncement(_validator, _storageLocation);
+        return true;
+    }
+
+    /**
+     * @notice Returns a list of all announced storage locations
+     * @param _validators The list of validators to get registrations for
+     * @return A list of registered storage metadata
+     */
+    function getAnnouncedStorageLocations(address[] calldata _validators)
+        external
+        view
+        returns (string[][] memory)
+    {
+        string[][] memory _metadata = new string[][](_validators.length);
+        for (uint256 i = 0; i < _validators.length; i++) {
+            _metadata[i] = storageLocations[_validators[i]];
+        }
+        return _metadata;
+    }
+
+    /// @notice Returns a list of validators that have made announcements
+    function getAnnouncedValidators() external view returns (address[] memory) {
+        return validators.values();
+    }
+
+    /**
+     * @notice Returns the digest validators are expected to sign when signing announcements.
+     * @param _storageLocation Storage location string.
+     * @return The digest of the announcement.
+     */
+    function getAnnouncementDigest(string memory _storageLocation)
+        public
+        view
+        returns (bytes32)
+    {
+        return
+            ECDSA.toEthSignedMessageHash(
+                keccak256(abi.encodePacked(_domainHash(), _storageLocation))
+            );
+    }
+
+    /**
+     * @notice Returns the domain separator used in validator announcements.
+     */
+    function _domainHash() internal view returns (bytes32) {
+        return
+            keccak256(
+                abi.encodePacked(
+                    localDomain,
+                    address(mailbox).addressToBytes32(),
+                    "HYPERLANE_ANNOUNCEMENT"
+                )
+            );
+    }
+}

package/contracts/isms/routing/DefaultFallbackRoutingIsm.sol

@@ -1,29 +1,24 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 pragma solidity >=0.8.0;
 
+// ============ Internal Imports ============
 import {DomainRoutingIsm} from "./DomainRoutingIsm.sol";
-import {IMailbox} from "../../Mailbox.sol";
 import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
 import {EnumerableMapExtended} from "../../libs/EnumerableMapExtended.sol";
 import {TypeCasts} from "../../libs/TypeCasts.sol";
+import {MailboxClient} from "../../client/MailboxClient.sol";
+
+// ============ External Imports ============
 import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 
-contract DefaultFallbackRoutingIsm is DomainRoutingIsm {
+contract DefaultFallbackRoutingIsm is DomainRoutingIsm, MailboxClient {
     using EnumerableMapExtended for EnumerableMapExtended.UintToBytes32Map;
     using Address for address;
     using TypeCasts for bytes32;
 
-    IMailbox public immutable mailbox;
-
-    constructor(address _mailbox) {
-        require(
-            _mailbox.isContract(),
-            "DefaultFallbackRoutingIsm: INVALID_MAILBOX"
-        );
-        mailbox = IMailbox(_mailbox);
-    }
+    constructor(address _mailbox) MailboxClient(_mailbox) {}
 
-    function modules(uint32 origin)
+    function module(uint32 origin)
         public
         view
         override

package/contracts/isms/routing/DomainRoutingIsm.sol

@@ -1,8 +1,10 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 pragma solidity >=0.8.0;
+
 // ============ External Imports ============
 import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
 
 // ============ Internal Imports ============
 import {AbstractRoutingIsm} from "./AbstractRoutingIsm.sol";
@@ -20,19 +22,11 @@ contract DomainRoutingIsm is AbstractRoutingIsm, OwnableUpgradeable {
     using TypeCasts for bytes32;
     using TypeCasts for address;
     using Address for address;
+    using Strings for uint32;
 
     // ============ Mutable Storage ============
     EnumerableMapExtended.UintToBytes32Map internal _modules;
 
-    // ============ Events ============
-
-    /**
-     * @notice Emitted when a module is set for a domain
-     * @param domain The origin domain.
-     * @param module The ISM to use.
-     */
-    event ModuleSet(uint32 indexed domain, address module);
-
     // ============ External Functions ============
 
     /**
@@ -75,18 +69,26 @@ contract DomainRoutingIsm is AbstractRoutingIsm, OwnableUpgradeable {
         _set(_domain, address(_module));
     }
 
+    /**
+     * @notice Removes the specified origin domain
+     * @param _domain The origin domain
+     */
+    function remove(uint32 _domain) external onlyOwner {
+        _remove(_domain);
+    }
+
     function domains() external view returns (uint256[] memory) {
         return _modules.keys();
     }
 
-    function modules(uint32 origin)
+    function module(uint32 origin)
         public
         view
         virtual
         returns (IInterchainSecurityModule)
     {
         (bool contained, bytes32 _module) = _modules.tryGet(origin);
-        require(contained, "No ISM found for origin domain");
+        require(contained, _originNotFoundError(origin));
         return IInterchainSecurityModule(_module.bytes32ToAddress());
     }
 
@@ -103,19 +105,34 @@ contract DomainRoutingIsm is AbstractRoutingIsm, OwnableUpgradeable {
         override
         returns (IInterchainSecurityModule)
     {
-        return modules(_message.origin());
+        return module(_message.origin());
     }
 
     // ============ Internal Functions ============
 
+    /**
+     * @notice Removes the specified origin domain's ISM
+     * @param _domain The origin domain
+     */
+    function _remove(uint32 _domain) internal {
+        require(_modules.remove(_domain), _originNotFoundError(_domain));
+    }
+
+    function _originNotFoundError(uint32 _origin)
+        internal
+        pure
+        returns (string memory)
+    {
+        return string.concat("No ISM found for origin: ", _origin.toString());
+    }
+
     /**
      * @notice Sets the ISM to be used for the specified origin domain
      * @param _domain The origin domain
      * @param _module The ISM to use to verify messages
      */
     function _set(uint32 _domain, address _module) internal {
-        require(_module.isContract(), "!contract");
+        require(_module.isContract(), "ISM must be a contract");
         _modules.set(_domain, _module.addressToBytes32());
-        emit ModuleSet(_domain, _module);
     }
 }

package/contracts/isms/routing/DomainRoutingIsmFactory.sol

@@ -33,9 +33,7 @@ abstract contract AbstractDomainRoutingIsmFactory {
         return _ism;
     }
 
-    // ============ Internal Functions ============
-
-    function implementation() internal view virtual returns (address);
+    function implementation() public view virtual returns (address);
 }
 
 /**
@@ -49,7 +47,7 @@ contract DomainRoutingIsmFactory is AbstractDomainRoutingIsmFactory {
         _implementation = address(new DomainRoutingIsm());
     }
 
-    function implementation() internal view override returns (address) {
+    function implementation() public view override returns (address) {
         return _implementation;
     }
 }
@@ -65,7 +63,7 @@ contract DefaultFallbackRoutingIsmFactory is AbstractDomainRoutingIsmFactory {
         _implementation = address(new DefaultFallbackRoutingIsm(mailbox));
     }
 
-    function implementation() internal view override returns (address) {
+    function implementation() public view override returns (address) {
         return _implementation;
     }
 }

package/contracts/isms/routing/InterchainAccountIsm.sol

@@ -5,7 +5,7 @@ import {AbstractRoutingIsm} from "./AbstractRoutingIsm.sol";
 import {IMailbox} from "../../interfaces/IMailbox.sol";
 import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
 import {Message} from "../../libs/Message.sol";
-import {InterchainAccountMessage} from "../../libs/middleware/InterchainAccountMessage.sol";
+import {InterchainAccountMessage} from "../../middleware/libs/InterchainAccountMessage.sol";
 
 /**
  * @title InterchainAccountIsm

package/contracts/libs/CheckpointLib.sol

@@ -4,13 +4,11 @@ pragma solidity >=0.8.0;
 // ============ External Imports ============
 import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 
-import {LegacyCheckpointLib} from "./LegacyCheckpointLib.sol";
-
 library CheckpointLib {
     /**
      * @notice Returns the digest validators are expected to sign when signing checkpoints.
      * @param _origin The origin domain of the checkpoint.
-     * @param _originMailbox The address of the origin mailbox as bytes32.
+     * @param _originmerkleTreeHook The address of the origin merkle tree hook as bytes32.
      * @param _checkpointRoot The root of the checkpoint.
      * @param _checkpointIndex The index of the checkpoint.
      * @param _messageId The message ID of the checkpoint.
@@ -19,12 +17,12 @@ library CheckpointLib {
      */
     function digest(
         uint32 _origin,
-        bytes32 _originMailbox,
+        bytes32 _originmerkleTreeHook,
         bytes32 _checkpointRoot,
         uint32 _checkpointIndex,
         bytes32 _messageId
     ) internal pure returns (bytes32) {
-        bytes32 _domainHash = domainHash(_origin, _originMailbox);
+        bytes32 _domainHash = domainHash(_origin, _originmerkleTreeHook);
         return
             ECDSA.toEthSignedMessageHash(
                 keccak256(
@@ -42,21 +40,22 @@ library CheckpointLib {
      * @notice Returns the domain hash that validators are expected to use
      * when signing checkpoints.
      * @param _origin The origin domain of the checkpoint.
-     * @param _originMailbox The address of the origin mailbox as bytes32.
+     * @param _originmerkleTreeHook The address of the origin merkle tree as bytes32.
      * @return The domain hash.
      */
-    function domainHash(uint32 _origin, bytes32 _originMailbox)
+    function domainHash(uint32 _origin, bytes32 _originmerkleTreeHook)
         internal
         pure
         returns (bytes32)
     {
-        // Including the origin mailbox address in the signature allows the slashing
-        // protocol to enroll multiple mailboxes. Otherwise, a valid signature for
-        // mailbox A would be indistinguishable from a fraudulent signature for mailbox
-        // B.
+        // Including the origin merkle tree address in the signature allows the slashing
+        // protocol to enroll multiple trees. Otherwise, a valid signature for
+        // tree A would be indistinguishable from a fraudulent signature for tree B.
         // The slashing protocol should slash if validators sign attestations for
-        // anything other than a whitelisted mailbox.
+        // anything other than a whitelisted tree.
         return
-            keccak256(abi.encodePacked(_origin, _originMailbox, "HYPERLANE"));
+            keccak256(
+                abi.encodePacked(_origin, _originmerkleTreeHook, "HYPERLANE")
+            );
     }
 }

package/contracts/libs/Indexed.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+contract Indexed {
+    uint256 public immutable deployedBlock;
+
+    constructor() {
+        deployedBlock = block.number;
+    }
+}

package/contracts/libs/LibBit.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+/// @notice Library for bit shifting and masking
+library LibBit {
+    function setBit(uint256 _value, uint256 _index)
+        internal
+        pure
+        returns (uint256)
+    {
+        return _value | (1 << _index);
+    }
+
+    function clearBit(uint256 _value, uint256 _index)
+        internal
+        pure
+        returns (uint256)
+    {
+        return _value & ~(1 << _index);
+    }
+
+    function isBitSet(uint256 _value, uint256 _index)
+        internal
+        pure
+        returns (bool)
+    {
+        return (_value >> _index) & 1 == 1;
+    }
+}

package/contracts/libs/StaticAddressSetFactory.sol

@@ -0,0 +1,130 @@
+// 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";
+
+// ============ Internal Imports ============
+import {MetaProxy} from "./MetaProxy.sol";
+
+abstract contract StaticThresholdAddressSetFactory {
+    // ============ Immutables ============
+    address public immutable implementation;
+
+    // ============ Constructor ============
+
+    constructor() {
+        implementation = _deployImplementation();
+    }
+
+    function _deployImplementation() internal virtual returns (address);
+
+    /**
+     * @notice Deploys a StaticThresholdAddressSet contract address for the given
+     * values
+     * @dev Consider sorting addresses to ensure contract reuse
+     * @param _values An array of addresses
+     * @param _threshold The threshold value to use
+     * @return set The contract address representing this StaticThresholdAddressSet
+     */
+    function deploy(address[] calldata _values, uint8 _threshold)
+        public
+        returns (address)
+    {
+        (bytes32 _salt, bytes memory _bytecode) = _saltAndBytecode(
+            _values,
+            _threshold
+        );
+        address _set = _getAddress(_salt, _bytecode);
+        if (!Address.isContract(_set)) {
+            _set = Create2.deploy(0, _salt, _bytecode);
+        }
+        return _set;
+    }
+
+    /**
+     * @notice Returns the StaticThresholdAddressSet contract address for the given
+     * values
+     * @dev Consider sorting addresses to ensure contract reuse
+     * @param _values An array of addresses
+     * @param _threshold The threshold value to use
+     * @return set The contract address representing this StaticThresholdAddressSet
+     */
+    function getAddress(address[] calldata _values, uint8 _threshold)
+        external
+        view
+        returns (address)
+    {
+        (bytes32 _salt, bytes memory _bytecode) = _saltAndBytecode(
+            _values,
+            _threshold
+        );
+        return _getAddress(_salt, _bytecode);
+    }
+
+    /**
+     * @notice Returns the StaticThresholdAddressSet 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 StaticThresholdAddressSet
+     */
+    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 _values An array of addresses
+     * @param _threshold The threshold value to use
+     * @return _salt The salt used in Create2
+     * @return _bytecode The metaproxy bytecode used in Create2
+     */
+    function _saltAndBytecode(address[] calldata _values, uint8 _threshold)
+        internal
+        view
+        returns (bytes32, bytes memory)
+    {
+        bytes memory _metadata = abi.encode(_values, _threshold);
+        bytes memory _bytecode = MetaProxy.bytecode(implementation, _metadata);
+        bytes32 _salt = keccak256(_metadata);
+        return (_salt, _bytecode);
+    }
+}
+
+abstract contract StaticAddressSetFactory is StaticThresholdAddressSetFactory {
+    /**
+     * @notice Deploys a StaticAddressSet contract address for the given
+     * values
+     * @dev Consider sorting addresses to ensure contract reuse
+     * @param _values An array of addresses
+     * @return set The contract address representing this StaticAddressSet
+     */
+    function deploy(address[] calldata _values) external returns (address) {
+        return super.deploy(_values, uint8(_values.length));
+    }
+
+    /**
+     * @notice Returns the StaticAddressSet contract address for the given
+     * values
+     * @dev Consider sorting addresses to ensure contract reuse
+     * @param _values An array of addresses
+     * @return set The contract address representing this StaticAddressSet
+     */
+    function getAddress(address[] calldata _values)
+        external
+        view
+        returns (address)
+    {
+        (bytes32 _salt, bytes memory _bytecode) = _saltAndBytecode(
+            _values,
+            uint8(_values.length)
+        );
+        return super._getAddress(_salt, _bytecode);
+    }
+}