diff --git a/script/src/scheduler.rs b/script/src/scheduler.rs
index 3e3f386728..4ace66ab37 100644
--- a/script/src/scheduler.rs
+++ b/script/src/scheduler.rs
@@ -6,7 +6,7 @@ use crate::syscalls::{
 
 use crate::types::{
     CoreMachineType, DataLocation, DataPieceId, DebugContext, Fd, FdArgs, FullSuspendedState,
-    Machine, Message, ReadState, RunMode, SgData, VmContext, VmData, VmId, VmState, WriteState,
+    Machine, Message, ReadState, RunMode, SgData, VmContext, VmId, VmState, WriteState,
     FIRST_FD_SLOT, FIRST_VM_ID,
 };
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
@@ -884,21 +884,20 @@ where
             // We will update max_cycles for each machine when it gets a chance to run
             u64::MAX,
         );
-        let vm_data = Arc::new(VmData {
-            sg_data: Arc::clone(&self.sg_data),
-            vm_id: *id,
-        });
         let vm_context = VmContext {
             base_cycles: Arc::clone(&self.total_cycles),
             message_box: Arc::clone(&self.message_box),
-            snapshot2_context: Arc::new(Mutex::new(Snapshot2Context::new(Arc::clone(&vm_data)))),
+            snapshot2_context: Arc::new(Mutex::new(Snapshot2Context::new(Arc::clone(
+                &self.sg_data,
+            )))),
         };
 
         let machine_builder = DefaultMachineBuilder::new(core_machine)
             .instruction_cycle_func(Box::new(estimate_cycles));
-        let machine_builder = generate_ckb_syscalls(&vm_data, &vm_context, &self.debug_context)
-            .into_iter()
-            .fold(machine_builder, |builder, syscall| builder.syscall(syscall));
+        let machine_builder =
+            generate_ckb_syscalls(id, &self.sg_data, &vm_context, &self.debug_context)
+                .into_iter()
+                .fold(machine_builder, |builder, syscall| builder.syscall(syscall));
         let default_machine = machine_builder.build();
         Ok((vm_context, Machine::new(default_machine)))
     }
diff --git a/script/src/syscalls/close.rs b/script/src/syscalls/close.rs
index 88c0124326..536465b9da 100644
--- a/script/src/syscalls/close.rs
+++ b/script/src/syscalls/close.rs
@@ -1,5 +1,5 @@
 use crate::syscalls::{CLOSE, SPAWN_YIELD_CYCLES_BASE};
