@hyperlane-xyz/core 0.5.2 → 0.5.4-0

package/contracts/libs/MultisigIsmMetadata.sol

@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+/**
+ * Format of metadata:
+ * [   0:  32] Merkle root
+ * [  32:  64] Root index
+ * [  64:  96] Origin mailbox address
+ * [  96:1120] Merkle proof
+ * [1120:1152] Threshold
+ * [1152:????] Validator signatures, 65 bytes each, length == Threshold
+ * [????:????] Addresses of the entire validator set, left padded to bytes32
+ */
+library MultisigIsmMetadata {
+    uint256 private constant MERKLE_ROOT_OFFSET = 0;
+    uint256 private constant MERKLE_INDEX_OFFSET = 32;
+    uint256 private constant ORIGIN_MAILBOX_OFFSET = 64;
+    uint256 private constant MERKLE_PROOF_OFFSET = 96;
+    uint256 private constant THRESHOLD_OFFSET = 1120;
+    uint256 private constant SIGNATURES_OFFSET = 1152;
+    uint256 private constant SIGNATURE_LENGTH = 65;
+
+    /**
+     * @notice Returns the merkle root of the signed checkpoint.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return Merkle root of the signed checkpoint
+     */
+    function root(bytes calldata _metadata) internal pure returns (bytes32) {
+        return bytes32(_metadata[MERKLE_ROOT_OFFSET:MERKLE_INDEX_OFFSET]);
+    }
+
+    /**
+     * @notice Returns the index of the signed checkpoint.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return Index of the signed checkpoint
+     */
+    function index(bytes calldata _metadata) internal pure returns (uint256) {
+        return
+            uint256(
+                bytes32(_metadata[MERKLE_INDEX_OFFSET:ORIGIN_MAILBOX_OFFSET])
+            );
+    }
+
+    /**
+     * @notice Returns the origin mailbox of the signed checkpoint as bytes32.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return Origin mailbox of the signed checkpoint as bytes32
+     */
+    function originMailbox(bytes calldata _metadata)
+        internal
+        pure
+        returns (bytes32)
+    {
+        return bytes32(_metadata[ORIGIN_MAILBOX_OFFSET:MERKLE_PROOF_OFFSET]);
+    }
+
+    /**
+     * @notice Returns the merkle proof branch of the message.
+     * @dev This appears to be more gas efficient than returning a calldata
+     * slice and using that.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return Merkle proof branch of the message.
+     */
+    function proof(bytes calldata _metadata)
+        internal
+        pure
+        returns (bytes32[32] memory)
+    {
+        return
+            abi.decode(
+                _metadata[MERKLE_PROOF_OFFSET:THRESHOLD_OFFSET],
+                (bytes32[32])
+            );
+    }
+
+    /**
+     * @notice Returns the number of required signatures. Verified against
+     * the commitment stored in the module.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return The number of required signatures.
+     */
+    function threshold(bytes calldata _metadata)
+        internal
+        pure
+        returns (uint256)
+    {
+        return uint256(bytes32(_metadata[THRESHOLD_OFFSET:SIGNATURES_OFFSET]));
+    }
+
+    /**
+     * @notice Returns the validator ECDSA signature at `_index`.
+     * @dev Assumes signatures are sorted by validator
+     * @dev Assumes `_metadata` encodes `threshold` signatures.
+     * @dev Assumes `_index` is less than `threshold`
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @param _index The index of the signature to return.
+     * @return The validator ECDSA signature at `_index`.
+     */
+    function signatureAt(bytes calldata _metadata, uint256 _index)
+        internal
+        pure
+        returns (bytes calldata)
+    {
+        uint256 _start = SIGNATURES_OFFSET + (_index * SIGNATURE_LENGTH);
+        uint256 _end = _start + SIGNATURE_LENGTH;
+        return _metadata[_start:_end];
+    }
+
+    /**
+     * @notice Returns the validator address at `_index`.
+     * @dev Assumes `_index` is less than the number of validators
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @param _index The index of the validator to return.
+     * @return The validator address at `_index`.
+     */
+    function validatorAt(bytes calldata _metadata, uint256 _index)
+        internal
+        pure
+        returns (address)
+    {
+        // Validator addresses are left padded to bytes32 in order to match
+        // abi.encodePacked(address[]).
+        uint256 _start = _validatorsOffset(_metadata) + (_index * 32) + 12;
+        uint256 _end = _start + 20;
+        return address(bytes20(_metadata[_start:_end]));
+    }
+
+    /**
+     * @notice Returns the validator set encoded as bytes. Verified against the
+     * commitment stored in the module.
+     * @dev Validator addresses are encoded as tightly packed array of bytes32,
+     * sorted to match the enumerable set stored by the module.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return The validator set encoded as bytes.
+     */
+    function validators(bytes calldata _metadata)
+        internal
+        pure
+        returns (bytes calldata)
+    {
+        return _metadata[_validatorsOffset(_metadata):];
+    }
+
+    /**
+     * @notice Returns the size of the validator set encoded in the metadata
+     * @dev Validator addresses are encoded as tightly packed array of bytes32,
+     * sorted to match the enumerable set stored by the module.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return The size of the validator set encoded in the metadata
+     */
+    function commitment(bytes calldata _metadata)
+        internal
+        pure
+        returns (uint256)
+    {
+        return (_metadata.length - _validatorsOffset(_metadata)) / 32;
+    }
+
+    /**
+     * @notice Returns the size of the validator set encoded in the metadata
+     * @dev Validator addresses are encoded as tightly packed array of bytes32,
+     * sorted to match the enumerable set stored by the module.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return The size of the validator set encoded in the metadata
+     */
+    function validatorCount(bytes calldata _metadata)
+        internal
+        pure
+        returns (uint256)
+    {
+        return (_metadata.length - _validatorsOffset(_metadata)) / 32;
+    }
+
+    /**
+     * @notice Returns the offset in bytes of the list of validators within
+     * `_metadata`.
+     * @param _metadata ABI encoded Multisig ISM metadata.
+     * @return The index at which the list of validators starts
+     */
+    function _validatorsOffset(bytes calldata _metadata)
+        private
+        pure
+        returns (uint256)
+    {
+        return SIGNATURES_OFFSET + (threshold(_metadata) * SIGNATURE_LENGTH);
+    }
+}

