Copy types from ipc/contracts

Author: islamaliev

.gitmodules

@@ -28,6 +28,3 @@
 [submodule "lib/solidity-cborutils"]
 	path = lib/solidity-cborutils
 	url = https://github.com/smartcontractkit/solidity-cborutils
-[submodule "lib/ipc"]
-	path = lib/ipc
-	url = https://github.com/consensus-shipyard/ipc

lib/ipc

@@ -3,9 +3,9 @@ pragma solidity ^0.8.26;
 
 import {InterchainTokenExecutable} from "@axelar-network/interchain-token-service/contracts/executable/InterchainTokenExecutable.sol";
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import {SubnetID} from "@ipc/contracts/contracts/structs/Subnet.sol";
-import {FvmAddress} from "@ipc/contracts/contracts/structs/FvmAddress.sol";
-import {IGateway} from "@ipc/contracts/contracts/interfaces/IGateway.sol";
+import {SubnetID} from "../types/CommonTypes.sol";
+import {FvmAddress} from "../types/CommonTypes.sol";
+import {IGatewayManagerFacet} from "./IGatewayManagerFacet.sol";
 
 /// @title AutoDeposit
 /// @notice Handles automatic token deposits from Axelar to IPC subnets
@@ -16,7 +16,7 @@ contract AutoDeposit is InterchainTokenExecutable {
 
     SubnetID public recallSubnet;
     IERC20 public immutable RECALL_TOKEN;
-    IGateway public immutable RECALL_GATEWAY;
+    IGatewayManagerFacet public immutable RECALL_GATEWAY;
 
     /// @notice Initializes the contract with required addresses and subnet ID
     /// @param subnet The subnet ID where tokens will be deposited
@@ -31,7 +31,7 @@ contract AutoDeposit is InterchainTokenExecutable {
     ) InterchainTokenExecutable(interchainTokenService_) {
         recallSubnet = subnet;
         RECALL_TOKEN = IERC20(token);
-        RECALL_GATEWAY = IGateway(gateway);
+        RECALL_GATEWAY = IGatewayManagerFacet(gateway);
     }
 
     /// @inheritdoc InterchainTokenExecutable

src/token/AutoDeposit.sol

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity ^0.8.26;
+
+import {BottomUpCheckpoint, BottomUpMsgBatch, IpcEnvelope, ParentFinality, SubnetID, FvmAddress, FullActivityRollup} from "../types/CommonTypes.sol";
+
+/// @title Gateway interface
+/// @author LimeChain team
+interface IGatewayManagerFacet {
+    /// @notice Register is called by subnet actors to put the required collateral
+    /// and register the subnet to the hierarchy.
+    function register(uint256 genesisCircSupply, uint256 collateral) external payable;
+
+    /// @notice AddStake adds stake to the collateral of a subnet.
+    function addStake(uint256 amount) external payable;
+
+    /// @notice Release stake recovers some collateral of the subnet
+    function releaseStake(uint256 amount) external;
+
+    /// @notice Kill propagates the kill signal from a subnet actor to unregister it from th
+    /// hierarchy.
+    function kill() external;
+
+    /// @notice commitCheckpoint propagates the commitment of a checkpoint from a child
+    function commitCheckpoint(BottomUpCheckpoint calldata bottomUpCheckpoint) external;
+
+    /// @notice fund locks the received funds —denominated in the native coin— and moves the value down the hierarchy,
+    /// crediting the funds to the specified address in the destination network.
+    ///
+    /// This functions ends up minting supply in the subnet equal to the value of the transaction. It does so by
+    /// committing the relevant top-down message, updating the top-down nonce along the way.
+    ///
+    /// Calling this method on a subnet whose supply source is not 'native' will revert with UnexpectedAsset().
+    function fund(SubnetID calldata subnetId, FvmAddress calldata to) external payable;
+
+    /// @notice fundWithToken locks the specified amount of tokens in the ERC20 contract linked to the subnet, and
+    /// moves the value down the hierarchy, crediting the funds as native coins to the specified address
+    /// in the destination network.
+    ///
+    /// This method expects the caller to have approved the gateway to spend `amount` tokens on their behalf
+    /// (usually done through IERC20#approve). Tokens are locked by calling IERC20#transferFrom(caller, address(this), amount).
+    /// A failure in transferring tokens to the gateway will revert the call.
+    ///
+    /// It's possible to call this method from an EOA or a contract. Regardless, it's recommended to approve strictly
+    /// the amount that will subsequently be deposited into the subnet. Keeping outstanding approvals is not recommended.
+    ///
+    /// Calling this method on a subnet whose supply source is not 'ERC20' will revert with UnexpectedAsset().
+    function fundWithToken(SubnetID calldata subnetId, FvmAddress calldata to, uint256 amount) external;
+
+    /// @notice Release creates a new check message to release funds in parent chain
+    ///
+    /// This function burns the funds that will be released in the current subnet
+    /// and propagates a new checkpoint message to the parent chain to signal
+    /// the amount of funds that can be released for a specific address.
+    function release(FvmAddress calldata to) external payable;
+
+    /// @notice sendContractXnetMessage sends an arbitrary cross-message to other subnet in the hierarchy.
+    // TODO: add the right comment and function name here.
+    function sendContractXnetMessage(
+        IpcEnvelope calldata envelope
+    ) external payable returns (IpcEnvelope memory committed);
+
+    /// @notice Propagates all the stored messages to destination subnet
+    function propagateAll() external payable;
+
+    /// @notice commit the ipc parent finality into storage
+    function commitParentFinality(ParentFinality calldata finality) external;
+
+    /// @notice creates a new bottom-up checkpoint
+    function createBottomUpCheckpoint(
+        BottomUpCheckpoint calldata checkpoint,
+        bytes32 membershipRootHash,
+        uint256 membershipWeight,
+        FullActivityRollup calldata activity
+    ) external;
+} 

src/token/IGatewayManagerFacet.sol

@@ -38,15 +38,10 @@ struct SubnetID {
     address[] route;
 }
 
-/// Namespace for consensus-level activity summaries.
-library Consensus {
-    struct ValidatorData {
-        /// @dev The validator whose activity we're reporting about, identified by the Ethereum address corresponding
-        /// to its secp256k1 pubkey.
-        address validator;
-        /// @dev The number of blocks committed by this validator during the summarised period.
-        uint64 blocksCommitted;
-    }
+/// @notice The parent finality for IPC parent at certain height.
+struct ParentFinality {
+    uint256 height;
+    bytes32 blockHash;
 }
 
 /// @notice A bottom-up checkpoint type.
@@ -69,25 +64,17 @@ struct BottomUpCheckpoint {
     CompressedActivityRollup activity;
 }
 
-// Compressed representation of the activity summary that can be embedded in checkpoints to propagate up the hierarchy.
-struct CompressedActivityRollup {
-    CompressedSummary consensus;
-}
-
-// Aggregated stats for consensus-level activity.
-struct AggregatedStats {
-    /// The total number of unique validators that have mined within this period.
-    uint64 totalActiveValidators;
-    /// The total number of blocks committed by all validators during this period.
-    uint64 totalNumBlocksCommitted;
+/// @notice A batch of bottom-up messages for execution.
+struct BottomUpMsgBatch {
+    SubnetID subnetID;
+    uint256 blockHeight;
+    IpcEnvelope[] msgs;
 }
 
-// The compresed representation of the activity summary for consensus-level activity suitable for embedding in a
-// checkpoint.
-struct CompressedSummary {
-    AggregatedStats stats;
-    /// The commitment for the validator details, so that we don't have to transmit them in full.
-    bytes32 dataRootCommitment;
+/// @notice Tracks information about the last batch executed.
+struct BottomUpMsgBatchInfo {
+    uint256 blockHeight;
+    bytes32 hash;
 }
 
 /// @notice Type of cross-net messages currently supported
@@ -132,3 +119,86 @@ struct IpcEnvelope {
     /// @dev abi.encoded message
     bytes message;
 }
+
+/// @notice Message format used for `Transfer` and `Call` messages.
+struct CallMsg {
+    bytes method;
+    bytes params;
+}
+
+/// @notice Outcome type for cross message execution
+enum OutcomeType {
+    Ok,
+    SystemErr,
+    ActorErr
+}
+
+struct ResultMsg {
+    bytes32 id;
+    OutcomeType outcome;
+    bytes ret;
+}
+
+/// @notice Validator struct stored in the gateway.
+struct Validator {
+    uint256 weight;
+    address addr;
+    bytes metadata;
+}
+
+/// @notice Membership information stored in the gateway.
+struct Membership {
+    Validator[] validators;
+    uint64 configurationNumber;
+}
+
+/// @notice Defines token representation in subnet
+struct Asset {
+    AssetKind kind;
+    address tokenAddress;
+}
+
+/// @notice Token type used in the subnet
+enum AssetKind {
+    Native,
+    ERC20
+}
+
+// Activity related structs
+struct FullActivityRollup {
+    Consensus.FullSummary consensus;
+}
+
+struct CompressedActivityRollup {
+    Consensus.CompressedSummary consensus;
+}
+
+/// Namespace for consensus-level activity summaries.
+library Consensus {
+    type MerkleHash is bytes32;
+
+    struct AggregatedStats {
+        uint64 totalActiveValidators;
+        uint64 totalNumBlocksCommitted;
+    }
+
+    struct FullSummary {
+        AggregatedStats stats;
+        ValidatorData[] data;
+    }
+
+    struct CompressedSummary {
+        AggregatedStats stats;
+        MerkleHash dataRootCommitment;
+    }
+
+    struct ValidatorData {
+        address validator;
+        uint64 blocksCommitted;
+    }
+
+    struct ValidatorClaim {
+        ValidatorData data;
+        MerkleHash[] proof;
+    }
+}