feat: v0.2.0

packages/evm/contracts/Hashi.sol

@@ -34,61 +34,97 @@
 pragma solidity ^0.8.17;
 
 import { IOracleAdapter } from "./interfaces/IOracleAdapter.sol";
+import { IHashi } from "./interfaces/IHashi.sol";
 
-contract Hashi {
-    error NoOracleAdaptersGiven(address emitter);
-    error OracleDidNotReport(address emitter, IOracleAdapter oracleAdapter);
-    error OraclesDisagree(address emitter, IOracleAdapter oracleOne, IOracleAdapter oracleTwo);
-
-    /// @dev Returns the hash reported by a given oracle for a given ID.
-    /// @param oracleAdapter Address of the oracle adapter to query.
-    /// @param domain Id of the domain to query.
-    /// @param id ID for which to return a hash.
-    /// @return hash Hash reported by the given oracle adapter for the given ID number.
-    function getHashFromOracle(
-        IOracleAdapter oracleAdapter,
+contract Hashi is IHashi {
+    /// @inheritdoc IHashi
+    function checkHashWithThresholdFromOracles(
         uint256 domain,
-        uint256 id
-    ) public view returns (bytes32 hash) {
-        hash = oracleAdapter.getHashFromOracle(domain, id);
+        uint256 id,
+        uint256 threshold,
+        IOracleAdapter[] calldata oracleAdapters
+    ) external view returns (bool) {
+        if (oracleAdapters.length == 0) revert NoOracleAdaptersGiven();
+        if (threshold > oracleAdapters.length || threshold == 0)
+            revert InvalidThreshold(threshold, oracleAdapters.length);
+
+        bytes32[] memory hashes = new bytes32[](oracleAdapters.length);
+        for (uint256 i = 0; i < oracleAdapters.length; ) {
+            try oracleAdapters[i].getHashFromOracle(domain, id) returns (bytes32 hash) {
+                hashes[i] = hash;
+            } catch {}
+            unchecked {
+                ++i;
+            }
+        }
+
+        for (uint256 i = 0; i < hashes.length; ) {
+            bytes32 baseHash = hashes[i];
+            if (baseHash == bytes32(0)) {
+                unchecked {
+                    ++i;
+                }
+                continue;
+            }
+
+            uint256 num = 0;
+            for (uint256 j = 0; j < hashes.length; ) {
+                if (baseHash == hashes[j]) {
+                    unchecked {
+                        ++num;
+                    }
+                    if (num == threshold) return true;
+                }
+                unchecked {
+                    ++j;
+                }
+            }
+
+            unchecked {
+                ++i;
+            }
+        }
+        return false;
     }
 
-    /// @dev Returns the hash for a given ID reported by a given set of oracles.
-    /// @param oracleAdapters Array of address for the oracle adapters to query.
-    /// @param domain ID of the domain to query.
-    /// @param id ID for which to return hashs.
-    /// @return hashes Array of hash reported by the given oracle adapters for the given ID.
+    /// @inheritdoc IHashi
+    function getHashFromOracle(uint256 domain, uint256 id, IOracleAdapter oracleAdapter) public view returns (bytes32) {
+        return oracleAdapter.getHashFromOracle(domain, id);
+    }
+
+    /// @inheritdoc IHashi
     function getHashesFromOracles(
-        IOracleAdapter[] memory oracleAdapters,
         uint256 domain,
-        uint256 id
+        uint256 id,
+        IOracleAdapter[] calldata oracleAdapters
     ) public view returns (bytes32[] memory) {
-        if (oracleAdapters.length == 0) revert NoOracleAdaptersGiven(address(this));
+        if (oracleAdapters.length == 0) revert NoOracleAdaptersGiven();
         bytes32[] memory hashes = new bytes32[](oracleAdapters.length);
-        for (uint256 i = 0; i < oracleAdapters.length; i++) {
-            hashes[i] = getHashFromOracle(oracleAdapters[i], domain, id);
+        for (uint256 i = 0; i < oracleAdapters.length; ) {
+            hashes[i] = getHashFromOracle(domain, id, oracleAdapters[i]);
+            unchecked {
+                ++i;
+            }
         }
         return hashes;
     }
 
-    /// @dev Returns the hash unanimously agreed upon by a given set of oracles.
-    /// @param domain ID of the domain to query.
-    /// @param id ID for which to return hash.
-    /// @param oracleAdapters Array of address for the oracle adapters to query.
-    /// @return hash Hash agreed on by the given set of oracle adapters.
-    /// @notice MUST revert if oracles disagree on the hash or if an oracle does not report.
+    /// @inheritdoc IHashi
     function getHash(
         uint256 domain,
         uint256 id,
-        IOracleAdapter[] memory oracleAdapters
-    ) public view returns (bytes32 hash) {
-        if (oracleAdapters.length == 0) revert NoOracleAdaptersGiven(address(this));
-        bytes32[] memory hashes = getHashesFromOracles(oracleAdapters, domain, id);
+        IOracleAdapter[] calldata oracleAdapters
+    ) external view returns (bytes32 hash) {
+        if (oracleAdapters.length == 0) revert NoOracleAdaptersGiven();
+        bytes32[] memory hashes = getHashesFromOracles(domain, id, oracleAdapters);
         hash = hashes[0];
-        if (hash == bytes32(0)) revert OracleDidNotReport(address(this), oracleAdapters[0]);
-        for (uint256 i = 1; i < hashes.length; i++) {
-            if (hashes[i] == bytes32(0)) revert OracleDidNotReport(address(this), oracleAdapters[i]);
-            if (hash != hashes[i]) revert OraclesDisagree(address(this), oracleAdapters[i - 1], oracleAdapters[i]);
+        if (hash == bytes32(0)) revert OracleDidNotReport(oracleAdapters[0]);
+        for (uint256 i = 1; i < hashes.length; ) {
+            if (hashes[i] == bytes32(0)) revert OracleDidNotReport(oracleAdapters[i]);
+            if (hash != hashes[i]) revert OraclesDisagree(oracleAdapters[i - 1], oracleAdapters[i]);
+            unchecked {
+                ++i;
+            }
         }
     }
 }

packages/evm/contracts/Yaho.sol

@@ -1,72 +1,203 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 pragma solidity ^0.8.17;
 
-import { IMessageRelay } from "./interfaces/IMessageRelay.sol";
-import { Message } from "./interfaces/IMessageDispatcher.sol";
-import { IYaho } from "./interfaces/IYaho.sol";
+import { MessageIdCalculator } from "./utils/MessageIdCalculator.sol";
 import { MessageHashCalculator } from "./utils/MessageHashCalculator.sol";
+import { IYaho } from "./interfaces/IYaho.sol";
+import { IReporter } from "./interfaces/IReporter.sol";
+import { Message } from "./interfaces/IMessage.sol";
+import { IOracleAdapter } from "./interfaces/IOracleAdapter.sol";
 
-contract Yaho is IYaho, MessageHashCalculator {
-    mapping(uint256 => bytes32) public hashes;
-    uint256 private count;
+contract Yaho is IYaho, MessageIdCalculator, MessageHashCalculator {
+    mapping(uint256 => bytes32) private _pendingMessageHashes;
 
-    /// @dev Dispatches a batch of messages, putting their into storage and emitting their contents as an event.
-    /// @param messages An array of Messages to be dispatched.
-    /// @return messageIds An array of message IDs corresponding to the dispatched messages.
-    function dispatchMessages(Message[] memory messages) public payable returns (bytes32[] memory) {
-        if (messages.length == 0) revert NoMessagesGiven(address(this));
-        bytes32[] memory messageIds = new bytes32[](messages.length);
-        for (uint256 i = 0; i < messages.length; i++) {
-            uint256 id = count;
-            hashes[id] = calculateHash(block.chainid, id, address(this), msg.sender, messages[i]);
-            messageIds[i] = bytes32(id);
-            emit MessageDispatched(bytes32(id), msg.sender, messages[i].toChainId, messages[i].to, messages[i].data);
-            count++;
+    /// @inheritdoc IYaho
+    function dispatchMessage(
+        uint256 toChainId,
+        uint256 threshold,
+        address receiver,
+        bytes calldata data,
+        IReporter[] calldata reporters,
+        IOracleAdapter[] calldata adapters
+    ) external returns (uint256) {
+        _checkReportersAndAdapters(threshold, reporters, adapters);
+        (uint256 messageId, ) = _dispatchMessage(toChainId, threshold, receiver, data, reporters, adapters);
+        return messageId;
+    }
+
+    /// @inheritdoc IYaho
+    function dispatchMessageToAdapters(
+        uint256 toChainId,
+        uint256 threshold,
+        address receiver,
+        bytes calldata data,
+        IReporter[] calldata reporters,
+        IOracleAdapter[] calldata adapters
+    ) external payable returns (uint256, bytes32[] memory) {
+        _checkReportersAndAdapters(threshold, reporters, adapters);
+        (uint256 messageId, bytes32 messageHash) = _dispatchMessage(
+            toChainId,
+            threshold,
+            receiver,
+            data,
+            reporters,
+            adapters
+        );
+        bytes32[] memory reportersReceipts = _dispatchMessageToAdapters(
+            toChainId,
+            messageId,
+            messageHash,
+            reporters,
+            adapters
+        );
+        return (messageId, reportersReceipts);
+    }
+
+    /// @inheritdoc IYaho
+    function dispatchMessagesToAdapters(
+        uint256 toChainId,
+        uint256[] calldata thresholds,
+        address[] calldata receivers,
+        bytes[] calldata data,
+        IReporter[] calldata reporters,
+        IOracleAdapter[] calldata adapters
+    ) external payable returns (uint256[] memory, bytes32[] memory) {
+        if (thresholds.length != receivers.length) revert UnequalArrayLengths(thresholds.length, receivers.length);
+        if (thresholds.length != data.length) revert UnequalArrayLengths(thresholds.length, data.length);
+
+        uint256[] memory messageIds = new uint256[](receivers.length);
+        bytes32[] memory messageHashes = new bytes32[](receivers.length);
+        for (uint256 i = 0; i < receivers.length; ) {
+            _checkReportersAndAdapters(thresholds[i], reporters, adapters);
+            (messageIds[i], messageHashes[i]) = _dispatchMessage(
+                toChainId,
+                thresholds[i],
+                receivers[i],
+                data[i],
+                reporters,
+                adapters
+            );
+            unchecked {
+                ++i;
+            }
         }
-        return messageIds;
+
+        bytes32[] memory reportersReceipts = new bytes32[](reporters.length);
+        reportersReceipts = _dispatchMessagesToAdapters(toChainId, messageIds, messageHashes, reporters, adapters);
+        return (messageIds, reportersReceipts);
     }
 
-    /// @dev Relays hashes of the given messageIds to the given adapters.
-    /// @param messageIds Array of IDs of the message hashes to relay to the given adapters.
-    /// @param adapters Array of relay adapter addresses to which hashes should be relayed.
-    /// @param destinationAdapters Array of oracle adapter addresses to receive hashes.
-    /// @return adapterReciepts Reciepts from each of the relay adapters.
-    function relayMessagesToAdapters(
-        uint256[] memory messageIds,
-        address[] memory adapters,
-        address[] memory destinationAdapters
-    ) external payable returns (bytes32[] memory) {
-        if (messageIds.length == 0) revert NoMessageIdsGiven(address(this));
-        if (adapters.length == 0) revert NoAdaptersGiven(address(this));
-        if (adapters.length != destinationAdapters.length) revert UnequalArrayLengths(address(this));
-        bytes32[] memory adapterReciepts = new bytes32[](adapters.length);
-        for (uint256 i = 0; i < adapters.length; i++) {
-            adapterReciepts[i] = IMessageRelay(adapters[i]).relayMessages(messageIds, destinationAdapters[i]);
+    /// @inheritdoc IYaho
+    function getPendingMessageHash(uint256 messageId) external view returns (bytes32) {
+        return _pendingMessageHashes[messageId];
+    }
+
+    /// @inheritdoc IYaho
+    function relayMessagesToAdapters(Message[] calldata messages) external payable returns (bytes32[] memory) {
+        if (messages.length == 0) revert NoMessagesGiven();
+
+        bytes32 expectedParams = keccak256(
+            abi.encode(messages[0].toChainId, messages[0].reporters, messages[0].adapters)
+        );
+
+        bytes32[] memory messageHashes = new bytes32[](messages.length);
+        uint256[] memory messageIds = new uint256[](messages.length);
+        for (uint256 i = 0; i < messages.length; i++) {
+            Message memory message = messages[i];
+            if (
+                i > 0 && expectedParams != keccak256(abi.encode(message.toChainId, message.reporters, message.adapters))
+            ) revert InvalidMessage(message);
+            uint256 messageId = calculateMessageId(block.chainid, address(this), calculateMessageHash(message));
+            bytes32 messageHash = _pendingMessageHashes[messageId];
+            if (messageHash == bytes32(0)) revert MessageHashNotFound(messageId);
+            messageHashes[i] = messageHash;
+            messageIds[i] = messageId;
         }
-        return adapterReciepts;
+
+        return
+            _dispatchMessagesToAdapters(
+                messages[0].toChainId,
+                messageIds,
+                messageHashes,
+                messages[0].reporters,
+                messages[0].adapters
+            );
     }
 
-    /// @dev Dispatches an array of messages and relays their hashes to an array of relay adapters.
-    /// @param messages An array of Messages to be dispatched.
-    /// @param adapters Array of relay adapter addresses to which hashes should be relayed.
-    /// @param destinationAdapters Array of oracle adapter addresses to receive hashes.
-    /// @return messageIds An array of message IDs corresponding to the dispatched messages.
-    /// @return adapterReciepts Reciepts from each of the relay adapters.
-    function dispatchMessagesToAdapters(
-        Message[] memory messages,
-        address[] memory adapters,
-        address[] memory destinationAdapters
-    ) external payable returns (bytes32[] memory messageIds, bytes32[] memory) {
-        if (adapters.length == 0) revert NoAdaptersGiven(address(this));
-        messageIds = dispatchMessages(messages);
-        uint256[] memory uintIds = new uint256[](messageIds.length);
-        for (uint256 i = 0; i < messageIds.length; i++) {
-            uintIds[i] = uint256(messageIds[i]);
+    function _checkReportersAndAdapters(
+        uint256 threshold,
+        IReporter[] calldata reporters,
+        IOracleAdapter[] calldata adapters
+    ) internal pure {
+        if (reporters.length == 0) revert NoReportersGiven();
+        if (adapters.length == 0) revert NoAdaptersGiven();
+        if (reporters.length != adapters.length) revert UnequalArrayLengths(reporters.length, adapters.length);
+        if (threshold > reporters.length || threshold == 0) revert InvalidThreshold(threshold, reporters.length);
+    }
+
+    function _dispatchMessage(
+        uint256 toChainId,
+        uint256 threshold,
+        address receiver,
+        bytes calldata data,
+        IReporter[] calldata reporters,
+        IOracleAdapter[] calldata adapters
+    ) internal returns (uint256, bytes32) {
+        address sender = msg.sender;
+        Message memory message = Message(
+            keccak256(abi.encode(blockhash(block.number - 1), gasleft())),
+            toChainId,
+            threshold,
+            sender,
+            receiver,
+            data,
+            reporters,
+            adapters
+        );
+        bytes32 messageHash = calculateMessageHash(message);
+        uint256 messageId = calculateMessageId(block.chainid, address(this), messageHash);
+        _pendingMessageHashes[messageId] = messageHash;
+        emit MessageDispatched(messageId, message);
+        return (messageId, messageHash);
+    }
+
+    function _dispatchMessageToAdapters(
+        uint256 toChainId,
+        uint256 messageId,
+        bytes32 messageHash,
+        IReporter[] memory reporters,
+        IOracleAdapter[] memory adapters
+    ) internal returns (bytes32[] memory) {
+        uint256[] memory messageIds = new uint256[](1);
+        bytes32[] memory messageHashes = new bytes32[](1);
+        messageIds[0] = messageId;
+        messageHashes[0] = messageHash;
+        return _dispatchMessagesToAdapters(toChainId, messageIds, messageHashes, reporters, adapters);
+    }
+
+    function _dispatchMessagesToAdapters(
+        uint256 toChainId,
+        uint256[] memory messageIds,
+        bytes32[] memory messageHashes,
+        IReporter[] memory reporters,
+        IOracleAdapter[] memory adapters
+    ) internal returns (bytes32[] memory) {
+        bytes32[] memory reportersReceipts = new bytes32[](reporters.length);
+
+        for (uint256 i = 0; i < reporters.length; ) {
+            reportersReceipts[i] = reporters[i].dispatchMessages(toChainId, adapters[i], messageIds, messageHashes);
+            unchecked {
+                ++i;
+            }
         }
-        bytes32[] memory adapterReciepts = new bytes32[](adapters.length);
-        for (uint256 i = 0; i < adapters.length; i++) {
-            adapterReciepts[i] = IMessageRelay(adapters[i]).relayMessages(uintIds, destinationAdapters[i]);
+
+        for (uint256 j = 0; j < messageIds.length; ) {
+            delete _pendingMessageHashes[messageIds[j]];
+            unchecked {
+                ++j;
+            }
         }
-        return (messageIds, adapterReciepts);
+
+        return reportersReceipts;
     }
 }