package/contracts/middleware/InterchainAccountRouter.sol

@@ -1,10 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.13;
 
+// ============ Internal Imports ============
 import {OwnableMulticall, Call} from "../OwnableMulticall.sol";
+import {Router} from "../Router.sol";
+import {IInterchainAccountRouter} from "../../interfaces/IInterchainAccountRouter.sol";
 
 // ============ External Imports ============
-import {Router} from "../Router.sol";
 import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
 import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
@@ -13,7 +15,7 @@ import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Ini
  * @title The Hello World App
  * @dev You can use this simple app as a starting point for your own application.
  */
-contract InterchainAccountRouter is Router {
+contract InterchainAccountRouter is Router, IInterchainAccountRouter {
     bytes constant bytecode = type(OwnableMulticall).creationCode;
     bytes32 constant bytecodeHash = bytes32(keccak256(bytecode));
 
@@ -25,21 +27,22 @@ contract InterchainAccountRouter is Router {
 
     function initialize(
         address _owner,
-        address _abacusConnectionManager,
+        address _mailbox,
         address _interchainGasPaymaster
     ) public initializer {
         // Transfer ownership of the contract to deployer
         _transferOwnership(_owner);
-        // Set the addresses for the ACM and IGP
+        // Set the addresses for the Mailbox and IGP
         // Alternatively, this could be done later in an initialize method
-        _setAbacusConnectionManager(_abacusConnectionManager);
+        _setMailbox(_mailbox);
         _setInterchainGasPaymaster(_interchainGasPaymaster);
     }
 
     function dispatch(uint32 _destinationDomain, Call[] calldata calls)
         external
+        returns (bytes32)
     {
-        _dispatch(_destinationDomain, abi.encode(msg.sender, calls));
+        return _dispatch(_destinationDomain, abi.encode(msg.sender, calls));
     }
 
     function getInterchainAccount(uint32 _origin, address _sender)

package/contracts/middleware/InterchainQueryRouter.sol

@@ -1,15 +1,21 @@
 // SPDX-License-Identifier: Apache-2.0
 pragma solidity ^0.8.13;
 
+// ============ Internal Imports ============
 import {OwnableMulticall, Call} from "../OwnableMulticall.sol";
+import {Router} from "../Router.sol";
+import {IInterchainQueryRouter} from "../../interfaces/IInterchainQueryRouter.sol";
 
 // ============ External Imports ============
-import {Router} from "../Router.sol";
 import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
 import {Address} from "@openzeppelin/contracts/utils/Address.sol";
 import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
-contract InterchainQueryRouter is Router, OwnableMulticall {
+contract InterchainQueryRouter is
+    Router,
+    OwnableMulticall,
+    IInterchainQueryRouter
+{
     enum Action {
         DISPATCH,
         RESOLVE
@@ -27,14 +33,14 @@ contract InterchainQueryRouter is Router, OwnableMulticall {
 
     function initialize(
         address _owner,
-        address _abacusConnectionManager,
+        address _mailbox,
         address _interchainGasPaymaster
     ) public initializer {
         // Transfer ownership of the contract to deployer
         _transferOwnership(_owner);
-        // Set the addresses for the ACM and IGP
+        // Set the addresses for the Mailbox and IGP
         // Alternatively, this could be done later in an initialize method
-        _setAbacusConnectionManager(_abacusConnectionManager);
+        _setMailbox(_mailbox);
         _setInterchainGasPaymaster(_interchainGasPaymaster);
     }
 
@@ -47,13 +53,13 @@ contract InterchainQueryRouter is Router, OwnableMulticall {
         uint32 _destinationDomain,
         Call calldata call,
         bytes calldata callback
-    ) external {
+    ) external returns (bytes32 messageId) {
         // TODO: fix this ugly arrayification
         Call[] memory calls = new Call[](1);
         calls[0] = call;
         bytes[] memory callbacks = new bytes[](1);
         callbacks[0] = callback;
-        query(_destinationDomain, calls, callbacks);
+        messageId = query(_destinationDomain, calls, callbacks);
     }
 
     /**
@@ -65,12 +71,12 @@ contract InterchainQueryRouter is Router, OwnableMulticall {
         uint32 _destinationDomain,
         Call[] memory calls,
         bytes[] memory callbacks
-    ) public {
+    ) public returns (bytes32 messageId) {
         require(
             calls.length == callbacks.length,
             "InterchainQueryRouter: calls and callbacks must be same length"
         );
-        _dispatch(
+        messageId = _dispatch(
             _destinationDomain,
             abi.encode(Action.DISPATCH, msg.sender, calls, callbacks)
         );

package/contracts/middleware/liquidity-layer/LiquidityLayerRouter.sol

@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+import {Router} from "../../Router.sol";
+
+import {IMessageRecipient} from "../../../interfaces/IMessageRecipient.sol";
+import {ICircleBridge} from "./interfaces/circle/ICircleBridge.sol";
+import {ICircleMessageTransmitter} from "./interfaces/circle/ICircleMessageTransmitter.sol";
+import {ILiquidityLayerAdapter} from "./interfaces/ILiquidityLayerAdapter.sol";
+import {ILiquidityLayerMessageRecipient} from "./interfaces/ILiquidityLayerMessageRecipient.sol";
+
+import {TypeCasts} from "../../libs/TypeCasts.sol";
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+contract LiquidityLayerRouter is Router {
+    // Token bridge => adapter address
+    mapping(string => address) public liquidityLayerAdapters;
+
+    event LiquidityLayerAdapterSet(string indexed bridge, address adapter);
+
+    function initialize(
+        address _owner,
+        address _mailbox,
+        address _interchainGasPaymaster
+    ) public initializer {
+        // Transfer ownership of the contract to deployer
+        _transferOwnership(_owner);
+        // Alternatively, this could be done later in an initialize method
+        _setMailbox(_mailbox);
+        _setInterchainGasPaymaster(_interchainGasPaymaster);
+    }
+
+    function dispatchWithTokens(
+        uint32 _destinationDomain,
+        bytes32 _recipientAddress,
+        bytes calldata _messageBody,
+        address _token,
+        uint256 _amount,
+        string calldata _bridge
+    ) external payable {
+        ILiquidityLayerAdapter _adapter = _getAdapter(_bridge);
+
+        // Transfer the tokens to the adapter
+        // TODO: use safeTransferFrom
+        // TODO: Are there scenarios where a transferFrom fails and it doesn't revert?
+        require(
+            IERC20(_token).transferFrom(msg.sender, address(_adapter), _amount),
+            "!transfer in"
+        );
+
+        // Reverts if the bridge was unsuccessful.
+        // Gets adapter-specific data that is encoded into the message
+        // ultimately sent via Hyperlane.
+        bytes memory _adapterData = _adapter.sendTokens(
+            _destinationDomain,
+            _recipientAddress,
+            _token,
+            _amount
+        );
+
+        // The user's message "wrapped" with metadata required by this middleware
+        bytes memory _messageWithMetadata = abi.encode(
+            TypeCasts.addressToBytes32(msg.sender),
+            _recipientAddress, // The "user" recipient
+            _amount, // The amount of the tokens sent over the bridge
+            _bridge, // The destination token bridge ID
+            _adapterData, // The adapter-specific data
+            _messageBody // The "user" message
+        );
+
+        // Dispatch the _messageWithMetadata to the destination's LiquidityLayerRouter.
+        _dispatchWithGas(_destinationDomain, _messageWithMetadata, msg.value);
+    }
+
+    // Handles a message from an enrolled remote LiquidityLayerRouter
+    function _handle(
+        uint32 _origin,
+        bytes32, // _sender, unused
+        bytes calldata _message
+    ) internal override {
+        // Decode the message with metadata, "unwrapping" the user's message body
+        (
+            bytes32 _originalSender,
+            bytes32 _userRecipientAddress,
+            uint256 _amount,
+            string memory _bridge,
+            bytes memory _adapterData,
+            bytes memory _userMessageBody
+        ) = abi.decode(
+                _message,
+                (bytes32, bytes32, uint256, string, bytes, bytes)
+            );
+
+        ILiquidityLayerMessageRecipient _userRecipient = ILiquidityLayerMessageRecipient(
+                TypeCasts.bytes32ToAddress(_userRecipientAddress)
+            );
+
+        // Reverts if the adapter hasn't received the bridged tokens yet
+        (address _token, uint256 _receivedAmount) = _getAdapter(_bridge)
+            .receiveTokens(
+                _origin,
+                address(_userRecipient),
+                _amount,
+                _adapterData
+            );
+
+        _userRecipient.handleWithTokens(
+            _origin,
+            _originalSender,
+            _userMessageBody,
+            _token,
+            _receivedAmount
+        );
+    }
+
+    function setLiquidityLayerAdapter(string calldata _bridge, address _adapter)
+        external
+        onlyOwner
+    {
+        liquidityLayerAdapters[_bridge] = _adapter;
+        emit LiquidityLayerAdapterSet(_bridge, _adapter);
+    }
+
+    function _getAdapter(string memory _bridge)
+        internal
+        view
+        returns (ILiquidityLayerAdapter _adapter)
+    {
+        _adapter = ILiquidityLayerAdapter(liquidityLayerAdapters[_bridge]);
+        // Require the adapter to have been set
+        require(address(_adapter) != address(0), "No adapter found for bridge");
+    }
+}

package/contracts/middleware/liquidity-layer/adapters/CircleBridgeAdapter.sol

@@ -0,0 +1,246 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.13;
+
+import {Router} from "../../../Router.sol";
+
+import {ICircleBridge} from "../interfaces/circle/ICircleBridge.sol";
+import {ICircleMessageTransmitter} from "../interfaces/circle/ICircleMessageTransmitter.sol";
+import {ILiquidityLayerAdapter} from "../interfaces/ILiquidityLayerAdapter.sol";
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+contract CircleBridgeAdapter is ILiquidityLayerAdapter, Router {
+    /// @notice The CircleBridge contract.
+    ICircleBridge public circleBridge;
+
+    /// @notice The Circle MessageTransmitter contract.
+    ICircleMessageTransmitter public circleMessageTransmitter;
+
+    /// @notice The LiquidityLayerRouter contract.
+    address public liquidityLayerRouter;
+
+    /// @notice Hyperlane domain => Circle domain.
+    /// ATM, known Circle domains are Ethereum = 0 and Avalanche = 1.
+    /// Note this could result in ambiguity between the Circle domain being
+    /// Ethereum or unknown. TODO fix?
+    mapping(uint32 => uint32) public hyperlaneDomainToCircleDomain;
+
+    /// @notice Token symbol => address of token on local chain.
+    mapping(string => IERC20) public tokenSymbolToAddress;
+
+    /// @notice Local chain token address => token symbol.
+    mapping(address => string) public tokenAddressToSymbol;
+
+    /**
+     * @notice Emits the nonce of the Circle message when a token is bridged.
+     * @param nonce The nonce of the Circle message.
+     */
+    event BridgedToken(uint64 nonce);
+
+    /**
+     * @notice Emitted when the Hyperlane domain to Circle domain mapping is updated.
+     * @param hyperlaneDomain The Hyperlane domain.
+     * @param circleDomain The Circle domain.
+     */
+    event DomainAdded(uint32 indexed hyperlaneDomain, uint32 circleDomain);
+
+    /**
+     * @notice Emitted when a local token and its token symbol have been added.
+     */
+    event TokenAdded(address indexed token, string indexed symbol);
+
+    /**
+     * @notice Emitted when a local token and its token symbol have been removed.
+     */
+    event TokenRemoved(address indexed token, string indexed symbol);
+
+    modifier onlyLiquidityLayerRouter() {
+        require(msg.sender == liquidityLayerRouter, "!liquidityLayerRouter");
+        _;
+    }
+
+    /**
+     * @param _owner The new owner.
+     * @param _circleBridge The CircleBridge contract.
+     * @param _circleMessageTransmitter The Circle MessageTransmitter contract.
+     * @param _liquidityLayerRouter The LiquidityLayerRouter contract.
+     */
+    function initialize(
+        address _owner,
+        address _circleBridge,
+        address _circleMessageTransmitter,
+        address _liquidityLayerRouter
+    ) public initializer {
+        // Transfer ownership of the contract to deployer
+        _transferOwnership(_owner);
+
+        // Set the addresses for the IGP to address(0) - it's not used.
+        _setInterchainGasPaymaster(address(0));
+
+        circleBridge = ICircleBridge(_circleBridge);
+        circleMessageTransmitter = ICircleMessageTransmitter(
+            _circleMessageTransmitter
+        );
+        liquidityLayerRouter = _liquidityLayerRouter;
+    }
+
+    function sendTokens(
+        uint32 _destinationDomain,
+        bytes32, // _recipientAddress, unused
+        address _token,
+        uint256 _amount
+    ) external onlyLiquidityLayerRouter returns (bytes memory) {
+        string memory _tokenSymbol = tokenAddressToSymbol[_token];
+        require(
+            bytes(_tokenSymbol).length > 0,
+            "CircleBridgeAdapter: Unknown token"
+        );
+
+        uint32 _circleDomain = hyperlaneDomainToCircleDomain[
+            _destinationDomain
+        ];
+        bytes32 _remoteRouter = routers[_destinationDomain];
+        require(
+            _remoteRouter != bytes32(0),
+            "CircleBridgeAdapter: No router for domain"
+        );
+
+        // Approve the token to Circle. We assume that the LiquidityLayerRouter
+        // has already transferred the token to this contract.
+        require(
+            IERC20(_token).approve(address(circleBridge), _amount),
+            "!approval"
+        );
+
+        uint64 _nonce = circleBridge.depositForBurn(
+            _amount,
+            _circleDomain,
+            _remoteRouter, // Mint to the remote router
+            _token
+        );
+
+        emit BridgedToken(_nonce);
+        return abi.encode(_nonce, _tokenSymbol);
+    }
+
+    // Returns the token and amount sent
+    function receiveTokens(
+        uint32 _originDomain, // Hyperlane domain
+        address _recipient,
+        uint256 _amount,
+        bytes calldata _adapterData // The adapter data from the message
+    ) external onlyLiquidityLayerRouter returns (address, uint256) {
+        // The origin Circle domain
+        uint32 _originCircleDomain = hyperlaneDomainToCircleDomain[
+            _originDomain
+        ];
+        // Get the token symbol and nonce of the transfer from the _adapterData
+        (uint64 _nonce, string memory _tokenSymbol) = abi.decode(
+            _adapterData,
+            (uint64, string)
+        );
+
+        // Require the circle message to have been processed
+        bytes32 _nonceId = _circleNonceId(_originCircleDomain, _nonce);
+        require(
+            circleMessageTransmitter.usedNonces(_nonceId),
+            "Circle message not processed yet"
+        );
+
+        IERC20 _token = tokenSymbolToAddress[_tokenSymbol];
+        require(
+            address(_token) != address(0),
+            "CircleBridgeAdapter: Unknown token"
+        );
+
+        // Transfer the token out to the recipient
+        // TODO: use safeTransfer
+        // Circle doesn't charge any fee, so we can safely transfer out the
+        // exact amount that was bridged over.
+        require(_token.transfer(_recipient, _amount), "!transfer out");
+
+        return (address(_token), _amount);
+    }
+
+    // This contract is only a Router to be aware of remote router addresses,
+    // and doesn't actually send/handle Hyperlane messages directly
+    function _handle(
+        uint32, // origin
+        bytes32, // sender
+        bytes calldata // message
+    ) internal pure override {
+        revert("No messages expected");
+    }
+
+    function addDomain(uint32 _hyperlaneDomain, uint32 _circleDomain)
+        external
+        onlyOwner
+    {
+        hyperlaneDomainToCircleDomain[_hyperlaneDomain] = _circleDomain;
+
+        emit DomainAdded(_hyperlaneDomain, _circleDomain);
+    }
+
+    function addToken(address _token, string calldata _tokenSymbol)
+        external
+        onlyOwner
+    {
+        require(
+            _token != address(0) && bytes(_tokenSymbol).length > 0,
+            "Cannot add default values"
+        );
+
+        // Require the token and token symbol to be unset.
+        address _existingToken = address(tokenSymbolToAddress[_tokenSymbol]);
+        require(_existingToken == address(0), "token symbol already has token");
+
+        string memory _existingSymbol = tokenAddressToSymbol[_token];
+        require(
+            bytes(_existingSymbol).length == 0,
+            "token already has token symbol"
+        );
+
+        tokenAddressToSymbol[_token] = _tokenSymbol;
+        tokenSymbolToAddress[_tokenSymbol] = IERC20(_token);
+
+        emit TokenAdded(_token, _tokenSymbol);
+    }
+
+    function removeToken(address _token, string calldata _tokenSymbol)
+        external
+        onlyOwner
+    {
+        // Require the provided token and token symbols match what's in storage.
+        address _existingToken = address(tokenSymbolToAddress[_tokenSymbol]);
+        require(_existingToken == _token, "Token mismatch");
+
+        string memory _existingSymbol = tokenAddressToSymbol[_token];
+        require(
+            keccak256(bytes(_existingSymbol)) == keccak256(bytes(_tokenSymbol)),
+            "Token symbol mismatch"
+        );
+
+        // Delete them from storage.
+        delete tokenSymbolToAddress[_tokenSymbol];
+        delete tokenAddressToSymbol[_token];
+
+        emit TokenRemoved(_token, _tokenSymbol);
+    }
+
+    /**
+     * @notice Gets the Circle nonce ID by hashing _originCircleDomain and _nonce.
+     * @param _originCircleDomain Domain of chain where the transfer originated
+     * @param _nonce The unique identifier for the message from source to
+              destination
+     * @return hash of source and nonce
+     */
+    function _circleNonceId(uint32 _originCircleDomain, uint64 _nonce)
+        internal
+        pure
+        returns (bytes32)
+    {
+        // The hash is of a uint256 nonce, not a uint64 one.
+        return
+            keccak256(abi.encodePacked(_originCircleDomain, uint256(_nonce)));
+    }
+}