-use crate::types::{Fd, Message, VmContext, VmData, VmId};
+use crate::types::{Fd, Message, VmContext, VmId};
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_vm::{
     registers::{A0, A7},
@@ -14,12 +14,12 @@ pub struct Close {
 }
 
 impl Close {
-    pub fn new<DL>(vm_data: &Arc<VmData<DL>>, vm_context: &VmContext<DL>) -> Self
+    pub fn new<DL>(vm_id: &VmId, vm_context: &VmContext<DL>) -> Self
     where
         DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
     {
         Self {
-            id: vm_data.vm_id,
+            id: *vm_id,
             message_box: Arc::clone(&vm_context.message_box),
         }
     }
diff --git a/script/src/syscalls/debugger.rs b/script/src/syscalls/debugger.rs
index 1e57502f34..d71732303e 100644
--- a/script/src/syscalls/debugger.rs
+++ b/script/src/syscalls/debugger.rs
@@ -1,4 +1,4 @@
-use crate::types::{DebugContext, DebugPrinter, VmData};
+use crate::types::{DebugContext, DebugPrinter, SgData};
 use crate::{cost_model::transferred_byte_cycles, syscalls::DEBUG_PRINT_SYSCALL_NUMBER};
 use ckb_vm::{
     registers::{A0, A7},
@@ -7,14 +7,14 @@ use ckb_vm::{
 use std::sync::Arc;
 
 pub struct Debugger<DL> {
-    vm_data: Arc<VmData<DL>>,
+    sg_data: Arc<SgData<DL>>,
     printer: DebugPrinter,
 }
 
 impl<DL> Debugger<DL> {
-    pub fn new(vm_data: &Arc<VmData<DL>>, debug_context: &DebugContext) -> Debugger<DL> {
+    pub fn new(sg_data: &Arc<SgData<DL>>, debug_context: &DebugContext) -> Debugger<DL> {
         Debugger {
-            vm_data: Arc::clone(vm_data),
+            sg_data: Arc::clone(sg_data),
             printer: Arc::clone(&debug_context.debug_printer),
         }
     }
@@ -49,7 +49,7 @@ impl<Mac: SupportMachine, DL: Send + Sync> Syscalls<Mac> for Debugger<DL> {
         machine.add_cycles_no_checking(transferred_byte_cycles(buffer.len() as u64))?;
         let s = String::from_utf8(buffer)
             .map_err(|e| VMError::External(format!("String from buffer {e:?}")))?;
-        (self.printer)(self.vm_data.current_script_hash(), s.as_str());
+        (self.printer)(self.sg_data.current_script_hash(), s.as_str());
 
         Ok(true)
     }
diff --git a/script/src/syscalls/exec.rs b/script/src/syscalls/exec.rs
index 56b7fabc36..97140104fd 100644
--- a/script/src/syscalls/exec.rs
+++ b/script/src/syscalls/exec.rs
@@ -3,7 +3,7 @@ use crate::syscalls::{
     Place, Source, SourceEntry, EXEC, INDEX_OUT_OF_BOUND, MAX_ARGV_LENGTH, SLICE_OUT_OF_BOUND,
     WRONG_FORMAT,
 };
-use crate::types::VmData;
+use crate::types::SgData;
 use ckb_traits::CellDataProvider;
 use ckb_types::core::cell::CellMeta;
 use ckb_types::core::error::ARGV_TOO_LONG_TEXT;
@@ -19,46 +19,46 @@ use std::sync::Arc;
 
 #[derive(Debug)]
 pub struct Exec<DL> {
-    vm_data: Arc<VmData<DL>>,
+    sg_data: Arc<SgData<DL>>,
 }
 
 impl<DL: CellDataProvider> Exec<DL> {
-    pub fn new(vm_data: &Arc<VmData<DL>>) -> Exec<DL> {
+    pub fn new(sg_data: &Arc<SgData<DL>>) -> Exec<DL> {
         Exec {
-            vm_data: Arc::clone(vm_data),
+            sg_data: Arc::clone(sg_data),
         }
     }
 
     #[inline]
     fn resolved_inputs(&self) -> &Vec<CellMeta> {
-        &self.vm_data.rtx().resolved_inputs
+        &self.sg_data.rtx().resolved_inputs
     }
 
     #[inline]
     fn resolved_cell_deps(&self) -> &Vec<CellMeta> {
-        &self.vm_data.rtx().resolved_cell_deps
+        &self.sg_data.rtx().resolved_cell_deps
     }
 
     #[inline]
     fn witnesses(&self) -> BytesVec {
-        self.vm_data.rtx().transaction.witnesses()
+        self.sg_data.rtx().transaction.witnesses()
     }
 
     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.vm_data.outputs().get(index),
+            Source::Transaction(SourceEntry::Output) => self.sg_data.outputs().get(index),
             Source::Transaction(SourceEntry::CellDep) => self.resolved_cell_deps().get(index),
             Source::Group(SourceEntry::Input) => self
-                .vm_data
+                .sg_data
                 .group_inputs()
                 .get(index)
                 .and_then(|actual_index| self.resolved_inputs().get(*actual_index)),
             Source::Group(SourceEntry::Output) => self
-                .vm_data
+                .sg_data
                 .group_outputs()
                 .get(index)
-                .and_then(|actual_index| self.vm_data.outputs().get(*actual_index)),
+                .and_then(|actual_index| self.sg_data.outputs().get(*actual_index)),
             Source::Transaction(SourceEntry::HeaderDep)
             | Source::Group(SourceEntry::CellDep)
             | Source::Group(SourceEntry::HeaderDep) => {
@@ -72,12 +72,12 @@ impl<DL: CellDataProvider> Exec<DL> {
     fn fetch_witness(&self, source: Source, index: usize) -> Result<PackedBytes, u8> {
         let witness_opt = match source {
             Source::Group(SourceEntry::Input) => self
-                .vm_data
+                .sg_data
                 .group_inputs()
                 .get(index)
                 .and_then(|actual_index| self.witnesses().get(*actual_index)),
             Source::Group(SourceEntry::Output) => self
-                .vm_data
+                .sg_data
                 .group_outputs()
                 .get(index)
                 .and_then(|actual_index| self.witnesses().get(*actual_index)),
@@ -116,7 +116,7 @@ impl<Mac: SupportMachine, DL: CellDataProvider + Send + Sync> Syscalls<Mac> for
                     return Ok(true);
                 }
                 let cell = cell.unwrap();
-                self.vm_data
+                self.sg_data
                     .data_loader()
                     .load_cell_data(cell)
                     .ok_or_else(|| {
diff --git a/script/src/syscalls/exec_v2.rs b/script/src/syscalls/exec_v2.rs
index 570c39a441..5f08ab39a9 100644
--- a/script/src/syscalls/exec_v2.rs
+++ b/script/src/syscalls/exec_v2.rs
@@ -1,5 +1,5 @@
 use crate::syscalls::{EXEC, INDEX_OUT_OF_BOUND};
-use crate::types::{DataLocation, DataPieceId, ExecV2Args, Message, VmContext, VmData, VmId};
+use crate::types::{DataLocation, DataPieceId, ExecV2Args, Message, VmContext, VmId};
 use ckb_traits::CellDataProvider;
 use ckb_vm::{
     registers::{A0, A1, A2, A3, A4, A5, A7},
@@ -13,12 +13,9 @@ pub struct ExecV2 {
 }
 
 impl ExecV2 {
-    pub fn new<DL: CellDataProvider>(
-        vm_data: &Arc<VmData<DL>>,
-        vm_context: &VmContext<DL>,
-    ) -> ExecV2 {
+    pub fn new<DL: CellDataProvider>(vm_id: &VmId, vm_context: &VmContext<DL>) -> ExecV2 {
         ExecV2 {
-            id: vm_data.vm_id,
+            id: *vm_id,
             message_box: Arc::clone(&vm_context.message_box),
         }
     }
diff --git a/script/src/syscalls/generator.rs b/script/src/syscalls/generator.rs
index 38a3c17cbf..c57adb8629 100644
--- a/script/src/syscalls/generator.rs
+++ b/script/src/syscalls/generator.rs
@@ -4,7 +4,7 @@ use crate::{
         LoadCellData, LoadHeader, LoadInput, LoadScript, LoadScriptHash, LoadTx, LoadWitness, Pipe,
         ProcessID, Read, Spawn, VMVersion, Wait, Write,
     },
-    types::{CoreMachine, DebugContext, ScriptVersion, VmContext, VmData},
+    types::{CoreMachine, DebugContext, ScriptVersion, SgData, VmContext, VmId},
 };
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_vm::Syscalls;
@@ -12,7 +12,8 @@ use std::sync::Arc;
 
 /// Generate RISC-V syscalls in CKB environment
 pub fn generate_ckb_syscalls<DL>(
-    vm_data: &Arc<VmData<DL>>,
+    vm_id: &VmId,
+    sg_data: &Arc<SgData<DL>>,
     vm_context: &VmContext<DL>,
     debug_context: &DebugContext,
 ) -> Vec<Box<(dyn Syscalls<CoreMachine>)>>
@@ -20,17 +21,17 @@ where
     DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
 {
     let mut syscalls: Vec<Box<(dyn Syscalls<CoreMachine>)>> = vec![
-        Box::new(LoadScriptHash::new(vm_data)),
-        Box::new(LoadTx::new(vm_data)),
-        Box::new(LoadCell::new(vm_data)),
-        Box::new(LoadInput::new(vm_data)),
-        Box::new(LoadHeader::new(vm_data)),
-        Box::new(LoadWitness::new(vm_data)),
-        Box::new(LoadScript::new(vm_data)),
+        Box::new(LoadScriptHash::new(sg_data)),
+        Box::new(LoadTx::new(sg_data)),
+        Box::new(LoadCell::new(sg_data)),
+        Box::new(LoadInput::new(sg_data)),
+        Box::new(LoadHeader::new(sg_data)),
+        Box::new(LoadWitness::new(sg_data)),
+        Box::new(LoadScript::new(sg_data)),
         Box::new(LoadCellData::new(vm_context)),
-        Box::new(Debugger::new(vm_data, debug_context)),
+        Box::new(Debugger::new(sg_data, debug_context)),
     ];
-    let script_version = &vm_data.sg_data.script_version;
+    let script_version = &sg_data.script_version;
     if script_version >= &ScriptVersion::V1 {
         syscalls.append(&mut vec![
             Box::new(VMVersion::new()),
@@ -38,20 +39,20 @@ where
         ]);
     }
     if script_version == &ScriptVersion::V1 {
-        syscalls.push(Box::new(Exec::new(vm_data)));
+        syscalls.push(Box::new(Exec::new(sg_data)));
     }
     if script_version >= &ScriptVersion::V2 {
         syscalls.append(&mut vec![
-            Box::new(ExecV2::new(vm_data, vm_context)),
-            Box::new(LoadBlockExtension::new(vm_data)),
-            Box::new(Spawn::new(vm_data, vm_context)),
-            Box::new(ProcessID::new(vm_data)),
-            Box::new(Pipe::new(vm_data, vm_context)),
-            Box::new(Wait::new(vm_data, vm_context)),
-            Box::new(Write::new(vm_data, vm_context)),
-            Box::new(Read::new(vm_data, vm_context)),
-            Box::new(InheritedFd::new(vm_data, vm_context)),
-            Box::new(Close::new(vm_data, vm_context)),
+            Box::new(ExecV2::new(vm_id, vm_context)),
+            Box::new(LoadBlockExtension::new(sg_data)),
+            Box::new(Spawn::new(vm_id, vm_context)),
+            Box::new(ProcessID::new(vm_id)),
+            Box::new(Pipe::new(vm_id, vm_context)),
+            Box::new(Wait::new(vm_id, vm_context)),
+            Box::new(Write::new(vm_id, vm_context)),
+            Box::new(Read::new(vm_id, vm_context)),
+            Box::new(InheritedFd::new(vm_id, vm_context)),
+            Box::new(Close::new(vm_id, vm_context)),
         ]);
     }
     #[cfg(test)]
diff --git a/script/src/syscalls/inherited_fd.rs b/script/src/syscalls/inherited_fd.rs
index 489a1b5101..510b82969c 100644
--- a/script/src/syscalls/inherited_fd.rs
+++ b/script/src/syscalls/inherited_fd.rs
@@ -1,5 +1,5 @@
 use crate::syscalls::{INHERITED_FD, SPAWN_YIELD_CYCLES_BASE};
-use crate::types::{Fd, FdArgs, Message, VmContext, VmData, VmId};
+use crate::types::{Fd, FdArgs, Message, VmContext, VmId};
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_vm::{
     registers::{A0, A1, A7},
@@ -14,12 +14,12 @@ pub struct InheritedFd {
 }
 
 impl InheritedFd {
-    pub fn new<DL>(vm_data: &Arc<VmData<DL>>, vm_context: &VmContext<DL>) -> Self
+    pub fn new<DL>(vm_id: &VmId, vm_context: &VmContext<DL>) -> Self
     where
         DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
     {
         Self {
-            id: vm_data.vm_id,
+            id: *vm_id,
             message_box: Arc::clone(&vm_context.message_box),
         }
     }
diff --git a/script/src/syscalls/load_block_extension.rs b/script/src/syscalls/load_block_extension.rs
index 81d7de6286..0594a890e3 100644
--- a/script/src/syscalls/load_block_extension.rs
+++ b/script/src/syscalls/load_block_extension.rs
@@ -4,7 +4,7 @@ use crate::{
         utils::store_data, Source, SourceEntry, INDEX_OUT_OF_BOUND, ITEM_MISSING,
         LOAD_BLOCK_EXTENSION, SUCCESS,
     },
-    types::VmData,
+    types::SgData,
 };
 use ckb_traits::ExtensionProvider;
 use ckb_types::{
@@ -19,29 +19,29 @@ use std::sync::Arc;
 
 #[derive(Debug)]
 pub struct LoadBlockExtension<DL> {
-    vm_data: Arc<VmData<DL>>,
+    sg_data: Arc<SgData<DL>>,
 }
 
 impl<DL: ExtensionProvider> LoadBlockExtension<DL> {
-    pub fn new(vm_data: &Arc<VmData<DL>>) -> LoadBlockExtension<DL> {
+    pub fn new(sg_data: &Arc<SgData<DL>>) -> LoadBlockExtension<DL> {
         LoadBlockExtension {
-            vm_data: Arc::clone(vm_data),
+            sg_data: Arc::clone(sg_data),
         }
     }
 
     #[inline]
     fn header_deps(&self) -> Byte32Vec {
-        self.vm_data.rtx().transaction.header_deps()
+        self.sg_data.rtx().transaction.header_deps()
     }
 
     #[inline]
     fn resolved_inputs(&self) -> &Vec<CellMeta> {
-        &self.vm_data.rtx().resolved_inputs
+        &self.sg_data.rtx().resolved_inputs
     }
 
     #[inline]
     fn resolved_cell_deps(&self) -> &Vec<CellMeta> {
-        &self.vm_data.rtx().resolved_cell_deps
+        &self.sg_data.rtx().resolved_cell_deps
     }
 
     fn load_block_extension(&self, cell_meta: &CellMeta) -> Option<packed::Bytes> {
@@ -55,7 +55,7 @@ impl<DL: ExtensionProvider> LoadBlockExtension<DL> {
             .into_iter()
             .any(|hash| &hash == block_hash)
         {
-            self.vm_data.data_loader().get_block_extension(block_hash)
+            self.sg_data.data_loader().get_block_extension(block_hash)
         } else {
             None
         }
@@ -79,13 +79,13 @@ impl<DL: ExtensionProvider> LoadBlockExtension<DL> {
                 .get(index)
                 .ok_or(INDEX_OUT_OF_BOUND)
                 .and_then(|block_hash| {
-                    self.vm_data
+                    self.sg_data
                         .data_loader()
                         .get_block_extension(&block_hash)
                         .ok_or(ITEM_MISSING)
                 }),
             Source::Group(SourceEntry::Input) => self
-                .vm_data
+                .sg_data
                 .group_inputs()
                 .get(index)
                 .ok_or(INDEX_OUT_OF_BOUND)
diff --git a/script/src/syscalls/load_cell.rs b/script/src/syscalls/load_cell.rs
index 4c71111bb1..78260c378b 100644
--- a/script/src/syscalls/load_cell.rs
+++ b/script/src/syscalls/load_cell.rs
@@ -4,7 +4,7 @@ use crate::{
         utils::store_data, CellField, Source, SourceEntry, INDEX_OUT_OF_BOUND, ITEM_MISSING,
         LOAD_CELL_BY_FIELD_SYSCALL_NUMBER, LOAD_CELL_SYSCALL_NUMBER, SUCCESS,
     },
-    types::{TxData, VmData},
+    types::{SgData, TxData},
 };
 use byteorder::{LittleEndian, WriteBytesExt};
 use ckb_traits::CellDataProvider;
@@ -20,29 +20,29 @@ use ckb_vm::{
 use std::sync::Arc;
 
 pub struct LoadCell<DL> {
-    vm_data: Arc<VmData<DL>>,
+    sg_data: Arc<SgData<DL>>,
 }
 
 impl<DL: CellDataProvider> LoadCell<DL> {
-    pub fn new(vm_data: &Arc<VmData<DL>>) -> LoadCell<DL> {
+    pub fn new(sg_data: &Arc<SgData<DL>>) -> LoadCell<DL> {
         LoadCell {
-            vm_data: Arc::clone(vm_data),
+            sg_data: Arc::clone(sg_data),
         }
     }
 
     #[inline]
     fn tx_data(&self) -> &TxData<DL> {
-        &self.vm_data.sg_data.tx_data
+        &self.sg_data.tx_data
     }
 
     #[inline]
     fn resolved_inputs(&self) -> &Vec<CellMeta> {
-        &self.vm_data.rtx().resolved_inputs
+        &self.sg_data.rtx().resolved_inputs
     }
 
     #[inline]
     fn resolved_cell_deps(&self) -> &Vec<CellMeta> {
-        &self.vm_data.rtx().resolved_cell_deps
+        &self.sg_data.rtx().resolved_cell_deps
     }
 
     fn fetch_cell(&self, source: Source, index: usize) -> Result<&CellMeta, u8> {
@@ -59,7 +59,7 @@ impl<DL: CellDataProvider> LoadCell<DL> {
                 .ok_or(INDEX_OUT_OF_BOUND),
             Source::Transaction(SourceEntry::HeaderDep) => Err(INDEX_OUT_OF_BOUND),
             Source::Group(SourceEntry::Input) => self
-                .vm_data
+                .sg_data
                 .group_inputs()
                 .get(index)
                 .ok_or(INDEX_OUT_OF_BOUND)
@@ -69,7 +69,7 @@ impl<DL: CellDataProvider> LoadCell<DL> {
                         .ok_or(INDEX_OUT_OF_BOUND)
                 }),
             Source::Group(SourceEntry::Output) => self
-                .vm_data
+                .sg_data
                 .group_outputs()
                 .get(index)
                 .ok_or(INDEX_OUT_OF_BOUND)
diff --git a/script/src/syscalls/load_cell_data.rs b/script/src/syscalls/load_cell_data.rs
index c78f3dcec9..53b14b0d1c 100644
--- a/script/src/syscalls/load_cell_data.rs
+++ b/script/src/syscalls/load_cell_data.rs
@@ -1,4 +1,4 @@
-use crate::types::{DataPieceId, VmContext, VmData};
+use crate::types::{DataPieceId, SgData, VmContext};
 use crate::{
     cost_model::transferred_byte_cycles,
     syscalls::{
@@ -20,7 +20,7 @@ pub struct LoadCellData<DL>
 where
     DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
 {
-    snapshot2_context: Arc<Mutex<Snapshot2Context<DataPieceId, Arc<VmData<DL>>>>>,
+    snapshot2_context: Arc<Mutex<Snapshot2Context<DataPieceId, Arc<SgData<DL>>>>>,
 }
 
 impl<DL> LoadCellData<DL>
diff --git a/script/src/syscalls/load_header.rs b/script/src/syscalls/load_header.rs
index 29df08cb04..5e503e3c1d 100644
--- a/script/src/syscalls/load_header.rs
+++ b/script/src/syscalls/load_header.rs
@@ -5,7 +5,7 @@ use crate::{
         HeaderField, Source, SourceEntry, INDEX_OUT_OF_BOUND, ITEM_MISSING,
         LOAD_HEADER_BY_FIELD_SYSCALL_NUMBER, LOAD_HEADER_SYSCALL_NUMBER, SUCCESS,
     },
-    types::VmData,
+    types::SgData,
 };
 use ckb_traits::HeaderProvider;
 use ckb_types::{
@@ -21,13 +21,13 @@ use std::sync::Arc;
 
 #[derive(Debug)]
 pub struct LoadHeader<DL> {
-    vm_data: Arc<VmData<DL>>,
+    sg_data: Arc<SgData<DL>>,
 }
 
 impl<DL: HeaderProvider> LoadHeader<DL> {
-    pub fn new(vm_data: &Arc<VmData<DL>>) -> LoadHeader<DL> {
+    pub fn new(sg_data: &Arc<SgData<DL>>) -> LoadHeader<DL> {
         LoadHeader {
-            vm_data: Arc::clone(vm_data),
+            sg_data: Arc::clone(sg_data),
         }
     }
 
@@ -37,22 +37,22 @@ impl<DL: HeaderProvider> LoadHeader<DL> {
     // resolved_cell_deps: &'a [CellMeta],
     #[inline]
     fn group_inputs(&self) -> &[usize] {
-        self.vm_data.group_inputs()
+        self.sg_data.group_inputs()
     }
 
     #[inline]
     fn header_deps(&self) -> Byte32Vec {
-        self.vm_data.rtx().transaction.header_deps()
+        self.sg_data.rtx().transaction.header_deps()
     }
 
     #[inline]
     fn resolved_inputs(&self) -> &Vec<CellMeta> {
-        &self.vm_data.rtx().resolved_inputs
+        &self.sg_data.rtx().resolved_inputs
     }
 
     #[inline]
     fn resolved_cell_deps(&self) -> &Vec<CellMeta> {
-        &self.vm_data.rtx().resolved_cell_deps
+        &self.sg_data.rtx().resolved_cell_deps
     }
 
     fn load_header(&self, cell_meta: &CellMeta) -> Option<HeaderView> {
@@ -66,11 +66,7 @@ impl<DL: HeaderProvider> LoadHeader<DL> {
             .into_iter()
             .any(|hash| &hash == block_hash)
         {
-            self.vm_data
-                .sg_data
-                .tx_data
-                .data_loader
-                .get_header(block_hash)
+            self.sg_data.tx_data.data_loader.get_header(block_hash)
         } else {
             None
         }
@@ -94,8 +90,7 @@ impl<DL: HeaderProvider> LoadHeader<DL> {
                 .get(index)
                 .ok_or(INDEX_OUT_OF_BOUND)
                 .and_then(|block_hash| {
-                    self.vm_data
-                        .sg_data
+                    self.sg_data
                         .tx_data
                         .data_loader
                         .get_header(&block_hash)
diff --git a/script/src/syscalls/load_input.rs b/script/src/syscalls/load_input.rs
index a7331e8756..5d0513a45e 100644
--- a/script/src/syscalls/load_input.rs
+++ b/script/src/syscalls/load_input.rs
@@ -4,7 +4,7 @@ use crate::{
         utils::store_data, InputField, Source, SourceEntry, INDEX_OUT_OF_BOUND,
         LOAD_INPUT_BY_FIELD_SYSCALL_NUMBER, LOAD_INPUT_SYSCALL_NUMBER, SUCCESS,
     },
-    types::VmData,
+    types::SgData,
 };
 use byteorder::{LittleEndian, WriteBytesExt};
 use ckb_types::{
@@ -19,19 +19,19 @@ use std::sync::Arc;
 
 #[derive(Debug)]
 pub struct LoadInput<DL> {
-    vm_data: Arc<VmData<DL>>,
+    sg_data: Arc<SgData<DL>>,
 }
 
 impl<DL> LoadInput<DL> {
-    pub fn new(vm_data: &Arc<VmData<DL>>) -> Self {
+    pub fn new(sg_data: &Arc<SgData<DL>>) -> Self {
         LoadInput {
-            vm_data: Arc::clone(vm_data),
+            sg_data: Arc::clone(sg_data),
         }
     }
 
     #[inline]
     fn inputs(&self) -> CellInputVec {
-        self.vm_data.rtx().transaction.inputs()
+        self.sg_data.rtx().transaction.inputs()
     }
 
     fn fetch_input(&self, source: Source, index: usize) -> Result<CellInput, u8> {
@@ -43,7 +43,7 @@ impl<DL> LoadInput<DL> {
             Source::Transaction(SourceEntry::CellDep) => Err(INDEX_OUT_OF_BOUND),
             Source::Transaction(SourceEntry::HeaderDep) => Err(INDEX_OUT_OF_BOUND),
             Source::Group(SourceEntry::Input) => self
-                .vm_data
+                .sg_data
                 .group_inputs()
                 .get(index)
                 .ok_or(INDEX_OUT_OF_BOUND)
diff --git a/script/src/syscalls/load_script.rs b/script/src/syscalls/load_script.rs
index 7050e67647..6ea2ec8d32 100644
--- a/script/src/syscalls/load_script.rs
+++ b/script/src/syscalls/load_script.rs
@@ -1,7 +1,7 @@
 use crate::{
     cost_model::transferred_byte_cycles,
     syscalls::{utils::store_data, LOAD_SCRIPT_SYSCALL_NUMBER, SUCCESS},
-    types::VmData,
+    types::SgData,
 };
 use ckb_types::prelude::*;
 use ckb_vm::{
@@ -12,13 +12,13 @@ use std::sync::Arc;
 
 #[derive(Debug)]
 pub struct LoadScript<DL> {
-    vm_data: Arc<VmData<DL>>,
+    sg_data: Arc<SgData<DL>>,
 }
 
 impl<DL> LoadScript<DL> {
-    pub fn new(vm_data: &Arc<VmData<DL>>) -> Self {
+    pub fn new(sg_data: &Arc<SgData<DL>>) -> Self {
         Self {
-            vm_data: Arc::clone(vm_data),
+            sg_data: Arc::clone(sg_data),
         }
     }
 }
@@ -33,7 +33,7 @@ impl<Mac: SupportMachine, DL: Send + Sync> Syscalls<Mac> for LoadScript<DL> {
             return Ok(false);
         }
 
-        let data = self.vm_data.sg_data.script_group.script.as_slice();
+        let data = self.sg_data.script_group.script.as_slice();
         let wrote_size = store_data(machine, data)?;
 
         machine.add_cycles_no_checking(transferred_byte_cycles(wrote_size))?;
diff --git a/script/src/syscalls/load_script_hash.rs b/script/src/syscalls/load_script_hash.rs
index a8dbe14aca..73ecefa88e 100644
--- a/script/src/syscalls/load_script_hash.rs
+++ b/script/src/syscalls/load_script_hash.rs
@@ -1,7 +1,7 @@
 use crate::{
     cost_model::transferred_byte_cycles,
     syscalls::{utils::store_data, LOAD_SCRIPT_HASH_SYSCALL_NUMBER, SUCCESS},
-    types::VmData,
+    types::SgData,
 };
 use ckb_vm::{
     registers::{A0, A7},
@@ -11,13 +11,13 @@ use std::sync::Arc;
 
 #[derive(Debug)]
 pub struct LoadScriptHash<DL> {
-    vm_data: Arc<VmData<DL>>,
+    sg_data: Arc<SgData<DL>>,
 }
 
 impl<DL> LoadScriptHash<DL> {
-    pub fn new(vm_data: &Arc<VmData<DL>>) -> LoadScriptHash<DL> {
+    pub fn new(sg_data: &Arc<SgData<DL>>) -> LoadScriptHash<DL> {
         LoadScriptHash {
-            vm_data: Arc::clone(vm_data),
+            sg_data: Arc::clone(sg_data),
         }
     }
 }
@@ -32,7 +32,7 @@ impl<Mac: SupportMachine, DL: Send + Sync> Syscalls<Mac> for LoadScriptHash<DL>
             return Ok(false);
         }
 
-        let data = self.vm_data.current_script_hash().as_reader().raw_data();
+        let data = self.sg_data.current_script_hash().as_reader().raw_data();
         let wrote_size = store_data(machine, data)?;
 
         machine.add_cycles_no_checking(transferred_byte_cycles(wrote_size))?;
diff --git a/script/src/syscalls/load_tx.rs b/script/src/syscalls/load_tx.rs
index 06b22a2715..fb4576682d 100644
--- a/script/src/syscalls/load_tx.rs
+++ b/script/src/syscalls/load_tx.rs
@@ -3,7 +3,7 @@ use crate::{
     syscalls::{
         utils::store_data, LOAD_TRANSACTION_SYSCALL_NUMBER, LOAD_TX_HASH_SYSCALL_NUMBER, SUCCESS,
     },
-    types::VmData,
+    types::SgData,
 };
 use ckb_types::{core::cell::ResolvedTransaction, prelude::*};
 use ckb_vm::{
@@ -18,9 +18,9 @@ pub struct LoadTx {
 }
 
 impl LoadTx {
-    pub fn new<DL>(vm_data: &Arc<VmData<DL>>) -> LoadTx {
+    pub fn new<DL>(sg_data: &Arc<SgData<DL>>) -> LoadTx {
         LoadTx {
-            rtx: Arc::clone(&vm_data.sg_data.tx_data.rtx),
+            rtx: Arc::clone(&sg_data.tx_data.rtx),
         }
     }
 }
diff --git a/script/src/syscalls/load_witness.rs b/script/src/syscalls/load_witness.rs
index 7a6acdb296..09e1698db3 100644
--- a/script/src/syscalls/load_witness.rs
+++ b/script/src/syscalls/load_witness.rs
@@ -4,7 +4,7 @@ use crate::{
         utils::store_data, Source, SourceEntry, INDEX_OUT_OF_BOUND, LOAD_WITNESS_SYSCALL_NUMBER,
         SUCCESS,
     },
-    types::VmData,
+    types::SgData,
 };
 use ckb_types::packed::{Bytes, BytesVec};
 use ckb_vm::{
@@ -15,30 +15,30 @@ use std::sync::Arc;
 
 #[derive(Debug)]
 pub struct LoadWitness<DL> {
-    vm_data: Arc<VmData<DL>>,
+    sg_data: Arc<SgData<DL>>,
 }
 
 impl<DL> LoadWitness<DL> {
-    pub fn new(vm_data: &Arc<VmData<DL>>) -> Self {
+    pub fn new(sg_data: &Arc<SgData<DL>>) -> Self {
         LoadWitness {
-            vm_data: Arc::clone(vm_data),
+            sg_data: Arc::clone(sg_data),
         }
     }
 
     #[inline]
     fn witnesses(&self) -> BytesVec {
-        self.vm_data.rtx().transaction.witnesses()
+        self.sg_data.rtx().transaction.witnesses()
     }
 
     fn fetch_witness(&self, source: Source, index: usize) -> Option<Bytes> {
         match source {
             Source::Group(SourceEntry::Input) => self
-                .vm_data
+                .sg_data
                 .group_inputs()
                 .get(index)
                 .and_then(|actual_index| self.witnesses().get(*actual_index)),
             Source::Group(SourceEntry::Output) => self
-                .vm_data
+                .sg_data
                 .group_outputs()
                 .get(index)
                 .and_then(|actual_index| self.witnesses().get(*actual_index)),
diff --git a/script/src/syscalls/pipe.rs b/script/src/syscalls/pipe.rs
index a20b2c0693..db7004b548 100644
--- a/script/src/syscalls/pipe.rs
+++ b/script/src/syscalls/pipe.rs
@@ -1,5 +1,5 @@
 use crate::syscalls::{PIPE, SPAWN_YIELD_CYCLES_BASE};
-use crate::types::{Message, PipeArgs, VmContext, VmData, VmId};
+use crate::types::{Message, PipeArgs, VmContext, VmId};
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_vm::{
     registers::{A0, A7},
@@ -14,12 +14,12 @@ pub struct Pipe {
 }
 
 impl Pipe {
-    pub fn new<DL>(vm_data: &Arc<VmData<DL>>, vm_context: &VmContext<DL>) -> Self
+    pub fn new<DL>(vm_id: &VmId, vm_context: &VmContext<DL>) -> Self
     where
         DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
     {
         Self {
-            id: vm_data.vm_id,
+            id: *vm_id,
             message_box: Arc::clone(&vm_context.message_box),
         }
     }
diff --git a/script/src/syscalls/process_id.rs b/script/src/syscalls/process_id.rs
index 0971ae1cbe..37b4df21e3 100644
--- a/script/src/syscalls/process_id.rs
+++ b/script/src/syscalls/process_id.rs
@@ -1,10 +1,9 @@
 use crate::syscalls::PROCESS_ID;
-use crate::types::VmData;
+use crate::types::VmId;
 use ckb_vm::{
     registers::{A0, A7},
     Error as VMError, Register, SupportMachine, Syscalls,
 };
-use std::sync::Arc;
 
 #[derive(Debug, Default)]
 pub struct ProcessID {
@@ -12,8 +11,8 @@ pub struct ProcessID {
 }
 
 impl ProcessID {
-    pub fn new<DL>(vm_data: &Arc<VmData<DL>>) -> Self {
-        Self { id: vm_data.vm_id }
+    pub fn new(vm_id: &VmId) -> Self {
+        Self { id: *vm_id }
     }
 }
 
diff --git a/script/src/syscalls/read.rs b/script/src/syscalls/read.rs
index 0f48095735..7c96c7125b 100644
--- a/script/src/syscalls/read.rs
+++ b/script/src/syscalls/read.rs
@@ -1,5 +1,5 @@
 use crate::syscalls::{INVALID_FD, READ, SPAWN_YIELD_CYCLES_BASE};
-use crate::types::{Fd, FdArgs, Message, VmContext, VmData, VmId};
+use crate::types::{Fd, FdArgs, Message, VmContext, VmId};
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_vm::{
     registers::{A0, A1, A2, A7},
@@ -14,12 +14,12 @@ pub struct Read {
 }
 
 impl Read {
-    pub fn new<DL>(vm_data: &Arc<VmData<DL>>, vm_context: &VmContext<DL>) -> Self
+    pub fn new<DL>(vm_id: &VmId, vm_context: &VmContext<DL>) -> Self
     where
         DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
     {
         Self {
-            id: vm_data.vm_id,
+            id: *vm_id,
             message_box: Arc::clone(&vm_context.message_box),
         }
     }
diff --git a/script/src/syscalls/spawn.rs b/script/src/syscalls/spawn.rs
index a9fca4332a..6fb7d536eb 100644
--- a/script/src/syscalls/spawn.rs
+++ b/script/src/syscalls/spawn.rs
@@ -2,7 +2,7 @@ use crate::syscalls::{
     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::{DataLocation, DataPieceId, Fd, Message, SpawnArgs, VmContext, VmData, VmId};
+use crate::types::{DataLocation, DataPieceId, Fd, Message, SgData, SpawnArgs, VmContext, VmId};
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_vm::{
     machine::SupportMachine,
@@ -20,16 +20,16 @@ where
 {
     id: VmId,
     message_box: Arc<Mutex<Vec<Message>>>,
-    snapshot2_context: Arc<Mutex<Snapshot2Context<DataPieceId, Arc<VmData<DL>>>>>,
+    snapshot2_context: Arc<Mutex<Snapshot2Context<DataPieceId, Arc<SgData<DL>>>>>,
 }
 
 impl<DL> Spawn<DL>
 where
     DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
 {
-    pub fn new(vm_data: &Arc<VmData<DL>>, vm_context: &VmContext<DL>) -> Self {
+    pub fn new(vm_id: &VmId, vm_context: &VmContext<DL>) -> Self {
         Self {
-            id: vm_data.vm_id,
+            id: *vm_id,
             message_box: Arc::clone(&vm_context.message_box),
             snapshot2_context: Arc::clone(&vm_context.snapshot2_context),
         }
diff --git a/script/src/syscalls/tests/utils.rs b/script/src/syscalls/tests/utils.rs
index 506f35bddb..6d5d95330b 100644
--- a/script/src/syscalls/tests/utils.rs
+++ b/script/src/syscalls/tests/utils.rs
@@ -1,5 +1,5 @@
 use crate::{
-    types::{DataPieceId, ScriptGroup, ScriptGroupType, ScriptVersion, SgData, TxData, VmData},
+    types::{DataPieceId, ScriptGroup, ScriptGroupType, ScriptVersion, SgData, TxData},
     verify_env::TxVerifyEnv,
 };
 use ckb_chain_spec::consensus::ConsensusBuilder;
@@ -86,11 +86,11 @@ pub(crate) fn build_tx_data_with_loader(
     }
 }
 
-pub(crate) fn build_vm_data(
+pub(crate) fn build_sg_data(
     tx_data: Arc<TxData<MockDataLoader>>,
     input_indices: Vec<usize>,
     output_indices: Vec<usize>,
-) -> Arc<VmData<MockDataLoader>> {
+) -> Arc<SgData<MockDataLoader>> {
     let script_group = ScriptGroup {
         script: Script::default(),
         group_type: ScriptGroupType::Lock,
@@ -98,14 +98,11 @@ pub(crate) fn build_vm_data(
         output_indices,
     };
     let script_hash = script_group.script.calc_script_hash();
-    Arc::new(VmData {
-        sg_data: Arc::new(SgData {
-            tx_data,
-            script_version: ScriptVersion::latest(),
-            script_group,
-            script_hash,
-            program_data_piece_id: DataPieceId::CellDep(0),
-        }),
-        vm_id: 0,
+    Arc::new(SgData {
+        tx_data,
+        script_version: ScriptVersion::latest(),
+        script_group,
+        script_hash,
+        program_data_piece_id: DataPieceId::CellDep(0),
     })
 }
diff --git a/script/src/syscalls/tests/vm_latest/syscalls_1.rs b/script/src/syscalls/tests/vm_latest/syscalls_1.rs
index 3d0a8e8b83..444a67a124 100644
--- a/script/src/syscalls/tests/vm_latest/syscalls_1.rs
+++ b/script/src/syscalls/tests/vm_latest/syscalls_1.rs
@@ -1,4 +1,4 @@
-use crate::types::{VmContext, VmData};
+use crate::types::VmContext;
 use byteorder::{ByteOrder, LittleEndian, WriteBytesExt};
 use ckb_hash::blake2b_256;
 use ckb_types::{
@@ -59,9 +59,9 @@ fn _test_load_cell_not_exist(data: &[u8]) -> Result<(), TestCaseError> {
         tx_data.outputs = vec![output];
         Arc::new(tx_data)
     };
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let mut load_cell = LoadCell::new(&vm_data);
+    let mut load_cell = LoadCell::new(&sg_data);
 
     prop_assert!(load_cell.ecall(&mut machine).is_ok());
     prop_assert_eq!(machine.registers()[A0], u64::from(INDEX_OUT_OF_BOUND));
@@ -105,9 +105,9 @@ fn _test_load_cell_all(data: &[u8]) -> Result<(), TestCaseError> {
         tx_data.outputs = vec![output.clone()];
         Arc::new(tx_data)
     };
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let mut load_cell = LoadCell::new(&vm_data);
+    let mut load_cell = LoadCell::new(&sg_data);
 
     let input_correct_data = input_cell.cell_output.as_slice();
     let output_correct_data = output.cell_output.as_slice();
@@ -199,9 +199,9 @@ fn _test_load_cell_from_group(data: &[u8], source: SourceEntry) -> Result<(), Te
         tx_data.outputs = vec![output.clone()];
         Arc::new(tx_data)
     };
-    let vm_data = build_vm_data(tx_data, vec![0], vec![0]);
+    let sg_data = build_sg_data(tx_data, vec![0], vec![0]);
 
-    let mut load_cell = LoadCell::new(&vm_data);
+    let mut load_cell = LoadCell::new(&sg_data);
 
     let input_correct_data = input_cell.cell_output.as_slice();
     let output_correct_data = output.cell_output.as_slice();
@@ -290,9 +290,9 @@ fn _test_load_cell_out_of_bound(index: u64, source: u64) -> Result<(), TestCaseE
         tx_data.outputs = vec![output];
         Arc::new(tx_data)
     };
-    let vm_data = build_vm_data(tx_data, vec![0], vec![0]);
+    let sg_data = build_sg_data(tx_data, vec![0], vec![0]);
 
-    let mut load_cell = LoadCell::new(&vm_data);
+    let mut load_cell = LoadCell::new(&sg_data);
 
     prop_assert!(load_cell.ecall(&mut machine).is_ok());
     prop_assert_eq!(machine.registers()[A0], u64::from(INDEX_OUT_OF_BOUND));
@@ -352,9 +352,9 @@ fn _test_load_cell_length(data: &[u8]) -> Result<(), TestCaseError> {
         tx_data.outputs = vec![output];
         Arc::new(tx_data)
     };
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let mut load_cell = LoadCell::new(&vm_data);
+    let mut load_cell = LoadCell::new(&sg_data);
 
     let input_correct_data = input_cell.cell_output.as_slice();
 
@@ -408,9 +408,9 @@ fn _test_load_cell_partial(data: &[u8], offset: u64) -> Result<(), TestCaseError
         tx_data.outputs = vec![output];
         Arc::new(tx_data)
     };
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let mut load_cell = LoadCell::new(&vm_data);
+    let mut load_cell = LoadCell::new(&sg_data);
 
     let input_correct_data = input_cell.cell_output.as_slice();
 
@@ -472,9 +472,9 @@ fn _test_load_cell_capacity(capacity: Capacity) -> Result<(), TestCaseError> {
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let mut load_cell = LoadCell::new(&vm_data);
+    let mut load_cell = LoadCell::new(&sg_data);
 
     prop_assert!(machine.memory_mut().store64(&size_addr, &16).is_ok());
 
@@ -531,9 +531,9 @@ fn _test_load_cell_occupied_capacity(data: &[u8]) -> Result<(), TestCaseError> {
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let mut load_cell = LoadCell::new(&vm_data);
+    let mut load_cell = LoadCell::new(&sg_data);
 
     prop_assert!(machine.memory_mut().store64(&size_addr, &16).is_ok());
 
@@ -591,9 +591,9 @@ fn test_load_missing_data_hash() {
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let mut load_cell = LoadCell::new(&vm_data);
+    let mut load_cell = LoadCell::new(&sg_data);
 
     assert!(machine.memory_mut().store64(&size_addr, &100).is_ok());
 
@@ -641,9 +641,9 @@ fn _test_load_missing_contract(field: CellField) {
         tx_data.outputs = vec![output_cell];
         Arc::new(tx_data)
     };
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let mut load_cell = LoadCell::new(&vm_data);
+    let mut load_cell = LoadCell::new(&sg_data);
 
     assert!(machine.memory_mut().store64(&size_addr, &100).is_ok());
 
@@ -713,9 +713,9 @@ fn _test_load_header(
     });
 
     let tx_data = Arc::new(build_tx_data_with_loader(rtx, data_loader));
-    let vm_data = build_vm_data(tx_data, vec![0], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![0], vec![]);
 
-    let mut load_header = LoadHeader::new(&vm_data);
+    let mut load_header = LoadHeader::new(&sg_data);
 
     prop_assert!(machine
         .memory_mut()
@@ -831,9 +831,9 @@ fn _test_load_header_by_field(data: &[u8], field: HeaderField) -> Result<(), Tes
     });
 
     let tx_data = Arc::new(build_tx_data_with_loader(rtx, data_loader));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let mut load_header = LoadHeader::new(&vm_data);
+    let mut load_header = LoadHeader::new(&sg_data);
 
     prop_assert!(machine
         .memory_mut()
@@ -884,9 +884,9 @@ fn _test_load_tx_hash(data: &[u8]) -> Result<(), TestCaseError> {
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let mut load_tx = LoadTx::new(&vm_data);
+    let mut load_tx = LoadTx::new(&sg_data);
 
     prop_assert!(machine
         .memory_mut()
@@ -938,9 +938,9 @@ fn _test_load_tx(data: &[u8]) -> Result<(), TestCaseError> {
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let mut load_tx = LoadTx::new(&vm_data);
+    let mut load_tx = LoadTx::new(&sg_data);
 
     prop_assert!(machine
         .memory_mut()
@@ -993,19 +993,16 @@ fn _test_load_current_script_hash(data: &[u8]) -> Result<(), TestCaseError> {
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
     // Swap the internal script in VmData
-    let vm_data = {
-        let mut sg_data = vm_data.sg_data.as_ref().clone();
+    let sg_data = {
+        let mut sg_data = sg_data.as_ref().clone();
         sg_data.script_hash = script.calc_script_hash();
         sg_data.script_group.script = script;
-        Arc::new(VmData {
-            sg_data: Arc::new(sg_data),
-            vm_id: vm_data.vm_id,
-        })
+        Arc::new(sg_data)
     };
 
-    let mut load_script_hash = LoadScriptHash::new(&vm_data);
+    let mut load_script_hash = LoadScriptHash::new(&sg_data);
 
     prop_assert!(machine.memory_mut().store64(&size_addr, &64).is_ok());
 
@@ -1078,9 +1075,9 @@ fn _test_load_input_lock_script_hash(data: &[u8]) -> Result<(), TestCaseError> {
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let mut load_cell = LoadCell::new(&vm_data);
+    let mut load_cell = LoadCell::new(&sg_data);
 
     prop_assert!(machine.memory_mut().store64(&size_addr, &64).is_ok());
 
@@ -1141,9 +1138,9 @@ fn _test_load_input_lock_script(data: &[u8]) -> Result<(), TestCaseError> {
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let mut load_cell = LoadCell::new(&vm_data);
+    let mut load_cell = LoadCell::new(&sg_data);
 
     prop_assert!(machine
         .memory_mut()
@@ -1207,9 +1204,9 @@ fn _test_load_input_type_script(data: &[u8]) -> Result<(), TestCaseError> {
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let mut load_cell = LoadCell::new(&vm_data);
+    let mut load_cell = LoadCell::new(&sg_data);
 
     prop_assert!(machine
         .memory_mut()
@@ -1275,9 +1272,9 @@ fn _test_load_input_type_script_hash(data: &[u8]) -> Result<(), TestCaseError> {
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let mut load_cell = LoadCell::new(&vm_data);
+    let mut load_cell = LoadCell::new(&sg_data);
 
     prop_assert!(machine
         .memory_mut()
@@ -1332,9 +1329,9 @@ fn _test_load_witness(data: &[u8], source: SourceEntry) -> Result<(), TestCaseEr
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let mut load_witness = LoadWitness::new(&vm_data);
+    let mut load_witness = LoadWitness::new(&sg_data);
 
     prop_assert!(machine
         .memory_mut()
@@ -1398,9 +1395,9 @@ fn _test_load_group_witness(data: &[u8], source: SourceEntry) -> Result<(), Test
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![1], vec![1]);
+    let sg_data = build_sg_data(tx_data, vec![1], vec![1]);
 
-    let mut load_witness = LoadWitness::new(&vm_data);
+    let mut load_witness = LoadWitness::new(&sg_data);
 
     prop_assert!(machine
         .memory_mut()
@@ -1455,19 +1452,16 @@ fn _test_load_script(data: &[u8]) -> Result<(), TestCaseError> {
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
     // Swap the internal script in VmData
-    let vm_data = {
-        let mut sg_data = vm_data.sg_data.as_ref().clone();
+    let sg_data = {
+        let mut sg_data = sg_data.as_ref().clone();
         sg_data.script_hash = script.calc_script_hash();
         sg_data.script_group.script = script.clone();
-        Arc::new(VmData {
-            sg_data: Arc::new(sg_data),
-            vm_id: vm_data.vm_id,
-        })
+        Arc::new(sg_data)
     };
 
-    let mut load_script = LoadScript::new(&vm_data);
+    let mut load_script = LoadScript::new(&sg_data);
 
     prop_assert!(machine
         .memory_mut()
@@ -1531,9 +1525,9 @@ fn _test_load_cell_data_as_code(
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![0], vec![0]);
+    let sg_data = build_sg_data(tx_data, vec![0], vec![0]);
 
-    let vm_context = VmContext::new(&vm_data, &Arc::new(Mutex::new(Vec::new())));
+    let vm_context = VmContext::new(&sg_data, &Arc::new(Mutex::new(Vec::new())));
 
     let mut load_code = LoadCellData::new(&vm_context);
 
@@ -1599,9 +1593,9 @@ fn _test_load_cell_data(
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![0], vec![0]);
+    let sg_data = build_sg_data(tx_data, vec![0], vec![0]);
 
-    let vm_context = VmContext::new(&vm_data, &Arc::new(Mutex::new(Vec::new())));
+    let vm_context = VmContext::new(&sg_data, &Arc::new(Mutex::new(Vec::new())));
 
     let mut load_code = LoadCellData::new(&vm_context);
 
@@ -1702,9 +1696,9 @@ fn test_load_overflowed_cell_data_as_code() {
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let vm_context = VmContext::new(&vm_data, &Arc::new(Mutex::new(Vec::new())));
+    let vm_context = VmContext::new(&sg_data, &Arc::new(Mutex::new(Vec::new())));
 
     let mut load_code = LoadCellData::new(&vm_context);
 
@@ -1747,9 +1741,9 @@ fn _test_load_cell_data_on_freezed_memory(data: &[u8]) -> Result<(), TestCaseErr
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let vm_context = VmContext::new(&vm_data, &Arc::new(Mutex::new(Vec::new())));
+    let vm_context = VmContext::new(&sg_data, &Arc::new(Mutex::new(Vec::new())));
 
     let mut load_code = LoadCellData::new(&vm_context);
 
@@ -1790,9 +1784,9 @@ fn _test_load_cell_data_as_code_on_freezed_memory(data: &[u8]) -> Result<(), Tes
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let vm_context = VmContext::new(&vm_data, &Arc::new(Mutex::new(Vec::new())));
+    let vm_context = VmContext::new(&sg_data, &Arc::new(Mutex::new(Vec::new())));
 
     let mut load_code = LoadCellData::new(&vm_context);
 
@@ -1844,9 +1838,9 @@ fn test_load_code_unaligned_error() {
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let vm_context = VmContext::new(&vm_data, &Arc::new(Mutex::new(Vec::new())));
+    let vm_context = VmContext::new(&sg_data, &Arc::new(Mutex::new(Vec::new())));
 
     let mut load_code = LoadCellData::new(&vm_context);
 
@@ -1885,9 +1879,9 @@ fn test_load_code_slice_out_of_bound_error() {
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let vm_context = VmContext::new(&vm_data, &Arc::new(Mutex::new(Vec::new())));
+    let vm_context = VmContext::new(&sg_data, &Arc::new(Mutex::new(Vec::new())));
 
     let mut load_code = LoadCellData::new(&vm_context);
 
@@ -1929,9 +1923,9 @@ fn test_load_code_not_enough_space_error() {
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let vm_context = VmContext::new(&vm_data, &Arc::new(Mutex::new(Vec::new())));
+    let vm_context = VmContext::new(&sg_data, &Arc::new(Mutex::new(Vec::new())));
 
     let mut load_code = LoadCellData::new(&vm_context);
 
@@ -1996,9 +1990,9 @@ fn _test_load_input(
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![0], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![0], vec![]);
 
-    let mut load_input = LoadInput::new(&vm_data);
+    let mut load_input = LoadInput::new(&sg_data);
 
     let mut buffer = vec![];
     let expect = if let Some(field) = field {
@@ -2136,9 +2130,9 @@ fn test_load_cell_data_size_zero() {
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![0], vec![0]);
+    let sg_data = build_sg_data(tx_data, vec![0], vec![0]);
 
-    let vm_context = VmContext::new(&vm_data, &Arc::new(Mutex::new(Vec::new())));
+    let vm_context = VmContext::new(&sg_data, &Arc::new(Mutex::new(Vec::new())));
 
     let mut load_code = LoadCellData::new(&vm_context);
 
@@ -2176,9 +2170,9 @@ fn test_load_cell_data_size_zero_index_out_of_bound() {
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![0], vec![0]);
+    let sg_data = build_sg_data(tx_data, vec![0], vec![0]);
 
-    let vm_context = VmContext::new(&vm_data, &Arc::new(Mutex::new(Vec::new())));
+    let vm_context = VmContext::new(&sg_data, &Arc::new(Mutex::new(Vec::new())));
 
     let mut load_code = LoadCellData::new(&vm_context);
 
diff --git a/script/src/syscalls/tests/vm_latest/syscalls_2.rs b/script/src/syscalls/tests/vm_latest/syscalls_2.rs
index f9991f3687..38b3f7c9ef 100644
--- a/script/src/syscalls/tests/vm_latest/syscalls_2.rs
+++ b/script/src/syscalls/tests/vm_latest/syscalls_2.rs
@@ -61,9 +61,9 @@ fn test_current_cycles() {
     });
 
     let tx_data = Arc::new(build_tx_data(rtx));
-    let vm_data = build_vm_data(tx_data, vec![], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![], vec![]);
 
-    let vm_context = VmContext::new(&vm_data, &Arc::new(Mutex::new(Vec::new())));
+    let vm_context = VmContext::new(&sg_data, &Arc::new(Mutex::new(Vec::new())));
 
     let result = CurrentCycles::new(&vm_context).ecall(&mut machine);
 
@@ -122,9 +122,9 @@ fn _test_load_extension(
     });
 
     let tx_data = Arc::new(build_tx_data_with_loader(rtx, data_loader));
-    let vm_data = build_vm_data(tx_data, vec![0], vec![]);
+    let sg_data = build_sg_data(tx_data, vec![0], vec![]);
 
-    let mut load_block_extension = LoadBlockExtension::new(&vm_data);
+    let mut load_block_extension = LoadBlockExtension::new(&sg_data);
 
     prop_assert!(machine
         .memory_mut()
diff --git a/script/src/syscalls/wait.rs b/script/src/syscalls/wait.rs
index 17592368f6..11ae3693e3 100644
--- a/script/src/syscalls/wait.rs
+++ b/script/src/syscalls/wait.rs
@@ -1,5 +1,5 @@
 use crate::syscalls::{SPAWN_YIELD_CYCLES_BASE, WAIT};
-use crate::types::{Message, VmContext, VmData, VmId, WaitArgs};
+use crate::types::{Message, VmContext, VmId, WaitArgs};
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_vm::{
     registers::{A0, A1, A7},
@@ -14,12 +14,12 @@ pub struct Wait {
 }
 
 impl Wait {
-    pub fn new<DL>(vm_data: &Arc<VmData<DL>>, vm_context: &VmContext<DL>) -> Self
+    pub fn new<DL>(vm_id: &VmId, vm_context: &VmContext<DL>) -> Self
     where
         DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
     {
         Self {
-            id: vm_data.vm_id,
+            id: *vm_id,
             message_box: Arc::clone(&vm_context.message_box),
         }
     }
diff --git a/script/src/syscalls/write.rs b/script/src/syscalls/write.rs
index 6d75d2d63b..2784abbeb4 100644
--- a/script/src/syscalls/write.rs
+++ b/script/src/syscalls/write.rs
@@ -1,5 +1,5 @@
 use crate::syscalls::{INVALID_FD, SPAWN_YIELD_CYCLES_BASE, WRITE};
-use crate::types::{Fd, FdArgs, Message, VmContext, VmData, VmId};
+use crate::types::{Fd, FdArgs, Message, VmContext, VmId};
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_vm::{
     registers::{A0, A1, A2, A7},
@@ -14,12 +14,12 @@ pub struct Write {
 }
 
 impl Write {
-    pub fn new<DL>(vm_data: &Arc<VmData<DL>>, vm_context: &VmContext<DL>) -> Self
+    pub fn new<DL>(vm_id: &VmId, vm_context: &VmContext<DL>) -> Self
     where
         DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
     {
         Self {
-            id: vm_data.vm_id,
+            id: *vm_id,
             message_box: Arc::clone(&vm_context.message_box),
         }
     }
diff --git a/script/src/types.rs b/script/src/types.rs
index a0ed256fb6..eee70ab348 100644
--- a/script/src/types.rs
+++ b/script/src/types.rs
@@ -847,6 +847,30 @@ impl<DL> SgData<DL> {
             program_data_piece_id: DataPieceId::CellDep(dep_index),
         })
     }
+
+    pub fn rtx(&self) -> &ResolvedTransaction {
+        &self.tx_data.rtx
+    }
+
+    pub fn data_loader(&self) -> &DL {
+        &self.tx_data.data_loader
+    }
+
+    pub fn group_inputs(&self) -> &[usize] {
+        &self.script_group.input_indices
+    }
+
+    pub fn group_outputs(&self) -> &[usize] {
+        &self.script_group.output_indices
+    }
+
+    pub fn outputs(&self) -> &[CellMeta] {
+        &self.tx_data.outputs
+    }
+
+    pub fn current_script_hash(&self) -> &Byte32 {
+        &self.script_hash
+    }
 }
 
 impl<DL> DataSource<DataPieceId> for Arc<SgData<DL>>
@@ -919,51 +943,6 @@ where
     }
 }
 
-/// Immutable context data at virtual machine level
-#[derive(Clone, Debug)]
-pub struct VmData<DL> {
-    /// Script group level data
-    pub sg_data: Arc<SgData<DL>>,
-
-    /// Currently executed virtual machine ID
-    pub vm_id: VmId,
-}
-
-impl<DL> VmData<DL> {
-    pub fn rtx(&self) -> &ResolvedTransaction {
-        &self.sg_data.tx_data.rtx
-    }
-
-    pub fn data_loader(&self) -> &DL {
-        &self.sg_data.tx_data.data_loader
-    }
-
-    pub fn group_inputs(&self) -> &[usize] {
-        &self.sg_data.script_group.input_indices
-    }
-
-    pub fn group_outputs(&self) -> &[usize] {
-        &self.sg_data.script_group.output_indices
-    }
-
-    pub fn outputs(&self) -> &[CellMeta] {
-        &self.sg_data.tx_data.outputs
-    }
-
-    pub fn current_script_hash(&self) -> &Byte32 {
-        &self.sg_data.script_hash
-    }
-}
-
-impl<DL> DataSource<DataPieceId> for Arc<VmData<DL>>
-where
-    DL: CellDataProvider,
-{
-    fn load_data(&self, id: &DataPieceId, offset: u64, length: u64) -> Option<(Bytes, u64)> {
-        self.sg_data.load_data(id, offset, length)
-    }
-}
-
 /// Mutable data at virtual machine level
 #[derive(Clone)]
 pub struct VmContext<DL>
@@ -973,7 +952,7 @@ where
     pub(crate) base_cycles: Arc<AtomicU64>,
     /// A mutable reference to scheduler's message box
     pub(crate) message_box: Arc<Mutex<Vec<Message>>>,
-    pub(crate) snapshot2_context: Arc<Mutex<Snapshot2Context<DataPieceId, Arc<VmData<DL>>>>>,
+    pub(crate) snapshot2_context: Arc<Mutex<Snapshot2Context<DataPieceId, Arc<SgData<DL>>>>>,
 }
 
 impl<DL> VmContext<DL>
@@ -983,11 +962,11 @@ where
     /// Creates a new VM context. It is by design that parameters to this function
     /// are references. It is a reminder that the inputs are designed to be shared
     /// among different entities.
-    pub fn new(vm_data: &Arc<VmData<DL>>, message_box: &Arc<Mutex<Vec<Message>>>) -> Self {
+    pub fn new(sg_data: &Arc<SgData<DL>>, message_box: &Arc<Mutex<Vec<Message>>>) -> Self {
         Self {
             base_cycles: Arc::new(AtomicU64::new(0)),
             message_box: Arc::clone(message_box),
-            snapshot2_context: Arc::new(Mutex::new(Snapshot2Context::new(Arc::clone(vm_data)))),
+            snapshot2_context: Arc::new(Mutex::new(Snapshot2Context::new(Arc::clone(sg_data)))),
         }
     }