diff --git a/Cargo.lock b/Cargo.lock
index 76e1954280..c3ac071e90 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1501,12 +1501,15 @@ dependencies = [
  "ckb-traits",
  "ckb-types",
  "ckb-vm",
+ "daggy",
  "faster-hex",
+ "molecule",
  "proptest",
  "rand 0.8.5",
  "serde",
  "tempfile",
  "tiny-keccak",
+ "tokio",
 ]
 
 [[package]]
@@ -1700,6 +1703,7 @@ dependencies = [
  "ckb-metrics",
  "ckb-network",
  "ckb-reward-calculator",
+ "ckb-script",
  "ckb-snapshot",
  "ckb-stop-handler",
  "ckb-store",
@@ -1711,6 +1715,7 @@ dependencies = [
  "hyper",
  "lru",
  "multi_index_map",
+ "num_cpus",
  "rand 0.8.5",
  "rustc-hash",
  "sentry",
@@ -1775,6 +1780,7 @@ dependencies = [
  "ckb-verification-traits",
  "derive_more",
  "lru",
+ "tokio",
 ]
 
 [[package]]
@@ -1813,9 +1819,9 @@ dependencies = [
 
 [[package]]
 name = "ckb-vm"
-version = "0.24.9"
+version = "0.24.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2c3d68dc7f891e5555c7ebc054722b28ab005e51c5076f54c20d36002dc8e83"
+checksum = "ddff96029d3298cb630e95f29d4b9a93384e938a0b75758684aa8794b53bdd1a"
 dependencies = [
  "byteorder",
  "bytes",
@@ -1831,9 +1837,9 @@ dependencies = [
 
 [[package]]
 name = "ckb-vm-definitions"
-version = "0.24.9"
+version = "0.24.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2fdf9c8ee14409b2208d23b9ad88828242d7881153ddc04872b66d2e018a52f"
+checksum = "c280bf1d589d23ab0358f58601c2187fc6be86a131644583ef72ea96a0a13ddd"
 dependencies = [
  "paste",
 ]
@@ -2089,11 +2095,10 @@ dependencies = [
 
 [[package]]
 name = "crossbeam"
-version = "0.8.2"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2801af0d36612ae591caa9568261fddce32ce6e08a7275ea334a06a4ad021a2c"
+checksum = "1137cd7e7fc0fb5d3c5a8678be38ec56e819125d8d7907411fe24ccb943faca8"
 dependencies = [
- "cfg-if",
  "crossbeam-channel",
  "crossbeam-deque",
  "crossbeam-epoch",
@@ -2222,6 +2227,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "daggy"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91a9304e55e9d601a39ae4deaba85406d5c0980e106f65afcf0460e9af1e7602"
+dependencies = [
+ "petgraph",
+]
+
 [[package]]
 name = "darling"
 version = "0.20.8"
@@ -3580,13 +3594,12 @@ dependencies = [
 
 [[package]]
 name = "minstant"
-version = "0.1.4"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8dfc09c8abbe145769b6d51fd03f84fdd459906cbd6ac54e438708f016b40bd"
+checksum = "1fb9b5c752f145ac5046bccc3c4f62892e3c950c1d1eab80c5949cd68a2078db"
 dependencies = [
  "ctor",
- "libc",
- "wasi 0.7.0",
+ "web-time",
 ]
 
 [[package]]
@@ -6196,12 +6209,6 @@ dependencies = [
  "try-lock",
 ]
 
-[[package]]
-name = "wasi"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b89c3ce4ce14bdc6fb6beaf9ec7928ca331de5df7e5ea278375642a2f478570d"
-
 [[package]]
 name = "wasi"
 version = "0.9.0+wasi-snapshot-preview1"
@@ -6296,6 +6303,16 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "web-time"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "webpki"
 version = "0.22.4"
diff --git a/Makefile b/Makefile
index 79a84eedcb..91ef1c2a5d 100644
--- a/Makefile
+++ b/Makefile
@@ -4,7 +4,7 @@ MOLC    := moleculec
 MOLC_VERSION := 0.7.5
 VERBOSE := $(if ${CI},--verbose,)
 CLIPPY_OPTS := -D warnings -D clippy::clone_on_ref_ptr -D clippy::redundant_clone -D clippy::enum_glob_use -D clippy::fallible_impl_from \
-	-A clippy::mutable_key_type -A clippy::upper_case_acronyms
+	-A clippy::mutable_key_type -A clippy::upper_case_acronyms -A clippy::needless_return
 CKB_TEST_ARGS := -c 4 ${CKB_TEST_ARGS}
 CKB_FEATURES ?= deadlock_detection,with_sentry
 ALL_FEATURES := deadlock_detection,with_sentry,with_dns_seeding,profiling,march-native
diff --git a/chain/src/tests/load_code_with_snapshot.rs b/chain/src/tests/load_code_with_snapshot.rs
index 42db84283d..9a51e6e82b 100644
--- a/chain/src/tests/load_code_with_snapshot.rs
+++ b/chain/src/tests/load_code_with_snapshot.rs
@@ -113,7 +113,7 @@ fn test_load_code() {
     let tx_status = tx_pool.get_tx_status(tx.hash());
     assert_eq!(
         tx_status.unwrap().unwrap(),
-        (TxStatus::Pending, Some(11174))
+        (TxStatus::Pending, Some(11325))
     );
 }
 
diff --git a/rpc/README.md b/rpc/README.md
index 939792d82f..e85719ae50 100644
--- a/rpc/README.md
+++ b/rpc/README.md
@@ -85,6 +85,7 @@ The crate `ckb-rpc`'s minimum supported rustc version is 1.71.1.
         * [Method `notify_transaction`](#integration_test-notify_transaction)
         * [Method `generate_block_with_template`](#integration_test-generate_block_with_template)
         * [Method `calculate_dao_field`](#integration_test-calculate_dao_field)
+        * [Method `send_test_transaction`](#integration_test-send_test_transaction)
     * [Module Miner](#module-miner) [👉 OpenRPC spec](http://playground.open-rpc.org/?uiSchema[appBar][ui:title]=CKB-Miner&uiSchema[appBar][ui:splitView]=false&uiSchema[appBar][ui:examplesDropdown]=false&uiSchema[appBar][ui:logoUrl]=https://raw.githubusercontent.com/nervosnetwork/ckb-rpc-resources/develop/ckb-logo.jpg&schemaUrl=https://raw.githubusercontent.com/nervosnetwork/ckb-rpc-resources/develop/json/miner_rpc_doc.json)
 
         * [Method `get_block_template`](#miner-get_block_template)
@@ -3549,6 +3550,95 @@ Response
 }
 ```
 
+<a id="integration_test-send_test_transaction"></a>
+#### Method `send_test_transaction`
+* `send_test_transaction(tx, outputs_validator)`
+    * `tx`: [`Transaction`](#type-transaction)
+    * `outputs_validator`: [`OutputsValidator`](#type-outputsvalidator) `|` `null`
+* result: [`H256`](#type-h256)
+
+Submits a new test local transaction into the transaction pool, only for testing.
+If the transaction is already in the pool, rebroadcast it to peers.
+
+###### Params
+
+* `transaction` - The transaction.
+* `outputs_validator` - Validates the transaction outputs before entering the tx-pool. (**Optional**, default is "passthrough").
+
+###### Errors
+
+* [`PoolRejectedTransactionByOutputsValidator (-1102)`](../enum.RPCError.html#variant.PoolRejectedTransactionByOutputsValidator) - The transaction is rejected by the validator specified by `outputs_validator`. If you really want to send transactions with advanced scripts, please set `outputs_validator` to "passthrough".
+* [`PoolRejectedTransactionByMinFeeRate (-1104)`](../enum.RPCError.html#variant.PoolRejectedTransactionByMinFeeRate) - The transaction fee rate must be greater than or equal to the config option `tx_pool.min_fee_rate`.
+* [`PoolRejectedTransactionByMaxAncestorsCountLimit (-1105)`](../enum.RPCError.html#variant.PoolRejectedTransactionByMaxAncestorsCountLimit) - The ancestors count must be greater than or equal to the config option `tx_pool.max_ancestors_count`.
+* [`PoolIsFull (-1106)`](../enum.RPCError.html#variant.PoolIsFull) - Pool is full.
+* [`PoolRejectedDuplicatedTransaction (-1107)`](../enum.RPCError.html#variant.PoolRejectedDuplicatedTransaction) - The transaction is already in the pool.
+* [`TransactionFailedToResolve (-301)`](../enum.RPCError.html#variant.TransactionFailedToResolve) - Failed to resolve the referenced cells and headers used in the transaction, as inputs or dependencies.
+* [`TransactionFailedToVerify (-302)`](../enum.RPCError.html#variant.TransactionFailedToVerify) - Failed to verify the transaction.
+
+###### Examples
+
+Request
+
+```json
+{
+  "id": 42,
+  "jsonrpc": "2.0",
+  "method": "send_test_transaction",
+  "params": [
+    {
+      "cell_deps": [
+        {
+          "dep_type": "code",
+          "out_point": {
+            "index": "0x0",
+            "tx_hash": "0xa4037a893eb48e18ed4ef61034ce26eba9c585f15c9cee102ae58505565eccc3"
+          }
+        }
+      ],
+      "header_deps": [
+        "0x7978ec7ce5b507cfb52e149e36b1a23f6062ed150503c85bbf825da3599095ed"
+      ],
+      "inputs": [
+        {
+          "previous_output": {
+            "index": "0x0",
+            "tx_hash": "0x365698b50ca0da75dca2c87f9e7b563811d3b5813736b8cc62cc3b106faceb17"
+          },
+          "since": "0x0"
+        }
+      ],
+      "outputs": [
+        {
+          "capacity": "0x2540be400",
+          "lock": {
+            "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
+            "hash_type": "data",
+            "args": "0x"
+          },
+          "type": null
+        }
+      ],
+      "outputs_data": [
+        "0x"
+      ],
+      "version": "0x0",
+      "witnesses": []
+    },
+    "passthrough"
+  ]
+}
+```
+
+Response
+
+```json
+{
+  "id": 42,
+  "jsonrpc": "2.0",
+  "result": "0xa0ef4eb5f4ceeb08a4c8524d84c5da95dce2f608e0ca2ec8091191b0f330c6e3"
+}
+```
+
 ### Module `Miner`
 - [👉 OpenRPC spec](http://playground.open-rpc.org/?uiSchema[appBar][ui:title]=CKB-Miner&uiSchema[appBar][ui:splitView]=false&uiSchema[appBar][ui:examplesDropdown]=false&uiSchema[appBar][ui:logoUrl]=https://raw.githubusercontent.com/nervosnetwork/ckb-rpc-resources/develop/ckb-logo.jpg&schemaUrl=https://raw.githubusercontent.com/nervosnetwork/ckb-rpc-resources/develop/json/miner_rpc_doc.json)
 
@@ -4619,7 +4709,8 @@ Response
     "tip_number": "0x400",
     "total_tx_cycles": "0x219",
     "total_tx_size": "0x112",
-    "tx_size_limit": "0x7d000"
+    "tx_size_limit": "0x7d000",
+    "verify_queue_size": "0x0"
   }
 }
 ```
@@ -7160,6 +7251,8 @@ Transaction pool information.
 
     Transactions with a large size close to the block size limit may not be packaged, because the block header and cellbase are occupied, so the tx-pool is limited to accepting transaction up to tx_size_limit.
 
+* `verify_queue_size`: [`Uint64`](#type-uint64) - verify_queue size
+
 ### Type `TxStatus`
 Transaction status and the block hash if it is committed.
 
diff --git a/rpc/src/module/pool.rs b/rpc/src/module/pool.rs
index aab1071e0d..9fe30b357e 100644
--- a/rpc/src/module/pool.rs
+++ b/rpc/src/module/pool.rs
@@ -287,7 +287,8 @@ pub trait PoolRpc {
     ///     "tip_number": "0x400",
     ///     "total_tx_cycles": "0x219",
     ///     "total_tx_size": "0x112",
-    ///     "tx_size_limit": "0x7d000"
+    ///     "tx_size_limit": "0x7d000",
+    ///     "verify_queue_size": "0x0"
     ///   }
     /// }
     /// ```
diff --git a/rpc/src/module/test.rs b/rpc/src/module/test.rs
index 72f2afbbc2..1974b39404 100644
--- a/rpc/src/module/test.rs
+++ b/rpc/src/module/test.rs
@@ -2,7 +2,9 @@ use crate::error::RPCError;
 use async_trait::async_trait;
 use ckb_chain::ChainController;
 use ckb_dao::DaoCalculator;
-use ckb_jsonrpc_types::{Block, BlockTemplate, Byte32, EpochNumberWithFraction, Transaction};
+use ckb_jsonrpc_types::{
+    Block, BlockTemplate, Byte32, EpochNumberWithFraction, OutputsValidator, Transaction,
+};
 use ckb_logger::error;
 use ckb_network::{NetworkController, SupportProtocols};
 use ckb_shared::{shared::Shared, Snapshot};
@@ -25,6 +27,8 @@ use jsonrpc_utils::rpc;
 use std::collections::HashSet;
 use std::sync::Arc;
 
+use super::pool::WellKnownScriptsOnlyValidator;
+
 /// RPC for Integration Test.
 #[rpc(openrpc)]
 #[async_trait]
@@ -498,6 +502,95 @@ pub trait IntegrationTestRpc {
     /// ```
     #[rpc(name = "calculate_dao_field")]
     fn calculate_dao_field(&self, block_template: BlockTemplate) -> Result<Byte32>;
+
+    /// Submits a new test local transaction into the transaction pool, only for testing.
+    /// If the transaction is already in the pool, rebroadcast it to peers.
+    ///
+    /// ## Params
+    ///
+    /// * `transaction` - The transaction.
+    /// * `outputs_validator` - Validates the transaction outputs before entering the tx-pool. (**Optional**, default is "passthrough").
+    ///
+    /// ## Errors
+    ///
+    /// * [`PoolRejectedTransactionByOutputsValidator (-1102)`](../enum.RPCError.html#variant.PoolRejectedTransactionByOutputsValidator) - The transaction is rejected by the validator specified by `outputs_validator`. If you really want to send transactions with advanced scripts, please set `outputs_validator` to "passthrough".
+    /// * [`PoolRejectedTransactionByMinFeeRate (-1104)`](../enum.RPCError.html#variant.PoolRejectedTransactionByMinFeeRate) - The transaction fee rate must be greater than or equal to the config option `tx_pool.min_fee_rate`.
+    /// * [`PoolRejectedTransactionByMaxAncestorsCountLimit (-1105)`](../enum.RPCError.html#variant.PoolRejectedTransactionByMaxAncestorsCountLimit) - The ancestors count must be greater than or equal to the config option `tx_pool.max_ancestors_count`.
+    /// * [`PoolIsFull (-1106)`](../enum.RPCError.html#variant.PoolIsFull) - Pool is full.
+    /// * [`PoolRejectedDuplicatedTransaction (-1107)`](../enum.RPCError.html#variant.PoolRejectedDuplicatedTransaction) - The transaction is already in the pool.
+    /// * [`TransactionFailedToResolve (-301)`](../enum.RPCError.html#variant.TransactionFailedToResolve) - Failed to resolve the referenced cells and headers used in the transaction, as inputs or dependencies.
+    /// * [`TransactionFailedToVerify (-302)`](../enum.RPCError.html#variant.TransactionFailedToVerify) - Failed to verify the transaction.
+    ///
+    /// ## Examples
+    ///
+    /// Request
+    ///
+    /// ```json
+    /// {
+    ///   "id": 42,
+    ///   "jsonrpc": "2.0",
+    ///   "method": "send_test_transaction",
+    ///   "params": [
+    ///     {
+    ///       "cell_deps": [
+    ///         {
+    ///           "dep_type": "code",
+    ///           "out_point": {
+    ///             "index": "0x0",
+    ///             "tx_hash": "0xa4037a893eb48e18ed4ef61034ce26eba9c585f15c9cee102ae58505565eccc3"
+    ///           }
+    ///         }
+    ///       ],
+    ///       "header_deps": [
+    ///         "0x7978ec7ce5b507cfb52e149e36b1a23f6062ed150503c85bbf825da3599095ed"
+    ///       ],
+    ///       "inputs": [
+    ///         {
+    ///           "previous_output": {
+    ///             "index": "0x0",
+    ///             "tx_hash": "0x365698b50ca0da75dca2c87f9e7b563811d3b5813736b8cc62cc3b106faceb17"
+    ///           },
+    ///           "since": "0x0"
+    ///         }
+    ///       ],
+    ///       "outputs": [
+    ///         {
+    ///           "capacity": "0x2540be400",
+    ///           "lock": {
+    ///             "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
+    ///             "hash_type": "data",
+    ///             "args": "0x"
+    ///           },
+    ///           "type": null
+    ///         }
+    ///       ],
+    ///       "outputs_data": [
+    ///         "0x"
+    ///       ],
+    ///       "version": "0x0",
+    ///       "witnesses": []
+    ///     },
+    ///     "passthrough"
+    ///   ]
+    /// }
+    /// ```
+    ///
+    /// Response
+    ///
+    /// ```json
+    /// {
+    ///   "id": 42,
+    ///   "jsonrpc": "2.0",
+    ///   "result": "0xa0ef4eb5f4ceeb08a4c8524d84c5da95dce2f608e0ca2ec8091191b0f330c6e3"
+    /// }
+    /// ```
+    ///
+    #[rpc(name = "send_test_transaction")]
+    fn send_test_transaction(
+        &self,
+        tx: Transaction,
+        outputs_validator: Option<OutputsValidator>,
+    ) -> Result<H256>;
 }
 
 #[derive(Clone)]
@@ -505,6 +598,8 @@ pub(crate) struct IntegrationTestRpcImpl {
     pub network_controller: NetworkController,
     pub shared: Shared,
     pub chain: ChainController,
+    pub well_known_lock_scripts: Vec<packed::Script>,
+    pub well_known_type_scripts: Vec<packed::Script>,
 }
 
 #[async_trait]
@@ -666,6 +761,49 @@ impl IntegrationTestRpc for IntegrationTestRpcImpl {
                 .into(),
         )
     }
+
+    fn send_test_transaction(
+        &self,
+        tx: Transaction,
+        outputs_validator: Option<OutputsValidator>,
+    ) -> Result<H256> {
+        let tx: packed::Transaction = tx.into();
+        let tx: core::TransactionView = tx.into_view();
+
+        if let Err(e) = match outputs_validator {
+            None | Some(OutputsValidator::Passthrough) => Ok(()),
+            Some(OutputsValidator::WellKnownScriptsOnly) => WellKnownScriptsOnlyValidator::new(
+                self.shared.consensus(),
+                &self.well_known_lock_scripts,
+                &self.well_known_type_scripts,
+            )
+            .validate(&tx),
+        } {
+            return Err(RPCError::custom_with_data(
+                RPCError::PoolRejectedTransactionByOutputsValidator,
+                format!(
+                    "The transaction is rejected by OutputsValidator set in params[1]: {}. \
+                    Please check the related information in https://github.com/nervosnetwork/ckb/wiki/Transaction-%C2%BB-Default-Outputs-Validator",
+                    outputs_validator.unwrap_or(OutputsValidator::WellKnownScriptsOnly).json_display()
+                ),
+                e,
+            ));
+        }
+
+        let tx_pool = self.shared.tx_pool_controller();
+        let submit_tx = tx_pool.submit_local_test_tx(tx.clone());
+
+        if let Err(e) = submit_tx {
+            error!("Send submit_tx request error {}", e);
+            return Err(RPCError::ckb_internal_error(e));
+        }
+
+        let tx_hash = tx.hash();
+        match submit_tx.unwrap() {
+            Ok(_) => Ok(tx_hash.unpack()),
+            Err(reject) => Err(RPCError::from_submit_transaction_reject(&reject)),
+        }
+    }
 }
 
 impl IntegrationTestRpcImpl {
diff --git a/rpc/src/service_builder.rs b/rpc/src/service_builder.rs
index 22d49069ad..c71dea35fe 100644
--- a/rpc/src/service_builder.rs
+++ b/rpc/src/service_builder.rs
@@ -144,6 +144,8 @@ impl<'a> ServiceBuilder<'a> {
         shared: Shared,
         network_controller: NetworkController,
         chain: ChainController,
+        well_known_lock_scripts: Vec<Script>,
+        well_known_type_scripts: Vec<Script>,
     ) -> Self {
         if self.config.integration_test_enable() {
             // IntegrationTest only on Dummy PoW chain
@@ -157,6 +159,8 @@ impl<'a> ServiceBuilder<'a> {
             shared,
             network_controller,
             chain,
+            well_known_lock_scripts,
+            well_known_type_scripts,
         };
         set_rpc_module_methods!(
             self,
diff --git a/rpc/src/tests/setup.rs b/rpc/src/tests/setup.rs
index ffa9edff6c..888186fe57 100644
--- a/rpc/src/tests/setup.rs
+++ b/rpc/src/tests/setup.rs
@@ -218,6 +218,8 @@ pub(crate) fn setup_rpc_test_suite(height: u64, consensus: Option<Consensus>) ->
             shared.clone(),
             network_controller.clone(),
             chain_controller.clone(),
+            vec![],
+            vec![],
         )
         .enable_debug()
         .enable_alert(alert_verifier, alert_notifier, network_controller);
diff --git a/script/Cargo.toml b/script/Cargo.toml
index 1640f8f77f..c0a3cdcad5 100644
--- a/script/Cargo.toml
+++ b/script/Cargo.toml
@@ -22,12 +22,13 @@ ckb-traits = { path = "../traits", version = "= 0.118.0-pre" }
 byteorder = "1.3.1"
 ckb-types = { path = "../util/types", version = "= 0.118.0-pre" }
 ckb-hash = { path = "../util/hash", version = "= 0.118.0-pre" }
-ckb-vm = { version = "=0.24.9", default-features = false }
+ckb-vm = { version = "= 0.24.12", default-features = false }
 faster-hex = "0.6"
 ckb-logger = { path = "../util/logger", version = "= 0.118.0-pre", optional = true }
 serde = { version = "1.0", features = ["derive"] }
 ckb-error = { path = "../error", version = "= 0.118.0-pre" }
 ckb-chain-spec = { path = "../spec", version = "= 0.118.0-pre" }
+tokio = { version = "1.35.0", features = ["rt-multi-thread"] }
 
 [dev-dependencies]
 proptest = "1.0"
@@ -39,3 +40,5 @@ ckb-crypto = { path = "../util/crypto", version = "= 0.118.0-pre" }
 ckb-db-schema = { path = "../db-schema", version = "= 0.118.0-pre" }
 tempfile.workspace = true
 rand = "0.8.4"
+daggy = "0.8.0"
+molecule = "0.8.0"
diff --git a/script/build.rs b/script/build.rs
index b9e5a0401e..a201f38439 100644
--- a/script/build.rs
+++ b/script/build.rs
@@ -19,4 +19,5 @@ fn main() {
     if cfg!(any(feature = "asm", feature = "detect-asm")) && can_enable_asm {
         println!("cargo:rustc-cfg=has_asm");
     }
+    println!("cargo:rerun-if-changed=src");
 }
diff --git a/script/fuzz/.gitignore b/script/fuzz/.gitignore
index df51d17bb0..438a59213f 100644
--- a/script/fuzz/.gitignore
+++ b/script/fuzz/.gitignore
@@ -3,3 +3,7 @@ target
 corpus
 artifacts
 coverage
+flamegraph.svg
+perf.data
+perf.data.old
+
diff --git a/script/fuzz/Cargo.toml b/script/fuzz/Cargo.toml
index 2e69c463ff..b7c9a6ae59 100644
--- a/script/fuzz/Cargo.toml
+++ b/script/fuzz/Cargo.toml
@@ -47,3 +47,9 @@ name = "syscall_exec"
 path = "fuzz_targets/syscall_exec.rs"
 test = false
 doc = false
+
+[[bin]]
+name = "syscall_spawn"
+path = "fuzz_targets/syscall_spawn.rs"
+test = false
+doc = false
diff --git a/script/fuzz/README.md b/script/fuzz/README.md
index d4942e9120..d51f1304df 100644
--- a/script/fuzz/README.md
+++ b/script/fuzz/README.md
@@ -14,7 +14,7 @@ cargo install cargo-fuzz
 
 run fuzz test
 ```
-cargo +nightly fuzz run transaction_scripts_verifier_data1
+cargo +nightly fuzz run -j $(nproc) transaction_scripts_verifier_data1
 ```
 
 generate coverage report
diff --git a/script/fuzz/fuzz_targets/syscall_spawn.rs b/script/fuzz/fuzz_targets/syscall_spawn.rs
new file mode 100644
index 0000000000..8782bee23a
--- /dev/null
+++ b/script/fuzz/fuzz_targets/syscall_spawn.rs
@@ -0,0 +1,136 @@
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+
+use ckb_chain_spec::consensus::ConsensusBuilder;
+use ckb_script::{TransactionScriptsVerifier, TxVerifyEnv};
+use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
+use ckb_types::{
+    bytes::Bytes,
+    core::{
+        capacity_bytes,
+        cell::{CellMetaBuilder, ResolvedTransaction},
+        hardfork::{HardForks, CKB2021, CKB2023},
+        Capacity, HeaderView, ScriptHashType, TransactionBuilder, TransactionInfo,
+    },
+    h256,
+    packed::{
+        self, Byte32, CellInput, CellOutput, CellOutputBuilder, OutPoint, Script,
+        TransactionInfoBuilder, TransactionKeyBuilder,
+    },
+    prelude::*,
+};
+
+#[derive(Default, PartialEq, Eq, Clone)]
+struct MockDataLoader {}
+
+impl CellDataProvider for MockDataLoader {
+    fn get_cell_data(&self, _out_point: &OutPoint) -> Option<Bytes> {
+        None
+    }
+
+    fn get_cell_data_hash(&self, _out_point: &OutPoint) -> Option<Byte32> {
+        None
+    }
+}
+
+impl HeaderProvider for MockDataLoader {
+    fn get_header(&self, _block_hash: &Byte32) -> Option<HeaderView> {
+        None
+    }
+}
+
+impl ExtensionProvider for MockDataLoader {
+    fn get_block_extension(&self, _hash: &Byte32) -> Option<packed::Bytes> {
+        None
+    }
+}
+
+fn mock_transaction_info() -> TransactionInfo {
+    TransactionInfoBuilder::default()
+        .block_number(1u64.pack())
+        .block_epoch(0u64.pack())
+        .key(
+            TransactionKeyBuilder::default()
+                .block_hash(Byte32::zero())
+                .index(1u32.pack())
+                .build(),
+        )
+        .build()
+        .unpack()
+}
+
+static PROGRAM_DATA: &[u8] = include_bytes!("../../testdata/spawn_fuzzing");
+
+fn run(data: &[u8]) {
+    if data.len() < 8 {
+        return;
+    }
+    let split_offset = data[0] as usize;
+    let split_offset = usize::min(split_offset, data.len() - 1);
+    let parent_witness = Bytes::copy_from_slice(&data[0..split_offset]);
+    let child_witness = Bytes::copy_from_slice(&data[split_offset..]);
+    let witnesses = vec![parent_witness.pack(), child_witness.pack()];
+
+    let transaction = TransactionBuilder::default()
+        .input(CellInput::new(OutPoint::null(), 0))
+        .set_witnesses(witnesses)
+        .build();
+
+    let data: Bytes = (Vec::from(PROGRAM_DATA)).into();
+    let script = Script::new_builder()
+        .hash_type(ScriptHashType::Data2.into())
+        .code_hash(CellOutput::calc_data_hash(&data))
+        .build();
+    let dep_cell = CellMetaBuilder::from_cell_output(
+        CellOutput::new_builder()
+            .capacity(Capacity::bytes(data.len()).unwrap().pack())
+            .build(),
+        data,
+    )
+    .transaction_info(mock_transaction_info())
+    .out_point(OutPoint::new(h256!("0x0").pack(), 0))
+    .build();
+
+    let input_cell = CellMetaBuilder::from_cell_output(
+        CellOutputBuilder::default()
+            .capacity(capacity_bytes!(100).pack())
+            .lock(script)
+            .build(),
+        Bytes::new(),
+    )
+    .transaction_info(mock_transaction_info())
+    .build();
+
+    let rtx = ResolvedTransaction {
+        transaction,
+        resolved_cell_deps: vec![dep_cell],
+        resolved_inputs: vec![input_cell],
+        resolved_dep_groups: vec![],
+    };
+
+    let provider = MockDataLoader {};
+    let hardfork_switch = HardForks {
+        ckb2021: CKB2021::new_mirana().as_builder().build().unwrap(),
+        ckb2023: CKB2023::new_mirana()
+            .as_builder()
+            .rfc_0049(0)
+            .build()
+            .unwrap(),
+    };
+    let consensus = ConsensusBuilder::default()
+        .hardfork_switch(hardfork_switch)
+        .build();
+    let tx_verify_env =
+        TxVerifyEnv::new_submit(&HeaderView::new_advanced_builder().epoch(0.pack()).build());
+    let verifier = TransactionScriptsVerifier::new(
+        rtx.into(),
+        provider,
+        consensus.into(),
+        tx_verify_env.into(),
+    );
+    let _ = verifier.verify(70_000_000);
+}
+
+fuzz_target!(|data: &[u8]| {
+    run(data);
+});
diff --git a/script/fuzz/programs/exec_caller.c b/script/fuzz/programs/exec_caller.c
index 2f68f1a20f..7403a6b7ee 100644
--- a/script/fuzz/programs/exec_caller.c
+++ b/script/fuzz/programs/exec_caller.c
@@ -1,3 +1,4 @@
+#include <stdlib.h>
 #include <stdint.h>
 
 static inline long __internal_syscall(long n, long _a0, long _a1, long _a2,
diff --git a/script/src/lib.rs b/script/src/lib.rs
index 7f73ca7ee6..e979f3e411 100644
--- a/script/src/lib.rs
+++ b/script/src/lib.rs
@@ -1,6 +1,7 @@
 //! CKB component to run the type/lock scripts.
 pub mod cost_model;
 mod error;
+mod scheduler;
 mod syscalls;
 mod type_id;
 mod types;
@@ -8,10 +9,10 @@ mod verify;
 mod verify_env;
 
 pub use crate::error::{ScriptError, TransactionScriptError};
-pub use crate::syscalls::spawn::update_caller_machine;
+pub use crate::scheduler::{Scheduler, ROOT_VM_ID};
 pub use crate::types::{
-    CoreMachine, MachineContext, ResumableMachine, ScriptGroup, ScriptGroupType, ScriptVersion,
-    TransactionSnapshot, TransactionState, VerifyResult, VmIsa, VmVersion,
+    ChunkCommand, CoreMachine, DataPieceId, RunMode, ScriptGroup, ScriptGroupType, ScriptVersion,
+    TransactionSnapshot, TransactionState, TxData, VerifyResult, VmIsa, VmState, VmVersion,
 };
 pub use crate::verify::{TransactionScriptsSyscallsGenerator, TransactionScriptsVerifier};
 pub use crate::verify_env::TxVerifyEnv;
diff --git a/script/src/scheduler.rs b/script/src/scheduler.rs
new file mode 100644
index 0000000000..3c93c0ee82
--- /dev/null
+++ b/script/src/scheduler.rs
@@ -0,0 +1,812 @@
+use crate::cost_model::transferred_byte_cycles;
+use crate::syscalls::{
+    INVALID_FD, MAX_FDS_CREATED, MAX_VMS_SPAWNED, OTHER_END_CLOSED, SPAWN_EXTRA_CYCLES_BASE,
+    SUCCESS, WAIT_FAILURE,
+};
+use crate::types::MachineContext;
+use crate::verify::TransactionScriptsSyscallsGenerator;
+use crate::ScriptVersion;
+
+use crate::types::{
+    CoreMachineType, DataPieceId, Fd, FdArgs, FullSuspendedState, Machine, Message, ReadState,
+    RunMode, TxData, VmId, VmState, WriteState, FIRST_FD_SLOT, FIRST_VM_ID,
+};
+use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
+use ckb_types::core::Cycle;
+use ckb_vm::snapshot2::Snapshot2Context;
+use ckb_vm::{
+    bytes::Bytes,
+    cost_model::estimate_cycles,
+    elf::parse_elf,
+    machine::{CoreMachine, DefaultMachineBuilder, Pause, SupportMachine},
+    memory::Memory,
+    registers::A0,
+    snapshot2::Snapshot2,
+    Error, Register,
+};
+use std::collections::{BTreeMap, HashMap};
+use std::sync::{Arc, Mutex};
+
+/// Root process's id.
+pub const ROOT_VM_ID: VmId = FIRST_VM_ID;
+/// The maximum number of VMs that can be created at the same time.
+pub const MAX_VMS_COUNT: u64 = 16;
+/// The maximum number of instantiated VMs.
+pub const MAX_INSTANTIATED_VMS: usize = 4;
+/// The maximum number of fds.
+pub const MAX_FDS: u64 = 64;
+
+/// A single Scheduler instance is used to verify a single script
+/// within a CKB transaction.
+///
+/// A scheduler holds & manipulates a core, the scheduler also holds
+/// all CKB-VM machines, each CKB-VM machine also gets a mutable reference
+/// of the core for IO operations.
+pub struct Scheduler<DL>
+where
+    DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
+{
+    /// Context data for current running transaction & script.
+    pub tx_data: TxData<DL>,
+    /// In fact, Scheduler here has the potential to totally replace
+    /// TransactionScriptsVerifier, nonetheless much of current syscall
+    /// implementation is strictly tied to TransactionScriptsVerifier, we
+    /// are using it here to save some extra code.
+    pub script_version: ScriptVersion,
+    /// Generate system calls.
+    pub syscalls_generator: TransactionScriptsSyscallsGenerator<DL>,
+
+    /// Total cycles.
+    pub total_cycles: Cycle,
+    /// Current iteration cycles. This value is periodically added to
+    /// total_cycles and cleared
+    pub current_iteration_cycles: Cycle,
+    /// Next vm id used by spawn.
+    pub next_vm_id: VmId,
+    /// Next fd used by pipe.
+    pub next_fd_slot: u64,
+    /// Used to store VM state.
+    pub states: BTreeMap<VmId, VmState>,
+    /// Used to confirm the owner of fd.
+    pub fds: BTreeMap<Fd, VmId>,
+    /// Verify the VM's inherited fd list.
+    pub inherited_fd: BTreeMap<VmId, Vec<Fd>>,
+    /// Instantiated vms.
+    pub instantiated: BTreeMap<VmId, (MachineContext<DL>, Machine)>,
+    /// Suspended vms.
+    pub suspended: BTreeMap<VmId, Snapshot2<DataPieceId>>,
+    /// Terminated vms.
+    pub terminated_vms: BTreeMap<VmId, i8>,
+
+    /// MessageBox is expected to be empty before returning from `run`
+    /// function, there is no need to persist messages.
+    pub message_box: Arc<Mutex<Vec<Message>>>,
+}
+
+impl<DL> Scheduler<DL>
+where
+    DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
+{
+    /// Create a new scheduler from empty state
+    pub fn new(
+        tx_data: TxData<DL>,
+        script_version: ScriptVersion,
+        syscalls_generator: TransactionScriptsSyscallsGenerator<DL>,
+    ) -> Self {
+        let message_box = Arc::clone(&syscalls_generator.message_box);
+        Self {
+            tx_data,
+            script_version,
+            syscalls_generator,
+            total_cycles: 0,
+            current_iteration_cycles: 0,
+            next_vm_id: FIRST_VM_ID,
+            next_fd_slot: FIRST_FD_SLOT,
+            states: BTreeMap::default(),
+            fds: BTreeMap::default(),
+            inherited_fd: BTreeMap::default(),
+            instantiated: BTreeMap::default(),
+            suspended: BTreeMap::default(),
+            message_box,
+            terminated_vms: BTreeMap::default(),
+        }
+    }
+
+    /// Return total cycles.
+    pub fn consumed_cycles(&self) -> Cycle {
+        self.total_cycles
+    }
+
+    /// Add cycles to total cycles.
+    pub fn consumed_cycles_add(&mut self, cycles: Cycle) -> Result<(), Error> {
+        self.total_cycles = self
+            .total_cycles
+            .checked_add(cycles)
+            .ok_or(Error::CyclesExceeded)?;
+        Ok(())
+    }
+
+    /// Resume a previously suspended scheduler state
+    pub fn resume(
+        tx_data: TxData<DL>,
+        script_version: ScriptVersion,
+        syscalls_generator: TransactionScriptsSyscallsGenerator<DL>,
+        full: FullSuspendedState,
+    ) -> Self {
+        let message_box = Arc::clone(&syscalls_generator.message_box);
+        let mut scheduler = Self {
+            tx_data,
+            script_version,
+            syscalls_generator,
+            total_cycles: full.total_cycles,
+            current_iteration_cycles: 0,
+            next_vm_id: full.next_vm_id,
+            next_fd_slot: full.next_fd_slot,
+            states: full
+                .vms
+                .iter()
+                .map(|(id, state, _)| (*id, state.clone()))
+                .collect(),
+            fds: full.fds.into_iter().collect(),
+            inherited_fd: full.inherited_fd.into_iter().collect(),
+            instantiated: BTreeMap::default(),
+            suspended: full
+                .vms
+                .into_iter()
+                .map(|(id, _, snapshot)| (id, snapshot))
+                .collect(),
+            message_box,
+            terminated_vms: full.terminated_vms.into_iter().collect(),
+        };
+        scheduler
+            .ensure_vms_instantiated(&full.instantiated_ids)
+            .unwrap();
+        scheduler
+    }
+
+    /// Suspend current scheduler into a serializable full state
+    pub fn suspend(mut self) -> Result<FullSuspendedState, Error> {
+        assert!(self.message_box.lock().expect("lock").is_empty());
+        let mut vms = Vec::with_capacity(self.states.len());
+        let instantiated_ids: Vec<_> = self.instantiated.keys().cloned().collect();
+        for id in &instantiated_ids {
+            self.suspend_vm(id)?;
+        }
+        for (id, state) in self.states {
+            let snapshot = self
+                .suspended
+                .remove(&id)
+                .ok_or_else(|| Error::Unexpected("Unable to find VM Id".to_string()))?;
+            vms.push((id, state, snapshot));
+        }
+        Ok(FullSuspendedState {
+            total_cycles: self.total_cycles,
+            next_vm_id: self.next_vm_id,
+            next_fd_slot: self.next_fd_slot,
+            vms,
+            fds: self.fds.into_iter().collect(),
+            inherited_fd: self.inherited_fd.into_iter().collect(),
+            terminated_vms: self.terminated_vms.into_iter().collect(),
+            instantiated_ids,
+        })
+    }
+
+    /// This is the only entrypoint for running the scheduler,
+    /// both newly created instance and resumed instance are supported.
+    /// It accepts 2 run mode, one can either limit the cycles to execute,
+    /// or use a pause signal to trigger termination.
+    ///
+    /// Only when the execution terminates without VM errors, will this
+    /// function return an exit code(could still be non-zero) and total
+    /// consumed cycles.
+    ///
+    /// Err would be returned in the following cases:
+    /// * Cycle limit reached, the returned error would be ckb_vm::Error::CyclesExceeded,
+    /// * Pause trigger, the returned error would be ckb_vm::Error::Pause,
+    /// * Other terminating errors
+    pub fn run(&mut self, mode: RunMode) -> Result<(i8, Cycle), Error> {
+        if self.states.is_empty() {
+            // Booting phase, we will need to initialize the first VM.
+            assert_eq!(
+                self.boot_vm(&DataPieceId::Program, 0, u64::max_value(), &[])?,
+                ROOT_VM_ID
+            );
+        }
+        assert!(self.states.contains_key(&ROOT_VM_ID));
+
+        let (pause, mut limit_cycles) = match mode {
+            RunMode::LimitCycles(limit_cycles) => (Pause::new(), limit_cycles),
+            RunMode::Pause(pause) => (pause, u64::max_value()),
+        };
+
+        while self.states[&ROOT_VM_ID] != VmState::Terminated {
+            self.current_iteration_cycles = 0;
+            let iterate_return = self.iterate(pause.clone(), limit_cycles);
+            self.consumed_cycles_add(self.current_iteration_cycles)?;
+            limit_cycles = limit_cycles
+                .checked_sub(self.current_iteration_cycles)
+                .ok_or(Error::CyclesExceeded)?;
+            iterate_return?;
+        }
+
+        // At this point, root VM cannot be suspended
+        let root_vm = &self.instantiated[&ROOT_VM_ID];
+        Ok((root_vm.1.machine.exit_code(), self.total_cycles))
+    }
+
+    /// Returns the machine that needs to be executed in the current iterate.
+    pub fn iterate_prepare_machine(
+        &mut self,
+        pause: Pause,
+        limit_cycles: Cycle,
+    ) -> Result<(u64, &mut Machine), Error> {
+        // Process all pending VM reads & writes.
+        self.process_io()?;
+        // Find a runnable VM that has the largest ID.
+        let vm_id_to_run = self
+            .states
+            .iter()
+            .rev()
+            .filter(|(_, state)| matches!(state, VmState::Runnable))
+            .map(|(id, _)| *id)
+            .next();
+        let vm_id_to_run = vm_id_to_run.ok_or_else(|| {
+            Error::Unexpected("A deadlock situation has been reached!".to_string())
+        })?;
+        let total_cycles = self.total_cycles;
+        let (context, machine) = self.ensure_get_instantiated(&vm_id_to_run)?;
+        context.set_base_cycles(total_cycles);
+        machine.set_max_cycles(limit_cycles);
+        machine.machine.set_pause(pause);
+        Ok((vm_id_to_run, machine))
+    }
+
+    /// Process machine execution results in the current iterate.
+    pub fn iterate_process_results(
+        &mut self,
+        vm_id_to_run: u64,
+        result: Result<i8, Error>,
+        cycles: u64,
+    ) -> Result<(), Error> {
+        self.current_iteration_cycles = self
+            .current_iteration_cycles
+            .checked_add(cycles)
+            .ok_or(Error::CyclesOverflow)?;
+        // Process message box, update VM states accordingly
+        self.process_message_box()?;
+        assert!(self.message_box.lock().expect("lock").is_empty());
+        // If the VM terminates, update VMs in join state, also closes its fds
+        match result {
+            Ok(code) => {
+                self.terminated_vms.insert(vm_id_to_run, code);
+                // When root VM terminates, the execution stops immediately, we will purge
+                // all non-root VMs, and only keep root VM in states.
+                // When non-root VM terminates, we only purge the VM's own states.
+                if vm_id_to_run == ROOT_VM_ID {
+                    self.ensure_vms_instantiated(&[vm_id_to_run])?;
+                    self.instantiated.retain(|id, _| *id == vm_id_to_run);
+                    self.suspended.clear();
+                    self.states.clear();
+                    self.states.insert(vm_id_to_run, VmState::Terminated);
+                } else {
+                    let joining_vms: Vec<(VmId, u64)> = self
+                        .states
+                        .iter()
+                        .filter_map(|(vm_id, state)| match state {
+                            VmState::Wait {
+                                target_vm_id,
+                                exit_code_addr,
+                            } if *target_vm_id == vm_id_to_run => Some((*vm_id, *exit_code_addr)),
+                            _ => None,
+                        })
+                        .collect();
+                    // For all joining VMs, update exit code, then mark them as
+                    // runnable state.
+                    for (vm_id, exit_code_addr) in joining_vms {
+                        let (_, machine) = self.ensure_get_instantiated(&vm_id)?;
+                        machine
+                            .machine
+                            .memory_mut()
+                            .store8(&exit_code_addr, &u64::from_i8(code))?;
+                        machine.machine.set_register(A0, SUCCESS as u64);
+                        self.states.insert(vm_id, VmState::Runnable);
+                    }
+                    // Close fds
+                    self.fds.retain(|_, vm_id| *vm_id != vm_id_to_run);
+                    // Clear terminated VM states
+                    self.states.remove(&vm_id_to_run);
+                    self.instantiated.remove(&vm_id_to_run);
+                    self.suspended.remove(&vm_id_to_run);
+                }
+                Ok(())
+            }
+            Err(Error::Yield) => Ok(()),
+            Err(e) => Err(e),
+        }
+    }
+
+    // This is internal function that does the actual VM execution loop.
+    // Here both pause signal and limit_cycles are provided so as to simplify
+    // branches.
+    fn iterate(&mut self, pause: Pause, limit_cycles: Cycle) -> Result<(), Error> {
+        let (id, vm) = self.iterate_prepare_machine(pause, limit_cycles)?;
+        let result = vm.run();
+        let cycles = vm.machine.cycles();
+        vm.machine.set_cycles(0);
+        self.iterate_process_results(id, result, cycles)
+    }
+
+    fn process_message_box(&mut self) -> Result<(), Error> {
+        let messages: Vec<Message> = self.message_box.lock().expect("lock").drain(..).collect();
+        for message in messages {
+            match message {
+                Message::Spawn(vm_id, args) => {
+                    // All fds must belong to the correct owner
+                    if args.fds.iter().any(|fd| self.fds.get(fd) != Some(&vm_id)) {
+                        let (_, machine) = self.ensure_get_instantiated(&vm_id)?;
+                        machine.machine.set_register(A0, INVALID_FD as u64);
+                        continue;
+                    }
+                    if self.suspended.len() + self.instantiated.len() > MAX_VMS_COUNT as usize {
+                        let (_, machine) = self.ensure_get_instantiated(&vm_id)?;
+                        machine.machine.set_register(A0, MAX_VMS_SPAWNED as u64);
+                        continue;
+                    }
+                    let spawned_vm_id =
+                        self.boot_vm(&args.data_piece_id, args.offset, args.length, &args.argv)?;
+                    // Move passed fds from spawner to spawnee
+                    for fd in &args.fds {
+                        self.fds.insert(*fd, spawned_vm_id);
+                    }
+                    // Here we keep the original version of file descriptors.
+                    // If one fd is moved afterward, this inherited file descriptors doesn't change.
+                    self.inherited_fd.insert(spawned_vm_id, args.fds.clone());
+
+                    let (_, machine) = self.ensure_get_instantiated(&vm_id)?;
+                    machine
+                        .machine
+                        .memory_mut()
+                        .store64(&args.process_id_addr, &spawned_vm_id)?;
+                    machine.machine.set_register(A0, SUCCESS as u64);
+                }
+                Message::Wait(vm_id, args) => {
+                    if let Some(exit_code) = self.terminated_vms.get(&args.target_id).copied() {
+                        let (_, machine) = self.ensure_get_instantiated(&vm_id)?;
+                        machine
+                            .machine
+                            .memory_mut()
+                            .store8(&args.exit_code_addr, &u64::from_i8(exit_code))?;
+                        machine.machine.set_register(A0, SUCCESS as u64);
+                        self.states.insert(vm_id, VmState::Runnable);
+                        self.terminated_vms.retain(|id, _| id != &args.target_id);
+                        continue;
+                    }
+                    if !self.states.contains_key(&args.target_id) {
+                        let (_, machine) = self.ensure_get_instantiated(&vm_id)?;
+                        machine.machine.set_register(A0, WAIT_FAILURE as u64);
+                        continue;
+                    }
+                    // Return code will be updated when the joining VM exits
+                    self.states.insert(
+                        vm_id,
+                        VmState::Wait {
+                            target_vm_id: args.target_id,
+                            exit_code_addr: args.exit_code_addr,
+                        },
+                    );
+                }
+                Message::Pipe(vm_id, args) => {
+                    if self.fds.len() as u64 >= MAX_FDS {
+                        let (_, machine) = self.ensure_get_instantiated(&vm_id)?;
+                        machine.machine.set_register(A0, MAX_FDS_CREATED as u64);
+                        continue;
+                    }
+                    let (p1, p2, slot) = Fd::create(self.next_fd_slot);
+                    self.next_fd_slot = slot;
+                    self.fds.insert(p1, vm_id);
+                    self.fds.insert(p2, vm_id);
+                    let (_, machine) = self.ensure_get_instantiated(&vm_id)?;
+                    machine
+                        .machine
+                        .memory_mut()
+                        .store64(&args.fd1_addr, &p1.0)?;
+                    machine
+                        .machine
+                        .memory_mut()
+                        .store64(&args.fd2_addr, &p2.0)?;
+                    machine.machine.set_register(A0, SUCCESS as u64);
+                }
+                Message::FdRead(vm_id, args) => {
+                    if !(self.fds.contains_key(&args.fd) && (self.fds[&args.fd] == vm_id)) {
+                        let (_, machine) = self.ensure_get_instantiated(&vm_id)?;
+                        machine.machine.set_register(A0, INVALID_FD as u64);
+                        continue;
+                    }
+                    if !self.fds.contains_key(&args.fd.other_fd()) {
+                        let (_, machine) = self.ensure_get_instantiated(&vm_id)?;
+                        machine.machine.set_register(A0, OTHER_END_CLOSED as u64);
+                        continue;
+                    }
+                    // Return code will be updated when the read operation finishes
+                    self.states.insert(
+                        vm_id,
+                        VmState::WaitForRead(ReadState {
+                            fd: args.fd,
+                            length: args.length,
+                            buffer_addr: args.buffer_addr,
+                            length_addr: args.length_addr,
+                        }),
+                    );
+                }
+                Message::FdWrite(vm_id, args) => {
+                    if !(self.fds.contains_key(&args.fd) && (self.fds[&args.fd] == vm_id)) {
+                        let (_, machine) = self.ensure_get_instantiated(&vm_id)?;
+                        machine.machine.set_register(A0, INVALID_FD as u64);
+                        continue;
+                    }
+                    if !self.fds.contains_key(&args.fd.other_fd()) {
+                        let (_, machine) = self.ensure_get_instantiated(&vm_id)?;
+                        machine.machine.set_register(A0, OTHER_END_CLOSED as u64);
+                        continue;
+                    }
+                    // Return code will be updated when the write operation finishes
+                    self.states.insert(
+                        vm_id,
+                        VmState::WaitForWrite(WriteState {
+                            fd: args.fd,
+                            consumed: 0,
+                            length: args.length,
+                            buffer_addr: args.buffer_addr,
+                            length_addr: args.length_addr,
+                        }),
+                    );
+                }
+                Message::InheritedFileDescriptor(vm_id, args) => {
+                    let inherited_fd = self.inherited_fd[&vm_id].clone();
+                    let (_, machine) = self.ensure_get_instantiated(&vm_id)?;
+                    let FdArgs {
+                        buffer_addr,
+                        length_addr,
+                        ..
+                    } = args;
+                    let full_length = machine
+                        .machine
+                        .inner_mut()
+                        .memory_mut()
+                        .load64(&length_addr)?;
+                    let real_length = inherited_fd.len() as u64;
+                    let copy_length = u64::min(full_length, real_length);
+                    for i in 0..copy_length {
+                        let fd = inherited_fd[i as usize].0;
+                        let addr = buffer_addr.checked_add(i * 8).ok_or(Error::MemOutOfBound)?;
+                        machine
+                            .machine
+                            .inner_mut()
+                            .memory_mut()
+                            .store64(&addr, &fd)?;
+                    }
+                    machine
+                        .machine
+                        .inner_mut()
+                        .memory_mut()
+                        .store64(&length_addr, &real_length)?;
+                    machine.machine.set_register(A0, SUCCESS as u64);
+                }
+                Message::Close(vm_id, fd) => {
+                    if self.fds.get(&fd) != Some(&vm_id) {
+                        let (_, machine) = self.ensure_get_instantiated(&vm_id)?;
+                        machine.machine.set_register(A0, INVALID_FD as u64);
+                    } else {
+                        self.fds.remove(&fd);
+                        let (_, machine) = self.ensure_get_instantiated(&vm_id)?;
+                        machine.machine.set_register(A0, SUCCESS as u64);
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn process_io(&mut self) -> Result<(), Error> {
+        let mut reads: HashMap<Fd, (VmId, ReadState)> = HashMap::default();
+        let mut closed_fds: Vec<VmId> = Vec::new();
+        self.states.iter().for_each(|(vm_id, state)| {
+            if let VmState::WaitForRead(inner_state) = state {
+                if self.fds.contains_key(&inner_state.fd.other_fd()) {
+                    reads.insert(inner_state.fd, (*vm_id, inner_state.clone()));
+                } else {
+                    closed_fds.push(*vm_id);
+                }
+            }
+        });
+        let mut pairs: Vec<(VmId, ReadState, VmId, WriteState)> = Vec::new();
+        self.states.iter().for_each(|(vm_id, state)| {
+            if let VmState::WaitForWrite(inner_state) = state {
+                if self.fds.contains_key(&inner_state.fd.other_fd()) {
+                    if let Some((read_vm_id, read_state)) = reads.get(&inner_state.fd.other_fd()) {
+                        pairs.push((*read_vm_id, read_state.clone(), *vm_id, inner_state.clone()));
+                    }
+                } else {
+                    closed_fds.push(*vm_id);
+                }
+            }
+        });
+        // Finish read / write syscalls for fds that are closed on the other end
+        for vm_id in closed_fds {
+            match self.states[&vm_id].clone() {
+                VmState::WaitForRead(ReadState { length_addr, .. }) => {
+                    let (_, machine) = self.ensure_get_instantiated(&vm_id)?;
+                    machine.machine.memory_mut().store64(&length_addr, &0)?;
+                    machine.machine.set_register(A0, SUCCESS as u64);
+                    self.states.insert(vm_id, VmState::Runnable);
+                }
+                VmState::WaitForWrite(WriteState {
+                    consumed,
+                    length_addr,
+                    ..
+                }) => {
+                    let (_, machine) = self.ensure_get_instantiated(&vm_id)?;
+                    machine
+                        .machine
+                        .memory_mut()
+                        .store64(&length_addr, &consumed)?;
+                    machine.machine.set_register(A0, SUCCESS as u64);
+                    self.states.insert(vm_id, VmState::Runnable);
+                }
+                _ => (),
+            }
+        }
+        // Transfering data from write fds to read fds
+        for (read_vm_id, read_state, write_vm_id, write_state) in pairs {
+            let ReadState {
+                length: read_length,
+                buffer_addr: read_buffer_addr,
+                length_addr: read_length_addr,
+                ..
+            } = read_state;
+            let WriteState {
+                fd: write_fd,
+                mut consumed,
+                length: write_length,
+                buffer_addr: write_buffer_addr,
+                length_addr: write_length_addr,
+            } = write_state;
+
+            self.ensure_vms_instantiated(&[read_vm_id, write_vm_id])?;
+            {
+                let fillable = read_length;
+                let consumable = write_length - consumed;
+                let copiable = std::cmp::min(fillable, consumable);
+
+                // Actual data copying
+                let (_, write_machine) = self
+                    .instantiated
+                    .get_mut(&write_vm_id)
+                    .ok_or_else(|| Error::Unexpected("Unable to find VM Id".to_string()))?;
+                write_machine
+                    .machine
+                    .add_cycles_no_checking(transferred_byte_cycles(copiable))?;
+                let data = write_machine
+                    .machine
+                    .memory_mut()
+                    .load_bytes(write_buffer_addr.wrapping_add(consumed), copiable)?;
+                let (_, read_machine) = self
+                    .instantiated
+                    .get_mut(&read_vm_id)
+                    .ok_or_else(|| Error::Unexpected("Unable to find VM Id".to_string()))?;
+                read_machine
+                    .machine
+                    .add_cycles_no_checking(transferred_byte_cycles(copiable))?;
+                read_machine
+                    .machine
+                    .memory_mut()
+                    .store_bytes(read_buffer_addr, &data)?;
+                // Read syscall terminates as soon as some data are filled
+                read_machine
+                    .machine
+                    .memory_mut()
+                    .store64(&read_length_addr, &copiable)?;
+                read_machine.machine.set_register(A0, SUCCESS as u64);
+                self.states.insert(read_vm_id, VmState::Runnable);
+
+                // Write syscall, however, terminates only when all the data
+                // have been written, or when the pairing read fd is closed.
+                consumed += copiable;
+                if consumed == write_length {
+                    // Write VM has fulfilled its write request
+                    let (_, write_machine) = self
+                        .instantiated
+                        .get_mut(&write_vm_id)
+                        .ok_or_else(|| Error::Unexpected("Unable to find VM Id".to_string()))?;
+                    write_machine
+                        .machine
+                        .memory_mut()
+                        .store64(&write_length_addr, &write_length)?;
+                    write_machine.machine.set_register(A0, SUCCESS as u64);
+                    self.states.insert(write_vm_id, VmState::Runnable);
+                } else {
+                    // Only update write VM state
+                    self.states.insert(
+                        write_vm_id,
+                        VmState::WaitForWrite(WriteState {
+                            fd: write_fd,
+                            consumed,
+                            length: write_length,
+                            buffer_addr: write_buffer_addr,
+                            length_addr: write_length_addr,
+                        }),
+                    );
+                }
+            }
+        }
+        Ok(())
+    }
+
+    // Ensure VMs are instantiated
+    fn ensure_vms_instantiated(&mut self, ids: &[VmId]) -> Result<(), Error> {
+        if ids.len() > MAX_INSTANTIATED_VMS {
+            return Err(Error::Unexpected(format!(
+                "At most {} VMs can be instantiated but {} are requested!",
+                MAX_INSTANTIATED_VMS,
+                ids.len()
+            )));
+        }
+
+        let mut uninstantiated_ids: Vec<VmId> = ids
+            .iter()
+            .filter(|id| !self.instantiated.contains_key(id))
+            .copied()
+            .collect();
+        while (!uninstantiated_ids.is_empty()) && (self.instantiated.len() < MAX_INSTANTIATED_VMS) {
+            let id = uninstantiated_ids
+                .pop()
+                .ok_or_else(|| Error::Unexpected("Map should not be empty".to_string()))?;
+            self.resume_vm(&id)?;
+        }
+
+        if !uninstantiated_ids.is_empty() {
+            // Instantiated is a BTreeMap, an iterator on it maintains key order to ensure deterministic behavior
+            let suspendable_ids: Vec<VmId> = self
+                .instantiated
+                .keys()
+                .filter(|id| !ids.contains(id))
+                .copied()
+                .collect();
+
+            assert!(suspendable_ids.len() >= uninstantiated_ids.len());
+            for i in 0..uninstantiated_ids.len() {
+                self.suspend_vm(&suspendable_ids[i])?;
+                self.resume_vm(&uninstantiated_ids[i])?;
+            }
+        }
+
+        Ok(())
+    }
+
+    // Ensure corresponding VM is instantiated and return a mutable reference to it
+    fn ensure_get_instantiated(
+        &mut self,
+        id: &VmId,
+    ) -> Result<&mut (MachineContext<DL>, Machine), Error> {
+        self.ensure_vms_instantiated(&[*id])?;
+        self.instantiated
+            .get_mut(id)
+            .ok_or_else(|| Error::Unexpected("Unable to find VM Id".to_string()))
+    }
+
+    // Resume a suspended VM
+    fn resume_vm(&mut self, id: &VmId) -> Result<(), Error> {
+        if !self.suspended.contains_key(id) {
+            return Err(Error::Unexpected(format!("VM {:?} is not suspended!", id)));
+        }
+        let snapshot = &self.suspended[id];
+        self.current_iteration_cycles = self
+            .current_iteration_cycles
+            .checked_add(SPAWN_EXTRA_CYCLES_BASE)
+            .ok_or(Error::CyclesExceeded)?;
+        let (context, mut machine) = self.create_dummy_vm(id)?;
+        {
+            let mut sc = context.snapshot2_context().lock().expect("lock");
+            sc.resume(&mut machine.machine, snapshot)?;
+        }
+        self.instantiated.insert(*id, (context, machine));
+        self.suspended.remove(id);
+        Ok(())
+    }
+
+    // Suspend an instantiated VM
+    fn suspend_vm(&mut self, id: &VmId) -> Result<(), Error> {
+        if !self.instantiated.contains_key(id) {
+            return Err(Error::Unexpected(format!(
+                "VM {:?} is not instantiated!",
+                id
+            )));
+        }
+        self.current_iteration_cycles = self
+            .current_iteration_cycles
+            .checked_add(SPAWN_EXTRA_CYCLES_BASE)
+            .ok_or(Error::CyclesExceeded)?;
+        let (context, machine) = self
+            .instantiated
+            .get_mut(id)
+            .ok_or_else(|| Error::Unexpected("Unable to find VM Id".to_string()))?;
+        let snapshot = {
+            let sc = context.snapshot2_context().lock().expect("lock");
+            sc.make_snapshot(&mut machine.machine)?
+        };
+        self.suspended.insert(*id, snapshot);
+        self.instantiated.remove(id);
+        Ok(())
+    }
+
+    /// Boot a vm by given program and args.
+    pub fn boot_vm(
+        &mut self,
+        data_piece_id: &DataPieceId,
+        offset: u64,
+        length: u64,
+        args: &[Bytes],
+    ) -> Result<VmId, Error> {
+        // Newly booted VM will be instantiated by default
+        while self.instantiated.len() >= MAX_INSTANTIATED_VMS {
+            // Instantiated is a BTreeMap, first_entry will maintain key order
+            let id = *self
+                .instantiated
+                .first_entry()
+                .ok_or_else(|| Error::Unexpected("Map should not be empty".to_string()))?
+                .key();
+            self.suspend_vm(&id)?;
+        }
+
+        let id = self.next_vm_id;
+        self.next_vm_id += 1;
+        let (context, mut machine) = self.create_dummy_vm(&id)?;
+        {
+            let mut sc = context.snapshot2_context().lock().expect("lock");
+            let (program, _) = sc.load_data(data_piece_id, offset, length)?;
+            let metadata = parse_elf::<u64>(&program, machine.machine.version())?;
+            let bytes = machine.load_program_with_metadata(&program, &metadata, args)?;
+            sc.mark_program(&mut machine.machine, &metadata, data_piece_id, offset)?;
+            machine
+                .machine
+                .add_cycles_no_checking(transferred_byte_cycles(bytes))?;
+        }
+        self.instantiated.insert(id, (context, machine));
+        self.states.insert(id, VmState::Runnable);
+
+        Ok(id)
+    }
+
+    // Create a new VM instance with syscalls attached
+    fn create_dummy_vm(&self, id: &VmId) -> Result<(MachineContext<DL>, Machine), Error> {
+        // The code here looks slightly weird, since I don't want to copy over all syscall
+        // impls here again. Ideally, this scheduler package should be merged with ckb-script,
+        // or simply replace ckb-script. That way, the quirks here will be eliminated.
+        let version = self.script_version;
+        let core_machine = CoreMachineType::new(
+            version.vm_isa(),
+            version.vm_version(),
+            // We will update max_cycles for each machine when it gets a chance to run
+            u64::max_value(),
+        );
+        let snapshot2_context = Arc::new(Mutex::new(Snapshot2Context::new(self.tx_data.clone())));
+        let mut syscalls_generator = self.syscalls_generator.clone();
+        syscalls_generator.vm_id = *id;
+        let mut machine_context = MachineContext::new(self.tx_data.clone());
+        machine_context.base_cycles = Arc::clone(&self.syscalls_generator.base_cycles);
+        machine_context.snapshot2_context = Arc::clone(&snapshot2_context);
+
+        let machine_builder = DefaultMachineBuilder::new(core_machine)
+            .instruction_cycle_func(Box::new(estimate_cycles));
+        let machine_builder = syscalls_generator
+            .generate_syscalls(
+                version,
+                &self.tx_data.script_group,
+                Arc::clone(&snapshot2_context),
+            )
+            .into_iter()
+            .fold(machine_builder, |builder, syscall| builder.syscall(syscall));
+        let default_machine = machine_builder.build();
+        Ok((machine_context, Machine::new(default_machine)))
+    }
+}
diff --git a/script/src/syscalls/close.rs b/script/src/syscalls/close.rs
new file mode 100644
index 0000000000..1e359095be
--- /dev/null
+++ b/script/src/syscalls/close.rs
@@ -0,0 +1,38 @@
+use crate::syscalls::{CLOSE, SPAWN_YIELD_CYCLES_BASE};
+use crate::types::{Fd, Message, VmId};
+use ckb_vm::{
+    registers::{A0, A7},
+    Error as VMError, Register, SupportMachine, Syscalls,
+};
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug)]
+pub struct Close {
+    id: VmId,
+    message_box: Arc<Mutex<Vec<Message>>>,
+}
+
+impl Close {
+    pub fn new(id: VmId, message_box: Arc<Mutex<Vec<Message>>>) -> Self {
+        Self { id, message_box }
+    }
+}
+
+impl<Mac: SupportMachine> Syscalls<Mac> for Close {
+    fn initialize(&mut self, _machine: &mut Mac) -> Result<(), VMError> {
+        Ok(())
+    }
+
+    fn ecall(&mut self, machine: &mut Mac) -> Result<bool, VMError> {
+        if machine.registers()[A7].to_u64() != CLOSE {
+            return Ok(false);
+        }
+        let fd = Fd(machine.registers()[A0].to_u64());
+        machine.add_cycles_no_checking(SPAWN_YIELD_CYCLES_BASE)?;
+        self.message_box
+            .lock()
+            .map_err(|e| VMError::Unexpected(e.to_string()))?
+            .push(Message::Close(self.id, fd));
+        Err(VMError::Yield)
+    }
+}
diff --git a/script/src/syscalls/current_cycles.rs b/script/src/syscalls/current_cycles.rs
index dc87cd281c..a791cef7a4 100644
--- a/script/src/syscalls/current_cycles.rs
+++ b/script/src/syscalls/current_cycles.rs
@@ -3,14 +3,15 @@ use ckb_vm::{
     registers::{A0, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
 };
+use std::sync::{Arc, Mutex};
 
 #[derive(Debug, Default)]
 pub struct CurrentCycles {
-    base: u64,
+    base: Arc<Mutex<u64>>,
 }
 
 impl CurrentCycles {
-    pub fn new(base: u64) -> Self {
+    pub fn new(base: Arc<Mutex<u64>>) -> Self {
         Self { base }
     }
 }
@@ -26,6 +27,8 @@ impl<Mac: SupportMachine> Syscalls<Mac> for CurrentCycles {
         }
         let cycles = self
             .base
+            .lock()
+            .map_err(|e| VMError::Unexpected(e.to_string()))?
             .checked_add(machine.cycles())
             .ok_or(VMError::CyclesOverflow)?;
         machine.set_register(A0, Mac::REG::from_u64(cycles));
diff --git a/script/src/syscalls/exec.rs b/script/src/syscalls/exec.rs
index 2c33a52165..6eb1d159c4 100644
--- a/script/src/syscalls/exec.rs
+++ b/script/src/syscalls/exec.rs
@@ -22,6 +22,7 @@ pub struct Exec<DL> {
     outputs: Arc<Vec<CellMeta>>,
     group_inputs: Indices,
     group_outputs: Indices,
+    load_elf_base_fee: u64,
 }
 
 impl<DL: CellDataProvider> Exec<DL> {
@@ -31,6 +32,7 @@ impl<DL: CellDataProvider> Exec<DL> {
         outputs: Arc<Vec<CellMeta>>,
         group_inputs: Indices,
         group_outputs: Indices,
+        load_elf_base_fee: u64,
     ) -> Exec<DL> {
         Exec {
             data_loader,
@@ -38,6 +40,7 @@ impl<DL: CellDataProvider> Exec<DL> {
             outputs,
             group_inputs,
             group_outputs,
+            load_elf_base_fee,
         }
     }
 
@@ -109,7 +112,6 @@ impl<Mac: SupportMachine, DL: CellDataProvider + Send + Sync> Syscalls<Mac> for
         if machine.registers()[A7].to_u64() != EXEC {
             return Ok(false);
         }
-
         let index = machine.registers()[A0].to_u64();
         let source = Source::parse_from_u64(machine.registers()[A1].to_u64())?;
         let place = Place::parse_from_u64(machine.registers()[A2].to_u64())?;
@@ -176,6 +178,7 @@ impl<Mac: SupportMachine, DL: CellDataProvider + Send + Sync> Syscalls<Mac> for
         machine.reset(max_cycles);
         machine.set_cycles(cycles);
 
+        machine.add_cycles_no_checking(self.load_elf_base_fee)?;
         match machine.load_elf(&data, true) {
             Ok(size) => {
                 machine.add_cycles_no_checking(transferred_byte_cycles(size))?;
diff --git a/script/src/syscalls/get_memory_limit.rs b/script/src/syscalls/get_memory_limit.rs
deleted file mode 100644
index 7b28887ce1..0000000000
--- a/script/src/syscalls/get_memory_limit.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use crate::syscalls::GET_MEMORY_LIMIT;
-use ckb_vm::{
-    registers::{A0, A7},
-    Error as VMError, Register, SupportMachine, Syscalls,
-};
-
-#[derive(Debug)]
-pub struct GetMemoryLimit {
-    memory_limit: u64,
-}
-
-impl GetMemoryLimit {
-    pub fn new(memory_limit: u64) -> Self {
-        Self { memory_limit }
-    }
-}
-
-impl<Mac: SupportMachine> Syscalls<Mac> for GetMemoryLimit {
-    fn initialize(&mut self, _machine: &mut Mac) -> Result<(), VMError> {
-        Ok(())
-    }
-
-    fn ecall(&mut self, machine: &mut Mac) -> Result<bool, VMError> {
-        if machine.registers()[A7].to_u64() != GET_MEMORY_LIMIT {
-            return Ok(false);
-        }
-        machine.set_register(A0, Mac::REG::from_u64(self.memory_limit));
-        Ok(true)
-    }
-}
diff --git a/script/src/syscalls/inherited_fd.rs b/script/src/syscalls/inherited_fd.rs
new file mode 100644
index 0000000000..4d041a0ba1
--- /dev/null
+++ b/script/src/syscalls/inherited_fd.rs
@@ -0,0 +1,47 @@
+use crate::syscalls::{INHERITED_FD, SPAWN_YIELD_CYCLES_BASE};
+use crate::types::{Fd, FdArgs, Message, VmId};
+use ckb_vm::{
+    registers::{A0, A1, A7},
+    Error as VMError, Register, SupportMachine, Syscalls,
+};
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug)]
+pub struct InheritedFd {
+    id: VmId,
+    message_box: Arc<Mutex<Vec<Message>>>,
+}
+
+impl InheritedFd {
+    pub fn new(id: VmId, message_box: Arc<Mutex<Vec<Message>>>) -> Self {
+        Self { id, message_box }
+    }
+}
+
+impl<Mac: SupportMachine> Syscalls<Mac> for InheritedFd {
+    fn initialize(&mut self, _machine: &mut Mac) -> Result<(), VMError> {
+        Ok(())
+    }
+
+    fn ecall(&mut self, machine: &mut Mac) -> Result<bool, VMError> {
+        if machine.registers()[A7].to_u64() != INHERITED_FD {
+            return Ok(false);
+        }
+        let buffer_addr = machine.registers()[A0].to_u64();
+        let length_addr = machine.registers()[A1].to_u64();
+        machine.add_cycles_no_checking(SPAWN_YIELD_CYCLES_BASE)?;
+        self.message_box
+            .lock()
+            .map_err(|e| VMError::Unexpected(e.to_string()))?
+            .push(Message::InheritedFileDescriptor(
+                self.id,
+                FdArgs {
+                    fd: Fd(0),
+                    length: 0,
+                    buffer_addr,
+                    length_addr,
+                },
+            ));
+        Err(VMError::Yield)
+    }
+}
diff --git a/script/src/syscalls/load_cell_data.rs b/script/src/syscalls/load_cell_data.rs
index 11adfadca7..3abe9b35b2 100644
--- a/script/src/syscalls/load_cell_data.rs
+++ b/script/src/syscalls/load_cell_data.rs
@@ -1,85 +1,101 @@
-use crate::types::Indices;
+use crate::types::{DataPieceId, TxData};
 use crate::{
     cost_model::transferred_byte_cycles,
     syscalls::{
-        utils::store_data, Source, SourceEntry, INDEX_OUT_OF_BOUND,
-        LOAD_CELL_DATA_AS_CODE_SYSCALL_NUMBER, LOAD_CELL_DATA_SYSCALL_NUMBER, SLICE_OUT_OF_BOUND,
+        Source, INDEX_OUT_OF_BOUND, LOAD_CELL_DATA_AS_CODE_SYSCALL_NUMBER,
+        LOAD_CELL_DATA_SYSCALL_NUMBER, SLICE_OUT_OF_BOUND, SOURCE_ENTRY_MASK, SOURCE_GROUP_FLAG,
         SUCCESS,
     },
 };
-use ckb_traits::CellDataProvider;
-use ckb_types::core::cell::{CellMeta, ResolvedTransaction};
+use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_vm::{
     memory::{Memory, FLAG_EXECUTABLE, FLAG_FREEZED},
     registers::{A0, A1, A2, A3, A4, A5, A7},
-    Error as VMError, Register, SupportMachine, Syscalls,
+    snapshot2::Snapshot2Context,
+    Bytes, Error as VMError, Register, SupportMachine, Syscalls,
 };
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 
-pub struct LoadCellData<DL> {
-    data_loader: DL,
-    rtx: Arc<ResolvedTransaction>,
-    outputs: Arc<Vec<CellMeta>>,
-    group_inputs: Indices,
-    group_outputs: Indices,
+pub struct LoadCellData<DL>
+where
+    DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
+{
+    snapshot2_context: Arc<Mutex<Snapshot2Context<DataPieceId, TxData<DL>>>>,
 }
 
-impl<DL: CellDataProvider> LoadCellData<DL> {
+impl<DL> LoadCellData<DL>
+where
+    DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
+{
     pub fn new(
-        data_loader: DL,
-        rtx: Arc<ResolvedTransaction>,
-        outputs: Arc<Vec<CellMeta>>,
-        group_inputs: Indices,
-        group_outputs: Indices,
+        snapshot2_context: Arc<Mutex<Snapshot2Context<DataPieceId, TxData<DL>>>>,
     ) -> LoadCellData<DL> {
-        LoadCellData {
-            data_loader,
-            rtx,
-            outputs,
-            group_inputs,
-            group_outputs,
-        }
-    }
-
-    #[inline]
-    fn resolved_inputs(&self) -> &Vec<CellMeta> {
-        &self.rtx.resolved_inputs
+        LoadCellData { snapshot2_context }
     }
 
-    #[inline]
-    fn resolved_cell_deps(&self) -> &Vec<CellMeta> {
-        &self.rtx.resolved_cell_deps
-    }
+    fn load_data<Mac: SupportMachine>(&self, machine: &mut Mac) -> Result<(), VMError> {
+        let index = machine.registers()[A3].to_u64();
+        let mut source = machine.registers()[A4].to_u64();
+        // To keep compatible with the old behavior. When Source is wrong, a
+        // Vm internal error should be returned.
+        if let Source::Group(_) = Source::parse_from_u64(source)? {
+            source = source & SOURCE_ENTRY_MASK | SOURCE_GROUP_FLAG;
+        } else {
+            source &= SOURCE_ENTRY_MASK;
+        }
+        let data_piece_id = match DataPieceId::try_from((source, index, 0)) {
+            Ok(id) => id,
+            Err(_) => {
+                machine.set_register(A0, Mac::REG::from_u8(INDEX_OUT_OF_BOUND));
+                return Ok(());
+            }
+        };
+        let addr = machine.registers()[A0].to_u64();
+        let size_addr = machine.registers()[A1].clone();
+        let offset = machine.registers()[A2].to_u64();
+        let mut sc = self
+            .snapshot2_context
+            .lock()
+            .map_err(|e| VMError::Unexpected(e.to_string()))?;
 
-    fn fetch_cell(&self, source: Source, index: usize) -> Result<&CellMeta, u8> {
-        match source {
-            Source::Transaction(SourceEntry::Input) => {
-                self.resolved_inputs().get(index).ok_or(INDEX_OUT_OF_BOUND)
+        match sc.load_data(&data_piece_id, offset, u64::max_value()) {
+            Ok((cell, _)) => {
+                let size = machine.memory_mut().load64(&size_addr)?.to_u64();
+                if size == 0 {
+                    machine
+                        .memory_mut()
+                        .store64(&size_addr, &Mac::REG::from_u64(cell.len() as u64))?;
+                    machine.set_register(A0, Mac::REG::from_u8(SUCCESS));
+                    return Ok(());
+                }
+                let (wrote_size, _) = match sc.store_bytes(
+                    machine,
+                    addr,
+                    &data_piece_id,
+                    offset,
+                    size,
+                    size_addr.to_u64(),
+                ) {
+                    Ok(val) => val,
+                    Err(VMError::SnapshotDataLoadError) => {
+                        // This comes from TxData results in an out of bound error, to
+                        // mimic current behavior, we would return INDEX_OUT_OF_BOUND error.
+                        machine.set_register(A0, Mac::REG::from_u8(INDEX_OUT_OF_BOUND));
+                        return Ok(());
+                    }
+                    Err(e) => return Err(e),
+                };
+                machine.add_cycles_no_checking(transferred_byte_cycles(wrote_size))?;
+                machine.set_register(A0, Mac::REG::from_u8(SUCCESS));
+                return Ok(());
             }
-            Source::Transaction(SourceEntry::Output) => {
-                self.outputs.get(index).ok_or(INDEX_OUT_OF_BOUND)
+            Err(VMError::SnapshotDataLoadError) => {
+                // This comes from TxData results in an out of bound error, to
+                // mimic current behavior, we would return INDEX_OUT_OF_BOUND error.
+                machine.set_register(A0, Mac::REG::from_u8(INDEX_OUT_OF_BOUND));
+                return Ok(());
             }
-            Source::Transaction(SourceEntry::CellDep) => self
-                .resolved_cell_deps()
-                .get(index)
-                .ok_or(INDEX_OUT_OF_BOUND),
-            Source::Transaction(SourceEntry::HeaderDep) => Err(INDEX_OUT_OF_BOUND),
-            Source::Group(SourceEntry::Input) => self
-                .group_inputs
-                .get(index)
-                .ok_or(INDEX_OUT_OF_BOUND)
-                .and_then(|actual_index| {
-                    self.resolved_inputs()
-                        .get(*actual_index)
-                        .ok_or(INDEX_OUT_OF_BOUND)
-                }),
-            Source::Group(SourceEntry::Output) => self
-                .group_outputs
-                .get(index)
-                .ok_or(INDEX_OUT_OF_BOUND)
-                .and_then(|actual_index| self.outputs.get(*actual_index).ok_or(INDEX_OUT_OF_BOUND)),
-            Source::Group(SourceEntry::CellDep) => Err(INDEX_OUT_OF_BOUND),
-            Source::Group(SourceEntry::HeaderDep) => Err(INDEX_OUT_OF_BOUND),
+            Err(e) => return Err(e),
         }
     }
 
@@ -88,75 +104,73 @@ impl<DL: CellDataProvider> LoadCellData<DL> {
         let memory_size = machine.registers()[A1].to_u64();
         let content_offset = machine.registers()[A2].to_u64();
         let content_size = machine.registers()[A3].to_u64();
-
         let index = machine.registers()[A4].to_u64();
-        let source = Source::parse_from_u64(machine.registers()[A5].to_u64())?;
-
-        let cell = self.fetch_cell(source, index as usize);
-        if let Err(err) = cell {
-            machine.set_register(A0, Mac::REG::from_u8(err));
-            return Ok(());
+        let mut source = machine.registers()[A5].to_u64();
+        // To keep compatible with the old behavior. When Source is wrong, a
+        // Vm internal error should be returned.
+        if let Source::Group(_) = Source::parse_from_u64(source)? {
+            source = source & SOURCE_ENTRY_MASK | SOURCE_GROUP_FLAG;
+        } else {
+            source &= SOURCE_ENTRY_MASK;
         }
-        let cell = cell.unwrap();
-
+        let data_piece_id = match DataPieceId::try_from((source, index, 0)) {
+            Ok(id) => id,
+            Err(_) => {
+                machine.set_register(A0, Mac::REG::from_u8(INDEX_OUT_OF_BOUND));
+                return Ok(());
+            }
+        };
+        let mut sc = self
+            .snapshot2_context
+            .lock()
+            .map_err(|e| VMError::Unexpected(e.to_string()))?;
+        // We are using 0..u64::max_value() to fetch full cell, there is
+        // also no need to keep the full length value. Since cell's length
+        // is already full length.
+        let (cell, _) = match sc.load_data(&data_piece_id, 0, u64::max_value()) {
+            Ok(val) => {
+                if content_size == 0 {
+                    (Bytes::new(), val.1)
+                } else {
+                    val
+                }
+            }
+            Err(VMError::SnapshotDataLoadError) => {
+                // This comes from TxData results in an out of bound error, to
+                // mimic current behavior, we would return INDEX_OUT_OF_BOUND error.
+                machine.set_register(A0, Mac::REG::from_u8(INDEX_OUT_OF_BOUND));
+                return Ok(());
+            }
+            Err(e) => return Err(e),
+        };
         let content_end = content_offset
             .checked_add(content_size)
             .ok_or(VMError::MemOutOfBound)?;
-        if content_offset >= cell.data_bytes
-            || content_end > cell.data_bytes
+        if content_offset >= cell.len() as u64
+            || content_end > cell.len() as u64
             || content_size > memory_size
         {
             machine.set_register(A0, Mac::REG::from_u8(SLICE_OUT_OF_BOUND));
             return Ok(());
         }
-        let data = self
-            .data_loader
-            .load_cell_data(cell)
-            .ok_or_else(|| {
-                VMError::Unexpected(format!(
-                    "Unexpected load_cell_data failed {}",
-                    cell.out_point,
-                ))
-            })?
-            .slice((content_offset as usize)..(content_end as usize));
         machine.memory_mut().init_pages(
             addr,
             memory_size,
             FLAG_EXECUTABLE | FLAG_FREEZED,
-            Some(data),
+            Some(cell.slice((content_offset as usize)..(content_end as usize))),
             0,
         )?;
-
+        sc.track_pages(machine, addr, memory_size, &data_piece_id, content_offset)?;
         machine.add_cycles_no_checking(transferred_byte_cycles(memory_size))?;
         machine.set_register(A0, Mac::REG::from_u8(SUCCESS));
         Ok(())
     }
-
-    fn load_data<Mac: SupportMachine>(&self, machine: &mut Mac) -> Result<(), VMError> {
-        let index = machine.registers()[A3].to_u64();
-        let source = Source::parse_from_u64(machine.registers()[A4].to_u64())?;
-
-        let cell = self.fetch_cell(source, index as usize);
-        if let Err(err) = cell {
-            machine.set_register(A0, Mac::REG::from_u8(err));
-            return Ok(());
-        }
-        let cell = cell.unwrap();
-        let data = self.data_loader.load_cell_data(cell).ok_or_else(|| {
-            VMError::Unexpected(format!(
-                "Unexpected load_cell_data failed {}",
-                cell.out_point,
-            ))
-        })?;
-
-        let wrote_size = store_data(machine, &data)?;
-        machine.add_cycles_no_checking(transferred_byte_cycles(wrote_size))?;
-        machine.set_register(A0, Mac::REG::from_u8(SUCCESS));
-        Ok(())
-    }
 }
 
-impl<Mac: SupportMachine, DL: CellDataProvider + Send + Sync> Syscalls<Mac> for LoadCellData<DL> {
+impl<Mac: SupportMachine, DL> Syscalls<Mac> for LoadCellData<DL>
+where
+    DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
+{
     fn initialize(&mut self, _machine: &mut Mac) -> Result<(), VMError> {
         Ok(())
     }
diff --git a/script/src/syscalls/mod.rs b/script/src/syscalls/mod.rs
index ed0f5fc839..4e09f8968e 100644
--- a/script/src/syscalls/mod.rs
+++ b/script/src/syscalls/mod.rs
@@ -1,8 +1,8 @@
+mod close;
 mod current_cycles;
-mod current_memory;
 mod debugger;
 mod exec;
-mod get_memory_limit;
+mod inherited_fd;
 mod load_block_extension;
 mod load_cell;
 mod load_cell_data;
@@ -12,10 +12,14 @@ mod load_script;
 mod load_script_hash;
 mod load_tx;
 mod load_witness;
-mod set_content;
+mod pipe;
+mod process_id;
+mod read;
 pub(crate) mod spawn;
 mod utils;
 mod vm_version;
+mod wait;
+mod write;
 
 #[cfg(test)]
 mod pause;
@@ -23,11 +27,11 @@ mod pause;
 #[cfg(test)]
 mod tests;
 
+pub use self::close::Close;
 pub use self::current_cycles::CurrentCycles;
-pub use self::current_memory::CurrentMemory;
 pub use self::debugger::Debugger;
 pub use self::exec::Exec;
-pub use self::get_memory_limit::GetMemoryLimit;
+pub use self::inherited_fd::InheritedFd;
 pub use self::load_block_extension::LoadBlockExtension;
 pub use self::load_cell::LoadCell;
 pub use self::load_cell_data::LoadCellData;
@@ -37,9 +41,13 @@ pub use self::load_script::LoadScript;
 pub use self::load_script_hash::LoadScriptHash;
 pub use self::load_tx::LoadTx;
 pub use self::load_witness::LoadWitness;
-pub use self::set_content::SetContent;
+pub use self::pipe::Pipe;
+pub use self::process_id::ProcessID;
+pub use self::read::Read;
 pub use self::spawn::Spawn;
 pub use self::vm_version::VMVersion;
+pub use self::wait::Wait;
+pub use self::write::Write;
 
 #[cfg(test)]
 pub use self::pause::Pause;
@@ -55,9 +63,11 @@ pub const INDEX_OUT_OF_BOUND: u8 = 1;
 pub const ITEM_MISSING: u8 = 2;
 pub const SLICE_OUT_OF_BOUND: u8 = 3;
 pub const WRONG_FORMAT: u8 = 4;
-pub const SPAWN_EXCEEDED_MAX_CONTENT_LENGTH: u8 = 5;
-pub const SPAWN_WRONG_MEMORY_LIMIT: u8 = 6;
-pub const SPAWN_EXCEEDED_MAX_PEAK_MEMORY: u8 = 7;
+pub const WAIT_FAILURE: u8 = 5;
+pub const INVALID_FD: u8 = 6;
+pub const OTHER_END_CLOSED: u8 = 7;
+pub const MAX_VMS_SPAWNED: u8 = 8;
+pub const MAX_FDS_CREATED: u8 = 9;
 
 pub const VM_VERSION: u64 = 2041;
 pub const CURRENT_CYCLES: u64 = 2042;
@@ -75,21 +85,22 @@ pub const LOAD_HEADER_BY_FIELD_SYSCALL_NUMBER: u64 = 2082;
 pub const LOAD_INPUT_BY_FIELD_SYSCALL_NUMBER: u64 = 2083;
 pub const LOAD_CELL_DATA_AS_CODE_SYSCALL_NUMBER: u64 = 2091;
 pub const LOAD_CELL_DATA_SYSCALL_NUMBER: u64 = 2092;
-pub const SPAWN: u64 = 2101;
-pub const GET_MEMORY_LIMIT: u64 = 2102;
-pub const SET_CONTENT: u64 = 2103;
 pub const LOAD_BLOCK_EXTENSION: u64 = 2104;
-pub const CURRENT_MEMORY: u64 = 2105;
+pub const SPAWN: u64 = 2601;
+pub const WAIT: u64 = 2602;
+pub const PROCESS_ID: u64 = 2603;
+pub const PIPE: u64 = 2604;
+pub const WRITE: u64 = 2605;
+pub const READ: u64 = 2606;
+pub const INHERITED_FD: u64 = 2607;
+pub const CLOSE: u64 = 2608;
 pub const DEBUG_PRINT_SYSCALL_NUMBER: u64 = 2177;
 #[cfg(test)]
 pub const DEBUG_PAUSE: u64 = 2178;
 
-pub const SPAWN_MAX_MEMORY: u64 = 8;
-pub const SPAWN_MAX_PEAK_MEMORY: u64 = 64; // 64 * 0.5M = 32M
-pub const SPAWN_MEMORY_PAGE_SIZE: u64 = 512 * 1024; // 0.5M
-pub const SPAWN_MAX_CONTENT_LENGTH: u64 = 256 * 1024; // 256K
+pub const EXEC_LOAD_ELF_V2_CYCLES_BASE: u64 = 75_000;
 pub const SPAWN_EXTRA_CYCLES_BASE: u64 = 100_000;
-pub const SPAWN_EXTRA_CYCLES_PER_MEMORY_PAGE: u64 = 8192;
+pub const SPAWN_YIELD_CYCLES_BASE: u64 = 800;
 
 #[derive(Debug, PartialEq, Clone, Copy, Eq)]
 enum CellField {
diff --git a/script/src/syscalls/pause.rs b/script/src/syscalls/pause.rs
index 48044fe013..1de3401bdc 100644
--- a/script/src/syscalls/pause.rs
+++ b/script/src/syscalls/pause.rs
@@ -28,6 +28,12 @@ impl<Mac: SupportMachine> Syscalls<Mac> for Pause {
         if self.skip.load(Ordering::SeqCst) {
             return Ok(true);
         }
-        Err(VMError::CyclesExceeded)
+        // Note(yukang): this syscall is used for tests and debugging,
+        // old verify and tests logic use VMInternalError::CyclesExceeded as a flag to Suspend,
+        // in new verify VMInternalError::CycleExceeded is used to indicate cycles exceeded error only,
+        // VMInternalError::Pause is used to indicate the script execution should be paused.
+        // To keep compatibility with old tests, we should change to use VMInternalError::Pause
+        // and use VMInternalError::CyclesExceeded | VMInternalError::Pause as a flag to Suspend in tests code.
+        Err(VMError::Pause)
     }
 }
diff --git a/script/src/syscalls/pipe.rs b/script/src/syscalls/pipe.rs
new file mode 100644
index 0000000000..3bb61ba22d
--- /dev/null
+++ b/script/src/syscalls/pipe.rs
@@ -0,0 +1,39 @@
+use crate::syscalls::{PIPE, SPAWN_YIELD_CYCLES_BASE};
+use crate::types::{Message, PipeArgs, VmId};
+use ckb_vm::{
+    registers::{A0, A7},
+    Error as VMError, Register, SupportMachine, Syscalls,
+};
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug)]
+pub struct Pipe {
+    id: VmId,
+    message_box: Arc<Mutex<Vec<Message>>>,
+}
+
+impl Pipe {
+    pub fn new(id: VmId, message_box: Arc<Mutex<Vec<Message>>>) -> Self {
+        Self { id, message_box }
+    }
+}
+
+impl<Mac: SupportMachine> Syscalls<Mac> for Pipe {
+    fn initialize(&mut self, _machine: &mut Mac) -> Result<(), VMError> {
+        Ok(())
+    }
+
+    fn ecall(&mut self, machine: &mut Mac) -> Result<bool, VMError> {
+        if machine.registers()[A7].to_u64() != PIPE {
+            return Ok(false);
+        }
+        let fd1_addr = machine.registers()[A0].to_u64();
+        let fd2_addr = fd1_addr.wrapping_add(8);
+        machine.add_cycles_no_checking(SPAWN_YIELD_CYCLES_BASE)?;
+        self.message_box
+            .lock()
+            .map_err(|e| VMError::Unexpected(e.to_string()))?
+            .push(Message::Pipe(self.id, PipeArgs { fd1_addr, fd2_addr }));
+        Err(VMError::Yield)
+    }
+}
diff --git a/script/src/syscalls/current_memory.rs b/script/src/syscalls/process_id.rs
similarity index 51%
rename from script/src/syscalls/current_memory.rs
rename to script/src/syscalls/process_id.rs
index 401d778191..55114ae18a 100644
--- a/script/src/syscalls/current_memory.rs
+++ b/script/src/syscalls/process_id.rs
@@ -1,30 +1,30 @@
-use crate::syscalls::CURRENT_MEMORY;
+use crate::syscalls::PROCESS_ID;
 use ckb_vm::{
     registers::{A0, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
 };
 
 #[derive(Debug, Default)]
-pub struct CurrentMemory {
-    value: u64,
+pub struct ProcessID {
+    id: u64,
 }
 
-impl CurrentMemory {
-    pub fn new(value: u64) -> Self {
-        Self { value }
+impl ProcessID {
+    pub fn new(id: u64) -> Self {
+        Self { id }
     }
 }
 
-impl<Mac: SupportMachine> Syscalls<Mac> for CurrentMemory {
+impl<Mac: SupportMachine> Syscalls<Mac> for ProcessID {
     fn initialize(&mut self, _machine: &mut Mac) -> Result<(), VMError> {
         Ok(())
     }
 
     fn ecall(&mut self, machine: &mut Mac) -> Result<bool, VMError> {
-        if machine.registers()[A7].to_u64() != CURRENT_MEMORY {
+        if machine.registers()[A7].to_u64() != PROCESS_ID {
             return Ok(false);
         }
-        machine.set_register(A0, Mac::REG::from_u64(self.value));
+        machine.set_register(A0, Mac::REG::from_u64(self.id));
         Ok(true)
     }
 }
diff --git a/script/src/syscalls/read.rs b/script/src/syscalls/read.rs
new file mode 100644
index 0000000000..63976ef096
--- /dev/null
+++ b/script/src/syscalls/read.rs
@@ -0,0 +1,59 @@
+use crate::syscalls::{INVALID_FD, READ, SPAWN_YIELD_CYCLES_BASE};
+use crate::types::{Fd, FdArgs, Message, VmId};
+use ckb_vm::{
+    registers::{A0, A1, A2, A7},
+    Error as VMError, Memory, Register, SupportMachine, Syscalls,
+};
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug)]
+pub struct Read {
+    id: VmId,
+    message_box: Arc<Mutex<Vec<Message>>>,
+}
+
+impl Read {
+    pub fn new(id: VmId, message_box: Arc<Mutex<Vec<Message>>>) -> Self {
+        Self { id, message_box }
+    }
+}
+
+impl<Mac: SupportMachine> Syscalls<Mac> for Read {
+    fn initialize(&mut self, _machine: &mut Mac) -> Result<(), VMError> {
+        Ok(())
+    }
+
+    fn ecall(&mut self, machine: &mut Mac) -> Result<bool, VMError> {
+        if machine.registers()[A7].to_u64() != READ {
+            return Ok(false);
+        }
+        let fd = Fd(machine.registers()[A0].to_u64());
+        let buffer_addr = machine.registers()[A1].to_u64();
+        let length_addr = machine.registers()[A2].to_u64();
+        let length = machine
+            .memory_mut()
+            .load64(&Mac::REG::from_u64(length_addr))?
+            .to_u64();
+
+        // We can only do basic checks here, when the message is actually processed,
+        // more complete checks will be performed.
+        if !fd.is_read() {
+            machine.set_register(A0, Mac::REG::from_u8(INVALID_FD));
+            return Ok(true);
+        }
+        machine.add_cycles_no_checking(SPAWN_YIELD_CYCLES_BASE)?;
+        self.message_box
+            .lock()
+            .map_err(|e| VMError::Unexpected(e.to_string()))?
+            .push(Message::FdRead(
+                self.id,
+                FdArgs {
+                    fd,
+                    length,
+                    buffer_addr,
+                    length_addr,
+                },
+            ));
+        Err(VMError::Yield)
+    }
+}
diff --git a/script/src/syscalls/set_content.rs b/script/src/syscalls/set_content.rs
deleted file mode 100644
index c1442c30c9..0000000000
--- a/script/src/syscalls/set_content.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-use crate::cost_model::transferred_byte_cycles;
-use crate::syscalls::utils::load_bytes;
-use crate::syscalls::SET_CONTENT;
-use ckb_vm::{
-    registers::{A0, A1, A7},
-    Error as VMError, Memory, Register, SupportMachine, Syscalls,
-};
-use std::sync::{Arc, Mutex};
-
-#[derive(Debug)]
-pub struct SetContent {
-    content: Arc<Mutex<Vec<u8>>>,
-    content_size: u64,
-}
-
-impl SetContent {
-    pub fn new(content: Arc<Mutex<Vec<u8>>>, content_size: u64) -> Self {
-        Self {
-            content,
-            content_size,
-        }
-    }
-}
-
-impl<Mac: SupportMachine> Syscalls<Mac> for SetContent {
-    fn initialize(&mut self, _machine: &mut Mac) -> Result<(), VMError> {
-        Ok(())
-    }
-
-    fn ecall(&mut self, machine: &mut Mac) -> Result<bool, VMError> {
-        if machine.registers()[A7].to_u64() != SET_CONTENT {
-            return Ok(false);
-        }
-        let content_addr = machine.registers()[A0].to_u64();
-        let request_size_addr = machine.registers()[A1].to_u64();
-        let request_size = machine
-            .memory_mut()
-            .load64(&Mac::REG::from_u64(request_size_addr))?;
-        let size = std::cmp::min(self.content_size, request_size.to_u64());
-        self.content.lock().unwrap().resize(size as usize, 0);
-        let content = load_bytes(machine, content_addr, size)?;
-        self.content.lock().unwrap().copy_from_slice(&content);
-        machine.memory_mut().store64(
-            &Mac::REG::from_u64(request_size_addr),
-            &Mac::REG::from_u64(size),
-        )?;
-        machine.add_cycles_no_checking(transferred_byte_cycles(size))?;
-        machine.set_register(A0, Mac::REG::from_u64(0));
-        Ok(true)
-    }
-}
diff --git a/script/src/syscalls/spawn.rs b/script/src/syscalls/spawn.rs
index cf6bc8dd80..ad929718f1 100644
--- a/script/src/syscalls/spawn.rs
+++ b/script/src/syscalls/spawn.rs
@@ -1,95 +1,44 @@
-use crate::cost_model::transferred_byte_cycles;
 use crate::syscalls::utils::load_c_string;
 use crate::syscalls::{
-    Source, SourceEntry, INDEX_OUT_OF_BOUND, SLICE_OUT_OF_BOUND, SPAWN,
-    SPAWN_EXCEEDED_MAX_CONTENT_LENGTH, SPAWN_EXCEEDED_MAX_PEAK_MEMORY, SPAWN_EXTRA_CYCLES_BASE,
-    SPAWN_EXTRA_CYCLES_PER_MEMORY_PAGE, SPAWN_MAX_CONTENT_LENGTH, SPAWN_MAX_MEMORY,
-    SPAWN_MAX_PEAK_MEMORY, SPAWN_MEMORY_PAGE_SIZE, SPAWN_WRONG_MEMORY_LIMIT, WRONG_FORMAT,
+    Source, INDEX_OUT_OF_BOUND, SLICE_OUT_OF_BOUND, SOURCE_ENTRY_MASK, SOURCE_GROUP_FLAG, SPAWN,
+    SPAWN_EXTRA_CYCLES_BASE, SPAWN_YIELD_CYCLES_BASE,
 };
-use crate::types::{
-    set_vm_max_cycles, CoreMachineType, Machine, MachineContext, ResumableMachine, SpawnData,
-};
-use crate::TransactionScriptsSyscallsGenerator;
-use crate::{ScriptGroup, ScriptVersion};
+use crate::types::{DataPieceId, Fd, Message, SpawnArgs, TxData, VmId};
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
-use ckb_types::core::cell::CellMeta;
 use ckb_vm::{
-    cost_model::estimate_cycles,
-    registers::{A0, A1, A2, A3, A4, A5, A7},
-    DefaultMachineBuilder, Error as VMError, Memory, Register, SupportMachine, Syscalls,
+    machine::SupportMachine,
+    memory::Memory,
+    registers::{A0, A1, A2, A3, A4, A7},
+    snapshot2::Snapshot2Context,
+    syscalls::Syscalls,
+    Error as VMError, Register,
 };
 use std::sync::{Arc, Mutex};
 
-pub struct Spawn<DL> {
-    script_group: ScriptGroup,
-    script_version: ScriptVersion,
-    syscalls_generator: TransactionScriptsSyscallsGenerator<DL>,
-    peak_memory: u64,
-    cycles_base: u64,
-    context: Arc<Mutex<MachineContext>>,
+pub struct Spawn<DL>
+where
+    DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
+{
+    id: VmId,
+    message_box: Arc<Mutex<Vec<Message>>>,
+    snapshot2_context: Arc<Mutex<Snapshot2Context<DataPieceId, TxData<DL>>>>,
 }
 
-impl<DL: CellDataProvider + Clone + HeaderProvider + Send + Sync + 'static> Spawn<DL> {
+impl<DL> Spawn<DL>
+where
+    DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
+{
     pub fn new(
-        script_group: ScriptGroup,
-        script_version: ScriptVersion,
-        syscalls_generator: TransactionScriptsSyscallsGenerator<DL>,
-        peak_memory: u64,
-        cycles_base: u64,
-        context: Arc<Mutex<MachineContext>>,
+        id: VmId,
+        message_box: Arc<Mutex<Vec<Message>>>,
+        snapshot2_context: Arc<Mutex<Snapshot2Context<DataPieceId, TxData<DL>>>>,
     ) -> Self {
         Self {
-            script_group,
-            script_version,
-            syscalls_generator,
-            peak_memory,
-            cycles_base,
-            context,
+            id,
+            message_box,
+            snapshot2_context,
         }
     }
-
-    fn data_loader(&self) -> &DL {
-        &self.syscalls_generator.data_loader
-    }
-
-    fn outputs(&self) -> &Vec<CellMeta> {
-        &self.syscalls_generator.outputs
-    }
-
-    #[inline]
-    fn resolved_inputs(&self) -> &Vec<CellMeta> {
-        &self.syscalls_generator.rtx.resolved_inputs
-    }
-
-    #[inline]
-    fn resolved_cell_deps(&self) -> &Vec<CellMeta> {
-        &self.syscalls_generator.rtx.resolved_cell_deps
-    }
-
-    fn fetch_cell(&self, source: Source, index: usize) -> Result<&CellMeta, u8> {
-        let cell_opt = match source {
-            Source::Transaction(SourceEntry::Input) => self.resolved_inputs().get(index),
-            Source::Transaction(SourceEntry::Output) => self.outputs().get(index),
-            Source::Transaction(SourceEntry::CellDep) => self.resolved_cell_deps().get(index),
-            Source::Group(SourceEntry::Input) => self
-                .script_group
-                .input_indices
-                .get(index)
-                .and_then(|actual_index| self.resolved_inputs().get(*actual_index)),
-            Source::Group(SourceEntry::Output) => self
-                .script_group
-                .output_indices
-                .get(index)
-                .and_then(|actual_index| self.outputs().get(*actual_index)),
-            Source::Transaction(SourceEntry::HeaderDep)
-            | Source::Group(SourceEntry::CellDep)
-            | Source::Group(SourceEntry::HeaderDep) => {
-                return Err(INDEX_OUT_OF_BOUND);
-            }
-        };
-
-        cell_opt.ok_or(INDEX_OUT_OF_BOUND)
-    }
 }
 
 impl<Mac, DL> Syscalls<Mac> for Spawn<DL>
@@ -105,235 +54,117 @@ where
         if machine.registers()[A7].to_u64() != SPAWN {
             return Ok(false);
         }
-        // Arguments for positioning child programs.
         let index = machine.registers()[A0].to_u64();
-        let source = Source::parse_from_u64(machine.registers()[A1].to_u64())?;
-        let bounds = machine.registers()[A2].to_u64();
-        let offset = (bounds >> 32) as usize;
-        let length = bounds as u32 as usize;
-        // Arguments for childs.
-        let argc = machine.registers()[A3].to_u64();
-        let argv_addr = machine.registers()[A4].to_u64();
-        let spgs_addr = machine.registers()[A5].to_u64();
-        let memory_limit_addr = spgs_addr;
-        let exit_code_addr_addr = spgs_addr.wrapping_add(8);
-        let content_addr_addr = spgs_addr.wrapping_add(16);
-        let content_length_addr_addr = spgs_addr.wrapping_add(24);
-        // Arguments for limiting.
-        let memory_limit = machine
-            .memory_mut()
-            .load64(&Mac::REG::from_u64(memory_limit_addr))?
-            .to_u64();
-        let cycles_limit = machine.max_cycles() - machine.cycles();
-        // Arguments for saving outputs from child programs.
-        let exit_code_addr = machine
-            .memory_mut()
-            .load64(&Mac::REG::from_u64(exit_code_addr_addr))?;
-        let content_addr = machine
-            .memory_mut()
-            .load64(&Mac::REG::from_u64(content_addr_addr))?;
-        let content_length_addr = machine
-            .memory_mut()
-            .load64(&Mac::REG::from_u64(content_length_addr_addr))?;
-        let content_length = machine.memory_mut().load64(&content_length_addr)?.to_u64();
-        // Arguments check.
-        if content_length > SPAWN_MAX_CONTENT_LENGTH {
-            machine.set_register(A0, Mac::REG::from_u8(SPAWN_EXCEEDED_MAX_CONTENT_LENGTH));
-            return Ok(true);
-        }
-        if memory_limit > SPAWN_MAX_MEMORY || memory_limit == 0 {
-            machine.set_register(A0, Mac::REG::from_u8(SPAWN_WRONG_MEMORY_LIMIT));
-            return Ok(true);
+        let mut source = machine.registers()[A1].to_u64();
+        let place = machine.registers()[A2].to_u64();
+        // To keep compatible with the old behavior. When Source is wrong, a
+        // Vm internal error should be returned.
+        if let Source::Group(_) = Source::parse_from_u64(source)? {
+            source = source & SOURCE_ENTRY_MASK | SOURCE_GROUP_FLAG;
+        } else {
+            source &= SOURCE_ENTRY_MASK;
         }
-        if self.peak_memory + memory_limit > SPAWN_MAX_PEAK_MEMORY {
-            machine.set_register(A0, Mac::REG::from_u8(SPAWN_EXCEEDED_MAX_PEAK_MEMORY));
-            return Ok(true);
-        }
-        // Build child machine.
-        let spawn_data = SpawnData {
-            callee_peak_memory: self.peak_memory + memory_limit,
-            callee_memory_limit: memory_limit,
-            content: Arc::new(Mutex::new(Vec::<u8>::new())),
-            content_length: content_length.to_u64(),
-            caller_exit_code_addr: exit_code_addr.to_u64(),
-            caller_content_addr: content_addr.to_u64(),
-            caller_content_length_addr: content_length_addr.to_u64(),
-            cycles_base: self.cycles_base + machine.cycles(),
-        };
-        let mut machine_child = build_child_machine(
-            &self.script_group,
-            self.script_version,
-            &self.syscalls_generator,
-            cycles_limit,
-            &spawn_data,
-            &self.context,
-        )?;
-        // Get binary.
-        let program = {
-            let cell = self.fetch_cell(source, index as usize);
-            if let Err(err) = cell {
-                machine.set_register(A0, Mac::REG::from_u8(err));
-                return Ok(true);
-            }
-            let cell = cell.unwrap();
-            let data = self.data_loader().load_cell_data(cell).ok_or_else(|| {
-                VMError::Unexpected(format!(
-                    "Unexpected load_cell_data failed {}",
-                    cell.out_point,
-                ))
-            })?;
-            let size = data.len();
-            if offset >= size {
-                machine.set_register(A0, Mac::REG::from_u8(SLICE_OUT_OF_BOUND));
+        let data_piece_id = match DataPieceId::try_from((source, index, place)) {
+            Ok(id) => id,
+            Err(_) => {
+                machine.set_register(A0, Mac::REG::from_u8(INDEX_OUT_OF_BOUND));
                 return Ok(true);
-            };
-            if length == 0 {
-                data.slice(offset..size)
-            } else {
-                let end = offset.checked_add(length).ok_or(VMError::MemOutOfBound)?;
-                if end > size {
-                    machine.set_register(A0, Mac::REG::from_u8(SLICE_OUT_OF_BOUND));
-                    return Ok(true);
-                }
-                data.slice(offset..end)
             }
         };
-        // Build arguments.
-        let mut addr = argv_addr.to_u64();
-        let mut argv_vec = Vec::new();
+        let bounds = machine.registers()[A3].to_u64();
+        let offset = bounds >> 32;
+        let length = bounds as u32 as u64;
+        let spgs_addr = machine.registers()[A4].to_u64();
+        let argc_addr = spgs_addr;
+        let argc = machine
+            .memory_mut()
+            .load64(&Mac::REG::from_u64(argc_addr))?
+            .to_u64();
+        let argv_addr_addr = spgs_addr.wrapping_add(8);
+        let argv_addr = machine
+            .memory_mut()
+            .load64(&Mac::REG::from_u64(argv_addr_addr))?
+            .to_u64();
+        let mut addr = argv_addr;
+        let mut argv = Vec::new();
         for _ in 0..argc {
             let target_addr = machine
                 .memory_mut()
                 .load64(&Mac::REG::from_u64(addr))?
                 .to_u64();
             let cstr = load_c_string(machine, target_addr)?;
-            argv_vec.push(cstr);
-            addr += 8;
+            argv.push(cstr);
+            addr = addr.wrapping_add(8);
         }
-        // Deduct cycles used to build the child machine
-        let extra_cycles =
-            SPAWN_EXTRA_CYCLES_BASE + memory_limit * SPAWN_EXTRA_CYCLES_PER_MEMORY_PAGE;
-        machine_child.machine.add_cycles_no_checking(extra_cycles)?;
-        // Load program into child machine.
-        match machine_child.load_program(&program, &argv_vec) {
-            Ok(size) => {
-                machine_child
-                    .machine
-                    .add_cycles_no_checking(transferred_byte_cycles(size))?;
+
+        let process_id_addr_addr = spgs_addr.wrapping_add(16);
+        let process_id_addr = machine
+            .memory_mut()
+            .load64(&Mac::REG::from_u64(process_id_addr_addr))?
+            .to_u64();
+        let fds_addr_addr = spgs_addr.wrapping_add(24);
+        let mut fds_addr = machine
+            .memory_mut()
+            .load64(&Mac::REG::from_u64(fds_addr_addr))?
+            .to_u64();
+
+        let mut fds = vec![];
+        if fds_addr != 0 {
+            loop {
+                let fd = machine
+                    .memory_mut()
+                    .load64(&Mac::REG::from_u64(fds_addr))?
+                    .to_u64();
+                if fd == 0 {
+                    break;
+                }
+                fds.push(Fd(fd));
+                fds_addr += 8;
             }
-            Err(_) => {
-                // If loading binary fails, we still need to consume extra_cycles.
-                machine.add_cycles_no_checking(extra_cycles)?;
-                machine.set_register(A0, Mac::REG::from_u8(WRONG_FORMAT));
+        }
+
+        // We are fetching the actual cell here for some in-place validation
+        let mut sc = self
+            .snapshot2_context
+            .lock()
+            .map_err(|e| VMError::Unexpected(e.to_string()))?;
+        let (_, full_length) = match sc.load_data(&data_piece_id, 0, 0) {
+            Ok(val) => val,
+            Err(VMError::SnapshotDataLoadError) => {
+                // This comes from TxData results in an out of bound error, to
+                // mimic current behavior, we would return INDEX_OUT_OF_BOUND error.
+                machine.set_register(A0, Mac::REG::from_u8(INDEX_OUT_OF_BOUND));
                 return Ok(true);
             }
+            Err(e) => return Err(e),
+        };
+        if offset >= full_length {
+            machine.set_register(A0, Mac::REG::from_u8(SLICE_OUT_OF_BOUND));
+            return Ok(true);
         }
-        // Run the child machine and check result.
-        match machine_child.run() {
-            Ok(data) => {
-                update_caller_machine(machine, data, machine_child.machine.cycles(), &spawn_data)?;
-                Ok(true)
-            }
-            Err(VMError::CyclesExceeded) => {
-                let mut context = self
-                    .context
-                    .lock()
-                    .map_err(|e| VMError::Unexpected(format!("Failed to acquire lock: {}", e)))?;
-                context
-                    .suspended_machines
-                    .push(ResumableMachine::spawn(machine_child, spawn_data));
-                Err(VMError::CyclesExceeded)
+        if length > 0 {
+            let end = offset.checked_add(length).ok_or(VMError::MemOutOfBound)?;
+            if end > full_length {
+                machine.set_register(A0, Mac::REG::from_u8(SLICE_OUT_OF_BOUND));
+                return Ok(true);
             }
-            Err(err) => Err(err),
         }
+        machine.add_cycles_no_checking(SPAWN_EXTRA_CYCLES_BASE)?;
+        machine.add_cycles_no_checking(SPAWN_YIELD_CYCLES_BASE)?;
+        self.message_box
+            .lock()
+            .map_err(|e| VMError::Unexpected(e.to_string()))?
+            .push(Message::Spawn(
+                self.id,
+                SpawnArgs {
+                    data_piece_id,
+                    offset,
+                    length,
+                    argv,
+                    fds,
+                    process_id_addr,
+                },
+            ));
+        Err(VMError::Yield)
     }
 }
-
-pub fn build_child_machine<
-    DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
->(
-    script_group: &ScriptGroup,
-    script_version: ScriptVersion,
-    syscalls_generator: &TransactionScriptsSyscallsGenerator<DL>,
-    cycles_limit: u64,
-    spawn_data: &SpawnData,
-    context: &Arc<Mutex<MachineContext>>,
-) -> Result<Machine, VMError> {
-    let SpawnData {
-        callee_peak_memory,
-        callee_memory_limit,
-        content,
-        content_length,
-        cycles_base,
-        ..
-    } = spawn_data;
-
-    let machine_isa = script_version.vm_isa();
-    let machine_version = script_version.vm_version();
-    let machine_core = CoreMachineType::new_with_memory(
-        machine_isa,
-        machine_version,
-        cycles_limit,
-        (callee_memory_limit * SPAWN_MEMORY_PAGE_SIZE) as usize,
-    );
-    let machine_builder =
-        DefaultMachineBuilder::new(machine_core).instruction_cycle_func(Box::new(estimate_cycles));
-    let machine_syscalls = syscalls_generator.generate_same_syscalls(script_version, script_group);
-    let machine_builder = machine_syscalls
-        .into_iter()
-        .fold(machine_builder, |builder, syscall| builder.syscall(syscall));
-    let machine_builder = machine_builder.syscall(Box::new(
-        syscalls_generator.build_current_cycles(*cycles_base),
-    ));
-    let machine_builder = machine_builder.syscall(Box::new(
-        syscalls_generator.build_get_memory_limit(*callee_memory_limit),
-    ));
-    let machine_builder = machine_builder.syscall(Box::new(
-        syscalls_generator.build_set_content(Arc::clone(content), *content_length),
-    ));
-    let machine_builder = machine_builder.syscall(Box::new(syscalls_generator.build_spawn(
-        script_version,
-        script_group,
-        *callee_peak_memory,
-        *cycles_base,
-        Arc::clone(context),
-    )));
-    let machine_builder = machine_builder.syscall(Box::new(
-        syscalls_generator.build_current_memory(*callee_peak_memory),
-    ));
-    let mut machine_child = Machine::new(machine_builder.build());
-    set_vm_max_cycles(&mut machine_child, cycles_limit);
-    Ok(machine_child)
-}
-
-/// Write the data generated by callee back to the caller memory space.
-pub fn update_caller_machine<Mac: SupportMachine>(
-    caller: &mut Mac,
-    callee_exit_code: i8,
-    callee_cycles: u64,
-    spawn_data: &SpawnData,
-) -> Result<(), VMError> {
-    let SpawnData {
-        content,
-        caller_exit_code_addr,
-        caller_content_addr,
-        caller_content_length_addr,
-        ..
-    } = spawn_data;
-
-    caller.set_register(A0, Mac::REG::from_u32(0));
-    caller.memory_mut().store8(
-        &Mac::REG::from_u64(*caller_exit_code_addr),
-        &Mac::REG::from_i8(callee_exit_code),
-    )?;
-    caller
-        .memory_mut()
-        .store_bytes(caller_content_addr.to_u64(), &content.lock().unwrap())?;
-    caller.memory_mut().store64(
-        &Mac::REG::from_u64(*caller_content_length_addr),
-        &Mac::REG::from_u64(content.lock().unwrap().len() as u64),
-    )?;
-    caller.add_cycles_no_checking(callee_cycles)?;
-
-    Ok(())
-}
diff --git a/script/src/syscalls/tests/vm_latest/syscalls_1.rs b/script/src/syscalls/tests/vm_latest/syscalls_1.rs
index 391320a556..761537e2ff 100644
--- a/script/src/syscalls/tests/vm_latest/syscalls_1.rs
+++ b/script/src/syscalls/tests/vm_latest/syscalls_1.rs
@@ -14,14 +14,17 @@ use ckb_types::{
 use ckb_vm::{
     memory::{FLAG_DIRTY, FLAG_EXECUTABLE, FLAG_FREEZED, FLAG_WRITABLE},
     registers::{A0, A1, A2, A3, A4, A5, A7},
+    snapshot2::Snapshot2Context,
     CoreMachine, Error as VMError, Memory, Syscalls, RISCV_PAGESIZE,
 };
 use proptest::{collection::size_range, prelude::*};
 use std::collections::HashMap;
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 
 use super::SCRIPT_VERSION;
 use crate::syscalls::{tests::utils::*, *};
+use crate::types::TxData;
+use crate::types::{ScriptGroup, ScriptGroupType};
 
 fn _test_load_cell_not_exist(data: &[u8]) -> Result<(), TestCaseError> {
     let mut machine = SCRIPT_VERSION.init_core_machine_without_limit();
@@ -1450,20 +1453,28 @@ fn _test_load_cell_data_as_code(
 
     let data = Bytes::from(data.to_owned());
     let dep_cell = build_cell_meta(10000, data.clone());
-    let output = build_cell_meta(100, data.clone());
     let input_cell = build_cell_meta(100, data.clone());
 
-    let outputs = Arc::new(vec![output]);
-    let group_inputs = Arc::new(vec![0]);
-    let group_outputs = Arc::new(vec![0]);
     let data_loader = new_mock_data_loader();
     let rtx = Arc::new(ResolvedTransaction {
-        transaction: TransactionBuilder::default().build(),
+        transaction: TransactionBuilder::default()
+            .output_data(data.pack())
+            .build(),
         resolved_cell_deps: vec![dep_cell],
         resolved_inputs: vec![input_cell],
         resolved_dep_groups: vec![],
     });
-    let mut load_code = LoadCellData::new(data_loader, rtx, outputs, group_inputs, group_outputs);
+    let mut load_code = LoadCellData::new(Arc::new(Mutex::new(Snapshot2Context::new(TxData {
+        rtx,
+        data_loader,
+        program: Bytes::new(),
+        script_group: Arc::new(ScriptGroup {
+            script: Default::default(),
+            group_type: ScriptGroupType::Lock,
+            input_indices: vec![0],
+            output_indices: vec![0],
+        }),
+    }))));
 
     prop_assert!(machine.memory_mut().store_byte(addr, addr_size, 1).is_ok());
 
@@ -1474,7 +1485,7 @@ fn _test_load_cell_data_as_code(
     } else {
         prop_assert_eq!(machine.registers()[A0], u64::from(SUCCESS));
 
-        let flags = FLAG_EXECUTABLE | FLAG_FREEZED | FLAG_DIRTY;
+        let flags = FLAG_EXECUTABLE | FLAG_FREEZED;
         prop_assert_eq!(
             machine
                 .memory_mut()
@@ -1515,21 +1526,28 @@ fn _test_load_cell_data(
 
     let data = Bytes::from(data.to_owned());
     let dep_cell = build_cell_meta(10000, data.clone());
-    let output = build_cell_meta(100, data.clone());
     let input_cell = build_cell_meta(100, data.clone());
-
-    let outputs = Arc::new(vec![output]);
-    let group_inputs = Arc::new(vec![0]);
-    let group_outputs = Arc::new(vec![0]);
     let data_loader = new_mock_data_loader();
 
     let rtx = Arc::new(ResolvedTransaction {
-        transaction: TransactionBuilder::default().build(),
+        transaction: TransactionBuilder::default()
+            .output_data(data.pack())
+            .build(),
         resolved_cell_deps: vec![dep_cell],
         resolved_inputs: vec![input_cell],
         resolved_dep_groups: vec![],
     });
-    let mut load_code = LoadCellData::new(data_loader, rtx, outputs, group_inputs, group_outputs);
+    let mut load_code = LoadCellData::new(Arc::new(Mutex::new(Snapshot2Context::new(TxData {
+        rtx,
+        data_loader,
+        program: Bytes::new(),
+        script_group: Arc::new(ScriptGroup {
+            script: Default::default(),
+            group_type: ScriptGroupType::Lock,
+            input_indices: vec![0],
+            output_indices: vec![0],
+        }),
+    }))));
 
     prop_assert!(load_code.ecall(&mut machine).is_ok());
 
@@ -1537,8 +1555,11 @@ fn _test_load_cell_data(
         prop_assert_eq!(machine.registers()[A0], u64::from(code));
     } else {
         prop_assert_eq!(machine.registers()[A0], u64::from(SUCCESS));
-
-        let flags = FLAG_WRITABLE | FLAG_DIRTY;
+        let flags = if data.len() < RISCV_PAGESIZE {
+            FLAG_WRITABLE | FLAG_DIRTY
+        } else {
+            FLAG_WRITABLE
+        };
         prop_assert_eq!(
             machine
                 .memory_mut()
@@ -1618,9 +1639,6 @@ fn test_load_overflowed_cell_data_as_code() {
     let dep_cell = build_cell_meta(10000, dep_cell_data);
 
     let data_loader = new_mock_data_loader();
-    let outputs = Arc::new(vec![]);
-    let group_inputs = Arc::new(vec![]);
-    let group_outputs = Arc::new(vec![]);
 
     let rtx = Arc::new(ResolvedTransaction {
         transaction: TransactionBuilder::default().build(),
@@ -1629,7 +1647,17 @@ fn test_load_overflowed_cell_data_as_code() {
         resolved_dep_groups: vec![],
     });
 
-    let mut load_code = LoadCellData::new(data_loader, rtx, outputs, group_inputs, group_outputs);
+    let mut load_code = LoadCellData::new(Arc::new(Mutex::new(Snapshot2Context::new(TxData {
+        rtx,
+        data_loader,
+        program: Bytes::new(),
+        script_group: Arc::new(ScriptGroup {
+            script: Default::default(),
+            group_type: ScriptGroupType::Lock,
+            input_indices: Default::default(),
+            output_indices: Default::default(),
+        }),
+    }))));
 
     assert!(machine.memory_mut().store_byte(addr, addr_size, 1).is_ok());
 
@@ -1637,7 +1665,61 @@ fn test_load_overflowed_cell_data_as_code() {
     assert_eq!(result.unwrap_err(), VMError::MemOutOfBound);
 }
 
-fn _test_load_cell_data_on_freezed_memory(as_code: bool, data: &[u8]) -> Result<(), TestCaseError> {
+fn _test_load_cell_data_on_freezed_memory(data: &[u8]) -> Result<(), TestCaseError> {
+    let mut machine = SCRIPT_VERSION.init_core_machine_without_limit();
+    let addr = 8192;
+    let addr_size = 4096;
+    let size_addr = 100;
+
+    prop_assert!(machine
+        .memory_mut()
+        .store64(&size_addr, &(data.len() as u64))
+        .is_ok());
+    prop_assert!(machine
+        .memory_mut()
+        .init_pages(addr, addr_size, FLAG_EXECUTABLE | FLAG_FREEZED, None, 0)
+        .is_ok());
+
+    machine.set_register(A0, addr); // addr
+    machine.set_register(A1, size_addr); // size
+    machine.set_register(A2, 0); // content offset
+    machine.set_register(A3, 0); //index
+    machine.set_register(A4, u64::from(Source::Transaction(SourceEntry::CellDep))); //source
+    machine.set_register(A7, LOAD_CELL_DATA_SYSCALL_NUMBER); // syscall number
+
+    let dep_cell_data = Bytes::from(data.to_owned());
+    let dep_cell = build_cell_meta(10000, dep_cell_data);
+
+    let data_loader = new_mock_data_loader();
+
+    let rtx = Arc::new(ResolvedTransaction {
+        transaction: TransactionBuilder::default().build(),
+        resolved_cell_deps: vec![dep_cell],
+        resolved_inputs: vec![],
+        resolved_dep_groups: vec![],
+    });
+
+    let mut load_code = LoadCellData::new(Arc::new(Mutex::new(Snapshot2Context::new(TxData {
+        rtx,
+        data_loader,
+        program: Bytes::new(),
+        script_group: Arc::new(ScriptGroup {
+            script: Default::default(),
+            group_type: ScriptGroupType::Lock,
+            input_indices: Default::default(),
+            output_indices: Default::default(),
+        }),
+    }))));
+
+    prop_assert!(load_code.ecall(&mut machine).is_err());
+
+    for i in addr..addr + addr_size {
+        assert_eq!(machine.memory_mut().load8(&i), Ok(0));
+    }
+    Ok(())
+}
+
+fn _test_load_cell_data_as_code_on_freezed_memory(data: &[u8]) -> Result<(), TestCaseError> {
     let mut machine = SCRIPT_VERSION.init_core_machine_without_limit();
     let addr = 8192;
     let addr_size = 4096;
@@ -1653,20 +1735,12 @@ fn _test_load_cell_data_on_freezed_memory(as_code: bool, data: &[u8]) -> Result<
     machine.set_register(A3, data.len() as u64); // content size
     machine.set_register(A4, 0); //index
     machine.set_register(A5, u64::from(Source::Transaction(SourceEntry::CellDep))); //source
-    let syscall = if as_code {
-        LOAD_CELL_DATA_AS_CODE_SYSCALL_NUMBER
-    } else {
-        LOAD_CELL_DATA_SYSCALL_NUMBER
-    };
-    machine.set_register(A7, syscall); // syscall number
+    machine.set_register(A7, LOAD_CELL_DATA_AS_CODE_SYSCALL_NUMBER); // syscall number
 
     let dep_cell_data = Bytes::from(data.to_owned());
     let dep_cell = build_cell_meta(10000, dep_cell_data);
 
     let data_loader = new_mock_data_loader();
-    let outputs = Arc::new(vec![]);
-    let group_inputs = Arc::new(vec![]);
-    let group_outputs = Arc::new(vec![]);
 
     let rtx = Arc::new(ResolvedTransaction {
         transaction: TransactionBuilder::default().build(),
@@ -1675,7 +1749,17 @@ fn _test_load_cell_data_on_freezed_memory(as_code: bool, data: &[u8]) -> Result<
         resolved_dep_groups: vec![],
     });
 
-    let mut load_code = LoadCellData::new(data_loader, rtx, outputs, group_inputs, group_outputs);
+    let mut load_code = LoadCellData::new(Arc::new(Mutex::new(Snapshot2Context::new(TxData {
+        rtx,
+        data_loader,
+        program: Bytes::new(),
+        script_group: Arc::new(ScriptGroup {
+            script: Default::default(),
+            group_type: ScriptGroupType::Lock,
+            input_indices: Default::default(),
+            output_indices: Default::default(),
+        }),
+    }))));
 
     prop_assert!(load_code.ecall(&mut machine).is_err());
 
@@ -1691,12 +1775,12 @@ proptest! {
     })]
     #[test]
     fn test_load_code_on_freezed_memory(ref data in any_with::<Vec<u8>>(size_range(4096).lift())) {
-        _test_load_cell_data_on_freezed_memory(true, data)?;
+        _test_load_cell_data_as_code_on_freezed_memory(data)?;
     }
 
     #[test]
     fn test_load_data_on_freezed_memory(ref data in any_with::<Vec<u8>>(size_range(4096).lift())) {
-        _test_load_cell_data_on_freezed_memory(false, data)?;
+        _test_load_cell_data_on_freezed_memory(data)?;
     }
 }
 
@@ -1718,9 +1802,6 @@ fn test_load_code_unaligned_error() {
     let dep_cell = build_cell_meta(10000, dep_cell_data);
 
     let data_loader = new_mock_data_loader();
-    let outputs = Arc::new(vec![]);
-    let group_inputs = Arc::new(vec![]);
-    let group_outputs = Arc::new(vec![]);
 
     let rtx = Arc::new(ResolvedTransaction {
         transaction: TransactionBuilder::default().build(),
@@ -1729,7 +1810,17 @@ fn test_load_code_unaligned_error() {
         resolved_dep_groups: vec![],
     });
 
-    let mut load_code = LoadCellData::new(data_loader, rtx, outputs, group_inputs, group_outputs);
+    let mut load_code = LoadCellData::new(Arc::new(Mutex::new(Snapshot2Context::new(TxData {
+        rtx,
+        data_loader,
+        program: Bytes::new(),
+        script_group: Arc::new(ScriptGroup {
+            script: Default::default(),
+            group_type: ScriptGroupType::Lock,
+            input_indices: Default::default(),
+            output_indices: Default::default(),
+        }),
+    }))));
 
     assert!(machine.memory_mut().store_byte(addr, addr_size, 1).is_ok());
 
@@ -1759,9 +1850,6 @@ fn test_load_code_slice_out_of_bound_error() {
     let dep_cell = build_cell_meta(10000, dep_cell_data);
 
     let data_loader = new_mock_data_loader();
-    let outputs = Arc::new(vec![]);
-    let group_inputs = Arc::new(vec![]);
-    let group_outputs = Arc::new(vec![]);
 
     let rtx = Arc::new(ResolvedTransaction {
         transaction: TransactionBuilder::default().build(),
@@ -1770,7 +1858,17 @@ fn test_load_code_slice_out_of_bound_error() {
         resolved_dep_groups: vec![],
     });
 
-    let mut load_code = LoadCellData::new(data_loader, rtx, outputs, group_inputs, group_outputs);
+    let mut load_code = LoadCellData::new(Arc::new(Mutex::new(Snapshot2Context::new(TxData {
+        rtx,
+        data_loader,
+        program: Bytes::new(),
+        script_group: Arc::new(ScriptGroup {
+            script: Default::default(),
+            group_type: ScriptGroupType::Lock,
+            input_indices: Default::default(),
+            output_indices: Default::default(),
+        }),
+    }))));
 
     assert!(machine.memory_mut().store_byte(addr, addr_size, 1).is_ok());
 
@@ -1803,9 +1901,6 @@ fn test_load_code_not_enough_space_error() {
     let dep_cell = build_cell_meta(10000, dep_cell_data);
 
     let data_loader = new_mock_data_loader();
-    let outputs = Arc::new(vec![]);
-    let group_inputs = Arc::new(vec![]);
-    let group_outputs = Arc::new(vec![]);
 
     let rtx = Arc::new(ResolvedTransaction {
         transaction: TransactionBuilder::default().build(),
@@ -1814,7 +1909,17 @@ fn test_load_code_not_enough_space_error() {
         resolved_dep_groups: vec![],
     });
 
-    let mut load_code = LoadCellData::new(data_loader, rtx, outputs, group_inputs, group_outputs);
+    let mut load_code = LoadCellData::new(Arc::new(Mutex::new(Snapshot2Context::new(TxData {
+        rtx,
+        data_loader,
+        program: Bytes::new(),
+        script_group: Arc::new(ScriptGroup {
+            script: Default::default(),
+            group_type: ScriptGroupType::Lock,
+            input_indices: Default::default(),
+            output_indices: Default::default(),
+        }),
+    }))));
 
     assert!(machine.memory_mut().store_byte(addr, addr_size, 1).is_ok());
 
@@ -1985,3 +2090,91 @@ fn _test_input_field_bound(field: u64) -> Result<(), TestCaseError> {
     prop_assert!(InputField::parse_from_u64(field).is_err());
     Ok(())
 }
+
+#[test]
+fn test_load_cell_data_size_zero() {
+    let mut machine = SCRIPT_VERSION.init_core_machine_without_limit();
+    let size_addr: u64 = 100;
+    let addr = 4096;
+    let data = [0xff; 256];
+
+    machine.set_register(A0, addr); // addr
+    machine.set_register(A1, size_addr); // size
+    machine.set_register(A2, 0); // offset
+    machine.set_register(A3, 0); // index
+    machine.set_register(A4, u64::from(Source::Transaction(SourceEntry::CellDep))); //source
+    machine.set_register(A7, LOAD_CELL_DATA_SYSCALL_NUMBER); // syscall number
+
+    machine.memory_mut().store64(&size_addr, &0).unwrap();
+
+    let data = Bytes::from(data.to_vec());
+    let dep_cell = build_cell_meta(10000, data.clone());
+    let input_cell = build_cell_meta(100, data);
+
+    let data_loader = new_mock_data_loader();
+
+    let rtx = Arc::new(ResolvedTransaction {
+        transaction: TransactionBuilder::default().build(),
+        resolved_cell_deps: vec![dep_cell],
+        resolved_inputs: vec![input_cell],
+        resolved_dep_groups: vec![],
+    });
+    let mut load_code = LoadCellData::new(Arc::new(Mutex::new(Snapshot2Context::new(TxData {
+        rtx,
+        data_loader,
+        program: Bytes::new(),
+        script_group: Arc::new(ScriptGroup {
+            script: Default::default(),
+            group_type: ScriptGroupType::Lock,
+            input_indices: vec![0],
+            output_indices: vec![0],
+        }),
+    }))));
+    load_code.ecall(&mut machine).unwrap();
+    assert_eq!(machine.registers()[A0], u64::from(SUCCESS));
+    assert_eq!(machine.memory_mut().load64(&size_addr).unwrap(), 256);
+    assert_eq!(machine.memory_mut().load64(&addr).unwrap(), 0);
+}
+
+#[test]
+fn test_load_cell_data_size_zero_index_out_of_bound() {
+    let mut machine = SCRIPT_VERSION.init_core_machine_without_limit();
+    let size_addr: u64 = 100;
+    let addr = 4096;
+    let data = [0xff; 256];
+
+    machine.set_register(A0, addr); // addr
+    machine.set_register(A1, size_addr); // size
+    machine.set_register(A2, 0); // offset
+    machine.set_register(A3, 8); // index
+    machine.set_register(A4, u64::from(Source::Transaction(SourceEntry::CellDep))); //source
+    machine.set_register(A7, LOAD_CELL_DATA_SYSCALL_NUMBER); // syscall number
+
+    machine.memory_mut().store64(&size_addr, &0).unwrap();
+
+    let data = Bytes::from(data.to_vec());
+    let dep_cell = build_cell_meta(10000, data.clone());
+    let input_cell = build_cell_meta(100, data);
+
+    let data_loader = new_mock_data_loader();
+
+    let rtx = Arc::new(ResolvedTransaction {
+        transaction: TransactionBuilder::default().build(),
+        resolved_cell_deps: vec![dep_cell],
+        resolved_inputs: vec![input_cell],
+        resolved_dep_groups: vec![],
+    });
+    let mut load_code = LoadCellData::new(Arc::new(Mutex::new(Snapshot2Context::new(TxData {
+        rtx,
+        data_loader,
+        program: Bytes::new(),
+        script_group: Arc::new(ScriptGroup {
+            script: Default::default(),
+            group_type: ScriptGroupType::Lock,
+            input_indices: vec![0],
+            output_indices: vec![0],
+        }),
+    }))));
+    load_code.ecall(&mut machine).unwrap();
+    assert_eq!(machine.registers()[A0], u64::from(INDEX_OUT_OF_BOUND));
+}
diff --git a/script/src/syscalls/tests/vm_latest/syscalls_2.rs b/script/src/syscalls/tests/vm_latest/syscalls_2.rs
index 372b0377d3..4cac872f56 100644
--- a/script/src/syscalls/tests/vm_latest/syscalls_2.rs
+++ b/script/src/syscalls/tests/vm_latest/syscalls_2.rs
@@ -53,54 +53,12 @@ fn test_current_cycles() {
 
     machine.set_cycles(cycles);
 
-    let result = CurrentCycles::new(0).ecall(&mut machine);
+    let result = CurrentCycles::new(Arc::new(Mutex::new(0))).ecall(&mut machine);
 
     assert!(result.unwrap());
     assert_eq!(machine.registers()[A0], cycles);
 }
 
-#[test]
-fn test_get_memory_limit() {
-    let mut machine = SCRIPT_VERSION.init_core_machine_without_limit();
-
-    machine.set_register(A0, 0);
-    machine.set_register(A1, 0);
-    machine.set_register(A2, 0);
-    machine.set_register(A3, 0);
-    machine.set_register(A4, 0);
-    machine.set_register(A5, 0);
-    machine.set_register(A7, GET_MEMORY_LIMIT);
-
-    let result = GetMemoryLimit::new(8).ecall(&mut machine);
-
-    assert!(result.unwrap());
-    assert_eq!(machine.registers()[A0], 8);
-}
-
-#[test]
-fn test_set_content() {
-    let mut machine = SCRIPT_VERSION.init_core_machine_without_limit();
-    machine.memory_mut().store64(&20000, &10).unwrap();
-    machine
-        .memory_mut()
-        .store_bytes(30000, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
-        .unwrap();
-
-    machine.set_register(A0, 30000);
-    machine.set_register(A1, 20000);
-    machine.set_register(A2, 0);
-    machine.set_register(A3, 0);
-    machine.set_register(A4, 0);
-    machine.set_register(A5, 0);
-    machine.set_register(A7, SET_CONTENT);
-
-    let content_data = Arc::new(Mutex::new(vec![]));
-    let result = SetContent::new(content_data, 5).ecall(&mut machine);
-
-    assert!(result.unwrap());
-    assert_eq!(machine.memory_mut().load64(&20000).unwrap(), 5);
-}
-
 fn _test_load_extension(
     data: &[u8],
     index: u64,
diff --git a/script/src/syscalls/utils.rs b/script/src/syscalls/utils.rs
index cacfdfa0fb..a62d0900b3 100644
--- a/script/src/syscalls/utils.rs
+++ b/script/src/syscalls/utils.rs
@@ -47,21 +47,3 @@ pub fn load_c_string<Mac: SupportMachine>(machine: &mut Mac, addr: u64) -> Resul
 
     Ok(Bytes::from(buffer))
 }
-
-pub fn load_bytes<Mac: SupportMachine>(
-    machine: &mut Mac,
-    addr: u64,
-    size: u64,
-) -> Result<Bytes, VMError> {
-    let mut buffer = Vec::new();
-    let mut addr = addr;
-    for _ in 0..size {
-        let byte = machine
-            .memory_mut()
-            .load8(&Mac::REG::from_u64(addr))?
-            .to_u8();
-        buffer.push(byte);
-        addr += 1;
-    }
-    Ok(Bytes::from(buffer))
-}
diff --git a/script/src/syscalls/wait.rs b/script/src/syscalls/wait.rs
new file mode 100644
index 0000000000..c9a49566aa
--- /dev/null
+++ b/script/src/syscalls/wait.rs
@@ -0,0 +1,45 @@
+use crate::syscalls::{SPAWN_YIELD_CYCLES_BASE, WAIT};
+use crate::types::{Message, VmId, WaitArgs};
+use ckb_vm::{
+    registers::{A0, A1, A7},
+    Error as VMError, Register, SupportMachine, Syscalls,
+};
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug)]
+pub struct Wait {
+    id: VmId,
+    message_box: Arc<Mutex<Vec<Message>>>,
+}
+
+impl Wait {
+    pub fn new(id: VmId, message_box: Arc<Mutex<Vec<Message>>>) -> Self {
+        Self { id, message_box }
+    }
+}
+
+impl<Mac: SupportMachine> Syscalls<Mac> for Wait {
+    fn initialize(&mut self, _machine: &mut Mac) -> Result<(), VMError> {
+        Ok(())
+    }
+
+    fn ecall(&mut self, machine: &mut Mac) -> Result<bool, VMError> {
+        if machine.registers()[A7].to_u64() != WAIT {
+            return Ok(false);
+        }
+        let target_id = machine.registers()[A0].to_u64();
+        let exit_code_addr = machine.registers()[A1].to_u64();
+        machine.add_cycles_no_checking(SPAWN_YIELD_CYCLES_BASE)?;
+        self.message_box
+            .lock()
+            .map_err(|e| VMError::Unexpected(e.to_string()))?
+            .push(Message::Wait(
+                self.id,
+                WaitArgs {
+                    target_id,
+                    exit_code_addr,
+                },
+            ));
+        Err(VMError::Yield)
+    }
+}
diff --git a/script/src/syscalls/write.rs b/script/src/syscalls/write.rs
new file mode 100644
index 0000000000..a193f5589b
--- /dev/null
+++ b/script/src/syscalls/write.rs
@@ -0,0 +1,60 @@
+use crate::syscalls::{INVALID_FD, SPAWN_YIELD_CYCLES_BASE, WRITE};
+use crate::types::{Fd, FdArgs, Message, VmId};
+use ckb_vm::{
+    registers::{A0, A1, A2, A7},
+    Error as VMError, Memory, Register, SupportMachine, Syscalls,
+};
+use std::sync::{Arc, Mutex};
+
+#[derive(Debug)]
+pub struct Write {
+    id: VmId,
+    message_box: Arc<Mutex<Vec<Message>>>,
+}
+
+impl Write {
+    pub fn new(id: VmId, message_box: Arc<Mutex<Vec<Message>>>) -> Self {
+        Self { id, message_box }
+    }
+}
+
+impl<Mac: SupportMachine> Syscalls<Mac> for Write {
+    fn initialize(&mut self, _machine: &mut Mac) -> Result<(), VMError> {
+        Ok(())
+    }
+
+    fn ecall(&mut self, machine: &mut Mac) -> Result<bool, VMError> {
+        if machine.registers()[A7].to_u64() != WRITE {
+            return Ok(false);
+        }
+        let fd = Fd(machine.registers()[A0].to_u64());
+        let buffer_addr = machine.registers()[A1].to_u64();
+        let length_addr = machine.registers()[A2].to_u64();
+        let length = machine
+            .memory_mut()
+            .load64(&Mac::REG::from_u64(length_addr))?
+            .to_u64();
+
+        // We can only do basic checks here, when the message is actually processed,
+        // more complete checks will be performed.
+        // We will also leave to the actual write operation to test memory permissions.
+        if !fd.is_write() {
+            machine.set_register(A0, Mac::REG::from_u8(INVALID_FD));
+            return Ok(true);
+        }
+        machine.add_cycles_no_checking(SPAWN_YIELD_CYCLES_BASE)?;
+        self.message_box
+            .lock()
+            .map_err(|e| VMError::Unexpected(e.to_string()))?
+            .push(Message::FdWrite(
+                self.id,
+                FdArgs {
+                    fd,
+                    length,
+                    buffer_addr,
+                    length_addr,
+                },
+            ));
+        Err(VMError::Yield)
+    }
+}
diff --git a/script/src/types.rs b/script/src/types.rs
index b8b625b84b..6a3900bafe 100644
--- a/script/src/types.rs
+++ b/script/src/types.rs
@@ -1,4 +1,3 @@
-use crate::ScriptError;
 use ckb_error::Error;
 use ckb_types::{
     core::{Cycle, ScriptHashType},
@@ -6,8 +5,7 @@ use ckb_types::{
 };
 use ckb_vm::{
     machine::{VERSION0, VERSION1, VERSION2},
-    snapshot::{make_snapshot, Snapshot},
-    Error as VMInternalError, SupportMachine, ISA_A, ISA_B, ISA_IMC, ISA_MOP,
+    ISA_A, ISA_B, ISA_IMC, ISA_MOP,
 };
 use serde::{Deserialize, Serialize};
 use std::fmt;
@@ -19,6 +17,18 @@ use ckb_vm::machine::asm::{AsmCoreMachine, AsmMachine};
 #[cfg(not(has_asm))]
 use ckb_vm::{DefaultCoreMachine, TraceMachine, WXorXMemory};
 
+use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
+use ckb_vm::snapshot2::Snapshot2Context;
+
+use ckb_types::core::cell::ResolvedTransaction;
+use ckb_vm::{
+    bytes::Bytes,
+    machine::Pause,
+    snapshot2::{DataSource, Snapshot2},
+    RISCV_GENERAL_REGISTER_NUMBER,
+};
+use std::mem::size_of;
+
 /// The type of CKB-VM ISA.
 pub type VmIsa = u8;
 /// /// The type of CKB-VM version.
@@ -40,6 +50,11 @@ pub type CoreMachine = DefaultCoreMachine<u64, WXorXMemory<ckb_vm::SparseMemory<
 #[cfg(all(not(has_asm), feature = "flatmemory"))]
 pub type CoreMachine = DefaultCoreMachine<u64, WXorXMemory<ckb_vm::FlatMemory<u64>>>;
 
+#[cfg(has_asm)]
+pub(crate) type Machine = AsmMachine;
+#[cfg(not(has_asm))]
+pub(crate) type Machine = TraceMachine<CoreMachine>;
+
 pub(crate) type Indices = Arc<Vec<usize>>;
 
 pub(crate) type DebugPrinter = Arc<dyn Fn(&Byte32, &str) + Send + Sync>;
@@ -107,139 +122,6 @@ impl ScriptVersion {
     }
 }
 
-#[cfg(has_asm)]
-pub(crate) type Machine = AsmMachine;
-#[cfg(not(has_asm))]
-pub(crate) type Machine = TraceMachine<CoreMachine>;
-
-/// Common data that would be shared amongst multiple VM instances.
-/// One sample usage right now, is to capture suspended machines in
-/// a chain of spawned machines.
-#[derive(Default)]
-pub struct MachineContext {
-    /// A stack of ResumableMachines.
-    pub suspended_machines: Vec<ResumableMachine>,
-}
-
-/// Data structure captured all environment data for a suspended machine
-#[derive(Clone, Debug)]
-pub enum ResumePoint {
-    Initial,
-    Spawn {
-        callee_peak_memory: u64,
-        callee_memory_limit: u64,
-        content: Vec<u8>,
-        content_length: u64,
-        caller_exit_code_addr: u64,
-        caller_content_addr: u64,
-        caller_content_length_addr: u64,
-        cycles_base: u64,
-    },
-}
-
-/// Data structure captured all the required data for a spawn syscall
-#[derive(Clone, Debug)]
-pub struct SpawnData {
-    pub(crate) callee_peak_memory: u64,
-    pub(crate) callee_memory_limit: u64,
-    pub(crate) content: Arc<Mutex<Vec<u8>>>,
-    pub(crate) content_length: u64,
-    pub(crate) caller_exit_code_addr: u64,
-    pub(crate) caller_content_addr: u64,
-    pub(crate) caller_content_length_addr: u64,
-    pub(crate) cycles_base: u64,
-}
-
-impl TryFrom<&SpawnData> for ResumePoint {
-    type Error = VMInternalError;
-
-    fn try_from(value: &SpawnData) -> Result<Self, Self::Error> {
-        let SpawnData {
-            callee_peak_memory,
-            callee_memory_limit,
-            content,
-            content_length,
-            caller_exit_code_addr,
-            caller_content_addr,
-            caller_content_length_addr,
-            cycles_base,
-        } = value;
-        Ok(ResumePoint::Spawn {
-            callee_peak_memory: *callee_peak_memory,
-            callee_memory_limit: *callee_memory_limit,
-            content: content
-                .lock()
-                .map_err(|e| VMInternalError::Unexpected(format!("Lock error: {}", e)))?
-                .clone(),
-            content_length: *content_length,
-            caller_exit_code_addr: *caller_exit_code_addr,
-            caller_content_addr: *caller_content_addr,
-            caller_content_length_addr: *caller_content_length_addr,
-            cycles_base: *cycles_base,
-        })
-    }
-}
-
-/// An enumerated type indicating the type of the Machine.
-pub enum ResumableMachine {
-    /// Root machine instance.
-    Initial(Machine),
-    /// A machine which created by spawn syscall.
-    Spawn(Machine, SpawnData),
-}
-
-impl ResumableMachine {
-    pub(crate) fn initial(machine: Machine) -> Self {
-        ResumableMachine::Initial(machine)
-    }
-
-    pub(crate) fn spawn(machine: Machine, data: SpawnData) -> Self {
-        ResumableMachine::Spawn(machine, data)
-    }
-
-    pub(crate) fn machine(&self) -> &Machine {
-        match self {
-            ResumableMachine::Initial(machine) => machine,
-            ResumableMachine::Spawn(machine, _) => machine,
-        }
-    }
-
-    pub(crate) fn machine_mut(&mut self) -> &mut Machine {
-        match self {
-            ResumableMachine::Initial(machine) => machine,
-            ResumableMachine::Spawn(machine, _) => machine,
-        }
-    }
-
-    pub(crate) fn cycles(&self) -> Cycle {
-        self.machine().machine.cycles()
-    }
-
-    pub(crate) fn set_max_cycles(&mut self, cycles: Cycle) {
-        set_vm_max_cycles(self.machine_mut(), cycles)
-    }
-
-    /// Add cycles to current machine.
-    pub fn add_cycles(&mut self, cycles: Cycle) -> Result<(), VMInternalError> {
-        self.machine_mut().machine.add_cycles(cycles)
-    }
-
-    /// Run machine.
-    pub fn run(&mut self) -> Result<i8, VMInternalError> {
-        self.machine_mut().run()
-    }
-}
-
-#[cfg(has_asm)]
-pub(crate) fn set_vm_max_cycles(vm: &mut Machine, cycles: Cycle) {
-    vm.set_max_cycles(cycles)
-}
-
-#[cfg(not(has_asm))]
-pub(crate) fn set_vm_max_cycles(vm: &mut Machine, cycles: Cycle) {
-    vm.machine.inner_mut().set_max_cycles(cycles)
-}
-
 /// A script group is defined as scripts that share the same hash.
 ///
 /// A script group will only be executed once per transaction, the
@@ -309,7 +191,7 @@ pub struct TransactionSnapshot {
     /// current suspended script index
     pub current: usize,
     /// vm snapshots
-    pub snaps: Vec<(Snapshot, Cycle, ResumePoint)>,
+    pub state: Option<FullSuspendedState>,
     /// current consumed cycle
     pub current_cycles: Cycle,
     /// limit cycles when snapshot create
@@ -321,29 +203,25 @@ pub struct TransactionSnapshot {
 pub struct TransactionState {
     /// current suspended script index
     pub current: usize,
-    /// vm states
-    pub vms: Vec<ResumableMachine>,
+    /// vm scheduler suspend state
+    pub state: Option<FullSuspendedState>,
     /// current consumed cycle
     pub current_cycles: Cycle,
     /// limit cycles
     pub limit_cycles: Cycle,
-    /// machine context for the vms included in this state
-    pub machine_context: Arc<Mutex<MachineContext>>,
 }
 
 impl TransactionState {
     /// Creates a new TransactionState struct
     pub fn new(
-        vms: Vec<ResumableMachine>,
-        machine_context: Arc<Mutex<MachineContext>>,
+        state: Option<FullSuspendedState>,
         current: usize,
         current_cycles: Cycle,
         limit_cycles: Cycle,
     ) -> Self {
         TransactionState {
             current,
-            vms,
-            machine_context,
+            state,
             current_cycles,
             limit_cycles,
         }
@@ -382,29 +260,15 @@ impl TryFrom<TransactionState> for TransactionSnapshot {
     fn try_from(state: TransactionState) -> Result<Self, Self::Error> {
         let TransactionState {
             current,
-            vms,
+            state,
             current_cycles,
             limit_cycles,
             ..
         } = state;
 
-        let mut snaps = Vec::with_capacity(vms.len());
-        for mut vm in vms {
-            let snapshot = make_snapshot(&mut vm.machine_mut().machine)
-                .map_err(|e| ScriptError::VMInternalError(e).unknown_source())?;
-            let cycles = vm.cycles();
-            let resume_point = match vm {
-                ResumableMachine::Initial(_) => ResumePoint::Initial,
-                ResumableMachine::Spawn(_, data) => (&data)
-                    .try_into()
-                    .map_err(|e| ScriptError::VMInternalError(e).unknown_source())?,
-            };
-            snaps.push((snapshot, cycles, resume_point));
-        }
-
         Ok(TransactionSnapshot {
             current,
-            snaps,
+            state,
             current_cycles,
             limit_cycles,
         })
@@ -440,3 +304,334 @@ impl std::fmt::Debug for TransactionState {
             .finish()
     }
 }
+
+/// ChunkCommand is used to control the verification process to suspend or resume
+#[derive(Eq, PartialEq, Clone, Debug)]
+pub enum ChunkCommand {
+    /// Suspend the verification process
+    Suspend,
+    /// Resume the verification process
+    Resume,
+    /// Stop the verification process
+    Stop,
+}
+
+#[derive(Clone)]
+pub struct MachineContext<
+    DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
+> {
+    pub(crate) base_cycles: Arc<Mutex<u64>>,
+    pub(crate) snapshot2_context: Arc<Mutex<Snapshot2Context<DataPieceId, TxData<DL>>>>,
+}
+
+impl<DL> MachineContext<DL>
+where
+    DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
+{
+    pub fn new(tx_data: TxData<DL>) -> Self {
+        Self {
+            base_cycles: Arc::new(Mutex::new(0)),
+            snapshot2_context: Arc::new(Mutex::new(Snapshot2Context::new(tx_data))),
+        }
+    }
+
+    pub fn snapshot2_context(&self) -> &Arc<Mutex<Snapshot2Context<DataPieceId, TxData<DL>>>> {
+        &self.snapshot2_context
+    }
+
+    pub fn set_base_cycles(&mut self, base_cycles: u64) {
+        *self.base_cycles.lock().expect("lock") = base_cycles;
+    }
+}
+
+pub type VmId = u64;
+pub const FIRST_VM_ID: VmId = 0;
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct Fd(pub(crate) u64);
+
+pub const FIRST_FD_SLOT: u64 = 2;
+
+impl Fd {
+    pub fn create(slot: u64) -> (Fd, Fd, u64) {
+        (Fd(slot), Fd(slot + 1), slot + 2)
+    }
+
+    pub fn other_fd(&self) -> Fd {
+        Fd(self.0 ^ 0x1)
+    }
+
+    pub fn is_read(&self) -> bool {
+        self.0 % 2 == 0
+    }
+
+    pub fn is_write(&self) -> bool {
+        self.0 % 2 == 1
+    }
+}
+
+/// VM is in waiting-to-read state.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct ReadState {
+    pub fd: Fd,
+    pub length: u64,
+    pub buffer_addr: u64,
+    pub length_addr: u64,
+}
+
+/// VM is in waiting-to-write state.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct WriteState {
+    pub fd: Fd,
+    pub consumed: u64,
+    pub length: u64,
+    pub buffer_addr: u64,
+    pub length_addr: u64,
+}
+
+/// VM State.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum VmState {
+    /// Runnable.
+    Runnable,
+    /// Terminated.
+    Terminated,
+    /// Wait.
+    Wait {
+        /// Target vm id.
+        target_vm_id: VmId,
+        /// Exit code addr.
+        exit_code_addr: u64,
+    },
+    /// WaitForWrite.
+    WaitForWrite(WriteState),
+    /// WaitForRead.
+    WaitForRead(ReadState),
+}
+
+#[derive(Clone, Debug)]
+pub struct SpawnArgs {
+    pub data_piece_id: DataPieceId,
+    pub offset: u64,
+    pub length: u64,
+    pub argv: Vec<Bytes>,
+    pub fds: Vec<Fd>,
+    pub process_id_addr: u64,
+}
+
+#[derive(Clone, Debug)]
+pub struct WaitArgs {
+    pub target_id: VmId,
+    pub exit_code_addr: u64,
+}
+
+#[derive(Clone, Debug)]
+pub struct PipeArgs {
+    pub fd1_addr: u64,
+    pub fd2_addr: u64,
+}
+
+#[derive(Clone, Debug)]
+pub struct FdArgs {
+    pub fd: Fd,
+    pub length: u64,
+    pub buffer_addr: u64,
+    pub length_addr: u64,
+}
+
+#[derive(Clone, Debug)]
+pub enum Message {
+    Spawn(VmId, SpawnArgs),
+    Wait(VmId, WaitArgs),
+    Pipe(VmId, PipeArgs),
+    FdRead(VmId, FdArgs),
+    FdWrite(VmId, FdArgs),
+    InheritedFileDescriptor(VmId, FdArgs),
+    Close(VmId, Fd),
+}
+
+/// A pointer to the data that is part of the transaction.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum DataPieceId {
+    /// Target program. Usually located in cell data.
+    Program,
+    /// The nth input cell data.
+    Input(u32),
+    /// The nth output data.
+    Output(u32),
+    /// The nth cell dep cell data.
+    CellDep(u32),
+    /// The nth group input cell data.
+    GroupInput(u32),
+    /// The nth group output data.
+    GroupOutput(u32),
+    /// The nth witness.
+    Witness(u32),
+    /// The nth witness group input.
+    WitnessGroupInput(u32),
+    /// The nth witness group output.
+    WitnessGroupOutput(u32),
+}
+
+impl TryFrom<(u64, u64, u64)> for DataPieceId {
+    type Error = String;
+
+    fn try_from(value: (u64, u64, u64)) -> Result<Self, Self::Error> {
+        let (source, index, place) = value;
+        let index: u32 =
+            u32::try_from(index).map_err(|e| format!("Error casting index to u32: {}", e))?;
+        match (source, place) {
+            (1, 0) => Ok(DataPieceId::Input(index)),
+            (2, 0) => Ok(DataPieceId::Output(index)),
+            (3, 0) => Ok(DataPieceId::CellDep(index)),
+            (0x0100000000000001, 0) => Ok(DataPieceId::GroupInput(index)),
+            (0x0100000000000002, 0) => Ok(DataPieceId::GroupOutput(index)),
+            (1, 1) => Ok(DataPieceId::Witness(index)),
+            (2, 1) => Ok(DataPieceId::Witness(index)),
+            (0x0100000000000001, 1) => Ok(DataPieceId::WitnessGroupInput(index)),
+            (0x0100000000000002, 1) => Ok(DataPieceId::WitnessGroupOutput(index)),
+            _ => Err(format!("Invalid source value: {:#x}", source)),
+        }
+    }
+}
+
+/// Full state representing all VM instances from verifying a CKB script.
+/// It should be serializable to binary formats, while also be able to
+/// fully recover the running environment with the full transaction environment.
+#[derive(Clone, Debug)]
+pub struct FullSuspendedState {
+    pub total_cycles: Cycle,
+    pub next_vm_id: VmId,
+    pub next_fd_slot: u64,
+    pub vms: Vec<(VmId, VmState, Snapshot2<DataPieceId>)>,
+    pub fds: Vec<(Fd, VmId)>,
+    pub inherited_fd: Vec<(VmId, Vec<Fd>)>,
+    pub terminated_vms: Vec<(VmId, i8)>,
+    pub instantiated_ids: Vec<VmId>,
+}
+
+impl FullSuspendedState {
+    pub fn size(&self) -> u64 {
+        (size_of::<Cycle>()
+            + size_of::<VmId>()
+            + size_of::<u64>()
+            + self.vms.iter().fold(0, |mut acc, (_, _, snapshot)| {
+                acc += size_of::<VmId>() + size_of::<VmState>();
+                acc += snapshot.pages_from_source.len()
+                    * (size_of::<u64>()
+                        + size_of::<u8>()
+                        + size_of::<DataPieceId>()
+                        + size_of::<u64>()
+                        + size_of::<u64>());
+                for dirty_page in &snapshot.dirty_pages {
+                    acc += size_of::<u64>() + size_of::<u8>() + dirty_page.2.len();
+                }
+                acc += size_of::<u32>()
+                    + RISCV_GENERAL_REGISTER_NUMBER * size_of::<u64>()
+                    + size_of::<u64>()
+                    + size_of::<u64>()
+                    + size_of::<u64>();
+                acc
+            })
+            + (self.fds.len() * (size_of::<Fd>() + size_of::<VmId>()))) as u64
+            + (self.inherited_fd.len() * (size_of::<Fd>())) as u64
+            + (self.terminated_vms.len() * (size_of::<VmId>() + size_of::<i8>())) as u64
+            + (self.instantiated_ids.len() * size_of::<VmId>()) as u64
+    }
+}
+
+/// Context data for current running transaction & script
+#[derive(Clone)]
+pub struct TxData<DL> {
+    /// ResolvedTransaction.
+    pub rtx: Arc<ResolvedTransaction>,
+    /// Data loader.
+    pub data_loader: DL,
+    /// Ideally one might not want to keep program here, since program is totally
+    /// deducible from rtx + data_loader, however, for a demo here, program
+    /// does help us save some extra coding.
+    pub program: Bytes,
+    /// The script group to which the current program belongs.
+    pub script_group: Arc<ScriptGroup>,
+}
+
+impl<DL> DataSource<DataPieceId> for TxData<DL>
+where
+    DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
+{
+    fn load_data(&self, id: &DataPieceId, offset: u64, length: u64) -> Option<(Bytes, u64)> {
+        match id {
+            DataPieceId::Program => {
+                // This is just a shortcut so we don't have to copy over the logic in extract_script,
+                // ideally you can also only define the rest 5, then figure out a way to convert
+                // script group to the actual cell dep index.
+                Some(self.program.clone())
+            }
+            DataPieceId::Input(i) => self
+                .rtx
+                .resolved_inputs
+                .get(*i as usize)
+                .and_then(|cell| self.data_loader.load_cell_data(cell)),
+            DataPieceId::Output(i) => self
+                .rtx
+                .transaction
+                .outputs_data()
+                .get(*i as usize)
+                .map(|data| data.raw_data()),
+            DataPieceId::CellDep(i) => self
+                .rtx
+                .resolved_cell_deps
+                .get(*i as usize)
+                .and_then(|cell| self.data_loader.load_cell_data(cell)),
+            DataPieceId::GroupInput(i) => self
+                .script_group
+                .input_indices
+                .get(*i as usize)
+                .and_then(|gi| self.rtx.resolved_inputs.get(*gi))
+                .and_then(|cell| self.data_loader.load_cell_data(cell)),
+            DataPieceId::GroupOutput(i) => self
+                .script_group
+                .output_indices
+                .get(*i as usize)
+                .and_then(|gi| self.rtx.transaction.outputs_data().get(*gi))
+                .map(|data| data.raw_data()),
+            DataPieceId::Witness(i) => self
+                .rtx
+                .transaction
+                .witnesses()
+                .get(*i as usize)
+                .map(|data| data.raw_data()),
+            DataPieceId::WitnessGroupInput(i) => self
+                .script_group
+                .input_indices
+                .get(*i as usize)
+                .and_then(|gi| self.rtx.transaction.witnesses().get(*gi))
+                .map(|data| data.raw_data()),
+            DataPieceId::WitnessGroupOutput(i) => self
+                .script_group
+                .output_indices
+                .get(*i as usize)
+                .and_then(|gi| self.rtx.transaction.witnesses().get(*gi))
+                .map(|data| data.raw_data()),
+        }
+        .map(|data| {
+            let offset = std::cmp::min(offset as usize, data.len());
+            let full_length = data.len() - offset;
+            let real_length = if length > 0 {
+                std::cmp::min(full_length, length as usize)
+            } else {
+                full_length
+            };
+            (data.slice(offset..offset + real_length), full_length as u64)
+        })
+    }
+}
+
+/// The scheduler's running mode.
+#[derive(Clone)]
+pub enum RunMode {
+    /// Continues running until cycles are exhausted.
+    LimitCycles(Cycle),
+    /// Continues running until a Pause signal is received.
+    Pause(Pause),
+}
diff --git a/script/src/verify.rs b/script/src/verify.rs
index 207161e436..f91328e598 100644
--- a/script/src/verify.rs
+++ b/script/src/verify.rs
@@ -1,21 +1,22 @@
+use crate::scheduler::Scheduler;
 #[cfg(test)]
 use crate::syscalls::Pause;
+use crate::syscalls::{InheritedFd, ProcessID, EXEC_LOAD_ELF_V2_CYCLES_BASE};
+use crate::types::{DataPieceId, FullSuspendedState, Message, RunMode, TxData, VmId, FIRST_VM_ID};
 use crate::{
-    cost_model::transferred_byte_cycles,
     error::{ScriptError, TransactionScriptError},
     syscalls::{
-        spawn::{build_child_machine, update_caller_machine},
-        CurrentCycles, CurrentMemory, Debugger, Exec, GetMemoryLimit, LoadBlockExtension, LoadCell,
-        LoadCellData, LoadHeader, LoadInput, LoadScript, LoadScriptHash, LoadTx, LoadWitness,
-        SetContent, Spawn, VMVersion,
+        Close, CurrentCycles, Debugger, Exec, LoadBlockExtension, LoadCell, LoadCellData,
+        LoadHeader, LoadInput, LoadScript, LoadScriptHash, LoadTx, LoadWitness, Pipe, Read, Spawn,
+        VMVersion, Wait, Write,
     },
     type_id::TypeIdSystemScript,
     types::{
-        CoreMachine, DebugPrinter, Indices, Machine, MachineContext, ResumableMachine, ResumePoint,
-        ScriptGroup, ScriptGroupType, ScriptVersion, SpawnData, TransactionSnapshot,
-        TransactionState, VerifyResult,
+        CoreMachine, DebugPrinter, Indices, ScriptGroup, ScriptGroupType, ScriptVersion,
+        TransactionSnapshot, TransactionState, VerifyResult,
     },
     verify_env::TxVerifyEnv,
+    ChunkCommand,
 };
 use ckb_chain_spec::consensus::{Consensus, TYPE_ID_CODE_HASH};
 use ckb_error::Error;
@@ -31,14 +32,17 @@ use ckb_types::{
     packed::{Byte32, CellOutput, OutPoint, Script},
     prelude::*,
 };
-use ckb_vm::{
-    cost_model::estimate_cycles,
-    snapshot::{resume, Snapshot},
-    DefaultMachineBuilder, Error as VMInternalError, SupportMachine, Syscalls,
-};
-use std::cell::RefCell;
-use std::collections::{BTreeMap, HashMap};
+use ckb_vm::machine::Pause as VMPause;
+use ckb_vm::{snapshot2::Snapshot2Context, Error as VMInternalError, Syscalls};
 use std::sync::{Arc, Mutex};
+use std::{
+    collections::{BTreeMap, HashMap},
+    sync::RwLock,
+};
+use tokio::sync::{
+    oneshot,
+    watch::{self, Receiver},
+};
 
 #[cfg(test)]
 use core::sync::atomic::{AtomicBool, Ordering};
@@ -47,17 +51,18 @@ use core::sync::atomic::{AtomicBool, Ordering};
 mod tests;
 
 pub enum ChunkState {
-    Suspended(Vec<ResumableMachine>, Arc<Mutex<MachineContext>>),
-    Completed(Cycle),
+    Suspended(Option<FullSuspendedState>),
+    // (total_cycles, consumed_cycles in last chunk)
+    Completed(Cycle, Cycle),
 }
 
 impl ChunkState {
-    pub fn suspended(machines: Vec<ResumableMachine>, context: Arc<Mutex<MachineContext>>) -> Self {
-        ChunkState::Suspended(machines, context)
+    pub fn suspended(state: FullSuspendedState) -> Self {
+        ChunkState::Suspended(Some(state))
     }
 
     pub fn suspended_type_id() -> Self {
-        ChunkState::Suspended(vec![], Default::default())
+        ChunkState::Suspended(None)
     }
 }
 
@@ -68,33 +73,43 @@ enum DataGuard {
 }
 
 /// LazyData wrapper make sure not-loaded data will be loaded only after one access
-#[derive(Debug, PartialEq, Eq, Clone)]
-struct LazyData(RefCell<DataGuard>);
+#[derive(Debug, Clone)]
+struct LazyData(Arc<RwLock<DataGuard>>);
 
 impl LazyData {
     fn from_cell_meta(cell_meta: &CellMeta) -> LazyData {
         match &cell_meta.mem_cell_data {
-            Some(data) => LazyData(RefCell::new(DataGuard::Loaded(data.to_owned()))),
-            None => LazyData(RefCell::new(DataGuard::NotLoaded(
+            Some(data) => LazyData(Arc::new(RwLock::new(DataGuard::Loaded(data.to_owned())))),
+            None => LazyData(Arc::new(RwLock::new(DataGuard::NotLoaded(
                 cell_meta.out_point.clone(),
-            ))),
+            )))),
         }
     }
 
-    fn access<DL: CellDataProvider>(&self, data_loader: &DL) -> Bytes {
-        let guard = self.0.borrow().to_owned();
+    fn access<DL: CellDataProvider>(&self, data_loader: &DL) -> Result<Bytes, ScriptError> {
+        let guard = self
+            .0
+            .read()
+            .map_err(|_| ScriptError::Other("RwLock poisoned".into()))?
+            .to_owned();
         match guard {
             DataGuard::NotLoaded(out_point) => {
-                let data = data_loader.get_cell_data(&out_point).expect("cell data");
-                self.0.replace(DataGuard::Loaded(data.to_owned()));
-                data
+                let data = data_loader
+                    .get_cell_data(&out_point)
+                    .ok_or(ScriptError::Other("cell data not found".into()))?;
+                let mut write_guard = self
+                    .0
+                    .write()
+                    .map_err(|_| ScriptError::Other("RwLock poisoned".into()))?;
+                *write_guard = DataGuard::Loaded(data.clone());
+                Ok(data)
             }
-            DataGuard::Loaded(bytes) => bytes,
+            DataGuard::Loaded(bytes) => Ok(bytes),
         }
     }
 }
 
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, Clone)]
 enum Binaries {
     Unique(Byte32, LazyData),
     Duplicate(Byte32, LazyData),
@@ -124,21 +139,28 @@ impl Binaries {
 ///
 /// TransactionScriptsSyscallsGenerator can be cloned.
 #[derive(Clone)]
-pub struct TransactionScriptsSyscallsGenerator<DL> {
+pub struct TransactionScriptsSyscallsGenerator<DL>
+where
+    DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
+{
+    pub(crate) base_cycles: Arc<Mutex<u64>>,
     pub(crate) data_loader: DL,
-    debug_printer: DebugPrinter,
+    pub(crate) debug_printer: DebugPrinter,
+    pub(crate) message_box: Arc<Mutex<Vec<Message>>>,
     pub(crate) outputs: Arc<Vec<CellMeta>>,
     pub(crate) rtx: Arc<ResolvedTransaction>,
     #[cfg(test)]
-    skip_pause: Arc<AtomicBool>,
+    pub(crate) skip_pause: Arc<AtomicBool>,
+    pub(crate) vm_id: VmId,
 }
 
-impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static>
-    TransactionScriptsSyscallsGenerator<DL>
+impl<DL> TransactionScriptsSyscallsGenerator<DL>
+where
+    DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
 {
     /// Build syscall: current_cycles
-    pub fn build_current_cycles(&self, base: u64) -> CurrentCycles {
-        CurrentCycles::new(base)
+    pub fn build_current_cycles(&self) -> CurrentCycles {
+        CurrentCycles::new(Arc::clone(&self.base_cycles))
     }
 
     /// Build syscall: vm_version
@@ -147,13 +169,19 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
     }
 
     /// Build syscall: exec
-    pub fn build_exec(&self, group_inputs: Indices, group_outputs: Indices) -> Exec<DL> {
+    pub fn build_exec(
+        &self,
+        group_inputs: Indices,
+        group_outputs: Indices,
+        load_elf_base_fee: u64,
+    ) -> Exec<DL> {
         Exec::new(
             self.data_loader.clone(),
             Arc::clone(&self.rtx),
             Arc::clone(&self.outputs),
             group_inputs,
             group_outputs,
+            load_elf_base_fee,
         )
     }
 
@@ -176,16 +204,9 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
     /// Build syscall: load_cell_data
     pub fn build_load_cell_data(
         &self,
-        group_inputs: Indices,
-        group_outputs: Indices,
+        snapshot2_context: Arc<Mutex<Snapshot2Context<DataPieceId, TxData<DL>>>>,
     ) -> LoadCellData<DL> {
-        LoadCellData::new(
-            self.data_loader.clone(),
-            Arc::clone(&self.rtx),
-            Arc::clone(&self.outputs),
-            group_inputs,
-            group_outputs,
-        )
+        LoadCellData::new(snapshot2_context)
     }
 
     ///Build syscall: load_input
@@ -226,49 +247,55 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
         LoadScript::new(script)
     }
 
-    /// Build syscall: get_memory_limit
-    pub fn build_get_memory_limit(&self, memory_limit: u64) -> GetMemoryLimit {
-        GetMemoryLimit::new(memory_limit)
-    }
-
-    /// Build syscall: set_content
-    pub fn build_set_content(
-        &self,
-        content: Arc<Mutex<Vec<u8>>>,
-        content_length: u64,
-    ) -> SetContent {
-        SetContent::new(content, content_length)
-    }
-
     /// Build syscall: spawn
     pub fn build_spawn(
         &self,
-        script_version: ScriptVersion,
-        script_group: &ScriptGroup,
-        peak_memory: u64,
-        cycles_base: u64,
-        context: Arc<Mutex<MachineContext>>,
+        snapshot2_context: Arc<Mutex<Snapshot2Context<DataPieceId, TxData<DL>>>>,
     ) -> Spawn<DL> {
-        Spawn::new(
-            script_group.clone(),
-            script_version,
-            self.clone(),
-            peak_memory,
-            cycles_base,
-            context,
-        )
+        Spawn::new(self.vm_id, Arc::clone(&self.message_box), snapshot2_context)
+    }
+
+    /// Build syscall: wait
+    pub fn build_wait(&self) -> Wait {
+        Wait::new(self.vm_id, Arc::clone(&self.message_box))
+    }
+
+    /// Build syscall: process_id
+    pub fn build_process_id(&self) -> ProcessID {
+        ProcessID::new(self.vm_id)
+    }
+
+    /// Build syscall: pipe
+    pub fn build_pipe(&self) -> Pipe {
+        Pipe::new(self.vm_id, Arc::clone(&self.message_box))
     }
 
-    /// Build syscall: current_memory
-    pub fn build_current_memory(&self, current_memory: u64) -> CurrentMemory {
-        CurrentMemory::new(current_memory)
+    /// Build syscall: write
+    pub fn build_write(&self) -> Write {
+        Write::new(self.vm_id, Arc::clone(&self.message_box))
     }
 
-    /// Generate same syscalls. The result does not contain spawn syscalls.
-    pub fn generate_same_syscalls(
+    /// Build syscall: read
+    pub fn build_read(&self) -> Read {
+        Read::new(self.vm_id, Arc::clone(&self.message_box))
+    }
+
+    /// Build syscall: inherited_fd
+    pub fn inherited_fd(&self) -> InheritedFd {
+        InheritedFd::new(self.vm_id, Arc::clone(&self.message_box))
+    }
+
+    /// Build syscall: close
+    pub fn close(&self) -> Close {
+        Close::new(self.vm_id, Arc::clone(&self.message_box))
+    }
+
+    /// Generate syscalls.
+    pub fn generate_syscalls(
         &self,
         script_version: ScriptVersion,
         script_group: &ScriptGroup,
+        snapshot2_context: Arc<Mutex<Snapshot2Context<DataPieceId, TxData<DL>>>>,
     ) -> Vec<Box<(dyn Syscalls<CoreMachine>)>> {
         let current_script_hash = script_group.script.calc_script_hash();
         let script_group_input_indices = Arc::new(script_group.input_indices.clone());
@@ -287,60 +314,42 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
                 Arc::clone(&script_group_output_indices),
             )),
             Box::new(self.build_load_script(script_group.script.clone())),
-            Box::new(self.build_load_cell_data(
-                Arc::clone(&script_group_input_indices),
-                Arc::clone(&script_group_output_indices),
-            )),
+            Box::new(self.build_load_cell_data(Arc::clone(&snapshot2_context))),
             Box::new(Debugger::new(
                 current_script_hash,
                 Arc::clone(&self.debug_printer),
             )),
         ];
-        #[cfg(test)]
-        syscalls.push(Box::new(Pause::new(Arc::clone(&self.skip_pause))));
         if script_version >= ScriptVersion::V1 {
             syscalls.append(&mut vec![
                 Box::new(self.build_vm_version()),
                 Box::new(self.build_exec(
                     Arc::clone(&script_group_input_indices),
                     Arc::clone(&script_group_output_indices),
+                    if script_version >= ScriptVersion::V2 {
+                        EXEC_LOAD_ELF_V2_CYCLES_BASE
+                    } else {
+                        0
+                    },
                 )),
+                Box::new(self.build_current_cycles()),
             ]);
         }
-
-        if script_version >= ScriptVersion::V2 {
-            syscalls.push(Box::new(
-                self.build_load_block_extension(Arc::clone(&script_group_input_indices)),
-            ));
-        }
-        syscalls
-    }
-
-    /// Generate root syscalls.
-    pub fn generate_root_syscalls(
-        &self,
-        script_version: ScriptVersion,
-        script_group: &ScriptGroup,
-        context: Arc<Mutex<MachineContext>>,
-    ) -> Vec<Box<(dyn Syscalls<CoreMachine>)>> {
-        let mut syscalls = self.generate_same_syscalls(script_version, script_group);
-        if script_version >= ScriptVersion::V1 {
-            syscalls.push(Box::new(self.build_current_cycles(0)));
-        }
         if script_version >= ScriptVersion::V2 {
             syscalls.append(&mut vec![
-                Box::new(self.build_get_memory_limit(8)),
-                Box::new(self.build_set_content(Arc::new(Mutex::new(vec![])), 0)),
-                Box::new(self.build_spawn(
-                    script_version,
-                    script_group,
-                    8,
-                    0,
-                    Arc::clone(&context),
-                )),
-                Box::new(self.build_current_memory(8)),
-            ])
+                Box::new(self.build_load_block_extension(Arc::clone(&script_group_input_indices))),
+                Box::new(self.build_spawn(Arc::clone(&snapshot2_context))),
+                Box::new(self.build_process_id()),
+                Box::new(self.build_pipe()),
+                Box::new(self.build_wait()),
+                Box::new(self.build_write()),
+                Box::new(self.build_read()),
+                Box::new(self.inherited_fd()),
+                Box::new(self.close()),
+            ]);
         }
+        #[cfg(test)]
+        syscalls.push(Box::new(Pause::new(Arc::clone(&self.skip_pause))));
         syscalls
     }
 }
@@ -349,7 +358,10 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
 ///
 /// FlatBufferBuilder owned `Vec<u8>` that grows as needed, in the
 /// future, we might refactor this to share buffer to achieve zero-copy
-pub struct TransactionScriptsVerifier<DL> {
+pub struct TransactionScriptsVerifier<DL>
+where
+    DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
+{
     data_loader: DL,
 
     rtx: Arc<ResolvedTransaction>,
@@ -366,11 +378,12 @@ pub struct TransactionScriptsVerifier<DL> {
     consensus: Arc<Consensus>,
     tx_env: Arc<TxVerifyEnv>,
 
-    generator: TransactionScriptsSyscallsGenerator<DL>,
+    syscalls_generator: TransactionScriptsSyscallsGenerator<DL>,
 }
 
-impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static>
-    TransactionScriptsVerifier<DL>
+impl<DL> TransactionScriptsVerifier<DL>
+where
+    DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
 {
     /// Creates a script verifier for the transaction.
     ///
@@ -462,13 +475,16 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
         #[cfg(test)]
         let skip_pause = Arc::new(AtomicBool::new(false));
 
-        let generator = TransactionScriptsSyscallsGenerator {
+        let syscalls_generator = TransactionScriptsSyscallsGenerator {
+            base_cycles: Arc::new(Mutex::new(0)),
             data_loader: data_loader.clone(),
             debug_printer: Arc::clone(&debug_printer),
+            message_box: Arc::new(Mutex::new(Vec::new())),
             outputs: Arc::clone(&outputs),
             rtx: Arc::clone(&rtx),
             #[cfg(test)]
             skip_pause: Arc::clone(&skip_pause),
+            vm_id: FIRST_VM_ID,
         };
 
         TransactionScriptsVerifier {
@@ -482,7 +498,7 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
             skip_pause,
             consensus,
             tx_env,
-            generator,
+            syscalls_generator,
         }
     }
 
@@ -496,7 +512,7 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
     /// * `hash: &Byte32`: this is the script hash of currently running script group.
     /// * `message: &str`: message passed to the debug syscall.
     pub fn set_debug_printer<F: Fn(&Byte32, &str) + Sync + Send + 'static>(&mut self, func: F) {
-        self.generator.debug_printer = Arc::new(func);
+        self.syscalls_generator.debug_printer = Arc::new(func);
     }
 
     #[cfg(test)]
@@ -517,7 +533,7 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
         match script_hash_type {
             ScriptHashType::Data | ScriptHashType::Data1 | ScriptHashType::Data2 => {
                 if let Some(lazy) = self.binaries_by_data_hash.get(&script.code_hash()) {
-                    Ok(lazy.access(&self.data_loader))
+                    Ok(lazy.access(&self.data_loader)?)
                 } else {
                     Err(ScriptError::ScriptNotFound(script.code_hash()))
                 }
@@ -525,8 +541,8 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
             ScriptHashType::Type => {
                 if let Some(ref bin) = self.binaries_by_type_hash.get(&script.code_hash()) {
                     match bin {
-                        Binaries::Unique(_, ref lazy) => Ok(lazy.access(&self.data_loader)),
-                        Binaries::Duplicate(_, ref lazy) => Ok(lazy.access(&self.data_loader)),
+                        Binaries::Unique(_, ref lazy) => Ok(lazy.access(&self.data_loader)?),
+                        Binaries::Duplicate(_, ref lazy) => Ok(lazy.access(&self.data_loader)?),
                         Binaries::Multiple => Err(ScriptError::MultipleMatches),
                     }
                 } else {
@@ -636,22 +652,27 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
     /// If verify is suspended, a state will returned.
     pub fn resumable_verify(&self, limit_cycles: Cycle) -> Result<VerifyResult, Error> {
         let mut cycles = 0;
+        let mut current_consumed_cycles = 0;
 
         let groups: Vec<_> = self.groups().collect();
         for (idx, (_hash, group)) in groups.iter().enumerate() {
             // vm should early return invalid cycles
-            let remain_cycles = limit_cycles.checked_sub(cycles).ok_or_else(|| {
-                ScriptError::Other(format!("expect invalid cycles {limit_cycles} {cycles}"))
-                    .source(group)
-            })?;
+            let remain_cycles = limit_cycles
+                .checked_sub(current_consumed_cycles)
+                .ok_or_else(|| {
+                    ScriptError::Other(format!("expect invalid cycles {limit_cycles} {cycles}"))
+                        .source(group)
+                })?;
 
-            match self.verify_group_with_chunk(group, remain_cycles, &[]) {
-                Ok(ChunkState::Completed(used_cycles)) => {
+            match self.verify_group_with_chunk(group, remain_cycles, &None) {
+                Ok(ChunkState::Completed(used_cycles, consumed_cycles)) => {
+                    current_consumed_cycles =
+                        wrapping_cycles_add(current_consumed_cycles, consumed_cycles, group)?;
                     cycles = wrapping_cycles_add(cycles, used_cycles, group)?;
                 }
-                Ok(ChunkState::Suspended(vms, context)) => {
+                Ok(ChunkState::Suspended(state)) => {
                     let current = idx;
-                    let state = TransactionState::new(vms, context, current, cycles, remain_cycles);
+                    let state = TransactionState::new(state, current, cycles, remain_cycles);
                     return Ok(VerifyResult::Suspended(state));
                 }
                 Err(e) => {
@@ -665,6 +686,42 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
         Ok(VerifyResult::Completed(cycles))
     }
 
+    /// Performing a resumable verification on the transaction scripts with signal channel,
+    /// if `Suspend` comes from `command_rx`, the process will be hang up until `Resume` comes,
+    /// otherwise, it will return until the verification is completed.
+    pub async fn resumable_verify_with_signal(
+        &self,
+        limit_cycles: Cycle,
+        command_rx: &mut Receiver<ChunkCommand>,
+    ) -> Result<Cycle, Error> {
+        let mut cycles = 0;
+
+        let groups: Vec<_> = self.groups().collect();
+        for (_hash, group) in groups.iter() {
+            // vm should early return invalid cycles
+            let remain_cycles = limit_cycles.checked_sub(cycles).ok_or_else(|| {
+                ScriptError::Other(format!("expect invalid cycles {limit_cycles} {cycles}"))
+                    .source(group)
+            })?;
+
+            match self
+                .verify_group_with_signal(group, remain_cycles, command_rx)
+                .await
+            {
+                Ok(used_cycles) => {
+                    cycles = wrapping_cycles_add(cycles, used_cycles, group)?;
+                }
+                Err(e) => {
+                    #[cfg(feature = "logging")]
+                    logging::on_script_error(_hash, &self.hash(), &e);
+                    return Err(e.source(group).into());
+                }
+            }
+        }
+
+        Ok(cycles)
+    }
+
     /// Resuming an suspended verify from snapshot
     ///
     /// ## Params
@@ -683,7 +740,6 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
         snap: &TransactionSnapshot,
         limit_cycles: Cycle,
     ) -> Result<VerifyResult, Error> {
-        let current_group_used = snap.snaps.iter().map(|s| s.1).sum();
         let mut cycles = snap.current_cycles;
         let mut current_used = 0;
 
@@ -693,18 +749,14 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
         })?;
 
         // continue snapshot current script
-        match self.verify_group_with_chunk(current_group, limit_cycles, &snap.snaps) {
-            Ok(ChunkState::Completed(used_cycles)) => {
-                current_used = wrapping_cycles_add(
-                    current_used,
-                    wrapping_cycles_sub(used_cycles, current_group_used, current_group)?,
-                    current_group,
-                )?;
+        match self.verify_group_with_chunk(current_group, limit_cycles, &snap.state) {
+            Ok(ChunkState::Completed(used_cycles, consumed_cycles)) => {
+                current_used = wrapping_cycles_add(current_used, consumed_cycles, current_group)?;
                 cycles = wrapping_cycles_add(cycles, used_cycles, current_group)?;
             }
-            Ok(ChunkState::Suspended(vms, context)) => {
+            Ok(ChunkState::Suspended(state)) => {
                 let current = snap.current;
-                let state = TransactionState::new(vms, context, current, cycles, limit_cycles);
+                let state = TransactionState::new(state, current, cycles, limit_cycles);
                 return Ok(VerifyResult::Suspended(state));
             }
             Err(e) => {
@@ -714,21 +766,20 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
             }
         }
 
-        let skip = snap.current + 1;
-        for (idx, (_hash, group)) in self.groups().enumerate().skip(skip) {
+        for (idx, (_hash, group)) in self.groups().enumerate().skip(snap.current + 1) {
             let remain_cycles = limit_cycles.checked_sub(current_used).ok_or_else(|| {
                 ScriptError::Other(format!("expect invalid cycles {limit_cycles} {cycles}"))
                     .source(group)
             })?;
 
-            match self.verify_group_with_chunk(group, remain_cycles, &[]) {
-                Ok(ChunkState::Completed(used_cycles)) => {
-                    current_used = wrapping_cycles_add(current_used, used_cycles, group)?;
+            match self.verify_group_with_chunk(group, remain_cycles, &None) {
+                Ok(ChunkState::Completed(used_cycles, consumed_cycles)) => {
+                    current_used = wrapping_cycles_add(current_used, consumed_cycles, group)?;
                     cycles = wrapping_cycles_add(cycles, used_cycles, group)?;
                 }
-                Ok(ChunkState::Suspended(vms, context)) => {
+                Ok(ChunkState::Suspended(state)) => {
                     let current = idx;
-                    let state = TransactionState::new(vms, context, current, cycles, remain_cycles);
+                    let state = TransactionState::new(state, current, cycles, remain_cycles);
                     return Ok(VerifyResult::Suspended(state));
                 }
                 Err(e) => {
@@ -762,9 +813,8 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
     ) -> Result<VerifyResult, Error> {
         let TransactionState {
             current,
-            mut vms,
+            state,
             current_cycles,
-            machine_context,
             ..
         } = state;
 
@@ -775,20 +825,16 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
             ScriptError::Other(format!("snapshot group missing {current:?}")).unknown_source()
         })?;
 
-        let resumed_script_result = if vms.is_empty() {
-            self.verify_group_with_chunk(current_group, limit_cycles, &[])
-        } else {
-            vms.iter_mut()
-                .for_each(|vm| vm.set_max_cycles(limit_cycles));
-            run_vms(current_group, limit_cycles, vms, &machine_context)
-        };
+        let resumed_script_result =
+            self.verify_group_with_chunk(current_group, limit_cycles, &state);
+
         match resumed_script_result {
-            Ok(ChunkState::Completed(used_cycles)) => {
-                current_used = wrapping_cycles_add(current_used, used_cycles, current_group)?;
+            Ok(ChunkState::Completed(used_cycles, consumed_cycles)) => {
+                current_used = wrapping_cycles_add(current_used, consumed_cycles, current_group)?;
                 cycles = wrapping_cycles_add(cycles, used_cycles, current_group)?;
             }
-            Ok(ChunkState::Suspended(vms, context)) => {
-                let state = TransactionState::new(vms, context, current, cycles, limit_cycles);
+            Ok(ChunkState::Suspended(state)) => {
+                let state = TransactionState::new(state, current, cycles, limit_cycles);
                 return Ok(VerifyResult::Suspended(state));
             }
             Err(e) => {
@@ -800,18 +846,20 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
 
         for (idx, (_hash, group)) in self.groups().enumerate().skip(current + 1) {
             let remain_cycles = limit_cycles.checked_sub(current_used).ok_or_else(|| {
-                ScriptError::Other(format!("expect invalid cycles {limit_cycles} {cycles}"))
-                    .source(group)
+                ScriptError::Other(format!(
+                    "expect invalid cycles {limit_cycles} {current_used} {cycles}"
+                ))
+                .source(group)
             })?;
 
-            match self.verify_group_with_chunk(group, remain_cycles, &[]) {
-                Ok(ChunkState::Completed(used_cycles)) => {
-                    current_used = wrapping_cycles_add(current_used, used_cycles, group)?;
-                    cycles = wrapping_cycles_add(cycles, used_cycles, group)?;
+            match self.verify_group_with_chunk(group, remain_cycles, &None) {
+                Ok(ChunkState::Completed(_, consumed_cycles)) => {
+                    current_used = wrapping_cycles_add(current_used, consumed_cycles, group)?;
+                    cycles = wrapping_cycles_add(cycles, consumed_cycles, group)?;
                 }
-                Ok(ChunkState::Suspended(vms, context)) => {
+                Ok(ChunkState::Suspended(state)) => {
                     let current = idx;
-                    let state = TransactionState::new(vms, context, current, cycles, remain_cycles);
+                    let state = TransactionState::new(state, current, cycles, remain_cycles);
                     return Ok(VerifyResult::Suspended(state));
                 }
                 Err(e) => {
@@ -853,11 +901,11 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
 
         // continue snapshot current script
         // max_cycles - cycles checked
-        match self.verify_group_with_chunk(current_group, max_cycles - cycles, &snap.snaps) {
-            Ok(ChunkState::Completed(used_cycles)) => {
+        match self.verify_group_with_chunk(current_group, max_cycles - cycles, &snap.state) {
+            Ok(ChunkState::Completed(used_cycles, _consumed_cycles)) => {
                 cycles = wrapping_cycles_add(cycles, used_cycles, current_group)?;
             }
-            Ok(ChunkState::Suspended(_, _)) => {
+            Ok(ChunkState::Suspended(_)) => {
                 return Err(ScriptError::ExceededMaximumCycles(max_cycles)
                     .source(current_group)
                     .into());
@@ -875,11 +923,11 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
                     .source(group)
             })?;
 
-            match self.verify_group_with_chunk(group, remain_cycles, &[]) {
-                Ok(ChunkState::Completed(used_cycles)) => {
+            match self.verify_group_with_chunk(group, remain_cycles, &None) {
+                Ok(ChunkState::Completed(used_cycles, _consumed_cycles)) => {
                     cycles = wrapping_cycles_add(cycles, used_cycles, current_group)?;
                 }
-                Ok(ChunkState::Suspended(_, _)) => {
+                Ok(ChunkState::Suspended(_)) => {
                     return Err(ScriptError::ExceededMaximumCycles(max_cycles)
                         .source(group)
                         .into());
@@ -950,7 +998,7 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
         &self,
         group: &ScriptGroup,
         max_cycles: Cycle,
-        snaps: &[(Snapshot, Cycle, ResumePoint)],
+        state: &Option<FullSuspendedState>,
     ) -> Result<ChunkState, ScriptError> {
         if group.script.code_hash() == TYPE_ID_CODE_HASH.pack()
             && Into::<u8>::into(group.script.hash_type()) == Into::<u8>::into(ScriptHashType::Type)
@@ -961,12 +1009,87 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
                 max_cycles,
             };
             match verifier.verify() {
-                Ok(cycles) => Ok(ChunkState::Completed(cycles)),
+                Ok(cycles) => Ok(ChunkState::Completed(cycles, cycles)),
                 Err(ScriptError::ExceededMaximumCycles(_)) => Ok(ChunkState::suspended_type_id()),
                 Err(e) => Err(e),
             }
         } else {
-            self.chunk_run(group, max_cycles, snaps)
+            self.chunk_run(group, max_cycles, state)
+        }
+    }
+
+    fn chunk_run(
+        &self,
+        script_group: &ScriptGroup,
+        max_cycles: Cycle,
+        state: &Option<FullSuspendedState>,
+    ) -> Result<ChunkState, ScriptError> {
+        let program = self.extract_script(&script_group.script)?;
+        let tx_data = TxData {
+            rtx: Arc::clone(&self.rtx),
+            data_loader: self.data_loader.clone(),
+            program,
+            script_group: Arc::new(script_group.clone()),
+        };
+        let version = self.select_version(&script_group.script)?;
+        let mut scheduler = if let Some(state) = state {
+            Scheduler::resume(
+                tx_data,
+                version,
+                self.syscalls_generator.clone(),
+                state.clone(),
+            )
+        } else {
+            Scheduler::new(tx_data, version, self.syscalls_generator.clone())
+        };
+        let map_vm_internal_error = |error: VMInternalError| match error {
+            VMInternalError::CyclesExceeded => ScriptError::ExceededMaximumCycles(max_cycles),
+            _ => ScriptError::VMInternalError(error),
+        };
+        let previous_cycles = scheduler.consumed_cycles();
+        let res = scheduler.run(RunMode::LimitCycles(max_cycles));
+        match res {
+            Ok((exit_code, cycles)) => {
+                if exit_code == 0 {
+                    Ok(ChunkState::Completed(
+                        cycles,
+                        scheduler.consumed_cycles() - previous_cycles,
+                    ))
+                } else {
+                    Err(ScriptError::validation_failure(
+                        &script_group.script,
+                        exit_code,
+                    ))
+                }
+            }
+            Err(error) => match error {
+                VMInternalError::CyclesExceeded | VMInternalError::Pause => {
+                    let snapshot = scheduler.suspend().map_err(map_vm_internal_error)?;
+                    Ok(ChunkState::suspended(snapshot))
+                }
+                _ => Err(map_vm_internal_error(error)),
+            },
+        }
+    }
+
+    async fn verify_group_with_signal(
+        &self,
+        group: &ScriptGroup,
+        max_cycles: Cycle,
+        command_rx: &mut Receiver<ChunkCommand>,
+    ) -> Result<Cycle, ScriptError> {
+        if group.script.code_hash() == TYPE_ID_CODE_HASH.pack()
+            && Into::<u8>::into(group.script.hash_type()) == Into::<u8>::into(ScriptHashType::Type)
+        {
+            let verifier = TypeIdSystemScript {
+                rtx: &self.rtx,
+                script_group: group,
+                max_cycles,
+            };
+            verifier.verify()
+        } else {
+            self.chunk_run_with_signal(group, max_cycles, command_rx)
+                .await
         }
     }
 
@@ -987,29 +1110,30 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
         &self,
         script_version: ScriptVersion,
         script_group: &ScriptGroup,
-        context: Arc<Mutex<MachineContext>>,
+        snapshot2_context: Arc<Mutex<Snapshot2Context<DataPieceId, TxData<DL>>>>,
     ) -> Vec<Box<(dyn Syscalls<CoreMachine>)>> {
-        self.generator
-            .generate_root_syscalls(script_version, script_group, context)
+        self.syscalls_generator
+            .generate_syscalls(script_version, script_group, snapshot2_context)
     }
 
-    fn build_machine(
+    /// Create a scheduler to manage virtual machine instances.
+    pub fn create_scheduler(
         &self,
         script_group: &ScriptGroup,
-        max_cycles: Cycle,
-        context: Arc<Mutex<MachineContext>>,
-    ) -> Result<Machine, ScriptError> {
-        let script_version = self.select_version(&script_group.script)?;
-        let core_machine = script_version.init_core_machine(max_cycles);
-        let machine_builder = DefaultMachineBuilder::<CoreMachine>::new(core_machine)
-            .instruction_cycle_func(Box::new(estimate_cycles));
-        let syscalls = self.generate_syscalls(script_version, script_group, context);
-        let machine_builder = syscalls
-            .into_iter()
-            .fold(machine_builder, |builder, syscall| builder.syscall(syscall));
-        let default_machine = machine_builder.build();
-        let machine = Machine::new(default_machine);
-        Ok(machine)
+    ) -> Result<Scheduler<DL>, ScriptError> {
+        let program = self.extract_script(&script_group.script)?;
+        let tx_data = TxData {
+            rtx: Arc::clone(&self.rtx),
+            data_loader: self.data_loader.clone(),
+            program,
+            script_group: Arc::new(script_group.clone()),
+        };
+        let version = self.select_version(&script_group.script)?;
+        Ok(Scheduler::new(
+            tx_data,
+            version,
+            self.syscalls_generator.clone(),
+        ))
     }
 
     /// Runs a single program, then returns the exit code together with the entire
@@ -1018,214 +1142,129 @@ impl<DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + C
         &self,
         script_group: &ScriptGroup,
         max_cycles: Cycle,
-    ) -> Result<(i8, Machine), ScriptError> {
-        let program = self.extract_script(&script_group.script)?;
-        let context = Default::default();
-        let mut machine = self.build_machine(script_group, max_cycles, context)?;
-
+    ) -> Result<(i8, Cycle), ScriptError> {
+        let mut scheduler = self.create_scheduler(script_group)?;
         let map_vm_internal_error = |error: VMInternalError| match error {
             VMInternalError::CyclesExceeded => ScriptError::ExceededMaximumCycles(max_cycles),
             _ => ScriptError::VMInternalError(error),
         };
-
-        let bytes = machine
-            .load_program(&program, &[])
-            .map_err(map_vm_internal_error)?;
-        machine
-            .machine
-            .add_cycles_no_checking(transferred_byte_cycles(bytes))
-            .map_err(map_vm_internal_error)?;
-        let code = machine.run().map_err(map_vm_internal_error)?;
-
-        Ok((code, machine))
+        scheduler
+            .run(RunMode::LimitCycles(max_cycles))
+            .map_err(map_vm_internal_error)
     }
 
     fn run(&self, script_group: &ScriptGroup, max_cycles: Cycle) -> Result<Cycle, ScriptError> {
-        let (code, machine) = self.detailed_run(script_group, max_cycles)?;
+        let (code, cycles) = self.detailed_run(script_group, max_cycles)?;
 
         if code == 0 {
-            Ok(machine.machine.cycles())
+            Ok(cycles)
         } else {
             Err(ScriptError::validation_failure(&script_group.script, code))
         }
     }
 
-    fn chunk_run(
+    async fn chunk_run_with_signal(
         &self,
         script_group: &ScriptGroup,
         max_cycles: Cycle,
-        snaps: &[(Snapshot, Cycle, ResumePoint)],
-    ) -> Result<ChunkState, ScriptError> {
-        let context: Arc<Mutex<MachineContext>> = Default::default();
-
+        signal: &mut Receiver<ChunkCommand>,
+    ) -> Result<Cycle, ScriptError> {
+        let program = self.extract_script(&script_group.script)?;
+        let tx_data = TxData {
+            rtx: Arc::clone(&self.rtx),
+            data_loader: self.data_loader.clone(),
+            program,
+            script_group: Arc::new(script_group.clone()),
+        };
+        let version = self.select_version(&script_group.script)?;
+        let mut scheduler = Scheduler::new(tx_data, version, self.syscalls_generator.clone());
         let map_vm_internal_error = |error: VMInternalError| match error {
             VMInternalError::CyclesExceeded => ScriptError::ExceededMaximumCycles(max_cycles),
             _ => ScriptError::VMInternalError(error),
         };
 
-        let machines = if !snaps.is_empty() {
-            // Resume machines from snapshots
-            let mut machines = vec![];
-            for (sp, current_cycle, resume_point) in snaps {
-                let mut machine = match resume_point {
-                    ResumePoint::Initial => ResumableMachine::initial(self.build_machine(
-                        script_group,
-                        max_cycles,
-                        Arc::clone(&context),
-                    )?),
-                    ResumePoint::Spawn {
-                        callee_peak_memory,
-                        callee_memory_limit,
-                        content,
-                        content_length,
-                        caller_exit_code_addr,
-                        caller_content_addr,
-                        caller_content_length_addr,
-                        cycles_base,
-                    } => {
-                        let spawn_data = SpawnData {
-                            callee_peak_memory: *callee_peak_memory,
-                            callee_memory_limit: *callee_memory_limit,
-                            content: Arc::new(Mutex::new(content.clone())),
-                            content_length: *content_length,
-                            caller_exit_code_addr: *caller_exit_code_addr,
-                            caller_content_addr: *caller_content_addr,
-                            caller_content_length_addr: *caller_content_length_addr,
-                            cycles_base: *cycles_base,
-                        };
-                        let machine = build_child_machine(
-                            script_group,
-                            self.select_version(&script_group.script)?,
-                            &self.generator,
-                            max_cycles,
-                            &spawn_data,
-                            &context,
-                        )
-                        .map_err(map_vm_internal_error)?;
-                        ResumableMachine::spawn(machine, spawn_data)
+        let mut pause = VMPause::new();
+        let child_pause = pause.clone();
+        let (finish_tx, mut finish_rx) = oneshot::channel::<Result<(i8, Cycle), ckb_vm::Error>>();
+
+        // send initial `Resume` command to child
+        // it's maybe useful to set initial command to `signal.borrow().to_owned()`
+        // so that we can control the initial state of child, which is useful for testing purpose
+        let (child_tx, mut child_rx) = watch::channel(ChunkCommand::Resume);
+        let jh = tokio::spawn(async move {
+            child_rx.mark_changed();
+            loop {
+                let pause_cloned = child_pause.clone();
+                let _ = child_rx.changed().await;
+                match *child_rx.borrow() {
+                    ChunkCommand::Stop => {
+                        let exit = Err(ckb_vm::Error::External("stopped".into()));
+                        let _ = finish_tx.send(exit);
+                        return;
+                    }
+                    ChunkCommand::Suspend => {
+                        continue;
+                    }
+                    ChunkCommand::Resume => {
+                        //info!("[verify-test] run_vms_child: resume");
+                        let res = scheduler.run(RunMode::Pause(pause_cloned));
+                        match res {
+                            Ok(_) => {
+                                let _ = finish_tx.send(res);
+                                return;
+                            }
+                            Err(VMInternalError::Pause) => {
+                                // continue to wait for
+                            }
+                            _ => {
+                                let _ = finish_tx.send(res);
+                                return;
+                            }
+                        }
                     }
-                };
-                resume(&mut machine.machine_mut().machine, sp).map_err(map_vm_internal_error)?;
-                machine.machine_mut().machine.set_cycles(*current_cycle);
-                machines.push(machine);
-            }
-            machines
-        } else {
-            // No snapshots are available, create machine from scratch
-            let mut machine = self.build_machine(script_group, max_cycles, Arc::clone(&context))?;
-            let program = self.extract_script(&script_group.script)?;
-            let bytes = machine
-                .load_program(&program, &[])
-                .map_err(map_vm_internal_error)?;
-            let program_bytes_cycles = transferred_byte_cycles(bytes);
-            // NOTE: previously, we made a distinction between machines
-            // that completes program loading without errors, and machines
-            // that fail program loading due to cycle limits. For the latter
-            // one, we won't generate any snapshots. Starting from this version,
-            // we will remove this distinction: when loading program exceeds
-            // maximum cycles, the error will be triggered when executing the
-            // first instruction. As a result, now all ResumableMachine will
-            // be transformed to snapshots. This is due to several considerations:
-            //
-            // * Let's do a little bit math: right now CKB has a block limit of
-            // ~570KB, a single transaction is further limited to 512KB in RPC,
-            // the biggest program one can load is either 512KB or ~570KB depending
-            // on which limit to use. The cycles consumed to load a program, is
-            // thus at most 131072 or ~145920, which is far less than the cycle
-            // limit for running a single transaction (70 million or more). In
-            // reality it might be extremely rare that loading a program would
-            // result in exceeding cycle limits. Removing the distinction here,
-            // would help simply the code.
-            // * If you pay attention to the code now, we already have this behavior
-            // in the code: most syscalls use +add_cycles_no_checking+ in the code,
-            // meaning an error would not be immediately generated when cycle limit
-            // is reached, the error would be raised when executing the first instruction
-            // after the syscall. What's more, when spawn is loading a program
-            // to its child machine, it also uses +add_cycles_no_checking+ so it
-            // won't generate errors immediately. This means that all spawned machines
-            // will be in a state that a program is loaded, regardless of the fact if
-            // loading a program in spawn reaches the cycle limit or not. As a
-            // result, we definitely want to pull the trigger, so we can have unified
-            // behavior everywhere.
-            machine
-                .machine
-                .add_cycles_no_checking(program_bytes_cycles)
-                .map_err(ScriptError::VMInternalError)?;
-            vec![ResumableMachine::initial(machine)]
-        };
-
-        run_vms(script_group, max_cycles, machines, &context)
-    }
-}
-
-// Run a series of VMs that are just freshly resumed
-fn run_vms(
-    script_group: &ScriptGroup,
-    max_cycles: Cycle,
-    mut machines: Vec<ResumableMachine>,
-    context: &Arc<Mutex<MachineContext>>,
-) -> Result<ChunkState, ScriptError> {
-    let (mut exit_code, mut cycles, mut spawn_data) = (0, 0, None);
-
-    if machines.is_empty() {
-        return Err(ScriptError::Other(
-            "To resume VMs, at least one VM must be available!".to_string(),
-        ));
-    }
-
-    let map_vm_internal_error = |error: VMInternalError| match error {
-        VMInternalError::CyclesExceeded => ScriptError::ExceededMaximumCycles(max_cycles),
-        _ => ScriptError::VMInternalError(error),
-    };
-
-    while let Some(mut machine) = machines.pop() {
-        if let Some(callee_spawn_data) = &spawn_data {
-            update_caller_machine(
-                &mut machine.machine_mut().machine,
-                exit_code,
-                cycles,
-                callee_spawn_data,
-            )
-            .map_err(map_vm_internal_error)?;
-        }
-
-        match machine.run() {
-            Ok(code) => {
-                exit_code = code;
-                cycles = machine.cycles();
-                if let ResumableMachine::Spawn(_, data) = machine {
-                    spawn_data = Some(data);
-                } else {
-                    spawn_data = None;
                 }
             }
-            Err(error) => match error {
-                VMInternalError::CyclesExceeded => {
-                    let mut new_suspended_machines: Vec<_> = {
-                        let mut context = context.lock().map_err(|e| {
-                            ScriptError::Other(format!("Failed to acquire lock: {}", e))
-                        })?;
-                        context.suspended_machines.drain(..).collect()
-                    };
-                    // The inner most machine lives at the top of the vector,
-                    // reverse the list for natural order.
-                    new_suspended_machines.reverse();
-                    machines.push(machine);
-                    machines.append(&mut new_suspended_machines);
-                    return Ok(ChunkState::suspended(machines, Arc::clone(context)));
+        });
+
+        loop {
+            tokio::select! {
+                Ok(_) = signal.changed() => {
+                    let command = signal.borrow().to_owned();
+                    //info!("[verify-test] run_vms_with_signal: {:?}", command);
+                    match command {
+                        ChunkCommand::Suspend => {
+                            pause.interrupt();
+                        }
+                        ChunkCommand::Stop => {
+                            pause.interrupt();
+                            let _ = child_tx.send(command);
+                        }
+                        ChunkCommand::Resume => {
+                            pause.free();
+                            let _ = child_tx.send(command);
+                        }
+                    }
                 }
-                _ => return Err(ScriptError::VMInternalError(error)),
-            },
-        };
-    }
+                Ok(res) = &mut finish_rx => {
+                    let _ = jh.await;
+                    match res {
+                        Ok((0, cycles)) => {
+                            return Ok(cycles);
+                        }
+                        Ok((exit_code, _cycles)) => {
+                            return Err(ScriptError::validation_failure(
+                                &script_group.script,
+                                exit_code
+                            ))},
+                        Err(err) => {
+                            return Err(map_vm_internal_error(err));
+                        }
+                    }
 
-    if exit_code == 0 {
-        Ok(ChunkState::Completed(cycles))
-    } else {
-        Err(ScriptError::validation_failure(
-            &script_group.script,
-            exit_code,
-        ))
+                }
+                else => { break Err(ScriptError::validation_failure(&script_group.script, 0)) }
+            }
+        }
     }
 }
 
@@ -1238,15 +1277,6 @@ fn wrapping_cycles_add(
         .ok_or_else(|| ScriptError::CyclesOverflow(lhs, rhs).source(group))
 }
 
-fn wrapping_cycles_sub(
-    lhs: Cycle,
-    rhs: Cycle,
-    group: &ScriptGroup,
-) -> Result<Cycle, TransactionScriptError> {
-    lhs.checked_sub(rhs)
-        .ok_or_else(|| ScriptError::CyclesOverflow(lhs, rhs).source(group))
-}
-
 #[cfg(feature = "logging")]
 mod logging {
     use super::{info, Byte32, ScriptError};
diff --git a/script/src/verify/tests/ckb_latest/features_since_v2019.rs b/script/src/verify/tests/ckb_latest/features_since_v2019.rs
index 4a25ef1602..a69c887575 100644
--- a/script/src/verify/tests/ckb_latest/features_since_v2019.rs
+++ b/script/src/verify/tests/ckb_latest/features_since_v2019.rs
@@ -49,7 +49,7 @@ fn check_always_success_hash() {
 
     let verifier = TransactionScriptsVerifierWithEnv::new();
     let result = verifier.verify_without_limit(script_version, &rtx);
-    assert!(result.is_ok());
+    assert_eq!(result.ok(), Some(ALWAYS_SUCCESS_SCRIPT_CYCLE));
 }
 
 #[test]
@@ -119,7 +119,7 @@ fn check_signature() {
     );
 
     let result = verifier.verify_without_limit(script_version, &rtx);
-    assert!(result.is_ok());
+    assert_eq!(result.ok(), Some(ALWAYS_SUCCESS_SCRIPT_CYCLE));
 }
 
 #[test]
@@ -187,7 +187,11 @@ fn check_signature_referenced_via_type_hash() {
 
     let verifier = TransactionScriptsVerifierWithEnv::new();
     let result = verifier.verify_without_limit(script_version, &rtx);
-    assert!(result.is_ok());
+    if script_version == ScriptVersion::V0 {
+        assert_eq!(result.ok(), Some(ALWAYS_SUCCESS_SCRIPT_CYCLE));
+    } else {
+        assert_eq!(result.ok(), Some(ALWAYS_SUCCESS_SCRIPT_CYCLE + 2));
+    }
 }
 
 #[test]
@@ -378,7 +382,7 @@ fn check_output_contract() {
 
     let verifier = TransactionScriptsVerifierWithEnv::new();
     let result = verifier.verify_without_limit(script_version, &rtx);
-    assert!(result.is_ok());
+    assert_eq!(result.ok(), Some(1074));
 }
 
 #[test]
@@ -574,6 +578,7 @@ fn check_type_id_one_in_one_out() {
     let max_cycles = TYPE_ID_CYCLES * 2;
     let verifier = TransactionScriptsVerifierWithEnv::new();
     let result = verifier.verify(script_version, &rtx, max_cycles);
+
     assert!(
         result.is_ok(),
         "expect ok, but got {:?}",
diff --git a/script/src/verify/tests/ckb_latest/features_since_v2021.rs b/script/src/verify/tests/ckb_latest/features_since_v2021.rs
index e2ba122d09..5ffea363ce 100644
--- a/script/src/verify/tests/ckb_latest/features_since_v2021.rs
+++ b/script/src/verify/tests/ckb_latest/features_since_v2021.rs
@@ -57,6 +57,8 @@ fn test_hint_instructions() {
         };
         let script_error = ScriptError::VMInternalError(vm_error);
         assert_error_eq!(result.unwrap_err(), script_error.input_lock_script(0));
+    } else {
+        assert_eq!(result.ok(), Some(540));
     }
 }
 
@@ -100,13 +102,21 @@ fn test_b_extension() {
     let verifier = TransactionScriptsVerifierWithEnv::new();
     let result = verifier.verify_without_limit(script_version, &rtx);
     assert_eq!(result.is_ok(), script_version >= ScriptVersion::V1,);
-    if script_version < ScriptVersion::V1 {
-        let vm_error = VmError::InvalidInstruction {
-            pc: 0x10182,
-            instruction: 0x60291913,
-        };
-        let script_error = ScriptError::VMInternalError(vm_error);
-        assert_error_eq!(result.unwrap_err(), script_error.input_lock_script(0));
+    match script_version {
+        ScriptVersion::V0 => {
+            let vm_error = VmError::InvalidInstruction {
+                pc: 65866,
+                instruction: 0x60291913,
+            };
+            let script_error = ScriptError::VMInternalError(vm_error);
+            assert_error_eq!(result.unwrap_err(), script_error.input_lock_script(0));
+        }
+        ScriptVersion::V1 => {
+            assert_eq!(result.ok(), Some(1876));
+        }
+        ScriptVersion::V2 => {
+            assert_eq!(result.ok(), Some(1875));
+        }
     }
 }
 
@@ -372,6 +382,11 @@ fn check_exec_from_witness() {
     let verifier = TransactionScriptsVerifierWithEnv::new();
     let result = verifier.verify_without_limit(script_version, &rtx);
     assert_eq!(result.is_ok(), script_version >= ScriptVersion::V1);
+    if script_version == ScriptVersion::V1 {
+        assert_eq!(result.ok(), Some(1200));
+    } else if script_version == ScriptVersion::V2 {
+        assert_eq!(result.ok(), Some(76198));
+    }
 }
 
 #[test]
@@ -408,6 +423,42 @@ fn check_exec_wrong_callee_format() {
     assert!(result.is_err());
 }
 
+#[tokio::test]
+async fn async_check_exec_wrong_callee_format() {
+    let script_version = SCRIPT_VERSION;
+
+    let (exec_caller_cell, exec_caller_data_hash) =
+        load_cell_from_path("testdata/exec_caller_from_cell_data");
+    let (exec_callee_cell, _exec_caller_data_hash) =
+        load_cell_from_slice(&[0x00, 0x01, 0x02, 0x03]);
+
+    let exec_caller_script = Script::new_builder()
+        .hash_type(script_version.data_hash_type().into())
+        .code_hash(exec_caller_data_hash)
+        .build();
+    let output = CellOutputBuilder::default()
+        .capacity(capacity_bytes!(100).pack())
+        .lock(exec_caller_script)
+        .build();
+    let input = CellInput::new(OutPoint::null(), 0);
+
+    let transaction = TransactionBuilder::default().input(input).build();
+    let dummy_cell = create_dummy_cell(output);
+
+    let rtx = ResolvedTransaction {
+        transaction,
+        resolved_cell_deps: vec![exec_caller_cell, exec_callee_cell],
+        resolved_inputs: vec![dummy_cell],
+        resolved_dep_groups: vec![],
+    };
+
+    let verifier = TransactionScriptsVerifierWithEnv::new();
+    let result = verifier
+        .verify_without_limit_async(script_version, &rtx)
+        .await;
+    assert!(result.is_err());
+}
+
 #[test]
 fn check_exec_big_offset_length() {
     let script_version = SCRIPT_VERSION;
@@ -502,29 +553,30 @@ fn _check_type_id_one_in_one_out_resume(step_cycles: Cycle) -> Result<(), TestCa
 
     verifier.verify_map(script_version, &rtx, |verifier| {
         let mut groups: VecDeque<_> = verifier.groups_with_type().collect();
-        let mut tmp: Option<ResumableMachine> = None;
+        let mut tmp: Option<FullSuspendedState> = None;
+        let mut current_group = None;
         let mut limit = step_cycles;
 
         loop {
-            if let Some(mut vm) = tmp.take() {
-                vm.set_max_cycles(limit);
-                match vm.run() {
-                    Ok(code) => {
-                        if code == 0 {
-                            cycles += vm.cycles();
-                            groups.pop_front();
-                        } else {
-                            unreachable!()
-                        }
+            if let Some(cur_state) = tmp.take() {
+                match verifier.verify_group_with_chunk(
+                    current_group.unwrap(),
+                    limit,
+                    &Some(cur_state),
+                ) {
+                    Ok(ChunkState::Completed(used_cycles, _consumed_cycles)) => {
+                        cycles += used_cycles;
+                        groups.pop_front();
+                        tmp = None;
+                    }
+                    Ok(ChunkState::Suspended(suspend_state)) => {
+                        tmp = suspend_state;
+                        limit += step_cycles;
+                        continue;
+                    }
+                    Err(_error) => {
+                        unreachable!();
                     }
-                    Err(error) => match error {
-                        VMInternalError::CyclesExceeded => {
-                            tmp = Some(vm);
-                            limit += step_cycles;
-                            continue;
-                        }
-                        _ => unreachable!(),
-                    },
                 }
             }
             if groups.is_empty() {
@@ -532,19 +584,22 @@ fn _check_type_id_one_in_one_out_resume(step_cycles: Cycle) -> Result<(), TestCa
             }
 
             while let Some((ty, _, group)) = groups.front().cloned() {
-                match verifier.verify_group_with_chunk(group, limit, &[]).unwrap() {
-                    ChunkState::Completed(used_cycles) => {
+                match verifier
+                    .verify_group_with_chunk(group, limit, &tmp)
+                    .unwrap()
+                {
+                    ChunkState::Completed(used_cycles, _consumed_cycles) => {
                         cycles += used_cycles;
                         groups.pop_front();
+                        tmp = None;
                         if groups.front().is_some() {
                             limit = step_cycles;
                         }
                     }
-                    ChunkState::Suspended(mut vms, _) => {
-                        assert!(vms.len() <= 1);
-                        let vm = vms.pop();
-                        if vm.is_some() {
-                            tmp = vm;
+                    ChunkState::Suspended(suspend_state) => {
+                        if suspend_state.is_some() {
+                            tmp = suspend_state;
+                            current_group = Some(group);
                         } else if ty == ScriptGroupType::Type // fast forward
                             && step_cycles > TYPE_ID_CYCLES
                             && limit < (TYPE_ID_CYCLES - step_cycles)
@@ -703,49 +758,33 @@ fn _check_typical_secp256k1_blake160_2_in_2_out_tx_with_chunk(step_cycles: Cycle
     let verifier = TransactionScriptsVerifierWithEnv::new();
     let result = verifier.verify_map(script_version, &rtx, |verifier| {
         let mut groups: Vec<_> = verifier.groups_with_type().collect();
-        let mut tmp: Option<ResumableMachine> = None;
+        let mut tmp = None;
         let mut limit = step_cycles;
 
         loop {
-            if let Some(mut vm) = tmp.take() {
-                vm.set_max_cycles(limit);
-                match vm.run() {
-                    Ok(code) => {
-                        if code == 0 {
-                            cycles += vm.cycles();
-                        } else {
-                            unreachable!()
-                        }
-                    }
-                    Err(error) => match error {
-                        VMInternalError::CyclesExceeded => {
-                            tmp = Some(vm);
-                            limit += step_cycles;
-                            continue;
-                        }
-                        _ => unreachable!(),
-                    },
-                }
-            }
-            while let Some((_, _, group)) = groups.pop() {
-                match verifier.verify_group_with_chunk(group, limit, &[]).unwrap() {
-                    ChunkState::Completed(used_cycles) => {
+            while let Some(group) = groups.pop() {
+                match verifier
+                    .verify_group_with_chunk(group.2, limit, &tmp)
+                    .unwrap()
+                {
+                    ChunkState::Completed(used_cycles, _consumed_cycles) => {
                         cycles += used_cycles;
+                        tmp = None;
                     }
-                    ChunkState::Suspended(mut vms, _) => {
-                        assert!(vms.len() <= 1);
-                        tmp = vms.pop();
+                    ChunkState::Suspended(snapshot) => {
+                        tmp = snapshot;
                         if limit < (TWO_IN_TWO_OUT_CYCLES - step_cycles) {
                             limit += TWO_IN_TWO_OUT_CYCLES - step_cycles;
                         } else {
                             limit += step_cycles;
                         }
+                        groups.push(group);
                         break;
                     }
                 }
             }
 
-            if tmp.is_none() {
+            if groups.is_empty() {
                 break;
             }
         }
@@ -768,6 +807,13 @@ fn _check_typical_secp256k1_blake160_2_in_2_out_tx_with_chunk(step_cycles: Cycle
         );
     }
     assert_eq!(cycles, cycles_once, "step_cycles {step_cycles}");
+    // Note that different rand versions may cause different randomly
+    // generated tx data, which in turn leads to different final cycles.
+    if script_version < crate::ScriptVersion::V2 {
+        assert_eq!(cycles, 3334802);
+    } else {
+        assert_eq!(cycles, 3225879);
+    }
 }
 
 #[test]
@@ -840,10 +886,10 @@ fn check_typical_secp256k1_blake160_2_in_2_out_tx_with_state() {
 
 fn _check_typical_secp256k1_blake160_2_in_2_out_tx_with_snap(step_cycles: Cycle) {
     let script_version = SCRIPT_VERSION;
-
     let rtx = random_2_in_2_out_rtx();
     let mut cycles = 0;
     let verifier = TransactionScriptsVerifierWithEnv::new();
+
     let result = verifier.verify_map(script_version, &rtx, |verifier| {
         #[allow(unused_assignments)]
         let mut init_snap: Option<TransactionSnapshot> = None;
@@ -965,12 +1011,22 @@ fn check_typical_secp256k1_blake160_2_in_2_out_tx_with_complete() {
 
     let cycles_once = result.unwrap();
     assert!(cycles <= TWO_IN_TWO_OUT_CYCLES);
+
     if script_version == crate::ScriptVersion::V2 {
         assert!(cycles >= TWO_IN_TWO_OUT_CYCLES - V2_CYCLE_BOUND);
     } else {
         assert!(cycles >= TWO_IN_TWO_OUT_CYCLES - CYCLE_BOUND);
     }
     assert_eq!(cycles, cycles_once);
+    // Note that different rand versions may cause different randomly
+    // generated tx data, which in turn leads to different final cycles.
+    if script_version <= ScriptVersion::V0 {
+        assert_eq!(cycles, 3352333);
+    } else if script_version == ScriptVersion::V1 {
+        assert_eq!(cycles, 3334802);
+    } else if script_version == ScriptVersion::V2 {
+        assert_eq!(cycles, 3225879);
+    }
 }
 
 #[test]
@@ -1018,10 +1074,14 @@ fn load_code_into_global() {
     let verifier = TransactionScriptsVerifierWithEnv::new();
     let result = verifier.verify_without_limit(script_version, &rtx);
     assert_eq!(result.is_ok(), script_version >= ScriptVersion::V1,);
-    if script_version < ScriptVersion::V1 {
+    if script_version < ScriptVersion::V0 {
         let vm_error = VmError::MemWriteOnFreezedPage;
         let script_error = ScriptError::VMInternalError(vm_error);
         assert_error_eq!(result.unwrap_err(), script_error.input_lock_script(0));
+    } else if script_version == ScriptVersion::V1 {
+        assert_eq!(result.ok(), Some(10529));
+    } else if script_version == ScriptVersion::V2 {
+        assert_eq!(result.ok(), Some(10525));
     }
 }
 
@@ -1095,6 +1155,13 @@ fn load_code_with_snapshot() {
 
     let cycles_once = result.unwrap();
     assert_eq!(cycles, cycles_once);
+    if script_version == ScriptVersion::V0 {
+        assert_eq!(cycles_once, 11062);
+    } else if script_version == ScriptVersion::V1 {
+        assert_eq!(cycles_once, 11064);
+    } else {
+        assert_eq!(cycles_once, 11060);
+    }
 }
 
 #[test]
@@ -1188,6 +1255,13 @@ fn load_code_with_snapshot_more_times() {
     let result = verifier.verify_without_pause(script_version, &rtx, max_cycles);
     let cycles_once = result.unwrap();
     assert_eq!(cycles, cycles_once);
+    if script_version == ScriptVersion::V0 {
+        assert_eq!(cycles_once, 45740);
+    } else if script_version == ScriptVersion::V1 {
+        assert_eq!(cycles_once, 45742);
+    } else {
+        assert_eq!(cycles_once, 45729);
+    }
 }
 
 #[derive(Clone, Copy)]
@@ -1788,5 +1862,43 @@ fn check_signature_referenced_via_type_hash_ok_with_multiple_matches() {
 
     let verifier = TransactionScriptsVerifierWithEnv::new();
     let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.unwrap(), 539);
+    assert_eq!(result.ok(), Some(539));
+}
+
+#[test]
+fn check_exec_callee_pause() {
+    let script_version = SCRIPT_VERSION;
+    if script_version < crate::ScriptVersion::V1 {
+        return;
+    }
+
+    let (exec_caller_cell, exec_caller_data_hash) =
+        load_cell_from_path("testdata/exec_caller_from_cell_data");
+    let (exec_callee_cell, _exec_callee_data_hash) =
+        load_cell_from_path("testdata/exec_callee_pause");
+
+    let exec_caller_script = Script::new_builder()
+        .hash_type(script_version.data_hash_type().into())
+        .code_hash(exec_caller_data_hash)
+        .build();
+    let output = CellOutputBuilder::default()
+        .capacity(capacity_bytes!(100).pack())
+        .lock(exec_caller_script)
+        .build();
+    let input = CellInput::new(OutPoint::null(), 0);
+
+    let transaction = TransactionBuilder::default().input(input).build();
+    let dummy_cell = create_dummy_cell(output);
+
+    let rtx = ResolvedTransaction {
+        transaction,
+        resolved_cell_deps: vec![exec_caller_cell, exec_callee_cell],
+        resolved_inputs: vec![dummy_cell],
+        resolved_dep_groups: vec![],
+    };
+
+    let verifier = TransactionScriptsVerifierWithEnv::new();
+    let result = verifier.verify_until_completed(script_version, &rtx);
+    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V1);
+    assert_eq!(result.unwrap().1, 6);
 }
diff --git a/script/src/verify/tests/ckb_latest/features_since_v2023.rs b/script/src/verify/tests/ckb_latest/features_since_v2023.rs
index aafed8439d..4cb4fd8583 100644
--- a/script/src/verify/tests/ckb_latest/features_since_v2023.rs
+++ b/script/src/verify/tests/ckb_latest/features_since_v2023.rs
@@ -1,48 +1,26 @@
+use super::SCRIPT_VERSION;
+use crate::scheduler::{MAX_FDS, MAX_VMS_COUNT};
+use crate::syscalls::SOURCE_GROUP_FLAG;
+use crate::verify::{tests::utils::*, *};
 use ckb_types::{
-    core::{capacity_bytes, Capacity, TransactionBuilder},
+    core::{capacity_bytes, cell::CellMetaBuilder, Capacity, TransactionBuilder},
     packed::{CellInput, CellOutputBuilder, OutPoint, Script},
 };
+use proptest::prelude::*;
+use proptest::proptest;
 
-use super::SCRIPT_VERSION;
-use crate::verify::{tests::utils::*, *};
-
-// check_vm_version: vm_version() returns 2.
-// check_get_memory_limit: get_memory_limit() returns 8 in prime script.
-// check_set_content: set_content() succeed in prime script but write length is 0.
-// check_spawn_strcat: a smoking test for spawn().
-// check_spawn_strcat_data_hash: position child script by data hash.
-// check_spawn_get_memory_limit: call get_memory_limit() in child script.
-// check_spawn_set_content: set_content() with content < length, = length and > length.
-// check_spawn_out_of_cycles: child script out-of-cycles.
-// check_spawn_exec: A exec B spawn C.
-// check_spawn_strcat_wrap: A spawn B spwan C.
-// check_spawn_out_of_cycles_wrap: A spawn B spwan C, but C out-of-cycles.
-// check_spawn_recursive: A spawn A spawn A ... ... spawn A
-// check_spawn_big_memory_size: fails when memory_limit > 8.
-// check_spawn_big_content_length: fails when content_length > 256K.
-// check_peak_memory_4m_to_32m: spawn should success when peak memory <= 32M
-// check_peak_memory_2m_to_32m: spawn should success when peak memory <= 32M
-// check_peak_memory_512k_to_32m: spawn should success when peak memory <= 32M
-// check_spawn_snapshot: A spawn B, then B gets suspended to snapshot and resume again.
-// check_spawn_state: Like check_spawn_snapshot but invoking verifier.resume_from_state instead.
-// check_spawn_current_memory: Use current_memory() to terminate infinite recursion.
-// check_spawn_current_cycles: callee's current_cycles should inherit caller's current_cycles.
-// check_spawn_times_bug_1: BUG: execution results may be inconsistent
-// check_spawn_times_bug_2: BUG: execution results may be inconsistent
-
-#[test]
-fn check_vm_version() {
+fn simple_spawn_test(bin_path: &str, args: &[u8]) -> Result<Cycle, Error> {
     let script_version = SCRIPT_VERSION;
 
-    let (vm_version_cell, vm_version_data_hash) = load_cell_from_path("testdata/vm_version_2");
-
-    let vm_version_script = Script::new_builder()
+    let (cell, data_hash) = load_cell_from_path(bin_path);
+    let script = Script::new_builder()
         .hash_type(script_version.data_hash_type().into())
-        .code_hash(vm_version_data_hash)
+        .code_hash(data_hash)
+        .args(Bytes::copy_from_slice(args).pack())
         .build();
     let output = CellOutputBuilder::default()
         .capacity(capacity_bytes!(100).pack())
-        .lock(vm_version_script)
+        .lock(script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
 
@@ -51,163 +29,99 @@ fn check_vm_version() {
 
     let rtx = ResolvedTransaction {
         transaction,
-        resolved_cell_deps: vec![vm_version_cell],
+        resolved_cell_deps: vec![cell],
         resolved_inputs: vec![dummy_cell],
         resolved_dep_groups: vec![],
     };
-
     let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version == ScriptVersion::V2);
+    verifier.verify_without_limit(script_version, &rtx)
 }
 
 #[test]
-fn check_get_memory_limit() {
-    let script_version = SCRIPT_VERSION;
-
-    let (memory_limit_cell, memory_limit_data_hash) =
-        load_cell_from_path("testdata/get_memory_limit");
-
-    let memory_limit_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type().into())
-        .code_hash(memory_limit_data_hash)
-        .build();
-    let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
-        .lock(memory_limit_script)
-        .build();
-
-    let input = CellInput::new(OutPoint::null(), 0);
-
-    let transaction = TransactionBuilder::default().input(input).build();
-    let dummy_cell = create_dummy_cell(output);
-
-    let rtx = ResolvedTransaction {
-        transaction,
-        resolved_cell_deps: vec![memory_limit_cell],
-        resolved_inputs: vec![dummy_cell],
-        resolved_dep_groups: vec![],
-    };
-
-    let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+fn check_spawn_simple_read_write() {
+    let result = simple_spawn_test("testdata/spawn_cases", &[1]);
+    assert_eq!(result.is_ok(), SCRIPT_VERSION == ScriptVersion::V2);
 }
 
 #[test]
-fn check_set_content() {
-    let script_version = SCRIPT_VERSION;
-
-    let (set_content_cell, set_content_data_hash) = load_cell_from_path("testdata/set_content");
-
-    let memory_limit_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type().into())
-        .code_hash(set_content_data_hash)
-        .build();
-    let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
-        .lock(memory_limit_script)
-        .build();
-
-    let input = CellInput::new(OutPoint::null(), 0);
-
-    let transaction = TransactionBuilder::default().input(input).build();
-    let dummy_cell = create_dummy_cell(output);
-
-    let rtx = ResolvedTransaction {
-        transaction,
-        resolved_cell_deps: vec![set_content_cell],
-        resolved_inputs: vec![dummy_cell],
-        resolved_dep_groups: vec![],
-    };
-
-    let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+fn check_spawn_write_dead_lock() {
+    let result = simple_spawn_test("testdata/spawn_cases", &[2]);
+    assert_eq!(
+        result.unwrap_err().to_string().contains("deadlock"),
+        SCRIPT_VERSION == ScriptVersion::V2
+    );
 }
 
 #[test]
-fn check_spawn_strcat() {
-    let script_version = SCRIPT_VERSION;
-
-    let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_caller_strcat");
-    let (spawn_callee_cell, _spawn_callee_data_hash) =
-        load_cell_from_path("testdata/spawn_callee_strcat");
+fn check_spawn_invalid_fd() {
+    let result = simple_spawn_test("testdata/spawn_cases", &[3]);
+    assert_eq!(result.is_ok(), SCRIPT_VERSION == ScriptVersion::V2);
+}
 
-    let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type().into())
-        .code_hash(spawn_caller_data_hash)
-        .build();
-    let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
-        .lock(spawn_caller_script)
-        .build();
-    let input = CellInput::new(OutPoint::null(), 0);
+#[test]
+fn check_spawn_wait_dead_lock() {
+    let result = simple_spawn_test("testdata/spawn_cases", &[4]);
+    assert_eq!(
+        result.unwrap_err().to_string().contains("deadlock"),
+        SCRIPT_VERSION == ScriptVersion::V2
+    );
+}
 
-    let transaction = TransactionBuilder::default().input(input).build();
-    let dummy_cell = create_dummy_cell(output);
+#[test]
+fn check_spawn_read_write_with_close() {
+    let result = simple_spawn_test("testdata/spawn_cases", &[5]);
+    assert_eq!(result.is_ok(), SCRIPT_VERSION == ScriptVersion::V2);
+}
 
-    let rtx = ResolvedTransaction {
-        transaction,
-        resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
-        resolved_inputs: vec![dummy_cell],
-        resolved_dep_groups: vec![],
-    };
-    let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+#[test]
+fn check_spawn_wait_multiple() {
+    let result = simple_spawn_test("testdata/spawn_cases", &[6]);
+    assert_eq!(result.is_ok(), SCRIPT_VERSION == ScriptVersion::V2);
 }
 
 #[test]
-fn check_spawn_strcat_data_hash() {
-    let script_version = SCRIPT_VERSION;
+fn check_spawn_inherited_fds() {
+    let result = simple_spawn_test("testdata/spawn_cases", &[7]);
+    assert_eq!(result.is_ok(), SCRIPT_VERSION == ScriptVersion::V2);
+}
 
-    let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_caller_strcat_data_hash");
-    let (spawn_callee_cell, _spawn_callee_data_hash) =
-        load_cell_from_path("testdata/spawn_callee_strcat");
+#[test]
+fn check_spawn_inherited_fds_without_owner() {
+    let result = simple_spawn_test("testdata/spawn_cases", &[8]);
+    assert_eq!(result.is_ok(), SCRIPT_VERSION == ScriptVersion::V2);
+}
 
-    let spawn_caller_script = Script::new_builder()
-        .hash_type(script_version.data_hash_type().into())
-        .code_hash(spawn_caller_data_hash)
-        .build();
-    let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
-        .lock(spawn_caller_script)
-        .build();
-    let input = CellInput::new(OutPoint::null(), 0);
+#[test]
+fn check_spawn_read_then_close() {
+    let result = simple_spawn_test("testdata/spawn_cases", &[9]);
+    assert_eq!(result.is_ok(), SCRIPT_VERSION == ScriptVersion::V2);
+}
 
-    let transaction = TransactionBuilder::default().input(input).build();
-    let dummy_cell = create_dummy_cell(output);
+#[test]
+fn check_spawn_max_vms_count() {
+    let result = simple_spawn_test("testdata/spawn_cases", &[10]);
+    assert_eq!(result.is_ok(), SCRIPT_VERSION == ScriptVersion::V2);
+}
 
-    let rtx = ResolvedTransaction {
-        transaction,
-        resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
-        resolved_inputs: vec![dummy_cell],
-        resolved_dep_groups: vec![],
-    };
-    let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+#[test]
+fn check_spawn_max_fds_limit() {
+    let result = simple_spawn_test("testdata/spawn_cases", &[11]);
+    assert_eq!(result.is_ok(), SCRIPT_VERSION == ScriptVersion::V2);
 }
 
 #[test]
-fn check_spawn_get_memory_limit() {
+fn check_vm_version() {
     let script_version = SCRIPT_VERSION;
 
-    let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_caller_get_memory_limit");
-    let (spawn_callee_cell, _spawn_callee_data_hash) =
-        load_cell_from_path("testdata/spawn_callee_get_memory_limit");
+    let (vm_version_cell, vm_version_data_hash) = load_cell_from_path("testdata/vm_version_2");
 
-    let spawn_caller_script = Script::new_builder()
+    let vm_version_script = Script::new_builder()
         .hash_type(script_version.data_hash_type().into())
-        .code_hash(spawn_caller_data_hash)
+        .code_hash(vm_version_data_hash)
         .build();
     let output = CellOutputBuilder::default()
         .capacity(capacity_bytes!(100).pack())
-        .lock(spawn_caller_script)
+        .lock(vm_version_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
 
@@ -216,23 +130,24 @@ fn check_spawn_get_memory_limit() {
 
     let rtx = ResolvedTransaction {
         transaction,
-        resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
+        resolved_cell_deps: vec![vm_version_cell],
         resolved_inputs: vec![dummy_cell],
         resolved_dep_groups: vec![],
     };
+
     let verifier = TransactionScriptsVerifierWithEnv::new();
     let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+    assert_eq!(result.is_ok(), script_version == ScriptVersion::V2);
 }
 
 #[test]
-fn check_spawn_set_content() {
+fn check_spawn_strcat() {
     let script_version = SCRIPT_VERSION;
 
     let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_caller_set_content");
+        load_cell_from_path("testdata/spawn_caller_strcat");
     let (spawn_callee_cell, _spawn_callee_data_hash) =
-        load_cell_from_path("testdata/spawn_callee_set_content");
+        load_cell_from_path("testdata/spawn_callee_strcat");
 
     let spawn_caller_script = Script::new_builder()
         .hash_type(script_version.data_hash_type().into())
@@ -412,7 +327,7 @@ fn check_spawn_out_of_cycles_wrap() {
             .to_string()
             .contains("ExceededMaximumCycles"))
     } else {
-        assert!(result.is_err())
+        assert!(result.is_err());
     }
 }
 
@@ -443,20 +358,25 @@ fn check_spawn_recursive() {
         resolved_dep_groups: vec![],
     };
     let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
+    let result = verifier.verify(script_version, &rtx, 70_000_000);
     if script_version >= ScriptVersion::V2 {
-        assert!(result.unwrap_err().to_string().contains("error code 7"))
+        let msg = result.unwrap_err().to_string();
+        assert!(msg.contains("error code 8"))
     } else {
         assert!(result.is_err())
     }
 }
 
 #[test]
-fn check_spawn_big_memory_size() {
+fn check_spawn_snapshot() {
     let script_version = SCRIPT_VERSION;
+    if script_version <= ScriptVersion::V1 {
+        return;
+    }
 
     let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_big_memory_size");
+        load_cell_from_path("testdata/spawn_caller_exec");
+    let (snapshot_cell, _) = load_cell_from_path("testdata/current_cycles_with_snapshot");
 
     let spawn_caller_script = Script::new_builder()
         .hash_type(script_version.data_hash_type().into())
@@ -473,21 +393,31 @@ fn check_spawn_big_memory_size() {
 
     let rtx = ResolvedTransaction {
         transaction,
-        resolved_cell_deps: vec![spawn_caller_cell],
+        resolved_cell_deps: vec![spawn_caller_cell, snapshot_cell],
         resolved_inputs: vec![dummy_cell],
         resolved_dep_groups: vec![],
     };
     let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+    let result = verifier.verify_without_pause(script_version, &rtx, Cycle::MAX);
+    let cycles_once = result.unwrap();
+
+    let (cycles, chunks_count) = verifier
+        .verify_until_completed(script_version, &rtx)
+        .unwrap();
+    assert_eq!(cycles, cycles_once);
+    assert!(chunks_count > 1);
 }
 
-#[test]
-fn check_spawn_big_content_length() {
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn check_spawn_async() {
     let script_version = SCRIPT_VERSION;
+    if script_version <= ScriptVersion::V1 {
+        return;
+    }
 
     let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_big_content_length");
+        load_cell_from_path("testdata/spawn_caller_exec");
+    let (snapshot_cell, _) = load_cell_from_path("testdata/current_cycles_with_snapshot");
 
     let spawn_caller_script = Script::new_builder()
         .hash_type(script_version.data_hash_type().into())
@@ -504,21 +434,69 @@ fn check_spawn_big_content_length() {
 
     let rtx = ResolvedTransaction {
         transaction,
-        resolved_cell_deps: vec![spawn_caller_cell],
+        resolved_cell_deps: vec![spawn_caller_cell, snapshot_cell],
         resolved_inputs: vec![dummy_cell],
         resolved_dep_groups: vec![],
     };
     let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+    let result = verifier.verify_without_pause(script_version, &rtx, Cycle::MAX);
+    let cycles_once = result.unwrap();
+
+    // we use debug pause to test context resume
+    // `current_cycles_with_snapshot` will try to pause verifier
+    // here we use `channel` to send Resume to verifier until it completes
+    let (command_tx, mut command_rx) = watch::channel(ChunkCommand::Resume);
+    let _jt = tokio::spawn(async move {
+        loop {
+            let res = command_tx.send(ChunkCommand::Resume);
+            if res.is_err() {
+                break;
+            }
+            tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
+        }
+    });
+    let cycles = verifier
+        .verify_complete_async(script_version, &rtx, &mut command_rx, false)
+        .await
+        .unwrap();
+    assert_eq!(cycles, cycles_once);
+
+    // we send Resume/Suspend to command_rx in a loop, make sure cycles is still the same
+    let (command_tx, mut command_rx) = watch::channel(ChunkCommand::Resume);
+    let _jt = tokio::spawn(async move {
+        loop {
+            tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
+            let _res = command_tx.send(ChunkCommand::Suspend);
+            tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
+
+            let _res = command_tx.send(ChunkCommand::Resume);
+            tokio::time::sleep(tokio::time::Duration::from_millis(1)).await;
+
+            let _res = command_tx.send(ChunkCommand::Suspend);
+            tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
+
+            let _res = command_tx.send(ChunkCommand::Resume);
+            tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
+        }
+    });
+
+    let cycles = verifier
+        .verify_complete_async(script_version, &rtx, &mut command_rx, true)
+        .await
+        .unwrap();
+    assert_eq!(cycles, cycles_once);
 }
 
-#[test]
-fn check_peak_memory_4m_to_32m() {
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn check_spawn_suspend_shutdown() {
     let script_version = SCRIPT_VERSION;
+    if script_version <= ScriptVersion::V1 {
+        return;
+    }
 
     let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_peak_memory_4m_to_32m");
+        load_cell_from_path("testdata/spawn_caller_exec");
+    let (snapshot_cell, _) = load_cell_from_path("testdata/infinite_loop");
 
     let spawn_caller_script = Script::new_builder()
         .hash_type(script_version.data_hash_type().into())
@@ -535,21 +513,47 @@ fn check_peak_memory_4m_to_32m() {
 
     let rtx = ResolvedTransaction {
         transaction,
-        resolved_cell_deps: vec![spawn_caller_cell],
+        resolved_cell_deps: vec![spawn_caller_cell, snapshot_cell],
         resolved_inputs: vec![dummy_cell],
         resolved_dep_groups: vec![],
     };
+
     let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+    let (command_tx, mut command_rx) = watch::channel(ChunkCommand::Resume);
+    let _jt = tokio::spawn(async move {
+        loop {
+            let _res = command_tx.send(ChunkCommand::Suspend);
+            tokio::time::sleep(tokio::time::Duration::from_millis(20)).await;
+
+            let _res = command_tx.send(ChunkCommand::Resume);
+            tokio::time::sleep(tokio::time::Duration::from_millis(20)).await;
+
+            let _res = command_tx.send(ChunkCommand::Suspend);
+            tokio::time::sleep(tokio::time::Duration::from_millis(20)).await;
+
+            let _res = command_tx.send(ChunkCommand::Stop);
+            tokio::time::sleep(tokio::time::Duration::from_millis(20)).await;
+        }
+    });
+
+    let res = verifier
+        .verify_complete_async(script_version, &rtx, &mut command_rx, true)
+        .await;
+    assert!(res.is_err());
+    let err = res.unwrap_err().to_string();
+    assert!(err.contains("VM Internal Error: External(\"stopped\")"));
 }
 
 #[test]
-fn check_peak_memory_2m_to_32m() {
+fn check_spawn_state() {
     let script_version = SCRIPT_VERSION;
+    if script_version <= ScriptVersion::V1 {
+        return;
+    }
 
     let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_peak_memory_2m_to_32m");
+        load_cell_from_path("testdata/spawn_caller_exec");
+    let (snapshot_cell, _) = load_cell_from_path("testdata/current_cycles_with_snapshot");
 
     let spawn_caller_script = Script::new_builder()
         .hash_type(script_version.data_hash_type().into())
@@ -566,21 +570,58 @@ fn check_peak_memory_2m_to_32m() {
 
     let rtx = ResolvedTransaction {
         transaction,
-        resolved_cell_deps: vec![spawn_caller_cell],
+        resolved_cell_deps: vec![spawn_caller_cell, snapshot_cell],
         resolved_inputs: vec![dummy_cell],
         resolved_dep_groups: vec![],
     };
     let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+    let result = verifier.verify_without_pause(script_version, &rtx, Cycle::MAX);
+    let cycles_once = result.unwrap();
+
+    let (cycles, chunks_count) = verifier
+        .verify_map(script_version, &rtx, |verifier| {
+            let max_cycles = Cycle::MAX;
+            let cycles;
+            let mut times = 0usize;
+            times += 1;
+            let mut init_state = match verifier.resumable_verify(max_cycles).unwrap() {
+                VerifyResult::Suspended(state) => Some(state),
+                VerifyResult::Completed(cycle) => {
+                    cycles = cycle;
+                    return Ok((cycles, times));
+                }
+            };
+
+            loop {
+                times += 1;
+                let state: TransactionSnapshot =
+                    init_state.take().unwrap().try_into().expect("no snapshot");
+                match verifier.resume_from_snap(&state, max_cycles).unwrap() {
+                    VerifyResult::Suspended(state) => {
+                        init_state = Some(state);
+                    }
+                    VerifyResult::Completed(cycle) => {
+                        cycles = cycle;
+                        break;
+                    }
+                }
+            }
+
+            Ok::<(u64, usize), Error>((cycles, times))
+        })
+        .unwrap();
+    assert_eq!(cycles, cycles_once);
+    assert!(chunks_count > 1);
 }
 
 #[test]
-fn check_peak_memory_512k_to_32m() {
+fn check_spawn_current_cycles() {
     let script_version = SCRIPT_VERSION;
 
     let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_peak_memory_512k_to_32m");
+        load_cell_from_path("testdata/spawn_caller_current_cycles");
+    let (spawn_callee_cell, _spawn_callee_data_hash) =
+        load_cell_from_path("testdata/spawn_callee_current_cycles");
 
     let spawn_caller_script = Script::new_builder()
         .hash_type(script_version.data_hash_type().into())
@@ -597,7 +638,7 @@ fn check_peak_memory_512k_to_32m() {
 
     let rtx = ResolvedTransaction {
         transaction,
-        resolved_cell_deps: vec![spawn_caller_cell],
+        resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
         resolved_inputs: vec![dummy_cell],
         resolved_dep_groups: vec![],
     };
@@ -606,57 +647,547 @@ fn check_peak_memory_512k_to_32m() {
     assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
 }
 
-#[test]
-fn check_spawn_snapshot() {
+#[derive(Clone, Copy)]
+enum SpawnFrom {
+    TxInputWitness,
+    GroupInputWitness,
+    TxOutputWitness,
+    GroupOutputWitness,
+    TxCellDep,
+    TxInputCell,
+    TxOutputCell,
+    GroupInputCell,
+    GroupOutputCell,
+    Slice(u64, u64),
+}
+
+fn check_spawn_configurable_once(spawn_from: SpawnFrom) {
     let script_version = SCRIPT_VERSION;
-    if script_version <= ScriptVersion::V1 {
-        return;
-    }
 
-    let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_caller_exec");
-    let (snapshot_cell, _) = load_cell_from_path("testdata/current_cycles_with_snapshot");
+    let args = {
+        let mut args: Vec<u8> = vec![];
+        let position = match spawn_from {
+            SpawnFrom::TxInputWitness => vec![0, 1, 1, 0],
+            SpawnFrom::GroupInputWitness => vec![0, SOURCE_GROUP_FLAG | 1, 1, 0],
+            SpawnFrom::TxOutputWitness => vec![0, 2, 1, 0],
+            SpawnFrom::GroupOutputWitness => vec![0, SOURCE_GROUP_FLAG | 2, 1, 0],
+            SpawnFrom::TxCellDep => vec![1, 3, 0, 0],
+            SpawnFrom::TxInputCell => vec![1, 1, 0, 0],
+            SpawnFrom::TxOutputCell => vec![0, 2, 0, 0],
+            SpawnFrom::GroupInputCell => vec![0, SOURCE_GROUP_FLAG | 1, 0, 0],
+            SpawnFrom::GroupOutputCell => vec![0, SOURCE_GROUP_FLAG | 2, 0, 0],
+            SpawnFrom::Slice(offset, size) => {
+                let (spawn_callee_cell, _) =
+                    load_cell_from_path("testdata/spawn_configurable_callee");
+                let h = offset << 32;
+                let l = if size == 0 {
+                    0
+                } else {
+                    spawn_callee_cell.mem_cell_data.unwrap().len() as u64
+                };
+                vec![0, 1, 1, h | l]
+            }
+        };
+        for e in position {
+            args.extend(e.to_le_bytes());
+        }
+        args
+    };
 
+    let (spawn_caller_cell, spawn_caller_data_hash) =
+        load_cell_from_path("testdata/spawn_configurable_caller");
+    let (spawn_callee_cell, _) = load_cell_from_path("testdata/spawn_configurable_callee");
+    let (always_success_cell, always_success_data_hash) =
+        load_cell_from_path("testdata/always_success");
+    let spawn_callee_cell_data = spawn_callee_cell.mem_cell_data.as_ref().unwrap();
     let spawn_caller_script = Script::new_builder()
         .hash_type(script_version.data_hash_type().into())
         .code_hash(spawn_caller_data_hash)
+        .args(args.pack())
         .build();
-    let output = CellOutputBuilder::default()
-        .capacity(capacity_bytes!(100).pack())
-        .lock(spawn_caller_script)
+    let always_success_script = Script::new_builder()
+        .hash_type(script_version.data_hash_type().into())
+        .code_hash(always_success_data_hash)
         .build();
-    let input = CellInput::new(OutPoint::null(), 0);
-
-    let transaction = TransactionBuilder::default().input(input).build();
-    let dummy_cell = create_dummy_cell(output);
 
-    let rtx = ResolvedTransaction {
-        transaction,
-        resolved_cell_deps: vec![spawn_caller_cell, snapshot_cell],
-        resolved_inputs: vec![dummy_cell],
-        resolved_dep_groups: vec![],
+    let input_spawn_caller = create_dummy_cell(
+        CellOutputBuilder::default()
+            .capacity(capacity_bytes!(100).pack())
+            .lock(spawn_caller_script.clone())
+            .build(),
+    );
+
+    let rtx = match spawn_from {
+        SpawnFrom::TxInputWitness | SpawnFrom::TxOutputWitness | SpawnFrom::GroupInputWitness => {
+            ResolvedTransaction {
+                transaction: TransactionBuilder::default()
+                    .set_witnesses(vec![spawn_callee_cell_data.pack()])
+                    .build(),
+                resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
+                resolved_inputs: vec![input_spawn_caller],
+                resolved_dep_groups: vec![],
+            }
+        }
+        SpawnFrom::GroupOutputWitness => ResolvedTransaction {
+            transaction: TransactionBuilder::default()
+                .output(
+                    CellOutputBuilder::default()
+                        .capacity(capacity_bytes!(100).pack())
+                        .type_(Some(spawn_caller_script).pack())
+                        .build(),
+                )
+                .set_witnesses(vec![spawn_callee_cell_data.pack()])
+                .build(),
+            resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
+            resolved_inputs: vec![],
+            resolved_dep_groups: vec![],
+        },
+        SpawnFrom::TxCellDep => ResolvedTransaction {
+            transaction: TransactionBuilder::default().build(),
+            resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
+            resolved_inputs: vec![input_spawn_caller],
+            resolved_dep_groups: vec![],
+        },
+        SpawnFrom::TxInputCell => {
+            let input_spawn_callee_output = CellOutputBuilder::default()
+                .capacity(capacity_bytes!(1000).pack())
+                .lock(always_success_script)
+                .build();
+            let input_spawn_callee = CellMetaBuilder::from_cell_output(
+                input_spawn_callee_output,
+                spawn_callee_cell_data.clone(),
+            )
+            .build();
+            ResolvedTransaction {
+                transaction: TransactionBuilder::default().build(),
+                resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell, always_success_cell],
+                resolved_inputs: vec![input_spawn_caller, input_spawn_callee],
+                resolved_dep_groups: vec![],
+            }
+        }
+        SpawnFrom::TxOutputCell => ResolvedTransaction {
+            transaction: TransactionBuilder::default()
+                .output(
+                    CellOutputBuilder::default()
+                        .capacity(capacity_bytes!(100).pack())
+                        .lock(always_success_script)
+                        .build(),
+                )
+                .output_data(spawn_callee_cell_data.pack())
+                .build(),
+            resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell, always_success_cell],
+            resolved_inputs: vec![input_spawn_caller],
+            resolved_dep_groups: vec![],
+        },
+        SpawnFrom::GroupInputCell => {
+            let input_spawn_caller = CellMetaBuilder::from_cell_output(
+                CellOutputBuilder::default()
+                    .capacity(capacity_bytes!(100).pack())
+                    .lock(spawn_caller_script)
+                    .build(),
+                spawn_callee_cell_data.clone(),
+            )
+            .build();
+            ResolvedTransaction {
+                transaction: TransactionBuilder::default().build(),
+                resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell, always_success_cell],
+                resolved_inputs: vec![input_spawn_caller],
+                resolved_dep_groups: vec![],
+            }
+        }
+        SpawnFrom::GroupOutputCell => ResolvedTransaction {
+            transaction: TransactionBuilder::default()
+                .output(
+                    CellOutputBuilder::default()
+                        .capacity(capacity_bytes!(100).pack())
+                        .type_(Some(spawn_caller_script).pack())
+                        .build(),
+                )
+                .output_data(spawn_callee_cell_data.pack())
+                .build(),
+            resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell, always_success_cell],
+            resolved_inputs: vec![],
+            resolved_dep_groups: vec![],
+        },
+        SpawnFrom::Slice(offset, size) => {
+            let mut data = vec![0; offset as usize];
+            data.extend(spawn_callee_cell_data);
+            if size != 0 {
+                data.extend(vec![0; 0x12]);
+            }
+            ResolvedTransaction {
+                transaction: TransactionBuilder::default()
+                    .set_witnesses(vec![data.pack()])
+                    .build(),
+                resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
+                resolved_inputs: vec![input_spawn_caller],
+                resolved_dep_groups: vec![],
+            }
+        }
     };
+
     let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_pause(script_version, &rtx, Cycle::MAX);
-    let cycles_once = result.unwrap();
+    let result = verifier.verify_without_limit(script_version, &rtx);
+    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+}
 
-    let (cycles, chunks_count) = verifier
-        .verify_until_completed(script_version, &rtx)
-        .unwrap();
-    assert_eq!(cycles, cycles_once);
-    assert!(chunks_count > 1);
+#[test]
+fn check_spawn_configurable() {
+    check_spawn_configurable_once(SpawnFrom::TxInputWitness);
+    check_spawn_configurable_once(SpawnFrom::GroupInputWitness);
+    check_spawn_configurable_once(SpawnFrom::TxOutputWitness);
+    check_spawn_configurable_once(SpawnFrom::GroupOutputWitness);
+    check_spawn_configurable_once(SpawnFrom::TxCellDep);
+    check_spawn_configurable_once(SpawnFrom::TxInputCell);
+    check_spawn_configurable_once(SpawnFrom::TxOutputCell);
+    check_spawn_configurable_once(SpawnFrom::GroupInputCell);
+    check_spawn_configurable_once(SpawnFrom::GroupOutputCell);
+    check_spawn_configurable_once(SpawnFrom::Slice(0, 0));
+    check_spawn_configurable_once(SpawnFrom::Slice(1, 0));
+    check_spawn_configurable_once(SpawnFrom::Slice(0, 1));
+    check_spawn_configurable_once(SpawnFrom::Slice(1, 1));
+}
+
+#[allow(dead_code)]
+#[path = "../../../../testdata/spawn_dag.rs"]
+mod spawn_dag;
+use ckb_types::bytes::Bytes;
+use daggy::{Dag, Walker};
+use molecule::prelude::Byte;
+use rand::{rngs::StdRng, Rng, SeedableRng};
+use spawn_dag as dag;
+use std::collections::{HashSet, VecDeque};
+
+pub fn generate_data_graph(
+    seed: u64,
+    spawns: u32,
+    writes: u32,
+    converging_threshold: u32,
+) -> Result<dag::Data, Error> {
+    let mut rng = StdRng::seed_from_u64(seed);
+
+    let mut spawn_dag: Dag<(), ()> = Dag::new();
+    let mut write_dag: Dag<(), ()> = Dag::new();
+
+    // Root node denoting entrypoint VM
+    let spawn_root = spawn_dag.add_node(());
+    let write_root = write_dag.add_node(());
+    assert_eq!(spawn_root.index(), 0);
+    assert_eq!(write_root.index(), 0);
+
+    let mut spawn_nodes = vec![spawn_root];
+    let mut write_nodes = vec![write_root];
+
+    for _ in 1..=spawns {
+        let write_node = write_dag.add_node(());
+        write_nodes.push(write_node);
+
+        let previous_node = spawn_nodes[rng.gen_range(0..spawn_nodes.len())];
+        let (_, spawn_node) = spawn_dag.add_child(previous_node, (), ());
+        spawn_nodes.push(spawn_node);
+    }
+
+    let mut write_edges = Vec::new();
+    if spawns > 0 {
+        for _ in 1..=writes {
+            let mut updated = false;
+
+            for _ in 0..converging_threshold {
+                let first_index = rng.gen_range(0..write_nodes.len());
+                let second_index = {
+                    let mut i = first_index;
+                    while i == first_index {
+                        i = rng.gen_range(0..write_nodes.len());
+                    }
+                    i
+                };
+
+                let first_node = write_nodes[first_index];
+                let second_node = write_nodes[second_index];
+
+                if let Ok(e) = write_dag.add_edge(first_node, second_node, ()) {
+                    write_edges.push(e);
+                    updated = true;
+                    break;
+                }
+            }
+
+            if !updated {
+                break;
+            }
+        }
+    }
+
+    // Edge index -> pipe indices. Daggy::edge_endpoints helps us finding
+    // nodes (vms) from edges (spawns)
+    let mut spawn_ops: HashMap<usize, Vec<usize>> = HashMap::default();
+    // Node index -> created pipes
+    let mut pipes_ops: BTreeMap<usize, Vec<(usize, usize)>> = BTreeMap::default();
+
+    let mut spawn_edges = Vec::new();
+    // Traversing spawn_dag for spawn operations
+    let mut processing = VecDeque::from([spawn_root]);
+    while !processing.is_empty() {
+        let node = processing.pop_front().unwrap();
+        pipes_ops.insert(node.index(), Vec::new());
+        let children: Vec<_> = spawn_dag.children(node).iter(&spawn_dag).collect();
+        for (e, n) in children.into_iter().rev() {
+            spawn_ops.insert(e.index(), Vec::new());
+            spawn_edges.push(e);
+
+            processing.push_back(n);
+        }
+    }
+
+    let mut writes_builder = dag::WritesBuilder::default();
+    // Traversing all edges in write_dag
+    for e in write_edges {
+        let (writer, reader) = write_dag.edge_endpoints(e).unwrap();
+        assert_ne!(writer, reader);
+        let writer_pipe_index = e.index() * 2 + 1;
+        let reader_pipe_index = e.index() * 2;
+
+        // Generate finalized write op
+        {
+            let data_len = rng.gen_range(1..=1024);
+            let mut data = vec![0u8; data_len];
+            rng.fill(&mut data[..]);
+
+            writes_builder = writes_builder.push(
+                dag::WriteBuilder::default()
+                    .from(build_vm_index(writer.index() as u64))
+                    .from_fd(build_fd_index(writer_pipe_index as u64))
+                    .to(build_vm_index(reader.index() as u64))
+                    .to_fd(build_fd_index(reader_pipe_index as u64))
+                    .data(
+                        dag::BytesBuilder::default()
+                            .extend(data.iter().map(|b| Byte::new(*b)))
+                            .build(),
+                    )
+                    .build(),
+            );
+        }
+
+        // Finding the lowest common ancestor of writer & reader nodes
+        // in spawn_dag, which will creates the pair of pipes. Note that
+        // all traversed spawn edges will have to pass the pipes down.
+        //
+        // TODO: we use a simple yet slow LCA solution, a faster algorithm
+        // can be used to replace the code here if needed.
+        let ancestor = {
+            let mut a = writer;
+            let mut b = reader;
+
+            let mut set_a = HashSet::new();
+            set_a.insert(a);
+            let mut set_b = HashSet::new();
+            set_b.insert(b);
+
+            loop {
+                let parents_a: Vec<_> = spawn_dag.parents(a).iter(&spawn_dag).collect();
+                let parents_b: Vec<_> = spawn_dag.parents(b).iter(&spawn_dag).collect();
+
+                assert!(
+                    ((parents_a.len() == 1) && (parents_b.len() == 1))
+                        || (parents_a.is_empty() && (parents_b.len() == 1))
+                        || ((parents_a.len() == 1) && parents_b.is_empty())
+                );
+
+                // Update spawn ops to pass down pipes via edges, also update
+                // each node's path node list
+                if parents_a.len() == 1 {
+                    let (_, parent_a) = parents_a[0];
+                    set_a.insert(parent_a);
+
+                    a = parent_a;
+                }
+                if parents_b.len() == 1 {
+                    let (_, parent_b) = parents_b[0];
+                    set_b.insert(parent_b);
+
+                    b = parent_b;
+                }
+
+                // Test for ancestor
+                if parents_a.len() == 1 {
+                    let (_, parent_a) = parents_a[0];
+                    if set_b.contains(&parent_a) {
+                        break parent_a;
+                    }
+                }
+                if parents_b.len() == 1 {
+                    let (_, parent_b) = parents_b[0];
+                    if set_a.contains(&parent_b) {
+                        break parent_b;
+                    }
+                }
+            }
+        };
+
+        // Update the path from each node to the LCA so we can pass created
+        // pipes from LCA to each node
+        {
+            let mut a = writer;
+            while a != ancestor {
+                let parents_a: Vec<_> = spawn_dag.parents(a).iter(&spawn_dag).collect();
+                assert!(parents_a.len() == 1);
+                let (edge_a, parent_a) = parents_a[0];
+                spawn_ops
+                    .get_mut(&edge_a.index())
+                    .unwrap()
+                    .push(writer_pipe_index);
+                a = parent_a;
+            }
+
+            let mut b = reader;
+            while b != ancestor {
+                let parents_b: Vec<_> = spawn_dag.parents(b).iter(&spawn_dag).collect();
+                assert!(parents_b.len() == 1);
+                let (edge_b, parent_b) = parents_b[0];
+                spawn_ops
+                    .get_mut(&edge_b.index())
+                    .unwrap()
+                    .push(reader_pipe_index);
+                b = parent_b;
+            }
+        }
+
+        // Create the pipes at the ancestor node
+        pipes_ops
+            .get_mut(&ancestor.index())
+            .unwrap()
+            .push((reader_pipe_index, writer_pipe_index));
+    }
+
+    let mut spawns_builder = dag::SpawnsBuilder::default();
+    for e in spawn_edges {
+        let (parent, child) = spawn_dag.edge_endpoints(e).unwrap();
+
+        let pipes = {
+            let mut builder = dag::FdIndicesBuilder::default();
+            for p in &spawn_ops[&e.index()] {
+                builder = builder.push(build_fd_index(*p as u64));
+            }
+            builder.build()
+        };
+
+        spawns_builder = spawns_builder.push(
+            dag::SpawnBuilder::default()
+                .from(build_vm_index(parent.index() as u64))
+                .child(build_vm_index(child.index() as u64))
+                .fds(pipes)
+                .build(),
+        );
+    }
+
+    let mut pipes_builder = dag::PipesBuilder::default();
+    for (vm_index, pairs) in pipes_ops {
+        for (reader_pipe_index, writer_pipe_index) in pairs {
+            pipes_builder = pipes_builder.push(
+                dag::PipeBuilder::default()
+                    .vm(build_vm_index(vm_index as u64))
+                    .read_fd(build_fd_index(reader_pipe_index as u64))
+                    .write_fd(build_fd_index(writer_pipe_index as u64))
+                    .build(),
+            );
+        }
+    }
+
+    Ok(dag::DataBuilder::default()
+        .spawns(spawns_builder.build())
+        .pipes(pipes_builder.build())
+        .writes(writes_builder.build())
+        .build())
+}
+
+fn build_vm_index(val: u64) -> dag::VmIndex {
+    let mut data = [Byte::new(0); 8];
+    for (i, v) in val.to_le_bytes().into_iter().enumerate() {
+        data[i] = Byte::new(v);
+    }
+    dag::VmIndexBuilder::default().set(data).build()
+}
+
+fn build_fd_index(val: u64) -> dag::FdIndex {
+    let mut data = [Byte::new(0); 8];
+    for (i, v) in val.to_le_bytes().into_iter().enumerate() {
+        data[i] = Byte::new(v);
+    }
+    dag::FdIndexBuilder::default().set(data).build()
+}
+
+proptest! {
+    #![proptest_config(ProptestConfig::with_cases(32))]
+    #[test]
+    fn test_random_dag(
+        seed: u64,
+        spawns in 5u32..MAX_VMS_COUNT as u32,
+        writes in 3u32..MAX_FDS as u32 / 2,
+    ) {
+        let script_version = SCRIPT_VERSION;
+        let program: Bytes = std::fs::read("./testdata/spawn_dag").unwrap().into();
+        let data = generate_data_graph(seed, spawns, writes, 3).unwrap();
+
+        let (code_dep, code_dep_hash) = load_cell_from_slice(&program[..]);
+        let spawn_caller_script = Script::new_builder()
+            .hash_type(script_version.data_hash_type().into())
+            .code_hash(code_dep_hash)
+            .build();
+        let output = CellOutputBuilder::default()
+            .capacity(capacity_bytes!(100).pack())
+            .lock(spawn_caller_script)
+            .build();
+        let dummy_cell = create_dummy_cell(output);
+
+        let rtx = ResolvedTransaction {
+            transaction: TransactionBuilder::default().witness(data.as_bytes().pack()).build(),
+            resolved_cell_deps: vec![code_dep],
+            resolved_inputs: vec![dummy_cell],
+            resolved_dep_groups: vec![],
+        };
+
+        let verifier = TransactionScriptsVerifierWithEnv::new();
+        let result = verifier.verify_without_limit(script_version, &rtx);
+        assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+    }
 }
 
 #[test]
-fn check_spawn_state() {
+fn check_spawn_close_invalid_fd() {
+    let result = simple_spawn_test("testdata/spawn_cases", &[12]);
+    assert_eq!(result.is_ok(), SCRIPT_VERSION == ScriptVersion::V2);
+}
+
+#[test]
+fn check_spawn_write_closed_fd() {
+    let result = simple_spawn_test("testdata/spawn_cases", &[13]);
+    assert_eq!(result.is_ok(), SCRIPT_VERSION == ScriptVersion::V2);
+}
+
+#[test]
+fn check_spawn_pid() {
+    let result = simple_spawn_test("testdata/spawn_cases", &[14]);
+    assert_eq!(result.is_ok(), SCRIPT_VERSION == ScriptVersion::V2);
+}
+
+#[test]
+fn check_spawn_offset_out_of_bound() {
+    let result = simple_spawn_test("testdata/spawn_cases", &[15]);
+    assert_eq!(result.is_ok(), SCRIPT_VERSION == ScriptVersion::V2);
+}
+
+#[test]
+fn check_spawn_length_out_of_bound() {
+    let result = simple_spawn_test("testdata/spawn_cases", &[16]);
+    assert_eq!(result.is_ok(), SCRIPT_VERSION == ScriptVersion::V2);
+}
+
+#[test]
+fn check_spawn_huge_swap() {
     let script_version = SCRIPT_VERSION;
-    if script_version <= ScriptVersion::V1 {
-        return;
-    }
 
     let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_caller_exec");
-    let (snapshot_cell, _) = load_cell_from_path("testdata/current_cycles_with_snapshot");
+        load_cell_from_path("testdata/spawn_huge_swap");
 
     let spawn_caller_script = Script::new_builder()
         .hash_type(script_version.data_hash_type().into())
@@ -673,55 +1204,43 @@ fn check_spawn_state() {
 
     let rtx = ResolvedTransaction {
         transaction,
-        resolved_cell_deps: vec![spawn_caller_cell, snapshot_cell],
+        resolved_cell_deps: vec![spawn_caller_cell],
         resolved_inputs: vec![dummy_cell],
         resolved_dep_groups: vec![],
     };
     let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_pause(script_version, &rtx, Cycle::MAX);
-    let cycles_once = result.unwrap();
 
-    let (cycles, chunks_count) = verifier
-        .verify_map(script_version, &rtx, |verifier| {
-            let max_cycles = Cycle::MAX;
-            let cycles;
-            let mut times = 0usize;
-            times += 1;
-            let mut init_state = match verifier.resumable_verify(max_cycles).unwrap() {
-                VerifyResult::Suspended(state) => Some(state),
-                VerifyResult::Completed(cycle) => {
-                    cycles = cycle;
-                    return Ok((cycles, times));
-                }
-            };
+    let tic = std::time::Instant::now();
+    let result = verifier.verify(script_version, &rtx, 70_000_000);
+    let toc = tic.elapsed().as_millis();
+    if script_version >= ScriptVersion::V2 {
+        let msg = result.unwrap_err().to_string();
+        assert!(msg.contains("ExceededMaximumCycles"));
+        // Normally, this test should take less than 1 second.
+        assert!(toc < 5000);
+    } else {
+        assert!(result.is_err())
+    }
+}
 
-            loop {
-                times += 1;
-                let state = init_state.take().unwrap();
-                match verifier.resume_from_state(state, max_cycles).unwrap() {
-                    VerifyResult::Suspended(state) => {
-                        init_state = Some(state);
-                    }
-                    VerifyResult::Completed(cycle) => {
-                        cycles = cycle;
-                        break;
-                    }
-                }
-            }
+#[test]
+fn check_spawn_invaild_index() {
+    let result = simple_spawn_test("testdata/spawn_cases", &[17]);
+    assert_eq!(result.is_ok(), SCRIPT_VERSION == ScriptVersion::V2);
+}
 
-            Ok::<(u64, usize), Error>((cycles, times))
-        })
-        .unwrap();
-    assert_eq!(cycles, cycles_once);
-    assert!(chunks_count > 1);
+#[test]
+fn check_spawn_index_out_of_bound() {
+    let result = simple_spawn_test("testdata/spawn_cases", &[18]);
+    assert_eq!(result.is_ok(), SCRIPT_VERSION == ScriptVersion::V2);
 }
 
 #[test]
-fn check_spawn_current_memory() {
+fn check_spawn_cycles() {
     let script_version = SCRIPT_VERSION;
 
-    let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_current_memory");
+    let (spawn_caller_cell, spawn_caller_data_hash) = load_cell_from_path("testdata/spawn_cycles");
+    let (spawn_callee_cell, _spawn_callee_data_hash) = load_cell_from_path("testdata/spawn_cycles");
 
     let spawn_caller_script = Script::new_builder()
         .hash_type(script_version.data_hash_type().into())
@@ -738,31 +1257,34 @@ fn check_spawn_current_memory() {
 
     let rtx = ResolvedTransaction {
         transaction,
-        resolved_cell_deps: vec![spawn_caller_cell],
+        resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
         resolved_inputs: vec![dummy_cell],
         resolved_dep_groups: vec![],
     };
     let verifier = TransactionScriptsVerifierWithEnv::new();
     let result = verifier.verify_without_limit(script_version, &rtx);
     assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+    if script_version >= ScriptVersion::V2 {
+        assert_eq!(result.unwrap(), 1524861);
+    }
 }
 
-#[test]
-fn check_spawn_current_cycles() {
+fn spawn_io_test(io_size: u64, enable_check: bool) -> Result<u64, Error> {
     let script_version = SCRIPT_VERSION;
 
-    let (spawn_caller_cell, spawn_caller_data_hash) =
-        load_cell_from_path("testdata/spawn_caller_current_cycles");
-    let (spawn_callee_cell, _spawn_callee_data_hash) =
-        load_cell_from_path("testdata/spawn_callee_current_cycles");
+    let mut args = vec![0u8; 16];
+    args[..8].copy_from_slice(&io_size.to_le_bytes());
+    args[8] = enable_check as u8;
 
-    let spawn_caller_script = Script::new_builder()
+    let (cell, data_hash) = load_cell_from_path("testdata/spawn_io_cycles");
+    let script = Script::new_builder()
         .hash_type(script_version.data_hash_type().into())
-        .code_hash(spawn_caller_data_hash)
+        .code_hash(data_hash)
+        .args(Bytes::copy_from_slice(&args).pack())
         .build();
     let output = CellOutputBuilder::default()
         .capacity(capacity_bytes!(100).pack())
-        .lock(spawn_caller_script)
+        .lock(script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
 
@@ -771,28 +1293,52 @@ fn check_spawn_current_cycles() {
 
     let rtx = ResolvedTransaction {
         transaction,
-        resolved_cell_deps: vec![spawn_caller_cell, spawn_callee_cell],
+        resolved_cell_deps: vec![cell],
         resolved_inputs: vec![dummy_cell],
         resolved_dep_groups: vec![],
     };
     let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+    verifier.verify_without_limit(script_version, &rtx)
 }
 
 #[test]
-fn check_spawn_times_bug_1() {
-    let script_version = SCRIPT_VERSION;
+fn check_spawn_io_cycles() {
+    if SCRIPT_VERSION != ScriptVersion::V2 {
+        return;
+    }
 
-    let (spawn_caller_cell, spawn_caller_data_hash) = load_cell_from_path("testdata/spawn_times");
+    let offset_size = 1024;
+    let r = spawn_io_test(128, true);
+    r.unwrap();
+    let r = spawn_io_test(128 + offset_size, true);
+    r.unwrap();
 
-    let spawn_caller_script = Script::new_builder()
+    let r = spawn_io_test(128, false);
+    let cycles1 = r.unwrap();
+    let r = spawn_io_test(128 + offset_size, false);
+    let cycles2 = r.unwrap();
+
+    assert_eq!(cycles2 - cycles1, offset_size / 2);
+}
+
+#[test]
+fn check_spawn_saturate_memory() {
+    let result = simple_spawn_test("testdata/spawn_saturate_memory", &[0]);
+    assert_eq!(result.is_ok(), SCRIPT_VERSION == ScriptVersion::V2);
+}
+
+#[test]
+fn check_infinite_exec() {
+    let script_version = SCRIPT_VERSION;
+
+    let (exec_caller_cell, exec_caller_data_hash) = load_cell_from_path("testdata/infinite_exec");
+    let exec_caller_script = Script::new_builder()
         .hash_type(script_version.data_hash_type().into())
-        .code_hash(spawn_caller_data_hash)
+        .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
         .capacity(capacity_bytes!(100).pack())
-        .lock(spawn_caller_script)
+        .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
 
@@ -801,30 +1347,35 @@ fn check_spawn_times_bug_1() {
 
     let rtx = ResolvedTransaction {
         transaction,
-        resolved_cell_deps: vec![spawn_caller_cell],
+        resolved_cell_deps: vec![exec_caller_cell],
         resolved_inputs: vec![dummy_cell],
         resolved_dep_groups: vec![],
     };
+
     let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_limit(script_version, &rtx);
-    assert_eq!(result.is_ok(), script_version >= ScriptVersion::V2);
+    let result = verifier.verify(script_version, &rtx, 70000000);
+    if script_version >= ScriptVersion::V1 {
+        assert!(result
+            .unwrap_err()
+            .to_string()
+            .contains("ExceededMaximumCycles"))
+    } else {
+        assert!(result.is_err())
+    }
 }
 
 #[test]
-fn check_spawn_times_bug_2() {
+fn check_fuzz_crash_1() {
     let script_version = SCRIPT_VERSION;
-    if script_version <= ScriptVersion::V1 {
-        return;
-    }
-    let (spawn_caller_cell, spawn_caller_data_hash) = load_cell_from_path("testdata/spawn_times");
 
-    let spawn_caller_script = Script::new_builder()
+    let (exec_caller_cell, exec_caller_data_hash) = load_cell_from_path("testdata/crash-5a27052f");
+    let exec_caller_script = Script::new_builder()
         .hash_type(script_version.data_hash_type().into())
-        .code_hash(spawn_caller_data_hash)
+        .code_hash(exec_caller_data_hash)
         .build();
     let output = CellOutputBuilder::default()
         .capacity(capacity_bytes!(100).pack())
-        .lock(spawn_caller_script)
+        .lock(exec_caller_script)
         .build();
     let input = CellInput::new(OutPoint::null(), 0);
 
@@ -833,44 +1384,83 @@ fn check_spawn_times_bug_2() {
 
     let rtx = ResolvedTransaction {
         transaction,
-        resolved_cell_deps: vec![spawn_caller_cell],
+        resolved_cell_deps: vec![exec_caller_cell],
         resolved_inputs: vec![dummy_cell],
         resolved_dep_groups: vec![],
     };
-    let verifier = TransactionScriptsVerifierWithEnv::new();
-    let result = verifier.verify_without_pause(script_version, &rtx, Cycle::MAX);
-    let cycles_once = result.unwrap();
 
-    let (cycles, _) = verifier
-        .verify_map(script_version, &rtx, |verifier| {
-            let max_cycles = Cycle::MAX;
-            let cycles;
-            let mut times = 0usize;
-            times += 1;
-            let mut init_state = match verifier.resumable_verify(max_cycles).unwrap() {
-                VerifyResult::Suspended(state) => Some(state),
-                VerifyResult::Completed(cycle) => {
-                    cycles = cycle;
-                    return Ok((cycles, times));
-                }
-            };
+    let verifier = TransactionScriptsVerifierWithEnv::new();
+    let result = verifier.verify(script_version, &rtx, 70000000);
+    match script_version {
+        ScriptVersion::V0 => assert!(result
+            .unwrap_err()
+            .to_string()
+            .contains("MemWriteOnExecutablePage")),
+        ScriptVersion::V1 | ScriptVersion::V2 => assert!(result
+            .unwrap_err()
+            .to_string()
+            .contains("SourceEntry parse_from_u64 0")),
+    }
+}
 
-            loop {
-                times += 1;
-                let state = init_state.take().unwrap();
-                match verifier.resume_from_state(state, max_cycles).unwrap() {
-                    VerifyResult::Suspended(state) => {
-                        init_state = Some(state);
-                    }
-                    VerifyResult::Completed(cycle) => {
-                        cycles = cycle;
-                        break;
-                    }
-                }
-            }
+#[test]
+fn check_fuzz_crash_2() {
+    let script_version = SCRIPT_VERSION;
+    let (exec_caller_cell, exec_caller_data_hash) = load_cell_from_path("testdata/crash-45a6098d");
+    let exec_caller_script = Script::new_builder()
+        .hash_type(script_version.data_hash_type().into())
+        .code_hash(exec_caller_data_hash)
+        .build();
+    let output = CellOutputBuilder::default()
+        .capacity(capacity_bytes!(100).pack())
+        .lock(exec_caller_script)
+        .build();
+    let input = CellInput::new(OutPoint::null(), 0);
+    let transaction = TransactionBuilder::default().input(input).build();
+    let dummy_cell = create_dummy_cell(output);
+    let rtx = ResolvedTransaction {
+        transaction,
+        resolved_cell_deps: vec![exec_caller_cell],
+        resolved_inputs: vec![dummy_cell],
+        resolved_dep_groups: vec![],
+    };
+    let verifier = TransactionScriptsVerifierWithEnv::new();
+    let result = verifier.verify(script_version, &rtx, 70000000);
+    match script_version {
+        ScriptVersion::V0 => assert!(result
+            .unwrap_err()
+            .to_string()
+            .contains("MemWriteOnExecutablePage")),
+        ScriptVersion::V1 => assert_eq!(result.unwrap(), 58741),
+        ScriptVersion::V2 => assert_eq!(result.unwrap(), 58686),
+    }
+}
 
-            Ok::<(u64, usize), Error>((cycles, times))
-        })
-        .unwrap();
-    assert_eq!(cycles, cycles_once);
+#[test]
+fn check_fuzz_crash_3() {
+    let script_version = SCRIPT_VERSION;
+    let (exec_caller_cell, exec_caller_data_hash) = load_cell_from_path("testdata/crash-4717eb0e");
+    let exec_caller_script = Script::new_builder()
+        .hash_type(script_version.data_hash_type().into())
+        .code_hash(exec_caller_data_hash)
+        .build();
+    let output = CellOutputBuilder::default()
+        .capacity(capacity_bytes!(100).pack())
+        .lock(exec_caller_script)
+        .build();
+    let input = CellInput::new(OutPoint::null(), 0);
+    let transaction = TransactionBuilder::default().input(input).build();
+    let dummy_cell = create_dummy_cell(output);
+    let rtx = ResolvedTransaction {
+        transaction,
+        resolved_cell_deps: vec![exec_caller_cell],
+        resolved_inputs: vec![dummy_cell],
+        resolved_dep_groups: vec![],
+    };
+    let verifier = TransactionScriptsVerifierWithEnv::new();
+    let result = verifier.verify(script_version, &rtx, 70000000);
+    assert!(result
+        .unwrap_err()
+        .to_string()
+        .contains("MemWriteOnExecutablePage"));
 }
diff --git a/script/src/verify/tests/utils.rs b/script/src/verify/tests/utils.rs
index 8eaffcd64d..760921f627 100644
--- a/script/src/verify/tests/utils.rs
+++ b/script/src/verify/tests/utils.rs
@@ -173,6 +173,34 @@ impl TransactionScriptsVerifierWithEnv {
         self.verify(version, rtx, u64::MAX)
     }
 
+    pub(crate) async fn verify_without_limit_async(
+        &self,
+        version: ScriptVersion,
+        rtx: &ResolvedTransaction,
+    ) -> Result<Cycle, Error> {
+        let data_loader = self.store.as_data_loader();
+        let epoch = match version {
+            ScriptVersion::V0 => EpochNumberWithFraction::new(0, 0, 1),
+            ScriptVersion::V1 => EpochNumberWithFraction::new(self.version_1_enabled_at, 0, 1),
+            ScriptVersion::V2 => EpochNumberWithFraction::new(self.version_2_enabled_at, 0, 1),
+        };
+        let header = HeaderView::new_advanced_builder()
+            .epoch(epoch.pack())
+            .build();
+        let tx_env = Arc::new(TxVerifyEnv::new_commit(&header));
+        let verifier = TransactionScriptsVerifier::new(
+            Arc::new(rtx.clone()),
+            data_loader,
+            Arc::clone(&self.consensus),
+            tx_env,
+        );
+
+        let (_command_tx, mut command_rx) = tokio::sync::watch::channel(ChunkCommand::Resume);
+        verifier
+            .resumable_verify_with_signal(u64::MAX, &mut command_rx)
+            .await
+    }
+
     // If the max cycles is meaningless, please use `verify_without_limit`,
     // so reviewers or developers can understand the intentions easier.
     pub(crate) fn verify(
@@ -206,6 +234,7 @@ impl TransactionScriptsVerifierWithEnv {
             let cycles;
             let mut times = 0usize;
             times += 1;
+
             let mut init_snap = match verifier.resumable_verify(max_cycles).unwrap() {
                 VerifyResult::Suspended(state) => Some(state.try_into().unwrap()),
                 VerifyResult::Completed(cycle) => {
@@ -217,14 +246,15 @@ impl TransactionScriptsVerifierWithEnv {
             loop {
                 times += 1;
                 let snap = init_snap.take().unwrap();
-                match verifier.resume_from_snap(&snap, max_cycles).unwrap() {
-                    VerifyResult::Suspended(state) => {
+                match verifier.resume_from_snap(&snap, max_cycles) {
+                    Ok(VerifyResult::Suspended(state)) => {
                         init_snap = Some(state.try_into().unwrap());
                     }
-                    VerifyResult::Completed(cycle) => {
+                    Ok(VerifyResult::Completed(cycle)) => {
                         cycles = cycle;
                         break;
                     }
+                    Err(e) => return Err(e),
                 }
             }
 
@@ -232,6 +262,38 @@ impl TransactionScriptsVerifierWithEnv {
         })
     }
 
+    pub(crate) async fn verify_complete_async(
+        &self,
+        version: ScriptVersion,
+        rtx: &ResolvedTransaction,
+        command_rx: &mut tokio::sync::watch::Receiver<ChunkCommand>,
+        skip_debug_pause: bool,
+    ) -> Result<Cycle, Error> {
+        let data_loader = self.store.as_data_loader();
+        let epoch = match version {
+            ScriptVersion::V0 => EpochNumberWithFraction::new(0, 0, 1),
+            ScriptVersion::V1 => EpochNumberWithFraction::new(self.version_1_enabled_at, 0, 1),
+            ScriptVersion::V2 => EpochNumberWithFraction::new(self.version_2_enabled_at, 0, 1),
+        };
+        let header = HeaderView::new_advanced_builder()
+            .epoch(epoch.pack())
+            .build();
+        let tx_env = Arc::new(TxVerifyEnv::new_commit(&header));
+        let verifier = TransactionScriptsVerifier::new(
+            Arc::new(rtx.clone()),
+            data_loader,
+            Arc::clone(&self.consensus),
+            tx_env,
+        );
+
+        if skip_debug_pause {
+            verifier.set_skip_pause(true);
+        }
+        verifier
+            .resumable_verify_with_signal(Cycle::MAX, command_rx)
+            .await
+    }
+
     pub(crate) fn verify_map<R, F>(
         &self,
         version: ScriptVersion,
@@ -251,12 +313,18 @@ impl TransactionScriptsVerifierWithEnv {
             .epoch(epoch.pack())
             .build();
         let tx_env = Arc::new(TxVerifyEnv::new_commit(&header));
-        let verifier = TransactionScriptsVerifier::new(
+        let mut verifier = TransactionScriptsVerifier::new(
             Arc::new(rtx.clone()),
             data_loader,
             Arc::clone(&self.consensus),
             tx_env,
         );
+        verifier.set_debug_printer(Box::new(move |_hash: &Byte32, message: &str| {
+            print!("{}", message);
+            if !message.ends_with('\n') {
+                println!();
+            }
+        }));
         verify_func(verifier)
     }
 }
diff --git a/script/testdata/.clang-format b/script/testdata/.clang-format
new file mode 100644
index 0000000000..815a156416
--- /dev/null
+++ b/script/testdata/.clang-format
@@ -0,0 +1,5 @@
+BasedOnStyle: Google
+IndentWidth: 4
+TabWidth: 4
+ColumnLimit: 120
+SortIncludes: false
diff --git a/script/testdata/Makefile b/script/testdata/Makefile
index 1550a931de..9db92fd549 100644
--- a/script/testdata/Makefile
+++ b/script/testdata/Makefile
@@ -9,20 +9,23 @@ LIB_TARGET := riscv64-unknown-linux-gnu
 LIB_CC :=      $(LIB_TARGET)-gcc
 LIB_OBJCOPY := $(LIB_TARGET)-objcopy
 
-# Tip: add `-DDEBUG` to enable the debug outputs
 COMMON_CFLAGS := -O3 \
                  -I deps/ckb-c-stdlib \
+                 -I deps/ckb-c-stdlib/libc \
                  -I deps/ckb-c-stdlib/molecule \
-                 -Wall -Werror -g
+                 -Wall -Werror \
+				 -fno-builtin -nostdinc -nostartfiles \
+				 -Wno-stringop-overflow
+# enable ckb-c-stdlib's printf
+COMMON_CFLAGS += -DCKB_C_STDLIB_PRINTF -DCKB_C_STDLIB_PRINTF_BUFFER_SIZE=1024
+
 BIN_CFLAGS := $(COMMON_CFLAGS)
-LIB_CFLAGS := -shared -fPIC -nostdlib -nostartfiles -fvisibility=hidden $(COMMON_CFLAGS)
+LIB_CFLAGS := -shared -fPIC -nostdlib -fvisibility=hidden -D__SHARED_LIBRARY__ $(COMMON_CFLAGS)
 
 COMMON_LDFLAGS := -Wl,-static -fdata-sections -ffunction-sections -Wl,--gc-sections
 BIN_LDFLAGS := $(COMMON_LDFLAGS)
 LIB_LDFLAGS := $(COMMON_LDFLAGS)
 
-OBJCOPY_FLAGS := --strip-debug --strip-all
-
 # nervos/ckb-riscv-gnu-toolchain:bionic-20210804
 BIN_BUILDER_DOCKER := nervos/ckb-riscv-gnu-toolchain@sha256:cfeb97864cf2039a0900bfa83c3f112a780b2281bded395604b8a8a693c95e08
 # nervos/ckb-riscv-gnu-toolchain:gnu-bionic-20210727
@@ -45,41 +48,41 @@ ALL_BINS := jalr_zero \
             exec_caller_big_offset_length \
             exec_configurable_callee \
             exec_configurable_caller \
+            infinite_exec \
+            infinite_loop \
             load_code_to_stack_then_reuse \
             load_is_even_into_global \
             load_is_even_with_snapshot \
             load_arithmetic \
             debugger \
-            get_memory_limit \
-            set_content \
-            spawn_big_content_length \
-            spawn_big_memory_size \
-            spawn_callee_exec_callee \
+			spawn_caller_strcat \
+			spawn_callee_strcat \
+            spawn_caller_exec \
             spawn_callee_exec_caller \
-            spawn_callee_get_memory_limit \
+            spawn_callee_exec_callee \
+            spawn_caller_strcat_wrap \
+            spawn_recursive \
             spawn_callee_out_of_cycles \
-            spawn_callee_set_content \
-            spawn_callee_strcat \
-            spawn_caller_exec \
-            spawn_caller_get_memory_limit \
             spawn_caller_out_of_cycles \
             spawn_caller_out_of_cycles_wrap \
-            spawn_caller_set_content \
-            spawn_caller_strcat_wrap \
-            spawn_caller_strcat \
-            spawn_caller_strcat_data_hash \
-            spawn_recursive \
-            spawn_current_memory \
             spawn_caller_current_cycles \
             spawn_callee_current_cycles \
-            spawn_peak_memory_512k_to_32m \
-            spawn_peak_memory_2m_to_32m \
-            spawn_peak_memory_4m_to_32m
+            spawn_times \
+            spawn_cases \
+            spawn_configurable_caller \
+            spawn_configurable_callee \
+            spawn_dag \
+            spawn_fuzzing \
+            spawn_huge_swap \
+            spawn_cycles \
+            spawn_io_cycles \
+            spawn_saturate_memory
+
 ALL_LIBS := is_even.lib \
             add1.lib sub1.lib mul2.lib div2.lib
 
-all-bins: clean-bins $(ALL_BINS)
-all-libs: clean-libs $(ALL_LIBS)
+all-bins: $(ALL_BINS)
+all-libs: $(ALL_LIBS)
 
 bins-in-docker:
 	docker run --rm -v `pwd`:/code $(BIN_BUILDER_DOCKER) bash -c "cd /code && make all-bins"
@@ -94,36 +97,38 @@ clean-bins:
 clean-libs:
 	-rm -f $(ALL_LIBS)
 
+fmt:
+	clang-format -i *.c *.h
+
 clean: clean-bins clean-libs
 
 %: %.c
 	$(BIN_CC) $(BIN_CFLAGS) $(BIN_LDFLAGS) -o $@ $<
-	$(BIN_OBJCOPY) $(OBJCOPY_FLAGS) $@
 
 %.lib: %.c
 	$(LIB_CC) $(LIB_CFLAGS) $(LIB_LDFLAGS) -o $@ $<
-	$(LIB_OBJCOPY) $(OBJCOPY_FLAGS) $@
 
 %: %.S
 	$(BIN_AS) -o $@.o $<
 	$(BIN_LD) -o $@ $@.o
 	@rm $@.o
-	$(BIN_OBJCOPY) $(OBJCOPY_FLAGS) $@
 
 jalr_zero: jalr_zero.S
 cadd_hint_lock: cadd_hint_lock.S
 	$(BIN_AS) -march=rv64imc -o $@.o $<
 	$(BIN_LD) -o $@ $@.o
 	@rm $@.o
-	$(BIN_OBJCOPY) $(OBJCOPY_FLAGS) $@
 cpop_lock: cpop_lock.c
 mop_adc_lock: mop_adc_lock.S
 current_cycles: current_cycles.c
 current_cycles_with_snapshot: current_cycles_with_snapshot.c
+infinite_exec: infinite_exec.c
+infinite_loop: infinite_loop.c
 vm_version: vm_version.c
 vm_version_2: vm_version_2.c
 vm_version_with_snapshot: vm_version_with_snapshot.c
 exec_callee: exec_callee.c
+exec_callee_pause: exec_callee_pause.c
 exec_caller_from_cell_data: exec_caller_from_cell_data.c
 exec_caller_from_witness: exec_caller_from_witness.c
 exec_caller_big_offset_length: exec_caller_big_offset_length.c
@@ -139,28 +144,25 @@ mul2.lib: mul2.c
 div2.lib: div2.c
 load_arithmetic: load_arithmetic.c
 
-get_memory_limit: get_memory_limit.c
-set_content: set_content.c
-spawn_big_content_length: spawn_big_content_length.c
-spawn_big_memory_size: spawn_big_memory_size.c
-spawn_callee_current_cycles: spawn_callee_current_cycles.c
-spawn_callee_exec_callee: spawn_callee_exec_callee.c
-spawn_callee_exec_caller: spawn_callee_exec_caller.c
-spawn_callee_get_memory_limit: spawn_callee_get_memory_limit.c
-spawn_callee_out_of_cycles: spawn_callee_out_of_cycles.c
-spawn_callee_set_content: spawn_callee_out_of_cycles.c
-spawn_callee_strcat: spawn_callee_strcat.c
-spawn_caller_current_cycles: spawn_caller_current_cycles.c
+spawn_caller_strcat: spawn_caller_strcat.c spawn_utils.h
+spawn_callee_strcat: spawn_callee_strcat.c spawn_utils.h
 spawn_caller_exec: spawn_caller_exec.c
-spawn_caller_get_memory_limit: spawn_caller_get_memory_limit.c
+spawn_callee_exec_caller: spawn_callee_exec_caller.c
+spawn_callee_exec_callee: spawn_callee_exec_callee.c
+spawn_caller_strcat_wrap: spawn_caller_strcat_wrap.c spawn_utils.h
+spawn_recursive: spawn_recursive.c spawn_utils.h
 spawn_caller_out_of_cycles: spawn_caller_out_of_cycles.c
+spawn_callee_out_of_cycles: spawn_callee_out_of_cycles.c
 spawn_caller_out_of_cycles_wrap: spawn_caller_out_of_cycles_wrap.c
-spawn_caller_set_content: spawn_caller_set_content.c
-spawn_caller_strcat_wrap: spawn_caller_strcat_wrap.c
-spawn_caller_strcat: spawn_caller_strcat.c
-spawn_caller_strcat_data_hash: spawn_caller_strcat_data_hash.c
-spawn_peak_memory_512k_to_32m: spawn_peak_memory_512k_to_32m.c
-spawn_peak_memory_2m_to_32m: spawn_peak_memory_2m_to_32m.c
-spawn_peak_memory_4m_to_32m: spawn_peak_memory_4m_to_32m.c
-spawn_recursive: spawn_recursive.c
-spawn_current_memory: spawn_current_memory.c
+spawn_caller_current_cycles: spawn_caller_current_cycles.c
+spawn_callee_current_cycles: spawn_callee_current_cycles.c
+spawn_times: spawn_times.c spawn_utils.h
+spawn_cases: spawn_cases.c spawn_utils.h
+spawn_configurable_caller: spawn_configurable_caller.c spawn_utils.h
+spawn_configurable_callee: spawn_configurable_callee.c spawn_utils.h
+spawn_dag: spawn_dag.c spawn_dag.h spawn_dag_escape_encoding.h
+spawn_fuzzing: spawn_fuzzing.c spawn_utils.h
+spawn_huge_swap: spawn_huge_swap.c spawn_utils.h
+spawn_cycles: spawn_cycles.c spawn_utils.h
+spawn_io_cycles: spawn_io_cycles.c spawn_utils.h
+spawn_saturate_memory: spawn_saturate_memory.c spawn_utils.h
diff --git a/script/testdata/add1.c b/script/testdata/add1.c
index e392d605b7..2e70f13589 100644
--- a/script/testdata/add1.c
+++ b/script/testdata/add1.c
@@ -1,5 +1,3 @@
 #include <stdint.h>
 
-__attribute__((visibility("default"))) uint64_t apply (uint64_t num) {
-    return num + 1;
-}
+__attribute__((visibility("default"))) uint64_t apply(uint64_t num) { return num + 1; }
diff --git a/script/testdata/add1.lib b/script/testdata/add1.lib
index 1c916b0a73..e6cd7e9c06 100755
Binary files a/script/testdata/add1.lib and b/script/testdata/add1.lib differ
diff --git a/script/testdata/cadd_hint_lock b/script/testdata/cadd_hint_lock
index 1f46b6b2ee..0a365e08a4 100755
Binary files a/script/testdata/cadd_hint_lock and b/script/testdata/cadd_hint_lock differ
diff --git a/script/testdata/cpop_lock b/script/testdata/cpop_lock
index cce506539f..983cacff78 100755
Binary files a/script/testdata/cpop_lock and b/script/testdata/cpop_lock differ
diff --git a/script/testdata/cpop_lock.c b/script/testdata/cpop_lock.c
index c28cde3fd7..ef88746574 100644
--- a/script/testdata/cpop_lock.c
+++ b/script/testdata/cpop_lock.c
@@ -4,9 +4,9 @@
  *    - `num0 == 0 && num1 == 0`
  *    - `cpop(num0) == num 1`
  */
-
-#include "ckb_syscalls.h"
+#include <stdlib.h>
 #include "blockchain.h"
+#include "ckb_syscalls.h"
 
 #ifdef DEBUG
 #include <stdio.h>
@@ -17,25 +17,22 @@
 
 #define SCRIPT_SIZE 32768
 
-static uint64_t cpop (uint64_t rs1) {
+static uint64_t cpop(uint64_t rs1) {
     uint64_t rd;
-    asm volatile (
+    asm volatile(
         "mv s2, %1\n"
         // "cpop s2, s2\n"
         ".byte 0x13,0x19,0x29,0x60\n"
         "mv %0, s2\n"
         : "=r"(rd)
         : "r"(rs1)
-        : "s2"
-    );
+        : "s2");
     return rd;
 }
 
-uint64_t read_u64_le (const uint8_t *src) {
-    return *(const uint64_t *)src;
-}
+uint64_t read_u64_le(const uint8_t *src) { return *(const uint64_t *)src; }
 
-int main (int argc, char *argv[]) {
+int main(int argc, char *argv[]) {
     int ret;
     uint64_t len = SCRIPT_SIZE;
     uint8_t script[SCRIPT_SIZE];
@@ -67,17 +64,20 @@ int main (int argc, char *argv[]) {
     }
 
     volatile uint64_t num0 = read_u64_le(bytes_seg.ptr);
-    volatile uint64_t num1 = read_u64_le(bytes_seg.ptr+8);
+    volatile uint64_t num1 = read_u64_le(bytes_seg.ptr + 8);
 
-    sprintf(message, "num0 = %ld", num0); ckb_debug(message);
-    sprintf(message, "num1 = %ld", num1); ckb_debug(message);
+    sprintf(message, "num0 = %ld", num0);
+    ckb_debug(message);
+    sprintf(message, "num1 = %ld", num1);
+    ckb_debug(message);
 
     if (num0 == 0 && num1 == 0) {
         return CKB_SUCCESS;
     }
 
     volatile uint64_t num1_actual = cpop(num0);
-    sprintf(message, "cpop(%lx) = %ld (actual) == %ld (expected)", num0, num1_actual, num1); ckb_debug(message);
+    sprintf(message, "cpop(%lx) = %ld (actual) == %ld (expected)", num0, num1_actual, num1);
+    ckb_debug(message);
 
     if (num1 != num1_actual) {
         return -5;
diff --git a/script/testdata/crash-45a6098d b/script/testdata/crash-45a6098d
new file mode 100644
index 0000000000..1980f8d2d9
Binary files /dev/null and b/script/testdata/crash-45a6098d differ
diff --git a/script/testdata/crash-4717eb0e b/script/testdata/crash-4717eb0e
new file mode 100644
index 0000000000..f5bf52fb4f
Binary files /dev/null and b/script/testdata/crash-4717eb0e differ
diff --git a/script/testdata/crash-5a27052f b/script/testdata/crash-5a27052f
new file mode 100644
index 0000000000..fd90467c49
Binary files /dev/null and b/script/testdata/crash-5a27052f differ
diff --git a/script/testdata/current_cycles b/script/testdata/current_cycles
index c524f6d090..fff424aba8 100755
Binary files a/script/testdata/current_cycles and b/script/testdata/current_cycles differ
diff --git a/script/testdata/current_cycles.c b/script/testdata/current_cycles.c
index 015c6f779d..892364885e 100644
--- a/script/testdata/current_cycles.c
+++ b/script/testdata/current_cycles.c
@@ -1,13 +1,11 @@
 #include "ckb_syscalls.h"
 
-int current_cycles() {
-    return syscall(2042, 0, 0, 0, 0, 0, 0);
-}
+int current_cycles() { return syscall(2042, 0, 0, 0, 0, 0, 0); }
 
 int main() {
     int prev = current_cycles();
     int curr;
-    for (int i=0; i<4096; i++) {
+    for (int i = 0; i < 4096; i++) {
         curr = current_cycles();
         if (curr <= prev) {
             return -1;
diff --git a/script/testdata/current_cycles_with_snapshot b/script/testdata/current_cycles_with_snapshot
index 62e6752e66..267ca5cb7c 100755
Binary files a/script/testdata/current_cycles_with_snapshot and b/script/testdata/current_cycles_with_snapshot differ
diff --git a/script/testdata/current_cycles_with_snapshot.c b/script/testdata/current_cycles_with_snapshot.c
index bc6ac19a93..bed65bb3f8 100644
--- a/script/testdata/current_cycles_with_snapshot.c
+++ b/script/testdata/current_cycles_with_snapshot.c
@@ -7,13 +7,9 @@
 #define sprintf(...)
 #endif
 
-void try_pause() {
-    syscall(2178, 0, 0, 0, 0, 0, 0);
-}
+void try_pause() { syscall(2178, 0, 0, 0, 0, 0, 0); }
 
-int current_cycles() {
-    return syscall(2042, 0, 0, 0, 0, 0, 0);
-}
+int current_cycles() { return syscall(2042, 0, 0, 0, 0, 0, 0); }
 
 int main() {
 #ifdef DEBUG
@@ -21,9 +17,10 @@ int main() {
 #endif
     int prev = current_cycles();
     int curr;
-    for (int i=0; i<4096; i++) {
+    for (int i = 0; i < 4096; i++) {
         curr = current_cycles();
-        sprintf(message, "prev = %d, curr = %d", prev, curr); ckb_debug(message);
+        sprintf(message, "prev = %d, curr = %d", prev, curr);
+        ckb_debug(message);
         if (i > 16) {
             try_pause();
         }
diff --git a/script/testdata/debugger b/script/testdata/debugger
index c0ef526adc..c679d6289d 100755
Binary files a/script/testdata/debugger and b/script/testdata/debugger differ
diff --git a/script/testdata/debugger.c b/script/testdata/debugger.c
index 2bdeb3613e..e3b6452a0f 100644
--- a/script/testdata/debugger.c
+++ b/script/testdata/debugger.c
@@ -1,10 +1,8 @@
-#include "ckb_syscalls.h"
 #include <stdio.h>
 
-int main() {
-    char message[2048];
-    sprintf(message, "debugger print utf-8 string");
-    ckb_debug(message);
+#include "ckb_syscalls.h"
 
+int main() {
+    printf("debugger print utf-8 string");
     return CKB_SUCCESS;
 }
diff --git a/script/testdata/div2.c b/script/testdata/div2.c
index aef67b1947..8e10b2884a 100644
--- a/script/testdata/div2.c
+++ b/script/testdata/div2.c
@@ -1,5 +1,3 @@
 #include <stdint.h>
 
-__attribute__((visibility("default"))) uint64_t apply (uint64_t num) {
-    return num / 2;
-}
+__attribute__((visibility("default"))) uint64_t apply(uint64_t num) { return num / 2; }
diff --git a/script/testdata/div2.lib b/script/testdata/div2.lib
index 1775b76a35..d631c7773a 100755
Binary files a/script/testdata/div2.lib and b/script/testdata/div2.lib differ
diff --git a/script/testdata/exec_callee b/script/testdata/exec_callee
index 81c802765d..b34d537dd2 100755
Binary files a/script/testdata/exec_callee and b/script/testdata/exec_callee differ
diff --git a/script/testdata/exec_callee.c b/script/testdata/exec_callee.c
index 3a815b171c..d5d7040852 100644
--- a/script/testdata/exec_callee.c
+++ b/script/testdata/exec_callee.c
@@ -1,15 +1,17 @@
+#include <stdlib.h>
+
 int main(int argc, char* argv[]) {
-  if (argc != 3) {
-    return 1;
-  }
-  if (argv[0][0] != 'a') {
-    return 2;
-  }
-  if (argv[1][0] != 'b') {
-    return 3;
-  }
-  if (argv[2][0] != 'c') {
-    return 4;
-  }
-  return 0;
+    if (argc != 3) {
+        return 1;
+    }
+    if (argv[0][0] != 'a') {
+        return 2;
+    }
+    if (argv[1][0] != 'b') {
+        return 3;
+    }
+    if (argv[2][0] != 'c') {
+        return 4;
+    }
+    return 0;
 }
diff --git a/script/testdata/exec_callee_pause b/script/testdata/exec_callee_pause
new file mode 100755
index 0000000000..5bf0e730bb
Binary files /dev/null and b/script/testdata/exec_callee_pause differ
diff --git a/script/testdata/exec_callee_pause.c b/script/testdata/exec_callee_pause.c
new file mode 100644
index 0000000000..f3cc85fc84
--- /dev/null
+++ b/script/testdata/exec_callee_pause.c
@@ -0,0 +1,27 @@
+#include "ckb_syscalls.h"
+
+void try_pause() {
+    ckb_debug("try_pause");
+    syscall(2178, 0, 0, 0, 0, 0, 0);
+}
+
+int main(int argc, char* argv[]) {
+    try_pause();
+    if (argc != 3) {
+        return 1;
+    }
+    try_pause();
+    if (argv[0][0] != 'a') {
+        return 2;
+    }
+    try_pause();
+    if (argv[1][0] != 'b') {
+        return 3;
+    }
+    try_pause();
+    if (argv[2][0] != 'c') {
+        return 4;
+    }
+    try_pause();
+    return 0;
+}
diff --git a/script/testdata/exec_caller_big_offset_length b/script/testdata/exec_caller_big_offset_length
index 1ea87c14ca..9cb14cddcf 100755
Binary files a/script/testdata/exec_caller_big_offset_length and b/script/testdata/exec_caller_big_offset_length differ
diff --git a/script/testdata/exec_caller_big_offset_length.c b/script/testdata/exec_caller_big_offset_length.c
index 833baab339..e0577b3c6b 100644
--- a/script/testdata/exec_caller_big_offset_length.c
+++ b/script/testdata/exec_caller_big_offset_length.c
@@ -5,7 +5,7 @@ int main() {
     char *argv[] = {"a", "b", "c"};
     int ret = syscall(2043, 1, 3, 0, 0xffffffffffffffff, argc, argv);
     if (ret != 0) {
-      return ret;
+        return ret;
     }
     return -1;
 }
diff --git a/script/testdata/exec_caller_from_cell_data b/script/testdata/exec_caller_from_cell_data
index 64fa89fc73..2b597da570 100755
Binary files a/script/testdata/exec_caller_from_cell_data and b/script/testdata/exec_caller_from_cell_data differ
diff --git a/script/testdata/exec_caller_from_witness b/script/testdata/exec_caller_from_witness
index a22f978254..94c560a8fd 100755
Binary files a/script/testdata/exec_caller_from_witness and b/script/testdata/exec_caller_from_witness differ
diff --git a/script/testdata/exec_configurable_callee b/script/testdata/exec_configurable_callee
index c99bb78cad..0fd19349a2 100755
Binary files a/script/testdata/exec_configurable_callee and b/script/testdata/exec_configurable_callee differ
diff --git a/script/testdata/exec_configurable_callee.c b/script/testdata/exec_configurable_callee.c
index d03bdd7948..3cc60abe3a 100644
--- a/script/testdata/exec_configurable_callee.c
+++ b/script/testdata/exec_configurable_callee.c
@@ -25,9 +25,9 @@
  *      - The `code_hash`(`data_hash`) of a shared library.
  */
 
-#include "stdbool.h"
 #include "ckb_dlfcn.h"
 #include "ckb_syscalls.h"
+#include "stdbool.h"
 
 #ifdef DEBUG
 #include <stdio.h>
@@ -40,73 +40,74 @@ char message[2048];
 #define EXEC_ARGC 9
 #define BUFFER_SIZE 32768
 
-typedef uint64_t(arithmetic_func_t) (uint64_t);
+typedef uint64_t(arithmetic_func_t)(uint64_t);
 
 uint8_t CODE_BUFFER[BUFFER_SIZE] __attribute__((aligned(RISCV_PGSIZE)));
 
-void try_pause() {
-    syscall(2178, 0, 0, 0, 0, 0, 0);
-}
+void try_pause() { syscall(2178, 0, 0, 0, 0, 0, 0); }
 
-void from_hex (uint8_t* dst, char* src, size_t len) {
-    for (size_t i=0; i<len; i++) {
-        uint8_t hi = src[i*2];
-        uint8_t lo = src[i*2+1];
+void from_hex(uint8_t* dst, char* src, size_t len) {
+    for (size_t i = 0; i < len; i++) {
+        uint8_t hi = src[i * 2];
+        uint8_t lo = src[i * 2 + 1];
         dst[i] = (((hi & 0xf) + (hi >> 6) * 9) << 4) | (((lo & 0xf) + (lo >> 6) * 9));
     }
 }
 
 void to_hex(char* dst, uint8_t* src, size_t len) {
-    for (size_t i = 0; i<len; i++) {
+    for (size_t i = 0; i < len; i++) {
         char hi = src[i] >> 4;
         char lo = src[i] & 0xf;
-        dst[i*2] = hi + (hi < 10 ? '0' : ('a' - 10));
-        dst[i*2+1] = lo + (lo < 10 ? '0' : ('a' - 10));
+        dst[i * 2] = hi + (hi < 10 ? '0' : ('a' - 10));
+        dst[i * 2 + 1] = lo + (lo < 10 ? '0' : ('a' - 10));
     }
-    dst[len*2] = '\0';
+    dst[len * 2] = '\0';
 }
 
-volatile uint64_t read_u64_le_from_hex (char* src) {
+volatile uint64_t read_u64_le_from_hex(char* src) {
     uint8_t bytes[8];
     from_hex(bytes, src, 8);
-    return *(const uint64_t *)bytes;
+    return *(const uint64_t*)bytes;
 }
 
-void write_u64_le_to_hex (char* dst, uint64_t number) {
-    uint8_t* bytes = (uint8_t *)(&number);
+void write_u64_le_to_hex(char* dst, uint64_t number) {
+    uint8_t* bytes = (uint8_t*)(&number);
     to_hex(dst, bytes, 8);
 }
 
-int try_exec(char*argv[], uint64_t recursion, uint64_t number) {
-    sprintf(message, "argv[4] = %s", argv[4]); ckb_debug(message);
-    if (strlen(argv[4]) != 8*2) {
+int try_exec(char* argv[], uint64_t recursion, uint64_t number) {
+    sprintf(message, "argv[4] = %s", argv[4]);
+    ckb_debug(message);
+    if (strlen(argv[4]) != 8 * 2) {
         return -21;
     }
     uint64_t index = read_u64_le_from_hex(argv[4]);
 
-    sprintf(message, "argv[5] = %s", argv[5]); ckb_debug(message);
-    if (strlen(argv[5]) != 8*2) {
+    sprintf(message, "argv[5] = %s", argv[5]);
+    ckb_debug(message);
+    if (strlen(argv[5]) != 8 * 2) {
         return -22;
     }
     uint64_t source = read_u64_le_from_hex(argv[5]);
 
-    sprintf(message, "argv[6] = %s", argv[6]); ckb_debug(message);
-    if (strlen(argv[6]) != 8*2) {
+    sprintf(message, "argv[6] = %s", argv[6]);
+    ckb_debug(message);
+    if (strlen(argv[6]) != 8 * 2) {
         return -23;
     }
     uint64_t place = read_u64_le_from_hex(argv[6]);
 
-    sprintf(message, "argv[7] = %s", argv[7]); ckb_debug(message);
-    if (strlen(argv[7]) != 8*2) {
+    sprintf(message, "argv[7] = %s", argv[7]);
+    ckb_debug(message);
+    if (strlen(argv[7]) != 8 * 2) {
         return -24;
     }
     uint64_t bounds = read_u64_le_from_hex(argv[7]);
 
-    char recursion_str[8*2+1];
-    char number_str[8*2+1];
-    char *argv_new[EXEC_ARGC] = {
-        argv[0], recursion_str, number_str, argv[3],
-        argv[4], argv[5], argv[6], argv[7], argv[8] };
+    char recursion_str[8 * 2 + 1];
+    char number_str[8 * 2 + 1];
+    char* argv_new[EXEC_ARGC] = {argv[0], recursion_str, number_str, argv[3], argv[4],
+                                 argv[5], argv[6],       argv[7],    argv[8]};
     write_u64_le_to_hex(recursion_str, recursion);
     write_u64_le_to_hex(number_str, number);
     try_pause();
@@ -115,7 +116,7 @@ int try_exec(char*argv[], uint64_t recursion, uint64_t number) {
 }
 
 int try_load_code(uint64_t* number, uint8_t* code_hash) {
-    void *handle = NULL;
+    void* handle = NULL;
     uint64_t consumed_size = 0;
     uint8_t hash_type = 0;
     int ret = ckb_dlopen2(code_hash, hash_type, CODE_BUFFER, BUFFER_SIZE, &handle, &consumed_size);
@@ -123,7 +124,7 @@ int try_load_code(uint64_t* number, uint8_t* code_hash) {
         return -31;
     }
     try_pause();
-    arithmetic_func_t* func = (arithmetic_func_t*) ckb_dlsym(handle, "apply");
+    arithmetic_func_t* func = (arithmetic_func_t*)ckb_dlsym(handle, "apply");
     if (func == NULL) {
         return -32;
     }
@@ -132,54 +133,62 @@ int try_load_code(uint64_t* number, uint8_t* code_hash) {
     return CKB_SUCCESS;
 }
 
-int main (int argc, char *argv[]) {
-    sprintf(message, "argc = %d", argc); ckb_debug(message);
+int main(int argc, char* argv[]) {
+    sprintf(message, "argc = %d", argc);
+    ckb_debug(message);
     if (argc != EXEC_ARGC) {
         return -11;
     }
 
-    sprintf(message, "argv[0] = %s", argv[0]); ckb_debug(message);
-    if (strlen(argv[0]) != 1*2) {
+    sprintf(message, "argv[0] = %s", argv[0]);
+    ckb_debug(message);
+    if (strlen(argv[0]) != 1 * 2) {
         return -12;
     }
     uint8_t flag;
     from_hex(&flag, argv[0], 1);
 
-    bool if_write_stack      = (flag & 0b0010) == 0b0010;
+    bool if_write_stack = (flag & 0b0010) == 0b0010;
     if (if_write_stack) {
-        sprintf(message, "(try update the stack)"); ckb_debug(message);
-        sprintf(message, "W in [%p, %p)", CODE_BUFFER, CODE_BUFFER+BUFFER_SIZE); ckb_debug(message);
-        for (int i=0; i<BUFFER_SIZE; i++) {
+        sprintf(message, "(try update the stack)");
+        ckb_debug(message);
+        sprintf(message, "W in [%p, %p)", CODE_BUFFER, CODE_BUFFER + BUFFER_SIZE);
+        ckb_debug(message);
+        for (int i = 0; i < BUFFER_SIZE; i++) {
             CODE_BUFFER[i] += 1;
         }
     }
 
-    sprintf(message, "argv[1] = %s", argv[1]); ckb_debug(message);
-    if (strlen(argv[1]) != 8*2) {
+    sprintf(message, "argv[1] = %s", argv[1]);
+    ckb_debug(message);
+    if (strlen(argv[1]) != 8 * 2) {
         return -13;
     }
     uint64_t recursion = read_u64_le_from_hex(argv[1]);
 
-    sprintf(message, "argv[2] = %s", argv[2]); ckb_debug(message);
-    if (strlen(argv[2]) != 8*2) {
+    sprintf(message, "argv[2] = %s", argv[2]);
+    ckb_debug(message);
+    if (strlen(argv[2]) != 8 * 2) {
         return -14;
     }
     uint64_t number = read_u64_le_from_hex(argv[2]);
 
     if (recursion > 0) {
-        try_exec(argv, recursion-1, number-1);
+        try_exec(argv, recursion - 1, number - 1);
     }
 
-    sprintf(message, "argv[3] = %s", argv[3]); ckb_debug(message);
-    if (strlen(argv[3]) != 8*2) {
+    sprintf(message, "argv[3] = %s", argv[3]);
+    ckb_debug(message);
+    if (strlen(argv[3]) != 8 * 2) {
         return -15;
     }
     uint64_t expected = read_u64_le_from_hex(argv[3]);
 
-    bool if_load_after_exec  = (flag & 0b0100) == 0b0100;
+    bool if_load_after_exec = (flag & 0b0100) == 0b0100;
     if (if_load_after_exec) {
-        sprintf(message, "argv[8] = %s", argv[8]); ckb_debug(message);
-        if (strlen(argv[8]) != 32*2) {
+        sprintf(message, "argv[8] = %s", argv[8]);
+        ckb_debug(message);
+        if (strlen(argv[8]) != 32 * 2) {
             return -16;
         }
         uint8_t code_hash[32];
@@ -188,7 +197,8 @@ int main (int argc, char *argv[]) {
         if (ret != CKB_SUCCESS) {
             return ret;
         }
-        sprintf(message, "(apply after exec) number = %ld", number); ckb_debug(message);
+        sprintf(message, "(apply after exec) number = %ld", number);
+        ckb_debug(message);
     }
 
     if (number == expected) {
diff --git a/script/testdata/exec_configurable_caller b/script/testdata/exec_configurable_caller
index 911eb8d274..9cb002df35 100755
Binary files a/script/testdata/exec_configurable_caller and b/script/testdata/exec_configurable_caller differ
diff --git a/script/testdata/exec_configurable_caller.c b/script/testdata/exec_configurable_caller.c
index 48f3425ade..7e587a69f7 100644
--- a/script/testdata/exec_configurable_caller.c
+++ b/script/testdata/exec_configurable_caller.c
@@ -2,10 +2,10 @@
  *  - Args:
  *    See "exec_configurable_callee.c".
  */
-
+#include <stdlib.h>
+#include "blockchain.h"
 #include "ckb_dlfcn.h"
 #include "ckb_syscalls.h"
-#include "blockchain.h"
 
 #ifdef DEBUG
 #include <stdio.h>
@@ -19,36 +19,33 @@ char message[2048];
 #define SCRIPT_SIZE 32768
 #define BUFFER_SIZE 32768
 
-typedef uint64_t(arithmetic_func_t) (uint64_t);
+typedef uint64_t(arithmetic_func_t)(uint64_t);
 
 uint8_t CODE_BUFFER[BUFFER_SIZE] __attribute__((aligned(RISCV_PGSIZE)));
 
 void to_hex(char* dst, uint8_t* src, size_t len) {
-    for (size_t i = 0; i<len; i++) {
+    for (size_t i = 0; i < len; i++) {
         char hi = src[i] >> 4;
         char lo = src[i] & 0xf;
-        dst[i*2] = hi + (hi < 10 ? '0' : ('a' - 10));
-        dst[i*2+1] = lo + (lo < 10 ? '0' : ('a' - 10));
+        dst[i * 2] = hi + (hi < 10 ? '0' : ('a' - 10));
+        dst[i * 2 + 1] = lo + (lo < 10 ? '0' : ('a' - 10));
     }
-    dst[len*2] = '\0';
+    dst[len * 2] = '\0';
 }
 
-void write_u64_le_to_hex (char* dst, uint64_t number) {
-    uint8_t* bytes = (uint8_t *)(&number);
+void write_u64_le_to_hex(char* dst, uint64_t number) {
+    uint8_t* bytes = (uint8_t*)(&number);
     to_hex(dst, bytes, 8);
 }
 
-void try_pause() {
-    syscall(2178, 0, 0, 0, 0, 0, 0);
-}
+void try_pause() { syscall(2178, 0, 0, 0, 0, 0, 0); }
 
-uint64_t read_u64_le (const uint8_t *src) {
-    return *(const uint64_t *)src;
-}
+uint64_t read_u64_le(const uint8_t* src) { return *(const uint64_t*)src; }
 
 int try_load_code(uint64_t* number, uint8_t* code_hash) {
-    sprintf(message, "X in [%p, %p)", CODE_BUFFER, CODE_BUFFER+BUFFER_SIZE); ckb_debug(message);
-    void *handle = NULL;
+    sprintf(message, "X in [%p, %p)", CODE_BUFFER, CODE_BUFFER + BUFFER_SIZE);
+    ckb_debug(message);
+    void* handle = NULL;
     uint64_t consumed_size = 0;
     uint8_t hash_type = 0;
     int ret = ckb_dlopen2(code_hash, hash_type, CODE_BUFFER, BUFFER_SIZE, &handle, &consumed_size);
@@ -56,7 +53,7 @@ int try_load_code(uint64_t* number, uint8_t* code_hash) {
         return -6;
     }
     try_pause();
-    arithmetic_func_t* func = (arithmetic_func_t*) ckb_dlsym(handle, "apply");
+    arithmetic_func_t* func = (arithmetic_func_t*)ckb_dlsym(handle, "apply");
     if (func == NULL) {
         return -7;
     }
@@ -65,7 +62,7 @@ int try_load_code(uint64_t* number, uint8_t* code_hash) {
     return CKB_SUCCESS;
 }
 
-int main (int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
     int ret;
     uint64_t len = SCRIPT_SIZE;
     uint8_t script[SCRIPT_SIZE];
@@ -81,7 +78,7 @@ int main (int argc, char *argv[]) {
     mol_seg_t script_seg;
     mol_seg_t args_seg;
     mol_seg_t bytes_seg;
-    script_seg.ptr = (uint8_t *)script;
+    script_seg.ptr = (uint8_t*)script;
     script_seg.size = len;
     if (MolReader_Script_verify(&script_seg, false) != MOL_OK) {
         return -3;
@@ -89,27 +86,35 @@ int main (int argc, char *argv[]) {
     args_seg = MolReader_Script_get_args(&script_seg);
     bytes_seg = MolReader_Bytes_raw_bytes(&args_seg);
 
-    if (bytes_seg.size != 1 + 8*7 + 32) {
+    if (bytes_seg.size != 1 + 8 * 7 + 32) {
         return -4;
     }
 
-    uint8_t flag       = bytes_seg.ptr[0];
-    uint64_t recursion = read_u64_le(bytes_seg.ptr+1);
-    uint64_t number    = read_u64_le(bytes_seg.ptr+1+8);
-    uint64_t expected  = read_u64_le(bytes_seg.ptr+1+8*2);
-    uint64_t index     = read_u64_le(bytes_seg.ptr+1+8*3);
-    uint64_t source    = read_u64_le(bytes_seg.ptr+1+8*4);
-    uint64_t place     = read_u64_le(bytes_seg.ptr+1+8*5);
-    uint64_t bounds    = read_u64_le(bytes_seg.ptr+1+8*6);
-
-    sprintf(message, "flag      = %x",  flag     ); ckb_debug(message);
-    sprintf(message, "recursion = %ld", recursion); ckb_debug(message);
-    sprintf(message, "number    = %ld", number   ); ckb_debug(message);
-    sprintf(message, "expected  = %ld", expected ); ckb_debug(message);
-    sprintf(message, "index     = %ld", index    ); ckb_debug(message);
-    sprintf(message, "source    = %ld", source   ); ckb_debug(message);
-    sprintf(message, "place     = %ld", place    ); ckb_debug(message);
-    sprintf(message, "bounds    = %ld", bounds   ); ckb_debug(message);
+    uint8_t flag = bytes_seg.ptr[0];
+    uint64_t recursion = read_u64_le(bytes_seg.ptr + 1);
+    uint64_t number = read_u64_le(bytes_seg.ptr + 1 + 8);
+    uint64_t expected = read_u64_le(bytes_seg.ptr + 1 + 8 * 2);
+    uint64_t index = read_u64_le(bytes_seg.ptr + 1 + 8 * 3);
+    uint64_t source = read_u64_le(bytes_seg.ptr + 1 + 8 * 4);
+    uint64_t place = read_u64_le(bytes_seg.ptr + 1 + 8 * 5);
+    uint64_t bounds = read_u64_le(bytes_seg.ptr + 1 + 8 * 6);
+
+    sprintf(message, "flag      = %x", flag);
+    ckb_debug(message);
+    sprintf(message, "recursion = %ld", recursion);
+    ckb_debug(message);
+    sprintf(message, "number    = %ld", number);
+    ckb_debug(message);
+    sprintf(message, "expected  = %ld", expected);
+    ckb_debug(message);
+    sprintf(message, "index     = %ld", index);
+    ckb_debug(message);
+    sprintf(message, "source    = %ld", source);
+    ckb_debug(message);
+    sprintf(message, "place     = %ld", place);
+    ckb_debug(message);
+    sprintf(message, "bounds    = %ld", bounds);
+    ckb_debug(message);
 
     try_pause();
 
@@ -123,37 +128,37 @@ int main (int argc, char *argv[]) {
 
     bool if_load_before_exec = (flag & 0b0001) == 0b0001;
     if (if_load_before_exec) {
-        ret = try_load_code(&number, bytes_seg.ptr+1+8*7);
+        ret = try_load_code(&number, bytes_seg.ptr + 1 + 8 * 7);
         if (ret != CKB_SUCCESS) {
             return ret;
         }
         try_pause();
-        sprintf(message, "(apply before exec) number = %ld", number); ckb_debug(message);
+        sprintf(message, "(apply before exec) number = %ld", number);
+        ckb_debug(message);
     }
 
     {
         int argc_new = EXEC_ARGC;
-        char flag_str[1*2+1];
-        char recursion_str[8*2+1];
-        char number_str[8*2+1];
-        char expected_str[8*2+1];
-        char index_str[8*2+1];
-        char source_str[8*2+1];
-        char place_str[8*2+1];
-        char bounds_str[8*2+1];
-        char code_hash_str[32*2+1];
-        char *argv_new[EXEC_ARGC] = {
-            flag_str, recursion_str, number_str, expected_str,
-            index_str, source_str, place_str, bounds_str, code_hash_str };
-        to_hex(flag_str,      bytes_seg.ptr, 1);
-        write_u64_le_to_hex(recursion_str, recursion-1);
-        write_u64_le_to_hex(number_str, number-1);
+        char flag_str[1 * 2 + 1];
+        char recursion_str[8 * 2 + 1];
+        char number_str[8 * 2 + 1];
+        char expected_str[8 * 2 + 1];
+        char index_str[8 * 2 + 1];
+        char source_str[8 * 2 + 1];
+        char place_str[8 * 2 + 1];
+        char bounds_str[8 * 2 + 1];
+        char code_hash_str[32 * 2 + 1];
+        char* argv_new[EXEC_ARGC] = {flag_str,   recursion_str, number_str, expected_str, index_str,
+                                     source_str, place_str,     bounds_str, code_hash_str};
+        to_hex(flag_str, bytes_seg.ptr, 1);
+        write_u64_le_to_hex(recursion_str, recursion - 1);
+        write_u64_le_to_hex(number_str, number - 1);
         write_u64_le_to_hex(expected_str, expected);
-        to_hex(index_str,     bytes_seg.ptr+1+8*3, 8);
-        to_hex(source_str,    bytes_seg.ptr+1+8*4, 8);
-        to_hex(place_str,     bytes_seg.ptr+1+8*5, 8);
-        to_hex(bounds_str,    bytes_seg.ptr+1+8*6, 8);
-        to_hex(code_hash_str, bytes_seg.ptr+1+8*7, 32);
+        to_hex(index_str, bytes_seg.ptr + 1 + 8 * 3, 8);
+        to_hex(source_str, bytes_seg.ptr + 1 + 8 * 4, 8);
+        to_hex(place_str, bytes_seg.ptr + 1 + 8 * 5, 8);
+        to_hex(bounds_str, bytes_seg.ptr + 1 + 8 * 6, 8);
+        to_hex(code_hash_str, bytes_seg.ptr + 1 + 8 * 7, 32);
         int ret = syscall(2043, index, source, place, bounds, argc_new, argv_new);
         if (ret != CKB_SUCCESS) {
             return ret;
diff --git a/script/testdata/get_memory_limit b/script/testdata/get_memory_limit
deleted file mode 100755
index fbf37219f1..0000000000
Binary files a/script/testdata/get_memory_limit and /dev/null differ
diff --git a/script/testdata/get_memory_limit.c b/script/testdata/get_memory_limit.c
deleted file mode 100644
index a148ad4713..0000000000
--- a/script/testdata/get_memory_limit.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "ckb_syscalls.h"
-
-int main() {
-  if (ckb_get_memory_limit() == 8) {
-    return 0;
-  }
-  return 1;
-}
diff --git a/script/testdata/infinite_exec b/script/testdata/infinite_exec
new file mode 100755
index 0000000000..e5e4aad750
Binary files /dev/null and b/script/testdata/infinite_exec differ
diff --git a/script/testdata/infinite_exec.c b/script/testdata/infinite_exec.c
new file mode 100644
index 0000000000..3255ae2f64
--- /dev/null
+++ b/script/testdata/infinite_exec.c
@@ -0,0 +1,8 @@
+#include "ckb_syscalls.h"
+
+int main() {
+    int argc = 0;
+    char *argv[] = {};
+    syscall(2043, 0, 3, 0, 0, argc, argv);
+    return -1;
+}
diff --git a/script/testdata/infinite_loop b/script/testdata/infinite_loop
new file mode 100755
index 0000000000..778627008a
Binary files /dev/null and b/script/testdata/infinite_loop differ
diff --git a/script/testdata/infinite_loop.c b/script/testdata/infinite_loop.c
new file mode 100644
index 0000000000..ebe4d9a48d
--- /dev/null
+++ b/script/testdata/infinite_loop.c
@@ -0,0 +1,14 @@
+#include "ckb_syscalls.h"
+
+#ifdef DEBUG
+#include <stdio.h>
+#else
+#define ckb_debug(...)
+#define sprintf(...)
+#endif
+
+int main() {
+    for (;;) {
+    }
+    return CKB_SUCCESS;
+}
diff --git a/script/testdata/is_even.c b/script/testdata/is_even.c
index 44a23ed326..5d268ad424 100644
--- a/script/testdata/is_even.c
+++ b/script/testdata/is_even.c
@@ -1,7 +1,8 @@
+#include <stdlib.h>
 #include <stdbool.h>
 #include <stdint.h>
 
-__attribute__((visibility("default"))) bool is_even (uint64_t num) {
+__attribute__((visibility("default"))) bool is_even(uint64_t num) {
     if (num & 0x1) {
         return false;
     } else {
diff --git a/script/testdata/is_even.lib b/script/testdata/is_even.lib
index 07b308138a..9e45b77c71 100755
Binary files a/script/testdata/is_even.lib and b/script/testdata/is_even.lib differ
diff --git a/script/testdata/jalr_zero b/script/testdata/jalr_zero
index f77b85d85c..77a89a48d4 100755
Binary files a/script/testdata/jalr_zero and b/script/testdata/jalr_zero differ
diff --git a/script/testdata/load_arithmetic b/script/testdata/load_arithmetic
index 650df9295c..df1c203761 100755
Binary files a/script/testdata/load_arithmetic and b/script/testdata/load_arithmetic differ
diff --git a/script/testdata/load_arithmetic.c b/script/testdata/load_arithmetic.c
index b1c34bb181..95c06a831d 100644
--- a/script/testdata/load_arithmetic.c
+++ b/script/testdata/load_arithmetic.c
@@ -7,9 +7,10 @@
  *    - `num0 == num1` is zero at last.
  */
 
+#include <stdlib.h>
+#include "blockchain.h"
 #include "ckb_dlfcn.h"
 #include "ckb_syscalls.h"
-#include "blockchain.h"
 
 #ifdef DEBUG
 #include <stdio.h>
@@ -22,32 +23,28 @@
 #define CODE_BUFFER_SIZE (1024 * 32)
 #define CACHE_CAPACITY 4
 
-typedef uint64_t(arithmetic_func_t) (uint64_t);
+typedef uint64_t(arithmetic_func_t)(uint64_t);
 
-void try_pause() {
-    syscall(2178, 0, 0, 0, 0, 0, 0);
-}
+void try_pause() { syscall(2178, 0, 0, 0, 0, 0, 0); }
 
-uint64_t read_u64_le (const uint8_t *src) {
-    return *(const uint64_t *)src;
-}
+uint64_t read_u64_le(const uint8_t* src) { return *(const uint64_t*)src; }
 
-int load_arithmetic_func (arithmetic_func_t** func, uint8_t* code_hash, uint8_t* code_buffer) {
-    void *handle = NULL;
+int load_arithmetic_func(arithmetic_func_t** func, uint8_t* code_hash, uint8_t* code_buffer) {
+    void* handle = NULL;
     uint64_t consumed_size = 0;
     uint8_t hash_type = 0;
     int ret = ckb_dlopen2(code_hash, hash_type, code_buffer, CODE_BUFFER_SIZE, &handle, &consumed_size);
     if (ret != CKB_SUCCESS) {
         return -11;
     }
-    *func = (arithmetic_func_t*) ckb_dlsym(handle, "apply");
+    *func = (arithmetic_func_t*)ckb_dlsym(handle, "apply");
     if (*func == NULL) {
         return -12;
     }
     return CKB_SUCCESS;
 }
 
-int main (int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
     int ret;
     uint64_t len = SCRIPT_SIZE;
     uint8_t script[SCRIPT_SIZE];
@@ -66,7 +63,7 @@ int main (int argc, char *argv[]) {
     mol_seg_t script_seg;
     mol_seg_t args_seg;
     mol_seg_t bytes_seg;
-    script_seg.ptr = (uint8_t *)script;
+    script_seg.ptr = (uint8_t*)script;
     script_seg.size = len;
     if (MolReader_Script_verify(&script_seg, false) != MOL_OK) {
         return -3;
@@ -79,8 +76,9 @@ int main (int argc, char *argv[]) {
     }
 
     volatile uint64_t num0 = read_u64_le(bytes_seg.ptr);
-    volatile uint64_t num1 = read_u64_le(bytes_seg.ptr+8);
-    sprintf(message, "before num0 = %ld, num1 = %ld", num0, num1); ckb_debug(message);
+    volatile uint64_t num1 = read_u64_le(bytes_seg.ptr + 8);
+    sprintf(message, "before num0 = %ld, num1 = %ld", num0, num1);
+    ckb_debug(message);
 
     if (num0 == num1) {
         return CKB_SUCCESS;
@@ -113,7 +111,7 @@ int main (int argc, char *argv[]) {
             for (int i = 0; i < cache_size; i++) {
                 if (0 == memcmp(code_hash_ptr, cached_code_hash[i], 32)) {
                     // Find the function from caches.
-                    tmp_func = (arithmetic_func_t*) cached_funcs[i];
+                    tmp_func = (arithmetic_func_t*)cached_funcs[i];
                     is_found = true;
                 }
             }
@@ -144,7 +142,7 @@ int main (int argc, char *argv[]) {
             // Cache the current function.
             if (cache_size < CACHE_CAPACITY) {
                 cached_code_hash[cache_size] = code_hash_ptr;
-                cached_funcs[cache_size] = (void*) tmp_func;
+                cached_funcs[cache_size] = (void*)tmp_func;
                 cache_size += 1;
             }
         }
@@ -156,7 +154,8 @@ int main (int argc, char *argv[]) {
         called_funcs_count += 1;
     }
 
-    sprintf(message, "after  num0 = %ld, num1 = %ld", num0, num1); ckb_debug(message);
+    sprintf(message, "after  num0 = %ld, num1 = %ld", num0, num1);
+    ckb_debug(message);
 
     if (num0 != num1) {
         return -5;
diff --git a/script/testdata/load_code_to_stack_then_reuse b/script/testdata/load_code_to_stack_then_reuse
index 494dcd1a4b..52881964bf 100755
Binary files a/script/testdata/load_code_to_stack_then_reuse and b/script/testdata/load_code_to_stack_then_reuse differ
diff --git a/script/testdata/load_code_to_stack_then_reuse.c b/script/testdata/load_code_to_stack_then_reuse.c
index 96b6376ceb..a655f8e7e1 100644
--- a/script/testdata/load_code_to_stack_then_reuse.c
+++ b/script/testdata/load_code_to_stack_then_reuse.c
@@ -4,10 +4,10 @@
  *    - A little endian unsigned 64 bits integer: `size`.
  *    - The `code_hash`(`data_hash`) of a shared library.
  */
-
+#include <stdlib.h>
+#include "blockchain.h"
 #include "ckb_dlfcn.h"
 #include "ckb_syscalls.h"
-#include "blockchain.h"
 
 #ifdef DEBUG
 #include <stdio.h>
@@ -22,13 +22,12 @@ char message[2048];
 
 #define bool2char(b) ((b) ? '+' : '-')
 
-uint64_t read_u64_le (const uint8_t *src) {
-    return *(const uint64_t *)src;
-}
+uint64_t read_u64_le(const uint8_t *src) { return *(const uint64_t *)src; }
 
-int try_load_code(bool if_load_code, uint8_t* code_hash) {
+int try_load_code(bool if_load_code, uint8_t *code_hash) {
     uint8_t buf[BUFFER_SIZE] __attribute__((aligned(RISCV_PGSIZE)));
-    sprintf(message, "%c X in [%p, %p)", bool2char(if_load_code), buf, buf+BUFFER_SIZE); ckb_debug(message);
+    sprintf(message, "%c X in [%p, %p)", bool2char(if_load_code), buf, buf + BUFFER_SIZE);
+    ckb_debug(message);
     if (if_load_code) {
         void *handle = NULL;
         uint64_t consumed_size = 0;
@@ -43,16 +42,16 @@ int try_load_code(bool if_load_code, uint8_t* code_hash) {
 
 volatile void try_write_stack(bool if_write_stack, int size) {
     volatile uint8_t buf[size] __attribute__((aligned(RISCV_PGSIZE)));
-    sprintf(message, "%c W in [%p, %p)", bool2char(if_write_stack), buf, buf+size); ckb_debug(message);
+    sprintf(message, "%c W in [%p, %p)", bool2char(if_write_stack), buf, buf + size);
+    ckb_debug(message);
     if (if_write_stack) {
-        for (int i=0; i<size; i++) {
-            *(buf+i-1) = i;
+        for (int i = 0; i < size; i++) {
+            *(buf + i - 1) = i;
         }
     }
 }
 
-
-int main (int argc, char *argv[]) {
+int main(int argc, char *argv[]) {
     int ret;
     uint64_t len = SCRIPT_SIZE;
     uint8_t script[SCRIPT_SIZE];
@@ -81,16 +80,19 @@ int main (int argc, char *argv[]) {
     }
 
     uint8_t flag = bytes_seg.ptr[0];
-    volatile uint64_t size = read_u64_le(bytes_seg.ptr+1);
-    sprintf(message, "flag = %x, size = %ld", flag, size); ckb_debug(message);
+    volatile uint64_t size = read_u64_le(bytes_seg.ptr + 1);
+    sprintf(message, "flag = %x, size = %ld", flag, size);
+    ckb_debug(message);
 
-    bool if_init_stack  = (flag & 0b0001) == 0b0001;
-    bool if_load_code   = (flag & 0b0010) == 0b0010;
+    bool if_init_stack = (flag & 0b0001) == 0b0001;
+    bool if_load_code = (flag & 0b0010) == 0b0010;
     bool if_write_stack = (flag & 0b0100) == 0b0100;
 
     if (if_init_stack) {
-        ret = try_load_code(if_load_code, bytes_seg.ptr+9);
-        if (ret != 0) { return ret; }
+        ret = try_load_code(if_load_code, bytes_seg.ptr + 9);
+        if (ret != 0) {
+            return ret;
+        }
     }
     try_write_stack(if_write_stack, size);
     return CKB_SUCCESS;
diff --git a/script/testdata/load_is_even_into_global b/script/testdata/load_is_even_into_global
index 9fba1493f2..f90ad3b9ae 100755
Binary files a/script/testdata/load_is_even_into_global and b/script/testdata/load_is_even_into_global differ
diff --git a/script/testdata/load_is_even_into_global.c b/script/testdata/load_is_even_into_global.c
index 7dbab0cac6..4ee73a71da 100644
--- a/script/testdata/load_is_even_into_global.c
+++ b/script/testdata/load_is_even_into_global.c
@@ -7,9 +7,10 @@
  *    - `number` is not even.
  */
 
+#include <stdlib.h>
+#include "blockchain.h"
 #include "ckb_dlfcn.h"
 #include "ckb_syscalls.h"
-#include "blockchain.h"
 
 #ifdef DEBUG
 #include <stdio.h>
@@ -19,15 +20,13 @@
 #endif
 
 #define SCRIPT_SIZE 32768
-#define CODE_BUFFER_SIZE  (100 * 1024)
+#define CODE_BUFFER_SIZE (100 * 1024)
 
 uint8_t CODE_BUFFER[CODE_BUFFER_SIZE] __attribute__((aligned(RISCV_PGSIZE)));
 
-uint64_t read_u64_le (const uint8_t *src) {
-    return *(const uint64_t *)src;
-}
+uint64_t read_u64_le(const uint8_t *src) { return *(const uint64_t *)src; }
 
-int main (int argc, char *argv[]) {
+int main(int argc, char *argv[]) {
     int ret;
     uint64_t len = SCRIPT_SIZE;
     uint8_t script[SCRIPT_SIZE];
@@ -59,7 +58,8 @@ int main (int argc, char *argv[]) {
     }
 
     volatile uint64_t number = read_u64_le(bytes_seg.ptr);
-    sprintf(message, "number = %ld", number); ckb_debug(message);
+    sprintf(message, "number = %ld", number);
+    ckb_debug(message);
 
     if (number == 0) {
         return CKB_SUCCESS;
@@ -71,7 +71,7 @@ int main (int argc, char *argv[]) {
         uint64_t consumed_size = 0;
 
         uint8_t hash_type = 0;
-        ret = ckb_dlopen2(bytes_seg.ptr+8, hash_type, CODE_BUFFER, CODE_BUFFER_SIZE, &handle, &consumed_size);
+        ret = ckb_dlopen2(bytes_seg.ptr + 8, hash_type, CODE_BUFFER, CODE_BUFFER_SIZE, &handle, &consumed_size);
         if (ret != CKB_SUCCESS) {
             return ret;
         }
@@ -83,7 +83,8 @@ int main (int argc, char *argv[]) {
         is_even = func(number);
     }
 
-    sprintf(message, "is_even(%ld) = %d", number, is_even); ckb_debug(message);
+    sprintf(message, "is_even(%ld) = %d", number, is_even);
+    ckb_debug(message);
 
     if (is_even) {
         return -8;
diff --git a/script/testdata/load_is_even_with_snapshot b/script/testdata/load_is_even_with_snapshot
index 16d2b05393..340259290e 100755
Binary files a/script/testdata/load_is_even_with_snapshot and b/script/testdata/load_is_even_with_snapshot differ
diff --git a/script/testdata/load_is_even_with_snapshot.c b/script/testdata/load_is_even_with_snapshot.c
index 7004277e63..4b305c7882 100644
--- a/script/testdata/load_is_even_with_snapshot.c
+++ b/script/testdata/load_is_even_with_snapshot.c
@@ -6,10 +6,10 @@
  *    - `number` is zero.
  *    - `number` is not even.
  */
-
+#include <stdlib.h>
+#include "blockchain.h"
 #include "ckb_dlfcn.h"
 #include "ckb_syscalls.h"
-#include "blockchain.h"
 
 #ifdef DEBUG
 #include <stdio.h>
@@ -20,15 +20,11 @@
 
 #define SCRIPT_SIZE 32768
 
-void try_pause() {
-    syscall(2178, 0, 0, 0, 0, 0, 0);
-}
+void try_pause() { syscall(2178, 0, 0, 0, 0, 0, 0); }
 
-uint64_t read_u64_le (const uint8_t *src) {
-    return *(const uint64_t *)src;
-}
+uint64_t read_u64_le(const uint8_t *src) { return *(const uint64_t *)src; }
 
-int main (int argc, char *argv[]) {
+int main(int argc, char *argv[]) {
     int ret;
     uint64_t len = SCRIPT_SIZE;
     uint8_t script[SCRIPT_SIZE];
@@ -60,7 +56,8 @@ int main (int argc, char *argv[]) {
     }
 
     volatile uint64_t number = read_u64_le(bytes_seg.ptr);
-    sprintf(message, "number = %ld", number); ckb_debug(message);
+    sprintf(message, "number = %ld", number);
+    ckb_debug(message);
 
     if (number == 0) {
         return CKB_SUCCESS;
@@ -74,7 +71,7 @@ int main (int argc, char *argv[]) {
         uint64_t code_buffer_size = 100 * 1024;
         uint8_t code_buffer[code_buffer_size] __attribute__((aligned(RISCV_PGSIZE)));
         uint8_t hash_type = 0;
-        ret = ckb_dlopen2(bytes_seg.ptr+8, hash_type, code_buffer, code_buffer_size, &handle, &consumed_size);
+        ret = ckb_dlopen2(bytes_seg.ptr + 8, hash_type, code_buffer, code_buffer_size, &handle, &consumed_size);
         if (ret != CKB_SUCCESS) {
             return ret;
         }
@@ -87,7 +84,8 @@ int main (int argc, char *argv[]) {
         is_even = func(number);
     }
 
-    sprintf(message, "is_even(%ld) = %d", number, is_even); ckb_debug(message);
+    sprintf(message, "is_even(%ld) = %d", number, is_even);
+    ckb_debug(message);
 
     if (is_even) {
         return -8;
diff --git a/script/testdata/mop_adc_lock b/script/testdata/mop_adc_lock
index d24fad349c..6593665e13 100755
Binary files a/script/testdata/mop_adc_lock and b/script/testdata/mop_adc_lock differ
diff --git a/script/testdata/mul2.c b/script/testdata/mul2.c
index 4163351fc6..99c6533122 100644
--- a/script/testdata/mul2.c
+++ b/script/testdata/mul2.c
@@ -1,5 +1,3 @@
 #include <stdint.h>
 
-__attribute__((visibility("default"))) uint64_t apply (uint64_t num) {
-    return num * 2;
-}
+__attribute__((visibility("default"))) uint64_t apply(uint64_t num) { return num * 2; }
diff --git a/script/testdata/mul2.lib b/script/testdata/mul2.lib
index 4ce9d55c69..889d6cf06d 100755
Binary files a/script/testdata/mul2.lib and b/script/testdata/mul2.lib differ
diff --git a/script/testdata/set_content b/script/testdata/set_content
deleted file mode 100755
index 63b8d7ef3e..0000000000
Binary files a/script/testdata/set_content and /dev/null differ
diff --git a/script/testdata/set_content.c b/script/testdata/set_content.c
deleted file mode 100644
index b6b80a211b..0000000000
--- a/script/testdata/set_content.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "ckb_syscalls.h"
-
-int main() {
-  uint64_t length = 5;
-  if (ckb_set_content((uint8_t *)"hello", &length) != 0) {
-    return 1;
-  }
-  if (length != 0) {
-    return 1;
-  }
-  return 0;
-}
diff --git a/script/testdata/spawn_big_content_length b/script/testdata/spawn_big_content_length
deleted file mode 100755
index 0b63b00c4d..0000000000
Binary files a/script/testdata/spawn_big_content_length and /dev/null differ
diff --git a/script/testdata/spawn_big_content_length.c b/script/testdata/spawn_big_content_length.c
deleted file mode 100644
index 2620b5e15c..0000000000
--- a/script/testdata/spawn_big_content_length.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdint.h>
-#include <string.h>
-
-#include "ckb_syscalls.h"
-
-int main() {
-  uint64_t spawn_content_length = 0xffffffff;
-  spawn_args_t spgs = {
-      .memory_limit = 8,
-      .exit_code = NULL,
-      .content = NULL,
-      .content_length = &spawn_content_length,
-  };
-  int success = ckb_spawn(1, 3, 0, 0, NULL, &spgs);
-  if (success != 5) {
-    return 1;
-  }
-  return 0;
-}
diff --git a/script/testdata/spawn_big_memory_size b/script/testdata/spawn_big_memory_size
deleted file mode 100755
index 7c0b7f8ebf..0000000000
Binary files a/script/testdata/spawn_big_memory_size and /dev/null differ
diff --git a/script/testdata/spawn_big_memory_size.c b/script/testdata/spawn_big_memory_size.c
deleted file mode 100644
index d1b9b0e33c..0000000000
--- a/script/testdata/spawn_big_memory_size.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <stdint.h>
-#include <string.h>
-
-#include "ckb_syscalls.h"
-
-int main() {
-  spawn_args_t spgs = {
-      .memory_limit = 9,
-      .exit_code = NULL,
-      .content = NULL,
-      .content_length = NULL,
-  };
-  int success = ckb_spawn(1, 3, 0, 0, NULL, &spgs);
-  if (success != 6) {
-    return 1;
-  }
-  return 0;
-}
diff --git a/script/testdata/spawn_callee_current_cycles b/script/testdata/spawn_callee_current_cycles
index 1c2dd40aa0..a49bc961bb 100755
Binary files a/script/testdata/spawn_callee_current_cycles and b/script/testdata/spawn_callee_current_cycles differ
diff --git a/script/testdata/spawn_callee_current_cycles.c b/script/testdata/spawn_callee_current_cycles.c
index c2005c9da4..1e7e7f11d4 100644
--- a/script/testdata/spawn_callee_current_cycles.c
+++ b/script/testdata/spawn_callee_current_cycles.c
@@ -1,15 +1,28 @@
 #include <stdint.h>
-#include <stdlib.h>
+#include <stdio.h>
 #include <string.h>
 
 #include "ckb_syscalls.h"
 
-int main(int argc, char *argv[]) {
-  int caller_cycles = atoi(argv[0]);
-  // Callee's current cycles must > caller's current cycles.
-  int callee_cycles = ckb_current_cycles();
-  if (callee_cycles < caller_cycles + 100000) {
-    return 1;
-  }
-  return 0;
+int atoi(const char *s) {
+    int n = 0, neg = 0;
+    switch (*s) {
+        case '-':
+            neg = 1;
+        case '+':
+            s++;
+    }
+    /* Compute n as a negative number to avoid overflow on INT_MIN */
+    while (_is_digit(*s)) n = 10 * n - (*s++ - '0');
+    return neg ? n : -n;
+}
+
+int main(int argc, const char *argv[]) {
+    int caller_cycles = atoi(argv[0]);
+    // Callee's current cycles must > caller's current cycles.
+    int callee_cycles = ckb_current_cycles();
+    if (callee_cycles < caller_cycles + 100000) {
+        return 1;
+    }
+    return 0;
 }
diff --git a/script/testdata/spawn_callee_exec_callee b/script/testdata/spawn_callee_exec_callee
index 1686432359..e7e344be7a 100755
Binary files a/script/testdata/spawn_callee_exec_callee and b/script/testdata/spawn_callee_exec_callee differ
diff --git a/script/testdata/spawn_callee_exec_callee.c b/script/testdata/spawn_callee_exec_callee.c
index 76e8197013..a53d0f5123 100644
--- a/script/testdata/spawn_callee_exec_callee.c
+++ b/script/testdata/spawn_callee_exec_callee.c
@@ -1 +1,3 @@
+#include <stdlib.h>
+
 int main() { return 0; }
diff --git a/script/testdata/spawn_callee_exec_caller b/script/testdata/spawn_callee_exec_caller
index 0a3f6b6016..671dd0acd2 100755
Binary files a/script/testdata/spawn_callee_exec_caller and b/script/testdata/spawn_callee_exec_caller differ
diff --git a/script/testdata/spawn_callee_exec_caller.c b/script/testdata/spawn_callee_exec_caller.c
index 22723c1f0d..289a95b699 100644
--- a/script/testdata/spawn_callee_exec_caller.c
+++ b/script/testdata/spawn_callee_exec_caller.c
@@ -1,6 +1,8 @@
+#include <stdlib.h>
 #include "ckb_syscalls.h"
 
 int main() {
-  syscall(2043, 2, 3, 0, 0, 0, NULL);
-  return -1;
+    // syscall exec
+    syscall(2043, 2, 3, 0, 0, 0, NULL);
+    return -1;
 }
diff --git a/script/testdata/spawn_callee_get_memory_limit b/script/testdata/spawn_callee_get_memory_limit
deleted file mode 100755
index 94b6c711f7..0000000000
Binary files a/script/testdata/spawn_callee_get_memory_limit and /dev/null differ
diff --git a/script/testdata/spawn_callee_get_memory_limit.c b/script/testdata/spawn_callee_get_memory_limit.c
deleted file mode 100644
index 574544f877..0000000000
--- a/script/testdata/spawn_callee_get_memory_limit.c
+++ /dev/null
@@ -1,3 +0,0 @@
-#include "ckb_syscalls.h"
-
-int main() { return ckb_get_memory_limit(); }
diff --git a/script/testdata/spawn_callee_out_of_cycles b/script/testdata/spawn_callee_out_of_cycles
index c0819018bb..3b2f6684d2 100755
Binary files a/script/testdata/spawn_callee_out_of_cycles and b/script/testdata/spawn_callee_out_of_cycles differ
diff --git a/script/testdata/spawn_callee_out_of_cycles.c b/script/testdata/spawn_callee_out_of_cycles.c
index dbaa71d22a..caad7a35f3 100644
--- a/script/testdata/spawn_callee_out_of_cycles.c
+++ b/script/testdata/spawn_callee_out_of_cycles.c
@@ -1,8 +1,10 @@
+#include <stdlib.h>
+
 int fib(int n) {
-  if (n < 2) {
-    return n;
-  }
-  return fib(n - 1) + fib(n - 2);
+    if (n < 2) {
+        return n;
+    }
+    return fib(n - 1) + fib(n - 2);
 }
 
 int main() { return fib(100); }
diff --git a/script/testdata/spawn_callee_set_content b/script/testdata/spawn_callee_set_content
deleted file mode 100755
index b66210df7b..0000000000
Binary files a/script/testdata/spawn_callee_set_content and /dev/null differ
diff --git a/script/testdata/spawn_callee_set_content.c b/script/testdata/spawn_callee_set_content.c
deleted file mode 100644
index ed376ba5ce..0000000000
--- a/script/testdata/spawn_callee_set_content.c
+++ /dev/null
@@ -1,18 +0,0 @@
-#include <stdint.h>
-#include <stdlib.h>
-
-#include "ckb_syscalls.h"
-
-int main(int argc, char *argv[]) {
-  uint64_t size = (uint64_t)atoi(argv[0]);
-  uint64_t real = (uint64_t)atoi(argv[1]);
-  uint8_t data[20] = {};
-  int success = ckb_set_content(&data[0], &size);
-  if (success != 0) {
-    return 1;
-  }
-  if (size != real) {
-    return 1;
-  }
-  return 0;
-}
diff --git a/script/testdata/spawn_callee_strcat b/script/testdata/spawn_callee_strcat
index ecc962b30c..8f5d76ed3b 100755
Binary files a/script/testdata/spawn_callee_strcat and b/script/testdata/spawn_callee_strcat differ
diff --git a/script/testdata/spawn_callee_strcat.c b/script/testdata/spawn_callee_strcat.c
index f2f3f56e6c..56daa801d8 100644
--- a/script/testdata/spawn_callee_strcat.c
+++ b/script/testdata/spawn_callee_strcat.c
@@ -2,16 +2,31 @@
 #include <string.h>
 
 #include "ckb_syscalls.h"
+#include "spawn_utils.h"
+
+char *strcat(char *restrict dest, const char *restrict src) {
+    strcpy(dest + strlen(dest), src);
+    return dest;
+}
 
 int main(int argc, char *argv[]) {
-  char content[80];
-  for (int i = 0; i < argc; i++) {
-    strcat(content, argv[i]);
-  }
-  uint64_t content_size = (uint64_t)strlen(content);
-  ckb_set_content((uint8_t *)&content[0], &content_size);
-  if (content_size != (uint64_t)strlen(content)) {
-    return 1;
-  }
-  return 0;
+    int err = 0;
+    char content[80];
+    for (int i = 0; i < argc; i++) {
+        strcat(content, argv[i]);
+    }
+    size_t content_size = (uint64_t)strlen(content);
+    uint64_t fds[2] = {0};
+    uint64_t length = countof(fds);
+    err = ckb_inherited_file_descriptors(fds, &length);
+    CHECK(err);
+    CHECK2(length == 2, ErrorCommon);
+    size_t content_size2 = content_size;
+    printf("fds[CKB_STDOUT] = %d", fds[CKB_STDOUT]);
+    err = ckb_write(fds[CKB_STDOUT], content, &content_size);
+    CHECK(err);
+    CHECK2(content_size2 == content_size, ErrorWrite);
+
+exit:
+    return err;
 }
diff --git a/script/testdata/spawn_caller_current_cycles b/script/testdata/spawn_caller_current_cycles
index efa2fcec4d..d4d464dd27 100755
Binary files a/script/testdata/spawn_caller_current_cycles and b/script/testdata/spawn_caller_current_cycles differ
diff --git a/script/testdata/spawn_caller_current_cycles.c b/script/testdata/spawn_caller_current_cycles.c
index f508cd3966..8712b2a1d2 100644
--- a/script/testdata/spawn_caller_current_cycles.c
+++ b/script/testdata/spawn_caller_current_cycles.c
@@ -1,41 +1,26 @@
 #include <stdint.h>
-#include <stdlib.h>
+#include <stdio.h>
 #include <string.h>
 
 #include "ckb_syscalls.h"
+#include "spawn_utils.h"
 
 int fib(int n) {
-  if (n < 2) {
-    return n;
-  }
-  return fib(n - 1) + fib(n - 2);
+    if (n < 2) {
+        return n;
+    }
+    return fib(n - 1) + fib(n - 2);
 }
 
 int main() {
-  // Use invalid calculations to make the current cycles a larger value.
-  if (fib(20) != 6765) {
-    return 1;
-  }
+    // Use invalid calculations to make the current cycles a larger value.
+    if (fib(20) != 6765) {
+        return 1;
+    }
 
-  int cycles = ckb_current_cycles();
-  char buffer[8];
-  itoa(cycles, buffer, 10);
-  const char *argv[] = { &buffer[0] };
-  int8_t spawn_exit_code = 255;
-  uint8_t spawn_content[80] = {};
-  uint64_t spawn_content_length = 80;
-  spawn_args_t spgs = {
-      .memory_limit = 8,
-      .exit_code = &spawn_exit_code,
-      .content = &spawn_content[0],
-      .content_length = &spawn_content_length,
-  };
-  int success = ckb_spawn(1, 3, 0, 1, argv, &spgs);
-  if (success != 0) {
-    return 1;
-  }
-  if (spawn_exit_code != 0) {
-    return 1;
-  }
-  return 0;
+    int cycles = ckb_current_cycles();
+    char buffer[16] = {0};
+    sprintf_(buffer, "%d", cycles);
+    const char *argv[] = {&buffer[0], 0};
+    return simple_spawn_args(1, 1, argv);
 }
diff --git a/script/testdata/spawn_caller_exec b/script/testdata/spawn_caller_exec
index 429e98b60b..c2496f1f4f 100755
Binary files a/script/testdata/spawn_caller_exec and b/script/testdata/spawn_caller_exec differ
diff --git a/script/testdata/spawn_caller_exec.c b/script/testdata/spawn_caller_exec.c
index 614342713f..7fc5caa6e9 100644
--- a/script/testdata/spawn_caller_exec.c
+++ b/script/testdata/spawn_caller_exec.c
@@ -1,14 +1,5 @@
-#include <stdint.h>
-#include <string.h>
+#include <stdlib.h>
 
-#include "ckb_syscalls.h"
+#include "spawn_utils.h"
 
-int main() {
-  spawn_args_t spgs = {
-      .memory_limit = 8,
-      .exit_code = NULL,
-      .content = NULL,
-      .content_length = NULL,
-  };
-  return ckb_spawn(1, 3, 0, 0, NULL, &spgs);
-}
+int main() { return simple_spawn(1); }
diff --git a/script/testdata/spawn_caller_get_memory_limit b/script/testdata/spawn_caller_get_memory_limit
deleted file mode 100755
index 5b600a24e6..0000000000
Binary files a/script/testdata/spawn_caller_get_memory_limit and /dev/null differ
diff --git a/script/testdata/spawn_caller_get_memory_limit.c b/script/testdata/spawn_caller_get_memory_limit.c
deleted file mode 100644
index 6b6ea48662..0000000000
--- a/script/testdata/spawn_caller_get_memory_limit.c
+++ /dev/null
@@ -1,46 +0,0 @@
-#include <stdint.h>
-#include <string.h>
-
-#include "ckb_syscalls.h"
-
-int main() {
-  int8_t spawn_exit_code;
-  uint8_t spawn_content[80] = {};
-  uint64_t spawn_content_length = 80;
-  spawn_args_t spgs = {
-      .memory_limit = 0,
-      .exit_code = &spawn_exit_code,
-      .content = &spawn_content[0],
-      .content_length = &spawn_content_length,
-  };
-  uint64_t success = 0;
-
-  spgs.memory_limit = 3;
-  success = ckb_spawn(1, 3, 0, 0, NULL, &spgs);
-  if (success != 0) {
-    return 1;
-  }
-  if (spawn_exit_code != 3) {
-    return 1;
-  }
-
-  spgs.memory_limit = 7;
-  success = ckb_spawn(1, 3, 0, 0, NULL, &spgs);
-  if (success != 0) {
-    return 1;
-  }
-  if (spawn_exit_code != 7) {
-    return 1;
-  }
-
-  spgs.memory_limit = 8;
-  success = ckb_spawn(1, 3, 0, 0, NULL, &spgs);
-  if (success != 0) {
-    return 1;
-  }
-  if (spawn_exit_code != 8) {
-    return 1;
-  }
-
-  return 0;
-}
diff --git a/script/testdata/spawn_caller_out_of_cycles b/script/testdata/spawn_caller_out_of_cycles
index d4ac5f515c..158c256802 100755
Binary files a/script/testdata/spawn_caller_out_of_cycles and b/script/testdata/spawn_caller_out_of_cycles differ
diff --git a/script/testdata/spawn_caller_out_of_cycles.c b/script/testdata/spawn_caller_out_of_cycles.c
index 3818a84001..ee5e94f414 100644
--- a/script/testdata/spawn_caller_out_of_cycles.c
+++ b/script/testdata/spawn_caller_out_of_cycles.c
@@ -1,18 +1,3 @@
-#include <stdint.h>
-#include <string.h>
+#include "spawn_utils.h"
 
-#include "ckb_syscalls.h"
-
-int main() {
-  spawn_args_t spgs = {
-      .memory_limit = 8,
-      .exit_code = NULL,
-      .content = NULL,
-      .content_length = NULL,
-  };
-  uint64_t success = ckb_spawn(1, 3, 0, 0, NULL, &spgs);
-  if (success == 0) {
-    return 1;
-  }
-  return 0;
-}
+int main() { return simple_spawn(1); }
diff --git a/script/testdata/spawn_caller_out_of_cycles_wrap b/script/testdata/spawn_caller_out_of_cycles_wrap
index 1c3a8da922..3a1090c90c 100755
Binary files a/script/testdata/spawn_caller_out_of_cycles_wrap and b/script/testdata/spawn_caller_out_of_cycles_wrap differ
diff --git a/script/testdata/spawn_caller_out_of_cycles_wrap.c b/script/testdata/spawn_caller_out_of_cycles_wrap.c
index bbb717e58c..b823b50fd6 100644
--- a/script/testdata/spawn_caller_out_of_cycles_wrap.c
+++ b/script/testdata/spawn_caller_out_of_cycles_wrap.c
@@ -1,19 +1,3 @@
-#include <stdint.h>
-#include <string.h>
+#include "spawn_utils.h"
 
-#include "ckb_syscalls.h"
-
-int main() {
-  int8_t spawn_exit_code = 255;
-  spawn_args_t spgs = {
-      .memory_limit = 8,
-      .exit_code = &spawn_exit_code,
-      .content = NULL,
-      .content_length = NULL,
-  };
-  uint64_t success = ckb_spawn(2, 3, 0, 0, NULL, &spgs);
-  if (success != 0) {
-    return 1;
-  }
-  return spawn_exit_code;
-}
+int main() { return simple_spawn(2); }
diff --git a/script/testdata/spawn_caller_set_content b/script/testdata/spawn_caller_set_content
deleted file mode 100755
index f610c38817..0000000000
Binary files a/script/testdata/spawn_caller_set_content and /dev/null differ
diff --git a/script/testdata/spawn_caller_set_content.c b/script/testdata/spawn_caller_set_content.c
deleted file mode 100644
index 026ef1bcfa..0000000000
--- a/script/testdata/spawn_caller_set_content.c
+++ /dev/null
@@ -1,95 +0,0 @@
-#include <stdint.h>
-#include <string.h>
-
-#include "ckb_syscalls.h"
-
-int main_lt_content_length() {
-  int8_t spawn_exit_code = -1;
-  uint8_t spawn_content[10] = {};
-  uint64_t spawn_content_length = 10;
-  spawn_args_t spgs = {
-      .memory_limit = 8,
-      .exit_code = &spawn_exit_code,
-      .content = &spawn_content[0],
-      .content_length = &spawn_content_length,
-  };
-  const char *argv[] = {"8", "8"};
-  uint64_t success = 0;
-
-  success = ckb_spawn(1, 3, 0, 2, argv, &spgs);
-  if (success != 0) {
-    return 1;
-  }
-  if (spawn_exit_code != 0) {
-    return 1;
-  }
-  if (spawn_content_length != 8) {
-    return 1;
-  }
-  return 0;
-}
-
-int main_eq_content_length() {
-  int8_t spawn_exit_code = -1;
-  uint8_t spawn_content[10] = {};
-  uint64_t spawn_content_length = 10;
-  spawn_args_t spgs = {
-      .memory_limit = 8,
-      .exit_code = &spawn_exit_code,
-      .content = &spawn_content[0],
-      .content_length = &spawn_content_length,
-  };
-  const char *argv[] = {"10", "10"};
-  uint64_t success = 0;
-
-  success = ckb_spawn(1, 3, 0, 2, argv, &spgs);
-  if (success != 0) {
-    return 1;
-  }
-  if (spawn_exit_code != 0) {
-    return 1;
-  }
-  if (spawn_content_length != 10) {
-    return 1;
-  }
-  return 0;
-}
-
-int main_gt_content_length() {
-  int8_t spawn_exit_code = -1;
-  uint8_t spawn_content[10] = {};
-  uint64_t spawn_content_length = 10;
-  spawn_args_t spgs = {
-      .memory_limit = 8,
-      .exit_code = &spawn_exit_code,
-      .content = &spawn_content[0],
-      .content_length = &spawn_content_length,
-  };
-  const char *argv[] = {"12", "10"};
-  uint64_t success = 0;
-
-  success = ckb_spawn(1, 3, 0, 2, argv, &spgs);
-  if (success != 0) {
-    return 1;
-  }
-  if (spawn_exit_code != 0) {
-    return 1;
-  }
-  if (spawn_content_length != 10) {
-    return 1;
-  }
-  return 0;
-}
-
-int main() {
-  if (main_lt_content_length() != 0) {
-    return 1;
-  }
-  if (main_eq_content_length() != 0) {
-    return 1;
-  }
-  if (main_gt_content_length() != 0) {
-    return 1;
-  }
-  return 0;
-}
diff --git a/script/testdata/spawn_caller_strcat b/script/testdata/spawn_caller_strcat
index 1e1ed6edb3..f56aafa13f 100755
Binary files a/script/testdata/spawn_caller_strcat and b/script/testdata/spawn_caller_strcat differ
diff --git a/script/testdata/spawn_caller_strcat.c b/script/testdata/spawn_caller_strcat.c
index 466547502d..98eed197f0 100644
--- a/script/testdata/spawn_caller_strcat.c
+++ b/script/testdata/spawn_caller_strcat.c
@@ -2,30 +2,32 @@
 #include <string.h>
 
 #include "ckb_syscalls.h"
+#include "spawn_utils.h"
 
 int main() {
-  const char *argv[] = {"hello", "world"};
-  int8_t spawn_exit_code = 255;
-  uint8_t spawn_content[80] = {};
-  uint64_t spawn_content_length = 80;
-  spawn_args_t spgs = {
-      .memory_limit = 8,
-      .exit_code = &spawn_exit_code,
-      .content = &spawn_content[0],
-      .content_length = &spawn_content_length,
-  };
-  int success = ckb_spawn(1, 3, 0, 2, argv, &spgs);
-  if (success != 0) {
-    return 1;
-  }
-  if (spawn_exit_code != 0) {
-    return 1;
-  }
-  if (strlen((char *)spawn_content) != 10) {
-    return 1;
-  }
-  if (strcmp((char *)spawn_content, "helloworld") != 0) {
-    return 1;
-  }
-  return 0;
+    int err = 0;
+    const char *argv[] = {"hello", "world"};
+    uint64_t pid = 0;
+    uint64_t fds[2] = {0};
+    uint64_t inherited_fds[3] = {0};
+    err = create_std_fds(fds, inherited_fds);
+    CHECK(err);
+
+    spawn_args_t spgs = {
+        .argc = 2,
+        .argv = argv,
+        .process_id = &pid,
+        .inherited_fds = inherited_fds,
+    };
+    err = ckb_spawn(1, CKB_SOURCE_CELL_DEP, 0, 0, &spgs);
+    CHECK(err);
+    uint8_t buffer[1024] = {0};
+    size_t length = 1024;
+    err = ckb_read(fds[CKB_STDIN], buffer, &length);
+    CHECK(err);
+    err = memcmp("helloworld", buffer, length);
+    CHECK(err);
+
+exit:
+    return err;
 }
diff --git a/script/testdata/spawn_caller_strcat_data_hash b/script/testdata/spawn_caller_strcat_data_hash
deleted file mode 100755
index 9d32803cd0..0000000000
Binary files a/script/testdata/spawn_caller_strcat_data_hash and /dev/null differ
diff --git a/script/testdata/spawn_caller_strcat_data_hash.c b/script/testdata/spawn_caller_strcat_data_hash.c
deleted file mode 100644
index f21987dffc..0000000000
--- a/script/testdata/spawn_caller_strcat_data_hash.c
+++ /dev/null
@@ -1,39 +0,0 @@
-#include <stdbool.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "ckb_exec.h"
-#include "ckb_syscalls.h"
-
-int main() {
-  const char *argv[] = {"hello", "world"};
-
-  int8_t spawn_exit_code = -1;
-  uint8_t spawn_content[80] = {};
-  uint64_t spawn_content_length = 80;
-  spawn_args_t spgs = {
-      .memory_limit = 8,
-      .exit_code = &spawn_exit_code,
-      .content = &spawn_content[0],
-      .content_length = &spawn_content_length,
-  };
-  uint8_t hash[32] = {};
-  uint32_t hash_len = 0;
-  _exec_hex2bin(
-      "1dc91c6a0d93ffba6d11bae8bc74d4cb89506e58203e7361434e77f24eb7b11f", hash,
-      32, &hash_len);
-  int success = ckb_spawn_cell(hash, 0, 0, 0, 2, argv, &spgs);
-  if (success != 0) {
-    return 1;
-  }
-  if (spawn_exit_code != 0) {
-    return 1;
-  }
-  if (strlen((char *)spawn_content) != 10) {
-    return 1;
-  }
-  if (strcmp((char *)spawn_content, "helloworld") != 0) {
-    return 1;
-  }
-  return 0;
-}
diff --git a/script/testdata/spawn_caller_strcat_wrap b/script/testdata/spawn_caller_strcat_wrap
index 1c3a8da922..10aa1fa266 100755
Binary files a/script/testdata/spawn_caller_strcat_wrap and b/script/testdata/spawn_caller_strcat_wrap differ
diff --git a/script/testdata/spawn_caller_strcat_wrap.c b/script/testdata/spawn_caller_strcat_wrap.c
index bbb717e58c..25604f856f 100644
--- a/script/testdata/spawn_caller_strcat_wrap.c
+++ b/script/testdata/spawn_caller_strcat_wrap.c
@@ -1,19 +1,7 @@
+#include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
 
-#include "ckb_syscalls.h"
+#include "spawn_utils.h"
 
-int main() {
-  int8_t spawn_exit_code = 255;
-  spawn_args_t spgs = {
-      .memory_limit = 8,
-      .exit_code = &spawn_exit_code,
-      .content = NULL,
-      .content_length = NULL,
-  };
-  uint64_t success = ckb_spawn(2, 3, 0, 0, NULL, &spgs);
-  if (success != 0) {
-    return 1;
-  }
-  return spawn_exit_code;
-}
+int main() { return simple_spawn(2); }
diff --git a/script/testdata/spawn_cases b/script/testdata/spawn_cases
new file mode 100755
index 0000000000..2742af8b3e
Binary files /dev/null and b/script/testdata/spawn_cases differ
diff --git a/script/testdata/spawn_cases.c b/script/testdata/spawn_cases.c
new file mode 100644
index 0000000000..1729bf0bea
--- /dev/null
+++ b/script/testdata/spawn_cases.c
@@ -0,0 +1,644 @@
+#include "spawn_utils.h"
+
+int parent_simple_read_write(uint64_t* pid) {
+    int err = 0;
+    const char* argv[] = {"", 0};
+    uint64_t fds[2] = {0};
+
+    err = full_spawn(0, 1, argv, fds, pid);
+    // write
+    uint8_t block[11] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+    for (size_t i = 0; i < 7; i++) {
+        size_t actual_length = 0;
+        err = write_exact(fds[CKB_STDOUT], block, sizeof(block), &actual_length);
+        CHECK(err);
+        CHECK2(actual_length == sizeof(block), -2);
+    }
+    // read
+    for (size_t i = 0; i < 7; i++) {
+        uint8_t block[11] = {0};
+        size_t actual_length = 0;
+        err = read_exact(fds[CKB_STDIN], block, sizeof(block), &actual_length);
+        CHECK(err);
+        CHECK2(actual_length == sizeof(block), -2);
+        for (size_t j = 0; j < sizeof(block); j++) {
+            CHECK2(block[j] == 0xFF, -2);
+        }
+    }
+exit:
+    return err;
+}
+
+int child_simple_read_write() {
+    int err = 0;
+    uint64_t inherited_fds[2];
+    size_t inherited_fds_length = 2;
+    err = ckb_inherited_file_descriptors(inherited_fds, &inherited_fds_length);
+    // read
+    for (size_t i = 0; i < 11; i++) {
+        uint8_t block[7] = {0};
+        size_t actual_length = 0;
+        err = read_exact(inherited_fds[CKB_STDIN], block, sizeof(block), &actual_length);
+        CHECK(err);
+        CHECK2(actual_length == sizeof(block), -2);
+        for (size_t j = 0; j < sizeof(block); j++) {
+            CHECK2(block[j] == 0xFF, -3);
+        }
+    }
+    // write
+    uint8_t block[11] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+    for (size_t i = 0; i < 7; i++) {
+        size_t actual_length = 0;
+        err = write_exact(inherited_fds[CKB_STDOUT], block, sizeof(block), &actual_length);
+        CHECK(err);
+        CHECK2(actual_length == sizeof(block), -2);
+    }
+exit:
+    return err;
+}
+
+int parent_write_dead_lock(uint64_t* pid) {
+    int err = 0;
+    const char* argv[] = {"", 0};
+    uint64_t fds[2] = {0};
+    err = full_spawn(0, 1, argv, fds, pid);
+    CHECK(err);
+    uint8_t data[10];
+    size_t data_length = sizeof(data);
+    err = ckb_write(fds[CKB_STDOUT], data, &data_length);
+    CHECK(err);
+
+exit:
+    return err;
+}
+
+int child_write_dead_lock() {
+    int err = 0;
+    uint64_t inherited_fds[3] = {0};
+    size_t inherited_fds_length = 3;
+    err = ckb_inherited_file_descriptors(inherited_fds, &inherited_fds_length);
+    CHECK(err);
+    uint8_t data[10];
+    size_t data_length = sizeof(data);
+    err = ckb_write(inherited_fds[CKB_STDOUT], data, &data_length);
+    CHECK(err);
+exit:
+    return err;
+}
+
+int parent_invalid_fd(uint64_t* pid) {
+    uint64_t invalid_fd = 0xff;
+    uint8_t data[4];
+    size_t data_length = sizeof(data);
+    int err = ckb_read(invalid_fd, data, &data_length);
+    CHECK2(err != 0, -2);
+    err = ckb_write(invalid_fd, data, &data_length);
+    CHECK2(err != 0, -2);
+
+    uint64_t fds[2] = {0};
+    err = ckb_pipe(fds);
+    // read on write fd
+    err = ckb_read(fds[CKB_STDOUT], data, &data_length);
+    CHECK2(err != 0, -3);
+    // write on read fd
+    err = ckb_write(fds[CKB_STDIN], data, &data_length);
+    CHECK2(err != 0, -3);
+
+    // pass fd to child to make it invalid
+    const char* argv[] = {"", 0};
+    uint64_t inherited_fds[2] = {fds[0], 0};
+    spawn_args_t spgs = {.argc = 1, .argv = argv, .process_id = pid, .inherited_fds = inherited_fds};
+    err = ckb_spawn(0, CKB_SOURCE_CELL_DEP, 0, 0, &spgs);
+    CHECK(err);
+    err = ckb_read(fds[0], data, &data_length);
+    CHECK2(err != 0, -3);
+
+    // write to fd but the other end is closed
+    err = ckb_pipe(fds);
+    CHECK(err);
+    err = ckb_close(fds[CKB_STDIN]);
+    CHECK(err);
+    err = ckb_write(fds[CKB_STDOUT], data, &data_length);
+    CHECK2(err == CKB_OTHER_END_CLOSED, -2);
+
+    // read from fd but the ohter end is closed
+    err = ckb_pipe(fds);
+    CHECK(err);
+    err = ckb_close(fds[CKB_STDOUT]);
+    CHECK(err);
+    err = ckb_read(fds[CKB_STDIN], data, &data_length);
+    CHECK2(err == CKB_OTHER_END_CLOSED, -2);
+    err = 0;
+exit:
+    return err;
+}
+
+int parent_wait_dead_lock(uint64_t* pid) {
+    int err = 0;
+    const char* argv[] = {"", 0};
+    uint64_t fds[2] = {0};
+    err = full_spawn(0, 1, argv, fds, pid);
+    CHECK(err);
+
+exit:
+    return err;
+}
+
+int child_wait_dead_lock() {
+    uint64_t pid = 0;  // parent pid
+    int8_t exit_code = 0;
+    return ckb_wait(pid, &exit_code);
+}
+
+int parent_read_write_with_close(uint64_t* pid) {
+    int err = 0;
+    const char* argv[] = {"", 0};
+    uint64_t fds[2] = {0};
+    err = full_spawn(0, 1, argv, fds, pid);
+    // write util the other end is closed
+    uint8_t block[100];
+    for (size_t i = 0; i < sizeof(block); i++) {
+        block[i] = 0xFF;
+    }
+    size_t actual_length = 0;
+    err = write_exact(fds[CKB_STDOUT], block, sizeof(block), &actual_length);
+    CHECK(err);
+    CHECK2(actual_length == sizeof(block), -2);
+
+    err = 0;
+exit:
+    return err;
+}
+
+int child_read_write_with_close() {
+    int err = 0;
+    uint64_t inherited_fds[2];
+    size_t inherited_fds_length = 2;
+    err = ckb_inherited_file_descriptors(inherited_fds, &inherited_fds_length);
+    CHECK(err);
+
+    // read 100 bytes and close
+    uint8_t block[100] = {0};
+    size_t actual_length = 0;
+    err = read_exact(inherited_fds[CKB_STDIN], block, sizeof(block), &actual_length);
+    CHECK(err);
+    CHECK2(actual_length == sizeof(block), -2);
+    for (size_t j = 0; j < sizeof(block); j++) {
+        CHECK2(block[j] == 0xFF, -3);
+    }
+    err = ckb_close(inherited_fds[CKB_STDIN]);
+    CHECK(err);
+
+exit:
+    return err;
+}
+
+int parent_wait_multiple(uint64_t* pid) {
+    int err = 0;
+    const char* argv[] = {"", 0};
+    uint64_t fds[2] = {0};
+    full_spawn(0, 1, argv, fds, pid);
+    CHECK(err);
+
+    int8_t exit_code = 0;
+    err = ckb_wait(*pid, &exit_code);
+    CHECK(err);
+    // second wait is not allowed
+    err = ckb_wait(*pid, &exit_code);
+    CHECK2(err != 0, -2);
+    err = 0;
+    // spawn a new valid one, make ckb_wait happy
+    full_spawn(0, 1, argv, fds, pid);
+    CHECK(err);
+
+exit:
+    return err;
+}
+
+int parent_inherited_fds(uint64_t* pid) {
+    int err = 0;
+    const char* argv[] = {"", 0};
+    uint64_t inherited_fds[11] = {0};
+    for (size_t i = 0; i < 5; i++) {
+        err = ckb_pipe(&inherited_fds[i * 2]);
+        CHECK(err);
+    }
+    spawn_args_t spgs = {.argc = 1, .argv = argv, .process_id = pid, .inherited_fds = inherited_fds};
+    err = ckb_spawn(0, CKB_SOURCE_CELL_DEP, 0, 0, &spgs);
+    CHECK(err);
+exit:
+    return err;
+}
+
+int child_inherited_fds() {
+    int err = 0;
+
+    // correct way to get fd length
+    size_t fds_length = 0;
+    err = ckb_inherited_file_descriptors(0, &fds_length);
+    CHECK2(fds_length == 10, -2);
+
+    // get part of fds
+    uint64_t fds[11] = {0};
+    fds_length = 1;
+    err = ckb_inherited_file_descriptors(fds, &fds_length);
+    CHECK(err);
+    CHECK2(fds_length == 10, -2);
+    CHECK2(fds[0] == 2, -2);
+
+    // get all fds
+    fds_length = 10;
+    err = ckb_inherited_file_descriptors(fds, &fds_length);
+    CHECK(err);
+    CHECK2(fds_length == 10, -2);
+    for (size_t i = 0; i < 10; i++) {
+        CHECK2(fds[i] == (i + 2), -2);
+    }
+exit:
+    return err;
+}
+
+int parent_inherited_fds_without_owner(uint64_t* pid) {
+    int err = 0;
+    const char* argv[] = {"", 0};
+    uint64_t fds[3] = {0xFF, 0xEF, 0};
+
+    spawn_args_t spgs = {.argc = 1, .argv = argv, .process_id = pid, .inherited_fds = fds};
+    err = ckb_spawn(0, CKB_SOURCE_CELL_DEP, 0, 0, &spgs);
+    CHECK2(err == CKB_INVALID_FD, -2);
+
+    // create valid fds
+    err = ckb_pipe(fds);
+    CHECK(err);
+    // then transferred by spawn
+    err = ckb_spawn(0, CKB_SOURCE_CELL_DEP, 0, 0, &spgs);
+    CHECK(err);
+
+    // the fds are already transferred. An error expected.
+    err = ckb_spawn(0, CKB_SOURCE_CELL_DEP, 0, 0, &spgs);
+    CHECK2(err == CKB_INVALID_FD, -2);
+    err = 0;
+exit:
+    return err;
+}
+
+int parent_read_then_close(uint64_t* pid) {
+    int err = 0;
+    const char* argv[] = {"", 0};
+    uint64_t fds[2] = {0};
+    err = full_spawn(0, 1, argv, fds, pid);
+    CHECK(err);
+    err = ckb_close(fds[CKB_STDOUT]);
+    CHECK(err);
+exit:
+    return err;
+}
+
+int child_read_then_close() {
+    int err = 0;
+    uint64_t fds[2] = {0};
+    uint64_t fds_length = 2;
+    err = ckb_inherited_file_descriptors(fds, &fds_length);
+    CHECK(err);
+    uint8_t data[8];
+    size_t data_len = sizeof(data);
+    // first read to return 0 byte without error
+    err = ckb_read(fds[CKB_STDIN], data, &data_len);
+    CHECK(err);
+    CHECK2(data_len == 0, -2);
+    // second read to return error(other end closed)
+    err = ckb_read(fds[CKB_STDIN], data, &data_len);
+    CHECK2(err == CKB_OTHER_END_CLOSED, -2);
+
+    err = 0;
+exit:
+    return err;
+}
+
+int parent_max_vms_count() {
+    const char* argv[2] = {"", 0};
+    return simple_spawn_args(0, 1, argv);
+}
+
+int child_max_vms_count() {
+    const char* argv[2] = {"", 0};
+    int err = simple_spawn_args(0, 1, argv);
+    CHECK2(err == 0 || err == CKB_MAX_VMS_SPAWNED, -2);
+    err = 0;
+exit:
+    return err;
+}
+
+int parent_max_fds_limit() {
+    const char* argv[2] = {"", 0};
+    int err = 0;
+    uint64_t fd[2] = {0};
+    for (int i = 0; i < 16; i++) {
+        err = ckb_pipe(fd);
+        CHECK(err);
+    }
+    err = simple_spawn_args(0, 1, argv);
+exit:
+    return err;
+}
+
+int child_max_fds_limit() {
+    int err = 0;
+    uint64_t fd[2] = {0};
+    for (int i = 0; i < 16; i++) {
+        err = ckb_pipe(fd);
+        CHECK(err);
+    }
+    // Create up to 64 pipes.
+    err = ckb_pipe(fd);
+    err = CKB_MAX_FDS_CREATED - 9;
+
+exit:
+    return err;
+}
+
+int parent_close_invalid_fd() {
+    uint64_t fds[2] = {0};
+    int err = ckb_pipe(fds);
+    CHECK(err);
+
+    err = ckb_close(fds[CKB_STDIN] + 32);
+    CHECK2(err == 6, -1);
+
+    err = ckb_close(fds[CKB_STDIN]);
+    CHECK(err);
+    err = ckb_close(fds[CKB_STDOUT]);
+    CHECK(err);
+
+    err = ckb_close(fds[CKB_STDIN]);
+    CHECK2(err == 6, -1);
+    err = ckb_close(fds[CKB_STDOUT]);
+    CHECK2(err == 6, -1);
+
+    err = 0;
+exit:
+    return err;
+}
+
+int parent_write_closed_fd(uint64_t* pid) {
+    int err = 0;
+    const char* argv[] = {"", 0};
+    uint64_t fds[2] = {0};
+    err = full_spawn(0, 1, argv, fds, pid);
+    CHECK(err);
+
+    // int exit_code = 0;
+    uint8_t block[7] = {1, 2, 3, 4, 5, 6, 7};
+    size_t actual_length = 0;
+    err = read_exact(fds[CKB_STDIN], block, sizeof(block), &actual_length);
+    CHECK(err);
+    err = ckb_close(fds[CKB_STDIN]);
+    CHECK(err);
+
+    err = ckb_close(fds[CKB_STDOUT]);
+exit:
+    return err;
+}
+
+int child_write_closed_fd() {
+    int err = 0;
+    uint64_t inherited_fds[2];
+    size_t inherited_fds_length = 2;
+    err = ckb_inherited_file_descriptors(inherited_fds, &inherited_fds_length);
+    CHECK(err);
+
+    uint8_t block[7] = {0};
+    size_t actual_length = 0;
+    err = write_exact(inherited_fds[CKB_STDOUT], block, sizeof(block), &actual_length);
+    CHECK(err);
+    err = write_exact(inherited_fds[CKB_STDOUT], block, sizeof(block), &actual_length);
+    CHECK(err);
+
+    ckb_close(inherited_fds[CKB_STDIN]);
+    ckb_close(inherited_fds[CKB_STDOUT]);
+
+exit:
+    return err;
+}
+
+int parent_pid(uint64_t* pid) {
+    int err = 0;
+
+    uint64_t cur_pid = ckb_process_id();
+
+    uint64_t pid_c1 = 0;
+    const char* argv[] = {"", 0};
+    uint64_t fds_1[2] = {0};
+    err = full_spawn(0, 1, argv, fds_1, &pid_c1);
+    CHECK2(pid_c1 != cur_pid, -1);
+
+    uint64_t pid_c2 = 0;
+    uint64_t fds_2[2] = {0};
+    err = full_spawn(0, 1, argv, fds_2, &pid_c2);
+    CHECK(err);
+    CHECK2(pid_c2 != cur_pid, -1);
+
+    uint64_t child_pid_1 = 0;
+    size_t actual_length = 0;
+    err = read_exact(fds_1[CKB_STDIN], &child_pid_1, sizeof(child_pid_1), &actual_length);
+    CHECK(err);
+    CHECK2(child_pid_1 == pid_c1, -1);
+
+    uint64_t child_pid_2 = 0;
+    err = read_exact(fds_2[CKB_STDIN], &child_pid_2, sizeof(child_pid_2), &actual_length);
+    CHECK(err);
+    CHECK2(child_pid_2 == pid_c2, -1);
+
+exit:
+    return err;
+}
+
+int child_pid() {
+    uint64_t pid = ckb_process_id();
+
+    int err = 0;
+    uint64_t fds[2] = {0};
+    uint64_t fds_length = 2;
+    err = ckb_inherited_file_descriptors(fds, &fds_length);
+    CHECK(err);
+
+    // send pid
+    size_t actual_length = 0;
+    err = write_exact(fds[CKB_STDOUT], &pid, sizeof(pid), &actual_length);
+    CHECK(err);
+
+exit:
+    return err;
+}
+
+int parent_spawn_offset_out_of_bound(uint64_t* pid) {
+    int err = 0;
+
+    const char* argv[] = {"", 0};
+    spawn_args_t spgs = {.argc = 1, .argv = argv, .process_id = pid, .inherited_fds = NULL};
+    uint64_t offset = 1024 * 1024 * 1024 * 1;
+    uint64_t length = 0;
+    uint64_t bounds = (offset << 32) + length;
+    err = ckb_spawn(0, CKB_SOURCE_CELL_DEP, 0, bounds, &spgs);
+    CHECK2(err == 3, -1);  // SLICE_OUT_OF_BOUND
+    err = 0;
+exit:
+    return err;
+}
+
+int parent_spawn_length_out_of_bound(uint64_t* pid) {
+    int err = 0;
+
+    const char* argv[] = {"", 0};
+    spawn_args_t spgs = {.argc = 1, .argv = argv, .process_id = pid, .inherited_fds = NULL};
+    uint64_t offset = 1024 * 15;
+    uint64_t length = 1024;
+    uint64_t bounds = (offset << 32) + length;
+
+    err = ckb_spawn(0, CKB_SOURCE_CELL_DEP, 0, bounds, &spgs);
+    CHECK2(err == 3, -1);  // SLICE_OUT_OF_BOUND
+    err = 0;
+exit:
+    return err;
+}
+
+int parent_invaild_index(uint64_t* pid) {
+    int err = 0;
+    const char* argv[] = {"", 0};
+    uint64_t inherited_fds[11] = {0};
+    for (size_t i = 0; i < 5; i++) {
+        err = ckb_pipe(&inherited_fds[i * 2]);
+        CHECK(err);
+    }
+    spawn_args_t spgs = {.argc = 1, .argv = argv, .process_id = pid, .inherited_fds = inherited_fds};
+    err = ckb_spawn(0xFFFFFFFFF, CKB_SOURCE_CELL_DEP, 0, 0, &spgs);
+    CHECK2(err == 1, -1);  // INDEX_OUT_OF_BOUND
+    err = 0;
+
+exit:
+    return err;
+}
+
+int parent_index_out_of_bound(uint64_t* pid) {
+    int err = 0;
+    const char* argv[] = {"", 0};
+    uint64_t inherited_fds[11] = {0};
+    for (size_t i = 0; i < 5; i++) {
+        err = ckb_pipe(&inherited_fds[i * 2]);
+        CHECK(err);
+    }
+    spawn_args_t spgs = {.argc = 1, .argv = argv, .process_id = pid, .inherited_fds = inherited_fds};
+    err = ckb_spawn(2, CKB_SOURCE_CELL_DEP, 0, 0, &spgs);
+    CHECK2(err == 1, -1);  // INDEX_OUT_OF_BOUND
+    err = 0;
+
+exit:
+    return err;
+}
+
+int parent_entry(int case_id) {
+    int err = 0;
+    uint64_t pid = 0;
+    if (case_id == 1) {
+        err = parent_simple_read_write(&pid);
+    } else if (case_id == 2) {
+        err = parent_write_dead_lock(&pid);
+    } else if (case_id == 3) {
+        err = parent_invalid_fd(&pid);
+    } else if (case_id == 4) {
+        err = parent_wait_dead_lock(&pid);
+    } else if (case_id == 5) {
+        err = parent_read_write_with_close(&pid);
+    } else if (case_id == 6) {
+        err = parent_wait_multiple(&pid);
+    } else if (case_id == 7) {
+        err = parent_inherited_fds(&pid);
+    } else if (case_id == 8) {
+        err = parent_inherited_fds_without_owner(&pid);
+    } else if (case_id == 9) {
+        err = parent_read_then_close(&pid);
+    } else if (case_id == 10) {
+        err = parent_max_vms_count(&pid);
+        return err;
+    } else if (case_id == 11) {
+        err = parent_max_fds_limit(&pid);
+        return err;
+    } else if (case_id == 12) {
+        return parent_close_invalid_fd(&pid);
+    } else if (case_id == 13) {
+        return parent_write_closed_fd(&pid);
+    } else if (case_id == 14) {
+        return parent_pid(&pid);
+    } else if (case_id == 15) {
+        return parent_spawn_offset_out_of_bound(&pid);
+    } else if (case_id == 16) {
+        return parent_spawn_length_out_of_bound(&pid);
+    } else if (case_id == 17) {
+        return parent_invaild_index(&pid);
+    } else if (case_id == 18) {
+        return parent_index_out_of_bound(&pid);
+    } else {
+        CHECK2(false, -2);
+    }
+    CHECK(err);
+    int8_t exit_code = 0;
+    err = ckb_wait(pid, &exit_code);
+    CHECK(err);
+    CHECK(exit_code);
+
+exit:
+    return err;
+}
+
+int child_entry(int case_id) {
+    if (case_id == 1) {
+        return child_simple_read_write();
+    } else if (case_id == 2) {
+        return child_write_dead_lock();
+    } else if (case_id == 3) {
+        return 0;
+    } else if (case_id == 4) {
+        return child_wait_dead_lock();
+    } else if (case_id == 5) {
+        return child_read_write_with_close();
+    } else if (case_id == 6) {
+        return 0;
+    } else if (case_id == 7) {
+        return child_inherited_fds();
+    } else if (case_id == 8) {
+        return 0;
+    } else if (case_id == 9) {
+        return child_read_then_close();
+    } else if (case_id == 10) {
+        return child_max_vms_count();
+    } else if (case_id == 11) {
+        return child_max_fds_limit();
+    } else if (case_id == 12) {
+        return 0;
+    } else if (case_id == 13) {
+        return child_write_closed_fd();
+    } else if (case_id == 14) {
+        return child_pid();
+    } else if (case_id == 15) {
+        return 0;
+    } else if (case_id == 16) {
+        return 0;
+    } else {
+        return -1;
+    }
+}
+
+int main(int argc, const char* argv[]) {
+    uint8_t script_args[8];
+    size_t script_args_length = 8;
+    int err = load_script_args(script_args, &script_args_length);
+    if (err) {
+        return err;
+    }
+    int case_id = (int)script_args[0];
+    if (argc > 0) {
+        return child_entry(case_id);
+    } else {
+        return parent_entry(case_id);
+    }
+}
diff --git a/script/testdata/spawn_configurable_callee b/script/testdata/spawn_configurable_callee
new file mode 100755
index 0000000000..20b1024ecd
Binary files /dev/null and b/script/testdata/spawn_configurable_callee differ
diff --git a/script/testdata/spawn_configurable_callee.c b/script/testdata/spawn_configurable_callee.c
new file mode 100644
index 0000000000..92b849b35b
--- /dev/null
+++ b/script/testdata/spawn_configurable_callee.c
@@ -0,0 +1,29 @@
+#include <stdint.h>
+#include <string.h>
+
+#include "ckb_syscalls.h"
+#include "spawn_utils.h"
+
+int main() {
+    int err = 0;
+
+    uint64_t fds[2] = {0};
+    uint64_t fds_len = countof(fds);
+    err = ckb_inherited_file_descriptors(fds, &fds_len);
+    CHECK(err);
+    CHECK2(fds_len == 2, ErrorCommon);
+
+    uint8_t buffer[1024] = {0};
+    size_t length;
+    length = 1024;
+    ckb_read_all(fds[CKB_STDIN], buffer, &length);
+    CHECK2(length == 12, ErrorCommon);
+
+    err = ckb_write(fds[CKB_STDOUT], buffer, &length);
+    CHECK(err);
+    err = ckb_close(fds[CKB_STDOUT]);
+    CHECK(err);
+
+exit:
+    return err;
+}
diff --git a/script/testdata/spawn_configurable_caller b/script/testdata/spawn_configurable_caller
new file mode 100755
index 0000000000..f1620466f9
Binary files /dev/null and b/script/testdata/spawn_configurable_caller differ
diff --git a/script/testdata/spawn_configurable_caller.c b/script/testdata/spawn_configurable_caller.c
new file mode 100644
index 0000000000..ba3184c133
--- /dev/null
+++ b/script/testdata/spawn_configurable_caller.c
@@ -0,0 +1,60 @@
+#include <stdint.h>
+#include <string.h>
+
+#include "ckb_syscalls.h"
+#include "spawn_utils.h"
+
+uint64_t read_u64_le(const uint8_t* src) { return *(const uint64_t*)src; }
+
+int main() {
+    int err = 0;
+    uint64_t n = 0;
+
+    uint8_t args[32] = {0};
+    n = countof(args);
+    err = load_script_args(args, &n);
+    CHECK(err);
+    CHECK2(n == 32, ErrorCommon);
+    uint64_t args_index = read_u64_le(&args[0x00]);
+    uint64_t args_source = read_u64_le(&args[0x08]);
+    uint64_t args_place = read_u64_le(&args[0x10]);
+    uint64_t args_bounds = read_u64_le(&args[0x18]);
+    printf("args.index  = %llu", args_index);
+    printf("args.source = %llu", args_source);
+    printf("args.place  = %llu", args_place);
+    printf("args.bounds = %llu", args_bounds);
+
+    const char* argv[] = {};
+    uint64_t pid = 0;
+    uint64_t fds[2] = {0};
+    uint64_t inherited_fds[3] = {0};
+    err = create_std_fds(fds, inherited_fds);
+    CHECK(err);
+
+    spawn_args_t spgs = {
+        .argc = countof(argv),
+        .argv = argv,
+        .process_id = &pid,
+        .inherited_fds = inherited_fds,
+    };
+    err = ckb_spawn(args_index, args_source, args_place, args_bounds, &spgs);
+    CHECK(err);
+
+    size_t length = 0;
+    length = 12;
+    err = ckb_write(fds[CKB_STDOUT], "Hello World!", &length);
+    CHECK(err);
+    err = ckb_close(fds[CKB_STDOUT]);
+    CHECK(err);
+
+    uint8_t buffer[1024] = {0};
+    length = 1024;
+    err = ckb_read_all(fds[CKB_STDIN], buffer, &length);
+    CHECK(err);
+    CHECK2(length == 12, ErrorCommon);
+    err = memcmp("Hello World!", buffer, length);
+    CHECK(err);
+
+exit:
+    return err;
+}
diff --git a/script/testdata/spawn_current_memory b/script/testdata/spawn_current_memory
deleted file mode 100755
index 417eaca599..0000000000
Binary files a/script/testdata/spawn_current_memory and /dev/null differ
diff --git a/script/testdata/spawn_current_memory.c b/script/testdata/spawn_current_memory.c
deleted file mode 100644
index b09c62cb0e..0000000000
--- a/script/testdata/spawn_current_memory.c
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <stdint.h>
-#include <string.h>
-
-#include "ckb_syscalls.h"
-
-int main(int argc, char *argv[]) {
-  int peak_memory = ckb_current_memory();
-  if (peak_memory != (argc + 1) * 8) {
-    return 1;
-  }
-  if (peak_memory < 56) {
-    int spawn_argc = argc + 1;
-    const char *spawn_argv[] = {"", "", "", "", "", "", "", ""};
-    int8_t spawn_exit_code = 255;
-    spawn_args_t spgs = {
-        .memory_limit = 8,
-        .exit_code = &spawn_exit_code,
-        .content = NULL,
-        .content_length = NULL,
-    };
-    uint64_t success = ckb_spawn(0, 3, 0, spawn_argc, spawn_argv, &spgs);
-    if (success != 0) {
-      return success;
-    }
-  } else {
-    return 0;
-  }
-}
diff --git a/script/testdata/spawn_cycles b/script/testdata/spawn_cycles
new file mode 100755
index 0000000000..77d40c54fe
Binary files /dev/null and b/script/testdata/spawn_cycles differ
diff --git a/script/testdata/spawn_cycles.c b/script/testdata/spawn_cycles.c
new file mode 100644
index 0000000000..a338d73d4b
--- /dev/null
+++ b/script/testdata/spawn_cycles.c
@@ -0,0 +1,179 @@
+#include <stdint.h>
+#include <string.h>
+
+#include "ckb_syscalls.h"
+#include "spawn_utils.h"
+
+const uint64_t SYSCALL_CYCLES_BASE = 500;
+const uint64_t SPAWN_EXTRA_CYCLES_BASE = 100000;
+const uint64_t SPAWN_SPAWN_YIELD_CYCLES_BASE = 800;
+
+int tic() {
+    static uint64_t tic = 0;
+    uint64_t cur_cycles = ckb_current_cycles();
+    uint64_t toc = cur_cycles - tic;
+    tic = cur_cycles;
+    return toc;
+}
+
+uint64_t cal_cycles(uint64_t nbase, uint64_t yield, uint64_t extra) {
+    uint64_t r = 0;
+    r += SYSCALL_CYCLES_BASE * nbase;
+    r += SPAWN_SPAWN_YIELD_CYCLES_BASE * yield;
+    r += SPAWN_EXTRA_CYCLES_BASE * extra;
+    return r;
+}
+
+uint64_t cal_cycles_floor(uint64_t nbase, uint64_t yield, uint64_t extra) {
+    return cal_cycles(nbase, yield, extra);
+}
+
+uint64_t cal_cycles_upper(uint64_t nbase, uint64_t yield, uint64_t extra) {
+    return cal_cycles(nbase, yield, extra) + 8192;
+}
+
+int main() {
+    int err = 0;
+    int toc = 0;
+    uint64_t cid = ckb_process_id();
+    uint64_t pid[5] = {0};
+    uint64_t fds[5][2][3] = {0};
+    uint64_t buf[256] = {0};
+    uint64_t len = 0;
+
+    switch (cid) {
+        case 0:
+            const char* argv[1] = {0};
+
+            for (int i = 1; i < 5; i++) {
+                toc = tic();
+                err = ckb_pipe(buf);
+                CHECK(err);
+                toc = tic();
+                CHECK2(toc > cal_cycles_floor(1, 1, 0), ErrorCommon);
+                CHECK2(toc < cal_cycles_upper(1, 1, 0), ErrorCommon);
+                fds[i][0][0] = buf[0];
+                fds[i][1][1] = buf[1];
+
+                toc = tic();
+                err = ckb_pipe(buf);
+                CHECK(err);
+                toc = tic();
+                CHECK2(toc > cal_cycles_floor(1, 1, 0), ErrorCommon);
+                CHECK2(toc < cal_cycles_upper(1, 1, 0), ErrorCommon);
+                fds[i][0][1] = buf[1];
+                fds[i][1][0] = buf[0];
+            }
+
+            // Living Process: 0
+            // Living Process: 0, 1
+            // Living Process: 0, 1, 2
+            // Living Process: 0, 1, 2, 3
+            // Living Process: 1, 2, 3, 4
+            // Living Process: 0, 2, 3, 4
+            for (int i = 1; i < 5; i++) {
+                toc = tic();
+                spawn_args_t spgs = {.argc = 0, .argv = argv, .process_id = &pid[i], .inherited_fds = fds[i][1]};
+                err = ckb_spawn(0, CKB_SOURCE_CELL_DEP, 0, 0, &spgs);
+                CHECK(err);
+                toc = tic();
+                if (i < 4) {
+                    CHECK2(toc > cal_cycles_floor(1, 1, 1), ErrorCommon);
+                    CHECK2(toc < cal_cycles_upper(1, 1, 1), ErrorCommon);
+                } else {
+                    CHECK2(toc > cal_cycles_floor(1, 1, 4), ErrorCommon);
+                    CHECK2(toc < cal_cycles_upper(1, 1, 4), ErrorCommon);
+                }
+            }
+
+            // Living Process: 0, 2, 3, 4
+            // Living Process: 0, 1, 3, 4
+            // Living Process: 0, 2, 3, 4
+            for (int i = 1; i < 5; i++) {
+                len = 12;
+                toc = tic();
+                err = ckb_write(fds[i][0][1], "Hello World!", &len);
+                toc = tic();
+                CHECK(err);
+                if (i < 3) {
+                    CHECK2(toc > cal_cycles_floor(1, 1, 2), ErrorCommon);
+                    CHECK2(toc < cal_cycles_upper(1, 1, 2), ErrorCommon);
+                } else {
+                    CHECK2(toc > cal_cycles_floor(1, 1, 0), ErrorCommon);
+                    CHECK2(toc < cal_cycles_upper(1, 1, 0), ErrorCommon);
+                }
+                err = ckb_close(fds[i][0][1]);
+                CHECK(err);
+                toc = tic();
+                CHECK2(toc > cal_cycles_floor(1, 1, 0), ErrorCommon);
+                CHECK2(toc < cal_cycles_upper(1, 1, 0), ErrorCommon);
+            }
+
+            // Living Process: 0, 2, 3, 4
+            // Living Process: 0, 1, 3, 4
+            // Living Process: 0, 2, 3, 4
+            // Living Process: 0, 3, 4
+            // Living Process: 0, 4
+            // Living Process: 0
+            for (int i = 1; i < 5; i++) {
+                len = 1024;
+                toc = tic();
+                err = ckb_read_all(fds[i][0][0], buf, &len);
+                CHECK(err);
+                toc = tic();
+                if (i == 1) {
+                    CHECK2(toc > cal_cycles_floor(1, 1, 2), ErrorCommon);
+                    CHECK2(toc < cal_cycles_upper(1, 1, 2), ErrorCommon);
+                }
+                if (i == 2) {
+                    CHECK2(toc > cal_cycles_floor(1, 1, 1), ErrorCommon);
+                    CHECK2(toc < cal_cycles_upper(1, 1, 1), ErrorCommon);
+                }
+                if (i >= 3) {
+                    CHECK2(toc > cal_cycles_floor(1, 1, 0), ErrorCommon);
+                    CHECK2(toc < cal_cycles_upper(1, 1, 0), ErrorCommon);
+                }
+                CHECK2(len == 12, ErrorCommon);
+                err = memcmp("Hello World!", buf, len);
+                CHECK(err);
+            }
+
+            for (int i = 1; i < 5; i++) {
+                int8_t exit_code = 255;
+                toc = tic();
+                err = ckb_wait(pid[i], &exit_code);
+                CHECK(err);
+                toc = tic();
+                CHECK2(toc > cal_cycles_floor(1, 1, 0), ErrorCommon);
+                CHECK2(toc < cal_cycles_upper(1, 1, 0), ErrorCommon);
+                CHECK(exit_code);
+            }
+            break;
+        case 1:
+        case 2:
+        case 3:
+        case 4:
+            len = 2;
+            toc = tic();
+            err = ckb_inherited_file_descriptors(fds[cid][1], &len);
+            CHECK(err);
+            toc = tic();
+            CHECK2(toc > cal_cycles_floor(1, 1, 0), ErrorCommon);
+            CHECK2(toc < cal_cycles_upper(1, 1, 0), ErrorCommon);
+            CHECK2(len == 2, ErrorCommon);
+            len = 1024;
+            err = ckb_read_all(fds[cid][1][0], buf, &len);
+            CHECK(err);
+            CHECK2(len == 12, ErrorCommon);
+            err = memcmp("Hello World!", buf, len);
+            CHECK(err);
+            err = ckb_write(fds[cid][1][1], buf, &len);
+            CHECK(err);
+            err = ckb_close(fds[cid][1][1]);
+            CHECK(err);
+            break;
+    }
+
+exit:
+    return err;
+}
diff --git a/script/testdata/spawn_dag b/script/testdata/spawn_dag
new file mode 100755
index 0000000000..b88dedb7fd
Binary files /dev/null and b/script/testdata/spawn_dag differ
diff --git a/script/testdata/spawn_dag.c b/script/testdata/spawn_dag.c
new file mode 100644
index 0000000000..b813e01797
--- /dev/null
+++ b/script/testdata/spawn_dag.c
@@ -0,0 +1,318 @@
+#define CKB_C_STDLIB_PRINTF 1
+#include <ckb_syscalls.h>
+#include <stdio.h>
+
+#include "spawn_dag.h"
+#include "spawn_dag_escape_encoding.h"
+#include "ckb_syscalls.h"
+
+#define INPUT_DATA_LENGTH (600 * 1024)
+#define MAX_PIPE_COUNT 3200
+#define MAX_SPAWNED_VMS 1024
+
+#define _BASE_ERROR_CODE 42
+#define ERROR_NO_SPACE_FOR_PIPES (_BASE_ERROR_CODE + 1)
+#define ERROR_NOT_FOUND (_BASE_ERROR_CODE + 2)
+#define ERROR_ENCODING (_BASE_ERROR_CODE + 3)
+#define ERROR_ARGV (_BASE_ERROR_CODE + 4)
+#define ERROR_TOO_MANY_SPAWNS (_BASE_ERROR_CODE + 5)
+#define ERROR_PIPE_CLOSED (_BASE_ERROR_CODE + 6)
+#define ERROR_CORRUPTED_DATA (_BASE_ERROR_CODE + 7)
+
+typedef struct {
+    uint64_t indices[MAX_PIPE_COUNT];
+    uint64_t ids[MAX_PIPE_COUNT + 1];
+    size_t used;
+} pipes_t;
+
+void pipes_init(pipes_t *pipes) {
+    pipes->used = 0;
+    pipes->ids[pipes->used] = 0;
+}
+
+int pipes_add(pipes_t *pipes, uint64_t index, uint64_t id) {
+    if (pipes->used >= MAX_PIPE_COUNT) {
+        return ERROR_NO_SPACE_FOR_PIPES;
+    }
+    pipes->indices[pipes->used] = index;
+    pipes->ids[pipes->used] = id;
+    pipes->used++;
+    pipes->ids[pipes->used] = 0;
+    return CKB_SUCCESS;
+}
+
+int pipes_find(const pipes_t *pipes, uint64_t index, uint64_t *id) {
+    for (size_t i = 0; i < pipes->used; i++) {
+        if (pipes->indices[i] == index) {
+            *id = pipes->ids[i];
+            return CKB_SUCCESS;
+        }
+    }
+    return ERROR_NOT_FOUND;
+}
+
+int main(int argc, char *argv[]) {
+    uint8_t data_buffer[INPUT_DATA_LENGTH];
+    pipes_t current_pipes;
+    pipes_init(&current_pipes);
+
+    uint64_t data_length = INPUT_DATA_LENGTH;
+    int ret = ckb_load_witness(data_buffer, &data_length, 0, 0, CKB_SOURCE_INPUT);
+    if (ret != CKB_SUCCESS) {
+        return ret;
+    }
+    mol_seg_t data_seg;
+    data_seg.ptr = data_buffer;
+    data_seg.size = data_length;
+
+    if (MolReader_Data_verify(&data_seg, false) != MOL_OK) {
+        return ERROR_ENCODING;
+    }
+
+    mol_seg_t spawns_seg = MolReader_Data_get_spawns(&data_seg);
+    uint64_t vm_index = 0;
+    if (argc != 0) {
+        // For spawned VMs, read current VM index and passed pipes from argv
+        if (argc != 2) {
+            return ERROR_ARGV;
+        }
+
+        uint64_t decoded_length = 0;
+        ret = ee_decode_char_string_in_place(argv[0], &decoded_length);
+        if (ret != 0) {
+            return ret;
+        }
+        if (decoded_length != 8) {
+            return ERROR_ARGV;
+        }
+        vm_index = *((uint64_t *)argv[0]);
+
+        int spawn_found = 0;
+        mol_seg_t spawn_seg;
+        for (mol_num_t i = 0; i < MolReader_Spawns_length(&spawns_seg); i++) {
+            mol_seg_res_t spawn_res = MolReader_Spawns_get(&spawns_seg, i);
+            if (spawn_res.errno != MOL_OK) {
+                return ERROR_ENCODING;
+            }
+            mol_seg_t child_seg = MolReader_Spawn_get_child(&spawn_res.seg);
+            uint64_t child_index = *((uint64_t *)child_seg.ptr);
+            if (child_index == vm_index) {
+                spawn_seg = spawn_res.seg;
+                spawn_found = 1;
+                break;
+            }
+        }
+        if (spawn_found == 0) {
+            return ERROR_ARGV;
+        }
+        mol_seg_t passed_pipes_seg = MolReader_Spawn_get_fds(&spawn_seg);
+
+        decoded_length = 0;
+        ret = ee_decode_char_string_in_place(argv[1], &decoded_length);
+        if (ret != 0) {
+            return ret;
+        }
+        if (decoded_length != MolReader_FdIndices_length(&passed_pipes_seg) * 8) {
+            return ERROR_ARGV;
+        }
+        for (mol_num_t i = 0; i < MolReader_FdIndices_length(&passed_pipes_seg); i++) {
+            mol_seg_res_t pipe_res = MolReader_FdIndices_get(&passed_pipes_seg, i);
+            if (pipe_res.errno != MOL_OK) {
+                return ERROR_ENCODING;
+            }
+            uint64_t pipe_index = *((uint64_t *)pipe_res.seg.ptr);
+            uint64_t pipe_id = *((uint64_t *)&argv[1][i * 8]);
+
+            ret = pipes_add(&current_pipes, pipe_index, pipe_id);
+            if (ret != 0) {
+                return ret;
+            }
+        }
+    }
+
+    // Create new pipes that should be created from current VM
+    mol_seg_t pipes_seg = MolReader_Data_get_pipes(&data_seg);
+    for (mol_num_t i = 0; i < MolReader_Pipes_length(&pipes_seg); i++) {
+        mol_seg_res_t pipe_pair_res = MolReader_Pipes_get(&pipes_seg, i);
+        if (pipe_pair_res.errno != MOL_OK) {
+            return ERROR_ENCODING;
+        }
+        mol_seg_t pipe_pair_seg = pipe_pair_res.seg;
+
+        uint64_t pair_vm_index = *((uint64_t *)MolReader_Pipe_get_vm(&pipe_pair_seg).ptr);
+        if (pair_vm_index == vm_index) {
+            uint64_t read_index = *((uint64_t *)MolReader_Pipe_get_read_fd(&pipe_pair_seg).ptr);
+            uint64_t write_index = *((uint64_t *)MolReader_Pipe_get_write_fd(&pipe_pair_seg).ptr);
+
+            uint64_t fildes[2];
+            ret = ckb_pipe(fildes);
+            if (ret != 0) {
+                return ret;
+            }
+            ret = pipes_add(&current_pipes, read_index, fildes[0]);
+            if (ret != 0) {
+                return ret;
+            }
+            ret = pipes_add(&current_pipes, write_index, fildes[1]);
+            if (ret != 0) {
+                return ret;
+            }
+        }
+    }
+
+    uint64_t spawned_vms[MAX_SPAWNED_VMS];
+    size_t spawned_count = 0;
+
+    // Issue spawn syscalls for child VMs
+    for (mol_num_t i = 0; i < MolReader_Spawns_length(&spawns_seg); i++) {
+        mol_seg_res_t spawn_res = MolReader_Spawns_get(&spawns_seg, i);
+        if (spawn_res.errno != MOL_OK) {
+            return ERROR_ENCODING;
+        }
+        mol_seg_t spawn_seg = spawn_res.seg;
+
+        uint64_t from_index = *((uint64_t *)MolReader_Spawn_get_from(&spawn_seg).ptr);
+        if (from_index == vm_index) {
+            if (spawned_count >= MAX_SPAWNED_VMS) {
+                return ERROR_TOO_MANY_SPAWNS;
+            }
+
+            uint64_t child_index = *((uint64_t *)MolReader_Spawn_get_child(&spawn_seg).ptr);
+
+            pipes_t passed_pipes;
+            pipes_init(&passed_pipes);
+
+            mol_seg_t pipe_indices = MolReader_Spawn_get_fds(&spawn_seg);
+            for (mol_num_t i = 0; i < MolReader_FdIndices_length(&pipe_indices); i++) {
+                mol_seg_res_t index_res = MolReader_FdIndices_get(&pipe_indices, i);
+                if (index_res.errno != MOL_OK) {
+                    return ERROR_ENCODING;
+                }
+                mol_seg_t index_seg = index_res.seg;
+                uint64_t index = *((uint64_t *)index_seg.ptr);
+
+                uint64_t id = 0;
+                ret = pipes_find(&current_pipes, index, &id);
+                if (ret != 0) {
+                    return ret;
+                }
+
+                ret = pipes_add(&passed_pipes, index, id);
+                if (ret != 0) {
+                    return ret;
+                }
+            }
+
+            size_t src_len = 8;
+            size_t dst_len = ee_maximum_encoding_length(src_len);
+            uint8_t encoded_child_index[dst_len + 1];
+            ret = ee_encode(encoded_child_index, &dst_len, (const uint8_t *)&child_index, &src_len);
+            if (ret != 0) {
+                return ret;
+            }
+            encoded_child_index[dst_len] = '\0';
+
+            src_len = passed_pipes.used * 8;
+            dst_len = ee_maximum_encoding_length(src_len);
+            uint8_t encoded_ids[dst_len + 1];
+            ret = ee_encode(encoded_ids, &dst_len, (const uint8_t *)passed_pipes.ids, &src_len);
+            if (ret != 0) {
+                return ret;
+            }
+            encoded_ids[dst_len] = '\0';
+
+            const char *argv[2] = {(char *)encoded_child_index, (char *)encoded_ids};
+            spawn_args_t sargs;
+            sargs.argc = 2;
+            sargs.argv = argv;
+            sargs.process_id = &spawned_vms[spawned_count++];
+            sargs.inherited_fds = (const uint64_t *)passed_pipes.ids;
+
+            ret = ckb_spawn(0, CKB_SOURCE_CELL_DEP, 0, 0, &sargs);
+            if (ret != 0) {
+                return ret;
+            }
+        }
+    }
+
+    // Process all reads & writes
+    mol_seg_t writes_seg = MolReader_Data_get_writes(&data_seg);
+    for (mol_num_t i = 0; i < MolReader_Writes_length(&writes_seg); i++) {
+        mol_seg_res_t write_res = MolReader_Writes_get(&writes_seg, i);
+        if (write_res.errno != MOL_OK) {
+            return ERROR_ENCODING;
+        }
+        mol_seg_t write_seg = write_res.seg;
+
+        uint64_t from = *((uint64_t *)MolReader_Write_get_from(&write_seg).ptr);
+        uint64_t to = *((uint64_t *)MolReader_Write_get_to(&write_seg).ptr);
+
+        if (from == vm_index) {
+            // Write data
+            uint64_t from_pipe = *((uint64_t *)MolReader_Write_get_from_fd(&write_seg).ptr);
+            mol_seg_t data_seg = MolReader_Write_get_data(&write_seg);
+
+            uint64_t pipe_id = 0;
+            ret = pipes_find(&current_pipes, from_pipe, &pipe_id);
+            if (ret != 0) {
+                return ret;
+            }
+
+            uint32_t written = 0;
+            while (written < data_seg.size) {
+                size_t length = data_seg.size - written;
+                ret = ckb_write(pipe_id, &data_seg.ptr[written], &length);
+                if (ret != 0) {
+                    return ret;
+                }
+                if (length == 0) {
+                    return ERROR_PIPE_CLOSED;
+                }
+                written += length;
+            }
+        } else if (to == vm_index) {
+            // Read data
+            uint64_t to_pipe = *((uint64_t *)MolReader_Write_get_to_fd(&write_seg).ptr);
+            mol_seg_t data_seg = MolReader_Write_get_data(&write_seg);
+
+            uint64_t pipe_id = 0;
+            ret = pipes_find(&current_pipes, to_pipe, &pipe_id);
+            if (ret != 0) {
+                return ret;
+            }
+
+            uint32_t read = 0;
+            while (read < data_seg.size) {
+                size_t length = data_seg.size - read;
+                uint8_t data[length];
+                memset(data, 0, length);
+                ret = ckb_read(pipe_id, data, &length);
+                if (ret != 0) {
+                    return ret;
+                }
+                if (length == 0) {
+                    return ERROR_PIPE_CLOSED;
+                }
+                if (memcmp(&data_seg.ptr[read], data, length) != 0) {
+                    return ERROR_CORRUPTED_DATA;
+                }
+                read += length;
+            }
+        }
+    }
+
+    // Join all spawned VMs
+    for (size_t i = 0; i < spawned_count; i++) {
+        size_t j = spawned_count - i - 1;
+        int8_t exit_code = 0xFF;
+        ret = ckb_wait(spawned_vms[j], &exit_code);
+        if (ret != 0) {
+            return ret;
+        }
+        if (exit_code != 0) {
+            return exit_code;
+        }
+    }
+
+    return 0;
+}
diff --git a/script/testdata/spawn_dag.h b/script/testdata/spawn_dag.h
new file mode 100644
index 0000000000..a7bebf57ca
--- /dev/null
+++ b/script/testdata/spawn_dag.h
@@ -0,0 +1,887 @@
+// Generated by Molecule 0.8.0
+
+#define MOLECULEC_VERSION 8000
+#define MOLECULE_API_VERSION_MIN 7000
+
+#include "molecule_reader.h"
+#include "molecule_builder.h"
+
+#ifndef SPAWN_DAG_H
+#define SPAWN_DAG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#ifndef MOLECULE_API_DECORATOR
+#define __DEFINE_MOLECULE_API_DECORATOR_SPAWN_DAG
+#define MOLECULE_API_DECORATOR
+#endif /* MOLECULE_API_DECORATOR */
+
+/*
+ * Reader APIs
+ */
+
+#define                                 MolReader_VmIndex_verify(s, c)                  mol_verify_fixed_size(s, 8)
+#define                                 MolReader_VmIndex_get_nth0(s)                   mol_slice_by_offset(s, 0, 1)
+#define                                 MolReader_VmIndex_get_nth1(s)                   mol_slice_by_offset(s, 1, 1)
+#define                                 MolReader_VmIndex_get_nth2(s)                   mol_slice_by_offset(s, 2, 1)
+#define                                 MolReader_VmIndex_get_nth3(s)                   mol_slice_by_offset(s, 3, 1)
+#define                                 MolReader_VmIndex_get_nth4(s)                   mol_slice_by_offset(s, 4, 1)
+#define                                 MolReader_VmIndex_get_nth5(s)                   mol_slice_by_offset(s, 5, 1)
+#define                                 MolReader_VmIndex_get_nth6(s)                   mol_slice_by_offset(s, 6, 1)
+#define                                 MolReader_VmIndex_get_nth7(s)                   mol_slice_by_offset(s, 7, 1)
+#define                                 MolReader_FdIndex_verify(s, c)                  mol_verify_fixed_size(s, 8)
+#define                                 MolReader_FdIndex_get_nth0(s)                   mol_slice_by_offset(s, 0, 1)
+#define                                 MolReader_FdIndex_get_nth1(s)                   mol_slice_by_offset(s, 1, 1)
+#define                                 MolReader_FdIndex_get_nth2(s)                   mol_slice_by_offset(s, 2, 1)
+#define                                 MolReader_FdIndex_get_nth3(s)                   mol_slice_by_offset(s, 3, 1)
+#define                                 MolReader_FdIndex_get_nth4(s)                   mol_slice_by_offset(s, 4, 1)
+#define                                 MolReader_FdIndex_get_nth5(s)                   mol_slice_by_offset(s, 5, 1)
+#define                                 MolReader_FdIndex_get_nth6(s)                   mol_slice_by_offset(s, 6, 1)
+#define                                 MolReader_FdIndex_get_nth7(s)                   mol_slice_by_offset(s, 7, 1)
+#define                                 MolReader_FdIndices_verify(s, c)                mol_fixvec_verify(s, 8)
+#define                                 MolReader_FdIndices_length(s)                   mol_fixvec_length(s)
+#define                                 MolReader_FdIndices_get(s, i)                   mol_fixvec_slice_by_index(s, 8, i)
+#define                                 MolReader_Bytes_verify(s, c)                    mol_fixvec_verify(s, 1)
+#define                                 MolReader_Bytes_length(s)                       mol_fixvec_length(s)
+#define                                 MolReader_Bytes_get(s, i)                       mol_fixvec_slice_by_index(s, 1, i)
+#define                                 MolReader_Bytes_raw_bytes(s)                    mol_fixvec_slice_raw_bytes(s)
+MOLECULE_API_DECORATOR  mol_errno       MolReader_Pipe_verify                           (const mol_seg_t*, bool);
+#define                                 MolReader_Pipe_actual_field_count(s)            mol_table_actual_field_count(s)
+#define                                 MolReader_Pipe_has_extra_fields(s)              mol_table_has_extra_fields(s, 3)
+#define                                 MolReader_Pipe_get_vm(s)                        mol_table_slice_by_index(s, 0)
+#define                                 MolReader_Pipe_get_read_fd(s)                   mol_table_slice_by_index(s, 1)
+#define                                 MolReader_Pipe_get_write_fd(s)                  mol_table_slice_by_index(s, 2)
+MOLECULE_API_DECORATOR  mol_errno       MolReader_Pipes_verify                          (const mol_seg_t*, bool);
+#define                                 MolReader_Pipes_length(s)                       mol_dynvec_length(s)
+#define                                 MolReader_Pipes_get(s, i)                       mol_dynvec_slice_by_index(s, i)
+MOLECULE_API_DECORATOR  mol_errno       MolReader_Write_verify                          (const mol_seg_t*, bool);
+#define                                 MolReader_Write_actual_field_count(s)           mol_table_actual_field_count(s)
+#define                                 MolReader_Write_has_extra_fields(s)             mol_table_has_extra_fields(s, 5)
+#define                                 MolReader_Write_get_from(s)                     mol_table_slice_by_index(s, 0)
+#define                                 MolReader_Write_get_from_fd(s)                  mol_table_slice_by_index(s, 1)
+#define                                 MolReader_Write_get_to(s)                       mol_table_slice_by_index(s, 2)
+#define                                 MolReader_Write_get_to_fd(s)                    mol_table_slice_by_index(s, 3)
+#define                                 MolReader_Write_get_data(s)                     mol_table_slice_by_index(s, 4)
+MOLECULE_API_DECORATOR  mol_errno       MolReader_Writes_verify                         (const mol_seg_t*, bool);
+#define                                 MolReader_Writes_length(s)                      mol_dynvec_length(s)
+#define                                 MolReader_Writes_get(s, i)                      mol_dynvec_slice_by_index(s, i)
+MOLECULE_API_DECORATOR  mol_errno       MolReader_Spawn_verify                          (const mol_seg_t*, bool);
+#define                                 MolReader_Spawn_actual_field_count(s)           mol_table_actual_field_count(s)
+#define                                 MolReader_Spawn_has_extra_fields(s)             mol_table_has_extra_fields(s, 3)
+#define                                 MolReader_Spawn_get_from(s)                     mol_table_slice_by_index(s, 0)
+#define                                 MolReader_Spawn_get_child(s)                    mol_table_slice_by_index(s, 1)
+#define                                 MolReader_Spawn_get_fds(s)                      mol_table_slice_by_index(s, 2)
+MOLECULE_API_DECORATOR  mol_errno       MolReader_Spawns_verify                         (const mol_seg_t*, bool);
+#define                                 MolReader_Spawns_length(s)                      mol_dynvec_length(s)
+#define                                 MolReader_Spawns_get(s, i)                      mol_dynvec_slice_by_index(s, i)
+MOLECULE_API_DECORATOR  mol_errno       MolReader_Data_verify                           (const mol_seg_t*, bool);
+#define                                 MolReader_Data_actual_field_count(s)            mol_table_actual_field_count(s)
+#define                                 MolReader_Data_has_extra_fields(s)              mol_table_has_extra_fields(s, 3)
+#define                                 MolReader_Data_get_spawns(s)                    mol_table_slice_by_index(s, 0)
+#define                                 MolReader_Data_get_pipes(s)                     mol_table_slice_by_index(s, 1)
+#define                                 MolReader_Data_get_writes(s)                    mol_table_slice_by_index(s, 2)
+
+/*
+ * Builder APIs
+ */
+
+#define                                 MolBuilder_VmIndex_init(b)                      mol_builder_initialize_fixed_size(b, 8)
+#define                                 MolBuilder_VmIndex_set_nth0(b, p)               mol_builder_set_byte_by_offset(b, 0, p)
+#define                                 MolBuilder_VmIndex_set_nth1(b, p)               mol_builder_set_byte_by_offset(b, 1, p)
+#define                                 MolBuilder_VmIndex_set_nth2(b, p)               mol_builder_set_byte_by_offset(b, 2, p)
+#define                                 MolBuilder_VmIndex_set_nth3(b, p)               mol_builder_set_byte_by_offset(b, 3, p)
+#define                                 MolBuilder_VmIndex_set_nth4(b, p)               mol_builder_set_byte_by_offset(b, 4, p)
+#define                                 MolBuilder_VmIndex_set_nth5(b, p)               mol_builder_set_byte_by_offset(b, 5, p)
+#define                                 MolBuilder_VmIndex_set_nth6(b, p)               mol_builder_set_byte_by_offset(b, 6, p)
+#define                                 MolBuilder_VmIndex_set_nth7(b, p)               mol_builder_set_byte_by_offset(b, 7, p)
+#define                                 MolBuilder_VmIndex_build(b)                     mol_builder_finalize_simple(b)
+#define                                 MolBuilder_VmIndex_clear(b)                     mol_builder_discard(b)
+#define                                 MolBuilder_FdIndex_init(b)                      mol_builder_initialize_fixed_size(b, 8)
+#define                                 MolBuilder_FdIndex_set_nth0(b, p)               mol_builder_set_byte_by_offset(b, 0, p)
+#define                                 MolBuilder_FdIndex_set_nth1(b, p)               mol_builder_set_byte_by_offset(b, 1, p)
+#define                                 MolBuilder_FdIndex_set_nth2(b, p)               mol_builder_set_byte_by_offset(b, 2, p)
+#define                                 MolBuilder_FdIndex_set_nth3(b, p)               mol_builder_set_byte_by_offset(b, 3, p)
+#define                                 MolBuilder_FdIndex_set_nth4(b, p)               mol_builder_set_byte_by_offset(b, 4, p)
+#define                                 MolBuilder_FdIndex_set_nth5(b, p)               mol_builder_set_byte_by_offset(b, 5, p)
+#define                                 MolBuilder_FdIndex_set_nth6(b, p)               mol_builder_set_byte_by_offset(b, 6, p)
+#define                                 MolBuilder_FdIndex_set_nth7(b, p)               mol_builder_set_byte_by_offset(b, 7, p)
+#define                                 MolBuilder_FdIndex_build(b)                     mol_builder_finalize_simple(b)
+#define                                 MolBuilder_FdIndex_clear(b)                     mol_builder_discard(b)
+#define                                 MolBuilder_FdIndices_init(b)                    mol_fixvec_builder_initialize(b, 128)
+#define                                 MolBuilder_FdIndices_push(b, p)                 mol_fixvec_builder_push(b, p, 8)
+#define                                 MolBuilder_FdIndices_build(b)                   mol_fixvec_builder_finalize(b)
+#define                                 MolBuilder_FdIndices_clear(b)                   mol_builder_discard(b)
+#define                                 MolBuilder_Bytes_init(b)                        mol_fixvec_builder_initialize(b, 16)
+#define                                 MolBuilder_Bytes_push(b, p)                     mol_fixvec_builder_push_byte(b, p)
+#define                                 MolBuilder_Bytes_build(b)                       mol_fixvec_builder_finalize(b)
+#define                                 MolBuilder_Bytes_clear(b)                       mol_builder_discard(b)
+#define                                 MolBuilder_Pipe_init(b)                         mol_table_builder_initialize(b, 256, 3)
+#define                                 MolBuilder_Pipe_set_vm(b, p, l)                 mol_table_builder_add(b, 0, p, l)
+#define                                 MolBuilder_Pipe_set_read_fd(b, p, l)            mol_table_builder_add(b, 1, p, l)
+#define                                 MolBuilder_Pipe_set_write_fd(b, p, l)           mol_table_builder_add(b, 2, p, l)
+MOLECULE_API_DECORATOR  mol_seg_res_t   MolBuilder_Pipe_build                           (mol_builder_t);
+#define                                 MolBuilder_Pipe_clear(b)                        mol_builder_discard(b)
+#define                                 MolBuilder_Pipes_init(b)                        mol_builder_initialize_with_capacity(b, 1024, 64)
+#define                                 MolBuilder_Pipes_push(b, p, l)                  mol_dynvec_builder_push(b, p, l)
+#define                                 MolBuilder_Pipes_build(b)                       mol_dynvec_builder_finalize(b)
+#define                                 MolBuilder_Pipes_clear(b)                       mol_builder_discard(b)
+#define                                 MolBuilder_Write_init(b)                        mol_table_builder_initialize(b, 256, 5)
+#define                                 MolBuilder_Write_set_from(b, p, l)              mol_table_builder_add(b, 0, p, l)
+#define                                 MolBuilder_Write_set_from_fd(b, p, l)           mol_table_builder_add(b, 1, p, l)
+#define                                 MolBuilder_Write_set_to(b, p, l)                mol_table_builder_add(b, 2, p, l)
+#define                                 MolBuilder_Write_set_to_fd(b, p, l)             mol_table_builder_add(b, 3, p, l)
+#define                                 MolBuilder_Write_set_data(b, p, l)              mol_table_builder_add(b, 4, p, l)
+MOLECULE_API_DECORATOR  mol_seg_res_t   MolBuilder_Write_build                          (mol_builder_t);
+#define                                 MolBuilder_Write_clear(b)                       mol_builder_discard(b)
+#define                                 MolBuilder_Writes_init(b)                       mol_builder_initialize_with_capacity(b, 1024, 64)
+#define                                 MolBuilder_Writes_push(b, p, l)                 mol_dynvec_builder_push(b, p, l)
+#define                                 MolBuilder_Writes_build(b)                      mol_dynvec_builder_finalize(b)
+#define                                 MolBuilder_Writes_clear(b)                      mol_builder_discard(b)
+#define                                 MolBuilder_Spawn_init(b)                        mol_table_builder_initialize(b, 256, 3)
+#define                                 MolBuilder_Spawn_set_from(b, p, l)              mol_table_builder_add(b, 0, p, l)
+#define                                 MolBuilder_Spawn_set_child(b, p, l)             mol_table_builder_add(b, 1, p, l)
+#define                                 MolBuilder_Spawn_set_fds(b, p, l)               mol_table_builder_add(b, 2, p, l)
+MOLECULE_API_DECORATOR  mol_seg_res_t   MolBuilder_Spawn_build                          (mol_builder_t);
+#define                                 MolBuilder_Spawn_clear(b)                       mol_builder_discard(b)
+#define                                 MolBuilder_Spawns_init(b)                       mol_builder_initialize_with_capacity(b, 1024, 64)
+#define                                 MolBuilder_Spawns_push(b, p, l)                 mol_dynvec_builder_push(b, p, l)
+#define                                 MolBuilder_Spawns_build(b)                      mol_dynvec_builder_finalize(b)
+#define                                 MolBuilder_Spawns_clear(b)                      mol_builder_discard(b)
+#define                                 MolBuilder_Data_init(b)                         mol_table_builder_initialize(b, 128, 3)
+#define                                 MolBuilder_Data_set_spawns(b, p, l)             mol_table_builder_add(b, 0, p, l)
+#define                                 MolBuilder_Data_set_pipes(b, p, l)              mol_table_builder_add(b, 1, p, l)
+#define                                 MolBuilder_Data_set_writes(b, p, l)             mol_table_builder_add(b, 2, p, l)
+MOLECULE_API_DECORATOR  mol_seg_res_t   MolBuilder_Data_build                           (mol_builder_t);
+#define                                 MolBuilder_Data_clear(b)                        mol_builder_discard(b)
+
+/*
+ * Default Value
+ */
+
+#define ____ 0x00
+
+MOLECULE_API_DECORATOR const uint8_t MolDefault_VmIndex[8]       =  {
+    ____, ____, ____, ____, ____, ____, ____, ____,
+};
+MOLECULE_API_DECORATOR const uint8_t MolDefault_FdIndex[8]       =  {
+    ____, ____, ____, ____, ____, ____, ____, ____,
+};
+MOLECULE_API_DECORATOR const uint8_t MolDefault_FdIndices[4]     =  {____, ____, ____, ____};
+MOLECULE_API_DECORATOR const uint8_t MolDefault_Bytes[4]         =  {____, ____, ____, ____};
+MOLECULE_API_DECORATOR const uint8_t MolDefault_Pipe[40]         =  {
+    0x28, ____, ____, ____, 0x10, ____, ____, ____, 0x18, ____, ____, ____,
+    0x20, ____, ____, ____, ____, ____, ____, ____, ____, ____, ____, ____,
+    ____, ____, ____, ____, ____, ____, ____, ____, ____, ____, ____, ____,
+    ____, ____, ____, ____,
+};
+MOLECULE_API_DECORATOR const uint8_t MolDefault_Pipes[4]         =  {0x04, ____, ____, ____};
+MOLECULE_API_DECORATOR const uint8_t MolDefault_Write[60]        =  {
+    0x3c, ____, ____, ____, 0x18, ____, ____, ____, 0x20, ____, ____, ____,
+    0x28, ____, ____, ____, 0x30, ____, ____, ____, 0x38, ____, ____, ____,
+    ____, ____, ____, ____, ____, ____, ____, ____, ____, ____, ____, ____,
+    ____, ____, ____, ____, ____, ____, ____, ____, ____, ____, ____, ____,
+    ____, ____, ____, ____, ____, ____, ____, ____, ____, ____, ____, ____,
+};
+MOLECULE_API_DECORATOR const uint8_t MolDefault_Writes[4]        =  {0x04, ____, ____, ____};
+MOLECULE_API_DECORATOR const uint8_t MolDefault_Spawn[36]        =  {
+    0x24, ____, ____, ____, 0x10, ____, ____, ____, 0x18, ____, ____, ____,
+    0x20, ____, ____, ____, ____, ____, ____, ____, ____, ____, ____, ____,
+    ____, ____, ____, ____, ____, ____, ____, ____, ____, ____, ____, ____,
+};
+MOLECULE_API_DECORATOR const uint8_t MolDefault_Spawns[4]        =  {0x04, ____, ____, ____};
+MOLECULE_API_DECORATOR const uint8_t MolDefault_Data[28]         =  {
+    0x1c, ____, ____, ____, 0x10, ____, ____, ____, 0x14, ____, ____, ____,
+    0x18, ____, ____, ____, 0x04, ____, ____, ____, 0x04, ____, ____, ____,
+    0x04, ____, ____, ____,
+};
+
+#undef ____
+
+/*
+ * Reader Functions
+ */
+
+MOLECULE_API_DECORATOR mol_errno MolReader_Pipe_verify (const mol_seg_t *input, bool compatible) {
+    if (input->size < MOL_NUM_T_SIZE) {
+        return MOL_ERR_HEADER;
+    }
+    uint8_t *ptr = input->ptr;
+    mol_num_t total_size = mol_unpack_number(ptr);
+    if (input->size != total_size) {
+        return MOL_ERR_TOTAL_SIZE;
+    }
+    if (input->size < MOL_NUM_T_SIZE * 2) {
+        return MOL_ERR_HEADER;
+    }
+    ptr += MOL_NUM_T_SIZE;
+    mol_num_t offset = mol_unpack_number(ptr);
+    if (offset % 4 > 0 || offset < MOL_NUM_T_SIZE*2) {
+        return MOL_ERR_OFFSET;
+    }
+    mol_num_t field_count = offset / 4 - 1;
+    if (field_count < 3) {
+        return MOL_ERR_FIELD_COUNT;
+    } else if (!compatible && field_count > 3) {
+        return MOL_ERR_FIELD_COUNT;
+    }
+    if (input->size < MOL_NUM_T_SIZE*(field_count+1)){
+        return MOL_ERR_HEADER;
+    }
+    mol_num_t offsets[field_count+1];
+    offsets[0] = offset;
+    for (mol_num_t i=1; i<field_count; i++) {
+        ptr += MOL_NUM_T_SIZE;
+        offsets[i] = mol_unpack_number(ptr);
+        if (offsets[i-1] > offsets[i]) {
+            return MOL_ERR_OFFSET;
+        }
+    }
+    if (offsets[field_count-1] > total_size) {
+        return MOL_ERR_OFFSET;
+    }
+    offsets[field_count] = total_size;
+        mol_seg_t inner;
+        mol_errno errno;
+        inner.ptr = input->ptr + offsets[0];
+        inner.size = offsets[1] - offsets[0];
+        errno = MolReader_VmIndex_verify(&inner, compatible);
+        if (errno != MOL_OK) {
+            return MOL_ERR_DATA;
+        }
+        inner.ptr = input->ptr + offsets[1];
+        inner.size = offsets[2] - offsets[1];
+        errno = MolReader_FdIndex_verify(&inner, compatible);
+        if (errno != MOL_OK) {
+            return MOL_ERR_DATA;
+        }
+        inner.ptr = input->ptr + offsets[2];
+        inner.size = offsets[3] - offsets[2];
+        errno = MolReader_FdIndex_verify(&inner, compatible);
+        if (errno != MOL_OK) {
+            return MOL_ERR_DATA;
+        }
+    return MOL_OK;
+}
+MOLECULE_API_DECORATOR mol_errno MolReader_Pipes_verify (const mol_seg_t *input, bool compatible) {
+    if (input->size < MOL_NUM_T_SIZE) {
+        return MOL_ERR_HEADER;
+    }
+    uint8_t *ptr = input->ptr;
+    mol_num_t total_size = mol_unpack_number(ptr);
+    if (input->size != total_size) {
+        return MOL_ERR_TOTAL_SIZE;
+    }
+    if (input->size == MOL_NUM_T_SIZE) {
+        return MOL_OK;
+    }
+    if (input->size < MOL_NUM_T_SIZE * 2) {
+        return MOL_ERR_HEADER;
+    }
+    ptr += MOL_NUM_T_SIZE;
+    mol_num_t offset = mol_unpack_number(ptr);
+    if (offset % 4 > 0 || offset < MOL_NUM_T_SIZE*2) {
+        return MOL_ERR_OFFSET;
+    }
+    mol_num_t item_count = offset / 4 - 1;
+    if (input->size < MOL_NUM_T_SIZE*(item_count+1)) {
+        return MOL_ERR_HEADER;
+    }
+    mol_num_t end;
+    for (mol_num_t i=1; i<item_count; i++) {
+        ptr += MOL_NUM_T_SIZE;
+        end = mol_unpack_number(ptr);
+        if (offset > end) {
+            return MOL_ERR_OFFSET;
+        }
+        mol_seg_t inner;
+        inner.ptr = input->ptr + offset;
+        inner.size = end - offset;
+        mol_errno errno = MolReader_Pipe_verify(&inner, compatible);
+        if (errno != MOL_OK) {
+            return MOL_ERR_DATA;
+        }
+        offset = end;
+    }
+    if (offset > total_size) {
+        return MOL_ERR_OFFSET;
+    }
+    mol_seg_t inner;
+    inner.ptr = input->ptr + offset;
+    inner.size = total_size - offset;
+    return MolReader_Pipe_verify(&inner, compatible);
+}
+MOLECULE_API_DECORATOR mol_errno MolReader_Write_verify (const mol_seg_t *input, bool compatible) {
+    if (input->size < MOL_NUM_T_SIZE) {
+        return MOL_ERR_HEADER;
+    }
+    uint8_t *ptr = input->ptr;
+    mol_num_t total_size = mol_unpack_number(ptr);
+    if (input->size != total_size) {
+        return MOL_ERR_TOTAL_SIZE;
+    }
+    if (input->size < MOL_NUM_T_SIZE * 2) {
+        return MOL_ERR_HEADER;
+    }
+    ptr += MOL_NUM_T_SIZE;
+    mol_num_t offset = mol_unpack_number(ptr);
+    if (offset % 4 > 0 || offset < MOL_NUM_T_SIZE*2) {
+        return MOL_ERR_OFFSET;
+    }
+    mol_num_t field_count = offset / 4 - 1;
+    if (field_count < 5) {
+        return MOL_ERR_FIELD_COUNT;
+    } else if (!compatible && field_count > 5) {
+        return MOL_ERR_FIELD_COUNT;
+    }
+    if (input->size < MOL_NUM_T_SIZE*(field_count+1)){
+        return MOL_ERR_HEADER;
+    }
+    mol_num_t offsets[field_count+1];
+    offsets[0] = offset;
+    for (mol_num_t i=1; i<field_count; i++) {
+        ptr += MOL_NUM_T_SIZE;
+        offsets[i] = mol_unpack_number(ptr);
+        if (offsets[i-1] > offsets[i]) {
+            return MOL_ERR_OFFSET;
+        }
+    }
+    if (offsets[field_count-1] > total_size) {
+        return MOL_ERR_OFFSET;
+    }
+    offsets[field_count] = total_size;
+        mol_seg_t inner;
+        mol_errno errno;
+        inner.ptr = input->ptr + offsets[0];
+        inner.size = offsets[1] - offsets[0];
+        errno = MolReader_VmIndex_verify(&inner, compatible);
+        if (errno != MOL_OK) {
+            return MOL_ERR_DATA;
+        }
+        inner.ptr = input->ptr + offsets[1];
+        inner.size = offsets[2] - offsets[1];
+        errno = MolReader_FdIndex_verify(&inner, compatible);
+        if (errno != MOL_OK) {
+            return MOL_ERR_DATA;
+        }
+        inner.ptr = input->ptr + offsets[2];
+        inner.size = offsets[3] - offsets[2];
+        errno = MolReader_VmIndex_verify(&inner, compatible);
+        if (errno != MOL_OK) {
+            return MOL_ERR_DATA;
+        }
+        inner.ptr = input->ptr + offsets[3];
+        inner.size = offsets[4] - offsets[3];
+        errno = MolReader_FdIndex_verify(&inner, compatible);
+        if (errno != MOL_OK) {
+            return MOL_ERR_DATA;
+        }
+        inner.ptr = input->ptr + offsets[4];
+        inner.size = offsets[5] - offsets[4];
+        errno = MolReader_Bytes_verify(&inner, compatible);
+        if (errno != MOL_OK) {
+            return MOL_ERR_DATA;
+        }
+    return MOL_OK;
+}
+MOLECULE_API_DECORATOR mol_errno MolReader_Writes_verify (const mol_seg_t *input, bool compatible) {
+    if (input->size < MOL_NUM_T_SIZE) {
+        return MOL_ERR_HEADER;
+    }
+    uint8_t *ptr = input->ptr;
+    mol_num_t total_size = mol_unpack_number(ptr);
+    if (input->size != total_size) {
+        return MOL_ERR_TOTAL_SIZE;
+    }
+    if (input->size == MOL_NUM_T_SIZE) {
+        return MOL_OK;
+    }
+    if (input->size < MOL_NUM_T_SIZE * 2) {
+        return MOL_ERR_HEADER;
+    }
+    ptr += MOL_NUM_T_SIZE;
+    mol_num_t offset = mol_unpack_number(ptr);
+    if (offset % 4 > 0 || offset < MOL_NUM_T_SIZE*2) {
+        return MOL_ERR_OFFSET;
+    }
+    mol_num_t item_count = offset / 4 - 1;
+    if (input->size < MOL_NUM_T_SIZE*(item_count+1)) {
+        return MOL_ERR_HEADER;
+    }
+    mol_num_t end;
+    for (mol_num_t i=1; i<item_count; i++) {
+        ptr += MOL_NUM_T_SIZE;
+        end = mol_unpack_number(ptr);
+        if (offset > end) {
+            return MOL_ERR_OFFSET;
+        }
+        mol_seg_t inner;
+        inner.ptr = input->ptr + offset;
+        inner.size = end - offset;
+        mol_errno errno = MolReader_Write_verify(&inner, compatible);
+        if (errno != MOL_OK) {
+            return MOL_ERR_DATA;
+        }
+        offset = end;
+    }
+    if (offset > total_size) {
+        return MOL_ERR_OFFSET;
+    }
+    mol_seg_t inner;
+    inner.ptr = input->ptr + offset;
+    inner.size = total_size - offset;
+    return MolReader_Write_verify(&inner, compatible);
+}
+MOLECULE_API_DECORATOR mol_errno MolReader_Spawn_verify (const mol_seg_t *input, bool compatible) {
+    if (input->size < MOL_NUM_T_SIZE) {
+        return MOL_ERR_HEADER;
+    }
+    uint8_t *ptr = input->ptr;
+    mol_num_t total_size = mol_unpack_number(ptr);
+    if (input->size != total_size) {
+        return MOL_ERR_TOTAL_SIZE;
+    }
+    if (input->size < MOL_NUM_T_SIZE * 2) {
+        return MOL_ERR_HEADER;
+    }
+    ptr += MOL_NUM_T_SIZE;
+    mol_num_t offset = mol_unpack_number(ptr);
+    if (offset % 4 > 0 || offset < MOL_NUM_T_SIZE*2) {
+        return MOL_ERR_OFFSET;
+    }
+    mol_num_t field_count = offset / 4 - 1;
+    if (field_count < 3) {
+        return MOL_ERR_FIELD_COUNT;
+    } else if (!compatible && field_count > 3) {
+        return MOL_ERR_FIELD_COUNT;
+    }
+    if (input->size < MOL_NUM_T_SIZE*(field_count+1)){
+        return MOL_ERR_HEADER;
+    }
+    mol_num_t offsets[field_count+1];
+    offsets[0] = offset;
+    for (mol_num_t i=1; i<field_count; i++) {
+        ptr += MOL_NUM_T_SIZE;
+        offsets[i] = mol_unpack_number(ptr);
+        if (offsets[i-1] > offsets[i]) {
+            return MOL_ERR_OFFSET;
+        }
+    }
+    if (offsets[field_count-1] > total_size) {
+        return MOL_ERR_OFFSET;
+    }
+    offsets[field_count] = total_size;
+        mol_seg_t inner;
+        mol_errno errno;
+        inner.ptr = input->ptr + offsets[0];
+        inner.size = offsets[1] - offsets[0];
+        errno = MolReader_VmIndex_verify(&inner, compatible);
+        if (errno != MOL_OK) {
+            return MOL_ERR_DATA;
+        }
+        inner.ptr = input->ptr + offsets[1];
+        inner.size = offsets[2] - offsets[1];
+        errno = MolReader_VmIndex_verify(&inner, compatible);
+        if (errno != MOL_OK) {
+            return MOL_ERR_DATA;
+        }
+        inner.ptr = input->ptr + offsets[2];
+        inner.size = offsets[3] - offsets[2];
+        errno = MolReader_FdIndices_verify(&inner, compatible);
+        if (errno != MOL_OK) {
+            return MOL_ERR_DATA;
+        }
+    return MOL_OK;
+}
+MOLECULE_API_DECORATOR mol_errno MolReader_Spawns_verify (const mol_seg_t *input, bool compatible) {
+    if (input->size < MOL_NUM_T_SIZE) {
+        return MOL_ERR_HEADER;
+    }
+    uint8_t *ptr = input->ptr;
+    mol_num_t total_size = mol_unpack_number(ptr);
+    if (input->size != total_size) {
+        return MOL_ERR_TOTAL_SIZE;
+    }
+    if (input->size == MOL_NUM_T_SIZE) {
+        return MOL_OK;
+    }
+    if (input->size < MOL_NUM_T_SIZE * 2) {
+        return MOL_ERR_HEADER;
+    }
+    ptr += MOL_NUM_T_SIZE;
+    mol_num_t offset = mol_unpack_number(ptr);
+    if (offset % 4 > 0 || offset < MOL_NUM_T_SIZE*2) {
+        return MOL_ERR_OFFSET;
+    }
+    mol_num_t item_count = offset / 4 - 1;
+    if (input->size < MOL_NUM_T_SIZE*(item_count+1)) {
+        return MOL_ERR_HEADER;
+    }
+    mol_num_t end;
+    for (mol_num_t i=1; i<item_count; i++) {
+        ptr += MOL_NUM_T_SIZE;
+        end = mol_unpack_number(ptr);
+        if (offset > end) {
+            return MOL_ERR_OFFSET;
+        }
+        mol_seg_t inner;
+        inner.ptr = input->ptr + offset;
+        inner.size = end - offset;
+        mol_errno errno = MolReader_Spawn_verify(&inner, compatible);
+        if (errno != MOL_OK) {
+            return MOL_ERR_DATA;
+        }
+        offset = end;
+    }
+    if (offset > total_size) {
+        return MOL_ERR_OFFSET;
+    }
+    mol_seg_t inner;
+    inner.ptr = input->ptr + offset;
+    inner.size = total_size - offset;
+    return MolReader_Spawn_verify(&inner, compatible);
+}
+MOLECULE_API_DECORATOR mol_errno MolReader_Data_verify (const mol_seg_t *input, bool compatible) {
+    if (input->size < MOL_NUM_T_SIZE) {
+        return MOL_ERR_HEADER;
+    }
+    uint8_t *ptr = input->ptr;
+    mol_num_t total_size = mol_unpack_number(ptr);
+    if (input->size != total_size) {
+        return MOL_ERR_TOTAL_SIZE;
+    }
+    if (input->size < MOL_NUM_T_SIZE * 2) {
+        return MOL_ERR_HEADER;
+    }
+    ptr += MOL_NUM_T_SIZE;
+    mol_num_t offset = mol_unpack_number(ptr);
+    if (offset % 4 > 0 || offset < MOL_NUM_T_SIZE*2) {
+        return MOL_ERR_OFFSET;
+    }
+    mol_num_t field_count = offset / 4 - 1;
+    if (field_count < 3) {
+        return MOL_ERR_FIELD_COUNT;
+    } else if (!compatible && field_count > 3) {
+        return MOL_ERR_FIELD_COUNT;
+    }
+    if (input->size < MOL_NUM_T_SIZE*(field_count+1)){
+        return MOL_ERR_HEADER;
+    }
+    mol_num_t offsets[field_count+1];
+    offsets[0] = offset;
+    for (mol_num_t i=1; i<field_count; i++) {
+        ptr += MOL_NUM_T_SIZE;
+        offsets[i] = mol_unpack_number(ptr);
+        if (offsets[i-1] > offsets[i]) {
+            return MOL_ERR_OFFSET;
+        }
+    }
+    if (offsets[field_count-1] > total_size) {
+        return MOL_ERR_OFFSET;
+    }
+    offsets[field_count] = total_size;
+        mol_seg_t inner;
+        mol_errno errno;
+        inner.ptr = input->ptr + offsets[0];
+        inner.size = offsets[1] - offsets[0];
+        errno = MolReader_Spawns_verify(&inner, compatible);
+        if (errno != MOL_OK) {
+            return MOL_ERR_DATA;
+        }
+        inner.ptr = input->ptr + offsets[1];
+        inner.size = offsets[2] - offsets[1];
+        errno = MolReader_Pipes_verify(&inner, compatible);
+        if (errno != MOL_OK) {
+            return MOL_ERR_DATA;
+        }
+        inner.ptr = input->ptr + offsets[2];
+        inner.size = offsets[3] - offsets[2];
+        errno = MolReader_Writes_verify(&inner, compatible);
+        if (errno != MOL_OK) {
+            return MOL_ERR_DATA;
+        }
+    return MOL_OK;
+}
+
+/*
+ * Builder Functions
+ */
+
+MOLECULE_API_DECORATOR mol_seg_res_t MolBuilder_Pipe_build (mol_builder_t builder) {
+    mol_seg_res_t res;
+    res.errno = MOL_OK;
+    mol_num_t offset = 16;
+    mol_num_t len;
+    res.seg.size = offset;
+    len = builder.number_ptr[1];
+    res.seg.size += len == 0 ? 8 : len;
+    len = builder.number_ptr[3];
+    res.seg.size += len == 0 ? 8 : len;
+    len = builder.number_ptr[5];
+    res.seg.size += len == 0 ? 8 : len;
+    res.seg.ptr = (uint8_t*)malloc(res.seg.size);
+    uint8_t *dst = res.seg.ptr;
+    mol_pack_number(dst, &res.seg.size);
+    dst += MOL_NUM_T_SIZE;
+    mol_pack_number(dst, &offset);
+    dst += MOL_NUM_T_SIZE;
+    len = builder.number_ptr[1];
+    offset += len == 0 ? 8 : len;
+    mol_pack_number(dst, &offset);
+    dst += MOL_NUM_T_SIZE;
+    len = builder.number_ptr[3];
+    offset += len == 0 ? 8 : len;
+    mol_pack_number(dst, &offset);
+    dst += MOL_NUM_T_SIZE;
+    len = builder.number_ptr[5];
+    offset += len == 0 ? 8 : len;
+    uint8_t *src = builder.data_ptr;
+    len = builder.number_ptr[1];
+    if (len == 0) {
+        len = 8;
+        memcpy(dst, &MolDefault_VmIndex, len);
+    } else {
+        mol_num_t of = builder.number_ptr[0];
+        memcpy(dst, src+of, len);
+    }
+    dst += len;
+    len = builder.number_ptr[3];
+    if (len == 0) {
+        len = 8;
+        memcpy(dst, &MolDefault_FdIndex, len);
+    } else {
+        mol_num_t of = builder.number_ptr[2];
+        memcpy(dst, src+of, len);
+    }
+    dst += len;
+    len = builder.number_ptr[5];
+    if (len == 0) {
+        len = 8;
+        memcpy(dst, &MolDefault_FdIndex, len);
+    } else {
+        mol_num_t of = builder.number_ptr[4];
+        memcpy(dst, src+of, len);
+    }
+    dst += len;
+    mol_builder_discard(builder);
+    return res;
+}
+MOLECULE_API_DECORATOR mol_seg_res_t MolBuilder_Write_build (mol_builder_t builder) {
+    mol_seg_res_t res;
+    res.errno = MOL_OK;
+    mol_num_t offset = 24;
+    mol_num_t len;
+    res.seg.size = offset;
+    len = builder.number_ptr[1];
+    res.seg.size += len == 0 ? 8 : len;
+    len = builder.number_ptr[3];
+    res.seg.size += len == 0 ? 8 : len;
+    len = builder.number_ptr[5];
+    res.seg.size += len == 0 ? 8 : len;
+    len = builder.number_ptr[7];
+    res.seg.size += len == 0 ? 8 : len;
+    len = builder.number_ptr[9];
+    res.seg.size += len == 0 ? 4 : len;
+    res.seg.ptr = (uint8_t*)malloc(res.seg.size);
+    uint8_t *dst = res.seg.ptr;
+    mol_pack_number(dst, &res.seg.size);
+    dst += MOL_NUM_T_SIZE;
+    mol_pack_number(dst, &offset);
+    dst += MOL_NUM_T_SIZE;
+    len = builder.number_ptr[1];
+    offset += len == 0 ? 8 : len;
+    mol_pack_number(dst, &offset);
+    dst += MOL_NUM_T_SIZE;
+    len = builder.number_ptr[3];
+    offset += len == 0 ? 8 : len;
+    mol_pack_number(dst, &offset);
+    dst += MOL_NUM_T_SIZE;
+    len = builder.number_ptr[5];
+    offset += len == 0 ? 8 : len;
+    mol_pack_number(dst, &offset);
+    dst += MOL_NUM_T_SIZE;
+    len = builder.number_ptr[7];
+    offset += len == 0 ? 8 : len;
+    mol_pack_number(dst, &offset);
+    dst += MOL_NUM_T_SIZE;
+    len = builder.number_ptr[9];
+    offset += len == 0 ? 4 : len;
+    uint8_t *src = builder.data_ptr;
+    len = builder.number_ptr[1];
+    if (len == 0) {
+        len = 8;
+        memcpy(dst, &MolDefault_VmIndex, len);
+    } else {
+        mol_num_t of = builder.number_ptr[0];
+        memcpy(dst, src+of, len);
+    }
+    dst += len;
+    len = builder.number_ptr[3];
+    if (len == 0) {
+        len = 8;
+        memcpy(dst, &MolDefault_FdIndex, len);
+    } else {
+        mol_num_t of = builder.number_ptr[2];
+        memcpy(dst, src+of, len);
+    }
+    dst += len;
+    len = builder.number_ptr[5];
+    if (len == 0) {
+        len = 8;
+        memcpy(dst, &MolDefault_VmIndex, len);
+    } else {
+        mol_num_t of = builder.number_ptr[4];
+        memcpy(dst, src+of, len);
+    }
+    dst += len;
+    len = builder.number_ptr[7];
+    if (len == 0) {
+        len = 8;
+        memcpy(dst, &MolDefault_FdIndex, len);
+    } else {
+        mol_num_t of = builder.number_ptr[6];
+        memcpy(dst, src+of, len);
+    }
+    dst += len;
+    len = builder.number_ptr[9];
+    if (len == 0) {
+        len = 4;
+        memcpy(dst, &MolDefault_Bytes, len);
+    } else {
+        mol_num_t of = builder.number_ptr[8];
+        memcpy(dst, src+of, len);
+    }
+    dst += len;
+    mol_builder_discard(builder);
+    return res;
+}
+MOLECULE_API_DECORATOR mol_seg_res_t MolBuilder_Spawn_build (mol_builder_t builder) {
+    mol_seg_res_t res;
+    res.errno = MOL_OK;
+    mol_num_t offset = 16;
+    mol_num_t len;
+    res.seg.size = offset;
+    len = builder.number_ptr[1];
+    res.seg.size += len == 0 ? 8 : len;
+    len = builder.number_ptr[3];
+    res.seg.size += len == 0 ? 8 : len;
+    len = builder.number_ptr[5];
+    res.seg.size += len == 0 ? 4 : len;
+    res.seg.ptr = (uint8_t*)malloc(res.seg.size);
+    uint8_t *dst = res.seg.ptr;
+    mol_pack_number(dst, &res.seg.size);
+    dst += MOL_NUM_T_SIZE;
+    mol_pack_number(dst, &offset);
+    dst += MOL_NUM_T_SIZE;
+    len = builder.number_ptr[1];
+    offset += len == 0 ? 8 : len;
+    mol_pack_number(dst, &offset);
+    dst += MOL_NUM_T_SIZE;
+    len = builder.number_ptr[3];
+    offset += len == 0 ? 8 : len;
+    mol_pack_number(dst, &offset);
+    dst += MOL_NUM_T_SIZE;
+    len = builder.number_ptr[5];
+    offset += len == 0 ? 4 : len;
+    uint8_t *src = builder.data_ptr;
+    len = builder.number_ptr[1];
+    if (len == 0) {
+        len = 8;
+        memcpy(dst, &MolDefault_VmIndex, len);
+    } else {
+        mol_num_t of = builder.number_ptr[0];
+        memcpy(dst, src+of, len);
+    }
+    dst += len;
+    len = builder.number_ptr[3];
+    if (len == 0) {
+        len = 8;
+        memcpy(dst, &MolDefault_VmIndex, len);
+    } else {
+        mol_num_t of = builder.number_ptr[2];
+        memcpy(dst, src+of, len);
+    }
+    dst += len;
+    len = builder.number_ptr[5];
+    if (len == 0) {
+        len = 4;
+        memcpy(dst, &MolDefault_FdIndices, len);
+    } else {
+        mol_num_t of = builder.number_ptr[4];
+        memcpy(dst, src+of, len);
+    }
+    dst += len;
+    mol_builder_discard(builder);
+    return res;
+}
+MOLECULE_API_DECORATOR mol_seg_res_t MolBuilder_Data_build (mol_builder_t builder) {
+    mol_seg_res_t res;
+    res.errno = MOL_OK;
+    mol_num_t offset = 16;
+    mol_num_t len;
+    res.seg.size = offset;
+    len = builder.number_ptr[1];
+    res.seg.size += len == 0 ? 4 : len;
+    len = builder.number_ptr[3];
+    res.seg.size += len == 0 ? 4 : len;
+    len = builder.number_ptr[5];
+    res.seg.size += len == 0 ? 4 : len;
+    res.seg.ptr = (uint8_t*)malloc(res.seg.size);
+    uint8_t *dst = res.seg.ptr;
+    mol_pack_number(dst, &res.seg.size);
+    dst += MOL_NUM_T_SIZE;
+    mol_pack_number(dst, &offset);
+    dst += MOL_NUM_T_SIZE;
+    len = builder.number_ptr[1];
+    offset += len == 0 ? 4 : len;
+    mol_pack_number(dst, &offset);
+    dst += MOL_NUM_T_SIZE;
+    len = builder.number_ptr[3];
+    offset += len == 0 ? 4 : len;
+    mol_pack_number(dst, &offset);
+    dst += MOL_NUM_T_SIZE;
+    len = builder.number_ptr[5];
+    offset += len == 0 ? 4 : len;
+    uint8_t *src = builder.data_ptr;
+    len = builder.number_ptr[1];
+    if (len == 0) {
+        len = 4;
+        memcpy(dst, &MolDefault_Spawns, len);
+    } else {
+        mol_num_t of = builder.number_ptr[0];
+        memcpy(dst, src+of, len);
+    }
+    dst += len;
+    len = builder.number_ptr[3];
+    if (len == 0) {
+        len = 4;
+        memcpy(dst, &MolDefault_Pipes, len);
+    } else {
+        mol_num_t of = builder.number_ptr[2];
+        memcpy(dst, src+of, len);
+    }
+    dst += len;
+    len = builder.number_ptr[5];
+    if (len == 0) {
+        len = 4;
+        memcpy(dst, &MolDefault_Writes, len);
+    } else {
+        mol_num_t of = builder.number_ptr[4];
+        memcpy(dst, src+of, len);
+    }
+    dst += len;
+    mol_builder_discard(builder);
+    return res;
+}
+
+#ifdef __DEFINE_MOLECULE_API_DECORATOR_SPAWN_DAG
+#undef MOLECULE_API_DECORATOR
+#undef __DEFINE_MOLECULE_API_DECORATOR_SPAWN_DAG
+#endif /* __DEFINE_MOLECULE_API_DECORATOR_SPAWN_DAG */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* SPAWN_DAG_H */
diff --git a/script/testdata/spawn_dag.mol b/script/testdata/spawn_dag.mol
new file mode 100644
index 0000000000..0e4c9fab1b
--- /dev/null
+++ b/script/testdata/spawn_dag.mol
@@ -0,0 +1,34 @@
+array VmIndex [byte; 8];
+array FdIndex [byte; 8];
+
+vector FdIndices <FdIndex>;
+vector Bytes <byte>;
+
+table Pipe {
+  vm: VmIndex,
+  read_fd: FdIndex,
+  write_fd: FdIndex,
+}
+vector Pipes <Pipe>;
+
+table Write {
+  from: VmIndex,
+  from_fd: FdIndex,
+  to: VmIndex,
+  to_fd: FdIndex,
+  data: Bytes,
+}
+vector Writes <Write>;
+
+table Spawn {
+  from: VmIndex,
+  child: VmIndex,
+  fds: FdIndices,
+}
+vector Spawns <Spawn>;
+
+table Data {
+  spawns: Spawns,
+  pipes: Pipes,
+  writes: Writes,
+}
diff --git a/script/testdata/spawn_dag.rs b/script/testdata/spawn_dag.rs
new file mode 100644
index 0000000000..f3a20a27c5
--- /dev/null
+++ b/script/testdata/spawn_dag.rs
@@ -0,0 +1,3416 @@
+// Generated by Molecule 0.8.0
+#![allow(clippy::needless_lifetimes)]
+#![allow(clippy::needless_borrow)]
+#![allow(clippy::wrong_self_convention)]
+#![allow(clippy::if_same_then_else)]
+#![allow(clippy::derivable_impls)]
+#![allow(clippy::useless_conversion)]
+#![allow(clippy::write_literal)]
+#![allow(clippy::clone_on_copy)]
+#![allow(clippy::fallible_impl_from)]
+use molecule::prelude::*;
+#[derive(Clone)]
+pub struct VmIndex(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for VmIndex {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for VmIndex {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for VmIndex {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        let raw_data = hex_string(&self.raw_data());
+        write!(f, "{}(0x{})", Self::NAME, raw_data)
+    }
+}
+impl ::core::default::Default for VmIndex {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        VmIndex::new_unchecked(v)
+    }
+}
+impl VmIndex {
+    const DEFAULT_VALUE: [u8; 8] = [0, 0, 0, 0, 0, 0, 0, 0];
+    pub const TOTAL_SIZE: usize = 8;
+    pub const ITEM_SIZE: usize = 1;
+    pub const ITEM_COUNT: usize = 8;
+    pub fn nth0(&self) -> Byte {
+        Byte::new_unchecked(self.0.slice(0..1))
+    }
+    pub fn nth1(&self) -> Byte {
+        Byte::new_unchecked(self.0.slice(1..2))
+    }
+    pub fn nth2(&self) -> Byte {
+        Byte::new_unchecked(self.0.slice(2..3))
+    }
+    pub fn nth3(&self) -> Byte {
+        Byte::new_unchecked(self.0.slice(3..4))
+    }
+    pub fn nth4(&self) -> Byte {
+        Byte::new_unchecked(self.0.slice(4..5))
+    }
+    pub fn nth5(&self) -> Byte {
+        Byte::new_unchecked(self.0.slice(5..6))
+    }
+    pub fn nth6(&self) -> Byte {
+        Byte::new_unchecked(self.0.slice(6..7))
+    }
+    pub fn nth7(&self) -> Byte {
+        Byte::new_unchecked(self.0.slice(7..8))
+    }
+    pub fn raw_data(&self) -> molecule::bytes::Bytes {
+        self.as_bytes()
+    }
+    pub fn as_reader<'r>(&'r self) -> VmIndexReader<'r> {
+        VmIndexReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for VmIndex {
+    type Builder = VmIndexBuilder;
+    const NAME: &'static str = "VmIndex";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        VmIndex(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        VmIndexReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        VmIndexReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder().set([
+            self.nth0(),
+            self.nth1(),
+            self.nth2(),
+            self.nth3(),
+            self.nth4(),
+            self.nth5(),
+            self.nth6(),
+            self.nth7(),
+        ])
+    }
+}
+#[derive(Clone, Copy)]
+pub struct VmIndexReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for VmIndexReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for VmIndexReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for VmIndexReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        let raw_data = hex_string(&self.raw_data());
+        write!(f, "{}(0x{})", Self::NAME, raw_data)
+    }
+}
+impl<'r> VmIndexReader<'r> {
+    pub const TOTAL_SIZE: usize = 8;
+    pub const ITEM_SIZE: usize = 1;
+    pub const ITEM_COUNT: usize = 8;
+    pub fn nth0(&self) -> ByteReader<'r> {
+        ByteReader::new_unchecked(&self.as_slice()[0..1])
+    }
+    pub fn nth1(&self) -> ByteReader<'r> {
+        ByteReader::new_unchecked(&self.as_slice()[1..2])
+    }
+    pub fn nth2(&self) -> ByteReader<'r> {
+        ByteReader::new_unchecked(&self.as_slice()[2..3])
+    }
+    pub fn nth3(&self) -> ByteReader<'r> {
+        ByteReader::new_unchecked(&self.as_slice()[3..4])
+    }
+    pub fn nth4(&self) -> ByteReader<'r> {
+        ByteReader::new_unchecked(&self.as_slice()[4..5])
+    }
+    pub fn nth5(&self) -> ByteReader<'r> {
+        ByteReader::new_unchecked(&self.as_slice()[5..6])
+    }
+    pub fn nth6(&self) -> ByteReader<'r> {
+        ByteReader::new_unchecked(&self.as_slice()[6..7])
+    }
+    pub fn nth7(&self) -> ByteReader<'r> {
+        ByteReader::new_unchecked(&self.as_slice()[7..8])
+    }
+    pub fn raw_data(&self) -> &'r [u8] {
+        self.as_slice()
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for VmIndexReader<'r> {
+    type Entity = VmIndex;
+    const NAME: &'static str = "VmIndexReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        VmIndexReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], _compatible: bool) -> molecule::error::VerificationResult<()> {
+        use molecule::verification_error as ve;
+        let slice_len = slice.len();
+        if slice_len != Self::TOTAL_SIZE {
+            return ve!(Self, TotalSizeNotMatch, Self::TOTAL_SIZE, slice_len);
+        }
+        Ok(())
+    }
+}
+#[derive(Clone)]
+pub struct VmIndexBuilder(pub(crate) [Byte; 8]);
+impl ::core::fmt::Debug for VmIndexBuilder {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:?})", Self::NAME, &self.0[..])
+    }
+}
+impl ::core::default::Default for VmIndexBuilder {
+    fn default() -> Self {
+        VmIndexBuilder([
+            Byte::default(),
+            Byte::default(),
+            Byte::default(),
+            Byte::default(),
+            Byte::default(),
+            Byte::default(),
+            Byte::default(),
+            Byte::default(),
+        ])
+    }
+}
+impl VmIndexBuilder {
+    pub const TOTAL_SIZE: usize = 8;
+    pub const ITEM_SIZE: usize = 1;
+    pub const ITEM_COUNT: usize = 8;
+    pub fn set(mut self, v: [Byte; 8]) -> Self {
+        self.0 = v;
+        self
+    }
+    pub fn nth0(mut self, v: Byte) -> Self {
+        self.0[0] = v;
+        self
+    }
+    pub fn nth1(mut self, v: Byte) -> Self {
+        self.0[1] = v;
+        self
+    }
+    pub fn nth2(mut self, v: Byte) -> Self {
+        self.0[2] = v;
+        self
+    }
+    pub fn nth3(mut self, v: Byte) -> Self {
+        self.0[3] = v;
+        self
+    }
+    pub fn nth4(mut self, v: Byte) -> Self {
+        self.0[4] = v;
+        self
+    }
+    pub fn nth5(mut self, v: Byte) -> Self {
+        self.0[5] = v;
+        self
+    }
+    pub fn nth6(mut self, v: Byte) -> Self {
+        self.0[6] = v;
+        self
+    }
+    pub fn nth7(mut self, v: Byte) -> Self {
+        self.0[7] = v;
+        self
+    }
+}
+impl molecule::prelude::Builder for VmIndexBuilder {
+    type Entity = VmIndex;
+    const NAME: &'static str = "VmIndexBuilder";
+    fn expected_length(&self) -> usize {
+        Self::TOTAL_SIZE
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        writer.write_all(self.0[0].as_slice())?;
+        writer.write_all(self.0[1].as_slice())?;
+        writer.write_all(self.0[2].as_slice())?;
+        writer.write_all(self.0[3].as_slice())?;
+        writer.write_all(self.0[4].as_slice())?;
+        writer.write_all(self.0[5].as_slice())?;
+        writer.write_all(self.0[6].as_slice())?;
+        writer.write_all(self.0[7].as_slice())?;
+        Ok(())
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        VmIndex::new_unchecked(inner.into())
+    }
+}
+impl From<[Byte; 8usize]> for VmIndex {
+    fn from(value: [Byte; 8usize]) -> Self {
+        Self::new_builder().set(value).build()
+    }
+}
+impl ::core::convert::TryFrom<&[Byte]> for VmIndex {
+    type Error = ::core::array::TryFromSliceError;
+    fn try_from(value: &[Byte]) -> Result<Self, ::core::array::TryFromSliceError> {
+        Ok(Self::new_builder()
+            .set(<&[Byte; 8usize]>::try_from(value)?.clone())
+            .build())
+    }
+}
+impl From<VmIndex> for [Byte; 8usize] {
+    #[track_caller]
+    fn from(value: VmIndex) -> Self {
+        [
+            value.nth0(),
+            value.nth1(),
+            value.nth2(),
+            value.nth3(),
+            value.nth4(),
+            value.nth5(),
+            value.nth6(),
+            value.nth7(),
+        ]
+    }
+}
+impl From<[u8; 8usize]> for VmIndex {
+    fn from(value: [u8; 8usize]) -> Self {
+        VmIndexReader::new_unchecked(&value).to_entity()
+    }
+}
+impl ::core::convert::TryFrom<&[u8]> for VmIndex {
+    type Error = ::core::array::TryFromSliceError;
+    fn try_from(value: &[u8]) -> Result<Self, ::core::array::TryFromSliceError> {
+        Ok(<[u8; 8usize]>::try_from(value)?.into())
+    }
+}
+impl From<VmIndex> for [u8; 8usize] {
+    #[track_caller]
+    fn from(value: VmIndex) -> Self {
+        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
+    }
+}
+impl<'a> From<VmIndexReader<'a>> for &'a [u8; 8usize] {
+    #[track_caller]
+    fn from(value: VmIndexReader<'a>) -> Self {
+        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
+    }
+}
+impl<'a> From<&'a VmIndexReader<'a>> for &'a [u8; 8usize] {
+    #[track_caller]
+    fn from(value: &'a VmIndexReader<'a>) -> Self {
+        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
+    }
+}
+#[derive(Clone)]
+pub struct FdIndex(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for FdIndex {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for FdIndex {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for FdIndex {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        let raw_data = hex_string(&self.raw_data());
+        write!(f, "{}(0x{})", Self::NAME, raw_data)
+    }
+}
+impl ::core::default::Default for FdIndex {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        FdIndex::new_unchecked(v)
+    }
+}
+impl FdIndex {
+    const DEFAULT_VALUE: [u8; 8] = [0, 0, 0, 0, 0, 0, 0, 0];
+    pub const TOTAL_SIZE: usize = 8;
+    pub const ITEM_SIZE: usize = 1;
+    pub const ITEM_COUNT: usize = 8;
+    pub fn nth0(&self) -> Byte {
+        Byte::new_unchecked(self.0.slice(0..1))
+    }
+    pub fn nth1(&self) -> Byte {
+        Byte::new_unchecked(self.0.slice(1..2))
+    }
+    pub fn nth2(&self) -> Byte {
+        Byte::new_unchecked(self.0.slice(2..3))
+    }
+    pub fn nth3(&self) -> Byte {
+        Byte::new_unchecked(self.0.slice(3..4))
+    }
+    pub fn nth4(&self) -> Byte {
+        Byte::new_unchecked(self.0.slice(4..5))
+    }
+    pub fn nth5(&self) -> Byte {
+        Byte::new_unchecked(self.0.slice(5..6))
+    }
+    pub fn nth6(&self) -> Byte {
+        Byte::new_unchecked(self.0.slice(6..7))
+    }
+    pub fn nth7(&self) -> Byte {
+        Byte::new_unchecked(self.0.slice(7..8))
+    }
+    pub fn raw_data(&self) -> molecule::bytes::Bytes {
+        self.as_bytes()
+    }
+    pub fn as_reader<'r>(&'r self) -> FdIndexReader<'r> {
+        FdIndexReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for FdIndex {
+    type Builder = FdIndexBuilder;
+    const NAME: &'static str = "FdIndex";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        FdIndex(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        FdIndexReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        FdIndexReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder().set([
+            self.nth0(),
+            self.nth1(),
+            self.nth2(),
+            self.nth3(),
+            self.nth4(),
+            self.nth5(),
+            self.nth6(),
+            self.nth7(),
+        ])
+    }
+}
+#[derive(Clone, Copy)]
+pub struct FdIndexReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for FdIndexReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for FdIndexReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for FdIndexReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        let raw_data = hex_string(&self.raw_data());
+        write!(f, "{}(0x{})", Self::NAME, raw_data)
+    }
+}
+impl<'r> FdIndexReader<'r> {
+    pub const TOTAL_SIZE: usize = 8;
+    pub const ITEM_SIZE: usize = 1;
+    pub const ITEM_COUNT: usize = 8;
+    pub fn nth0(&self) -> ByteReader<'r> {
+        ByteReader::new_unchecked(&self.as_slice()[0..1])
+    }
+    pub fn nth1(&self) -> ByteReader<'r> {
+        ByteReader::new_unchecked(&self.as_slice()[1..2])
+    }
+    pub fn nth2(&self) -> ByteReader<'r> {
+        ByteReader::new_unchecked(&self.as_slice()[2..3])
+    }
+    pub fn nth3(&self) -> ByteReader<'r> {
+        ByteReader::new_unchecked(&self.as_slice()[3..4])
+    }
+    pub fn nth4(&self) -> ByteReader<'r> {
+        ByteReader::new_unchecked(&self.as_slice()[4..5])
+    }
+    pub fn nth5(&self) -> ByteReader<'r> {
+        ByteReader::new_unchecked(&self.as_slice()[5..6])
+    }
+    pub fn nth6(&self) -> ByteReader<'r> {
+        ByteReader::new_unchecked(&self.as_slice()[6..7])
+    }
+    pub fn nth7(&self) -> ByteReader<'r> {
+        ByteReader::new_unchecked(&self.as_slice()[7..8])
+    }
+    pub fn raw_data(&self) -> &'r [u8] {
+        self.as_slice()
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for FdIndexReader<'r> {
+    type Entity = FdIndex;
+    const NAME: &'static str = "FdIndexReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        FdIndexReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], _compatible: bool) -> molecule::error::VerificationResult<()> {
+        use molecule::verification_error as ve;
+        let slice_len = slice.len();
+        if slice_len != Self::TOTAL_SIZE {
+            return ve!(Self, TotalSizeNotMatch, Self::TOTAL_SIZE, slice_len);
+        }
+        Ok(())
+    }
+}
+#[derive(Clone)]
+pub struct FdIndexBuilder(pub(crate) [Byte; 8]);
+impl ::core::fmt::Debug for FdIndexBuilder {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:?})", Self::NAME, &self.0[..])
+    }
+}
+impl ::core::default::Default for FdIndexBuilder {
+    fn default() -> Self {
+        FdIndexBuilder([
+            Byte::default(),
+            Byte::default(),
+            Byte::default(),
+            Byte::default(),
+            Byte::default(),
+            Byte::default(),
+            Byte::default(),
+            Byte::default(),
+        ])
+    }
+}
+impl FdIndexBuilder {
+    pub const TOTAL_SIZE: usize = 8;
+    pub const ITEM_SIZE: usize = 1;
+    pub const ITEM_COUNT: usize = 8;
+    pub fn set(mut self, v: [Byte; 8]) -> Self {
+        self.0 = v;
+        self
+    }
+    pub fn nth0(mut self, v: Byte) -> Self {
+        self.0[0] = v;
+        self
+    }
+    pub fn nth1(mut self, v: Byte) -> Self {
+        self.0[1] = v;
+        self
+    }
+    pub fn nth2(mut self, v: Byte) -> Self {
+        self.0[2] = v;
+        self
+    }
+    pub fn nth3(mut self, v: Byte) -> Self {
+        self.0[3] = v;
+        self
+    }
+    pub fn nth4(mut self, v: Byte) -> Self {
+        self.0[4] = v;
+        self
+    }
+    pub fn nth5(mut self, v: Byte) -> Self {
+        self.0[5] = v;
+        self
+    }
+    pub fn nth6(mut self, v: Byte) -> Self {
+        self.0[6] = v;
+        self
+    }
+    pub fn nth7(mut self, v: Byte) -> Self {
+        self.0[7] = v;
+        self
+    }
+}
+impl molecule::prelude::Builder for FdIndexBuilder {
+    type Entity = FdIndex;
+    const NAME: &'static str = "FdIndexBuilder";
+    fn expected_length(&self) -> usize {
+        Self::TOTAL_SIZE
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        writer.write_all(self.0[0].as_slice())?;
+        writer.write_all(self.0[1].as_slice())?;
+        writer.write_all(self.0[2].as_slice())?;
+        writer.write_all(self.0[3].as_slice())?;
+        writer.write_all(self.0[4].as_slice())?;
+        writer.write_all(self.0[5].as_slice())?;
+        writer.write_all(self.0[6].as_slice())?;
+        writer.write_all(self.0[7].as_slice())?;
+        Ok(())
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        FdIndex::new_unchecked(inner.into())
+    }
+}
+impl From<[Byte; 8usize]> for FdIndex {
+    fn from(value: [Byte; 8usize]) -> Self {
+        Self::new_builder().set(value).build()
+    }
+}
+impl ::core::convert::TryFrom<&[Byte]> for FdIndex {
+    type Error = ::core::array::TryFromSliceError;
+    fn try_from(value: &[Byte]) -> Result<Self, ::core::array::TryFromSliceError> {
+        Ok(Self::new_builder()
+            .set(<&[Byte; 8usize]>::try_from(value)?.clone())
+            .build())
+    }
+}
+impl From<FdIndex> for [Byte; 8usize] {
+    #[track_caller]
+    fn from(value: FdIndex) -> Self {
+        [
+            value.nth0(),
+            value.nth1(),
+            value.nth2(),
+            value.nth3(),
+            value.nth4(),
+            value.nth5(),
+            value.nth6(),
+            value.nth7(),
+        ]
+    }
+}
+impl From<[u8; 8usize]> for FdIndex {
+    fn from(value: [u8; 8usize]) -> Self {
+        FdIndexReader::new_unchecked(&value).to_entity()
+    }
+}
+impl ::core::convert::TryFrom<&[u8]> for FdIndex {
+    type Error = ::core::array::TryFromSliceError;
+    fn try_from(value: &[u8]) -> Result<Self, ::core::array::TryFromSliceError> {
+        Ok(<[u8; 8usize]>::try_from(value)?.into())
+    }
+}
+impl From<FdIndex> for [u8; 8usize] {
+    #[track_caller]
+    fn from(value: FdIndex) -> Self {
+        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
+    }
+}
+impl<'a> From<FdIndexReader<'a>> for &'a [u8; 8usize] {
+    #[track_caller]
+    fn from(value: FdIndexReader<'a>) -> Self {
+        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
+    }
+}
+impl<'a> From<&'a FdIndexReader<'a>> for &'a [u8; 8usize] {
+    #[track_caller]
+    fn from(value: &'a FdIndexReader<'a>) -> Self {
+        ::core::convert::TryFrom::try_from(value.as_slice()).unwrap()
+    }
+}
+#[derive(Clone)]
+pub struct FdIndices(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for FdIndices {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for FdIndices {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for FdIndices {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} [", Self::NAME)?;
+        for i in 0..self.len() {
+            if i == 0 {
+                write!(f, "{}", self.get_unchecked(i))?;
+            } else {
+                write!(f, ", {}", self.get_unchecked(i))?;
+            }
+        }
+        write!(f, "]")
+    }
+}
+impl ::core::default::Default for FdIndices {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        FdIndices::new_unchecked(v)
+    }
+}
+impl FdIndices {
+    const DEFAULT_VALUE: [u8; 4] = [0, 0, 0, 0];
+    pub const ITEM_SIZE: usize = 8;
+    pub fn total_size(&self) -> usize {
+        molecule::NUMBER_SIZE + Self::ITEM_SIZE * self.item_count()
+    }
+    pub fn item_count(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn len(&self) -> usize {
+        self.item_count()
+    }
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    pub fn get(&self, idx: usize) -> Option<FdIndex> {
+        if idx >= self.len() {
+            None
+        } else {
+            Some(self.get_unchecked(idx))
+        }
+    }
+    pub fn get_unchecked(&self, idx: usize) -> FdIndex {
+        let start = molecule::NUMBER_SIZE + Self::ITEM_SIZE * idx;
+        let end = start + Self::ITEM_SIZE;
+        FdIndex::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn as_reader<'r>(&'r self) -> FdIndicesReader<'r> {
+        FdIndicesReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for FdIndices {
+    type Builder = FdIndicesBuilder;
+    const NAME: &'static str = "FdIndices";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        FdIndices(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        FdIndicesReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        FdIndicesReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder().extend(self.into_iter())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct FdIndicesReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for FdIndicesReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for FdIndicesReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for FdIndicesReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} [", Self::NAME)?;
+        for i in 0..self.len() {
+            if i == 0 {
+                write!(f, "{}", self.get_unchecked(i))?;
+            } else {
+                write!(f, ", {}", self.get_unchecked(i))?;
+            }
+        }
+        write!(f, "]")
+    }
+}
+impl<'r> FdIndicesReader<'r> {
+    pub const ITEM_SIZE: usize = 8;
+    pub fn total_size(&self) -> usize {
+        molecule::NUMBER_SIZE + Self::ITEM_SIZE * self.item_count()
+    }
+    pub fn item_count(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn len(&self) -> usize {
+        self.item_count()
+    }
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    pub fn get(&self, idx: usize) -> Option<FdIndexReader<'r>> {
+        if idx >= self.len() {
+            None
+        } else {
+            Some(self.get_unchecked(idx))
+        }
+    }
+    pub fn get_unchecked(&self, idx: usize) -> FdIndexReader<'r> {
+        let start = molecule::NUMBER_SIZE + Self::ITEM_SIZE * idx;
+        let end = start + Self::ITEM_SIZE;
+        FdIndexReader::new_unchecked(&self.as_slice()[start..end])
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for FdIndicesReader<'r> {
+    type Entity = FdIndices;
+    const NAME: &'static str = "FdIndicesReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        FdIndicesReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], _compatible: bool) -> molecule::error::VerificationResult<()> {
+        use molecule::verification_error as ve;
+        let slice_len = slice.len();
+        if slice_len < molecule::NUMBER_SIZE {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
+        }
+        let item_count = molecule::unpack_number(slice) as usize;
+        if item_count == 0 {
+            if slice_len != molecule::NUMBER_SIZE {
+                return ve!(Self, TotalSizeNotMatch, molecule::NUMBER_SIZE, slice_len);
+            }
+            return Ok(());
+        }
+        let total_size = molecule::NUMBER_SIZE + Self::ITEM_SIZE * item_count;
+        if slice_len != total_size {
+            return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
+        }
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct FdIndicesBuilder(pub(crate) Vec<FdIndex>);
+impl FdIndicesBuilder {
+    pub const ITEM_SIZE: usize = 8;
+    pub fn set(mut self, v: Vec<FdIndex>) -> Self {
+        self.0 = v;
+        self
+    }
+    pub fn push(mut self, v: FdIndex) -> Self {
+        self.0.push(v);
+        self
+    }
+    pub fn extend<T: ::core::iter::IntoIterator<Item = FdIndex>>(mut self, iter: T) -> Self {
+        for elem in iter {
+            self.0.push(elem);
+        }
+        self
+    }
+    pub fn replace(&mut self, index: usize, v: FdIndex) -> Option<FdIndex> {
+        self.0
+            .get_mut(index)
+            .map(|item| ::core::mem::replace(item, v))
+    }
+}
+impl molecule::prelude::Builder for FdIndicesBuilder {
+    type Entity = FdIndices;
+    const NAME: &'static str = "FdIndicesBuilder";
+    fn expected_length(&self) -> usize {
+        molecule::NUMBER_SIZE + Self::ITEM_SIZE * self.0.len()
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        writer.write_all(&molecule::pack_number(self.0.len() as molecule::Number))?;
+        for inner in &self.0[..] {
+            writer.write_all(inner.as_slice())?;
+        }
+        Ok(())
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        FdIndices::new_unchecked(inner.into())
+    }
+}
+pub struct FdIndicesIterator(FdIndices, usize, usize);
+impl ::core::iter::Iterator for FdIndicesIterator {
+    type Item = FdIndex;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.1 >= self.2 {
+            None
+        } else {
+            let ret = self.0.get_unchecked(self.1);
+            self.1 += 1;
+            Some(ret)
+        }
+    }
+}
+impl ::core::iter::ExactSizeIterator for FdIndicesIterator {
+    fn len(&self) -> usize {
+        self.2 - self.1
+    }
+}
+impl ::core::iter::IntoIterator for FdIndices {
+    type Item = FdIndex;
+    type IntoIter = FdIndicesIterator;
+    fn into_iter(self) -> Self::IntoIter {
+        let len = self.len();
+        FdIndicesIterator(self, 0, len)
+    }
+}
+impl<'r> FdIndicesReader<'r> {
+    pub fn iter<'t>(&'t self) -> FdIndicesReaderIterator<'t, 'r> {
+        FdIndicesReaderIterator(&self, 0, self.len())
+    }
+}
+pub struct FdIndicesReaderIterator<'t, 'r>(&'t FdIndicesReader<'r>, usize, usize);
+impl<'t: 'r, 'r> ::core::iter::Iterator for FdIndicesReaderIterator<'t, 'r> {
+    type Item = FdIndexReader<'t>;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.1 >= self.2 {
+            None
+        } else {
+            let ret = self.0.get_unchecked(self.1);
+            self.1 += 1;
+            Some(ret)
+        }
+    }
+}
+impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for FdIndicesReaderIterator<'t, 'r> {
+    fn len(&self) -> usize {
+        self.2 - self.1
+    }
+}
+impl ::core::iter::FromIterator<FdIndex> for FdIndices {
+    fn from_iter<T: IntoIterator<Item = FdIndex>>(iter: T) -> Self {
+        Self::new_builder().extend(iter).build()
+    }
+}
+#[derive(Clone)]
+pub struct Bytes(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for Bytes {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for Bytes {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for Bytes {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        let raw_data = hex_string(&self.raw_data());
+        write!(f, "{}(0x{})", Self::NAME, raw_data)
+    }
+}
+impl ::core::default::Default for Bytes {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        Bytes::new_unchecked(v)
+    }
+}
+impl Bytes {
+    const DEFAULT_VALUE: [u8; 4] = [0, 0, 0, 0];
+    pub const ITEM_SIZE: usize = 1;
+    pub fn total_size(&self) -> usize {
+        molecule::NUMBER_SIZE + Self::ITEM_SIZE * self.item_count()
+    }
+    pub fn item_count(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn len(&self) -> usize {
+        self.item_count()
+    }
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    pub fn get(&self, idx: usize) -> Option<Byte> {
+        if idx >= self.len() {
+            None
+        } else {
+            Some(self.get_unchecked(idx))
+        }
+    }
+    pub fn get_unchecked(&self, idx: usize) -> Byte {
+        let start = molecule::NUMBER_SIZE + Self::ITEM_SIZE * idx;
+        let end = start + Self::ITEM_SIZE;
+        Byte::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn raw_data(&self) -> molecule::bytes::Bytes {
+        self.0.slice(molecule::NUMBER_SIZE..)
+    }
+    pub fn as_reader<'r>(&'r self) -> BytesReader<'r> {
+        BytesReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for Bytes {
+    type Builder = BytesBuilder;
+    const NAME: &'static str = "Bytes";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        Bytes(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        BytesReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        BytesReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder().extend(self.into_iter())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct BytesReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for BytesReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for BytesReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for BytesReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        let raw_data = hex_string(&self.raw_data());
+        write!(f, "{}(0x{})", Self::NAME, raw_data)
+    }
+}
+impl<'r> BytesReader<'r> {
+    pub const ITEM_SIZE: usize = 1;
+    pub fn total_size(&self) -> usize {
+        molecule::NUMBER_SIZE + Self::ITEM_SIZE * self.item_count()
+    }
+    pub fn item_count(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn len(&self) -> usize {
+        self.item_count()
+    }
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    pub fn get(&self, idx: usize) -> Option<ByteReader<'r>> {
+        if idx >= self.len() {
+            None
+        } else {
+            Some(self.get_unchecked(idx))
+        }
+    }
+    pub fn get_unchecked(&self, idx: usize) -> ByteReader<'r> {
+        let start = molecule::NUMBER_SIZE + Self::ITEM_SIZE * idx;
+        let end = start + Self::ITEM_SIZE;
+        ByteReader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn raw_data(&self) -> &'r [u8] {
+        &self.as_slice()[molecule::NUMBER_SIZE..]
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for BytesReader<'r> {
+    type Entity = Bytes;
+    const NAME: &'static str = "BytesReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        BytesReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], _compatible: bool) -> molecule::error::VerificationResult<()> {
+        use molecule::verification_error as ve;
+        let slice_len = slice.len();
+        if slice_len < molecule::NUMBER_SIZE {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
+        }
+        let item_count = molecule::unpack_number(slice) as usize;
+        if item_count == 0 {
+            if slice_len != molecule::NUMBER_SIZE {
+                return ve!(Self, TotalSizeNotMatch, molecule::NUMBER_SIZE, slice_len);
+            }
+            return Ok(());
+        }
+        let total_size = molecule::NUMBER_SIZE + Self::ITEM_SIZE * item_count;
+        if slice_len != total_size {
+            return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
+        }
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct BytesBuilder(pub(crate) Vec<Byte>);
+impl BytesBuilder {
+    pub const ITEM_SIZE: usize = 1;
+    pub fn set(mut self, v: Vec<Byte>) -> Self {
+        self.0 = v;
+        self
+    }
+    pub fn push(mut self, v: Byte) -> Self {
+        self.0.push(v);
+        self
+    }
+    pub fn extend<T: ::core::iter::IntoIterator<Item = Byte>>(mut self, iter: T) -> Self {
+        for elem in iter {
+            self.0.push(elem);
+        }
+        self
+    }
+    pub fn replace(&mut self, index: usize, v: Byte) -> Option<Byte> {
+        self.0
+            .get_mut(index)
+            .map(|item| ::core::mem::replace(item, v))
+    }
+}
+impl molecule::prelude::Builder for BytesBuilder {
+    type Entity = Bytes;
+    const NAME: &'static str = "BytesBuilder";
+    fn expected_length(&self) -> usize {
+        molecule::NUMBER_SIZE + Self::ITEM_SIZE * self.0.len()
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        writer.write_all(&molecule::pack_number(self.0.len() as molecule::Number))?;
+        for inner in &self.0[..] {
+            writer.write_all(inner.as_slice())?;
+        }
+        Ok(())
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        Bytes::new_unchecked(inner.into())
+    }
+}
+pub struct BytesIterator(Bytes, usize, usize);
+impl ::core::iter::Iterator for BytesIterator {
+    type Item = Byte;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.1 >= self.2 {
+            None
+        } else {
+            let ret = self.0.get_unchecked(self.1);
+            self.1 += 1;
+            Some(ret)
+        }
+    }
+}
+impl ::core::iter::ExactSizeIterator for BytesIterator {
+    fn len(&self) -> usize {
+        self.2 - self.1
+    }
+}
+impl ::core::iter::IntoIterator for Bytes {
+    type Item = Byte;
+    type IntoIter = BytesIterator;
+    fn into_iter(self) -> Self::IntoIter {
+        let len = self.len();
+        BytesIterator(self, 0, len)
+    }
+}
+impl ::core::iter::FromIterator<Byte> for Bytes {
+    fn from_iter<T: IntoIterator<Item = Byte>>(iter: T) -> Self {
+        Self::new_builder().extend(iter).build()
+    }
+}
+impl ::core::iter::FromIterator<u8> for Bytes {
+    fn from_iter<T: IntoIterator<Item = u8>>(iter: T) -> Self {
+        Self::new_builder()
+            .extend(iter.into_iter().map(Into::into))
+            .build()
+    }
+}
+#[derive(Clone)]
+pub struct Pipe(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for Pipe {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for Pipe {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for Pipe {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "vm", self.vm())?;
+        write!(f, ", {}: {}", "read_fd", self.read_fd())?;
+        write!(f, ", {}: {}", "write_fd", self.write_fd())?;
+        let extra_count = self.count_extra_fields();
+        if extra_count != 0 {
+            write!(f, ", .. ({} fields)", extra_count)?;
+        }
+        write!(f, " }}")
+    }
+}
+impl ::core::default::Default for Pipe {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        Pipe::new_unchecked(v)
+    }
+}
+impl Pipe {
+    const DEFAULT_VALUE: [u8; 40] = [
+        40, 0, 0, 0, 16, 0, 0, 0, 24, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ];
+    pub const FIELD_COUNT: usize = 3;
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn field_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn count_extra_fields(&self) -> usize {
+        self.field_count() - Self::FIELD_COUNT
+    }
+    pub fn has_extra_fields(&self) -> bool {
+        Self::FIELD_COUNT != self.field_count()
+    }
+    pub fn vm(&self) -> VmIndex {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[4..]) as usize;
+        let end = molecule::unpack_number(&slice[8..]) as usize;
+        VmIndex::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn read_fd(&self) -> FdIndex {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[8..]) as usize;
+        let end = molecule::unpack_number(&slice[12..]) as usize;
+        FdIndex::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn write_fd(&self) -> FdIndex {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[12..]) as usize;
+        if self.has_extra_fields() {
+            let end = molecule::unpack_number(&slice[16..]) as usize;
+            FdIndex::new_unchecked(self.0.slice(start..end))
+        } else {
+            FdIndex::new_unchecked(self.0.slice(start..))
+        }
+    }
+    pub fn as_reader<'r>(&'r self) -> PipeReader<'r> {
+        PipeReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for Pipe {
+    type Builder = PipeBuilder;
+    const NAME: &'static str = "Pipe";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        Pipe(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        PipeReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        PipeReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder()
+            .vm(self.vm())
+            .read_fd(self.read_fd())
+            .write_fd(self.write_fd())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct PipeReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for PipeReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for PipeReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for PipeReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "vm", self.vm())?;
+        write!(f, ", {}: {}", "read_fd", self.read_fd())?;
+        write!(f, ", {}: {}", "write_fd", self.write_fd())?;
+        let extra_count = self.count_extra_fields();
+        if extra_count != 0 {
+            write!(f, ", .. ({} fields)", extra_count)?;
+        }
+        write!(f, " }}")
+    }
+}
+impl<'r> PipeReader<'r> {
+    pub const FIELD_COUNT: usize = 3;
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn field_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn count_extra_fields(&self) -> usize {
+        self.field_count() - Self::FIELD_COUNT
+    }
+    pub fn has_extra_fields(&self) -> bool {
+        Self::FIELD_COUNT != self.field_count()
+    }
+    pub fn vm(&self) -> VmIndexReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[4..]) as usize;
+        let end = molecule::unpack_number(&slice[8..]) as usize;
+        VmIndexReader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn read_fd(&self) -> FdIndexReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[8..]) as usize;
+        let end = molecule::unpack_number(&slice[12..]) as usize;
+        FdIndexReader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn write_fd(&self) -> FdIndexReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[12..]) as usize;
+        if self.has_extra_fields() {
+            let end = molecule::unpack_number(&slice[16..]) as usize;
+            FdIndexReader::new_unchecked(&self.as_slice()[start..end])
+        } else {
+            FdIndexReader::new_unchecked(&self.as_slice()[start..])
+        }
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for PipeReader<'r> {
+    type Entity = Pipe;
+    const NAME: &'static str = "PipeReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        PipeReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
+        use molecule::verification_error as ve;
+        let slice_len = slice.len();
+        if slice_len < molecule::NUMBER_SIZE {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
+        }
+        let total_size = molecule::unpack_number(slice) as usize;
+        if slice_len != total_size {
+            return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
+        }
+        if slice_len < molecule::NUMBER_SIZE * 2 {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
+        }
+        let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
+        if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        if slice_len < offset_first {
+            return ve!(Self, HeaderIsBroken, offset_first, slice_len);
+        }
+        let field_count = offset_first / molecule::NUMBER_SIZE - 1;
+        if field_count < Self::FIELD_COUNT {
+            return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
+        } else if !compatible && field_count > Self::FIELD_COUNT {
+            return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
+        };
+        let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
+            .chunks_exact(molecule::NUMBER_SIZE)
+            .map(|x| molecule::unpack_number(x) as usize)
+            .collect();
+        offsets.push(total_size);
+        if offsets.windows(2).any(|i| i[0] > i[1]) {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        VmIndexReader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
+        FdIndexReader::verify(&slice[offsets[1]..offsets[2]], compatible)?;
+        FdIndexReader::verify(&slice[offsets[2]..offsets[3]], compatible)?;
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct PipeBuilder {
+    pub(crate) vm: VmIndex,
+    pub(crate) read_fd: FdIndex,
+    pub(crate) write_fd: FdIndex,
+}
+impl PipeBuilder {
+    pub const FIELD_COUNT: usize = 3;
+    pub fn vm(mut self, v: VmIndex) -> Self {
+        self.vm = v;
+        self
+    }
+    pub fn read_fd(mut self, v: FdIndex) -> Self {
+        self.read_fd = v;
+        self
+    }
+    pub fn write_fd(mut self, v: FdIndex) -> Self {
+        self.write_fd = v;
+        self
+    }
+}
+impl molecule::prelude::Builder for PipeBuilder {
+    type Entity = Pipe;
+    const NAME: &'static str = "PipeBuilder";
+    fn expected_length(&self) -> usize {
+        molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1)
+            + self.vm.as_slice().len()
+            + self.read_fd.as_slice().len()
+            + self.write_fd.as_slice().len()
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
+        let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
+        offsets.push(total_size);
+        total_size += self.vm.as_slice().len();
+        offsets.push(total_size);
+        total_size += self.read_fd.as_slice().len();
+        offsets.push(total_size);
+        total_size += self.write_fd.as_slice().len();
+        writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
+        for offset in offsets.into_iter() {
+            writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
+        }
+        writer.write_all(self.vm.as_slice())?;
+        writer.write_all(self.read_fd.as_slice())?;
+        writer.write_all(self.write_fd.as_slice())?;
+        Ok(())
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        Pipe::new_unchecked(inner.into())
+    }
+}
+#[derive(Clone)]
+pub struct Pipes(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for Pipes {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for Pipes {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for Pipes {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} [", Self::NAME)?;
+        for i in 0..self.len() {
+            if i == 0 {
+                write!(f, "{}", self.get_unchecked(i))?;
+            } else {
+                write!(f, ", {}", self.get_unchecked(i))?;
+            }
+        }
+        write!(f, "]")
+    }
+}
+impl ::core::default::Default for Pipes {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        Pipes::new_unchecked(v)
+    }
+}
+impl Pipes {
+    const DEFAULT_VALUE: [u8; 4] = [4, 0, 0, 0];
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn item_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn len(&self) -> usize {
+        self.item_count()
+    }
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    pub fn get(&self, idx: usize) -> Option<Pipe> {
+        if idx >= self.len() {
+            None
+        } else {
+            Some(self.get_unchecked(idx))
+        }
+    }
+    pub fn get_unchecked(&self, idx: usize) -> Pipe {
+        let slice = self.as_slice();
+        let start_idx = molecule::NUMBER_SIZE * (1 + idx);
+        let start = molecule::unpack_number(&slice[start_idx..]) as usize;
+        if idx == self.len() - 1 {
+            Pipe::new_unchecked(self.0.slice(start..))
+        } else {
+            let end_idx = start_idx + molecule::NUMBER_SIZE;
+            let end = molecule::unpack_number(&slice[end_idx..]) as usize;
+            Pipe::new_unchecked(self.0.slice(start..end))
+        }
+    }
+    pub fn as_reader<'r>(&'r self) -> PipesReader<'r> {
+        PipesReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for Pipes {
+    type Builder = PipesBuilder;
+    const NAME: &'static str = "Pipes";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        Pipes(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        PipesReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        PipesReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder().extend(self.into_iter())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct PipesReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for PipesReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for PipesReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for PipesReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} [", Self::NAME)?;
+        for i in 0..self.len() {
+            if i == 0 {
+                write!(f, "{}", self.get_unchecked(i))?;
+            } else {
+                write!(f, ", {}", self.get_unchecked(i))?;
+            }
+        }
+        write!(f, "]")
+    }
+}
+impl<'r> PipesReader<'r> {
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn item_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn len(&self) -> usize {
+        self.item_count()
+    }
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    pub fn get(&self, idx: usize) -> Option<PipeReader<'r>> {
+        if idx >= self.len() {
+            None
+        } else {
+            Some(self.get_unchecked(idx))
+        }
+    }
+    pub fn get_unchecked(&self, idx: usize) -> PipeReader<'r> {
+        let slice = self.as_slice();
+        let start_idx = molecule::NUMBER_SIZE * (1 + idx);
+        let start = molecule::unpack_number(&slice[start_idx..]) as usize;
+        if idx == self.len() - 1 {
+            PipeReader::new_unchecked(&self.as_slice()[start..])
+        } else {
+            let end_idx = start_idx + molecule::NUMBER_SIZE;
+            let end = molecule::unpack_number(&slice[end_idx..]) as usize;
+            PipeReader::new_unchecked(&self.as_slice()[start..end])
+        }
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for PipesReader<'r> {
+    type Entity = Pipes;
+    const NAME: &'static str = "PipesReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        PipesReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
+        use molecule::verification_error as ve;
+        let slice_len = slice.len();
+        if slice_len < molecule::NUMBER_SIZE {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
+        }
+        let total_size = molecule::unpack_number(slice) as usize;
+        if slice_len != total_size {
+            return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
+        }
+        if slice_len == molecule::NUMBER_SIZE {
+            return Ok(());
+        }
+        if slice_len < molecule::NUMBER_SIZE * 2 {
+            return ve!(
+                Self,
+                TotalSizeNotMatch,
+                molecule::NUMBER_SIZE * 2,
+                slice_len
+            );
+        }
+        let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
+        if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        if slice_len < offset_first {
+            return ve!(Self, HeaderIsBroken, offset_first, slice_len);
+        }
+        let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
+            .chunks_exact(molecule::NUMBER_SIZE)
+            .map(|x| molecule::unpack_number(x) as usize)
+            .collect();
+        offsets.push(total_size);
+        if offsets.windows(2).any(|i| i[0] > i[1]) {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        for pair in offsets.windows(2) {
+            let start = pair[0];
+            let end = pair[1];
+            PipeReader::verify(&slice[start..end], compatible)?;
+        }
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct PipesBuilder(pub(crate) Vec<Pipe>);
+impl PipesBuilder {
+    pub fn set(mut self, v: Vec<Pipe>) -> Self {
+        self.0 = v;
+        self
+    }
+    pub fn push(mut self, v: Pipe) -> Self {
+        self.0.push(v);
+        self
+    }
+    pub fn extend<T: ::core::iter::IntoIterator<Item = Pipe>>(mut self, iter: T) -> Self {
+        for elem in iter {
+            self.0.push(elem);
+        }
+        self
+    }
+    pub fn replace(&mut self, index: usize, v: Pipe) -> Option<Pipe> {
+        self.0
+            .get_mut(index)
+            .map(|item| ::core::mem::replace(item, v))
+    }
+}
+impl molecule::prelude::Builder for PipesBuilder {
+    type Entity = Pipes;
+    const NAME: &'static str = "PipesBuilder";
+    fn expected_length(&self) -> usize {
+        molecule::NUMBER_SIZE * (self.0.len() + 1)
+            + self
+                .0
+                .iter()
+                .map(|inner| inner.as_slice().len())
+                .sum::<usize>()
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        let item_count = self.0.len();
+        if item_count == 0 {
+            writer.write_all(&molecule::pack_number(
+                molecule::NUMBER_SIZE as molecule::Number,
+            ))?;
+        } else {
+            let (total_size, offsets) = self.0.iter().fold(
+                (
+                    molecule::NUMBER_SIZE * (item_count + 1),
+                    Vec::with_capacity(item_count),
+                ),
+                |(start, mut offsets), inner| {
+                    offsets.push(start);
+                    (start + inner.as_slice().len(), offsets)
+                },
+            );
+            writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
+            for offset in offsets.into_iter() {
+                writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
+            }
+            for inner in self.0.iter() {
+                writer.write_all(inner.as_slice())?;
+            }
+        }
+        Ok(())
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        Pipes::new_unchecked(inner.into())
+    }
+}
+pub struct PipesIterator(Pipes, usize, usize);
+impl ::core::iter::Iterator for PipesIterator {
+    type Item = Pipe;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.1 >= self.2 {
+            None
+        } else {
+            let ret = self.0.get_unchecked(self.1);
+            self.1 += 1;
+            Some(ret)
+        }
+    }
+}
+impl ::core::iter::ExactSizeIterator for PipesIterator {
+    fn len(&self) -> usize {
+        self.2 - self.1
+    }
+}
+impl ::core::iter::IntoIterator for Pipes {
+    type Item = Pipe;
+    type IntoIter = PipesIterator;
+    fn into_iter(self) -> Self::IntoIter {
+        let len = self.len();
+        PipesIterator(self, 0, len)
+    }
+}
+impl<'r> PipesReader<'r> {
+    pub fn iter<'t>(&'t self) -> PipesReaderIterator<'t, 'r> {
+        PipesReaderIterator(&self, 0, self.len())
+    }
+}
+pub struct PipesReaderIterator<'t, 'r>(&'t PipesReader<'r>, usize, usize);
+impl<'t: 'r, 'r> ::core::iter::Iterator for PipesReaderIterator<'t, 'r> {
+    type Item = PipeReader<'t>;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.1 >= self.2 {
+            None
+        } else {
+            let ret = self.0.get_unchecked(self.1);
+            self.1 += 1;
+            Some(ret)
+        }
+    }
+}
+impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for PipesReaderIterator<'t, 'r> {
+    fn len(&self) -> usize {
+        self.2 - self.1
+    }
+}
+impl ::core::iter::FromIterator<Pipe> for Pipes {
+    fn from_iter<T: IntoIterator<Item = Pipe>>(iter: T) -> Self {
+        Self::new_builder().extend(iter).build()
+    }
+}
+#[derive(Clone)]
+pub struct Write(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for Write {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for Write {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for Write {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "from", self.from())?;
+        write!(f, ", {}: {}", "from_fd", self.from_fd())?;
+        write!(f, ", {}: {}", "to", self.to())?;
+        write!(f, ", {}: {}", "to_fd", self.to_fd())?;
+        write!(f, ", {}: {}", "data", self.data())?;
+        let extra_count = self.count_extra_fields();
+        if extra_count != 0 {
+            write!(f, ", .. ({} fields)", extra_count)?;
+        }
+        write!(f, " }}")
+    }
+}
+impl ::core::default::Default for Write {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        Write::new_unchecked(v)
+    }
+}
+impl Write {
+    const DEFAULT_VALUE: [u8; 60] = [
+        60, 0, 0, 0, 24, 0, 0, 0, 32, 0, 0, 0, 40, 0, 0, 0, 48, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0,
+    ];
+    pub const FIELD_COUNT: usize = 5;
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn field_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn count_extra_fields(&self) -> usize {
+        self.field_count() - Self::FIELD_COUNT
+    }
+    pub fn has_extra_fields(&self) -> bool {
+        Self::FIELD_COUNT != self.field_count()
+    }
+    pub fn from(&self) -> VmIndex {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[4..]) as usize;
+        let end = molecule::unpack_number(&slice[8..]) as usize;
+        VmIndex::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn from_fd(&self) -> FdIndex {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[8..]) as usize;
+        let end = molecule::unpack_number(&slice[12..]) as usize;
+        FdIndex::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn to(&self) -> VmIndex {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[12..]) as usize;
+        let end = molecule::unpack_number(&slice[16..]) as usize;
+        VmIndex::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn to_fd(&self) -> FdIndex {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[16..]) as usize;
+        let end = molecule::unpack_number(&slice[20..]) as usize;
+        FdIndex::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn data(&self) -> Bytes {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[20..]) as usize;
+        if self.has_extra_fields() {
+            let end = molecule::unpack_number(&slice[24..]) as usize;
+            Bytes::new_unchecked(self.0.slice(start..end))
+        } else {
+            Bytes::new_unchecked(self.0.slice(start..))
+        }
+    }
+    pub fn as_reader<'r>(&'r self) -> WriteReader<'r> {
+        WriteReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for Write {
+    type Builder = WriteBuilder;
+    const NAME: &'static str = "Write";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        Write(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        WriteReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        WriteReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder()
+            .from(self.from())
+            .from_fd(self.from_fd())
+            .to(self.to())
+            .to_fd(self.to_fd())
+            .data(self.data())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct WriteReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for WriteReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for WriteReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for WriteReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "from", self.from())?;
+        write!(f, ", {}: {}", "from_fd", self.from_fd())?;
+        write!(f, ", {}: {}", "to", self.to())?;
+        write!(f, ", {}: {}", "to_fd", self.to_fd())?;
+        write!(f, ", {}: {}", "data", self.data())?;
+        let extra_count = self.count_extra_fields();
+        if extra_count != 0 {
+            write!(f, ", .. ({} fields)", extra_count)?;
+        }
+        write!(f, " }}")
+    }
+}
+impl<'r> WriteReader<'r> {
+    pub const FIELD_COUNT: usize = 5;
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn field_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn count_extra_fields(&self) -> usize {
+        self.field_count() - Self::FIELD_COUNT
+    }
+    pub fn has_extra_fields(&self) -> bool {
+        Self::FIELD_COUNT != self.field_count()
+    }
+    pub fn from(&self) -> VmIndexReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[4..]) as usize;
+        let end = molecule::unpack_number(&slice[8..]) as usize;
+        VmIndexReader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn from_fd(&self) -> FdIndexReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[8..]) as usize;
+        let end = molecule::unpack_number(&slice[12..]) as usize;
+        FdIndexReader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn to(&self) -> VmIndexReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[12..]) as usize;
+        let end = molecule::unpack_number(&slice[16..]) as usize;
+        VmIndexReader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn to_fd(&self) -> FdIndexReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[16..]) as usize;
+        let end = molecule::unpack_number(&slice[20..]) as usize;
+        FdIndexReader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn data(&self) -> BytesReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[20..]) as usize;
+        if self.has_extra_fields() {
+            let end = molecule::unpack_number(&slice[24..]) as usize;
+            BytesReader::new_unchecked(&self.as_slice()[start..end])
+        } else {
+            BytesReader::new_unchecked(&self.as_slice()[start..])
+        }
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for WriteReader<'r> {
+    type Entity = Write;
+    const NAME: &'static str = "WriteReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        WriteReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
+        use molecule::verification_error as ve;
+        let slice_len = slice.len();
+        if slice_len < molecule::NUMBER_SIZE {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
+        }
+        let total_size = molecule::unpack_number(slice) as usize;
+        if slice_len != total_size {
+            return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
+        }
+        if slice_len < molecule::NUMBER_SIZE * 2 {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
+        }
+        let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
+        if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        if slice_len < offset_first {
+            return ve!(Self, HeaderIsBroken, offset_first, slice_len);
+        }
+        let field_count = offset_first / molecule::NUMBER_SIZE - 1;
+        if field_count < Self::FIELD_COUNT {
+            return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
+        } else if !compatible && field_count > Self::FIELD_COUNT {
+            return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
+        };
+        let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
+            .chunks_exact(molecule::NUMBER_SIZE)
+            .map(|x| molecule::unpack_number(x) as usize)
+            .collect();
+        offsets.push(total_size);
+        if offsets.windows(2).any(|i| i[0] > i[1]) {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        VmIndexReader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
+        FdIndexReader::verify(&slice[offsets[1]..offsets[2]], compatible)?;
+        VmIndexReader::verify(&slice[offsets[2]..offsets[3]], compatible)?;
+        FdIndexReader::verify(&slice[offsets[3]..offsets[4]], compatible)?;
+        BytesReader::verify(&slice[offsets[4]..offsets[5]], compatible)?;
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct WriteBuilder {
+    pub(crate) from: VmIndex,
+    pub(crate) from_fd: FdIndex,
+    pub(crate) to: VmIndex,
+    pub(crate) to_fd: FdIndex,
+    pub(crate) data: Bytes,
+}
+impl WriteBuilder {
+    pub const FIELD_COUNT: usize = 5;
+    pub fn from(mut self, v: VmIndex) -> Self {
+        self.from = v;
+        self
+    }
+    pub fn from_fd(mut self, v: FdIndex) -> Self {
+        self.from_fd = v;
+        self
+    }
+    pub fn to(mut self, v: VmIndex) -> Self {
+        self.to = v;
+        self
+    }
+    pub fn to_fd(mut self, v: FdIndex) -> Self {
+        self.to_fd = v;
+        self
+    }
+    pub fn data(mut self, v: Bytes) -> Self {
+        self.data = v;
+        self
+    }
+}
+impl molecule::prelude::Builder for WriteBuilder {
+    type Entity = Write;
+    const NAME: &'static str = "WriteBuilder";
+    fn expected_length(&self) -> usize {
+        molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1)
+            + self.from.as_slice().len()
+            + self.from_fd.as_slice().len()
+            + self.to.as_slice().len()
+            + self.to_fd.as_slice().len()
+            + self.data.as_slice().len()
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
+        let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
+        offsets.push(total_size);
+        total_size += self.from.as_slice().len();
+        offsets.push(total_size);
+        total_size += self.from_fd.as_slice().len();
+        offsets.push(total_size);
+        total_size += self.to.as_slice().len();
+        offsets.push(total_size);
+        total_size += self.to_fd.as_slice().len();
+        offsets.push(total_size);
+        total_size += self.data.as_slice().len();
+        writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
+        for offset in offsets.into_iter() {
+            writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
+        }
+        writer.write_all(self.from.as_slice())?;
+        writer.write_all(self.from_fd.as_slice())?;
+        writer.write_all(self.to.as_slice())?;
+        writer.write_all(self.to_fd.as_slice())?;
+        writer.write_all(self.data.as_slice())?;
+        Ok(())
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        Write::new_unchecked(inner.into())
+    }
+}
+#[derive(Clone)]
+pub struct Writes(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for Writes {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for Writes {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for Writes {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} [", Self::NAME)?;
+        for i in 0..self.len() {
+            if i == 0 {
+                write!(f, "{}", self.get_unchecked(i))?;
+            } else {
+                write!(f, ", {}", self.get_unchecked(i))?;
+            }
+        }
+        write!(f, "]")
+    }
+}
+impl ::core::default::Default for Writes {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        Writes::new_unchecked(v)
+    }
+}
+impl Writes {
+    const DEFAULT_VALUE: [u8; 4] = [4, 0, 0, 0];
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn item_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn len(&self) -> usize {
+        self.item_count()
+    }
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    pub fn get(&self, idx: usize) -> Option<Write> {
+        if idx >= self.len() {
+            None
+        } else {
+            Some(self.get_unchecked(idx))
+        }
+    }
+    pub fn get_unchecked(&self, idx: usize) -> Write {
+        let slice = self.as_slice();
+        let start_idx = molecule::NUMBER_SIZE * (1 + idx);
+        let start = molecule::unpack_number(&slice[start_idx..]) as usize;
+        if idx == self.len() - 1 {
+            Write::new_unchecked(self.0.slice(start..))
+        } else {
+            let end_idx = start_idx + molecule::NUMBER_SIZE;
+            let end = molecule::unpack_number(&slice[end_idx..]) as usize;
+            Write::new_unchecked(self.0.slice(start..end))
+        }
+    }
+    pub fn as_reader<'r>(&'r self) -> WritesReader<'r> {
+        WritesReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for Writes {
+    type Builder = WritesBuilder;
+    const NAME: &'static str = "Writes";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        Writes(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        WritesReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        WritesReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder().extend(self.into_iter())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct WritesReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for WritesReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for WritesReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for WritesReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} [", Self::NAME)?;
+        for i in 0..self.len() {
+            if i == 0 {
+                write!(f, "{}", self.get_unchecked(i))?;
+            } else {
+                write!(f, ", {}", self.get_unchecked(i))?;
+            }
+        }
+        write!(f, "]")
+    }
+}
+impl<'r> WritesReader<'r> {
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn item_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn len(&self) -> usize {
+        self.item_count()
+    }
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    pub fn get(&self, idx: usize) -> Option<WriteReader<'r>> {
+        if idx >= self.len() {
+            None
+        } else {
+            Some(self.get_unchecked(idx))
+        }
+    }
+    pub fn get_unchecked(&self, idx: usize) -> WriteReader<'r> {
+        let slice = self.as_slice();
+        let start_idx = molecule::NUMBER_SIZE * (1 + idx);
+        let start = molecule::unpack_number(&slice[start_idx..]) as usize;
+        if idx == self.len() - 1 {
+            WriteReader::new_unchecked(&self.as_slice()[start..])
+        } else {
+            let end_idx = start_idx + molecule::NUMBER_SIZE;
+            let end = molecule::unpack_number(&slice[end_idx..]) as usize;
+            WriteReader::new_unchecked(&self.as_slice()[start..end])
+        }
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for WritesReader<'r> {
+    type Entity = Writes;
+    const NAME: &'static str = "WritesReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        WritesReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
+        use molecule::verification_error as ve;
+        let slice_len = slice.len();
+        if slice_len < molecule::NUMBER_SIZE {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
+        }
+        let total_size = molecule::unpack_number(slice) as usize;
+        if slice_len != total_size {
+            return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
+        }
+        if slice_len == molecule::NUMBER_SIZE {
+            return Ok(());
+        }
+        if slice_len < molecule::NUMBER_SIZE * 2 {
+            return ve!(
+                Self,
+                TotalSizeNotMatch,
+                molecule::NUMBER_SIZE * 2,
+                slice_len
+            );
+        }
+        let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
+        if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        if slice_len < offset_first {
+            return ve!(Self, HeaderIsBroken, offset_first, slice_len);
+        }
+        let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
+            .chunks_exact(molecule::NUMBER_SIZE)
+            .map(|x| molecule::unpack_number(x) as usize)
+            .collect();
+        offsets.push(total_size);
+        if offsets.windows(2).any(|i| i[0] > i[1]) {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        for pair in offsets.windows(2) {
+            let start = pair[0];
+            let end = pair[1];
+            WriteReader::verify(&slice[start..end], compatible)?;
+        }
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct WritesBuilder(pub(crate) Vec<Write>);
+impl WritesBuilder {
+    pub fn set(mut self, v: Vec<Write>) -> Self {
+        self.0 = v;
+        self
+    }
+    pub fn push(mut self, v: Write) -> Self {
+        self.0.push(v);
+        self
+    }
+    pub fn extend<T: ::core::iter::IntoIterator<Item = Write>>(mut self, iter: T) -> Self {
+        for elem in iter {
+            self.0.push(elem);
+        }
+        self
+    }
+    pub fn replace(&mut self, index: usize, v: Write) -> Option<Write> {
+        self.0
+            .get_mut(index)
+            .map(|item| ::core::mem::replace(item, v))
+    }
+}
+impl molecule::prelude::Builder for WritesBuilder {
+    type Entity = Writes;
+    const NAME: &'static str = "WritesBuilder";
+    fn expected_length(&self) -> usize {
+        molecule::NUMBER_SIZE * (self.0.len() + 1)
+            + self
+                .0
+                .iter()
+                .map(|inner| inner.as_slice().len())
+                .sum::<usize>()
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        let item_count = self.0.len();
+        if item_count == 0 {
+            writer.write_all(&molecule::pack_number(
+                molecule::NUMBER_SIZE as molecule::Number,
+            ))?;
+        } else {
+            let (total_size, offsets) = self.0.iter().fold(
+                (
+                    molecule::NUMBER_SIZE * (item_count + 1),
+                    Vec::with_capacity(item_count),
+                ),
+                |(start, mut offsets), inner| {
+                    offsets.push(start);
+                    (start + inner.as_slice().len(), offsets)
+                },
+            );
+            writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
+            for offset in offsets.into_iter() {
+                writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
+            }
+            for inner in self.0.iter() {
+                writer.write_all(inner.as_slice())?;
+            }
+        }
+        Ok(())
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        Writes::new_unchecked(inner.into())
+    }
+}
+pub struct WritesIterator(Writes, usize, usize);
+impl ::core::iter::Iterator for WritesIterator {
+    type Item = Write;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.1 >= self.2 {
+            None
+        } else {
+            let ret = self.0.get_unchecked(self.1);
+            self.1 += 1;
+            Some(ret)
+        }
+    }
+}
+impl ::core::iter::ExactSizeIterator for WritesIterator {
+    fn len(&self) -> usize {
+        self.2 - self.1
+    }
+}
+impl ::core::iter::IntoIterator for Writes {
+    type Item = Write;
+    type IntoIter = WritesIterator;
+    fn into_iter(self) -> Self::IntoIter {
+        let len = self.len();
+        WritesIterator(self, 0, len)
+    }
+}
+impl<'r> WritesReader<'r> {
+    pub fn iter<'t>(&'t self) -> WritesReaderIterator<'t, 'r> {
+        WritesReaderIterator(&self, 0, self.len())
+    }
+}
+pub struct WritesReaderIterator<'t, 'r>(&'t WritesReader<'r>, usize, usize);
+impl<'t: 'r, 'r> ::core::iter::Iterator for WritesReaderIterator<'t, 'r> {
+    type Item = WriteReader<'t>;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.1 >= self.2 {
+            None
+        } else {
+            let ret = self.0.get_unchecked(self.1);
+            self.1 += 1;
+            Some(ret)
+        }
+    }
+}
+impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for WritesReaderIterator<'t, 'r> {
+    fn len(&self) -> usize {
+        self.2 - self.1
+    }
+}
+impl ::core::iter::FromIterator<Write> for Writes {
+    fn from_iter<T: IntoIterator<Item = Write>>(iter: T) -> Self {
+        Self::new_builder().extend(iter).build()
+    }
+}
+#[derive(Clone)]
+pub struct Spawn(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for Spawn {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for Spawn {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for Spawn {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "from", self.from())?;
+        write!(f, ", {}: {}", "child", self.child())?;
+        write!(f, ", {}: {}", "fds", self.fds())?;
+        let extra_count = self.count_extra_fields();
+        if extra_count != 0 {
+            write!(f, ", .. ({} fields)", extra_count)?;
+        }
+        write!(f, " }}")
+    }
+}
+impl ::core::default::Default for Spawn {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        Spawn::new_unchecked(v)
+    }
+}
+impl Spawn {
+    const DEFAULT_VALUE: [u8; 36] = [
+        36, 0, 0, 0, 16, 0, 0, 0, 24, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0,
+    ];
+    pub const FIELD_COUNT: usize = 3;
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn field_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn count_extra_fields(&self) -> usize {
+        self.field_count() - Self::FIELD_COUNT
+    }
+    pub fn has_extra_fields(&self) -> bool {
+        Self::FIELD_COUNT != self.field_count()
+    }
+    pub fn from(&self) -> VmIndex {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[4..]) as usize;
+        let end = molecule::unpack_number(&slice[8..]) as usize;
+        VmIndex::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn child(&self) -> VmIndex {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[8..]) as usize;
+        let end = molecule::unpack_number(&slice[12..]) as usize;
+        VmIndex::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn fds(&self) -> FdIndices {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[12..]) as usize;
+        if self.has_extra_fields() {
+            let end = molecule::unpack_number(&slice[16..]) as usize;
+            FdIndices::new_unchecked(self.0.slice(start..end))
+        } else {
+            FdIndices::new_unchecked(self.0.slice(start..))
+        }
+    }
+    pub fn as_reader<'r>(&'r self) -> SpawnReader<'r> {
+        SpawnReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for Spawn {
+    type Builder = SpawnBuilder;
+    const NAME: &'static str = "Spawn";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        Spawn(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        SpawnReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        SpawnReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder()
+            .from(self.from())
+            .child(self.child())
+            .fds(self.fds())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct SpawnReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for SpawnReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for SpawnReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for SpawnReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "from", self.from())?;
+        write!(f, ", {}: {}", "child", self.child())?;
+        write!(f, ", {}: {}", "fds", self.fds())?;
+        let extra_count = self.count_extra_fields();
+        if extra_count != 0 {
+            write!(f, ", .. ({} fields)", extra_count)?;
+        }
+        write!(f, " }}")
+    }
+}
+impl<'r> SpawnReader<'r> {
+    pub const FIELD_COUNT: usize = 3;
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn field_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn count_extra_fields(&self) -> usize {
+        self.field_count() - Self::FIELD_COUNT
+    }
+    pub fn has_extra_fields(&self) -> bool {
+        Self::FIELD_COUNT != self.field_count()
+    }
+    pub fn from(&self) -> VmIndexReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[4..]) as usize;
+        let end = molecule::unpack_number(&slice[8..]) as usize;
+        VmIndexReader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn child(&self) -> VmIndexReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[8..]) as usize;
+        let end = molecule::unpack_number(&slice[12..]) as usize;
+        VmIndexReader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn fds(&self) -> FdIndicesReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[12..]) as usize;
+        if self.has_extra_fields() {
+            let end = molecule::unpack_number(&slice[16..]) as usize;
+            FdIndicesReader::new_unchecked(&self.as_slice()[start..end])
+        } else {
+            FdIndicesReader::new_unchecked(&self.as_slice()[start..])
+        }
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for SpawnReader<'r> {
+    type Entity = Spawn;
+    const NAME: &'static str = "SpawnReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        SpawnReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
+        use molecule::verification_error as ve;
+        let slice_len = slice.len();
+        if slice_len < molecule::NUMBER_SIZE {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
+        }
+        let total_size = molecule::unpack_number(slice) as usize;
+        if slice_len != total_size {
+            return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
+        }
+        if slice_len < molecule::NUMBER_SIZE * 2 {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
+        }
+        let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
+        if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        if slice_len < offset_first {
+            return ve!(Self, HeaderIsBroken, offset_first, slice_len);
+        }
+        let field_count = offset_first / molecule::NUMBER_SIZE - 1;
+        if field_count < Self::FIELD_COUNT {
+            return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
+        } else if !compatible && field_count > Self::FIELD_COUNT {
+            return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
+        };
+        let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
+            .chunks_exact(molecule::NUMBER_SIZE)
+            .map(|x| molecule::unpack_number(x) as usize)
+            .collect();
+        offsets.push(total_size);
+        if offsets.windows(2).any(|i| i[0] > i[1]) {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        VmIndexReader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
+        VmIndexReader::verify(&slice[offsets[1]..offsets[2]], compatible)?;
+        FdIndicesReader::verify(&slice[offsets[2]..offsets[3]], compatible)?;
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct SpawnBuilder {
+    pub(crate) from: VmIndex,
+    pub(crate) child: VmIndex,
+    pub(crate) fds: FdIndices,
+}
+impl SpawnBuilder {
+    pub const FIELD_COUNT: usize = 3;
+    pub fn from(mut self, v: VmIndex) -> Self {
+        self.from = v;
+        self
+    }
+    pub fn child(mut self, v: VmIndex) -> Self {
+        self.child = v;
+        self
+    }
+    pub fn fds(mut self, v: FdIndices) -> Self {
+        self.fds = v;
+        self
+    }
+}
+impl molecule::prelude::Builder for SpawnBuilder {
+    type Entity = Spawn;
+    const NAME: &'static str = "SpawnBuilder";
+    fn expected_length(&self) -> usize {
+        molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1)
+            + self.from.as_slice().len()
+            + self.child.as_slice().len()
+            + self.fds.as_slice().len()
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
+        let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
+        offsets.push(total_size);
+        total_size += self.from.as_slice().len();
+        offsets.push(total_size);
+        total_size += self.child.as_slice().len();
+        offsets.push(total_size);
+        total_size += self.fds.as_slice().len();
+        writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
+        for offset in offsets.into_iter() {
+            writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
+        }
+        writer.write_all(self.from.as_slice())?;
+        writer.write_all(self.child.as_slice())?;
+        writer.write_all(self.fds.as_slice())?;
+        Ok(())
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        Spawn::new_unchecked(inner.into())
+    }
+}
+#[derive(Clone)]
+pub struct Spawns(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for Spawns {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for Spawns {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for Spawns {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} [", Self::NAME)?;
+        for i in 0..self.len() {
+            if i == 0 {
+                write!(f, "{}", self.get_unchecked(i))?;
+            } else {
+                write!(f, ", {}", self.get_unchecked(i))?;
+            }
+        }
+        write!(f, "]")
+    }
+}
+impl ::core::default::Default for Spawns {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        Spawns::new_unchecked(v)
+    }
+}
+impl Spawns {
+    const DEFAULT_VALUE: [u8; 4] = [4, 0, 0, 0];
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn item_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn len(&self) -> usize {
+        self.item_count()
+    }
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    pub fn get(&self, idx: usize) -> Option<Spawn> {
+        if idx >= self.len() {
+            None
+        } else {
+            Some(self.get_unchecked(idx))
+        }
+    }
+    pub fn get_unchecked(&self, idx: usize) -> Spawn {
+        let slice = self.as_slice();
+        let start_idx = molecule::NUMBER_SIZE * (1 + idx);
+        let start = molecule::unpack_number(&slice[start_idx..]) as usize;
+        if idx == self.len() - 1 {
+            Spawn::new_unchecked(self.0.slice(start..))
+        } else {
+            let end_idx = start_idx + molecule::NUMBER_SIZE;
+            let end = molecule::unpack_number(&slice[end_idx..]) as usize;
+            Spawn::new_unchecked(self.0.slice(start..end))
+        }
+    }
+    pub fn as_reader<'r>(&'r self) -> SpawnsReader<'r> {
+        SpawnsReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for Spawns {
+    type Builder = SpawnsBuilder;
+    const NAME: &'static str = "Spawns";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        Spawns(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        SpawnsReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        SpawnsReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder().extend(self.into_iter())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct SpawnsReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for SpawnsReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for SpawnsReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for SpawnsReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} [", Self::NAME)?;
+        for i in 0..self.len() {
+            if i == 0 {
+                write!(f, "{}", self.get_unchecked(i))?;
+            } else {
+                write!(f, ", {}", self.get_unchecked(i))?;
+            }
+        }
+        write!(f, "]")
+    }
+}
+impl<'r> SpawnsReader<'r> {
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn item_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn len(&self) -> usize {
+        self.item_count()
+    }
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    pub fn get(&self, idx: usize) -> Option<SpawnReader<'r>> {
+        if idx >= self.len() {
+            None
+        } else {
+            Some(self.get_unchecked(idx))
+        }
+    }
+    pub fn get_unchecked(&self, idx: usize) -> SpawnReader<'r> {
+        let slice = self.as_slice();
+        let start_idx = molecule::NUMBER_SIZE * (1 + idx);
+        let start = molecule::unpack_number(&slice[start_idx..]) as usize;
+        if idx == self.len() - 1 {
+            SpawnReader::new_unchecked(&self.as_slice()[start..])
+        } else {
+            let end_idx = start_idx + molecule::NUMBER_SIZE;
+            let end = molecule::unpack_number(&slice[end_idx..]) as usize;
+            SpawnReader::new_unchecked(&self.as_slice()[start..end])
+        }
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for SpawnsReader<'r> {
+    type Entity = Spawns;
+    const NAME: &'static str = "SpawnsReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        SpawnsReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
+        use molecule::verification_error as ve;
+        let slice_len = slice.len();
+        if slice_len < molecule::NUMBER_SIZE {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
+        }
+        let total_size = molecule::unpack_number(slice) as usize;
+        if slice_len != total_size {
+            return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
+        }
+        if slice_len == molecule::NUMBER_SIZE {
+            return Ok(());
+        }
+        if slice_len < molecule::NUMBER_SIZE * 2 {
+            return ve!(
+                Self,
+                TotalSizeNotMatch,
+                molecule::NUMBER_SIZE * 2,
+                slice_len
+            );
+        }
+        let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
+        if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        if slice_len < offset_first {
+            return ve!(Self, HeaderIsBroken, offset_first, slice_len);
+        }
+        let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
+            .chunks_exact(molecule::NUMBER_SIZE)
+            .map(|x| molecule::unpack_number(x) as usize)
+            .collect();
+        offsets.push(total_size);
+        if offsets.windows(2).any(|i| i[0] > i[1]) {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        for pair in offsets.windows(2) {
+            let start = pair[0];
+            let end = pair[1];
+            SpawnReader::verify(&slice[start..end], compatible)?;
+        }
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct SpawnsBuilder(pub(crate) Vec<Spawn>);
+impl SpawnsBuilder {
+    pub fn set(mut self, v: Vec<Spawn>) -> Self {
+        self.0 = v;
+        self
+    }
+    pub fn push(mut self, v: Spawn) -> Self {
+        self.0.push(v);
+        self
+    }
+    pub fn extend<T: ::core::iter::IntoIterator<Item = Spawn>>(mut self, iter: T) -> Self {
+        for elem in iter {
+            self.0.push(elem);
+        }
+        self
+    }
+    pub fn replace(&mut self, index: usize, v: Spawn) -> Option<Spawn> {
+        self.0
+            .get_mut(index)
+            .map(|item| ::core::mem::replace(item, v))
+    }
+}
+impl molecule::prelude::Builder for SpawnsBuilder {
+    type Entity = Spawns;
+    const NAME: &'static str = "SpawnsBuilder";
+    fn expected_length(&self) -> usize {
+        molecule::NUMBER_SIZE * (self.0.len() + 1)
+            + self
+                .0
+                .iter()
+                .map(|inner| inner.as_slice().len())
+                .sum::<usize>()
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        let item_count = self.0.len();
+        if item_count == 0 {
+            writer.write_all(&molecule::pack_number(
+                molecule::NUMBER_SIZE as molecule::Number,
+            ))?;
+        } else {
+            let (total_size, offsets) = self.0.iter().fold(
+                (
+                    molecule::NUMBER_SIZE * (item_count + 1),
+                    Vec::with_capacity(item_count),
+                ),
+                |(start, mut offsets), inner| {
+                    offsets.push(start);
+                    (start + inner.as_slice().len(), offsets)
+                },
+            );
+            writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
+            for offset in offsets.into_iter() {
+                writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
+            }
+            for inner in self.0.iter() {
+                writer.write_all(inner.as_slice())?;
+            }
+        }
+        Ok(())
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        Spawns::new_unchecked(inner.into())
+    }
+}
+pub struct SpawnsIterator(Spawns, usize, usize);
+impl ::core::iter::Iterator for SpawnsIterator {
+    type Item = Spawn;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.1 >= self.2 {
+            None
+        } else {
+            let ret = self.0.get_unchecked(self.1);
+            self.1 += 1;
+            Some(ret)
+        }
+    }
+}
+impl ::core::iter::ExactSizeIterator for SpawnsIterator {
+    fn len(&self) -> usize {
+        self.2 - self.1
+    }
+}
+impl ::core::iter::IntoIterator for Spawns {
+    type Item = Spawn;
+    type IntoIter = SpawnsIterator;
+    fn into_iter(self) -> Self::IntoIter {
+        let len = self.len();
+        SpawnsIterator(self, 0, len)
+    }
+}
+impl<'r> SpawnsReader<'r> {
+    pub fn iter<'t>(&'t self) -> SpawnsReaderIterator<'t, 'r> {
+        SpawnsReaderIterator(&self, 0, self.len())
+    }
+}
+pub struct SpawnsReaderIterator<'t, 'r>(&'t SpawnsReader<'r>, usize, usize);
+impl<'t: 'r, 'r> ::core::iter::Iterator for SpawnsReaderIterator<'t, 'r> {
+    type Item = SpawnReader<'t>;
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.1 >= self.2 {
+            None
+        } else {
+            let ret = self.0.get_unchecked(self.1);
+            self.1 += 1;
+            Some(ret)
+        }
+    }
+}
+impl<'t: 'r, 'r> ::core::iter::ExactSizeIterator for SpawnsReaderIterator<'t, 'r> {
+    fn len(&self) -> usize {
+        self.2 - self.1
+    }
+}
+impl ::core::iter::FromIterator<Spawn> for Spawns {
+    fn from_iter<T: IntoIterator<Item = Spawn>>(iter: T) -> Self {
+        Self::new_builder().extend(iter).build()
+    }
+}
+#[derive(Clone)]
+pub struct Data(molecule::bytes::Bytes);
+impl ::core::fmt::LowerHex for Data {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl ::core::fmt::Debug for Data {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl ::core::fmt::Display for Data {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "spawns", self.spawns())?;
+        write!(f, ", {}: {}", "pipes", self.pipes())?;
+        write!(f, ", {}: {}", "writes", self.writes())?;
+        let extra_count = self.count_extra_fields();
+        if extra_count != 0 {
+            write!(f, ", .. ({} fields)", extra_count)?;
+        }
+        write!(f, " }}")
+    }
+}
+impl ::core::default::Default for Data {
+    fn default() -> Self {
+        let v = molecule::bytes::Bytes::from_static(&Self::DEFAULT_VALUE);
+        Data::new_unchecked(v)
+    }
+}
+impl Data {
+    const DEFAULT_VALUE: [u8; 28] = [
+        28, 0, 0, 0, 16, 0, 0, 0, 20, 0, 0, 0, 24, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0,
+    ];
+    pub const FIELD_COUNT: usize = 3;
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn field_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn count_extra_fields(&self) -> usize {
+        self.field_count() - Self::FIELD_COUNT
+    }
+    pub fn has_extra_fields(&self) -> bool {
+        Self::FIELD_COUNT != self.field_count()
+    }
+    pub fn spawns(&self) -> Spawns {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[4..]) as usize;
+        let end = molecule::unpack_number(&slice[8..]) as usize;
+        Spawns::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn pipes(&self) -> Pipes {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[8..]) as usize;
+        let end = molecule::unpack_number(&slice[12..]) as usize;
+        Pipes::new_unchecked(self.0.slice(start..end))
+    }
+    pub fn writes(&self) -> Writes {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[12..]) as usize;
+        if self.has_extra_fields() {
+            let end = molecule::unpack_number(&slice[16..]) as usize;
+            Writes::new_unchecked(self.0.slice(start..end))
+        } else {
+            Writes::new_unchecked(self.0.slice(start..))
+        }
+    }
+    pub fn as_reader<'r>(&'r self) -> DataReader<'r> {
+        DataReader::new_unchecked(self.as_slice())
+    }
+}
+impl molecule::prelude::Entity for Data {
+    type Builder = DataBuilder;
+    const NAME: &'static str = "Data";
+    fn new_unchecked(data: molecule::bytes::Bytes) -> Self {
+        Data(data)
+    }
+    fn as_bytes(&self) -> molecule::bytes::Bytes {
+        self.0.clone()
+    }
+    fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+    fn from_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        DataReader::from_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn from_compatible_slice(slice: &[u8]) -> molecule::error::VerificationResult<Self> {
+        DataReader::from_compatible_slice(slice).map(|reader| reader.to_entity())
+    }
+    fn new_builder() -> Self::Builder {
+        ::core::default::Default::default()
+    }
+    fn as_builder(self) -> Self::Builder {
+        Self::new_builder()
+            .spawns(self.spawns())
+            .pipes(self.pipes())
+            .writes(self.writes())
+    }
+}
+#[derive(Clone, Copy)]
+pub struct DataReader<'r>(&'r [u8]);
+impl<'r> ::core::fmt::LowerHex for DataReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        use molecule::hex_string;
+        if f.alternate() {
+            write!(f, "0x")?;
+        }
+        write!(f, "{}", hex_string(self.as_slice()))
+    }
+}
+impl<'r> ::core::fmt::Debug for DataReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{}({:#x})", Self::NAME, self)
+    }
+}
+impl<'r> ::core::fmt::Display for DataReader<'r> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        write!(f, "{} {{ ", Self::NAME)?;
+        write!(f, "{}: {}", "spawns", self.spawns())?;
+        write!(f, ", {}: {}", "pipes", self.pipes())?;
+        write!(f, ", {}: {}", "writes", self.writes())?;
+        let extra_count = self.count_extra_fields();
+        if extra_count != 0 {
+            write!(f, ", .. ({} fields)", extra_count)?;
+        }
+        write!(f, " }}")
+    }
+}
+impl<'r> DataReader<'r> {
+    pub const FIELD_COUNT: usize = 3;
+    pub fn total_size(&self) -> usize {
+        molecule::unpack_number(self.as_slice()) as usize
+    }
+    pub fn field_count(&self) -> usize {
+        if self.total_size() == molecule::NUMBER_SIZE {
+            0
+        } else {
+            (molecule::unpack_number(&self.as_slice()[molecule::NUMBER_SIZE..]) as usize / 4) - 1
+        }
+    }
+    pub fn count_extra_fields(&self) -> usize {
+        self.field_count() - Self::FIELD_COUNT
+    }
+    pub fn has_extra_fields(&self) -> bool {
+        Self::FIELD_COUNT != self.field_count()
+    }
+    pub fn spawns(&self) -> SpawnsReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[4..]) as usize;
+        let end = molecule::unpack_number(&slice[8..]) as usize;
+        SpawnsReader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn pipes(&self) -> PipesReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[8..]) as usize;
+        let end = molecule::unpack_number(&slice[12..]) as usize;
+        PipesReader::new_unchecked(&self.as_slice()[start..end])
+    }
+    pub fn writes(&self) -> WritesReader<'r> {
+        let slice = self.as_slice();
+        let start = molecule::unpack_number(&slice[12..]) as usize;
+        if self.has_extra_fields() {
+            let end = molecule::unpack_number(&slice[16..]) as usize;
+            WritesReader::new_unchecked(&self.as_slice()[start..end])
+        } else {
+            WritesReader::new_unchecked(&self.as_slice()[start..])
+        }
+    }
+}
+impl<'r> molecule::prelude::Reader<'r> for DataReader<'r> {
+    type Entity = Data;
+    const NAME: &'static str = "DataReader";
+    fn to_entity(&self) -> Self::Entity {
+        Self::Entity::new_unchecked(self.as_slice().to_owned().into())
+    }
+    fn new_unchecked(slice: &'r [u8]) -> Self {
+        DataReader(slice)
+    }
+    fn as_slice(&self) -> &'r [u8] {
+        self.0
+    }
+    fn verify(slice: &[u8], compatible: bool) -> molecule::error::VerificationResult<()> {
+        use molecule::verification_error as ve;
+        let slice_len = slice.len();
+        if slice_len < molecule::NUMBER_SIZE {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE, slice_len);
+        }
+        let total_size = molecule::unpack_number(slice) as usize;
+        if slice_len != total_size {
+            return ve!(Self, TotalSizeNotMatch, total_size, slice_len);
+        }
+        if slice_len < molecule::NUMBER_SIZE * 2 {
+            return ve!(Self, HeaderIsBroken, molecule::NUMBER_SIZE * 2, slice_len);
+        }
+        let offset_first = molecule::unpack_number(&slice[molecule::NUMBER_SIZE..]) as usize;
+        if offset_first % molecule::NUMBER_SIZE != 0 || offset_first < molecule::NUMBER_SIZE * 2 {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        if slice_len < offset_first {
+            return ve!(Self, HeaderIsBroken, offset_first, slice_len);
+        }
+        let field_count = offset_first / molecule::NUMBER_SIZE - 1;
+        if field_count < Self::FIELD_COUNT {
+            return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
+        } else if !compatible && field_count > Self::FIELD_COUNT {
+            return ve!(Self, FieldCountNotMatch, Self::FIELD_COUNT, field_count);
+        };
+        let mut offsets: Vec<usize> = slice[molecule::NUMBER_SIZE..offset_first]
+            .chunks_exact(molecule::NUMBER_SIZE)
+            .map(|x| molecule::unpack_number(x) as usize)
+            .collect();
+        offsets.push(total_size);
+        if offsets.windows(2).any(|i| i[0] > i[1]) {
+            return ve!(Self, OffsetsNotMatch);
+        }
+        SpawnsReader::verify(&slice[offsets[0]..offsets[1]], compatible)?;
+        PipesReader::verify(&slice[offsets[1]..offsets[2]], compatible)?;
+        WritesReader::verify(&slice[offsets[2]..offsets[3]], compatible)?;
+        Ok(())
+    }
+}
+#[derive(Clone, Debug, Default)]
+pub struct DataBuilder {
+    pub(crate) spawns: Spawns,
+    pub(crate) pipes: Pipes,
+    pub(crate) writes: Writes,
+}
+impl DataBuilder {
+    pub const FIELD_COUNT: usize = 3;
+    pub fn spawns(mut self, v: Spawns) -> Self {
+        self.spawns = v;
+        self
+    }
+    pub fn pipes(mut self, v: Pipes) -> Self {
+        self.pipes = v;
+        self
+    }
+    pub fn writes(mut self, v: Writes) -> Self {
+        self.writes = v;
+        self
+    }
+}
+impl molecule::prelude::Builder for DataBuilder {
+    type Entity = Data;
+    const NAME: &'static str = "DataBuilder";
+    fn expected_length(&self) -> usize {
+        molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1)
+            + self.spawns.as_slice().len()
+            + self.pipes.as_slice().len()
+            + self.writes.as_slice().len()
+    }
+    fn write<W: molecule::io::Write>(&self, writer: &mut W) -> molecule::io::Result<()> {
+        let mut total_size = molecule::NUMBER_SIZE * (Self::FIELD_COUNT + 1);
+        let mut offsets = Vec::with_capacity(Self::FIELD_COUNT);
+        offsets.push(total_size);
+        total_size += self.spawns.as_slice().len();
+        offsets.push(total_size);
+        total_size += self.pipes.as_slice().len();
+        offsets.push(total_size);
+        total_size += self.writes.as_slice().len();
+        writer.write_all(&molecule::pack_number(total_size as molecule::Number))?;
+        for offset in offsets.into_iter() {
+            writer.write_all(&molecule::pack_number(offset as molecule::Number))?;
+        }
+        writer.write_all(self.spawns.as_slice())?;
+        writer.write_all(self.pipes.as_slice())?;
+        writer.write_all(self.writes.as_slice())?;
+        Ok(())
+    }
+    fn build(&self) -> Self::Entity {
+        let mut inner = Vec::with_capacity(self.expected_length());
+        self.write(&mut inner)
+            .unwrap_or_else(|_| panic!("{} build should be ok", Self::NAME));
+        Data::new_unchecked(inner.into())
+    }
+}
diff --git a/script/testdata/spawn_dag_escape_encoding.h b/script/testdata/spawn_dag_escape_encoding.h
new file mode 100644
index 0000000000..2b1590da46
--- /dev/null
+++ b/script/testdata/spawn_dag_escape_encoding.h
@@ -0,0 +1,80 @@
+#ifndef ESCAPE_ENCODING_H_
+#define ESCAPE_ENCODING_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifndef ESCAPE_ERROR_ENCODING
+#define ESCAPE_ERROR_ENCODING 1
+#endif /* ESCAPE_ERROR_ENCODING */
+
+size_t ee_maximum_encoding_length(size_t length) { return length * 2; }
+
+int ee_decode(uint8_t *dst, size_t *dst_length, const uint8_t *src, size_t *src_length) {
+    size_t ds = 0;
+    size_t dl = *dst_length;
+    size_t ss = 0;
+    size_t sl = *src_length;
+
+    while ((ss < sl) && (ds < dl)) {
+        if (src[ss] == 0xFE) {
+            if (ss + 1 >= sl) {
+                return ESCAPE_ERROR_ENCODING;
+            }
+            dst[ds++] = src[ss + 1] + 1;
+            ss += 2;
+        } else {
+            dst[ds++] = src[ss++];
+        }
+    }
+
+    *dst_length = ds;
+    *src_length = ss;
+    return 0;
+}
+
+int ee_decode_char_string_in_place(char *buf, size_t *length) {
+    size_t ss = 0;
+    size_t ds = 0;
+
+    while (buf[ss] != '\0') {
+        if (((uint8_t)buf[ss]) == 0xFE) {
+            if (buf[ss + 1] == '\0') {
+                return ESCAPE_ERROR_ENCODING;
+            }
+            buf[ds++] = buf[ss + 1] + 1;
+            ss += 2;
+        } else {
+            buf[ds++] = buf[ss++];
+        }
+    }
+
+    *length = ds;
+    return 0;
+}
+
+int ee_encode(uint8_t *dst, size_t *dst_length, const uint8_t *src, size_t *src_length) {
+    size_t ds = 0;
+    size_t dl = *dst_length;
+    size_t ss = 0;
+    size_t sl = *src_length;
+
+    while ((ss < sl) && (ds < dl)) {
+        if ((src[ss] == 0x0) || (src[ss] == 0xFE)) {
+            if (ds + 1 >= dl) {
+                break;
+            }
+            dst[ds] = 0xFE;
+            dst[ds + 1] = src[ss++] - 1;
+            ds += 2;
+        } else {
+            dst[ds++] = src[ss++];
+        }
+    }
+
+    *dst_length = ds;
+    *src_length = ss;
+    return 0;
+}
+
+#endif /* ESCAPE_ENCODING_H_ */
diff --git a/script/testdata/spawn_fuzzing b/script/testdata/spawn_fuzzing
new file mode 100755
index 0000000000..0c1602e09a
Binary files /dev/null and b/script/testdata/spawn_fuzzing differ
diff --git a/script/testdata/spawn_fuzzing.c b/script/testdata/spawn_fuzzing.c
new file mode 100644
index 0000000000..7702717c0a
--- /dev/null
+++ b/script/testdata/spawn_fuzzing.c
@@ -0,0 +1,114 @@
+#include "spawn_utils.h"
+
+typedef enum SyscallId { SyscallRead, SyscallWrite, SyscallClose } SyscallId;
+
+typedef struct Command {
+    SyscallId id;
+    uint64_t buf_ptr;
+    uint64_t len_ptr;
+    size_t fd_index;
+} Command;
+
+typedef struct Data {
+    uint8_t* ptr;
+    uint64_t offset;
+    uint64_t total_size;
+} Data;
+
+int extract_command(Data* data, Command* cmd) {
+    if ((data->offset + 1) > data->total_size) {
+        return -1;
+    }
+    uint8_t id = data->ptr[0];
+
+    if (id > 250) {
+        cmd->id = SyscallClose;
+        cmd->fd_index = (size_t)(id % 2);
+        data->offset += 1;
+    } else if (id > 128) {
+        if ((data->offset + 7) > data->total_size) {
+            return -1;
+        }
+        cmd->id = SyscallRead;
+        memcpy(&cmd->buf_ptr, &data->ptr[data->offset + 1], 3);
+        memcpy(&cmd->len_ptr, &data->ptr[data->offset + 4], 3);
+        data->offset += 7;
+    } else {
+        if ((data->offset + 7) > data->total_size) {
+            return -1;
+        }
+        cmd->id = SyscallWrite;
+        memcpy(&cmd->buf_ptr, &data->ptr[data->offset + 1], 3);
+        memcpy(&cmd->len_ptr, &data->ptr[data->offset + 4], 3);
+        data->offset += 7;
+    }
+    return 0;
+}
+
+int random_read_write(uint64_t fds[2], size_t index) {
+    int err = 0;
+    uint8_t cmd_buf[4096] = {0};
+    uint64_t cmd_len = sizeof(cmd_buf);
+
+    err = ckb_load_witness(cmd_buf, &cmd_len, 0, index, CKB_SOURCE_INPUT);
+    CHECK(err);
+    Data data = {.ptr = cmd_buf, .total_size = cmd_len, .offset = 0};
+
+    while (true) {
+        Command cmd = {0};
+        err = extract_command(&data, &cmd);
+        if (err) break;
+        if (cmd.id == SyscallRead) {
+            ckb_read(fds[CKB_STDIN], (void*)cmd.buf_ptr, (uint64_t*)cmd.len_ptr);
+            // ignore error
+        } else if (cmd.id == SyscallWrite) {
+            ckb_write(fds[CKB_STDOUT], (void*)cmd.buf_ptr, (uint64_t*)cmd.len_ptr);
+            // ignore error
+        } else if (cmd.id == SyscallClose) {
+            ckb_close(fds[cmd.fd_index]);
+            // ignore error
+        } else {
+            CHECK2(false, -1);
+        }
+    }
+exit:
+    return err;
+}
+
+int parent_entry() {
+    int err = 0;
+    uint64_t pid = 0;
+    const char* argv[] = {"", 0};
+    uint64_t fds[2] = {0};
+
+    err = full_spawn(0, 1, argv, fds, &pid);
+    CHECK(err);
+    random_read_write(fds, 0);
+
+    int8_t exit_code = 0;
+    err = ckb_wait(pid, &exit_code);
+    CHECK(err);
+    CHECK(exit_code);
+exit:
+    return err;
+}
+
+int child_entry() {
+    int err = 0;
+    uint64_t inherited_fds[2];
+    size_t inherited_fds_length = 2;
+    err = ckb_inherited_file_descriptors(inherited_fds, &inherited_fds_length);
+    CHECK(err);
+    random_read_write(inherited_fds, 0);
+
+exit:
+    return err;
+}
+
+int main(int argc, const char* argv[]) {
+    if (argc > 0) {
+        return child_entry();
+    } else {
+        return parent_entry();
+    }
+}
diff --git a/script/testdata/spawn_huge_swap b/script/testdata/spawn_huge_swap
new file mode 100755
index 0000000000..3d7ab1ca7a
Binary files /dev/null and b/script/testdata/spawn_huge_swap differ
diff --git a/script/testdata/spawn_huge_swap.c b/script/testdata/spawn_huge_swap.c
new file mode 100644
index 0000000000..2666857631
--- /dev/null
+++ b/script/testdata/spawn_huge_swap.c
@@ -0,0 +1,65 @@
+#include "spawn_utils.h"
+
+// 2.4 M bytes
+static uint64_t g_data[300 * 1024];
+
+int main() {
+    int err = 0;
+    uint64_t fds[2] = {0};
+    uint64_t pid = 0;
+    uint64_t current_pid = ckb_process_id();
+    size_t argc = 1;
+    const char* argv[2] = {"", 0};
+    int8_t exit_code = 0;
+
+    printf("current pid = %d", current_pid);
+    for (size_t i = 0; i < sizeof(g_data) / sizeof(uint64_t); i++) {
+        g_data[i] = current_pid;
+    }
+
+    if (current_pid == 7) {
+        // wait forever
+        ckb_wait(0, &exit_code);
+    } else {
+        err = full_spawn(0, argc, argv, fds, &pid);
+        CHECK(err);
+        if (current_pid == 0) {
+            uint8_t buf[1] = {0};
+            while (true) {
+                size_t len = 1;
+                ckb_read(fds[CKB_STDIN], buf, &len);
+            }
+        } else if (current_pid == 1) {
+            uint64_t inherited_fds[3];
+            size_t fds_len = 3;
+            err = ckb_inherited_file_descriptors(inherited_fds, &fds_len);
+            CHECK(err);
+            uint8_t buf[1] = {0};
+            while (true) {
+                size_t len = 1;
+                ckb_write(inherited_fds[CKB_STDOUT], buf, &len);
+                ckb_read(fds[CKB_STDIN], buf, &len);
+            }
+        } else if (current_pid == 2) {
+            uint64_t inherited_fds[3];
+            size_t fds_len = 3;
+            err = ckb_inherited_file_descriptors(inherited_fds, &fds_len);
+            CHECK(err);
+            uint8_t buf[1] = {0};
+            while (true) {
+                size_t len = 1;
+                ckb_write(inherited_fds[CKB_STDOUT], buf, &len);
+            }
+        } else {
+            // wait forever
+            ckb_wait(0, &exit_code);
+        }
+    }
+    // avoid g_data to be optimized
+    for (size_t i = 0; i < sizeof(g_data) / sizeof(uint64_t); i++) {
+        err += (int8_t)g_data[i];
+    }
+
+exit:
+    return err;
+}
\ No newline at end of file
diff --git a/script/testdata/spawn_io_cycles b/script/testdata/spawn_io_cycles
new file mode 100755
index 0000000000..e77022ac8b
Binary files /dev/null and b/script/testdata/spawn_io_cycles differ
diff --git a/script/testdata/spawn_io_cycles.c b/script/testdata/spawn_io_cycles.c
new file mode 100644
index 0000000000..e58151f4d8
--- /dev/null
+++ b/script/testdata/spawn_io_cycles.c
@@ -0,0 +1,81 @@
+#include <stdint.h>
+#include <string.h>
+
+#include "ckb_syscalls.h"
+#include "spawn_utils.h"
+
+#define BUFFER_SIZE 1024 * 4
+
+typedef struct {
+    uint64_t io_size;
+    bool check_buffer;
+} ScriptArgs;
+
+int parent(ScriptArgs* args, uint8_t* buffer) {
+    int err = 0;
+    const char* argv[] = {"", 0};
+    uint64_t fds[2] = {0};
+    uint64_t pid = 0;
+    err = full_spawn(0, 1, argv, fds, &pid);
+    CHECK(err);
+
+    uint64_t buf_len = args->io_size;
+
+    err = ckb_read(fds[CKB_STDIN], buffer, &buf_len);
+    CHECK(err);
+    CHECK2(buf_len == args->io_size, -1);
+    if (args->check_buffer) {
+        for (size_t i = 0; i < args->io_size; i++)
+            CHECK2(buffer[i] == (uint8_t)i, -1);
+    }
+
+    int8_t exit_code = 0;
+    err = ckb_wait(pid, &exit_code);
+    CHECK(err);
+    CHECK(exit_code);
+
+exit:
+    return err;
+}
+
+int child(ScriptArgs* args, uint8_t* buffer) {
+    int err = 0;
+    uint64_t inherited_fds[2];
+    size_t inherited_fds_length = 2;
+    err = ckb_inherited_file_descriptors(inherited_fds, &inherited_fds_length);
+    CHECK(err);
+
+    uint64_t buf_len = args->io_size;
+
+    if (args->check_buffer) {
+        for (size_t i = 0; i < args->io_size; i++) buffer[i] = i;
+    }
+
+    err = ckb_write(inherited_fds[CKB_STDOUT], buffer, &buf_len);
+
+    CHECK(err);
+    CHECK2(buf_len == args->io_size, -1);
+exit:
+    return err;
+}
+
+int main() {
+    int err = 0;
+    ScriptArgs script_args;
+    size_t script_args_length = sizeof(script_args);
+    err = load_script_args((uint8_t*)&script_args, &script_args_length);
+    CHECK(err);
+    CHECK2(script_args_length == sizeof(script_args), -1);
+
+    uint64_t cid = ckb_process_id();
+    uint8_t buffer[BUFFER_SIZE] = {0};
+
+    if (cid == 0) {
+        return parent(&script_args, buffer);
+    } else {
+        return child(&script_args, buffer);
+    }
+
+exit:
+    return err;
+}
diff --git a/script/testdata/spawn_peak_memory_2m_to_32m b/script/testdata/spawn_peak_memory_2m_to_32m
deleted file mode 100755
index ebe14775db..0000000000
Binary files a/script/testdata/spawn_peak_memory_2m_to_32m and /dev/null differ
diff --git a/script/testdata/spawn_peak_memory_2m_to_32m.c b/script/testdata/spawn_peak_memory_2m_to_32m.c
deleted file mode 100644
index 11beb1e02a..0000000000
--- a/script/testdata/spawn_peak_memory_2m_to_32m.c
+++ /dev/null
@@ -1,36 +0,0 @@
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "ckb_syscalls.h"
-
-int main(int argc, char *argv[]) {
-  int8_t spawn_exit_code = 255;
-  spawn_args_t spgs = {
-      .memory_limit = 4,
-      .exit_code = &spawn_exit_code,
-      .content = NULL,
-      .content_length = NULL,
-  };
-  int8_t can_i_spawn = 0;
-  if (argc == 0) {
-    can_i_spawn = 1;
-  }
-  uint64_t depth = (uint64_t)atoi(argv[0]);
-  if (depth < 14) {
-    can_i_spawn = 1;
-  }
-  if (can_i_spawn) {
-    char buffer[20];
-    itoa(depth + 1, buffer, 10);
-    const char *argv[] = {buffer};
-    uint64_t success = ckb_spawn(0, 3, 0, 1, argv, &spgs);
-    if (success != 0) {
-      return success;
-    }
-    if (spawn_exit_code != 0) {
-      return 1;
-    }
-  }
-  return 0;
-}
diff --git a/script/testdata/spawn_peak_memory_4m_to_32m b/script/testdata/spawn_peak_memory_4m_to_32m
deleted file mode 100755
index 28d8274b57..0000000000
Binary files a/script/testdata/spawn_peak_memory_4m_to_32m and /dev/null differ
diff --git a/script/testdata/spawn_peak_memory_4m_to_32m.c b/script/testdata/spawn_peak_memory_4m_to_32m.c
deleted file mode 100644
index bd91167ce0..0000000000
--- a/script/testdata/spawn_peak_memory_4m_to_32m.c
+++ /dev/null
@@ -1,36 +0,0 @@
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "ckb_syscalls.h"
-
-int main(int argc, char *argv[]) {
-  int8_t spawn_exit_code = 255;
-  spawn_args_t spgs = {
-      .memory_limit = 8,
-      .exit_code = &spawn_exit_code,
-      .content = NULL,
-      .content_length = NULL,
-  };
-  int8_t can_i_spawn = 0;
-  if (argc == 0) {
-    can_i_spawn = 1;
-  }
-  uint64_t depth = (uint64_t)atoi(argv[0]);
-  if (depth < 7) {
-    can_i_spawn = 1;
-  }
-  if (can_i_spawn) {
-    char buffer[20];
-    itoa(depth + 1, buffer, 10);
-    const char *argv[] = {buffer};
-    uint64_t success = ckb_spawn(0, 3, 0, 1, argv, &spgs);
-    if (success != 0) {
-      return success;
-    }
-    if (spawn_exit_code != 0) {
-      return 1;
-    }
-  }
-  return 0;
-}
diff --git a/script/testdata/spawn_peak_memory_512k_to_32m b/script/testdata/spawn_peak_memory_512k_to_32m
deleted file mode 100755
index 118c5ab1d3..0000000000
Binary files a/script/testdata/spawn_peak_memory_512k_to_32m and /dev/null differ
diff --git a/script/testdata/spawn_peak_memory_512k_to_32m.c b/script/testdata/spawn_peak_memory_512k_to_32m.c
deleted file mode 100644
index 21680926ce..0000000000
--- a/script/testdata/spawn_peak_memory_512k_to_32m.c
+++ /dev/null
@@ -1,36 +0,0 @@
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "ckb_syscalls.h"
-
-int main(int argc, char *argv[]) {
-  int8_t spawn_exit_code = 255;
-  spawn_args_t spgs = {
-      .memory_limit = 1,
-      .exit_code = &spawn_exit_code,
-      .content = NULL,
-      .content_length = NULL,
-  };
-  int8_t can_i_spawn = 0;
-  if (argc == 0) {
-    can_i_spawn = 1;
-  }
-  uint64_t depth = (uint64_t)atoi(argv[0]);
-  if (depth < 56) {
-    can_i_spawn = 1;
-  }
-  if (can_i_spawn) {
-    char buffer[20];
-    itoa(depth + 1, buffer, 10);
-    const char *argv[] = {buffer};
-    uint64_t success = ckb_spawn(0, 3, 0, 1, argv, &spgs);
-    if (success != 0) {
-      return success;
-    }
-    if (spawn_exit_code != 0) {
-      return 1;
-    }
-  }
-  return 0;
-}
diff --git a/script/testdata/spawn_recursive b/script/testdata/spawn_recursive
index ce415ca010..80d777b5be 100755
Binary files a/script/testdata/spawn_recursive and b/script/testdata/spawn_recursive differ
diff --git a/script/testdata/spawn_recursive.c b/script/testdata/spawn_recursive.c
index 8b3510572a..d82b0b38cb 100644
--- a/script/testdata/spawn_recursive.c
+++ b/script/testdata/spawn_recursive.c
@@ -1,19 +1,3 @@
-#include <stdint.h>
-#include <string.h>
+#include "spawn_utils.h"
 
-#include "ckb_syscalls.h"
-
-int main() {
-  int8_t spawn_exit_code = 255;
-  spawn_args_t spgs = {
-      .memory_limit = 8,
-      .exit_code = &spawn_exit_code,
-      .content = NULL,
-      .content_length = NULL,
-  };
-  uint64_t success = ckb_spawn(0, 3, 0, 0, NULL, &spgs);
-  if (success != 0) {
-    return success;
-  }
-  return spawn_exit_code;
-}
+int main() { return simple_spawn(0); }
diff --git a/script/testdata/spawn_saturate_memory b/script/testdata/spawn_saturate_memory
new file mode 100755
index 0000000000..08e51f96c8
Binary files /dev/null and b/script/testdata/spawn_saturate_memory differ
diff --git a/script/testdata/spawn_saturate_memory.c b/script/testdata/spawn_saturate_memory.c
new file mode 100644
index 0000000000..de977b10db
--- /dev/null
+++ b/script/testdata/spawn_saturate_memory.c
@@ -0,0 +1,45 @@
+#include "spawn_utils.h"
+
+#define MAX_MEMORY (4 * 1024 * 1024)
+#define PAGE_SIZE (4 * 1024)
+
+extern char _end[];
+
+void dirty_all_pages() {
+    uint64_t addr = (uint64_t)_end;
+    while (addr < MAX_MEMORY) {
+        uint8_t* ptr = (uint8_t*)addr;
+        *ptr = 0;
+        addr += PAGE_SIZE;
+    }
+}
+
+int main(int argc, const char* argv[]) {
+    int err = 0;
+    if (argc > 0) {
+        // child
+        dirty_all_pages();
+        uint64_t inherited_fds[2];
+        size_t inherited_fds_length = 2;
+        err = ckb_inherited_file_descriptors(inherited_fds, &inherited_fds_length);
+        uint64_t length = MAX_MEMORY;
+        // Write a piece of data starting from address 0 with a size of 4M.
+        // It should not consume any memory.
+        err = ckb_write(inherited_fds[CKB_STDOUT], 0, &length);
+        // should be blocked forever since there is no reading on other end
+        CHECK(err);
+    } else {
+        // parent
+        for (size_t i = 0; i < 15; i++) {
+            uint64_t pid = 0;
+            const char* argv[] = {"", 0};
+            uint64_t fds[2] = {0};
+            err = full_spawn(0, 1, argv, fds, &pid);
+            CHECK(err);
+        }
+        dirty_all_pages();
+    }
+
+exit:
+    return err;
+}
diff --git a/script/testdata/spawn_times b/script/testdata/spawn_times
index c7dcd39e58..0eed0c30ae 100755
Binary files a/script/testdata/spawn_times and b/script/testdata/spawn_times differ
diff --git a/script/testdata/spawn_times.c b/script/testdata/spawn_times.c
new file mode 100644
index 0000000000..c40100f16b
--- /dev/null
+++ b/script/testdata/spawn_times.c
@@ -0,0 +1,12 @@
+#include "spawn_utils.h"
+
+int main() {
+    int err = 0;
+    for (size_t i = 0; i < 10000; i++) {
+        err = simple_spawn(0);
+        CHECK(err);
+    }
+
+exit:
+    return err;
+}
diff --git a/script/testdata/spawn_times.md b/script/testdata/spawn_times.md
deleted file mode 100644
index 351817947d..0000000000
--- a/script/testdata/spawn_times.md
+++ /dev/null
@@ -1,81 +0,0 @@
-This binary comes from: <https://github.com/gpBlockchain/ckb-test-contracts/blob/main/rust/acceptance-contracts/contracts/spawn_demo/src/spawn_times.rs>. Since I couldn't build a binary in C that would cause the same bug, I just added the binary to the project.
-
-```rs
-#![no_std]
-#![cfg_attr(not(test), no_main)]
-
-#[cfg(test)]
-extern crate alloc;
-
-#[cfg(not(test))]
-use ckb_std::default_alloc;
-#[cfg(not(test))]
-ckb_std::entry!(program_entry);
-#[cfg(not(test))]
-default_alloc!();
-
-use core::result::Result;
-
-use alloc::{vec};
-use core::ffi::{CStr};
-
-use ckb_std::{debug, syscalls};
-use ckb_std::ckb_constants::Source;
-use ckb_std::env::argv;
-use ckb_std::syscalls::{current_cycles, get_memory_limit, set_content, spawn};
-
-
-///
-/// test case :
-/// invoke int ckb_spawn( uint64_t memory_limit,
-///                    size_t index,
-///                    size_t source,
-///                    size_t bounds,
-///                    int argc, char* argv[],
-///                    int8_t* exit_code,
-///                    uint8_t* content,
-///                    uint64_t* content_length);
-///
-///     for {
-///         spawn(xxx)
-///     }
-///     case1 : for {
-///                spawn(xxx)
-///             }
-///
-///     result：
-///         return ERROR : ExceededMaximumCycles
-///
-pub fn program_entry() -> i8 {
-    // let argvs = argv();
-    // debug!("argvs length:{:?}:{:?}",argvs.len(),argvs);
-
-    if get_memory_limit() != 8 {
-        return 0;
-    }
-    let mut exit_code: i8 = 0;
-    let mut content: [u8; 10] = [1; 10];
-
-    let content_length: u64 = content.len() as u64;
-    let mut spawn_args = syscalls::SpawnArgs {
-        memory_limit: 8,
-        exit_code: &mut exit_code as *mut i8,
-        content: content.as_mut_ptr(),
-        content_length: &content_length as *const u64 as *mut u64,
-    };
-    // let cstr1 = CStr::from_bytes_with_nul(b"arg0\0").unwrap();
-    //argv is empty
-    let cstrs = vec![];
-
-    spawn_args.memory_limit = 1;
-    for i in 0..10000 {
-        debug!("current idx:{:?}",i);
-        let result = spawn(0, Source::CellDep, 0, cstrs.as_slice(), &spawn_args);
-        assert_eq!(exit_code, 0);
-        // debug!("result:{:?}",result);
-        let cycles = current_cycles();
-        debug!("cycle:{:?}",cycles);
-    }
-    return 0;
-}
-```
diff --git a/script/testdata/spawn_utils.h b/script/testdata/spawn_utils.h
new file mode 100644
index 0000000000..cb385ba560
--- /dev/null
+++ b/script/testdata/spawn_utils.h
@@ -0,0 +1,239 @@
+
+#ifndef __UTILS_H__
+#define __UTILS_H__
+
+#include <stdio.h>
+#include <stdbool.h>
+
+#include "ckb_consts.h"
+#include "ckb_syscalls.h"
+#include "blockchain.h"
+
+enum CkbSpawnError {
+    ErrorCommon = 31,
+    ErrorRead,
+    ErrorWrite,
+    ErrorPipe,
+    ErrorSpawn,
+};
+
+#define CHECK2(cond, code)                                                     \
+    do {                                                                       \
+        if (!(cond)) {                                                         \
+            printf("error at %s:%d, error code %d", __FILE__, __LINE__, code); \
+            err = code;                                                        \
+            goto exit;                                                         \
+        }                                                                      \
+    } while (0)
+
+#define CHECK(_code)                                                           \
+    do {                                                                       \
+        int code = (_code);                                                    \
+        if (code != 0) {                                                       \
+            printf("error at %s:%d, error code %d", __FILE__, __LINE__, code); \
+            err = code;                                                        \
+            goto exit;                                                         \
+        }                                                                      \
+    } while (0)
+#endif
+
+#define countof(array) (sizeof(array) / sizeof(array[0]))
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+
+// conventions
+#define CKB_STDIN (0)
+#define CKB_STDOUT (1)
+
+// mimic stdio fds on linux
+int create_std_fds(uint64_t* fds, uint64_t* inherited_fds) {
+    int err = 0;
+
+    uint64_t to_child[2] = {0};
+    uint64_t to_parent[2] = {0};
+    err = ckb_pipe(to_child);
+    CHECK(err);
+    err = ckb_pipe(to_parent);
+    CHECK(err);
+
+    inherited_fds[0] = to_child[0];
+    inherited_fds[1] = to_parent[1];
+    inherited_fds[2] = 0;
+
+    fds[CKB_STDIN] = to_parent[0];
+    fds[CKB_STDOUT] = to_child[1];
+
+exit:
+    return err;
+}
+
+// spawn script at `index` in cell_deps without any argc, argv
+int simple_spawn(size_t index) {
+    int err = 0;
+    int8_t spawn_exit_code = 255;
+    const char* argv[1] = {0};
+    uint64_t pid = 0;
+    uint64_t fds[1] = {0};
+    spawn_args_t spgs = {.argc = 0, .argv = argv, .process_id = &pid, .inherited_fds = fds};
+    err = ckb_spawn(index, CKB_SOURCE_CELL_DEP, 0, 0, &spgs);
+    CHECK(err);
+    err = ckb_wait(pid, &spawn_exit_code);
+    CHECK(err);
+    CHECK(spawn_exit_code);
+
+exit:
+    return err;
+}
+
+// spawn script at `index` in cell_deps with argv
+int simple_spawn_args(size_t index, int argc, const char* argv[]) {
+    int err = 0;
+    int8_t spawn_exit_code = 255;
+    uint64_t pid = 0;
+    uint64_t fds[1] = {0};
+    spawn_args_t spgs = {.argc = argc, .argv = argv, .process_id = &pid, .inherited_fds = fds};
+    err = ckb_spawn(index, CKB_SOURCE_CELL_DEP, 0, 0, &spgs);
+    CHECK(err);
+    err = ckb_wait(pid, &spawn_exit_code);
+    CHECK(err);
+    CHECK(spawn_exit_code);
+exit:
+    return err;
+}
+
+int full_spawn(size_t index, int argc, const char* argv[], uint64_t fds[2], uint64_t* pid) {
+    int err = 0;
+    uint64_t inherited_fds[3] = {0};
+    err = create_std_fds(fds, inherited_fds);
+    CHECK(err);
+    spawn_args_t spgs = {.argc = argc, .argv = argv, .process_id = pid, .inherited_fds = inherited_fds};
+    err = ckb_spawn(0, CKB_SOURCE_CELL_DEP, 0, 0, &spgs);
+    CHECK(err);
+exit:
+    return err;
+}
+
+// read exact `length` bytes into buffer.
+// Will wait forever when less bytes are written on write fd.
+int read_exact(uint64_t fd, void* buffer, size_t length, size_t* actual_length) {
+    int err = 0;
+    size_t remaining_length = length;
+    uint8_t* start_buffer = buffer;
+    while (true) {
+        size_t n = remaining_length;
+        err = ckb_read(fd, start_buffer, &n);
+        if (err == CKB_OTHER_END_CLOSED) {
+            err = 0;
+            break;
+        } else {
+            CHECK(err);
+        }
+        start_buffer += n;
+        remaining_length -= n;
+        *actual_length = length - remaining_length;
+        if (remaining_length == 0) {
+            break;
+        }
+    }
+
+exit:
+    return err;
+}
+
+// Function read_all reads from fd until an error or EOF and returns the data it read.
+int ckb_read_all(uint64_t fd, void* buffer, size_t* length) {
+    int err = 0;
+    size_t read_length = 0;
+    size_t full_length = *length;
+    uint8_t* b = buffer;
+    while (true) {
+        size_t n = full_length - read_length;
+        err = ckb_read(fd, b, &n);
+        if (err == CKB_OTHER_END_CLOSED) {
+            err = 0;
+            *length = read_length;
+            break;
+        } else {
+            CHECK(err);
+        }
+        if (full_length - read_length == 0) {
+            err = CKB_LENGTH_NOT_ENOUGH;
+            CHECK(err);
+        }
+        b += n;
+        read_length += n;
+        *length = read_length;
+    }
+
+exit:
+    return err;
+}
+
+// write exact `length` bytes into buffer.
+// Will wait forever when less bytes are read on read fd.
+int write_exact(uint64_t fd, void* buffer, size_t length, size_t* actual_length) {
+    int err = 0;
+    size_t remaining_length = length;
+    uint8_t* start_buffer = buffer;
+    while (true) {
+        size_t n = remaining_length;
+        err = ckb_write(fd, start_buffer, &n);
+        if (err == CKB_OTHER_END_CLOSED) {
+            err = 0;
+            break;
+        } else {
+            CHECK(err);
+        }
+        start_buffer += n;
+        remaining_length -= n;
+        *actual_length = length - remaining_length;
+        if (remaining_length == 0) {
+            break;
+        }
+    }
+exit:
+    return err;
+}
+
+#define SCRIPT_SIZE 4096
+
+int load_script_args(uint8_t* args, size_t* length) {
+    int err = 0;
+    uint64_t len = SCRIPT_SIZE;
+    uint8_t script[SCRIPT_SIZE];
+    err = ckb_load_script(script, &len, 0);
+    CHECK(err);
+    CHECK2(len <= SCRIPT_SIZE, -2);
+    mol_seg_t script_seg = {0};
+    script_seg.ptr = (uint8_t*)script;
+    script_seg.size = len;
+    CHECK2(MolReader_Script_verify(&script_seg, false) == MOL_OK, -3);
+    mol_seg_t args_seg = MolReader_Script_get_args(&script_seg);
+    mol_seg_t bytes_seg = MolReader_Bytes_raw_bytes(&args_seg);
+    size_t copy_length = MIN(bytes_seg.size, *length);
+    memcpy(args, bytes_seg.ptr, copy_length);
+    *length = copy_length;
+
+exit:
+    return err;
+}
+
+void print_hex(const uint8_t* buf, size_t length) {
+    char dst[65] = {0};
+    int j = 0;
+    for (int i = 0; i < length; i++) {
+        char hi = buf[i] >> 4;
+        char lo = buf[i] & 0xf;
+        dst[j * 2] = hi + (hi < 10 ? '0' : ('a' - 10));
+        dst[j * 2 + 1] = lo + (lo < 10 ? '0' : ('a' - 10));
+        j += 1;
+        if (j > 31) {
+            j = 0;
+            printf("%s", dst);
+        }
+    }
+    if (j != 0) {
+        dst[j * 2] = 0;
+        printf("%s", dst);
+    }
+}
diff --git a/script/testdata/sub1.c b/script/testdata/sub1.c
index 90d790729d..a31aaf63c4 100644
--- a/script/testdata/sub1.c
+++ b/script/testdata/sub1.c
@@ -1,5 +1,3 @@
 #include <stdint.h>
 
-__attribute__((visibility("default"))) uint64_t apply (uint64_t num) {
-    return num - 1;
-}
+__attribute__((visibility("default"))) uint64_t apply(uint64_t num) { return num - 1; }
diff --git a/script/testdata/sub1.lib b/script/testdata/sub1.lib
index 9afeae0776..b1a89a227b 100755
Binary files a/script/testdata/sub1.lib and b/script/testdata/sub1.lib differ
diff --git a/script/testdata/verify.c b/script/testdata/verify.c
index 9c3a1a4402..c42eb92b76 100644
--- a/script/testdata/verify.c
+++ b/script/testdata/verify.c
@@ -1,4 +1,5 @@
 #include <stdlib.h>
+
 #include "sha3.h"
 
 #define SHA3_BLOCK_SIZE 32
@@ -7,15 +8,11 @@
 #define CUSTOM_PRINT_ERR 1
 
 #include "syscall.h"
-void custom_abort()
-{
-  syscall_errno(93, 10, 0, 0, 0, 0, 0);
-}
+void custom_abort() { syscall_errno(93, 10, 0, 0, 0, 0, 0); }
 
-int custom_print_err(const char * arg, ...)
-{
-  (void) arg;
-  return 0;
+int custom_print_err(const char* arg, ...) {
+    (void)arg;
+    return 0;
 }
 
 #include <secp256k1_static.h>
@@ -26,39 +23,40 @@ int custom_print_err(const char * arg, ...)
  */
 #include <secp256k1.c>
 
-int char_to_int(char ch)
-{
-  if (ch >= '0' && ch <= '9') {
-    return ch - '0';
-  }
-  if (ch >= 'a' && ch <= 'f') {
-    return ch - 'a' + 10;
-  }
-  return -1;
+int char_to_int(char ch) {
+    if (ch >= '0' && ch <= '9') {
+        return ch - '0';
+    }
+    if (ch >= 'a' && ch <= 'f') {
+        return ch - 'a' + 10;
+    }
+    return -1;
 }
 
-int hex_to_bin(char* buf, size_t buf_len, const char* hex)
-{
-  int i = 0;
+int hex_to_bin(char* buf, size_t buf_len, const char* hex) {
+    int i = 0;
 
-  for (; i < buf_len && hex[i * 2] != '\0' && hex[i * 2 + 1] != '\0'; i++) {
-    int a = char_to_int(hex[i * 2]);
-    int b = char_to_int(hex[i * 2 + 1]);
+    for (; i < buf_len && hex[i * 2] != '\0' && hex[i * 2 + 1] != '\0'; i++) {
+        int a = char_to_int(hex[i * 2]);
+        int b = char_to_int(hex[i * 2 + 1]);
 
-    if (a < 0 || b < 0) {
-      return -1;
-    }
+        if (a < 0 || b < 0) {
+            return -1;
+        }
 
-    buf[i] = ((a & 0xF) << 4) | (b & 0xF);
-  }
+        buf[i] = ((a & 0xF) << 4) | (b & 0xF);
+    }
 
-  if (i == buf_len && hex[i * 2] != '\0') {
-    return -1;
-  }
-  return i;
+    if (i == buf_len && hex[i * 2] != '\0') {
+        return -1;
+    }
+    return i;
 }
 
-#define CHECK_LEN(x) if ((x) <= 0) { return x; }
+#define CHECK_LEN(x) \
+    if ((x) <= 0) {  \
+        return x;    \
+    }
 
 /*
  * Arguments are listed in the following order:
@@ -80,56 +78,55 @@ int hex_to_bin(char* buf, size_t buf_len, const char* hex)
  * Note all hex values passed in as arguments must have lower case letters for
  * deterministic behavior.
  */
-int main(int argc, char* argv[])
-{
-  char buf[256];
-  int len;
+int main(int argc, char* argv[]) {
+    char buf[256];
+    int len;
 
-  if (argc < 4) {
-    return -1;
-  }
-
-  secp256k1_context context;
-  int ret = secp256k1_context_initialize(&context, SECP256K1_CONTEXT_VERIFY);
-  if (ret == 0) {
-    return 4;
-  }
-
-  len = hex_to_bin(buf, 65, argv[argc - 2]);
-  CHECK_LEN(len);
-  secp256k1_pubkey pubkey;
-
-  ret = secp256k1_ec_pubkey_parse(&context, &pubkey, buf, len);
-  if (ret == 0) {
-    return 1;
-  }
-
-  len = hex_to_bin(buf, 256, argv[argc - 1]);
-  CHECK_LEN(len);
-  secp256k1_ecdsa_signature signature;
-  secp256k1_ecdsa_signature_parse_der(&context, &signature, buf, len);
-  if (ret == 0) {
-    return 3;
-  }
-
-  sha3_ctx_t sha3_ctx;
-  unsigned char hash[SHA3_BLOCK_SIZE];
-  sha3_init(&sha3_ctx, SHA3_BLOCK_SIZE);
-  for (int i = 1; i < argc -2; i++) {
-    sha3_update(&sha3_ctx, argv[i], strlen(argv[i]));
-  }
-  sha3_final(hash, &sha3_ctx);
-
-  sha3_init(&sha3_ctx, SHA3_BLOCK_SIZE);
-  sha3_update(&sha3_ctx, hash, SHA3_BLOCK_SIZE);
-  sha3_final(hash, &sha3_ctx);
-
-  ret = secp256k1_ecdsa_verify(&context, &signature, hash, &pubkey);
-  if (ret == 1) {
-    ret = 0;
-  } else {
-    ret = 2;
-  }
-
-  return ret;
+    if (argc < 4) {
+        return -1;
+    }
+
+    secp256k1_context context;
+    int ret = secp256k1_context_initialize(&context, SECP256K1_CONTEXT_VERIFY);
+    if (ret == 0) {
+        return 4;
+    }
+
+    len = hex_to_bin(buf, 65, argv[argc - 2]);
+    CHECK_LEN(len);
+    secp256k1_pubkey pubkey;
+
+    ret = secp256k1_ec_pubkey_parse(&context, &pubkey, buf, len);
+    if (ret == 0) {
+        return 1;
+    }
+
+    len = hex_to_bin(buf, 256, argv[argc - 1]);
+    CHECK_LEN(len);
+    secp256k1_ecdsa_signature signature;
+    secp256k1_ecdsa_signature_parse_der(&context, &signature, buf, len);
+    if (ret == 0) {
+        return 3;
+    }
+
+    sha3_ctx_t sha3_ctx;
+    unsigned char hash[SHA3_BLOCK_SIZE];
+    sha3_init(&sha3_ctx, SHA3_BLOCK_SIZE);
+    for (int i = 1; i < argc - 2; i++) {
+        sha3_update(&sha3_ctx, argv[i], strlen(argv[i]));
+    }
+    sha3_final(hash, &sha3_ctx);
+
+    sha3_init(&sha3_ctx, SHA3_BLOCK_SIZE);
+    sha3_update(&sha3_ctx, hash, SHA3_BLOCK_SIZE);
+    sha3_final(hash, &sha3_ctx);
+
+    ret = secp256k1_ecdsa_verify(&context, &signature, hash, &pubkey);
+    if (ret == 1) {
+        ret = 0;
+    } else {
+        ret = 2;
+    }
+
+    return ret;
 }
diff --git a/script/testdata/vm_version b/script/testdata/vm_version
index bf39e3d56a..e2c0225e5b 100755
Binary files a/script/testdata/vm_version and b/script/testdata/vm_version differ
diff --git a/script/testdata/vm_version.c b/script/testdata/vm_version.c
index 427f1227f6..d7397d8c98 100644
--- a/script/testdata/vm_version.c
+++ b/script/testdata/vm_version.c
@@ -2,7 +2,7 @@
 
 int main() {
     if (syscall(2041, 0, 0, 0, 0, 0, 0) == 1) {
-      return 0;
+        return 0;
     }
     return 1;
 }
diff --git a/script/testdata/vm_version_2 b/script/testdata/vm_version_2
index 13ea61a6ca..ebc92ae7c8 100755
Binary files a/script/testdata/vm_version_2 and b/script/testdata/vm_version_2 differ
diff --git a/script/testdata/vm_version_2.c b/script/testdata/vm_version_2.c
index 2b1cff6e02..0576c517a0 100644
--- a/script/testdata/vm_version_2.c
+++ b/script/testdata/vm_version_2.c
@@ -2,7 +2,7 @@
 
 int main() {
     if (syscall(2041, 0, 0, 0, 0, 0, 0) == 2) {
-      return 0;
+        return 0;
     }
     return 1;
 }
diff --git a/script/testdata/vm_version_with_snapshot b/script/testdata/vm_version_with_snapshot
index 9e16b52a45..4f27a8944f 100755
Binary files a/script/testdata/vm_version_with_snapshot and b/script/testdata/vm_version_with_snapshot differ
diff --git a/script/testdata/vm_version_with_snapshot.c b/script/testdata/vm_version_with_snapshot.c
index 8861f4a4ed..bea91f5fbe 100644
--- a/script/testdata/vm_version_with_snapshot.c
+++ b/script/testdata/vm_version_with_snapshot.c
@@ -7,22 +7,19 @@
 #define sprintf(...)
 #endif
 
-void try_pause() {
-    syscall(2178, 0, 0, 0, 0, 0, 0);
-}
+void try_pause() { syscall(2178, 0, 0, 0, 0, 0, 0); }
 
-int vm_version() {
-    return syscall(2041, 0, 0, 0, 0, 0, 0);
-}
+int vm_version() { return syscall(2041, 0, 0, 0, 0, 0, 0); }
 
 int main() {
 #ifdef DEBUG
     char message[2048];
 #endif
     int ver;
-    for (int i=0; i<4096; i++) {
+    for (int i = 0; i < 4096; i++) {
         ver = vm_version();
-        sprintf(message, "version = %d", ver); ckb_debug(message);
+        sprintf(message, "version = %d", ver);
+        ckb_debug(message);
         if (i > 16) {
             try_pause();
         }
diff --git a/tx-pool/Cargo.toml b/tx-pool/Cargo.toml
index adf1d5b5c1..f0ff88640a 100644
--- a/tx-pool/Cargo.toml
+++ b/tx-pool/Cargo.toml
@@ -16,6 +16,7 @@ ckb-logger = { path = "../util/logger", version = "= 0.118.0-pre" }
 ckb-verification = { path = "../verification", version = "= 0.118.0-pre" }
 ckb-systemtime = { path = "../util/systemtime", version = "= 0.118.0-pre" }
 lru = "0.7.1"
+num_cpus = "1.16.0"
 
 ckb-dao = { path = "../util/dao", version = "= 0.118.0-pre" }
 ckb-reward-calculator = { path = "../util/reward-calculator", version = "= 0.118.0-pre" }
@@ -34,6 +35,7 @@ ckb-network = { path = "../network", version = "= 0.118.0-pre" }
 ckb-channel = { path = "../util/channel", version = "= 0.118.0-pre" }
 ckb-traits = { path = "../traits", version = "= 0.118.0-pre" }
 ckb-db = { path = "../db", version = "= 0.118.0-pre" }
+ckb-script = { path = "../script", version = "= 0.118.0-pre" }
 sentry = { version = "0.26.0", optional = true }
 serde_json = "1.0"
 rand = "0.8.4"
diff --git a/tx-pool/src/component/chunk.rs b/tx-pool/src/component/chunk.rs
deleted file mode 100644
index 225e0a4ea8..0000000000
--- a/tx-pool/src/component/chunk.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-use ckb_network::PeerIndex;
-use ckb_types::{
-    core::{Cycle, TransactionView},
-    packed::ProposalShortId,
-};
-use ckb_util::{shrink_to_fit, LinkedHashMap};
-
-const SHRINK_THRESHOLD: usize = 100;
-pub(crate) const DEFAULT_MAX_CHUNK_TRANSACTIONS: usize = 100;
-
-#[derive(Debug, Clone, Eq)]
-pub(crate) struct Entry {
-    pub(crate) tx: TransactionView,
-    pub(crate) remote: Option<(Cycle, PeerIndex)>,
-}
-
-impl PartialEq for Entry {
-    fn eq(&self, other: &Entry) -> bool {
-        self.tx == other.tx
-    }
-}
-
-#[derive(Default)]
-pub(crate) struct ChunkQueue {
-    inner: LinkedHashMap<ProposalShortId, Entry>,
-    // memory last pop value for atomic reset
-    front: Option<Entry>,
-}
-
-impl ChunkQueue {
-    pub(crate) fn new() -> Self {
-        ChunkQueue {
-            inner: LinkedHashMap::default(),
-            front: None,
-        }
-    }
-
-    pub fn len(&self) -> usize {
-        self.inner.len()
-    }
-
-    #[allow(dead_code)]
-    pub fn is_empty(&self) -> bool {
-        self.inner.is_empty()
-    }
-
-    pub fn is_full(&self) -> bool {
-        self.len() > DEFAULT_MAX_CHUNK_TRANSACTIONS
-    }
-
-    pub fn contains_key(&self, id: &ProposalShortId) -> bool {
-        self.front
-            .as_ref()
-            .map(|e| e.tx.proposal_short_id())
-            .as_ref()
-            == Some(id)
-            || self.inner.contains_key(id)
-    }
-
-    pub fn shrink_to_fit(&mut self) {
-        shrink_to_fit!(self.inner, SHRINK_THRESHOLD);
-    }
-
-    pub fn clean_front(&mut self) {
-        self.front = None;
-    }
-
-    pub fn pop_front(&mut self) -> Option<Entry> {
-        if let Some(entry) = &self.front {
-            Some(entry.clone())
-        } else {
-            match self.inner.pop_front() {
-                Some((_id, entry)) => {
-                    self.front = Some(entry.clone());
-                    Some(entry)
-                }
-                None => None,
-            }
-        }
-    }
-
-    pub fn remove_chunk_tx(&mut self, id: &ProposalShortId) -> Option<Entry> {
-        let ret = self.inner.remove(id);
-        self.shrink_to_fit();
-        ret
-    }
-
-    pub fn remove_chunk_txs(&mut self, ids: impl Iterator<Item = ProposalShortId>) {
-        for id in ids {
-            self.inner.remove(&id);
-        }
-        self.shrink_to_fit();
-    }
-
-    /// If the queue did not have this tx present, true is returned.
-    /// If the queue did have this tx present, false is returned.
-    pub fn add_tx(&mut self, tx: TransactionView, remote: Option<(Cycle, PeerIndex)>) -> bool {
-        if self.contains_key(&tx.proposal_short_id()) {
-            return false;
-        }
-
-        self.inner
-            .insert(tx.proposal_short_id(), Entry { tx, remote })
-            .is_none()
-    }
-
-    /// Clears the map, removing all elements.
-    pub fn clear(&mut self) {
-        self.inner.clear();
-        self.clean_front();
-        self.shrink_to_fit()
-    }
-}
diff --git a/tx-pool/src/component/mod.rs b/tx-pool/src/component/mod.rs
index e5b8ab3cfc..99937a484c 100644
--- a/tx-pool/src/component/mod.rs
+++ b/tx-pool/src/component/mod.rs
@@ -1,15 +1,14 @@
 pub mod commit_txs_scanner;
 pub mod entry;
 
-pub(crate) mod chunk;
 pub(crate) mod edges;
 pub(crate) mod links;
 pub(crate) mod orphan;
 pub(crate) mod pool_map;
 pub(crate) mod recent_reject;
 pub(crate) mod sort_key;
-
 #[cfg(test)]
 mod tests;
+pub(crate) mod verify_queue;
 
 pub use self::entry::TxEntry;
diff --git a/tx-pool/src/component/tests/chunk.rs b/tx-pool/src/component/tests/chunk.rs
index a811133584..1b5d2fe0dd 100644
--- a/tx-pool/src/component/tests/chunk.rs
+++ b/tx-pool/src/component/tests/chunk.rs
@@ -1,22 +1,149 @@
+use crate::component::tests::util::build_tx;
+use crate::component::verify_queue::{Entry, VerifyQueue};
+use ckb_network::SessionId;
 use ckb_types::core::TransactionBuilder;
+use ckb_types::prelude::Pack;
+use ckb_types::H256;
+use tokio::select;
+use tokio::sync::watch;
+use tokio::time::sleep;
 
-use crate::component::chunk::{ChunkQueue, Entry};
-
-#[test]
-fn basic() {
+const MAX_TX_VERIFY_CYCLES: u64 = 70_000_000;
+#[tokio::test]
+async fn verify_queue_basic() {
     let tx = TransactionBuilder::default().build();
     let entry = Entry {
         tx: tx.clone(),
         remote: None,
     };
+    let tx2 = build_tx(vec![(&tx.hash(), 0)], 1);
+
     let id = tx.proposal_short_id();
-    let mut queue = ChunkQueue::new();
+    let (exit_tx, mut exit_rx) = watch::channel(());
+    let mut queue = VerifyQueue::new(MAX_TX_VERIFY_CYCLES);
+    let queue_rx = queue.subscribe();
+    let count = tokio::spawn(async move {
+        let mut count = 0;
+        loop {
+            select! {
+                _ = queue_rx.notified() => {
+                    count += 1;
+                }
+                _ = exit_rx.changed() => {
+                    break;
+                }
+            }
+        }
+        count
+    });
 
-    assert!(queue.add_tx(tx.clone(), None));
-    assert_eq!(queue.pop_front().as_ref(), Some(&entry));
-    assert!(queue.contains_key(&id));
-    assert!(!queue.add_tx(tx, None));
+    assert!(queue.add_tx(tx.clone(), None).unwrap());
+    sleep(std::time::Duration::from_millis(100)).await;
 
-    queue.clean_front();
+    assert!(!queue.add_tx(tx.clone(), None).unwrap());
+
+    assert_eq!(queue.pop_first(false).as_ref(), Some(&entry));
     assert!(!queue.contains_key(&id));
+
+    assert!(queue.add_tx(tx.clone(), None).unwrap());
+    sleep(std::time::Duration::from_millis(100)).await;
+
+    assert_eq!(queue.pop_first(false).as_ref(), Some(&entry));
+
+    assert!(queue.add_tx(tx.clone(), None).unwrap());
+    sleep(std::time::Duration::from_millis(100)).await;
+
+    assert!(queue.add_tx(tx2.clone(), None).unwrap());
+    sleep(std::time::Duration::from_millis(100)).await;
+
+    exit_tx.send(()).unwrap();
+    let counts = count.await.unwrap();
+    assert_eq!(counts, 4);
+
+    let cur = queue.pop_first(false);
+    assert_eq!(cur.unwrap().tx, tx);
+
+    assert!(!queue.is_empty());
+    let cur = queue.pop_first(false);
+    assert_eq!(cur.unwrap().tx, tx2);
+
+    assert!(queue.is_empty());
+
+    queue.clear();
+    assert!(!queue.contains_key(&id));
+}
+
+#[tokio::test]
+async fn test_verify_different_cycles() {
+    let (exit_tx, mut exit_rx) = watch::channel(());
+    let mut queue = VerifyQueue::new(MAX_TX_VERIFY_CYCLES);
+    let queue_rx = queue.subscribe();
+    let count = tokio::spawn(async move {
+        let mut count = 0;
+        loop {
+            select! {
+                _ = queue_rx.notified() => {
+                    count += 1;
+                }
+                _ = exit_rx.changed() => {
+                    break;
+                }
+            }
+        }
+        count
+    });
+
+    let remote = |cycles| Some((cycles, SessionId::default()));
+
+    let tx0 = build_tx(vec![(&H256([0; 32]).pack(), 0)], 1);
+    assert!(queue.add_tx(tx0.clone(), remote(1001)).unwrap());
+    sleep(std::time::Duration::from_millis(100)).await;
+
+    let tx1 = build_tx(vec![(&H256([1; 32]).pack(), 0)], 1);
+    assert!(queue
+        .add_tx(tx1.clone(), remote(MAX_TX_VERIFY_CYCLES + 1))
+        .unwrap());
+    sleep(std::time::Duration::from_millis(100)).await;
+
+    let tx2 = build_tx(vec![(&H256([2; 32]).pack(), 0)], 1);
+    assert!(queue.add_tx(tx2.clone(), remote(1001)).unwrap());
+    sleep(std::time::Duration::from_millis(100)).await;
+    // now queue should be sorted by time (tx1, tx2)
+
+    let tx3 = build_tx(vec![(&H256([3; 32]).pack(), 0)], 1);
+    assert!(queue.add_tx(tx3.clone(), remote(1001)).unwrap());
+    sleep(std::time::Duration::from_millis(100)).await;
+
+    let tx_size_sum = [&tx0, &tx1, &tx2, &tx3]
+        .iter()
+        .map(|tx| tx.data().serialized_size_in_block())
+        .sum::<usize>();
+
+    assert_eq!(queue.total_tx_size(), tx_size_sum);
+
+    // tx0 should be the first tx in the queue
+    let cur = queue.pop_first(true);
+    assert_eq!(cur.unwrap().tx, tx0);
+
+    let cur = queue.pop_first(true);
+    assert_eq!(cur.unwrap().tx, tx2);
+
+    let cur = queue.pop_first(true);
+    assert_eq!(cur.unwrap().tx, tx3);
+
+    // now there is no small cycle tx
+    let cur = queue.pop_first(true);
+    assert!(cur.is_none());
+
+    // pop the tx with the large cycle
+    let cur = queue.pop_first(false);
+    assert_eq!(cur.unwrap().tx, tx1);
+
+    let cur = queue.pop_first(false);
+    assert!(cur.is_none());
+
+    exit_tx.send(()).unwrap();
+    let counts = count.await.unwrap();
+    assert_eq!(counts, 4);
+    assert_eq!(queue.total_tx_size(), 0);
 }
diff --git a/tx-pool/src/component/verify_queue.rs b/tx-pool/src/component/verify_queue.rs
new file mode 100644
index 0000000000..20d6d77449
--- /dev/null
+++ b/tx-pool/src/component/verify_queue.rs
@@ -0,0 +1,195 @@
+//! Top-level VerifyQueue structure.
+#![allow(missing_docs)]
+extern crate rustc_hash;
+extern crate slab;
+use ckb_logger::error;
+use ckb_network::PeerIndex;
+use ckb_systemtime::unix_time_as_millis;
+use ckb_types::{
+    core::{tx_pool::Reject, Cycle, TransactionView},
+    packed::ProposalShortId,
+};
+use ckb_util::shrink_to_fit;
+use multi_index_map::MultiIndexMap;
+use std::sync::Arc;
+use tokio::sync::Notify;
+
+// 256mb for total_tx_size limit, default max_tx_pool_size is 180mb
+const DEFAULT_MAX_VERIFY_QUEUE_TX_SIZE: usize = 256_000_000;
+const SHRINK_THRESHOLD: usize = 100;
+
+/// The verify queue Entry to verify.
+#[derive(Debug, Clone, Eq)]
+pub struct Entry {
+    pub(crate) tx: TransactionView,
+    pub(crate) remote: Option<(Cycle, PeerIndex)>,
+}
+
+impl PartialEq for Entry {
+    fn eq(&self, other: &Entry) -> bool {
+        self.tx == other.tx
+    }
+}
+
+#[derive(MultiIndexMap, Clone)]
+struct VerifyEntry {
+    /// The transaction id
+    #[multi_index(hashed_unique)]
+    id: ProposalShortId,
+    /// The unix timestamp when entering the Txpool, unit: Millisecond
+    /// This field is used to sort the txs in the queue
+    /// We may add more other sort keys in the future
+    #[multi_index(ordered_non_unique)]
+    added_time: u64,
+
+    /// whether the tx is a large cycle tx
+    #[multi_index(hashed_non_unique)]
+    is_large_cycle: bool,
+
+    /// other sort key
+    inner: Entry,
+}
+
+/// The verify queue is a priority queue of transactions to verify.
+pub(crate) struct VerifyQueue {
+    /// inner tx entry
+    inner: MultiIndexVerifyEntryMap,
+    /// subscribe this notify to get be notified when there is item in the queue
+    ready_rx: Arc<Notify>,
+    /// total tx size in the queue, will reject new transaction if exceed the limit
+    total_tx_size: usize,
+    /// large cycle threshold, from `pool_config.max_tx_verify_cycles`
+    large_cycle_threshold: u64,
+}
+
+impl VerifyQueue {
+    /// Create a new VerifyQueue
+    pub(crate) fn new(large_cycle_threshold: u64) -> Self {
+        VerifyQueue {
+            inner: MultiIndexVerifyEntryMap::default(),
+            ready_rx: Arc::new(Notify::new()),
+            total_tx_size: 0,
+            large_cycle_threshold,
+        }
+    }
+
+    /// Returns true if the queue contains no txs.
+    pub fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+
+    pub fn len(&self) -> usize {
+        self.inner.len()
+    }
+
+    #[cfg(test)]
+    pub fn total_tx_size(&self) -> usize {
+        self.total_tx_size
+    }
+
+    /// Returns true if the queue is full.
+    pub fn is_full(&self, add_tx_size: usize) -> bool {
+        add_tx_size >= DEFAULT_MAX_VERIFY_QUEUE_TX_SIZE - self.total_tx_size
+    }
+
+    /// Returns true if the queue contains a tx with the specified id.
+    pub fn contains_key(&self, id: &ProposalShortId) -> bool {
+        self.inner.get_by_id(id).is_some()
+    }
+
+    /// Shrink the capacity of the queue as much as possible.
+    pub fn shrink_to_fit(&mut self) {
+        shrink_to_fit!(self.inner, SHRINK_THRESHOLD);
+    }
+
+    /// get a queue_rx to subscribe the txs count in the queue
+    pub fn subscribe(&self) -> Arc<Notify> {
+        Arc::clone(&self.ready_rx)
+    }
+
+    /// Remove a tx from the queue
+    pub fn remove_tx(&mut self, id: &ProposalShortId) -> Option<Entry> {
+        self.inner.remove_by_id(id).map(|e| {
+            let tx_size = e.inner.tx.data().serialized_size_in_block();
+            self.total_tx_size = self.total_tx_size.checked_sub(tx_size).unwrap_or_else(|| {
+                error!(
+                    "verify_queue total_tx_size {} overflown by sub {}",
+                    self.total_tx_size, tx_size
+                );
+                0
+            });
+            self.shrink_to_fit();
+            e.inner
+        })
+    }
+
+    /// Remove multiple txs from the queue
+    pub fn remove_txs(&mut self, ids: impl Iterator<Item = ProposalShortId>) {
+        for id in ids {
+            self.remove_tx(&id);
+        }
+    }
+
+    /// Returns the first entry in the queue and remove it
+    pub fn pop_first(&mut self, only_small_cycle: bool) -> Option<Entry> {
+        if let Some(short_id) = self.peek(only_small_cycle) {
+            self.remove_tx(&short_id)
+        } else {
+            None
+        }
+    }
+
+    /// Returns the first entry in the queue
+    pub fn peek(&self, only_small_cycle: bool) -> Option<ProposalShortId> {
+        if only_small_cycle {
+            self.inner.iter_by_added_time().find(|e| !e.is_large_cycle)
+        } else {
+            self.inner.iter_by_added_time().next()
+        }
+        .map(|entry| entry.inner.tx.proposal_short_id())
+    }
+
+    /// If the queue did not have this tx present, true is returned.
+    /// If the queue did have this tx present, false is returned.
+    pub fn add_tx(
+        &mut self,
+        tx: TransactionView,
+        remote: Option<(Cycle, PeerIndex)>,
+    ) -> Result<bool, Reject> {
+        if self.contains_key(&tx.proposal_short_id()) {
+            return Ok(false);
+        }
+        let tx_size = tx.data().serialized_size_in_block();
+        let is_large_cycle = remote
+            .map(|(cycles, _)| cycles > self.large_cycle_threshold)
+            .unwrap_or(false);
+        if self.is_full(tx_size) {
+            return Err(Reject::Full(format!(
+                "verify_queue total_tx_size exceeded, failed to add tx: {:#x}",
+                tx.hash()
+            )));
+        }
+        self.inner.insert(VerifyEntry {
+            id: tx.proposal_short_id(),
+            added_time: unix_time_as_millis(),
+            inner: Entry { tx, remote },
+            is_large_cycle,
+        });
+        self.total_tx_size = self.total_tx_size.checked_add(tx_size).unwrap_or_else(|| {
+            error!(
+                "verify_queue total_tx_size {} overflown by add {}",
+                self.total_tx_size, tx_size
+            );
+            self.total_tx_size
+        });
+        self.ready_rx.notify_one();
+        Ok(true)
+    }
+
+    /// Clears the map, removing all elements.
+    pub fn clear(&mut self) {
+        self.inner.clear();
+        self.total_tx_size = 0;
+        self.shrink_to_fit();
+    }
+}
diff --git a/tx-pool/src/lib.rs b/tx-pool/src/lib.rs
index d122177c01..b22c3248b5 100644
--- a/tx-pool/src/lib.rs
+++ b/tx-pool/src/lib.rs
@@ -3,7 +3,6 @@
 
 pub mod block_assembler;
 mod callback;
-mod chunk_process;
 mod component;
 pub mod error;
 mod persisted;
@@ -12,6 +11,7 @@ mod pool_cell;
 mod process;
 pub mod service;
 mod util;
+mod verify_mgr;
 
 pub use ckb_jsonrpc_types::BlockTemplate;
 pub use component::entry::TxEntry;
diff --git a/tx-pool/src/process.rs b/tx-pool/src/process.rs
index 5a5961530c..b249be78d7 100644
--- a/tx-pool/src/process.rs
+++ b/tx-pool/src/process.rs
@@ -16,8 +16,8 @@ use ckb_jsonrpc_types::BlockTemplate;
 use ckb_logger::Level::Trace;
 use ckb_logger::{debug, error, info, log_enabled_target, trace_target};
 use ckb_network::PeerIndex;
+use ckb_script::ChunkCommand;
 use ckb_snapshot::Snapshot;
-use ckb_store::data_loader_wrapper::AsDataLoader;
 use ckb_types::core::error::OutPointError;
 use ckb_types::{
     core::{cell::ResolvedTransaction, BlockView, Capacity, Cycle, HeaderView, TransactionView},
@@ -26,14 +26,13 @@ use ckb_types::{
 use ckb_util::LinkedHashSet;
 use ckb_verification::{
     cache::{CacheEntry, Completed},
-    ContextualTransactionVerifier, DaoScriptSizeVerifier, ScriptVerifyResult,
-    TimeRelativeTransactionVerifier, TxVerifyEnv,
+    TxVerifyEnv,
 };
 use std::collections::HashSet;
 use std::collections::{HashMap, VecDeque};
 use std::sync::Arc;
-use std::time::Duration;
-use tokio::task::block_in_place;
+use std::time::{Duration, Instant};
+use tokio::sync::watch;
 
 const DELAY_LIMIT: usize = 1_500 * 21; // 1_500 per block, 21 blocks
 
@@ -52,12 +51,6 @@ pub enum TxStatus {
     Proposed,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum ProcessResult {
-    Suspended,
-    Completed(Completed),
-}
-
 impl TxStatus {
     fn with_env(self, header: &HeaderView) -> TxVerifyEnv {
         match self {
@@ -207,16 +200,16 @@ impl TxPoolService {
         }
     }
 
+    pub(crate) async fn verify_queue_contains(&self, tx: &TransactionView) -> bool {
+        let queue = self.verify_queue.read().await;
+        queue.contains_key(&tx.proposal_short_id())
+    }
+
     pub(crate) async fn orphan_contains(&self, tx: &TransactionView) -> bool {
         let orphan = self.orphan.read().await;
         orphan.contains_key(&tx.proposal_short_id())
     }
 
-    pub(crate) async fn chunk_contains(&self, tx: &TransactionView) -> bool {
-        let chunk = self.chunk.read().await;
-        chunk.contains_key(&tx.proposal_short_id())
-    }
-
     pub(crate) async fn with_tx_pool_read_lock<U, F: FnMut(&TxPool, Arc<Snapshot>) -> U>(
         &self,
         mut f: F,
@@ -308,44 +301,26 @@ impl TxPoolService {
         &self,
         tx: TransactionView,
         remote: Option<(Cycle, PeerIndex)>,
-    ) -> Result<(), Reject> {
+    ) -> Result<bool, Reject> {
         // non contextual verify first
         self.non_contextual_verify(&tx, remote)?;
 
-        if self.chunk_contains(&tx).await {
-            return Err(Reject::Duplicated(tx.hash()));
-        }
-
         if self.orphan_contains(&tx).await {
             debug!("reject tx {} already in orphan pool", tx.hash());
             return Err(Reject::Duplicated(tx.hash()));
         }
 
-        if let Some((ret, snapshot)) = self._resumeble_process_tx(tx.clone(), remote).await {
-            match ret {
-                Ok(processed) => {
-                    if let ProcessResult::Completed(completed) = processed {
-                        self.after_process(tx, remote, &snapshot, &Ok(completed))
-                            .await;
-                    }
-                    Ok(())
-                }
-                Err(e) => {
-                    self.after_process(tx, remote, &snapshot, &Err(e.clone()))
-                        .await;
-                    Err(e)
-                }
-            }
-        } else {
-            Ok(())
+        if self.verify_queue_contains(&tx).await {
+            return Err(Reject::Duplicated(tx.hash()));
         }
+        self.enqueue_verify_queue(tx, remote).await
     }
 
     pub(crate) async fn test_accept_tx(&self, tx: TransactionView) -> Result<Completed, Reject> {
         // non contextual verify first
         self.non_contextual_verify(&tx, None)?;
 
-        if self.chunk_contains(&tx).await {
+        if self.verify_queue_contains(&tx).await {
             return Err(Reject::Duplicated(tx.hash()));
         }
 
@@ -364,11 +339,14 @@ impl TxPoolService {
         // non contextual verify first
         self.non_contextual_verify(&tx, remote)?;
 
-        if self.chunk_contains(&tx).await || self.orphan_contains(&tx).await {
+        if self.verify_queue_contains(&tx).await || self.orphan_contains(&tx).await {
             return Err(Reject::Duplicated(tx.hash()));
         }
 
-        if let Some((ret, snapshot)) = self._process_tx(tx.clone(), remote.map(|r| r.0)).await {
+        if let Some((ret, snapshot)) = self
+            ._process_tx(tx.clone(), remote.map(|r| r.0), None)
+            .await
+        {
             self.after_process(tx, remote, &snapshot, &ret).await;
             ret
         } else {
@@ -395,8 +373,8 @@ impl TxPoolService {
     pub(crate) async fn remove_tx(&self, tx_hash: Byte32) -> bool {
         let id = ProposalShortId::from_tx_hash(&tx_hash);
         {
-            let mut chunk = self.chunk.write().await;
-            if chunk.remove_chunk_tx(&id).is_some() {
+            let mut queue = self.verify_queue.write().await;
+            if queue.remove_tx(&id).is_some() {
                 return true;
             }
         }
@@ -569,17 +547,16 @@ impl TxPoolService {
             for orphan in orphans.into_iter() {
                 if orphan.cycle > self.tx_pool_config.max_tx_verify_cycles {
                     debug!(
-                        "process_orphan {} added to chunk; find previous from {}",
+                        "process_orphan {} added to verify queue; find previous from {}",
                         orphan.tx.hash(),
                         tx.hash(),
                     );
                     self.remove_orphan_tx(&orphan.tx.proposal_short_id()).await;
-                    self.chunk
-                        .write()
+                    self.enqueue_verify_queue(orphan.tx, Some((orphan.cycle, orphan.peer)))
                         .await
-                        .add_tx(orphan.tx, Some((orphan.cycle, orphan.peer)));
+                        .expect("enqueue suspended tx");
                 } else if let Some((ret, snapshot)) = self
-                    ._process_tx(orphan.tx.clone(), Some(orphan.cycle))
+                    ._process_tx(orphan.tx.clone(), Some(orphan.cycle), None)
                     .await
                 {
                     match ret {
@@ -668,150 +645,15 @@ impl TxPoolService {
         self.network.ban_peer(peer, DEFAULT_BAN_TIME, reason);
     }
 
-    async fn _resumeble_process_tx(
-        &self,
-        tx: TransactionView,
-        remote: Option<(Cycle, PeerIndex)>,
-    ) -> Option<(Result<ProcessResult, Reject>, Arc<Snapshot>)> {
-        let limit_cycles = self.tx_pool_config.max_tx_verify_cycles;
-        let wtx_hash = tx.witness_hash();
-
-        let (ret, snapshot) = self.pre_check(&tx).await;
-        let (tip_hash, rtx, status, fee, tx_size) = try_or_return_with_snapshot!(ret, snapshot);
-
-        if self.is_in_delay_window(&snapshot) {
-            let mut delay = self.delay.write().await;
-            if delay.len() < DELAY_LIMIT {
-                delay.insert(tx.proposal_short_id(), tx);
-            }
-            return None;
-        }
-
-        let cached = self.fetch_tx_verify_cache(&tx).await;
-        let tip_header = snapshot.tip_header();
-        let tx_env = Arc::new(status.with_env(tip_header));
-
-        let data_loader = snapshot.as_data_loader();
-
-        let completed = if let Some(ref entry) = cached {
-            match entry {
-                CacheEntry::Completed(completed) => {
-                    let ret = TimeRelativeTransactionVerifier::new(
-                        Arc::clone(&rtx),
-                        Arc::clone(&self.consensus),
-                        data_loader,
-                        tx_env,
-                    )
-                    .verify()
-                    .map_err(Reject::Verification);
-                    try_or_return_with_snapshot!(ret, snapshot);
-                    *completed
-                }
-                CacheEntry::Suspended(_) => {
-                    return Some((Ok(ProcessResult::Suspended), snapshot));
-                }
-            }
-        } else {
-            let is_chunk_full = self.is_chunk_full().await;
-
-            let ret = block_in_place(|| {
-                let verifier = ContextualTransactionVerifier::new(
-                    Arc::clone(&rtx),
-                    Arc::clone(&self.consensus),
-                    data_loader,
-                    tx_env,
-                );
-
-                let (ret, fee) = verifier
-                    .resumable_verify(limit_cycles)
-                    .map_err(Reject::Verification)?;
-
-                match ret {
-                    ScriptVerifyResult::Completed(cycles) => {
-                        if let Err(e) = DaoScriptSizeVerifier::new(
-                            Arc::clone(&rtx),
-                            Arc::clone(&self.consensus),
-                            snapshot.as_data_loader(),
-                        )
-                        .verify()
-                        {
-                            return Err(Reject::Verification(e));
-                        }
-                        if let Some((declared, _)) = remote {
-                            if declared != cycles {
-                                return Err(Reject::DeclaredWrongCycles(declared, cycles));
-                            }
-                        }
-                        Ok(CacheEntry::completed(cycles, fee))
-                    }
-                    ScriptVerifyResult::Suspended(state) => {
-                        if is_chunk_full {
-                            Err(Reject::Full("chunk".to_owned()))
-                        } else {
-                            let snap = Arc::new(state.try_into().map_err(Reject::Verification)?);
-                            Ok(CacheEntry::suspended(snap, fee))
-                        }
-                    }
-                }
-            });
-
-            let entry = try_or_return_with_snapshot!(ret, snapshot);
-            match entry {
-                cached @ CacheEntry::Suspended(_) => {
-                    let ret = self
-                        .enqueue_suspended_tx(rtx.transaction.clone(), cached, remote)
-                        .await;
-                    try_or_return_with_snapshot!(ret, snapshot);
-                    return Some((Ok(ProcessResult::Suspended), snapshot));
-                }
-                CacheEntry::Completed(completed) => completed,
-            }
-        };
-
-        let entry = TxEntry::new(rtx, completed.cycles, fee, tx_size);
-
-        let (ret, submit_snapshot) = self.submit_entry(tip_hash, entry, status).await;
-        try_or_return_with_snapshot!(ret, submit_snapshot);
-
-        self.notify_block_assembler(status).await;
-        if cached.is_none() {
-            // update cache
-            let txs_verify_cache = Arc::clone(&self.txs_verify_cache);
-            tokio::spawn(async move {
-                let mut guard = txs_verify_cache.write().await;
-                guard.put(wtx_hash, CacheEntry::Completed(completed));
-            });
-        }
-
-        Some((Ok(ProcessResult::Completed(completed)), submit_snapshot))
-    }
-
-    pub(crate) async fn is_chunk_full(&self) -> bool {
-        self.chunk.read().await.is_full()
-    }
-
-    pub(crate) async fn enqueue_suspended_tx(
-        &self,
-        tx: TransactionView,
-        cached: CacheEntry,
-        remote: Option<(Cycle, PeerIndex)>,
-    ) -> Result<(), Reject> {
-        let wtx_hash = tx.witness_hash();
-        let mut chunk = self.chunk.write().await;
-        if chunk.add_tx(tx, remote) {
-            let mut guard = self.txs_verify_cache.write().await;
-            guard.put(wtx_hash, cached);
-        }
-
-        Ok(())
-    }
-
     pub(crate) async fn _process_tx(
         &self,
         tx: TransactionView,
         declared_cycles: Option<Cycle>,
+        command_rx: Option<&mut watch::Receiver<ChunkCommand>>,
     ) -> Option<(Result<Completed, Reject>, Arc<Snapshot>)> {
         let wtx_hash = tx.witness_hash();
+        let instant = Instant::now();
+        let is_sync_process = command_rx.is_none();
 
         let (ret, snapshot) = self.pre_check(&tx).await;
 
@@ -836,7 +678,9 @@ impl TxPoolService {
             tx_env,
             &verify_cache,
             max_cycles,
-        );
+            command_rx,
+        )
+        .await;
 
         let verified = try_or_return_with_snapshot!(verified_ret, snapshot);
 
@@ -861,10 +705,19 @@ impl TxPoolService {
             let txs_verify_cache = Arc::clone(&self.txs_verify_cache);
             tokio::spawn(async move {
                 let mut guard = txs_verify_cache.write().await;
-                guard.put(wtx_hash, CacheEntry::Completed(verified));
+                guard.put(wtx_hash, verified);
             });
         }
 
+        if let Some(metrics) = ckb_metrics::handle() {
+            let elapsed = instant.elapsed().as_secs_f64();
+            if is_sync_process {
+                metrics.ckb_tx_pool_sync_process.observe(elapsed);
+            } else {
+                metrics.ckb_tx_pool_async_process.observe(elapsed);
+            }
+        }
+
         Some((Ok(verified), submit_snapshot))
     }
 
@@ -886,7 +739,9 @@ impl TxPoolService {
             tx_env,
             &verify_cache,
             max_cycles,
+            None,
         )
+        .await
     }
 
     pub(crate) async fn update_tx_pool_for_reorg(
@@ -939,7 +794,7 @@ impl TxPoolService {
 
             let txs_opt = if is_in_delay_window {
                 {
-                    self.chunk.write().await.clear();
+                    self.verify_queue.write().await.clear();
                 }
                 Some(tx_pool.drain_all_transactions())
             } else {
@@ -971,7 +826,8 @@ impl TxPoolService {
             }
 
             // notice: readd_detached_tx don't update cache
-            self.readd_detached_tx(&mut tx_pool, retain, fetched_cache);
+            self.readd_detached_tx(&mut tx_pool, retain, fetched_cache)
+                .await;
 
             txs_opt
         };
@@ -1010,11 +866,20 @@ impl TxPoolService {
 
         self.remove_orphan_txs_by_attach(&attached).await;
         {
-            let mut chunk = self.chunk.write().await;
-            chunk.remove_chunk_txs(attached.iter().map(|tx| tx.proposal_short_id()));
+            let mut queue = self.verify_queue.write().await;
+            queue.remove_txs(attached.iter().map(|tx| tx.proposal_short_id()));
         }
     }
 
+    async fn enqueue_verify_queue(
+        &self,
+        tx: TransactionView,
+        remote: Option<(Cycle, PeerIndex)>,
+    ) -> Result<bool, Reject> {
+        let mut queue = self.verify_queue.write().await;
+        queue.add_tx(tx, remote)
+    }
+
     async fn remove_orphan_txs_by_attach<'a>(&self, txs: &LinkedHashSet<TransactionView>) {
         for tx in txs.iter() {
             self.process_orphan_tx(tx).await;
@@ -1023,7 +888,7 @@ impl TxPoolService {
         orphan.remove_orphan_txs(txs.iter().map(|tx| tx.proposal_short_id()));
     }
 
-    fn readd_detached_tx(
+    async fn readd_detached_tx(
         &self,
         tx_pool: &mut TxPool,
         txs: Vec<TransactionView>,
@@ -1045,7 +910,10 @@ impl TxPoolService {
                         tx_env,
                         &verify_cache,
                         max_cycles,
-                    ) {
+                        None,
+                    )
+                    .await
+                    {
                         let entry = TxEntry::new(rtx, verified.cycles, fee, tx_size);
                         if let Err(e) = _submit_entry(tx_pool, status, entry, &self.callbacks) {
                             error!("readd_detached_tx submit_entry {} error {}", tx_hash, e);
diff --git a/tx-pool/src/service.rs b/tx-pool/src/service.rs
index 7d46926b1c..cb9c3939f7 100644
--- a/tx-pool/src/service.rs
+++ b/tx-pool/src/service.rs
@@ -2,20 +2,23 @@
 
 use crate::block_assembler::{self, BlockAssembler};
 use crate::callback::{Callbacks, PendingCallback, ProposedCallback, RejectCallback};
-use crate::chunk_process::ChunkCommand;
+use crate::component::orphan::OrphanPool;
 use crate::component::pool_map::{PoolEntry, Status};
-use crate::component::{chunk::ChunkQueue, orphan::OrphanPool};
+use crate::component::verify_queue::VerifyQueue;
 use crate::error::{handle_recv_error, handle_send_cmd_error, handle_try_send_error};
 use crate::pool::TxPool;
 use crate::util::after_delay_window;
+use crate::verify_mgr::VerifyMgr;
 use ckb_app_config::{BlockAssemblerConfig, TxPoolConfig};
 use ckb_async_runtime::Handle;
 use ckb_chain_spec::consensus::Consensus;
 use ckb_channel::oneshot;
 use ckb_error::AnyError;
 use ckb_jsonrpc_types::BlockTemplate;
-use ckb_logger::{error, info};
+use ckb_logger::error;
+use ckb_logger::info;
 use ckb_network::{NetworkController, PeerIndex};
+use ckb_script::ChunkCommand;
 use ckb_snapshot::Snapshot;
 use ckb_stop_handler::new_tokio_exit_rx;
 use ckb_store::ChainStore;
@@ -117,6 +120,7 @@ pub(crate) enum Message {
     PlugEntry(Request<(Vec<TxEntry>, PlugTarget), ()>),
     #[cfg(feature = "internal")]
     PackageTxs(Request<Option<u64>, Vec<TxEntry>>),
+    SubmitLocalTestTx(Request<TransactionView, SubmitTxResult>),
 }
 
 #[derive(Debug, Hash, Eq, PartialEq)]
@@ -341,6 +345,7 @@ impl TxPoolController {
 
     /// Sends suspend chunk process cmd
     pub fn suspend_chunk_process(&self) -> Result<(), AnyError> {
+        //debug!("[verify-test] run suspend_chunk_process");
         self.chunk_tx
             .send(ChunkCommand::Suspend)
             .map_err(handle_send_cmd_error)
@@ -349,6 +354,7 @@ impl TxPoolController {
 
     /// Sends continue chunk process cmd
     pub fn continue_chunk_process(&self) -> Result<(), AnyError> {
+        //debug!("[verify-test] run continue_chunk_process");
         self.chunk_tx
             .send(ChunkCommand::Resume)
             .map_err(handle_send_cmd_error)
@@ -388,6 +394,11 @@ impl TxPoolController {
     pub fn package_txs(&self, bytes_limit: Option<u64>) -> Result<Vec<TxEntry>, AnyError> {
         send_message!(self, PackageTxs, bytes_limit)
     }
+
+    /// Submit local test tx to tx-pool, this tx will be put into verify queue directly.
+    pub fn submit_local_test_tx(&self, tx: TransactionView) -> Result<SubmitTxResult, AnyError> {
+        send_message!(self, SubmitLocalTestTx, tx)
+    }
 }
 
 /// A builder used to create TxPoolService.
@@ -404,7 +415,6 @@ pub struct TxPoolServiceBuilder {
     pub(crate) handle: Handle,
     pub(crate) tx_relay_sender: ckb_channel::Sender<TxVerificationResult>,
     pub(crate) chunk_rx: watch::Receiver<ChunkCommand>,
-    pub(crate) chunk: Arc<RwLock<ChunkQueue>>,
     pub(crate) started: Arc<AtomicBool>,
     pub(crate) block_assembler_channel: (
         mpsc::Sender<BlockAssemblerMessage>,
@@ -427,7 +437,6 @@ impl TxPoolServiceBuilder {
         let (reorg_sender, reorg_receiver) = mpsc::channel(DEFAULT_CHANNEL_SIZE);
         let signal_receiver: CancellationToken = new_tokio_exit_rx();
         let (chunk_tx, chunk_rx) = watch::channel(ChunkCommand::Resume);
-        let chunk = Arc::new(RwLock::new(ChunkQueue::new()));
         let started = Arc::new(AtomicBool::new(false));
 
         let controller = TxPoolController {
@@ -453,7 +462,6 @@ impl TxPoolServiceBuilder {
             handle: handle.clone(),
             tx_relay_sender,
             chunk_rx,
-            chunk,
             started,
             block_assembler_channel,
         };
@@ -486,6 +494,10 @@ impl TxPoolServiceBuilder {
         let consensus = self.snapshot.cloned_consensus();
         let after_delay_window = after_delay_window(&self.snapshot);
 
+        let verify_queue = Arc::new(RwLock::new(VerifyQueue::new(
+            self.tx_pool_config.max_tx_verify_cycles,
+        )));
+
         let tx_pool = TxPool::new(self.tx_pool_config, self.snapshot);
         let txs = match tx_pool.load_from_file() {
             Ok(txs) => txs,
@@ -506,21 +518,17 @@ impl TxPoolServiceBuilder {
             callbacks: Arc::new(self.callbacks),
             tx_relay_sender: self.tx_relay_sender,
             block_assembler_sender,
-            chunk: self.chunk,
+            verify_queue: Arc::clone(&verify_queue),
             network,
             consensus,
             delay: Arc::new(RwLock::new(LinkedHashMap::new())),
             after_delay: Arc::new(AtomicBool::new(after_delay_window)),
         };
 
-        let signal_receiver = self.signal_receiver.clone();
-        let chunk_process = crate::chunk_process::ChunkProcess::new(
-            service.clone(),
-            self.chunk_rx,
-            signal_receiver,
-        );
+        let mut verify_mgr =
+            VerifyMgr::new(service.clone(), self.chunk_rx, self.signal_receiver.clone());
+        self.handle.spawn(async move { verify_mgr.run().await });
 
-        self.handle.spawn(async move { chunk_process.run().await });
         let mut receiver = self.receiver;
         let mut reorg_receiver = self.reorg_receiver;
         let handle_clone = self.handle.clone();
@@ -662,7 +670,7 @@ pub(crate) struct TxPoolService {
     pub(crate) callbacks: Arc<Callbacks>,
     pub(crate) network: NetworkController,
     pub(crate) tx_relay_sender: ckb_channel::Sender<TxVerificationResult>,
-    pub(crate) chunk: Arc<RwLock<ChunkQueue>>,
+    pub(crate) verify_queue: Arc<RwLock<VerifyQueue>>,
     pub(crate) block_assembler_sender: mpsc::Sender<BlockAssemblerMessage>,
     pub(crate) delay: Arc<RwLock<LinkedHashMap<ProposalShortId, TransactionView>>>,
     pub(crate) after_delay: Arc<AtomicBool>,
@@ -724,7 +732,16 @@ async fn process(mut service: TxPoolService, message: Message) {
             responder,
             arguments: tx,
         }) => {
-            let result = service.resumeble_process_tx(tx, None).await;
+            let result = service.process_tx(tx, None).await.map(|_| ());
+            if let Err(e) = responder.send(result) {
+                error!("Responder sending submit_tx result failed {:?}", e);
+            };
+        }
+        Message::SubmitLocalTestTx(Request {
+            responder,
+            arguments: tx,
+        }) => {
+            let result = service.resumeble_process_tx(tx, None).await.map(|_| ());
             if let Err(e) = responder.send(result) {
                 error!("Responder sending submit_tx result failed {:?}", e);
             };
@@ -751,19 +768,12 @@ async fn process(mut service: TxPoolService, message: Message) {
             responder,
             arguments: (tx, declared_cycles, peer),
         }) => {
-            if declared_cycles > service.tx_pool_config.max_tx_verify_cycles {
-                let _result = service
-                    .resumeble_process_tx(tx, Some((declared_cycles, peer)))
-                    .await;
-                if let Err(e) = responder.send(()) {
-                    error!("Responder sending submit_tx result failed {:?}", e);
-                };
-            } else {
-                let _result = service.process_tx(tx, Some((declared_cycles, peer))).await;
-                if let Err(e) = responder.send(()) {
-                    error!("Responder sending submit_tx result failed {:?}", e);
-                };
-            }
+            let _result = service
+                .resumeble_process_tx(tx, Some((declared_cycles, peer)))
+                .await;
+            if let Err(e) = responder.send(()) {
+                error!("Responder sending submit_tx result failed {:?}", e);
+            };
         }
         Message::NotifyTxs(Notify { arguments: txs }) => {
             for tx in txs {
@@ -972,6 +982,7 @@ impl TxPoolService {
     async fn info(&self) -> TxPoolInfo {
         let tx_pool = self.tx_pool.read().await;
         let orphan = self.orphan.read().await;
+        let verify_queue = self.verify_queue.read().await;
         let tip_header = tx_pool.snapshot.tip_header();
         TxPoolInfo {
             tip_hash: tip_header.hash(),
@@ -986,6 +997,7 @@ impl TxPoolService {
             last_txs_updated_at: tx_pool.pool_map.get_max_update_time(),
             tx_size_limit: TRANSACTION_SIZE_LIMIT,
             max_tx_pool_size: self.tx_pool_config.max_tx_pool_size as u64,
+            verify_queue_size: verify_queue.len(),
         }
     }
 
diff --git a/tx-pool/src/util.rs b/tx-pool/src/util.rs
index c94eab5b25..0bb3bf9aae 100644
--- a/tx-pool/src/util.rs
+++ b/tx-pool/src/util.rs
@@ -2,6 +2,7 @@ use crate::error::Reject;
 use crate::pool::TxPool;
 use ckb_chain_spec::consensus::Consensus;
 use ckb_dao::DaoCalculator;
+use ckb_script::ChunkCommand;
 use ckb_snapshot::Snapshot;
 use ckb_store::data_loader_wrapper::AsDataLoader;
 use ckb_store::ChainStore;
@@ -15,7 +16,7 @@ use ckb_verification::{
     TimeRelativeTransactionVerifier, TxVerifyEnv,
 };
 use std::sync::Arc;
-use tokio::task::block_in_place;
+use tokio::{sync::watch, task::block_in_place};
 
 pub(crate) fn check_txid_collision(tx_pool: &TxPool, tx: &TransactionView) -> Result<(), Reject> {
     let short_id = tx.proposal_short_id();
@@ -82,39 +83,37 @@ pub(crate) fn non_contextual_verify(
     Ok(())
 }
 
-pub(crate) fn verify_rtx(
+pub(crate) async fn verify_rtx(
     snapshot: Arc<Snapshot>,
     rtx: Arc<ResolvedTransaction>,
     tx_env: Arc<TxVerifyEnv>,
     cache_entry: &Option<CacheEntry>,
     max_tx_verify_cycles: Cycle,
+    command_rx: Option<&mut watch::Receiver<ChunkCommand>>,
 ) -> Result<Completed, Reject> {
     let consensus = snapshot.cloned_consensus();
     let data_loader = snapshot.as_data_loader();
 
-    if let Some(ref cached) = cache_entry {
-        match cached {
-            CacheEntry::Completed(completed) => {
-                TimeRelativeTransactionVerifier::new(rtx, consensus, data_loader, tx_env)
-                    .verify()
-                    .map(|_| *completed)
-                    .map_err(Reject::Verification)
-            }
-            CacheEntry::Suspended(suspended) => {
-                ContextualTransactionVerifier::new(Arc::clone(&rtx), consensus, data_loader, tx_env)
-                    .complete(max_tx_verify_cycles, false, &suspended.snap)
-                    .and_then(|result| {
-                        DaoScriptSizeVerifier::new(
-                            rtx,
-                            snapshot.cloned_consensus(),
-                            snapshot.as_data_loader(),
-                        )
-                        .verify()?;
-                        Ok(result)
-                    })
-                    .map_err(Reject::Verification)
-            }
-        }
+    if let Some(ref completed) = cache_entry {
+        TimeRelativeTransactionVerifier::new(rtx, consensus, data_loader, tx_env)
+            .verify()
+            .map(|_| *completed)
+            .map_err(Reject::Verification)
+    } else if let Some(command_rx) = command_rx {
+        ContextualTransactionVerifier::new(
+            Arc::clone(&rtx),
+            consensus,
+            data_loader,
+            Arc::clone(&tx_env),
+        )
+        .verify_with_pause(max_tx_verify_cycles, command_rx)
+        .await
+        .and_then(|result| {
+            DaoScriptSizeVerifier::new(rtx, snapshot.cloned_consensus(), snapshot.as_data_loader())
+                .verify()?;
+            Ok(result)
+        })
+        .map_err(Reject::Verification)
     } else {
         block_in_place(|| {
             ContextualTransactionVerifier::new(Arc::clone(&rtx), consensus, data_loader, tx_env)
diff --git a/tx-pool/src/verify_mgr.rs b/tx-pool/src/verify_mgr.rs
new file mode 100644
index 0000000000..ec2080b6ba
--- /dev/null
+++ b/tx-pool/src/verify_mgr.rs
@@ -0,0 +1,202 @@
+extern crate num_cpus;
+use crate::component::verify_queue::VerifyQueue;
+use crate::service::TxPoolService;
+use ckb_logger::info;
+use ckb_script::ChunkCommand;
+use ckb_stop_handler::CancellationToken;
+use std::sync::Arc;
+use tokio::sync::{watch, RwLock};
+use tokio::task::JoinHandle;
+
+#[derive(Clone, Debug, PartialEq)]
+enum WorkerRole {
+    OnlySmallCycleTx,
+    SubmitTimeFirst,
+}
+
+struct Worker {
+    tasks: Arc<RwLock<VerifyQueue>>,
+    command_rx: watch::Receiver<ChunkCommand>,
+    service: TxPoolService,
+    exit_signal: CancellationToken,
+    status: ChunkCommand,
+    role: WorkerRole,
+}
+
+impl Clone for Worker {
+    fn clone(&self) -> Self {
+        Self {
+            tasks: Arc::clone(&self.tasks),
+            command_rx: self.command_rx.clone(),
+            exit_signal: self.exit_signal.clone(),
+            service: self.service.clone(),
+            status: self.status.clone(),
+            role: self.role.clone(),
+        }
+    }
+}
+
+impl Worker {
+    pub fn new(
+        service: TxPoolService,
+        tasks: Arc<RwLock<VerifyQueue>>,
+        command_rx: watch::Receiver<ChunkCommand>,
+        exit_signal: CancellationToken,
+        role: WorkerRole,
+    ) -> Self {
+        Worker {
+            service,
+            tasks,
+            command_rx,
+            exit_signal,
+            status: ChunkCommand::Resume,
+            role,
+        }
+    }
+
+    pub fn start(mut self) -> JoinHandle<()> {
+        tokio::spawn(async move {
+            let queue_ready = self.tasks.read().await.subscribe();
+            loop {
+                tokio::select! {
+                    _ = self.exit_signal.cancelled() => {
+                        break;
+                    }
+                    _ = self.command_rx.changed() => {
+                        self.status = self.command_rx.borrow().to_owned();
+                        self.process_inner().await;
+                    }
+                    _ = queue_ready.notified() => {
+                        self.process_inner().await;
+                    }
+                };
+            }
+        })
+    }
+
+    async fn process_inner(&mut self) {
+        loop {
+            if self.status != ChunkCommand::Resume {
+                return;
+            }
+            // cheap query to check queue is not empty
+            if self.tasks.read().await.is_empty() {
+                return;
+            }
+            // pick a entry to run verify
+            let entry = match self
+                .tasks
+                .write()
+                .await
+                .pop_first(self.role == WorkerRole::OnlySmallCycleTx)
+            {
+                Some(entry) => entry,
+                None => return,
+            };
+
+            let (res, snapshot) = self
+                .service
+                ._process_tx(
+                    entry.tx.clone(),
+                    entry.remote.map(|e| e.0),
+                    Some(&mut self.command_rx),
+                )
+                .await
+                .expect("verify worker _process_tx failed");
+
+            self.service
+                .after_process(entry.tx, entry.remote, &snapshot, &res)
+                .await;
+        }
+    }
+}
+
+pub(crate) struct VerifyMgr {
+    workers: Vec<(watch::Sender<ChunkCommand>, Worker)>,
+    join_handles: Option<Vec<JoinHandle<()>>>,
+    signal_exit: CancellationToken,
+    command_rx: watch::Receiver<ChunkCommand>,
+}
+
+impl VerifyMgr {
+    pub fn new(
+        service: TxPoolService,
+        command_rx: watch::Receiver<ChunkCommand>,
+        signal_exit: CancellationToken,
+    ) -> Self {
+        // `num_cpus::get()` will always return at least 1,
+        // don't use too many cpu cores to avoid high workload on the system
+        let worker_num = std::cmp::max(num_cpus::get() * 3 / 4, 1);
+        let workers: Vec<_> = (0..worker_num)
+            .map({
+                let tasks = Arc::clone(&service.verify_queue);
+                let signal_exit = signal_exit.clone();
+                move |idx| {
+                    let role = if idx == 0 && worker_num > 1 {
+                        WorkerRole::OnlySmallCycleTx
+                    } else {
+                        WorkerRole::SubmitTimeFirst
+                    };
+                    let (child_tx, child_rx) = watch::channel(ChunkCommand::Resume);
+                    (
+                        child_tx,
+                        Worker::new(
+                            service.clone(),
+                            Arc::clone(&tasks),
+                            child_rx,
+                            signal_exit.clone(),
+                            role,
+                        ),
+                    )
+                }
+            })
+            .collect();
+        Self {
+            workers,
+            join_handles: None,
+            signal_exit,
+            command_rx,
+        }
+    }
+
+    fn send_child_command(&self, command: ChunkCommand) {
+        //info!("[verify-test] verify-mgr send child command: {:?}", command);
+        for w in &self.workers {
+            if let Err(err) = w.0.send(command.clone()) {
+                info!("send worker command failed, error: {}", err);
+            }
+        }
+    }
+
+    async fn start_loop(&mut self) {
+        let mut join_handles = Vec::new();
+        for w in self.workers.iter_mut() {
+            let h = w.1.clone().start();
+            join_handles.push(h);
+        }
+        self.join_handles.replace(join_handles);
+        loop {
+            tokio::select! {
+                _ = self.signal_exit.cancelled() => {
+                    info!("TxPool chunk_command service received exit signal, exit now");
+                    self.send_child_command(ChunkCommand::Stop);
+                    break;
+                },
+                _ = self.command_rx.changed() => {
+                    let command = self.command_rx.borrow().to_owned();
+                    self.send_child_command(command);
+                }
+            }
+        }
+        if let Some(jh) = self.join_handles.take() {
+            for h in jh {
+                h.await.expect("Worker thread panic");
+            }
+        }
+        info!("TxPool verify_mgr service exited");
+    }
+
+    pub async fn run(&mut self) {
+        self.start_loop().await;
+    }
+}
diff --git a/util/app-config/src/tests/bats_tests/graceful_shutdown.bats b/util/app-config/src/tests/bats_tests/graceful_shutdown.bats
index 44c32efd2e..6d463552ff 100644
--- a/util/app-config/src/tests/bats_tests/graceful_shutdown.bats
+++ b/util/app-config/src/tests/bats_tests/graceful_shutdown.bats
@@ -23,7 +23,7 @@ function ckb_graceful_shutdown { #@test
   assert_output --regexp "INFO ckb_bin::subcommand::run  Trapped exit signal, exiting..."
   assert_output --regexp "INFO ckb_chain::chain_service  ChainService received exit signal, exit now"
   assert_output --regexp "INFO ckb_sync::synchronizer  BlockDownload received exit signal, exit now"
-  assert_output --regexp "INFO ckb_tx_pool::chunk_process  TxPool chunk_command service received exit signal, exit now"
+  assert_output --regexp "INFO ckb_tx_pool::verify_mgr  TxPool chunk_command service received exit signal, exit now"
   assert_output --regexp "INFO ckb_tx_pool::service  TxPool is saving, please wait..."
   assert_output --regexp "INFO ckb_tx_pool::service  TxPool reorg process service received exit signal, exit now"
   assert_output --regexp "INFO ckb_indexer_sync  Indexer received exit signal, exit now"
diff --git a/util/jsonrpc-types/src/pool.rs b/util/jsonrpc-types/src/pool.rs
index 18f2052dd1..b3d9ea8c7a 100644
--- a/util/jsonrpc-types/src/pool.rs
+++ b/util/jsonrpc-types/src/pool.rs
@@ -59,6 +59,9 @@ pub struct TxPoolInfo {
     pub tx_size_limit: Uint64,
     /// Total limit on the size of transactions in the tx-pool
     pub max_tx_pool_size: Uint64,
+
+    /// verify_queue size
+    pub verify_queue_size: Uint64,
 }
 
 impl From<CoreTxPoolInfo> for TxPoolInfo {
@@ -76,6 +79,7 @@ impl From<CoreTxPoolInfo> for TxPoolInfo {
             last_txs_updated_at: tx_pool_info.last_txs_updated_at.into(),
             tx_size_limit: tx_pool_info.tx_size_limit.into(),
             max_tx_pool_size: tx_pool_info.max_tx_pool_size.into(),
+            verify_queue_size: (tx_pool_info.verify_queue_size as u64).into(),
         }
     }
 }
diff --git a/util/launcher/src/lib.rs b/util/launcher/src/lib.rs
index c6930fb21d..1598953e25 100644
--- a/util/launcher/src/lib.rs
+++ b/util/launcher/src/lib.rs
@@ -417,7 +417,21 @@ impl Launcher {
             )
             .enable_stats(shared.clone(), Arc::clone(&alert_notifier))
             .enable_experiment(shared.clone())
-            .enable_integration_test(shared.clone(), network_controller.clone(), chain_controller)
+            .enable_integration_test(
+                shared.clone(),
+                network_controller.clone(),
+                chain_controller,
+                rpc_config
+                    .extra_well_known_lock_scripts
+                    .iter()
+                    .map(|script| script.clone().into())
+                    .collect(),
+                rpc_config
+                    .extra_well_known_type_scripts
+                    .iter()
+                    .map(|script| script.clone().into())
+                    .collect(),
+            )
             .enable_alert(alert_verifier, alert_notifier, network_controller.clone())
             .enable_indexer(
                 shared.clone(),
diff --git a/util/metrics/src/lib.rs b/util/metrics/src/lib.rs
index 3609524743..41b9d7d895 100644
--- a/util/metrics/src/lib.rs
+++ b/util/metrics/src/lib.rs
@@ -96,6 +96,10 @@ pub struct Metrics {
     pub ckb_relay_cb_verify_duration: Histogram,
     /// Histogram for block process duration
     pub ckb_block_process_duration: Histogram,
+    /// Histogram for sync process tx in txpool
+    pub ckb_tx_pool_sync_process: Histogram,
+    /// Histogram for async process tx in txpool
+    pub ckb_tx_pool_async_process: Histogram,
     /// Counter for relay compact block transaction count
     pub ckb_relay_cb_transaction_count: IntCounter,
     /// Counter for relay compact block reconstruct ok
@@ -124,78 +128,78 @@ pub struct Metrics {
 
 static METRICS: once_cell::sync::Lazy<Metrics> = once_cell::sync::Lazy::new(|| {
     Metrics {
-        ckb_chain_tip: register_int_gauge!("ckb_chain_tip", "The CKB chain tip header number").unwrap(),
-        ckb_chain_unverified_tip: register_int_gauge!(
+    ckb_chain_tip: register_int_gauge!("ckb_chain_tip", "The CKB chain tip header number").unwrap(),
+    ckb_chain_unverified_tip: register_int_gauge!(
         "ckb_chain_unverified_tip",
         "The CKB chain unverified tip header number"
     )
             .unwrap(),
-        ckb_chain_async_process_block_duration: register_histogram!(
+    ckb_chain_async_process_block_duration: register_histogram!(
         "ckb_chain_async_process_block_duration",
         "The CKB chain asynchronous_process_block duration (seconds)"
     )
             .unwrap(),
-        ckb_chain_process_lonely_block_duration: register_histogram!(
+    ckb_chain_process_lonely_block_duration: register_histogram!(
         "ckb_chain_process_lonely_block_duration",
         "The CKB chain consume_orphan thread's process_lonely_block duration (seconds)"
     )
             .unwrap(),
-        ckb_chain_consume_unverified_block_duration: register_histogram!(
+    ckb_chain_consume_unverified_block_duration: register_histogram!(
         "ckb_chain_consume_unverified_block_duration",
         "The CKB chain consume_unverified thread's consume_unverified_block duration (seconds)"
     )
             .unwrap(),
-        ckb_chain_consume_unverified_block_waiting_block_duration: register_histogram!(
+    ckb_chain_consume_unverified_block_waiting_block_duration: register_histogram!(
         "ckb_chain_consume_unverified_block_waiting_block_duration",
         "The CKB chain consume_unverified thread's consume_unverified_block waiting for block duration (seconds)"
     ).unwrap(),
-        ckb_chain_execute_callback_duration: register_histogram!(
+    ckb_chain_execute_callback_duration: register_histogram!(
             "ckb_chain_execute_callback_duration",
             "The CKB chain execute_callback duration (seconds)"
         ).unwrap(),
-        ckb_chain_orphan_count: register_int_gauge!(
+    ckb_chain_orphan_count: register_int_gauge!(
             "ckb_chain_orphan_count",
             "The CKB chain orphan blocks count",
         ).unwrap(),
-        ckb_chain_lonely_block_ch_len: register_int_gauge!(
+    ckb_chain_lonely_block_ch_len: register_int_gauge!(
             "ckb_chain_lonely_block_ch_len",
             "The CKB chain lonely block channel length",
         ).unwrap(),
-        ckb_chain_unverified_block_ch_len: register_int_gauge!(
+    ckb_chain_unverified_block_ch_len: register_int_gauge!(
             "ckb_chain_unverified_block_ch_len",
             "The CKB chain unverified block channel length",
         ).unwrap(),
-        ckb_chain_preload_unverified_block_ch_len: register_int_gauge!(
+    ckb_chain_preload_unverified_block_ch_len: register_int_gauge!(
             "ckb_chain_preload_unverified_block_ch_len",
             "The CKB chain fill unverified block channel length",
         ).unwrap(),
-        ckb_chain_load_full_unverified_block: register_histogram!(
+    ckb_chain_load_full_unverified_block: register_histogram!(
             "ckb_chain_load_full_unverified_block",
             "The CKB chain load_full_unverified_block duration (seconds)"
         ).unwrap(),
-        ckb_sync_msg_process_duration: register_histogram_vec!(
+    ckb_sync_msg_process_duration: register_histogram_vec!(
             "ckb_sync_msg_process_duration",
             "The CKB sync message process duration (seconds)",
             &["msg_type"],
         ).unwrap(),
-        ckb_sync_block_fetch_duration: register_histogram!(
+    ckb_sync_block_fetch_duration: register_histogram!(
             "ckb_sync_block_fetch_duration",
             "The CKB sync block fetch duration (seconds)"
         ).unwrap(),
-        ckb_header_map_limit_memory_duration: register_histogram!(
+    ckb_header_map_limit_memory_duration: register_histogram!(
             "ckb_header_map_limit_memory_duration",
             "The CKB header map limit_memory job duration (seconds)"
         ).unwrap(),
-        ckb_header_map_ops_duration: register_histogram_vec!(
+    ckb_header_map_ops_duration: register_histogram_vec!(
             "ckb_header_map_ops_duration",
             "The CKB header map operation duration (seconds)",
             &["operation"],
         ).unwrap(),
-        ckb_header_map_memory_count: register_int_gauge!(
+    ckb_header_map_memory_count: register_int_gauge!(
             "ckb_header_map_memory_count",
             "The CKB HeaderMap memory count",
         ).unwrap(),
-        ckb_header_map_memory_hit_miss_count: CkbHeaderMapMemoryHitMissStatistics::from(
+    ckb_header_map_memory_hit_miss_count: CkbHeaderMapMemoryHitMissStatistics::from(
             &register_int_counter_vec!(
             "ckb_header_map_memory_hit_miss_count",
             "The CKB HeaderMap memory hit count",
@@ -203,49 +207,56 @@ static METRICS: once_cell::sync::Lazy<Metrics> = once_cell::sync::Lazy::new(|| {
         )
                 .unwrap()
         ),
-        ckb_freezer_size: register_int_gauge!("ckb_freezer_size", "The CKB freezer size").unwrap(),
-        ckb_freezer_read: register_int_counter!("ckb_freezer_read", "The CKB freezer read").unwrap(),
-        ckb_relay_transaction_short_id_collide: register_int_counter!(
+    ckb_freezer_size: register_int_gauge!("ckb_freezer_size", "The CKB freezer size").unwrap(),
+    ckb_freezer_read: register_int_counter!("ckb_freezer_read", "The CKB freezer read").unwrap(),
+    ckb_relay_transaction_short_id_collide: register_int_counter!(
         "ckb_relay_transaction_short_id_collide",
         "The CKB relay transaction short id collide"
     )
             .unwrap(),
-        ckb_relay_cb_verify_duration: register_histogram!(
+    ckb_relay_cb_verify_duration: register_histogram!(
         "ckb_relay_cb_verify_duration",
         "The CKB relay compact block verify duration"
     )
             .unwrap(),
-        ckb_block_process_duration: register_histogram!(
+    ckb_block_process_duration: register_histogram!(
         "ckb_block_process_duration",
         "The CKB block process duration"
     )
-            .unwrap(),
-        ckb_relay_cb_transaction_count: register_int_counter!(
+    .unwrap(),
+    ckb_tx_pool_sync_process: register_histogram!(
+        "ckb_tx_pool_sync_process",
+        "The CKB tx_pool sync process tx duration"
+    )
+    .unwrap(),
+    ckb_tx_pool_async_process: register_histogram!(
+        "ckb_tx_pool_async_process",
+        "The CKB tx_pool async process tx duration"
+    )
+    .unwrap(),
+    ckb_relay_cb_transaction_count: register_int_counter!(
         "ckb_relay_cb_transaction_count",
         "The CKB relay compact block transaction count"
-    )
-            .unwrap(),
-        ckb_relay_cb_reconstruct_ok: register_int_counter!(
+    ).unwrap(),
+    ckb_relay_cb_reconstruct_ok: register_int_counter!(
         "ckb_relay_cb_reconstruct_ok",
         "The CKB relay compact block reconstruct ok count"
-    )
-            .unwrap(),
-        ckb_relay_cb_fresh_tx_cnt: register_int_counter!(
+    ).unwrap(),
+    ckb_relay_cb_fresh_tx_cnt: register_int_counter!(
         "ckb_relay_cb_fresh_tx_cnt",
         "The CKB relay compact block fresh tx count"
-    )
-            .unwrap(),
-        ckb_relay_cb_reconstruct_fail: register_int_counter!(
+    ).unwrap(),
+    ckb_relay_cb_reconstruct_fail: register_int_counter!(
         "ckb_relay_cb_reconstruct_fail",
         "The CKB relay compact block reconstruct fail count"
     )
             .unwrap(),
-        ckb_shared_best_number: register_int_gauge!(
+    ckb_shared_best_number: register_int_gauge!(
         "ckb_shared_best_number",
         "The CKB shared best header number"
     )
             .unwrap(),
-        ckb_sys_mem_process: CkbSysMemProcessStatistics::from(
+    ckb_sys_mem_process: CkbSysMemProcessStatistics::from(
             &register_int_gauge_vec!(
             "ckb_sys_mem_process",
             "CKB system memory for process statistics",
@@ -253,7 +264,7 @@ static METRICS: once_cell::sync::Lazy<Metrics> = once_cell::sync::Lazy::new(|| {
         )
                 .unwrap(),
         ),
-        ckb_sys_mem_jemalloc: CkbSysMemJemallocStatistics::from(
+    ckb_sys_mem_jemalloc: CkbSysMemJemallocStatistics::from(
             &register_int_gauge_vec!(
             "ckb_sys_mem_jemalloc",
             "CKB system memory for jemalloc statistics",
@@ -261,7 +272,7 @@ static METRICS: once_cell::sync::Lazy<Metrics> = once_cell::sync::Lazy::new(|| {
         )
                 .unwrap(),
         ),
-        ckb_tx_pool_entry: CkbTxPoolEntryStatistics::from(
+    ckb_tx_pool_entry: CkbTxPoolEntryStatistics::from(
             &register_int_gauge_vec!(
             "ckb_tx_pool_entry",
             "CKB tx-pool entry status statistics",
@@ -269,7 +280,7 @@ static METRICS: once_cell::sync::Lazy<Metrics> = once_cell::sync::Lazy::new(|| {
         )
                 .unwrap(),
         ),
-        ckb_message_bytes: register_histogram_vec!(
+    ckb_message_bytes: register_histogram_vec!(
         "ckb_message_bytes",
         "The CKB message bytes",
         &["direction", "protocol_name", "msg_item_name", "status_code"],
@@ -278,28 +289,26 @@ static METRICS: once_cell::sync::Lazy<Metrics> = once_cell::sync::Lazy::new(|| {
         ]
     )
             .unwrap(),
-
-        ckb_sys_mem_rocksdb: register_int_gauge_vec!(
+    ckb_sys_mem_rocksdb: register_int_gauge_vec!(
         "ckb_sys_mem_rocksdb",
         "CKB system memory for rocksdb statistics",
         &["type", "cf"]
     )
             .unwrap(),
-        ckb_network_ban_peer: register_int_counter!(
+    ckb_network_ban_peer: register_int_counter!(
         "ckb_network_ban_peer",
         "CKB network baned peer count"
     )
             .unwrap(),
-        ckb_inflight_blocks_count: register_int_gauge!(
+    ckb_inflight_blocks_count: register_int_gauge!(
             "ckb_inflight_blocks_count",
             "The CKB inflight blocks count"
     )
             .unwrap(),
-        ckb_inflight_timeout_count: register_int_counter!(
+    ckb_inflight_timeout_count: register_int_counter!(
             "ckb_inflight_timeout_count",
             "The CKB inflight timeout count"
-    )
-            .unwrap(),
+    ).unwrap(),
     }
 });
 
diff --git a/util/types/src/core/tx_pool.rs b/util/types/src/core/tx_pool.rs
index 01723d18bf..5cb15443f7 100644
--- a/util/types/src/core/tx_pool.rs
+++ b/util/types/src/core/tx_pool.rs
@@ -355,6 +355,9 @@ pub struct TxPoolInfo {
     pub tx_size_limit: u64,
     /// Total limit on the size of transactions in the tx-pool
     pub max_tx_pool_size: u64,
+
+    /// verify queue number
+    pub verify_queue_size: usize,
 }
 
 /// A struct as a sorted key in tx-pool
diff --git a/verification/Cargo.toml b/verification/Cargo.toml
index 7f6303bd4a..20def25ad1 100644
--- a/verification/Cargo.toml
+++ b/verification/Cargo.toml
@@ -21,6 +21,7 @@ ckb-dao-utils = { path = "../util/dao/utils", version = "= 0.118.0-pre" }
 ckb-error = { path = "../error", version = "= 0.118.0-pre" }
 derive_more = { version = "0.99.0", default-features=false, features = ["display"] }
 ckb-verification-traits = { path = "./traits", version = "= 0.118.0-pre" }
+tokio = { version = "1", features = ["sync", "process"] }
 
 [dev-dependencies]
 ckb-test-chain-utils = { path = "../util/test-chain-utils", version = "= 0.118.0-pre" }
diff --git a/verification/contextual/src/contextual_block_verifier.rs b/verification/contextual/src/contextual_block_verifier.rs
index af0c32a873..74bd483a47 100644
--- a/verification/contextual/src/contextual_block_verifier.rs
+++ b/verification/contextual/src/contextual_block_verifier.rs
@@ -379,7 +379,7 @@ impl<'a, 'b, CS: ChainStore + VersionbitsIndexer + 'static> BlockTxsVerifier<'a,
         self.handle.spawn(async move {
             let mut guard = txs_verify_cache.write().await;
             for (k, v) in ret {
-                guard.put(k, CacheEntry::Completed(v));
+                guard.put(k, v);
             }
         });
     }
@@ -406,9 +406,8 @@ impl<'a, 'b, CS: ChainStore + VersionbitsIndexer + 'static> BlockTxsVerifier<'a,
             .map(|(index, tx)| {
                 let wtx_hash = tx.transaction.witness_hash();
 
-                if let Some(cache_entry) = fetched_cache.get(&wtx_hash) {
-                    match cache_entry {
-                        CacheEntry::Completed(completed) => TimeRelativeTransactionVerifier::new(
+                if let Some(completed) = fetched_cache.get(&wtx_hash) {
+                    TimeRelativeTransactionVerifier::new(
                             Arc::clone(tx),
                             Arc::clone(&self.context.consensus),
                             self.context.store.as_data_loader(),
@@ -422,27 +421,7 @@ impl<'a, 'b, CS: ChainStore + VersionbitsIndexer + 'static> BlockTxsVerifier<'a,
                             }
                             .into()
                         })
-                        .map(|_| (wtx_hash, *completed)),
-                        CacheEntry::Suspended(suspended) => ContextualTransactionVerifier::new(
-                            Arc::clone(tx),
-                            Arc::clone(&self.context.consensus),
-                            self.context.store.as_data_loader(),
-                            Arc::clone(&tx_env),
-                        )
-                        .complete(
-                            self.context.consensus.max_block_cycles(),
-                            skip_script_verify,
-                            &suspended.snap,
-                        )
-                        .map_err(|error| {
-                            BlockTransactionsError {
-                                index: index as u32,
-                                error,
-                            }
-                            .into()
-                        })
-                        .map(|completed| (wtx_hash, completed)),
-                    }
+                        .map(|_| (wtx_hash, *completed))
                 } else {
                     ContextualTransactionVerifier::new(
                         Arc::clone(tx),
diff --git a/verification/src/cache.rs b/verification/src/cache.rs
index 4165f4d1db..88a14364c2 100644
--- a/verification/src/cache.rs
+++ b/verification/src/cache.rs
@@ -17,14 +17,8 @@ pub fn init_cache() -> TxVerificationCache {
     lru::LruCache::new(CACHE_SIZE)
 }
 
-#[derive(Clone, Debug)]
 /// TX verification lru entry
-pub enum CacheEntry {
-    /// Completed
-    Completed(Completed),
-    /// Suspended
-    Suspended(Suspended),
-}
+pub type CacheEntry = Completed;
 
 /// Suspended state
 #[derive(Clone, Debug)]
@@ -52,15 +46,3 @@ impl From<Completed> for EntryCompleted {
         }
     }
 }
-
-impl CacheEntry {
-    /// Constructs a completed CacheEntry
-    pub fn completed(cycles: Cycle, fee: Capacity) -> Self {
-        CacheEntry::Completed(Completed { cycles, fee })
-    }
-
-    /// Constructs a Suspended CacheEntry
-    pub fn suspended(snap: Arc<TransactionSnapshot>, fee: Capacity) -> Self {
-        CacheEntry::Suspended(Suspended { snap, fee })
-    }
-}
diff --git a/verification/src/lib.rs b/verification/src/lib.rs
index e2417019f6..7ae9bab362 100644
--- a/verification/src/lib.rs
+++ b/verification/src/lib.rs
@@ -21,8 +21,8 @@ pub use crate::error::{
 pub use crate::genesis_verifier::GenesisVerifier;
 pub use crate::header_verifier::HeaderVerifier;
 pub use crate::transaction_verifier::{
-    CapacityVerifier, ContextualTransactionVerifier, ContextualWithoutScriptTransactionVerifier,
-    DaoScriptSizeVerifier, NonContextualTransactionVerifier, ScriptVerifier, Since, SinceMetric,
+    CapacityVerifier, ContextualTransactionVerifier, DaoScriptSizeVerifier,
+    NonContextualTransactionVerifier, ScriptVerifier, Since, SinceMetric,
     TimeRelativeTransactionVerifier,
 };
 pub use ckb_script::{
diff --git a/verification/src/transaction_verifier.rs b/verification/src/transaction_verifier.rs
index c22d74b359..b6317cebaa 100644
--- a/verification/src/transaction_verifier.rs
+++ b/verification/src/transaction_verifier.rs
@@ -5,7 +5,7 @@ use ckb_chain_spec::consensus::Consensus;
 use ckb_dao::DaoCalculator;
 use ckb_dao_utils::DaoError;
 use ckb_error::Error;
-use ckb_script::{TransactionScriptsVerifier, TransactionSnapshot, VerifyResult};
+use ckb_script::{ChunkCommand, TransactionScriptsVerifier, TransactionSnapshot};
 use ckb_traits::{
     CellDataProvider, EpochProvider, ExtensionProvider, HeaderFieldsProvider, HeaderProvider,
 };
@@ -104,7 +104,10 @@ impl<'a> NonContextualTransactionVerifier<'a> {
 /// [`CapacityVerifier`](./struct.CapacityVerifier.html)
 /// [`ScriptVerifier`](./struct.ScriptVerifier.html)
 /// [`FeeCalculator`](./struct.FeeCalculator.html)
-pub struct ContextualTransactionVerifier<DL> {
+pub struct ContextualTransactionVerifier<DL>
+where
+    DL: Send + Sync + Clone + CellDataProvider + HeaderProvider + ExtensionProvider + 'static,
+{
     pub(crate) compatible: CompatibleVerifier,
     pub(crate) time_relative: TimeRelativeTransactionVerifier<DL>,
     pub(crate) capacity: CapacityVerifier,
@@ -143,7 +146,7 @@ where
                 data_loader.clone(),
                 Arc::clone(&tx_env),
             ),
-            script: ScriptVerifier::new(
+            script: TransactionScriptsVerifier::new(
                 Arc::clone(&rtx),
                 data_loader.clone(),
                 Arc::clone(&consensus),
@@ -154,16 +157,6 @@ where
         }
     }
 
-    /// Perform resumable context-dependent verification, return a `Result` to `CacheEntry`
-    pub fn resumable_verify(&self, limit_cycles: Cycle) -> Result<(VerifyResult, Capacity), Error> {
-        self.compatible.verify()?;
-        self.time_relative.verify()?;
-        self.capacity.verify()?;
-        let fee = self.fee_calculator.transaction_fee()?;
-        let ret = self.script.resumable_verify(limit_cycles)?;
-        Ok((ret, fee))
-    }
-
     /// Perform context-dependent verification, return a `Result` to `CacheEntry`
     ///
     /// skip script verify will result in the return value cycle always is zero
@@ -180,6 +173,24 @@ where
         Ok(Completed { cycles, fee })
     }
 
+    /// Perform context-dependent verification with command
+    /// The verification will be interrupted when receiving a Suspend command
+    pub async fn verify_with_pause(
+        &self,
+        max_cycles: Cycle,
+        command_rx: &mut tokio::sync::watch::Receiver<ChunkCommand>,
+    ) -> Result<Completed, Error> {
+        self.compatible.verify()?;
+        self.time_relative.verify()?;
+        self.capacity.verify()?;
+        let fee = self.fee_calculator.transaction_fee()?;
+        let cycles = self
+            .script
+            .resumable_verify_with_signal(max_cycles, command_rx)
+            .await?;
+        Ok(Completed { cycles, fee })
+    }
+
     /// Perform complete a suspend context-dependent verification, return a `Result` to `CacheEntry`
     ///
     /// skip script verify will result in the return value cycle always is zero
@@ -830,65 +841,6 @@ impl CompatibleVerifier {
     }
 }
 
-/// Context-dependent checks exclude script
-///
-/// Contains:
-/// [`TimeRelativeTransactionVerifier`](./struct.TimeRelativeTransactionVerifier.html)
-/// [`CapacityVerifier`](./struct.CapacityVerifier.html)
-/// [`FeeCalculator`](./struct.FeeCalculator.html)
-pub struct ContextualWithoutScriptTransactionVerifier<DL> {
-    pub(crate) compatible: CompatibleVerifier,
-    pub(crate) time_relative: TimeRelativeTransactionVerifier<DL>,
-    pub(crate) capacity: CapacityVerifier,
-    pub(crate) fee_calculator: FeeCalculator<DL>,
-}
-
-impl<DL> ContextualWithoutScriptTransactionVerifier<DL>
-where
-    DL: CellDataProvider
-        + HeaderProvider
-        + HeaderFieldsProvider
-        + EpochProvider
-        + ExtensionProvider
-        + Send
-        + Sync
-        + Clone
-        + 'static,
-{
-    /// Creates a new ContextualWithoutScriptTransactionVerifier
-    pub fn new(
-        rtx: Arc<ResolvedTransaction>,
-        consensus: Arc<Consensus>,
-        data_loader: DL,
-        tx_env: Arc<TxVerifyEnv>,
-    ) -> Self {
-        ContextualWithoutScriptTransactionVerifier {
-            compatible: CompatibleVerifier::new(
-                Arc::clone(&rtx),
-                Arc::clone(&consensus),
-                Arc::clone(&tx_env),
-            ),
-            time_relative: TimeRelativeTransactionVerifier::new(
-                Arc::clone(&rtx),
-                Arc::clone(&consensus),
-                data_loader.clone(),
-                tx_env,
-            ),
-            capacity: CapacityVerifier::new(Arc::clone(&rtx), consensus.dao_type_hash()),
-            fee_calculator: FeeCalculator::new(rtx, consensus, data_loader),
-        }
-    }
-
-    /// Perform verification
-    pub fn verify(&self) -> Result<Capacity, Error> {
-        self.compatible.verify()?;
-        self.time_relative.verify()?;
-        self.capacity.verify()?;
-        let fee = self.fee_calculator.transaction_fee()?;
-        Ok(fee)
-    }
-}
-
 /// Verifies that deposit cell and withdrawing cell in Nervos DAO use same sized lock scripts.
 /// It provides a temporary solution till Nervos DAO script can be properly upgraded.
 pub struct DaoScriptSizeVerifier<DL> {