Merge pull request #21 from datachainlab/impl-initiator

feat: impl initiator

Author: YukiTsuchida

src/core/CrossModule.sol

@@ -13,16 +13,30 @@ import {Packet} from "@hyperledger-labs/yui-ibc-solidity/contracts/core/04-chann
 import "./PacketHandler.sol";
 import "./IBCKeeper.sol";
 
-abstract contract CrossModule is AccessControl, IIBCModule, IBCKeeper, PacketHandler {
+import {Initiator} from "./Initiator.sol";
+import {TxAuthManager} from "./TxAuthManager.sol";
+import {TxManager} from "./TxManager.sol";
+import {TxRunner} from "./TxRunner.sol";
+
+abstract contract CrossModule is
+    AccessControl,
+    IIBCModule,
+    IBCKeeper,
+    PacketHandler,
+    Initiator,
+    TxAuthManager,
+    TxManager,
+    TxRunner
+{
     bytes32 public constant IBC_ROLE = keccak256("IBC_ROLE");
 
-    constructor(IIBCHandler ibcHandler_) IBCKeeper(ibcHandler_) {
+    constructor(IIBCHandler ibcHandler_) Initiator() IBCKeeper(ibcHandler_) {
         _grantRole(IBC_ROLE, address(ibcHandler_));
     }
 
-    function supportsInterface(bytes4 interfaceId) public view virtual override(AccessControl, IERC165) returns (bool) {
-        return interfaceId == type(IIBCModule).interfaceId || interfaceId == type(IIBCModuleInitializer).interfaceId
-            || super.supportsInterface(interfaceId);
+    function supportsInterface(bytes4 interfaceID) public view virtual override(AccessControl, IERC165) returns (bool) {
+        return interfaceID == type(IIBCModule).interfaceId || interfaceID == type(IIBCModuleInitializer).interfaceId
+            || super.supportsInterface(interfaceID);
     }
 
     // function initiateTx() external {}

src/core/CrossStore.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {MsgInitiateTx, MsgInitiateTxResponse} from "../proto/cross/core/initiator/Initiator.sol";
+import {Account} from "../proto/cross/core/auth/Auth.sol";
+import {CoordinatorState} from "src/proto/cross/core/atomic/simple/AtomicSimple.sol";
+
+abstract contract CrossStore {
+    // keccak256(abi.encode(uint256(keccak256("cross.core.auth")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 internal constant AUTH_STORAGE_LOCATION =
+        hex"93e3b8eb4220ad7cd6d04c9032dc8d35824a37bf01220f3aeab27e9ece04f300";
+
+    // keccak256(abi.encode(uint256(keccak256("cross.core.tx")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 internal constant TX_STORAGE_LOCATION =
+        hex"2af14e14eac421b9203c410963a611c3e22a3e7dd2f462f3872422d801fd5a00";
+
+    // keccak256(abi.encode(uint256(keccak256("cross.core.coord")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 internal constant COORD_STORAGE_LOCATION =
+        hex"ef61b39f0bec0016a7c6e65e3ee8d2ea1b2327afbd737de3be2c6827c42f9600";
+
+    struct AuthStorage {
+        mapping(bytes32 => mapping(bytes32 => bool)) remaining;
+        mapping(bytes32 => uint256) remainingCount;
+        mapping(bytes32 => bool) authInitialized;
+        mapping(bytes32 => Account.Data[]) requiredAccounts;
+    }
+
+    struct TxStorage {
+        mapping(bytes32 => MsgInitiateTx.Data) txMsg;
+        mapping(bytes32 => MsgInitiateTxResponse.InitiateTxStatus) txStatus;
+    }
+
+    struct CoordEntry {
+        bool exists;
+        CoordinatorState.Data data;
+    }
+
+    struct CoordStorage {
+        mapping(bytes32 => CoordEntry) states;
+    }
+
+    function _getAuthStorage() internal pure returns (AuthStorage storage $) {
+        // solhint-disable-next-line no-inline-assembly
+        assembly { $.slot := AUTH_STORAGE_LOCATION }
+    }
+
+    function _getTxStorage() internal pure returns (TxStorage storage $) {
+        // solhint-disable-next-line no-inline-assembly
+        assembly { $.slot := TX_STORAGE_LOCATION }
+    }
+
+    function _getCoordStorage() internal pure returns (CoordStorage storage $) {
+        // solhint-disable-next-line no-inline-assembly
+        assembly { $.slot := COORD_STORAGE_LOCATION }
+    }
+}

src/core/IAuthenticator.sol

@@ -12,7 +12,11 @@ import {
 } from "../proto/cross/core/auth/Auth.sol";
 
 interface IAuthenticator {
-    event TxSigned(address indexed signer, bytes32 indexed txId, AuthType.AuthMode method);
+    error AuthStateAlreadyInitialized(bytes32 txID);
+    error IDNotFound(bytes32 txID);
+    error AuthAlreadyCompleted(bytes32 txID);
+
+    event TxSigned(address indexed signer, bytes32 indexed txID, AuthType.AuthMode method);
 
     function signTx(MsgSignTx.Data calldata msg_) external returns (MsgSignTxResponse.Data memory);
 

src/core/IContractModule.sol

@@ -22,7 +22,7 @@ interface IContractModule {
 
 // CrossContext is a context in cross-chain transaction
 struct CrossContext {
-    bytes txId;
+    bytes txID;
     uint8 txIndex;
     Account.Data[] signers;
 }

src/core/ICoordinator.sol

@@ -7,6 +7,8 @@ import {
 } from "src/proto/cross/core/atomic/simple/AtomicSimple.sol";
 
 interface ICoordinator {
+    error CoordinatorStateNotFound(bytes32 txID);
+
     function coordinatorState(QueryCoordinatorStateRequest.Data calldata req)
         external
         view

src/core/IInitiator.sol

@@ -4,7 +4,13 @@ pragma solidity ^0.8.20;
 import {MsgInitiateTx, MsgInitiateTxResponse, QuerySelfXCCResponse} from "../proto/cross/core/initiator/Initiator.sol";
 
 interface IInitiator {
-    event TxInitiated(bytes txId, address indexed proposer);
+    error UnexpectedChainID(bytes32 expectedHash, bytes32 gotHash);
+    error MessageTimeoutHeight(uint256 blockNumber, uint64 timeoutVersionHeight);
+    error MessageTimeoutTimestamp(uint256 blockTimestamp, uint64 timeoutTimestamp);
+    error TxIDAlreadyExists(bytes32 txIDHash);
+    error SelfXCCNotImplemented();
+
+    event TxInitiated(bytes txID, address indexed proposer);
 
     function initiateTx(MsgInitiateTx.Data calldata msg_) external returns (MsgInitiateTxResponse.Data memory resp);
 

src/core/Initiator.sol

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {IInitiator} from "./IInitiator.sol";
+import {TxAuthManagerBase} from "./TxAuthManagerBase.sol";
+import {TxManagerBase} from "./TxManagerBase.sol";
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+
+import {MsgInitiateTx, MsgInitiateTxResponse, QuerySelfXCCResponse} from "../proto/cross/core/initiator/Initiator.sol";
+import {Account} from "../proto/cross/core/auth/Auth.sol";
+
+abstract contract Initiator is IInitiator, TxAuthManagerBase, TxManagerBase {
+    bytes32 public immutable CHAIN_ID_HASH;
+
+    constructor() {
+        CHAIN_ID_HASH = keccak256(bytes(Strings.toString(block.chainid)));
+    }
+
+    function initiateTx(MsgInitiateTx.Data calldata msg_)
+        external
+        override
+        returns (MsgInitiateTxResponse.Data memory resp)
+    {
+        // chain_id check
+        bytes32 got = keccak256(bytes(msg_.chain_id));
+        if (got != CHAIN_ID_HASH) revert IInitiator.UnexpectedChainID(CHAIN_ID_HASH, got);
+
+        // timeouts
+        uint64 rh = msg_.timeout_height.revision_height;
+        if (rh != 0 && (block.number + 1 > uint256(rh))) {
+            revert IInitiator.MessageTimeoutHeight(block.number, rh);
+        }
+        // slither-disable-next-line timestamp
+        if (msg_.timeout_timestamp > 0 && (block.timestamp + 1 > msg_.timeout_timestamp)) {
+            revert IInitiator.MessageTimeoutTimestamp(block.timestamp, msg_.timeout_timestamp);
+        }
+
+        // generate txID
+        bytes32 txIDHash = sha256(MsgInitiateTx.encode(msg_));
+        bytes memory txID = abi.encodePacked(txIDHash);
+        if (isTxRecorded(txIDHash)) revert IInitiator.TxIDAlreadyExists(txIDHash);
+
+        // persist as PENDING
+        createTx(txIDHash, msg_);
+
+        // auth init & sign
+        Account.Data[] memory required = _getRequiredAccounts(msg_);
+        initAuthState(txIDHash, required);
+        bool completed = sign(txIDHash, msg_.signers);
+
+        emit TxInitiated(txID, msg.sender);
+
+        if (completed) {
+            runTxIfCompleted(txIDHash);
+            return MsgInitiateTxResponse.Data({
+                txID: txID, status: MsgInitiateTxResponse.InitiateTxStatus.INITIATE_TX_STATUS_VERIFIED
+            });
+        }
+        return MsgInitiateTxResponse.Data({
+            txID: txID, status: MsgInitiateTxResponse.InitiateTxStatus.INITIATE_TX_STATUS_PENDING
+        });
+    }
+
+    function selfXCC() external view virtual override returns (QuerySelfXCCResponse.Data memory) {
+        revert IInitiator.SelfXCCNotImplemented();
+    }
+
+    function _getRequiredAccounts(MsgInitiateTx.Data calldata msg_) internal pure returns (Account.Data[] memory out) {
+        uint256 upper = 0;
+        for (uint256 i = 0; i < msg_.contract_transactions.length; ++i) {
+            upper += msg_.contract_transactions[i].signers.length;
+        }
+        out = new Account.Data[](upper);
+        uint256 n = 0;
+
+        for (uint256 i = 0; i < msg_.contract_transactions.length; ++i) {
+            Account.Data[] memory rs = msg_.contract_transactions[i].signers;
+            for (uint256 j = 0; j < rs.length; ++j) {
+                out[n] = rs[j];
+                ++n;
+            }
+        }
+        return out;
+    }
+}

src/core/TxAtomicSimple.sol

@@ -20,7 +20,7 @@ abstract contract TxAtomicSimple is IBCKeeper, PacketHandler, ContractRegistry {
     error UnexpectedTypeURL();
     error NotImplemented();
 
-    event OnContractCall(bytes indexed txId, uint8 indexed txIndex, bool indexed success, bytes ret);
+    event OnContractCall(bytes indexed txID, uint8 indexed txIndex, bool indexed success, bytes ret);
 
     function handlePacket(Packet memory packet) internal virtual override returns (bytes memory acknowledgement) {
         IContractModule module = getModule(packet);

src/core/TxAuthManager.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {TxAuthManagerBase} from "./TxAuthManagerBase.sol";
+import {CrossStore} from "./CrossStore.sol";
+import {Account, TxAuthState} from "../proto/cross/core/auth/Auth.sol";
+
+abstract contract TxAuthManager is TxAuthManagerBase, CrossStore {
+    function initAuthState(bytes32 txID, Account.Data[] memory signers) internal virtual override {
+        CrossStore.AuthStorage storage s = _getAuthStorage();
+        if (s.authInitialized[txID]) revert AuthStateAlreadyInitialized(txID);
+        _setStateFromRemainingList(s, txID, signers);
+        s.authInitialized[txID] = true;
+    }
+
+    function isCompletedAuth(bytes32 txID) internal view virtual override returns (bool) {
+        CrossStore.AuthStorage storage s = _getAuthStorage();
+        if (!s.authInitialized[txID]) revert IDNotFound(txID);
+        return s.remainingCount[txID] == 0;
+    }
+
+    function sign(bytes32 txID, Account.Data[] memory signers) internal virtual override returns (bool) {
+        CrossStore.AuthStorage storage s = _getAuthStorage();
+        if (!s.authInitialized[txID]) revert IDNotFound(txID);
+        if (s.remainingCount[txID] == 0) revert AuthAlreadyCompleted(txID);
+
+        for (uint256 i = 0; i < signers.length; ++i) {
+            bytes32 key = _accountKey(signers[i]);
+            if (s.remaining[txID][key]) {
+                s.remaining[txID][key] = false;
+                --s.remainingCount[txID];
+                if (s.remainingCount[txID] == 0) return true;
+            }
+        }
+        return s.remainingCount[txID] == 0;
+    }
+
+    function getAuthState(bytes32 txID) internal view virtual override returns (TxAuthState.Data memory) {
+        CrossStore.AuthStorage storage s = _getAuthStorage();
+        if (!s.authInitialized[txID]) revert IDNotFound(txID);
+        Account.Data[] memory remains = _getRemainingSigners(s, txID);
+        return TxAuthState.Data({remaining_signers: remains});
+    }
+
+    function _getRemainingSigners(CrossStore.AuthStorage storage s, bytes32 txID)
+        internal
+        view
+        returns (Account.Data[] memory out)
+    {
+        uint256 total = s.requiredAccounts[txID].length;
+        uint256 need = s.remainingCount[txID];
+        out = new Account.Data[](need);
+        uint256 p = 0;
+        for (uint256 i = 0; i < total; ++i) {
+            Account.Data memory acc = s.requiredAccounts[txID][i];
+            if (s.remaining[txID][_accountKey(acc)]) {
+                out[p] = acc;
+                ++p;
+                if (p == need) break;
+            }
+        }
+    }
+
+    function _setStateFromRemainingList(CrossStore.AuthStorage storage s, bytes32 txID, Account.Data[] memory list)
+        internal
+    {
+        for (uint256 i = 0; i < list.length; ++i) {
+            bytes32 key = _accountKey(list[i]);
+            if (!s.remaining[txID][key]) {
+                s.remaining[txID][key] = true;
+                ++s.remainingCount[txID];
+                s.requiredAccounts[txID].push(list[i]);
+            }
+        }
+    }
+
+    function _accountKey(Account.Data memory a) internal pure returns (bytes32) {
+        return keccak256(abi.encode(a.id, a.auth_type));
+    }
+}

src/core/TxAuthManagerBase.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.20;
+
+import {Account, TxAuthState} from "../proto/cross/core/auth/Auth.sol";
+
+abstract contract TxAuthManagerBase {
+    error AuthStateAlreadyInitialized(bytes32 txID);
+    error IDNotFound(bytes32 txID);
+    error AuthAlreadyCompleted(bytes32 txID);
+
+    function initAuthState(bytes32 txID, Account.Data[] memory signers) internal virtual;
+    function isCompletedAuth(bytes32 txID) internal view virtual returns (bool);
+    function sign(bytes32 txID, Account.Data[] memory signers) internal virtual returns (bool);
+    function getAuthState(bytes32 txID) internal view virtual returns (TxAuthState.Data memory);
+}