MessageBus restructure

contracts/messaging/ContextChainId.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.13;
+
+abstract contract ContextChainId {
+    uint256 internal immutable localChainId;
+
+    constructor() {
+        localChainId = _chainId();
+    }
+
+    function _chainId() internal view virtual returns (uint256) {
+        return block.chainid;
+    }
+}

contracts/messaging/GasFeePricing.md

@@ -0,0 +1,63 @@
+# Gas Fee Pricing for Message Bridge
+
+## Setup
+
+On every chain `MessageBusUpgradeable` and `GasFeePricingUpgradeable` are deployed. `GasFeePricing` contracts are using `MessageBus` to communicate with each other, so they are set up as the "trusted remote" for one another.
+
+For every chain we're considering following information:
+
+- `gasTokenPrice`: price of chain's gas token (ETH, AVAX, BNB, ...)
+- `gasUnitPrice`: price of a single gas unit (usually referred as chain's "gwei gas price")
+
+> Both values are supposed to reflect the latest "average" price.
+
+`GasFeePricing` contract is storing this information both for the local chain, as well as for all known remote chains. Whenever information for a **local chain** is updated on any of the `GasFeePricing` contracts, it sends messages to all the remote `GasFeePricing` contracts, so they can update it as well.
+
+This way, the information about chain's gas token/unit prices is synchronized across all chains.
+
+## Message Passing
+
+Any contract can interact with `MessageBus` to send a message to a remote chain, specifying both a gas airdrop and a gas limit on the remote chain.
+Every remote chain has a different setting for the maximum amount of gas available for the airdrop. That way, the airdrop is fully flexible, and can not be taken advantage of by the bad actors. This value (for every remote chain) is also synchronized across all the chains.
+
+## Fee calculation
+
+### Basic calculation
+
+The fee is split into two parts. Both parts are quoted in the local gas token.
+
+- Fee for providing gas airdrop on a remote chain. Assuming dropping `gasDrop` worth of the remote gas token.
+
+```go
+feeGasDrop = gasDrop * remoteGasTokenPrice / localGasTokenPrice
+```
+
+- Fee for executing message on a remote chain. Assuming providing `gasLimit` gas units on the remote chain.
+
+```go
+feeGasUsage = max(
+  minRemoteFeeUsd / localGasTokenPrice,
+  gasLimit * remoteGasUnitPrice * remoteGasTokenPrice / localGasTokenPrice
+)
+```
+
+> `minRemoteFeeUsd` is the minimum fee (in $), taken for the gas usage on a remote chain. It is specific to the remote chain, and does not take a local chain into account. `minRemoteFeeUsd` (for every remote chain) is also synchronized across all the chains.
+
+Note that both fees will express the _exact expected costs_ of delivering the message.
+
+### Monetizing the messaging.
+
+Introduce markup. Markup is a value of `0%`, or higher. Markup means how much more is `MessageBus` charging, compared to [expected costs](#basic-calculation).
+
+Markups are separate for the gas airdrop, and the gas usage. This means that the final fee formula is
+
+```go
+fee = (100% + markupGasDrop) * feeGasDrop + (100% + markupGasUsage) * feeGasUsage
+```
+
+- Markups are specific to a "local chain - remote chain" pair.
+- `markupGasUsage` should be set higher for the remote chains, known to have gas spikes (Ethereum, Fantom).
+- `markupGasDrop` can be set to 0, when both local and remote chain are using the same gas token.
+  > Gas airdrop amount is limited, so it's not possible to bridge gas by sending an empty message with a huge airdrop.
+- `markupGasDrop <= markupGasUsage` makes sense, as the price ratio for the gas usage is more volatile, since it's taking into account the gas unit price as well.
+- `markupGasDrop` and `markupGasUsage` should be set higher for such a "local chain - remote chain" pair, where gas local token price is less correlated with the remote gas token price.

contracts/messaging/HarmonyMessageBus.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.13;
+
+import "./MessageBus.sol";
+
+contract HarmonyMessageBus is MessageBus {
+    uint256 private constant CHAIN_ID = 1666600000;
+
+    constructor(IAuthVerifier _verifier, IMessageExecutor _executor) MessageBus(_verifier, _executor) {
+        this;
+    }
+
+    function _chainId() internal pure override returns (uint256) {
+        return CHAIN_ID;
+    }
+}

contracts/messaging/MessageBus.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.13;
+
+import "./MessageBusSender.sol";
+import "./MessageBusReceiver.sol";
+
+contract MessageBus is MessageBusSender, MessageBusReceiver {
+    constructor(IAuthVerifier _verifier, IMessageExecutor _executor) {
+        verifier = _verifier;
+        executor = _executor;
+    }
+
+    /*╔══════════════════════════════════════════════════════════════════════╗*\
+    ▏*║                         UPDATING: ONLY OWNER                         ║*▕
+    \*╚══════════════════════════════════════════════════════════════════════╝*/
+
+    function updateAuthVerifier(IAuthVerifier _verifier) external onlyOwner {
+        require(address(_verifier) != address(0), "Cannot set to 0");
+        verifier = _verifier;
+    }
+
+    function updateMessageExecutor(IMessageExecutor _executor) external onlyOwner {
+        require(address(_executor) != address(0), "Cannot set to 0");
+        executor = _executor;
+    }
+
+    // TODO: how useful is that, if contract is immutable?
+    function updateMessageStatus(bytes32 _messageId, TxStatus _status) external onlyOwner {
+        executedMessages[_messageId] = _status;
+    }
+
+    /*╔══════════════════════════════════════════════════════════════════════╗*\
+    ▏*║                               PAUSABLE                               ║*▕
+    \*╚══════════════════════════════════════════════════════════════════════╝*/
+
+    function pause() external onlyOwner {
+        _pause();
+    }
+
+    function unpause() external onlyOwner {
+        _unpause();
+    }
+}

contracts/messaging/MessageBusBase.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.13;
+
+import "./interfaces/IAuthVerifier.sol";
+import "./interfaces/IMessageExecutor.sol";
+
+import "@openzeppelin/contracts-4.5.0/access/Ownable.sol";
+import "@openzeppelin/contracts-4.5.0/security/Pausable.sol";
+
+contract MessageBusBase is Ownable, Pausable {
+    /// @dev Contract used for executing received messages,
+    /// and for calculating a fee for sending a message
+    IMessageExecutor public executor;
+
+    /// @dev Contract used for authenticating validator address
+    IAuthVerifier public verifier;
+}

contracts/messaging/MessageBusReceiver.sol

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.13;
+
+import "./MessageBusBase.sol";
+
+contract MessageBusReceiver is MessageBusBase {
+    enum TxStatus {
+        Null,
+        Success,
+        Fail
+    }
+
+    event Executed(
+        bytes32 indexed messageId,
+        TxStatus status,
+        address indexed dstAddress,
+        uint256 indexed srcChainId,
+        uint256 srcNonce,
+        address gasDropRecipient,
+        uint256 gasDropAmount
+    );
+
+    event CallReverted(string reason);
+
+    /// @dev Status of all executed messages
+    mapping(bytes32 => TxStatus) public executedMessages;
+
+    /*╔══════════════════════════════════════════════════════════════════════╗*\
+    ▏*║                           MESSAGING LOGIC                            ║*▕
+    \*╚══════════════════════════════════════════════════════════════════════╝*/
+
+    /**
+     * @notice Relayer executes messages through an authenticated method to the destination receiver
+     * based on the originating transaction on source chain
+     * @param _srcChainId Originating chain ID - typically a standard EVM chain ID,
+     * but may refer to a Synapse-specific chain ID on nonEVM chains
+     * @param _srcAddress Originating bytes32 address of the message sender on the srcChain
+     * @param _dstAddress Destination address that the arbitrary message will be passed to
+     * @param _message Arbitrary message payload to pass to the destination chain receiver
+     * @param _srcNonce Nonce of the message on the originating chain
+     * @param _options Versioned struct used to instruct message executor on how to proceed with gas limits,
+     * gas airdrop, etc
+     * @param _messageId Unique message identifier, computed when sending message on originating chain
+     * @param _proof Byte string containing proof that message was sent from originating chain
+     */
+    function executeMessage(
+        uint256 _srcChainId,
+        bytes32 _srcAddress,
+        address _dstAddress,
+        bytes calldata _message,
+        uint256 _srcNonce,
+        bytes calldata _options,
+        bytes32 _messageId,
+        bytes calldata _proof
+    ) external whenNotPaused {
+        /// @dev Executing messages is disabled, when {MessageBus} is paused.
+
+        // In order to guarantee that an individual message is only executed once, a messageId is passed
+        // enforce that this message ID hasn't already been tried ever
+        require(executedMessages[_messageId] == TxStatus.Null, "Message already executed");
+        // Authenticate executeMessage, will revert if not authenticated
+        verifier.msgAuth(abi.encode(msg.sender, _messageId, _proof));
+
+        TxStatus status;
+        address gasDropRecipient;
+        uint256 gasDropAmount;
+        try executor.executeMessage(_srcChainId, _srcAddress, _dstAddress, _message, _options) returns (
+            address _gasDropRecipient,
+            uint256 _gasDropAmount
+        ) {
+            // Assuming success state if no revert
+            status = TxStatus.Success;
+            gasDropRecipient = _gasDropRecipient;
+            gasDropAmount = _gasDropAmount;
+        } catch (bytes memory reason) {
+            // call hard reverted & failed
+            emit CallReverted(_getRevertMsg(reason));
+            status = TxStatus.Fail;
+        }
+
+        executedMessages[_messageId] = status;
+        emit Executed(_messageId, status, _dstAddress, _srcChainId, _srcNonce, gasDropRecipient, gasDropAmount);
+    }
+
+    /*╔══════════════════════════════════════════════════════════════════════╗*\
+    ▏*║                           INTERNAL HELPERS                           ║*▕
+    \*╚══════════════════════════════════════════════════════════════════════╝*/
+
+    // https://ethereum.stackexchange.com/a/83577
+    // https://github.com/Uniswap/v3-periphery/blob/v1.0.0/contracts/base/Multicall.sol
+    function _getRevertMsg(bytes memory _returnData) internal pure returns (string memory) {
+        // If the _res length is less than 68, then the transaction failed silently (without a revert message)
+        if (_returnData.length < 68) return "Transaction reverted silently";
+        // solhint-disable-next-line
+        assembly {
+            // Slice the sighash.
+            _returnData := add(_returnData, 0x04)
+        }
+        return abi.decode(_returnData, (string)); // All that remains is the revert string
+    }
+}