From 01ac46c7f0341c92834a612212c9dedb55ff2376 Mon Sep 17 00:00:00 2001
From: mohanson <mohanson@outlook.com>
Date: Tue, 23 Mar 2021 17:23:51 +0800
Subject: [PATCH 01/14] Bump ckb-vm

---
 Cargo.lock                            | 28 ++++++++++-
 script/Cargo.toml                     |  4 +-
 script/src/cost_model.rs              | 68 ++++++++++++++++++++-------
 script/src/ill_transaction_checker.rs | 51 ++++++++------------
 script/src/syscalls/mod.rs            | 53 ++++++++++++++++-----
 script/src/verify.rs                  | 18 ++++---
 6 files changed, 152 insertions(+), 70 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 05ba4ca806..49081d90ad 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1137,7 +1137,7 @@ dependencies = [
  "ckb-vm",
  "ckb-vm-definitions",
  "faster-hex 0.4.1",
- "goblin",
+ "goblin 0.2.3",
  "proptest",
  "serde",
  "tiny-keccak",
@@ -1491,26 +1491,39 @@ dependencies = [
 
 [[package]]
 name = "ckb-vm"
+<<<<<<< HEAD
 version = "0.19.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2f4b7a3a2f19771d379884030417094c55986ccbc0d5caaaa651f7421ead4bb4"
+=======
+version = "0.19.1"
+source = "git+https://github.com/mohanson/ckb-vm?branch=instruction_design#fbd9af94342da2fe42839f965dbab1851aa87fb4"
+>>>>>>> Bump ckb-vm
 dependencies = [
  "byteorder",
  "bytes 1.0.1",
  "cc",
  "ckb-vm-definitions",
  "derive_more",
- "goblin",
+ "goblin 0.2.3",
+ "goblin 0.3.4",
  "libc",
  "mapr",
+ "rand 0.7.3",
  "scroll",
+ "serde",
 ]
 
 [[package]]
 name = "ckb-vm-definitions"
+<<<<<<< HEAD
 version = "0.19.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f5dd4b68248ffd8283d693a477f9594d195ceac25f6aa7f98e99d1b8f43f9b3e"
+=======
+version = "0.19.1"
+source = "git+https://github.com/mohanson/ckb-vm?branch=instruction_design#fbd9af94342da2fe42839f965dbab1851aa87fb4"
+>>>>>>> Bump ckb-vm
 
 [[package]]
 name = "clap"
@@ -2309,6 +2322,17 @@ dependencies = [
  "scroll",
 ]
 
+[[package]]
+name = "goblin"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "669cdc3826f69a51d3f8fc3f86de81c2378110254f678b8407977736122057a4"
+dependencies = [
+ "log",
+ "plain",
+ "scroll",
+]
+
 [[package]]
 name = "governor"
 version = "0.3.1"
diff --git a/script/Cargo.toml b/script/Cargo.toml
index a3a9050947..7f0f74d39a 100644
--- a/script/Cargo.toml
+++ b/script/Cargo.toml
@@ -21,14 +21,14 @@ ckb-traits = { path = "../traits", version = "= 0.43.0-pre" }
 byteorder = "1.3.1"
 ckb-types = {path = "../util/types", version = "= 0.43.0-pre"}
 ckb-hash = {path = "../util/hash", version = "= 0.43.0-pre"}
-ckb-vm = { version = "0.19.4", default-features = false }
+ckb-vm-definitions = { git = "https://github.com/mohanson/ckb-vm", branch="instruction_design" }
+ckb-vm = { git = "https://github.com/mohanson/ckb-vm", branch="instruction_design", default-features = false }
 faster-hex = "0.4"
 ckb-logger = { path = "../util/logger", version = "= 0.43.0-pre", optional = true }
 serde = { version = "1.0", features = ["derive"] }
 ckb-error = { path = "../error", version = "= 0.43.0-pre" }
 ckb-chain-spec = { path = "../spec", version = "= 0.43.0-pre" }
 goblin = "0.2"
-ckb-vm-definitions = "0.19.4"
 
 [dev-dependencies]
 proptest = "0.9"
diff --git a/script/src/cost_model.rs b/script/src/cost_model.rs
index dbcd458aa1..dce2c33adc 100644
--- a/script/src/cost_model.rs
+++ b/script/src/cost_model.rs
@@ -10,6 +10,9 @@ use ckb_vm::{
 // 0.25 cycles per byte
 pub const BYTES_PER_CYCLE: u64 = 4;
 
+/// The cost of switching between assembly and rust.
+pub const CONTEXT_SWITCH_CYCLE: u64 = 500;
+
 /// Calculates how many cycles spent to load the specified number of bytes.
 pub fn transferred_byte_cycles(bytes: u64) -> u64 {
     // Compiler will optimize the divisin here to shifts.
@@ -19,6 +22,7 @@ pub fn transferred_byte_cycles(bytes: u64) -> u64 {
 /// Returns the spent cycles to execute the secific instruction.
 pub fn instruction_cycles(i: Instruction) -> u64 {
     match extract_opcode(i) {
+        // IMC
         insts::OP_JALR => 3,
         insts::OP_LD => 2,
         insts::OP_LW => 3,
@@ -37,24 +41,9 @@ pub fn instruction_cycles(i: Instruction) -> u64 {
         insts::OP_BLT => 3,
         insts::OP_BLTU => 3,
         insts::OP_BNE => 3,
-        insts::OP_EBREAK => 500,
-        insts::OP_ECALL => 500,
+        insts::OP_EBREAK => CONTEXT_SWITCH_CYCLE,
+        insts::OP_ECALL => CONTEXT_SWITCH_CYCLE,
         insts::OP_JAL => 3,
-        insts::OP_RVC_LW => 3,
-        insts::OP_RVC_LD => 2,
-        insts::OP_RVC_SW => 3,
-        insts::OP_RVC_SD => 2,
-        insts::OP_RVC_LWSP => 3,
-        insts::OP_RVC_LDSP => 2,
-        insts::OP_RVC_SWSP => 3,
-        insts::OP_RVC_SDSP => 2,
-        insts::OP_RVC_BEQZ => 3,
-        insts::OP_RVC_BNEZ => 3,
-        insts::OP_RVC_JAL => 3,
-        insts::OP_RVC_J => 3,
-        insts::OP_RVC_JR => 3,
-        insts::OP_RVC_JALR => 3,
-        insts::OP_RVC_EBREAK => 500,
         insts::OP_MUL => 5,
         insts::OP_MULW => 5,
         insts::OP_MULH => 5,
@@ -68,6 +57,51 @@ pub fn instruction_cycles(i: Instruction) -> u64 {
         insts::OP_REMW => 32,
         insts::OP_REMU => 32,
         insts::OP_REMUW => 32,
+        // B
+        insts::OP_GREV => CONTEXT_SWITCH_CYCLE + 20,
+        insts::OP_GREVI => CONTEXT_SWITCH_CYCLE + 20,
+        insts::OP_GREVW => CONTEXT_SWITCH_CYCLE + 18,
+        insts::OP_GREVIW => CONTEXT_SWITCH_CYCLE + 18,
+        insts::OP_SHFL => CONTEXT_SWITCH_CYCLE + 20,
+        insts::OP_UNSHFL => CONTEXT_SWITCH_CYCLE + 20,
+        insts::OP_SHFLI => CONTEXT_SWITCH_CYCLE + 20,
+        insts::OP_UNSHFLI => CONTEXT_SWITCH_CYCLE + 20,
+        insts::OP_SHFLW => CONTEXT_SWITCH_CYCLE + 18,
+        insts::OP_UNSHFLW => CONTEXT_SWITCH_CYCLE + 18,
+        insts::OP_GORC => CONTEXT_SWITCH_CYCLE + 20,
+        insts::OP_GORCI => CONTEXT_SWITCH_CYCLE + 20,
+        insts::OP_GORCW => CONTEXT_SWITCH_CYCLE + 18,
+        insts::OP_GORCIW => CONTEXT_SWITCH_CYCLE + 18,
+        insts::OP_BFP => CONTEXT_SWITCH_CYCLE + 15,
+        insts::OP_BFPW => CONTEXT_SWITCH_CYCLE + 15,
+        insts::OP_BDEP => CONTEXT_SWITCH_CYCLE + 350,
+        insts::OP_BEXT => CONTEXT_SWITCH_CYCLE + 270,
+        insts::OP_BDEPW => CONTEXT_SWITCH_CYCLE + 180,
+        insts::OP_BEXTW => CONTEXT_SWITCH_CYCLE + 140,
+        insts::OP_CLMUL => CONTEXT_SWITCH_CYCLE + 320,
+        insts::OP_CLMULR => CONTEXT_SWITCH_CYCLE + 380,
+        insts::OP_CLMULH => CONTEXT_SWITCH_CYCLE + 400,
+        insts::OP_CLMULW => CONTEXT_SWITCH_CYCLE + 60,
+        insts::OP_CLMULRW => CONTEXT_SWITCH_CYCLE + 60,
+        insts::OP_CLMULHW => CONTEXT_SWITCH_CYCLE + 60,
+        insts::OP_CRC32B => CONTEXT_SWITCH_CYCLE + 15,
+        insts::OP_CRC32H => CONTEXT_SWITCH_CYCLE + 30,
+        insts::OP_CRC32W => CONTEXT_SWITCH_CYCLE + 45,
+        insts::OP_CRC32D => CONTEXT_SWITCH_CYCLE + 60,
+        insts::OP_CRC32CB => CONTEXT_SWITCH_CYCLE + 15,
+        insts::OP_CRC32CH => CONTEXT_SWITCH_CYCLE + 30,
+        insts::OP_CRC32CW => CONTEXT_SWITCH_CYCLE + 45,
+        insts::OP_CRC32CD => CONTEXT_SWITCH_CYCLE + 60,
+        insts::OP_BMATFLIP => CONTEXT_SWITCH_CYCLE + 40,
+        insts::OP_BMATOR => CONTEXT_SWITCH_CYCLE + 500,
+        insts::OP_BMATXOR => CONTEXT_SWITCH_CYCLE + 800,
+        // MOP
+        insts::OP_WIDE_MUL => 5,
+        insts::OP_WIDE_MULU => 5,
+        insts::OP_WIDE_DIV => 32,
+        insts::OP_WIDE_DIVU => 32,
+        insts::OP_FAR_JUMP_REL => 3,
+        insts::OP_FAR_JUMP_ABS => 3,
         _ => 1,
     }
 }
diff --git a/script/src/ill_transaction_checker.rs b/script/src/ill_transaction_checker.rs
index bcfceecf6b..b5e0916c7e 100644
--- a/script/src/ill_transaction_checker.rs
+++ b/script/src/ill_transaction_checker.rs
@@ -2,8 +2,8 @@ use crate::ScriptError;
 use byteorder::{ByteOrder, LittleEndian};
 use ckb_types::core::TransactionView;
 use ckb_vm::{
-    instructions::{extract_opcode, i, m, rvc, Instruction, Itype, Stype},
-    registers::{RA, ZERO},
+    instructions::{b, extract_opcode, i, m, rvc, Instruction, Itype},
+    registers::ZERO,
 };
 use ckb_vm_definitions::instructions as insts;
 use goblin::elf::{section_header::SHF_EXECINSTR, Elf};
@@ -56,35 +56,19 @@ impl<'a> IllScriptChecker<'a> {
                 let mut pc = section_header.sh_offset;
                 let end = section_header.sh_offset + section_header.sh_size;
                 while pc < end {
-                    match self.decode_instruction(pc) {
-                        (Some(i), len) => {
-                            match extract_opcode(i) {
-                                insts::OP_JALR => {
-                                    let i = Itype(i);
-                                    if i.rs1() == i.rd() && i.rd() != ZERO {
-                                        return Err(ScriptError::EncounteredKnownBugs(
-                                            CKB_VM_ISSUE_92.to_string(),
-                                            self.index,
-                                        ));
-                                    }
-                                }
-                                insts::OP_RVC_JALR => {
-                                    let i = Stype(i);
-                                    if i.rs1() == RA {
-                                        return Err(ScriptError::EncounteredKnownBugs(
-                                            CKB_VM_ISSUE_92.to_string(),
-                                            self.index,
-                                        ));
-                                    }
-                                }
-                                _ => (),
-                            };
-                            pc += len;
-                        }
-                        (None, len) => {
-                            pc += len;
-                        }
+                    let (option_instruction, len) = self.decode_instruction(pc);
+                    if let Some(i) = option_instruction {
+                        if extract_opcode(i) == insts::OP_JALR {
+                            let i = Itype(i);
+                            if i.rs1() == i.rd() && i.rd() != ZERO {
+                                return Err(ScriptError::EncounteredKnownBugs(
+                                    CKB_VM_ISSUE_92.to_string(),
+                                    self.index,
+                                ));
+                            }
+                        };
                     }
+                    pc += len;
                 }
             }
         }
@@ -103,7 +87,12 @@ impl<'a> IllScriptChecker<'a> {
             }
             i = LittleEndian::read_u32(&self.data[pc as usize..]);
         }
-        let factories = [rvc::factory::<u64>, i::factory::<u64>, m::factory::<u64>];
+        let factories = [
+            rvc::factory::<u64>,
+            i::factory::<u64>,
+            m::factory::<u64>,
+            b::factory::<u64>,
+        ];
         for factory in &factories {
             if let Some(instruction) = factory(i) {
                 return (Some(instruction), len);
diff --git a/script/src/syscalls/mod.rs b/script/src/syscalls/mod.rs
index 1382cb75fd..7a305ee0c7 100644
--- a/script/src/syscalls/mod.rs
+++ b/script/src/syscalls/mod.rs
@@ -193,9 +193,11 @@ mod tests {
     };
     use ckb_vm::machine::DefaultCoreMachine;
     use ckb_vm::{
-        memory::{FLAG_EXECUTABLE, FLAG_FREEZED, FLAG_WRITABLE},
+        machine::VERSION0,
+        memory::{FLAG_DIRTY, FLAG_EXECUTABLE, FLAG_FREEZED, FLAG_WRITABLE},
         registers::{A0, A1, A2, A3, A4, A5, A7},
-        CoreMachine, Error as VMError, Memory, SparseMemory, Syscalls, WXorXMemory, RISCV_PAGESIZE,
+        CoreMachine, Error as VMError, Memory, SparseMemory, Syscalls, WXorXMemory, ISA_IMC,
+        RISCV_PAGESIZE,
     };
     use proptest::{collection::size_range, prelude::*};
     use std::collections::HashMap;
@@ -1066,7 +1068,12 @@ mod tests {
     }
 
     fn _test_load_cell_data_as_code(data: &[u8]) -> Result<(), TestCaseError> {
-        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<u64, SparseMemory<u64>>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
+
         let addr = 4096;
         let addr_size = 4096;
 
@@ -1102,7 +1109,7 @@ mod tests {
         prop_assert!(load_code.ecall(&mut machine).is_ok());
         prop_assert_eq!(machine.registers()[A0], u64::from(SUCCESS));
 
-        let flags = FLAG_EXECUTABLE | FLAG_FREEZED;
+        let flags = FLAG_EXECUTABLE | FLAG_FREEZED | FLAG_DIRTY;
         prop_assert_eq!(
             machine
                 .memory_mut()
@@ -1121,7 +1128,11 @@ mod tests {
     }
 
     fn _test_load_cell_data(data: &[u8]) -> Result<(), TestCaseError> {
-        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<u64, SparseMemory<u64>>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let size_addr: u64 = 100;
         let addr = 4096;
         let addr_size = 4096;
@@ -1157,7 +1168,7 @@ mod tests {
         prop_assert!(load_code.ecall(&mut machine).is_ok());
         prop_assert_eq!(machine.registers()[A0], u64::from(SUCCESS));
 
-        let flags = FLAG_WRITABLE;
+        let flags = FLAG_WRITABLE | FLAG_DIRTY;
         prop_assert_eq!(
             machine
                 .memory_mut()
@@ -1193,7 +1204,11 @@ mod tests {
     #[test]
     fn test_load_overflowed_cell_data_as_code() {
         let data = vec![0, 1, 2, 3, 4, 5];
-        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<u64, SparseMemory<u64>>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let addr = 4096;
         let addr_size = 4096;
 
@@ -1234,7 +1249,11 @@ mod tests {
         as_code: bool,
         data: &[u8],
     ) -> Result<(), TestCaseError> {
-        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<u64, SparseMemory<u64>>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let addr = 8192;
         let addr_size = 4096;
 
@@ -1300,7 +1319,11 @@ mod tests {
 
     #[test]
     fn test_load_code_unaligned_error() {
-        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<u64, SparseMemory<u64>>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let addr = 4097;
         let addr_size = 4096;
         let data = [2; 32];
@@ -1342,7 +1365,11 @@ mod tests {
 
     #[test]
     fn test_load_code_slice_out_of_bound_error() {
-        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<u64, SparseMemory<u64>>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let addr = 4096;
         let addr_size = 4096;
         let data = [2; 32];
@@ -1386,7 +1413,11 @@ mod tests {
 
     #[test]
     fn test_load_code_not_enough_space_error() {
-        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<u64, SparseMemory<u64>>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let addr = 4096;
         let addr_size = 4096;
 
diff --git a/script/src/verify.rs b/script/src/verify.rs
index 7309f79bb6..3d793d045e 100644
--- a/script/src/verify.rs
+++ b/script/src/verify.rs
@@ -24,9 +24,12 @@ use ckb_types::{
 };
 #[cfg(has_asm)]
 use ckb_vm::{
-    machine::asm::{AsmCoreMachine, AsmMachine},
+    machine::{
+        asm::{AsmCoreMachine, AsmMachine},
+        VERSION0,
+    },
     DefaultMachineBuilder, Error as VMInternalError, InstructionCycleFunc, SupportMachine,
-    Syscalls,
+    Syscalls, ISA_B, ISA_IMC,
 };
 #[cfg(not(has_asm))]
 use ckb_vm::{
@@ -406,12 +409,13 @@ impl<'a, DL: CellDataProvider + HeaderProvider> TransactionScriptsVerifier<'a, D
     fn run(&self, script_group: &ScriptGroup, max_cycles: Cycle) -> Result<Cycle, ScriptError> {
         let program = self.extract_script(&script_group.script)?;
         #[cfg(has_asm)]
-        let core_machine = AsmCoreMachine::new_with_max_cycles(max_cycles);
+        let core_machine = AsmCoreMachine::new(ISA_IMC | ISA_B, VERSION0, max_cycles);
         #[cfg(not(has_asm))]
-        let core_machine =
-            DefaultCoreMachine::<u64, WXorXMemory<u64, SparseMemory<u64>>>::new_with_max_cycles(
-                max_cycles,
-            );
+        let core_machine = DefaultCoreMachine::<u64, WXorXMemory<u64, SparseMemory<u64>>>::new(
+            ISA_IMC | ISA_B,
+            VERSION0,
+            max_cycles,
+        );
         let machine_builder = DefaultMachineBuilder::<CoreMachineType>::new(core_machine)
             .instruction_cycle_func(self.cost_model());
         let machine_builder = self

From ca6d22af7489ba3d049bbb537c56e433e3001224 Mon Sep 17 00:00:00 2001
From: mohanson <mohanson@outlook.com>
Date: Thu, 20 May 2021 09:39:13 +0800
Subject: [PATCH 02/14] feat: new syscalls

---
 Cargo.lock                            |  22 +---
 script/Cargo.toml                     |   4 +-
 script/src/syscalls/current_cycles.rs |  28 +++++
 script/src/syscalls/exec.rs           | 156 ++++++++++++++++++++++++++
 script/src/syscalls/mod.rs            |  83 +++++++++++++-
 script/src/syscalls/vm_version.rs     |  28 +++++
 script/src/verify.rs                  | 135 +++++++++++++++++++++-
 script/testdata/current_cycles        | Bin 0 -> 6400 bytes
 script/testdata/current_cycles.c      |  23 ++++
 script/testdata/exec_callee           | Bin 0 -> 6352 bytes
 script/testdata/exec_callee.c         |  21 ++++
 script/testdata/exec_caller           | Bin 0 -> 6552 bytes
 script/testdata/exec_caller.c         |  28 +++++
 script/testdata/vm_version            | Bin 0 -> 6400 bytes
 script/testdata/vm_version.c          |  23 ++++
 15 files changed, 528 insertions(+), 23 deletions(-)
 create mode 100644 script/src/syscalls/current_cycles.rs
 create mode 100644 script/src/syscalls/exec.rs
 create mode 100644 script/src/syscalls/vm_version.rs
 create mode 100755 script/testdata/current_cycles
 create mode 100644 script/testdata/current_cycles.c
 create mode 100755 script/testdata/exec_callee
 create mode 100644 script/testdata/exec_callee.c
 create mode 100755 script/testdata/exec_caller
 create mode 100644 script/testdata/exec_caller.c
 create mode 100755 script/testdata/vm_version
 create mode 100644 script/testdata/vm_version.c

diff --git a/Cargo.lock b/Cargo.lock
index 49081d90ad..50b036fc7b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1491,14 +1491,8 @@ dependencies = [
 
 [[package]]
 name = "ckb-vm"
-<<<<<<< HEAD
-version = "0.19.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f4b7a3a2f19771d379884030417094c55986ccbc0d5caaaa651f7421ead4bb4"
-=======
 version = "0.19.1"
-source = "git+https://github.com/mohanson/ckb-vm?branch=instruction_design#fbd9af94342da2fe42839f965dbab1851aa87fb4"
->>>>>>> Bump ckb-vm
+source = "git+https://github.com/mohanson/ckb-vm?branch=develop#09e1e21995acaea3f75d26e144e652b4c4ba67ea"
 dependencies = [
  "byteorder",
  "bytes 1.0.1",
@@ -1506,7 +1500,7 @@ dependencies = [
  "ckb-vm-definitions",
  "derive_more",
  "goblin 0.2.3",
- "goblin 0.3.4",
+ "goblin 0.4.0",
  "libc",
  "mapr",
  "rand 0.7.3",
@@ -1516,14 +1510,8 @@ dependencies = [
 
 [[package]]
 name = "ckb-vm-definitions"
-<<<<<<< HEAD
-version = "0.19.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5dd4b68248ffd8283d693a477f9594d195ceac25f6aa7f98e99d1b8f43f9b3e"
-=======
 version = "0.19.1"
-source = "git+https://github.com/mohanson/ckb-vm?branch=instruction_design#fbd9af94342da2fe42839f965dbab1851aa87fb4"
->>>>>>> Bump ckb-vm
+source = "git+https://github.com/mohanson/ckb-vm?branch=develop#09e1e21995acaea3f75d26e144e652b4c4ba67ea"
 
 [[package]]
 name = "clap"
@@ -2324,9 +2312,9 @@ dependencies = [
 
 [[package]]
 name = "goblin"
-version = "0.3.4"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "669cdc3826f69a51d3f8fc3f86de81c2378110254f678b8407977736122057a4"
+checksum = "532a09cd3df2c6bbfc795fb0434bff8f22255d1d07328180e918a2e6ce122d4d"
 dependencies = [
  "log",
  "plain",
diff --git a/script/Cargo.toml b/script/Cargo.toml
index 7f0f74d39a..6f788993f0 100644
--- a/script/Cargo.toml
+++ b/script/Cargo.toml
@@ -21,8 +21,8 @@ ckb-traits = { path = "../traits", version = "= 0.43.0-pre" }
 byteorder = "1.3.1"
 ckb-types = {path = "../util/types", version = "= 0.43.0-pre"}
 ckb-hash = {path = "../util/hash", version = "= 0.43.0-pre"}
-ckb-vm-definitions = { git = "https://github.com/mohanson/ckb-vm", branch="instruction_design" }
-ckb-vm = { git = "https://github.com/mohanson/ckb-vm", branch="instruction_design", default-features = false }
+ckb-vm-definitions = { git = "https://github.com/mohanson/ckb-vm", branch="develop" }
+ckb-vm = { git = "https://github.com/mohanson/ckb-vm", branch="develop", default-features = false }
 faster-hex = "0.4"
 ckb-logger = { path = "../util/logger", version = "= 0.43.0-pre", optional = true }
 serde = { version = "1.0", features = ["derive"] }
diff --git a/script/src/syscalls/current_cycles.rs b/script/src/syscalls/current_cycles.rs
new file mode 100644
index 0000000000..4f80c73d3f
--- /dev/null
+++ b/script/src/syscalls/current_cycles.rs
@@ -0,0 +1,28 @@
+use crate::syscalls::CURRENT_CYCLES;
+use ckb_vm::{
+    registers::{A0, A7},
+    Error as VMError, Register, SupportMachine, Syscalls,
+};
+
+#[derive(Debug)]
+pub struct CurrentCycles {}
+
+impl CurrentCycles {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl<Mac: SupportMachine> Syscalls<Mac> for CurrentCycles {
+    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_CYCLES {
+            return Ok(false);
+        }
+        machine.set_register(A0, Mac::REG::from_u64(machine.cycles()));
+        Ok(true)
+    }
+}
diff --git a/script/src/syscalls/exec.rs b/script/src/syscalls/exec.rs
new file mode 100644
index 0000000000..e682348434
--- /dev/null
+++ b/script/src/syscalls/exec.rs
@@ -0,0 +1,156 @@
+use crate::cost_model::transferred_byte_cycles;
+use crate::syscalls::{Source, SourceEntry, EXEC, INDEX_OUT_OF_BOUND, WRONG_FORMAT};
+use ckb_traits::CellDataProvider;
+use ckb_types::core::cell::CellMeta;
+use ckb_vm::Memory;
+use ckb_vm::{
+    registers::{A0, A1, A2, A3, A7},
+    Bytes, Error as VMError, Register, SupportMachine, Syscalls,
+};
+use ckb_vm::{DEFAULT_STACK_SIZE, RISCV_MAX_MEMORY};
+
+#[derive(Debug)]
+pub struct Exec<'a, DL> {
+    data_loader: &'a DL,
+    outputs: &'a [CellMeta],
+    resolved_inputs: &'a [CellMeta],
+    resolved_cell_deps: &'a [CellMeta],
+    group_inputs: &'a [usize],
+    group_outputs: &'a [usize],
+}
+
+impl<'a, DL: CellDataProvider + 'a> Exec<'a, DL> {
+    pub fn new(
+        data_loader: &'a DL,
+        outputs: &'a [CellMeta],
+        resolved_inputs: &'a [CellMeta],
+        resolved_cell_deps: &'a [CellMeta],
+        group_inputs: &'a [usize],
+        group_outputs: &'a [usize],
+    ) -> Exec<'a, DL> {
+        Exec {
+            data_loader,
+            outputs,
+            resolved_inputs,
+            resolved_cell_deps,
+            group_inputs,
+            group_outputs,
+        }
+    }
+
+    fn fetch_cell(&self, source: Source, index: usize) -> Result<&'a CellMeta, u8> {
+        match source {
+            Source::Transaction(SourceEntry::Input) => {
+                self.resolved_inputs.get(index).ok_or(INDEX_OUT_OF_BOUND)
+            }
+            Source::Transaction(SourceEntry::Output) => {
+                self.outputs.get(index).ok_or(INDEX_OUT_OF_BOUND)
+            }
+            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),
+        }
+    }
+}
+
+fn load_c_string<Mac: SupportMachine>(machine: &mut Mac, addr: u64) -> Result<Bytes, VMError> {
+    let mut buffer = Vec::new();
+    let mut addr = addr;
+
+    loop {
+        let byte = machine
+            .memory_mut()
+            .load8(&Mac::REG::from_u64(addr))?
+            .to_u8();
+        if byte == 0 {
+            break;
+        }
+        buffer.push(byte);
+        addr += 1;
+    }
+
+    Ok(Bytes::from(buffer))
+}
+
+impl<'a, Mac: SupportMachine, DL: CellDataProvider> Syscalls<Mac> for Exec<'a, DL> {
+    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() != EXEC {
+            return Ok(false);
+        }
+
+        let index = machine.registers()[A0].to_u64();
+        let source = Source::parse_from_u64(machine.registers()[A1].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(false);
+        }
+        let cell = cell.unwrap();
+        let data = self
+            .data_loader
+            .load_cell_data(cell)
+            .ok_or(VMError::Unexpected)?;
+
+        let argc = machine.registers()[A2].to_u64();
+        let mut addr = machine.registers()[A3].to_u64();
+        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.push(cstr);
+            addr += 8;
+        }
+
+        machine.reset();
+
+        match machine.load_elf(&data, true) {
+            Ok(size) => {
+                machine.add_cycles(transferred_byte_cycles(size))?;
+            }
+            Err(_) => {
+                machine.set_register(A0, Mac::REG::from_u8(WRONG_FORMAT));
+                return Ok(false);
+            }
+        }
+
+        match machine.initialize_stack(
+            &argv,
+            (RISCV_MAX_MEMORY - DEFAULT_STACK_SIZE) as u64,
+            DEFAULT_STACK_SIZE as u64,
+        ) {
+            Ok(size) => {
+                machine.add_cycles(transferred_byte_cycles(size))?;
+            }
+            Err(_) => {
+                machine.set_register(A0, Mac::REG::from_u8(WRONG_FORMAT));
+                return Ok(false);
+            }
+        }
+        Ok(true)
+    }
+}
diff --git a/script/src/syscalls/mod.rs b/script/src/syscalls/mod.rs
index 7a305ee0c7..92fd900f32 100644
--- a/script/src/syscalls/mod.rs
+++ b/script/src/syscalls/mod.rs
@@ -1,4 +1,6 @@
+mod current_cycles;
 mod debugger;
+mod exec;
 mod load_cell;
 mod load_cell_data;
 mod load_header;
@@ -8,8 +10,11 @@ mod load_script_hash;
 mod load_tx;
 mod load_witness;
 mod utils;
+mod vm_version;
 
+pub use self::current_cycles::CurrentCycles;
 pub use self::debugger::Debugger;
+pub use self::exec::Exec;
 pub use self::load_cell::LoadCell;
 pub use self::load_cell_data::LoadCellData;
 pub use self::load_header::LoadHeader;
@@ -18,6 +23,7 @@ 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::vm_version::VMVersion;
 
 use ckb_vm::Error;
 
@@ -29,7 +35,11 @@ pub const SUCCESS: u8 = 0;
 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 VM_VERSION: u64 = 2041;
+pub const CURRENT_CYCLES: u64 = 2042;
+pub const EXEC: u64 = 2043;
 pub const LOAD_TRANSACTION_SYSCALL_NUMBER: u64 = 2051;
 pub const LOAD_SCRIPT_SYSCALL_NUMBER: u64 = 2052;
 pub const LOAD_TX_HASH_SYSCALL_NUMBER: u64 = 2061;
@@ -191,9 +201,9 @@ mod tests {
         prelude::*,
         H256,
     };
-    use ckb_vm::machine::DefaultCoreMachine;
+    use ckb_vm::{SupportMachine, machine::DefaultCoreMachine};
     use ckb_vm::{
-        machine::VERSION0,
+        machine::{VERSION0, VERSION1},
         memory::{FLAG_DIRTY, FLAG_EXECUTABLE, FLAG_FREEZED, FLAG_WRITABLE},
         registers::{A0, A1, A2, A3, A4, A5, A7},
         CoreMachine, Error as VMError, Memory, SparseMemory, Syscalls, WXorXMemory, ISA_IMC,
@@ -1460,4 +1470,73 @@ mod tests {
             assert_eq!(machine.memory_mut().load8(&i), Ok(1));
         }
     }
+
+    #[test]
+    fn test_vm_version0() {
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
+
+        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, VM_VERSION);
+
+        let result = VMVersion::new().ecall(&mut machine);
+
+        assert_eq!(result.unwrap(), true);
+        assert_eq!(machine.registers()[A0], 0);
+    }
+
+    #[test]
+    fn test_vm_version1() {
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION1,
+            u64::max_value(),
+        );
+
+        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, VM_VERSION);
+
+        let result = VMVersion::new().ecall(&mut machine);
+
+        assert_eq!(result.unwrap(), true);
+        assert_eq!(machine.registers()[A0], 1);
+    }
+
+    #[test]
+    fn test_current_cycles() {
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION1,
+            u64::max_value(),
+        );
+
+        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, CURRENT_CYCLES);
+
+        machine.set_cycles(100);
+
+        let result = CurrentCycles::new().ecall(&mut machine);
+
+        assert_eq!(result.unwrap(), true);
+        assert_eq!(machine.registers()[A0], 100);
+    }
+
 }
diff --git a/script/src/syscalls/vm_version.rs b/script/src/syscalls/vm_version.rs
new file mode 100644
index 0000000000..ad2283dfcb
--- /dev/null
+++ b/script/src/syscalls/vm_version.rs
@@ -0,0 +1,28 @@
+use crate::syscalls::VM_VERSION;
+use ckb_vm::{
+    registers::{A0, A7},
+    Error as VMError, Register, SupportMachine, Syscalls,
+};
+
+#[derive(Debug)]
+pub struct VMVersion {}
+
+impl VMVersion {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl<Mac: SupportMachine> Syscalls<Mac> for VMVersion {
+    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() != VM_VERSION {
+            return Ok(false);
+        }
+        machine.set_register(A0, Mac::REG::from_u32(machine.version()));
+        Ok(true)
+    }
+}
diff --git a/script/src/verify.rs b/script/src/verify.rs
index 3d793d045e..26f6800453 100644
--- a/script/src/verify.rs
+++ b/script/src/verify.rs
@@ -2,8 +2,8 @@ use crate::{
     cost_model::{instruction_cycles, transferred_byte_cycles},
     error::ScriptError,
     syscalls::{
-        Debugger, LoadCell, LoadCellData, LoadHeader, LoadInput, LoadScript, LoadScriptHash,
-        LoadTx, LoadWitness,
+        CurrentCycles, Debugger, Exec, LoadCell, LoadCellData, LoadHeader, LoadInput, LoadScript,
+        LoadScriptHash, LoadTx, LoadWitness, VMVersion,
     },
     type_id::TypeIdSystemScript,
     types::{ScriptGroup, ScriptGroupType},
@@ -200,6 +200,25 @@ impl<'a, DL: CellDataProvider + HeaderProvider> TransactionScriptsVerifier<'a, D
         self.rtx.transaction.hash()
     }
 
+    fn build_current_cycles(&self) -> CurrentCycles {
+        CurrentCycles::new()
+    }
+
+    fn build_vm_version(&self) -> VMVersion {
+        VMVersion::new()
+    }
+
+    fn build_exec(&'a self, group_inputs: &'a [usize], group_outputs: &'a [usize]) -> Exec<'a, DL> {
+        Exec::new(
+            &self.data_loader,
+            &self.outputs,
+            self.resolved_inputs(),
+            self.resolved_cell_deps(),
+            group_inputs,
+            group_outputs,
+        )
+    }
+
     fn build_load_tx(&self) -> LoadTx {
         LoadTx::new(&self.rtx.transaction)
     }
@@ -385,6 +404,9 @@ impl<'a, DL: CellDataProvider + HeaderProvider> TransactionScriptsVerifier<'a, D
     ) -> Vec<Box<(dyn Syscalls<CoreMachineType> + 'a)>> {
         let current_script_hash = script_group.script.calc_script_hash();
         vec![
+            Box::new(self.build_vm_version()),
+            Box::new(self.build_current_cycles()),
+            Box::new(self.build_exec(&script_group.input_indices, &script_group.output_indices)),
             Box::new(self.build_load_script_hash(current_script_hash.clone())),
             Box::new(self.build_load_tx()),
             Box::new(
@@ -1797,4 +1819,113 @@ mod tests {
         assert!(cycle <= TWO_IN_TWO_OUT_CYCLES);
         assert!(cycle >= TWO_IN_TWO_OUT_CYCLES - CYCLE_BOUND);
     }
+
+    #[test]
+    fn check_vm_version() {
+        let vm_version_cell_data = Bytes::from(std::fs::read(Path::new(env!("CARGO_MANIFEST_DIR")).join("testdata/vm_version")).unwrap());
+        let vm_version_cell = CellOutput::new_builder()
+        .capacity(
+            Capacity::bytes(vm_version_cell_data.len())
+                .unwrap()
+                .pack(),
+        )
+        .build();
+        let vm_version_script = Script::new_builder().hash_type(ScriptHashType::Data.into())
+            .code_hash(CellOutput::calc_data_hash(&vm_version_cell_data))
+            .build();
+        let output = CellOutputBuilder::default()
+            .capacity(capacity_bytes!(100).pack())
+            .lock(vm_version_script.clone())
+            .build();
+        let input = CellInput::new(OutPoint::null(), 0);
+
+        let transaction = TransactionBuilder::default().input(input).build();
+
+        let dummy_cell = CellMetaBuilder::from_cell_output(output, Bytes::new())
+            .transaction_info(default_transaction_info())
+            .build();
+        let vm_version_cell = CellMetaBuilder::from_cell_output(
+            vm_version_cell.clone(),
+            vm_version_cell_data.to_owned(),
+        )
+        .transaction_info(default_transaction_info())
+        .build();
+
+        let rtx = ResolvedTransaction {
+            transaction,
+            resolved_cell_deps: vec![vm_version_cell],
+            resolved_inputs: vec![dummy_cell],
+            resolved_dep_groups: vec![],
+        };
+
+        let store = new_store();
+        let data_loader = DataLoaderWrapper::new(&store);
+
+        let verifier = TransactionScriptsVerifier::new(&rtx, &data_loader);
+        assert!(verifier.verify(6000).is_ok());
+    }
+
+    #[test]
+    fn check_exec() {
+        let exec_caller_cell_data = Bytes::from(std::fs::read(Path::new(env!("CARGO_MANIFEST_DIR")).join("testdata/exec_caller")).unwrap());
+        let exec_caller_cell = CellOutput::new_builder()
+        .capacity(
+            Capacity::bytes(exec_caller_cell_data.len())
+                .unwrap()
+                .pack(),
+        )
+        .build();
+
+        let exec_callee_cell_data = Bytes::from(std::fs::read(Path::new(env!("CARGO_MANIFEST_DIR")).join("testdata/exec_callee")).unwrap());
+        let exec_callee_cell = CellOutput::new_builder()
+        .capacity(
+            Capacity::bytes(exec_callee_cell_data.len())
+                .unwrap()
+                .pack(),
+        )
+        .build();
+
+        let exec_caller_script = Script::new_builder().hash_type(ScriptHashType::Data.into())
+            .code_hash(CellOutput::calc_data_hash(&exec_caller_cell_data))
+            .build();
+        let output = CellOutputBuilder::default()
+            .capacity(capacity_bytes!(100).pack())
+            .lock(exec_caller_script.clone())
+            .build();
+        let input = CellInput::new(OutPoint::null(), 0);
+
+        let transaction = TransactionBuilder::default().input(input).build();
+
+        let dummy_cell = CellMetaBuilder::from_cell_output(output, Bytes::new())
+            .transaction_info(default_transaction_info())
+            .build();
+        let exec_caller_cell = CellMetaBuilder::from_cell_output(
+            exec_caller_cell.clone(),
+            exec_caller_cell_data.to_owned(),
+        )
+        .transaction_info(default_transaction_info())
+        .build();
+
+        let exec_callee_cell = CellMetaBuilder::from_cell_output(
+            exec_callee_cell.clone(),
+            exec_callee_cell_data.to_owned(),
+        )
+        .transaction_info(default_transaction_info())
+        .build();
+
+        let rtx = ResolvedTransaction {
+            transaction,
+            resolved_cell_deps: vec![exec_caller_cell, exec_callee_cell],
+            resolved_inputs: vec![dummy_cell],
+            resolved_dep_groups: vec![],
+        };
+
+        let store = new_store();
+        let data_loader = DataLoaderWrapper::new(&store);
+
+        let verifier = TransactionScriptsVerifier::new(&rtx, &data_loader);
+        println!("{:?}", verifier.verify(600000));
+        assert!(verifier.verify(600000).is_ok());
+    }
+
 }
diff --git a/script/testdata/current_cycles b/script/testdata/current_cycles
new file mode 100755
index 0000000000000000000000000000000000000000..dc53642971e1cba3a675e224fcef5cbf90a68082
GIT binary patch
literal 6400
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

literal 0
HcmV?d00001

diff --git a/script/testdata/current_cycles.c b/script/testdata/current_cycles.c
new file mode 100644
index 0000000000..d7e9dcf046
--- /dev/null
+++ b/script/testdata/current_cycles.c
@@ -0,0 +1,23 @@
+static inline long __internal_syscall(long n, long _a0, long _a1, long _a2,
+                                      long _a3, long _a4, long _a5) {
+  register long a0 asm("a0") = _a0;
+  register long a1 asm("a1") = _a1;
+  register long a2 asm("a2") = _a2;
+  register long a3 asm("a3") = _a3;
+  register long a4 asm("a4") = _a4;
+  register long a5 asm("a5") = _a5;
+  register long syscall_id asm("a7") = n;
+
+  asm volatile("scall"
+               : "+r"(a0)
+               : "r"(a1), "r"(a2), "r"(a3), "r"(a4), "r"(a5), "r"(syscall_id));
+  return a0;
+}
+
+#define syscall(n, a, b, c, d, e, f)                                           \
+  __internal_syscall(n, (long)(a), (long)(b), (long)(c), (long)(d), (long)(e), \
+                     (long)(f))
+
+int main() {
+    return syscall(2042, 0, 0, 0, 0, 0, 0);
+}
diff --git a/script/testdata/exec_callee b/script/testdata/exec_callee
new file mode 100755
index 0000000000000000000000000000000000000000..5d08c24b6a57431c87e7bf94f11f364cd98b13b6
GIT binary patch
literal 6352
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

literal 0
HcmV?d00001

diff --git a/script/testdata/exec_callee.c b/script/testdata/exec_callee.c
new file mode 100644
index 0000000000..ed7ffb2ff9
--- /dev/null
+++ b/script/testdata/exec_callee.c
@@ -0,0 +1,21 @@
+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;
+
+    // int sum = 0;
+    // for (int i = 0; i < argc; i++) {
+    //   sum += strlen(argv[i]);
+    // }
+    // return sum;
+}
diff --git a/script/testdata/exec_caller b/script/testdata/exec_caller
new file mode 100755
index 0000000000000000000000000000000000000000..e4dc62a15e8fbe0061e9369b6211b3639eabc0c7
GIT binary patch
literal 6552
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
DK3-Xk

literal 0
HcmV?d00001

diff --git a/script/testdata/exec_caller.c b/script/testdata/exec_caller.c
new file mode 100644
index 0000000000..d8ae048abe
--- /dev/null
+++ b/script/testdata/exec_caller.c
@@ -0,0 +1,28 @@
+static inline long __internal_syscall(long n, long _a0, long _a1, long _a2,
+                                      long _a3, long _a4, long _a5) {
+  register long a0 asm("a0") = _a0;
+  register long a1 asm("a1") = _a1;
+  register long a2 asm("a2") = _a2;
+  register long a3 asm("a3") = _a3;
+  register long a4 asm("a4") = _a4;
+  register long a5 asm("a5") = _a5;
+  register long syscall_id asm("a7") = n;
+
+  asm volatile("scall"
+               : "+r"(a0)
+               : "r"(a1), "r"(a2), "r"(a3), "r"(a4), "r"(a5), "r"(syscall_id));
+  return a0;
+}
+
+#define syscall(n, a, b, c, d, e, f)                                           \
+  __internal_syscall(n, (long)(a), (long)(b), (long)(c), (long)(d), (long)(e), \
+                     (long)(f))
+
+int main() {
+    int argc = 3;
+    char *argv[] = {"a", "b", "c"};
+
+    syscall(2043, 1, 3, argc, argv, 0, 0);
+
+    return -1;
+}
diff --git a/script/testdata/vm_version b/script/testdata/vm_version
new file mode 100755
index 0000000000000000000000000000000000000000..3111cbe34bae68925e544e9cbb42cbd60aaa8919
GIT binary patch
literal 6400
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

literal 0
HcmV?d00001

diff --git a/script/testdata/vm_version.c b/script/testdata/vm_version.c
new file mode 100644
index 0000000000..b66b1e8e4f
--- /dev/null
+++ b/script/testdata/vm_version.c
@@ -0,0 +1,23 @@
+static inline long __internal_syscall(long n, long _a0, long _a1, long _a2,
+                                      long _a3, long _a4, long _a5) {
+  register long a0 asm("a0") = _a0;
+  register long a1 asm("a1") = _a1;
+  register long a2 asm("a2") = _a2;
+  register long a3 asm("a3") = _a3;
+  register long a4 asm("a4") = _a4;
+  register long a5 asm("a5") = _a5;
+  register long syscall_id asm("a7") = n;
+
+  asm volatile("scall"
+               : "+r"(a0)
+               : "r"(a1), "r"(a2), "r"(a3), "r"(a4), "r"(a5), "r"(syscall_id));
+  return a0;
+}
+
+#define syscall(n, a, b, c, d, e, f)                                           \
+  __internal_syscall(n, (long)(a), (long)(b), (long)(c), (long)(d), (long)(e), \
+                     (long)(f))
+
+int main() {
+    return syscall(2041, 0, 0, 0, 0, 0, 0);
+}

From 0108a6a2d20837dec5e0167efa5f513c9f35f388 Mon Sep 17 00:00:00 2001
From: mohanson <mohanson@outlook.com>
Date: Wed, 26 May 2021 21:29:11 +0800
Subject: [PATCH 03/14] redesign exec

---
 script/src/cost_model.rs                      |   1 +
 script/src/syscalls/exec.rs                   |  67 ++++++++---
 script/src/syscalls/mod.rs                    |   3 +-
 script/src/verify.rs                          | 107 ++++++++++++++----
 script/testdata/exec_callee.c                 |   6 -
 ...exec_caller => exec_caller_from_cell_data} | Bin 6552 -> 6552 bytes
 ..._caller.c => exec_caller_from_cell_data.c} |   4 +-
 script/testdata/exec_caller_from_witness      | Bin 0 -> 6560 bytes
 script/testdata/exec_caller_from_witness.c    |  26 +++++
 9 files changed, 165 insertions(+), 49 deletions(-)
 rename script/testdata/{exec_caller => exec_caller_from_cell_data} (76%)
 rename script/testdata/{exec_caller.c => exec_caller_from_cell_data.c} (94%)
 create mode 100755 script/testdata/exec_caller_from_witness
 create mode 100644 script/testdata/exec_caller_from_witness.c

diff --git a/script/src/cost_model.rs b/script/src/cost_model.rs
index dce2c33adc..6607496d29 100644
--- a/script/src/cost_model.rs
+++ b/script/src/cost_model.rs
@@ -98,6 +98,7 @@ pub fn instruction_cycles(i: Instruction) -> u64 {
         // MOP
         insts::OP_WIDE_MUL => 5,
         insts::OP_WIDE_MULU => 5,
+        insts::OP_WIDE_MULSU => 5,
         insts::OP_WIDE_DIV => 32,
         insts::OP_WIDE_DIVU => 32,
         insts::OP_FAR_JUMP_REL => 3,
diff --git a/script/src/syscalls/exec.rs b/script/src/syscalls/exec.rs
index e682348434..55cce65662 100644
--- a/script/src/syscalls/exec.rs
+++ b/script/src/syscalls/exec.rs
@@ -2,9 +2,10 @@ use crate::cost_model::transferred_byte_cycles;
 use crate::syscalls::{Source, SourceEntry, EXEC, INDEX_OUT_OF_BOUND, WRONG_FORMAT};
 use ckb_traits::CellDataProvider;
 use ckb_types::core::cell::CellMeta;
+use ckb_types::packed::{Bytes as PackedBytes, BytesVec};
 use ckb_vm::Memory;
 use ckb_vm::{
-    registers::{A0, A1, A2, A3, A7},
+    registers::{A0, A1, A2, A3, A4, A5, A7},
     Bytes, Error as VMError, Register, SupportMachine, Syscalls,
 };
 use ckb_vm::{DEFAULT_STACK_SIZE, RISCV_MAX_MEMORY};
@@ -17,6 +18,7 @@ pub struct Exec<'a, DL> {
     resolved_cell_deps: &'a [CellMeta],
     group_inputs: &'a [usize],
     group_outputs: &'a [usize],
+    witnesses: BytesVec,
 }
 
 impl<'a, DL: CellDataProvider + 'a> Exec<'a, DL> {
@@ -27,6 +29,7 @@ impl<'a, DL: CellDataProvider + 'a> Exec<'a, DL> {
         resolved_cell_deps: &'a [CellMeta],
         group_inputs: &'a [usize],
         group_outputs: &'a [usize],
+        witnesses: BytesVec,
     ) -> Exec<'a, DL> {
         Exec {
             data_loader,
@@ -35,6 +38,7 @@ impl<'a, DL: CellDataProvider + 'a> Exec<'a, DL> {
             resolved_cell_deps,
             group_inputs,
             group_outputs,
+            witnesses,
         }
     }
 
@@ -68,6 +72,22 @@ impl<'a, DL: CellDataProvider + 'a> Exec<'a, DL> {
             Source::Group(SourceEntry::HeaderDep) => Err(INDEX_OUT_OF_BOUND),
         }
     }
+
+    fn fetch_witness(&self, source: Source, index: usize) -> Option<PackedBytes> {
+        match source {
+            Source::Group(SourceEntry::Input) => self
+                .group_inputs
+                .get(index)
+                .and_then(|actual_index| self.witnesses.get(*actual_index)),
+            Source::Group(SourceEntry::Output) => self
+                .group_outputs
+                .get(index)
+                .and_then(|actual_index| self.witnesses.get(*actual_index)),
+            Source::Transaction(SourceEntry::Input) => self.witnesses.get(index),
+            Source::Transaction(SourceEntry::Output) => self.witnesses.get(index),
+            _ => None,
+        }
+    }
 }
 
 fn load_c_string<Mac: SupportMachine>(machine: &mut Mac, addr: u64) -> Result<Bytes, VMError> {
@@ -101,19 +121,40 @@ impl<'a, Mac: SupportMachine, DL: CellDataProvider> Syscalls<Mac> for Exec<'a, D
 
         let index = machine.registers()[A0].to_u64();
         let source = Source::parse_from_u64(machine.registers()[A1].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(false);
-        }
-        let cell = cell.unwrap();
-        let data = self
-            .data_loader
-            .load_cell_data(cell)
-            .ok_or(VMError::Unexpected)?;
+        let place = machine.registers()[A2].to_u64();
+        let bounds = machine.registers()[A3].to_u64();
+        let offset = bounds as usize >> 32;
+        let length = bounds as u32 as usize;
 
-        let argc = machine.registers()[A2].to_u64();
-        let mut addr = machine.registers()[A3].to_u64();
+        let data = if place == 0 {
+            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(false);
+            }
+            let cell = cell.unwrap();
+            let data = self
+                .data_loader
+                .load_cell_data(cell)
+                .ok_or(VMError::Unexpected)?;
+            data
+        } else {
+            let witness = self.fetch_witness(source, index as usize);
+            if witness.is_none() {
+                machine.set_register(A0, Mac::REG::from_u8(INDEX_OUT_OF_BOUND));
+                return Ok(true);
+            }
+            let witness = witness.unwrap();
+            let data = witness.raw_data();
+            data
+        };
+        let data = if length == 0 {
+            data.slice(offset..data.len())
+        } else {
+            data.slice(offset..offset + length)
+        };
+        let argc = machine.registers()[A4].to_u64();
+        let mut addr = machine.registers()[A5].to_u64();
         let mut argv = Vec::new();
         for _ in 0..argc {
             let target_addr = machine
diff --git a/script/src/syscalls/mod.rs b/script/src/syscalls/mod.rs
index 92fd900f32..f4020d0f61 100644
--- a/script/src/syscalls/mod.rs
+++ b/script/src/syscalls/mod.rs
@@ -201,7 +201,7 @@ mod tests {
         prelude::*,
         H256,
     };
-    use ckb_vm::{SupportMachine, machine::DefaultCoreMachine};
+    use ckb_vm::{machine::DefaultCoreMachine, SupportMachine};
     use ckb_vm::{
         machine::{VERSION0, VERSION1},
         memory::{FLAG_DIRTY, FLAG_EXECUTABLE, FLAG_FREEZED, FLAG_WRITABLE},
@@ -1538,5 +1538,4 @@ mod tests {
         assert_eq!(result.unwrap(), true);
         assert_eq!(machine.registers()[A0], 100);
     }
-
 }
diff --git a/script/src/verify.rs b/script/src/verify.rs
index 26f6800453..8970f626fe 100644
--- a/script/src/verify.rs
+++ b/script/src/verify.rs
@@ -216,6 +216,7 @@ impl<'a, DL: CellDataProvider + HeaderProvider> TransactionScriptsVerifier<'a, D
             self.resolved_cell_deps(),
             group_inputs,
             group_outputs,
+            self.witnesses(),
         )
     }
 
@@ -1822,15 +1823,15 @@ mod tests {
 
     #[test]
     fn check_vm_version() {
-        let vm_version_cell_data = Bytes::from(std::fs::read(Path::new(env!("CARGO_MANIFEST_DIR")).join("testdata/vm_version")).unwrap());
+        let vm_version_cell_data = Bytes::from(
+            std::fs::read(Path::new(env!("CARGO_MANIFEST_DIR")).join("testdata/vm_version"))
+                .unwrap(),
+        );
         let vm_version_cell = CellOutput::new_builder()
-        .capacity(
-            Capacity::bytes(vm_version_cell_data.len())
-                .unwrap()
-                .pack(),
-        )
-        .build();
-        let vm_version_script = Script::new_builder().hash_type(ScriptHashType::Data.into())
+            .capacity(Capacity::bytes(vm_version_cell_data.len()).unwrap().pack())
+            .build();
+        let vm_version_script = Script::new_builder()
+            .hash_type(ScriptHashType::Data.into())
             .code_hash(CellOutput::calc_data_hash(&vm_version_cell_data))
             .build();
         let output = CellOutputBuilder::default()
@@ -1866,26 +1867,27 @@ mod tests {
     }
 
     #[test]
-    fn check_exec() {
-        let exec_caller_cell_data = Bytes::from(std::fs::read(Path::new(env!("CARGO_MANIFEST_DIR")).join("testdata/exec_caller")).unwrap());
+    fn check_exec_from_cell_data() {
+        let exec_caller_cell_data = Bytes::from(
+            std::fs::read(
+                Path::new(env!("CARGO_MANIFEST_DIR")).join("testdata/exec_caller_from_cell_data"),
+            )
+            .unwrap(),
+        );
         let exec_caller_cell = CellOutput::new_builder()
-        .capacity(
-            Capacity::bytes(exec_caller_cell_data.len())
-                .unwrap()
-                .pack(),
-        )
-        .build();
+            .capacity(Capacity::bytes(exec_caller_cell_data.len()).unwrap().pack())
+            .build();
 
-        let exec_callee_cell_data = Bytes::from(std::fs::read(Path::new(env!("CARGO_MANIFEST_DIR")).join("testdata/exec_callee")).unwrap());
+        let exec_callee_cell_data = Bytes::from(
+            std::fs::read(Path::new(env!("CARGO_MANIFEST_DIR")).join("testdata/exec_callee"))
+                .unwrap(),
+        );
         let exec_callee_cell = CellOutput::new_builder()
-        .capacity(
-            Capacity::bytes(exec_callee_cell_data.len())
-                .unwrap()
-                .pack(),
-        )
-        .build();
+            .capacity(Capacity::bytes(exec_callee_cell_data.len()).unwrap().pack())
+            .build();
 
-        let exec_caller_script = Script::new_builder().hash_type(ScriptHashType::Data.into())
+        let exec_caller_script = Script::new_builder()
+            .hash_type(ScriptHashType::Data.into())
             .code_hash(CellOutput::calc_data_hash(&exec_caller_cell_data))
             .build();
         let output = CellOutputBuilder::default()
@@ -1924,8 +1926,63 @@ mod tests {
         let data_loader = DataLoaderWrapper::new(&store);
 
         let verifier = TransactionScriptsVerifier::new(&rtx, &data_loader);
-        println!("{:?}", verifier.verify(600000));
         assert!(verifier.verify(600000).is_ok());
     }
 
+    #[test]
+    fn check_exec_from_witness() {
+        let exec_caller_cell_data = Bytes::from(
+            std::fs::read(
+                Path::new(env!("CARGO_MANIFEST_DIR")).join("testdata/exec_caller_from_witness"),
+            )
+            .unwrap(),
+        );
+        let exec_caller_cell = CellOutput::new_builder()
+            .capacity(Capacity::bytes(exec_caller_cell_data.len()).unwrap().pack())
+            .build();
+
+        let exec_callee = Bytes::from(
+            std::fs::read(Path::new(env!("CARGO_MANIFEST_DIR")).join("testdata/exec_callee"))
+                .unwrap(),
+        )
+        .pack();
+
+        let exec_caller_script = Script::new_builder()
+            .hash_type(ScriptHashType::Data.into())
+            .code_hash(CellOutput::calc_data_hash(&exec_caller_cell_data))
+            .build();
+        let output = CellOutputBuilder::default()
+            .capacity(capacity_bytes!(100).pack())
+            .lock(exec_caller_script.clone())
+            .build();
+        let input = CellInput::new(OutPoint::null(), 0);
+
+        let transaction = TransactionBuilder::default()
+            .input(input)
+            .set_witnesses(vec![exec_callee])
+            .build();
+
+        let dummy_cell = CellMetaBuilder::from_cell_output(output, Bytes::new())
+            .transaction_info(default_transaction_info())
+            .build();
+        let exec_caller_cell = CellMetaBuilder::from_cell_output(
+            exec_caller_cell.clone(),
+            exec_caller_cell_data.to_owned(),
+        )
+        .transaction_info(default_transaction_info())
+        .build();
+
+        let rtx = ResolvedTransaction {
+            transaction,
+            resolved_cell_deps: vec![exec_caller_cell],
+            resolved_inputs: vec![dummy_cell],
+            resolved_dep_groups: vec![],
+        };
+
+        let store = new_store();
+        let data_loader = DataLoaderWrapper::new(&store);
+
+        let verifier = TransactionScriptsVerifier::new(&rtx, &data_loader);
+        assert!(verifier.verify(600000).is_ok());
+    }
 }
diff --git a/script/testdata/exec_callee.c b/script/testdata/exec_callee.c
index ed7ffb2ff9..3a815b171c 100644
--- a/script/testdata/exec_callee.c
+++ b/script/testdata/exec_callee.c
@@ -12,10 +12,4 @@ int main(int argc, char* argv[]) {
     return 4;
   }
   return 0;
-
-    // int sum = 0;
-    // for (int i = 0; i < argc; i++) {
-    //   sum += strlen(argv[i]);
-    // }
-    // return sum;
 }
diff --git a/script/testdata/exec_caller b/script/testdata/exec_caller_from_cell_data
similarity index 76%
rename from script/testdata/exec_caller
rename to script/testdata/exec_caller_from_cell_data
index e4dc62a15e8fbe0061e9369b6211b3639eabc0c7..6320a6eb1d037cdfbb942408a4d1813a4961b0e2 100755
GIT binary patch
delta 232
zcmbPXJi~ax0e4oHd<F&UriST?3=ESS8BYqgGJX?oYy8RC*Xa75;efn2D+7ZttE;8t
zQ3xy5^gV-u#e0SZaVA$C21d8{3=jD884he_XH;R7P(Sidn4RUXRR^PcqZ_YVtE({U
zhWhs(>^D0yJ!RUg!TN)nQE9TGV7X)-6C(o%WPwQr1|B8`1|bGU28YQT1;rVgCZ814
zXKa}KQ_!99#$-n!dBGs4x^$?zlF5Za<&ptVQ{<qsEl}BSn;C`6nHeiKSBl9q0|0Cs
BI6wdZ

delta 233
zcmbPXJi~ax0r#iQ`3wx!O%2l(85kxvGM*G}W&9@G*7%dNuhI2A!vcA6Rt5%PR#i*M
zqY##>>3aqSi}wr(;!LhO42*8?86NQGGc4H5&ZxpDrgr3?Fgwd%Mvq2!Ubj|PVb%@x
z??1$Ec4m6Y#Kgd`S%dWlH>1L2MZt2(941Bv5Xb_P3=BL#c_9Wy2D`}{1;rT~CZ814
zXRMq2Q_!99+GIx|dBFgvx^$?zqRE9q<&u6-Q{<qsEl}Ann;C`6nHkGASBl9q0{~<S
BH;MoN

diff --git a/script/testdata/exec_caller.c b/script/testdata/exec_caller_from_cell_data.c
similarity index 94%
rename from script/testdata/exec_caller.c
rename to script/testdata/exec_caller_from_cell_data.c
index d8ae048abe..edefd815af 100644
--- a/script/testdata/exec_caller.c
+++ b/script/testdata/exec_caller_from_cell_data.c
@@ -21,8 +21,6 @@ static inline long __internal_syscall(long n, long _a0, long _a1, long _a2,
 int main() {
     int argc = 3;
     char *argv[] = {"a", "b", "c"};
-
-    syscall(2043, 1, 3, argc, argv, 0, 0);
-
+    syscall(2043, 1, 3, 0, 0, argc, argv);
     return -1;
 }
diff --git a/script/testdata/exec_caller_from_witness b/script/testdata/exec_caller_from_witness
new file mode 100755
index 0000000000000000000000000000000000000000..7c19b85b46133d4a1f55ffaeafed6c7b32bedb01
GIT binary patch
literal 6560
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
M9Y|Kja=QM10JR@p+yDRo

literal 0
HcmV?d00001

diff --git a/script/testdata/exec_caller_from_witness.c b/script/testdata/exec_caller_from_witness.c
new file mode 100644
index 0000000000..4a12a0da52
--- /dev/null
+++ b/script/testdata/exec_caller_from_witness.c
@@ -0,0 +1,26 @@
+static inline long __internal_syscall(long n, long _a0, long _a1, long _a2,
+                                      long _a3, long _a4, long _a5) {
+  register long a0 asm("a0") = _a0;
+  register long a1 asm("a1") = _a1;
+  register long a2 asm("a2") = _a2;
+  register long a3 asm("a3") = _a3;
+  register long a4 asm("a4") = _a4;
+  register long a5 asm("a5") = _a5;
+  register long syscall_id asm("a7") = n;
+
+  asm volatile("scall"
+               : "+r"(a0)
+               : "r"(a1), "r"(a2), "r"(a3), "r"(a4), "r"(a5), "r"(syscall_id));
+  return a0;
+}
+
+#define syscall(n, a, b, c, d, e, f)                                           \
+  __internal_syscall(n, (long)(a), (long)(b), (long)(c), (long)(d), (long)(e), \
+                     (long)(f))
+
+int main() {
+    int argc = 3;
+    char *argv[] = {"a", "b", "c"};
+    syscall(2043, 0, 1, 1, 0, argc, argv);
+    return -1;
+}

From ec59a90011b95c00cd989b377e6a4910de498d7e Mon Sep 17 00:00:00 2001
From: Boyu Yang <yangby@cryptape.com>
Date: Fri, 28 May 2021 02:45:26 +0800
Subject: [PATCH 04/14] chore: new vm and new syscalls: use crates.io; fix
 compilation, test and clippy

---
 Cargo.lock                  | 10 +++--
 script/Cargo.toml           |  4 +-
 script/src/syscalls/exec.rs | 11 ++---
 script/src/verify.rs        | 82 ++++++++++++++++++++-----------------
 4 files changed, 57 insertions(+), 50 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 81967092cb..c3ceaa9a7a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1492,8 +1492,9 @@ dependencies = [
 
 [[package]]
 name = "ckb-vm"
-version = "0.19.1"
-source = "git+https://github.com/mohanson/ckb-vm?branch=develop#09e1e21995acaea3f75d26e144e652b4c4ba67ea"
+version = "0.20.0-alpha"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca63668a4a96a895c5324edbc3f827781d043a79d82789d590f7d611ce9dff4a"
 dependencies = [
  "byteorder",
  "bytes 1.0.1",
@@ -1511,8 +1512,9 @@ dependencies = [
 
 [[package]]
 name = "ckb-vm-definitions"
-version = "0.19.1"
-source = "git+https://github.com/mohanson/ckb-vm?branch=develop#09e1e21995acaea3f75d26e144e652b4c4ba67ea"
+version = "0.20.0-alpha"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1983bc408f08c00d8907e602f24bb54caf7b9aadbdbb20624d24a2a2fc6e3efb"
 
 [[package]]
 name = "clap"
diff --git a/script/Cargo.toml b/script/Cargo.toml
index 6f788993f0..57941c1632 100644
--- a/script/Cargo.toml
+++ b/script/Cargo.toml
@@ -21,8 +21,8 @@ ckb-traits = { path = "../traits", version = "= 0.43.0-pre" }
 byteorder = "1.3.1"
 ckb-types = {path = "../util/types", version = "= 0.43.0-pre"}
 ckb-hash = {path = "../util/hash", version = "= 0.43.0-pre"}
-ckb-vm-definitions = { git = "https://github.com/mohanson/ckb-vm", branch="develop" }
-ckb-vm = { git = "https://github.com/mohanson/ckb-vm", branch="develop", default-features = false }
+ckb-vm-definitions = "0.20.0-alpha"
+ckb-vm = { version = "0.20.0-alpha", default-features = false }
 faster-hex = "0.4"
 ckb-logger = { path = "../util/logger", version = "= 0.43.0-pre", optional = true }
 serde = { version = "1.0", features = ["derive"] }
diff --git a/script/src/syscalls/exec.rs b/script/src/syscalls/exec.rs
index 55cce65662..88d9aa7a34 100644
--- a/script/src/syscalls/exec.rs
+++ b/script/src/syscalls/exec.rs
@@ -123,7 +123,7 @@ impl<'a, Mac: SupportMachine, DL: CellDataProvider> Syscalls<Mac> for Exec<'a, D
         let source = Source::parse_from_u64(machine.registers()[A1].to_u64())?;
         let place = machine.registers()[A2].to_u64();
         let bounds = machine.registers()[A3].to_u64();
-        let offset = bounds as usize >> 32;
+        let offset = (bounds >> 32) as usize;
         let length = bounds as u32 as usize;
 
         let data = if place == 0 {
@@ -133,11 +133,9 @@ impl<'a, Mac: SupportMachine, DL: CellDataProvider> Syscalls<Mac> for Exec<'a, D
                 return Ok(false);
             }
             let cell = cell.unwrap();
-            let data = self
-                .data_loader
+            self.data_loader
                 .load_cell_data(cell)
-                .ok_or(VMError::Unexpected)?;
-            data
+                .ok_or(VMError::Unexpected)?
         } else {
             let witness = self.fetch_witness(source, index as usize);
             if witness.is_none() {
@@ -145,8 +143,7 @@ impl<'a, Mac: SupportMachine, DL: CellDataProvider> Syscalls<Mac> for Exec<'a, D
                 return Ok(true);
             }
             let witness = witness.unwrap();
-            let data = witness.raw_data();
-            data
+            witness.raw_data()
         };
         let data = if length == 0 {
             data.slice(offset..data.len())
diff --git a/script/src/verify.rs b/script/src/verify.rs
index fb20a6913b..f3a60d0fc3 100644
--- a/script/src/verify.rs
+++ b/script/src/verify.rs
@@ -23,6 +23,12 @@ use ckb_types::{
     packed::{Byte32, Byte32Vec, BytesVec, CellInputVec, CellOutput, OutPoint, Script},
     prelude::*,
 };
+#[cfg(not(has_asm))]
+use ckb_vm::{
+    machine::VERSION0, DefaultCoreMachine, DefaultMachineBuilder, Error as VMInternalError,
+    InstructionCycleFunc, SparseMemory, SupportMachine, Syscalls, TraceMachine, WXorXMemory, ISA_B,
+    ISA_IMC,
+};
 #[cfg(has_asm)]
 use ckb_vm::{
     machine::{
@@ -32,18 +38,13 @@ use ckb_vm::{
     DefaultMachineBuilder, Error as VMInternalError, InstructionCycleFunc, SupportMachine,
     Syscalls, ISA_B, ISA_IMC,
 };
-#[cfg(not(has_asm))]
-use ckb_vm::{
-    DefaultCoreMachine, DefaultMachineBuilder, Error as VMInternalError, InstructionCycleFunc,
-    SparseMemory, SupportMachine, Syscalls, TraceMachine, WXorXMemory,
-};
 use std::collections::HashMap;
 use std::convert::TryFrom;
 
 #[cfg(has_asm)]
 type CoreMachineType = Box<AsmCoreMachine>;
 #[cfg(not(has_asm))]
-type CoreMachineType = DefaultCoreMachine<u64, WXorXMemory<u64, SparseMemory<u64>>>;
+type CoreMachineType = DefaultCoreMachine<u64, WXorXMemory<SparseMemory<u64>>>;
 
 enum Binaries {
     Unique((Byte32, Bytes)),
@@ -491,7 +492,7 @@ impl<'a, DL: CellDataProvider + HeaderProvider> TransactionScriptsVerifier<'a, D
         #[cfg(has_asm)]
         let core_machine = AsmCoreMachine::new(ISA_IMC | ISA_B, VERSION0, max_cycles);
         #[cfg(not(has_asm))]
-        let core_machine = DefaultCoreMachine::<u64, WXorXMemory<u64, SparseMemory<u64>>>::new(
+        let core_machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
             ISA_IMC | ISA_B,
             VERSION0,
             max_cycles,
@@ -1984,7 +1985,7 @@ mod tests {
             .build();
         let output = CellOutputBuilder::default()
             .capacity(capacity_bytes!(100).pack())
-            .lock(vm_version_script.clone())
+            .lock(vm_version_script)
             .build();
         let input = CellInput::new(OutPoint::null(), 0);
 
@@ -1993,12 +1994,10 @@ mod tests {
         let dummy_cell = CellMetaBuilder::from_cell_output(output, Bytes::new())
             .transaction_info(default_transaction_info())
             .build();
-        let vm_version_cell = CellMetaBuilder::from_cell_output(
-            vm_version_cell.clone(),
-            vm_version_cell_data.to_owned(),
-        )
-        .transaction_info(default_transaction_info())
-        .build();
+        let vm_version_cell =
+            CellMetaBuilder::from_cell_output(vm_version_cell, vm_version_cell_data)
+                .transaction_info(default_transaction_info())
+                .build();
 
         let rtx = ResolvedTransaction {
             transaction,
@@ -2009,8 +2008,13 @@ mod tests {
 
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
+        let consensus = ConsensusBuilder::default().build();
+        let tx_env = {
+            let header = HeaderView::new_advanced_builder().build();
+            TxVerifyEnv::new_commit(&header)
+        };
 
-        let verifier = TransactionScriptsVerifier::new(&rtx, &data_loader);
+        let verifier = TransactionScriptsVerifier::new(&rtx, &consensus, &data_loader, &tx_env);
         assert!(verifier.verify(6000).is_ok());
     }
 
@@ -2040,7 +2044,7 @@ mod tests {
             .build();
         let output = CellOutputBuilder::default()
             .capacity(capacity_bytes!(100).pack())
-            .lock(exec_caller_script.clone())
+            .lock(exec_caller_script)
             .build();
         let input = CellInput::new(OutPoint::null(), 0);
 
@@ -2049,19 +2053,15 @@ mod tests {
         let dummy_cell = CellMetaBuilder::from_cell_output(output, Bytes::new())
             .transaction_info(default_transaction_info())
             .build();
-        let exec_caller_cell = CellMetaBuilder::from_cell_output(
-            exec_caller_cell.clone(),
-            exec_caller_cell_data.to_owned(),
-        )
-        .transaction_info(default_transaction_info())
-        .build();
+        let exec_caller_cell =
+            CellMetaBuilder::from_cell_output(exec_caller_cell, exec_caller_cell_data)
+                .transaction_info(default_transaction_info())
+                .build();
 
-        let exec_callee_cell = CellMetaBuilder::from_cell_output(
-            exec_callee_cell.clone(),
-            exec_callee_cell_data.to_owned(),
-        )
-        .transaction_info(default_transaction_info())
-        .build();
+        let exec_callee_cell =
+            CellMetaBuilder::from_cell_output(exec_callee_cell, exec_callee_cell_data)
+                .transaction_info(default_transaction_info())
+                .build();
 
         let rtx = ResolvedTransaction {
             transaction,
@@ -2072,8 +2072,13 @@ mod tests {
 
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
+        let consensus = ConsensusBuilder::default().build();
+        let tx_env = {
+            let header = HeaderView::new_advanced_builder().build();
+            TxVerifyEnv::new_commit(&header)
+        };
 
-        let verifier = TransactionScriptsVerifier::new(&rtx, &data_loader);
+        let verifier = TransactionScriptsVerifier::new(&rtx, &consensus, &data_loader, &tx_env);
         assert!(verifier.verify(600000).is_ok());
     }
 
@@ -2101,7 +2106,7 @@ mod tests {
             .build();
         let output = CellOutputBuilder::default()
             .capacity(capacity_bytes!(100).pack())
-            .lock(exec_caller_script.clone())
+            .lock(exec_caller_script)
             .build();
         let input = CellInput::new(OutPoint::null(), 0);
 
@@ -2113,12 +2118,10 @@ mod tests {
         let dummy_cell = CellMetaBuilder::from_cell_output(output, Bytes::new())
             .transaction_info(default_transaction_info())
             .build();
-        let exec_caller_cell = CellMetaBuilder::from_cell_output(
-            exec_caller_cell.clone(),
-            exec_caller_cell_data.to_owned(),
-        )
-        .transaction_info(default_transaction_info())
-        .build();
+        let exec_caller_cell =
+            CellMetaBuilder::from_cell_output(exec_caller_cell, exec_caller_cell_data)
+                .transaction_info(default_transaction_info())
+                .build();
 
         let rtx = ResolvedTransaction {
             transaction,
@@ -2129,8 +2132,13 @@ mod tests {
 
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
+        let consensus = ConsensusBuilder::default().build();
+        let tx_env = {
+            let header = HeaderView::new_advanced_builder().build();
+            TxVerifyEnv::new_commit(&header)
+        };
 
-        let verifier = TransactionScriptsVerifier::new(&rtx, &data_loader);
+        let verifier = TransactionScriptsVerifier::new(&rtx, &consensus, &data_loader, &tx_env);
         assert!(verifier.verify(600000).is_ok());
     }
 }

From fa40d1cb6cc535ff75cf2cca3553548fb608ca3b Mon Sep 17 00:00:00 2001
From: Boyu Yang <yangby@cryptape.com>
Date: Tue, 15 Jun 2021 15:17:31 +0800
Subject: [PATCH 05/14] feat(hardfork): vm version selection, vm version 1 and
 syscalls 2

---
 benches/benches/benchmarks/util.rs            |   2 +-
 chain/src/tests/block_assembler.rs            |   4 +-
 chain/src/tests/reward.rs                     |   4 +-
 chain/src/tests/util.rs                       |   4 +-
 devtools/doc/rpc.py                           |   3 +-
 rpc/src/module/pool.rs                        |  18 +-
 script/src/error.rs                           |   8 +
 script/src/ill_transaction_checker.rs         |  32 ++-
 script/src/syscalls/mod.rs                    |   4 +-
 script/src/verify.rs                          | 243 +++++++++++++-----
 script/testdata/vm_version                    | Bin 6400 -> 6408 bytes
 script/testdata/vm_version.c                  |   5 +-
 spec/src/hardfork.rs                          |   6 +-
 spec/src/lib.rs                               |   4 +-
 test/src/main.rs                              |   4 +-
 test/src/node.rs                              |   2 +-
 test/src/specs/hardfork/v2021/cell_deps.rs    |   2 +-
 test/src/specs/mining/bootstrap.rs            |   4 +-
 test/src/specs/tx_pool/mod.rs                 |   2 +-
 .../specs/tx_pool/send_multisig_secp_tx.rs    |   2 +-
 test/template/specs/integration.toml          |   1 +
 util/app-config/src/configs/tx_pool.rs        |  58 ++++-
 util/jsonrpc-types/src/blockchain.rs          | 176 ++++++++++++-
 util/jsonrpc-types/src/lib.rs                 |   8 +-
 util/jsonrpc-types/src/primitive.rs           |   8 +-
 util/jsonrpc-types/src/uints.rs               |  11 +-
 util/test-chain-utils/src/chain.rs            |   6 +-
 util/types/src/core/blockchain.rs             |  17 +-
 util/types/src/core/hardfork.rs               |  16 ++
 util/types/src/extension/check_data.rs        |   4 +-
 30 files changed, 528 insertions(+), 130 deletions(-)
 mode change 100755 => 100644 script/testdata/vm_version

diff --git a/benches/benches/benchmarks/util.rs b/benches/benches/benchmarks/util.rs
index d99f76f20a..1f050f0b67 100644
--- a/benches/benches/benchmarks/util.rs
+++ b/benches/benches/benchmarks/util.rs
@@ -225,7 +225,7 @@ lazy_static! {
         let script = Script::new_builder()
             .code_hash(CellOutput::calc_data_hash(&data))
             .args(Bytes::from(PUBKEY_HASH.as_bytes()).pack())
-            .hash_type(ScriptHashType::Data.into())
+            .hash_type(ScriptHashType::Data(0).into())
             .build();
 
         (cell, data, script)
diff --git a/chain/src/tests/block_assembler.rs b/chain/src/tests/block_assembler.rs
index 6117bfc5fd..97a5f690c2 100644
--- a/chain/src/tests/block_assembler.rs
+++ b/chain/src/tests/block_assembler.rs
@@ -33,7 +33,9 @@ fn start_chain(consensus: Option<Consensus>) -> (ChainController, Shared) {
     let config = BlockAssemblerConfig {
         code_hash: h256!("0x0"),
         args: Default::default(),
-        hash_type: ScriptHashType::Data,
+        hash_type: ScriptHashType::Data {
+            vm_version: 0.into(),
+        },
         message: Default::default(),
     };
     let (shared, mut pack) = builder
diff --git a/chain/src/tests/reward.rs b/chain/src/tests/reward.rs
index 89318cff80..a41667243d 100644
--- a/chain/src/tests/reward.rs
+++ b/chain/src/tests/reward.rs
@@ -179,14 +179,14 @@ fn finalize_reward() {
     let bob = ScriptBuilder::default()
         .args(bob_args)
         .code_hash(always_success_script.code_hash())
-        .hash_type(ScriptHashType::Data.into())
+        .hash_type(ScriptHashType::Data(0).into())
         .build();
 
     let alice_args: packed::Bytes = Bytes::from(b"a11ce".to_vec()).pack();
     let alice = ScriptBuilder::default()
         .args(alice_args)
         .code_hash(always_success_script.code_hash())
-        .hash_type(ScriptHashType::Data.into())
+        .hash_type(ScriptHashType::Data(0).into())
         .build();
 
     for i in 1..23 {
diff --git a/chain/src/tests/util.rs b/chain/src/tests/util.rs
index f3acf25321..b48494854e 100644
--- a/chain/src/tests/util.rs
+++ b/chain/src/tests/util.rs
@@ -115,7 +115,9 @@ pub(crate) fn start_chain(consensus: Option<Consensus>) -> (ChainController, Sha
     let config = BlockAssemblerConfig {
         code_hash: h256!("0x0"),
         args: Default::default(),
-        hash_type: ScriptHashType::Data,
+        hash_type: ScriptHashType::Data {
+            vm_version: 0.into(),
+        },
         message: Default::default(),
     };
 
diff --git a/devtools/doc/rpc.py b/devtools/doc/rpc.py
index 9ce9ab8000..72dcd1e513 100755
--- a/devtools/doc/rpc.py
+++ b/devtools/doc/rpc.py
@@ -500,7 +500,8 @@ def handle_endtag(self, tag):
         if self.variant_parser is not None:
             self.variant_parser.handle_endtag(tag)
             if self.variant_parser.completed():
-                self.variants.append((self.next_variant, self.variant_parser))
+                if self.next_variant not in [v[0] for v in self.variants]:
+                    self.variants.append((self.next_variant, self.variant_parser))
                 self.next_variant = None
                 self.variant_parser = None
 
diff --git a/rpc/src/module/pool.rs b/rpc/src/module/pool.rs
index dcb58201ef..563bfc1c51 100644
--- a/rpc/src/module/pool.rs
+++ b/rpc/src/module/pool.rs
@@ -3,9 +3,9 @@ use ckb_chain_spec::consensus::Consensus;
 use ckb_jsonrpc_types::{OutputsValidator, RawTxPool, Transaction, TxPoolInfo};
 use ckb_logger::error;
 use ckb_script::IllTransactionChecker;
-use ckb_shared::shared::Shared;
+use ckb_shared::{shared::Shared, Snapshot};
 use ckb_types::{core, packed, prelude::*, H256};
-use ckb_verification::{Since, SinceMetric};
+use ckb_verification::{Since, SinceMetric, TxVerifyEnv};
 use jsonrpc_core::Result;
 use jsonrpc_derive::rpc;
 use std::convert::TryInto;
@@ -258,7 +258,13 @@ impl PoolRpc for PoolRpcImpl {
         }
 
         if self.reject_ill_transactions {
-            if let Err(e) = IllTransactionChecker::new(&tx).check() {
+            let snapshot: &Snapshot = &self.shared.snapshot();
+            let consensus = snapshot.consensus();
+            let tx_env = {
+                let tip_header = snapshot.tip_header();
+                TxVerifyEnv::new_submit(&tip_header)
+            };
+            if let Err(e) = IllTransactionChecker::new(&tx, consensus, &tx_env).check() {
                 return Err(RPCError::custom_with_data(
                     RPCError::PoolRejectedTransactionByIllTransactionChecker,
                     "The transaction is rejected by IllTransactionChecker",
@@ -496,7 +502,7 @@ mod tests {
             assert!(validator.validate(&tx).is_err());
 
             // invalid hash type
-            let tx = build_tx(&type_hash, core::ScriptHashType::Data, vec![1; 20]);
+            let tx = build_tx(&type_hash, core::ScriptHashType::Data(0), vec![1; 20]);
             assert!(validator.validate(&tx).is_err());
 
             // invalid code hash
@@ -528,7 +534,7 @@ mod tests {
             assert!(validator.validate(&tx).is_err());
 
             // invalid hash type
-            let tx = build_tx(&type_hash, core::ScriptHashType::Data, vec![1; 20]);
+            let tx = build_tx(&type_hash, core::ScriptHashType::Data(0), vec![1; 20]);
             assert!(validator.validate(&tx).is_err());
 
             // invalid since args format
@@ -583,7 +589,7 @@ mod tests {
                 core::ScriptHashType::Type,
                 vec![1; 20],
                 &type_type_hash,
-                core::ScriptHashType::Data,
+                core::ScriptHashType::Data(0),
             );
             assert!(validator.validate(&tx).is_err());
 
diff --git a/script/src/error.rs b/script/src/error.rs
index f965cb24f5..8c512a77c9 100644
--- a/script/src/error.rs
+++ b/script/src/error.rs
@@ -26,6 +26,14 @@ pub enum ScriptError {
     #[error("Known bugs encountered in output {1}: {0}")]
     EncounteredKnownBugs(String, usize),
 
+    /// InvalidScriptHashType
+    #[error("InvalidScriptHashType: {0}")]
+    InvalidScriptHashType(String),
+
+    /// InvalidVmVersion
+    #[error("Invalid vm version {0}")]
+    InvalidVmVersion(u8),
+
     /// Known bugs are detected in transaction script outputs
     #[error("VM Internal Error: {0}")]
     VMInternalError(String),
diff --git a/script/src/ill_transaction_checker.rs b/script/src/ill_transaction_checker.rs
index b5e0916c7e..2dc8a5d742 100644
--- a/script/src/ill_transaction_checker.rs
+++ b/script/src/ill_transaction_checker.rs
@@ -1,8 +1,9 @@
-use crate::ScriptError;
+use crate::{verify_env::TxVerifyEnv, ScriptError};
 use byteorder::{ByteOrder, LittleEndian};
+use ckb_chain_spec::consensus::Consensus;
 use ckb_types::core::TransactionView;
 use ckb_vm::{
-    instructions::{b, extract_opcode, i, m, rvc, Instruction, Itype},
+    instructions::{extract_opcode, i, m, rvc, Instruction, Itype},
     registers::ZERO,
 };
 use ckb_vm_definitions::instructions as insts;
@@ -13,18 +14,30 @@ const CKB_VM_ISSUE_92: &str = "https://github.com/nervosnetwork/ckb-vm/issues/92
 /// Ill formed transactions checker.
 pub struct IllTransactionChecker<'a> {
     tx: &'a TransactionView,
+    consensus: &'a Consensus,
+    tx_env: &'a TxVerifyEnv,
 }
 
 impl<'a> IllTransactionChecker<'a> {
     /// Creates the checker for a transaction.
-    pub fn new(tx: &'a TransactionView) -> Self {
-        IllTransactionChecker { tx }
+    pub fn new(tx: &'a TransactionView, consensus: &'a Consensus, tx_env: &'a TxVerifyEnv) -> Self {
+        IllTransactionChecker {
+            tx,
+            consensus,
+            tx_env,
+        }
     }
 
     /// Checks whether the transaction is ill formed.
     pub fn check(&self) -> Result<(), ScriptError> {
-        for (i, data) in self.tx.outputs_data().into_iter().enumerate() {
-            IllScriptChecker::new(&data.raw_data(), i).check()?;
+        let proposal_window = self.consensus.tx_proposal_window();
+        let epoch_number = self.tx_env.epoch_number(proposal_window);
+        let hardfork_switch = self.consensus.hardfork_switch();
+        // TODO ckb2021 require-confirmation We couldn't known if user run the code in vm v0 or vm v1.
+        if !hardfork_switch.is_vm_version_1_and_syscalls_2_enabled(epoch_number) {
+            for (i, data) in self.tx.outputs_data().into_iter().enumerate() {
+                IllScriptChecker::new(&data.raw_data(), i).check()?;
+            }
         }
         Ok(())
     }
@@ -87,12 +100,7 @@ impl<'a> IllScriptChecker<'a> {
             }
             i = LittleEndian::read_u32(&self.data[pc as usize..]);
         }
-        let factories = [
-            rvc::factory::<u64>,
-            i::factory::<u64>,
-            m::factory::<u64>,
-            b::factory::<u64>,
-        ];
+        let factories = [rvc::factory::<u64>, i::factory::<u64>, m::factory::<u64>];
         for factory in &factories {
             if let Some(instruction) = factory(i) {
                 return (Some(instruction), len);
diff --git a/script/src/syscalls/mod.rs b/script/src/syscalls/mod.rs
index 50426d73bc..a3ec78e28d 100644
--- a/script/src/syscalls/mod.rs
+++ b/script/src/syscalls/mod.rs
@@ -834,7 +834,7 @@ mod tests {
 
         let script = Script::new_builder()
             .args(Bytes::from(data.to_owned()).pack())
-            .hash_type(ScriptHashType::Data.into())
+            .hash_type(ScriptHashType::Data(0).into())
             .build();
         let hash = script.calc_script_hash();
         let data = hash.raw_data();
@@ -889,7 +889,7 @@ mod tests {
 
         let script = Script::new_builder()
             .args(Bytes::from(data.to_owned()).pack())
-            .hash_type(ScriptHashType::Data.into())
+            .hash_type(ScriptHashType::Data(0).into())
             .build();
         let h = script.calc_script_hash();
         let hash = h.as_bytes();
diff --git a/script/src/verify.rs b/script/src/verify.rs
index 9afc602430..7ab02a7ce0 100644
--- a/script/src/verify.rs
+++ b/script/src/verify.rs
@@ -23,21 +23,15 @@ use ckb_types::{
     packed::{Byte32, Byte32Vec, BytesVec, CellInputVec, CellOutput, OutPoint, Script},
     prelude::*,
 };
-#[cfg(not(has_asm))]
-use ckb_vm::{
-    machine::VERSION0, DefaultCoreMachine, DefaultMachineBuilder, Error as VMInternalError,
-    InstructionCycleFunc, SparseMemory, SupportMachine, Syscalls, TraceMachine, WXorXMemory, ISA_B,
-    ISA_IMC,
-};
 #[cfg(has_asm)]
+use ckb_vm::machine::asm::{AsmCoreMachine, AsmMachine};
 use ckb_vm::{
-    machine::{
-        asm::{AsmCoreMachine, AsmMachine},
-        VERSION0,
-    },
+    machine::{VERSION0, VERSION1},
     DefaultMachineBuilder, Error as VMInternalError, InstructionCycleFunc, SupportMachine,
-    Syscalls, ISA_B, ISA_IMC,
+    Syscalls, ISA_B, ISA_IMC, ISA_MOP,
 };
+#[cfg(not(has_asm))]
+use ckb_vm::{DefaultCoreMachine, SparseMemory, TraceMachine, WXorXMemory};
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::convert::TryFrom;
@@ -359,8 +353,10 @@ impl<'a, DL: CellDataProvider + HeaderProvider> TransactionScriptsVerifier<'a, D
 
     /// Extracts actual script binary either in dep cells.
     pub fn extract_script(&self, script: &'a Script) -> Result<Bytes, ScriptError> {
-        match ScriptHashType::try_from(script.hash_type()).expect("checked data") {
-            ScriptHashType::Data => {
+        let script_hash_type = ScriptHashType::try_from(script.hash_type())
+            .map_err(|err| ScriptError::InvalidScriptHashType(err.to_string()))?;
+        match script_hash_type {
+            ScriptHashType::Data(_) => {
                 if let Some(lazy) = self.binaries_by_data_hash.get(&script.code_hash()) {
                     Ok(lazy.access(self.data_loader))
                 } else {
@@ -393,6 +389,37 @@ impl<'a, DL: CellDataProvider + HeaderProvider> TransactionScriptsVerifier<'a, D
         }
     }
 
+    /// Select the ISA and the version number of the new machine.
+    pub fn select_machine_options(&self, script: &'a Script) -> Result<(u8, u32), ScriptError> {
+        let proposal_window = self.consensus.tx_proposal_window();
+        let epoch_number = self.tx_env.epoch_number(proposal_window);
+        let hardfork_switch = self.consensus.hardfork_switch();
+        let is_vm_version_1_and_syscalls_2_enabled =
+            hardfork_switch.is_vm_version_1_and_syscalls_2_enabled(epoch_number);
+        let script_hash_type = ScriptHashType::try_from(script.hash_type())
+            .map_err(|err| ScriptError::InvalidScriptHashType(err.to_string()))?;
+        match script_hash_type {
+            ScriptHashType::Data(version) => {
+                if !is_vm_version_1_and_syscalls_2_enabled && version > 0 {
+                    Err(ScriptError::InvalidVmVersion(version))
+                } else {
+                    match version {
+                        0 => Ok((ISA_IMC, VERSION0)),
+                        1 => Ok((ISA_IMC | ISA_B | ISA_MOP, VERSION1)),
+                        _ => Err(ScriptError::InvalidVmVersion(version)),
+                    }
+                }
+            }
+            ScriptHashType::Type => {
+                if is_vm_version_1_and_syscalls_2_enabled {
+                    Ok((ISA_IMC | ISA_B | ISA_MOP, VERSION1))
+                } else {
+                    Ok((ISA_IMC, VERSION0))
+                }
+            }
+        }
+    }
+
     /// Verifies the transaction by running scripts.
     ///
     /// ## Params
@@ -483,13 +510,11 @@ impl<'a, DL: CellDataProvider + HeaderProvider> TransactionScriptsVerifier<'a, D
     /// Prepares syscalls.
     pub fn generate_syscalls(
         &'a self,
+        version: u32,
         script_group: &'a ScriptGroup,
     ) -> Vec<Box<(dyn Syscalls<CoreMachineType> + 'a)>> {
         let current_script_hash = script_group.script.calc_script_hash();
-        vec![
-            Box::new(self.build_vm_version()),
-            Box::new(self.build_current_cycles()),
-            Box::new(self.build_exec(&script_group.input_indices, &script_group.output_indices)),
+        let mut syscalls: Vec<Box<(dyn Syscalls<CoreMachineType> + 'a)>> = vec![
             Box::new(self.build_load_script_hash(current_script_hash.clone())),
             Box::new(self.build_load_tx()),
             Box::new(
@@ -508,23 +533,30 @@ impl<'a, DL: CellDataProvider + HeaderProvider> TransactionScriptsVerifier<'a, D
                 ),
             ),
             Box::new(Debugger::new(current_script_hash, &self.debug_printer)),
-        ]
+        ];
+        if version >= VERSION1 {
+            syscalls.append(&mut vec![
+                Box::new(self.build_vm_version()),
+                Box::new(self.build_current_cycles()),
+                Box::new(
+                    self.build_exec(&script_group.input_indices, &script_group.output_indices),
+                ),
+            ])
+        }
+        syscalls
     }
 
     fn run(&self, script_group: &ScriptGroup, max_cycles: Cycle) -> Result<Cycle, ScriptError> {
         let program = self.extract_script(&script_group.script)?;
+        let (isa, version) = self.select_machine_options(&script_group.script)?;
         #[cfg(has_asm)]
-        let core_machine = AsmCoreMachine::new(ISA_IMC | ISA_B, VERSION0, max_cycles);
+        let core_machine = AsmCoreMachine::new(isa, version, max_cycles);
         #[cfg(not(has_asm))]
-        let core_machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
-            ISA_IMC | ISA_B,
-            VERSION0,
-            max_cycles,
-        );
+        let core_machine = CoreMachineType::new(isa, version, max_cycles);
         let machine_builder = DefaultMachineBuilder::<CoreMachineType>::new(core_machine)
             .instruction_cycle_func(self.cost_model());
         let machine_builder = self
-            .generate_syscalls(script_group)
+            .generate_syscalls(version, script_group)
             .into_iter()
             .fold(machine_builder, |builder, syscall| builder.syscall(syscall));
         let default_machine = machine_builder.build();
@@ -566,8 +598,9 @@ mod tests {
     use ckb_store::{data_loader_wrapper::DataLoaderWrapper, ChainDB};
     use ckb_types::{
         core::{
-            capacity_bytes, cell::CellMetaBuilder, Capacity, Cycle, DepType, HeaderView,
-            ScriptHashType, TransactionBuilder, TransactionInfo,
+            capacity_bytes, cell::CellMetaBuilder, hardfork::HardForkSwitch, Capacity, Cycle,
+            DepType, EpochNumberWithFraction, HeaderView, ScriptHashType, TransactionBuilder,
+            TransactionInfo,
         },
         h256,
         packed::{
@@ -690,7 +723,10 @@ mod tests {
 
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
             let header = HeaderView::new_advanced_builder().build();
             TxVerifyEnv::new_commit(&header)
@@ -730,7 +766,7 @@ mod tests {
         let script = Script::new_builder()
             .args(Bytes::from(args).pack())
             .code_hash(code_hash.pack())
-            .hash_type(ScriptHashType::Data.into())
+            .hash_type(ScriptHashType::Data(0).into())
             .build();
         let input = CellInput::new(OutPoint::null(), 0);
 
@@ -755,7 +791,10 @@ mod tests {
         };
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
             let header = HeaderView::new_advanced_builder().build();
             TxVerifyEnv::new_commit(&header)
@@ -801,7 +840,7 @@ mod tests {
                 Some(
                     Script::new_builder()
                         .code_hash(h256!("0x123456abcd90").pack())
-                        .hash_type(ScriptHashType::Data.into())
+                        .hash_type(ScriptHashType::Data(0).into())
                         .build(),
                 )
                 .pack(),
@@ -841,7 +880,10 @@ mod tests {
         };
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
             let header = HeaderView::new_advanced_builder().build();
             TxVerifyEnv::new_commit(&header)
@@ -876,7 +918,7 @@ mod tests {
                 Some(
                     Script::new_builder()
                         .code_hash(h256!("0x123456abcd90").pack())
-                        .hash_type(ScriptHashType::Data.into())
+                        .hash_type(ScriptHashType::Data(0).into())
                         .build(),
                 )
                 .pack(),
@@ -898,7 +940,7 @@ mod tests {
                 Some(
                     Script::new_builder()
                         .code_hash(h256!("0x123456abcd90").pack())
-                        .hash_type(ScriptHashType::Data.into())
+                        .hash_type(ScriptHashType::Data(0).into())
                         .build(),
                 )
                 .pack(),
@@ -938,7 +980,10 @@ mod tests {
         };
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
             let header = HeaderView::new_advanced_builder().build();
             TxVerifyEnv::new_commit(&header)
@@ -982,7 +1027,7 @@ mod tests {
         let script = Script::new_builder()
             .args(Bytes::from(args).pack())
             .code_hash(code_hash.pack())
-            .hash_type(ScriptHashType::Data.into())
+            .hash_type(ScriptHashType::Data(0).into())
             .build();
         let input = CellInput::new(OutPoint::null(), 0);
 
@@ -1008,7 +1053,10 @@ mod tests {
 
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
             let header = HeaderView::new_advanced_builder().build();
             TxVerifyEnv::new_commit(&header)
@@ -1040,7 +1088,7 @@ mod tests {
         let script = Script::new_builder()
             .args(Bytes::from(args).pack())
             .code_hash(blake2b_256(&buffer).pack())
-            .hash_type(ScriptHashType::Data.into())
+            .hash_type(ScriptHashType::Data(0).into())
             .build();
         let input = CellInput::new(OutPoint::null(), 0);
 
@@ -1066,7 +1114,10 @@ mod tests {
 
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
             let header = HeaderView::new_advanced_builder().build();
             TxVerifyEnv::new_commit(&header)
@@ -1112,13 +1163,13 @@ mod tests {
         let script = Script::new_builder()
             .args(Bytes::from(args).pack())
             .code_hash(blake2b_256(&buffer).pack())
-            .hash_type(ScriptHashType::Data.into())
+            .hash_type(ScriptHashType::Data(0).into())
             .build();
         let output_data = Bytes::default();
         let output = CellOutputBuilder::default()
             .lock(
                 Script::new_builder()
-                    .hash_type(ScriptHashType::Data.into())
+                    .hash_type(ScriptHashType::Data(0).into())
                     .build(),
             )
             .type_(Some(script).pack())
@@ -1155,7 +1206,10 @@ mod tests {
 
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
             let header = HeaderView::new_advanced_builder().build();
             TxVerifyEnv::new_commit(&header)
@@ -1201,7 +1255,7 @@ mod tests {
         let script = Script::new_builder()
             .args(Bytes::from(args).pack())
             .code_hash(blake2b_256(&buffer).pack())
-            .hash_type(ScriptHashType::Data.into())
+            .hash_type(ScriptHashType::Data(0).into())
             .build();
         let output = CellOutputBuilder::default()
             .type_(Some(script).pack())
@@ -1235,7 +1289,10 @@ mod tests {
 
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
             let header = HeaderView::new_advanced_builder().build();
             TxVerifyEnv::new_commit(&header)
@@ -1266,7 +1323,7 @@ mod tests {
         let script = Script::new_builder()
             .args(Bytes::from(args).pack())
             .code_hash(blake2b_256(&buffer).pack())
-            .hash_type(ScriptHashType::Data.into())
+            .hash_type(ScriptHashType::Data(0).into())
             .build();
 
         let dep_out_point = OutPoint::new(h256!("0x123").pack(), 8);
@@ -1305,7 +1362,10 @@ mod tests {
         };
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
             let header = HeaderView::new_advanced_builder().build();
             TxVerifyEnv::new_commit(&header)
@@ -1374,7 +1434,10 @@ mod tests {
 
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
             let header = HeaderView::new_advanced_builder().build();
             TxVerifyEnv::new_commit(&header)
@@ -1441,7 +1504,10 @@ mod tests {
 
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
             let header = HeaderView::new_advanced_builder().build();
             TxVerifyEnv::new_commit(&header)
@@ -1519,7 +1585,10 @@ mod tests {
 
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
             let header = HeaderView::new_advanced_builder().build();
             TxVerifyEnv::new_commit(&header)
@@ -1583,7 +1652,10 @@ mod tests {
 
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
             let header = HeaderView::new_advanced_builder().build();
             TxVerifyEnv::new_commit(&header)
@@ -1662,7 +1734,10 @@ mod tests {
 
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
             let header = HeaderView::new_advanced_builder().build();
             TxVerifyEnv::new_commit(&header)
@@ -1747,7 +1822,10 @@ mod tests {
 
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
             let header = HeaderView::new_advanced_builder().build();
             TxVerifyEnv::new_commit(&header)
@@ -1821,7 +1899,10 @@ mod tests {
 
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
             let header = HeaderView::new_advanced_builder().build();
             TxVerifyEnv::new_commit(&header)
@@ -1983,7 +2064,10 @@ mod tests {
 
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
             let header = HeaderView::new_advanced_builder().build();
             TxVerifyEnv::new_commit(&header)
@@ -2006,7 +2090,7 @@ mod tests {
             .capacity(Capacity::bytes(vm_version_cell_data.len()).unwrap().pack())
             .build();
         let vm_version_script = Script::new_builder()
-            .hash_type(ScriptHashType::Data.into())
+            .hash_type(ScriptHashType::Data(1).into())
             .code_hash(CellOutput::calc_data_hash(&vm_version_cell_data))
             .build();
         let output = CellOutputBuilder::default()
@@ -2032,11 +2116,22 @@ mod tests {
             resolved_dep_groups: vec![],
         };
 
+        let fork_at = 10;
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled()
+            .as_builder()
+            .rfc_pr_0237(fork_at)
+            .build()
+            .unwrap();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
-            let header = HeaderView::new_advanced_builder().build();
+            let epoch = EpochNumberWithFraction::new(fork_at, 0, 1);
+            let header = HeaderView::new_advanced_builder()
+                .epoch(epoch.pack())
+                .build();
             TxVerifyEnv::new_commit(&header)
         };
 
@@ -2065,7 +2160,7 @@ mod tests {
             .build();
 
         let exec_caller_script = Script::new_builder()
-            .hash_type(ScriptHashType::Data.into())
+            .hash_type(ScriptHashType::Data(1).into())
             .code_hash(CellOutput::calc_data_hash(&exec_caller_cell_data))
             .build();
         let output = CellOutputBuilder::default()
@@ -2096,11 +2191,22 @@ mod tests {
             resolved_dep_groups: vec![],
         };
 
+        let fork_at = 10;
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled()
+            .as_builder()
+            .rfc_pr_0237(fork_at)
+            .build()
+            .unwrap();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
-            let header = HeaderView::new_advanced_builder().build();
+            let epoch = EpochNumberWithFraction::new(fork_at, 0, 1);
+            let header = HeaderView::new_advanced_builder()
+                .epoch(epoch.pack())
+                .build();
             TxVerifyEnv::new_commit(&header)
         };
 
@@ -2127,7 +2233,7 @@ mod tests {
         .pack();
 
         let exec_caller_script = Script::new_builder()
-            .hash_type(ScriptHashType::Data.into())
+            .hash_type(ScriptHashType::Data(1).into())
             .code_hash(CellOutput::calc_data_hash(&exec_caller_cell_data))
             .build();
         let output = CellOutputBuilder::default()
@@ -2156,11 +2262,22 @@ mod tests {
             resolved_dep_groups: vec![],
         };
 
+        let fork_at = 10;
         let store = new_store();
         let data_loader = DataLoaderWrapper::new(&store);
-        let consensus = ConsensusBuilder::default().build();
+        let hardfork_switch = HardForkSwitch::new_without_any_enabled()
+            .as_builder()
+            .rfc_pr_0237(fork_at)
+            .build()
+            .unwrap();
+        let consensus = ConsensusBuilder::default()
+            .hardfork_switch(hardfork_switch)
+            .build();
         let tx_env = {
-            let header = HeaderView::new_advanced_builder().build();
+            let epoch = EpochNumberWithFraction::new(fork_at, 0, 1);
+            let header = HeaderView::new_advanced_builder()
+                .epoch(epoch.pack())
+                .build();
             TxVerifyEnv::new_commit(&header)
         };
 
diff --git a/script/testdata/vm_version b/script/testdata/vm_version
old mode 100755
new mode 100644
index 3111cbe34bae68925e544e9cbb42cbd60aaa8919..b355c5d06a47a6908916e600b825471581517aea
GIT binary patch
delta 963
zcmZWo&ubGw6rM>oKi0-{Hfy?Bn>JZNjiN-;V#q;~l*U|}9>nxwYipr`B)O<T!E7Za
z2Y<9Yu;gTme}P0Vg4iA^z4UHR7Al^E=tb#8e7iF%5(jqPe)E0roA-8R8>x0`B|&#q
z&!qE5Jj5POB#dK<!HZ8o@PV+kf>^`{J{yuZs~fT6$%zWdWtJOj1|eY5k7|?tR3Dp%
z@-ws0Bl{y7ny8+eX?>f&HOG1+cd19#!>+<PLa(4^utN61N0;a})aZGfU()-*v#n-v
z{@5>K7M1m85k_6(lTt~Q<<gjZnDc%+^+hdba`OW+Q6;HlPDW>&k|8ax9Yj073k!uM
z@Y(8VOZ~61`@;2vdZcM+wcxb$8T_8OI(wY=$A)>_9HwA+cj3F{?=tT-uaXdr^R@{|
zKt1q~20%F)cDo6~sL{BMJjmq{RiTEQkF+s9M<oqjr)`)ETDp2Lsjo!&Ru_cjD~y!5
zNd&fncWDALgCA^v6#^{!-~JO|Fb$@dUyt`ywrJa0HPx7=vp)9eUv`6O`NRmX!RhKP
z!Vp#=dHA|@1+4KNA;Sw%6*co!LUut>G+>Hfzt_in#SF#DfQyQzPr10?Es;3j;`^L{
zIYpxjP*;-r4T)>+2+ag)81a!!*g}VPpZ|<-cn3d}m@+PM7RBmSFhZK%5IKIq-nJdB
z^C=<Q?|9kn(b~^MHYF+^6}gXu^QZ3XP{mDWz!*x(&fgG#@=#iKJ~e|5BIj7*u!qRG
tJ_*pZwCsGwDwGj9g|wlgW$}va;oJc|lBGLPw&zYHE0@B&k}4RH*dI2imihny

delta 901
zcmZuvL1+_E5S^dwW_Phoce5ma*QPY_U=vZ&#%lD`1d?h&BsmDxiw29dr_ht4g1aTL
z6{HyEP&}F7&66dUco6F$2QQxWq(QwYp%)<@)Y<GVLU0Z<fBu_!^XJd(WUcIz6gz09
za|IB=72m3^%gBVBqkkWDZb&?9Nv_*%wr4Li3N>h*+p_kO0BGAiy}^F!5AC6{YnKL)
zpW#HJi@mdE&pmz14xn{rKxBc^NnpzZ_&imEJW6bXiMYv5k$%SR2`{$oIZOo>i^a08
ztdvhH!+hxb@vr*T^ZA=c6wrlY*)GO!G=!wEwf80d^ml2kw1HBcq90Y9=zo#*a;Ft|
z%*1*Hw<TN<K4DlqrmY@zyOO6}+wBy@jHD&}X5Ahkf%e1$2FNBklSxN|0vNbJUSi~h
zU>&RES)`-5J9(F4mGE`bio3L~23R9L22QRW&afTa4|AsCyYOw|DNMa_DySK}sH&J(
zWz!gY#g!3Fkg}_4bUFaS7*175f*@n_zxZ>)RXF^Uz_%(le+llZMnk5&*CW*F<WS|>
zy7zL2(UFhHG>-F{Z2E}o0x+b!2z9lL6^)yQ$GYgDGXWR9hPIYrtGG`w-7)UV6r+L!
z7WOsHUgA)jO`q`cZ+ZEbJl+ZK{s&dnXhH8_A;Qh^dEFl|hKO;K(D8b8k28hs2xsp*
zuOhV|D`PsAQT*)&tj2PR?0v9|ZSwqa7}$^H@Iy?+6rWf8@1O<XImI8ig>Ak>>(D3N
T#H6vr4zN1XZPF{)H|G8V5owoH

diff --git a/script/testdata/vm_version.c b/script/testdata/vm_version.c
index b66b1e8e4f..66c33c2bbe 100644
--- a/script/testdata/vm_version.c
+++ b/script/testdata/vm_version.c
@@ -19,5 +19,8 @@ static inline long __internal_syscall(long n, long _a0, long _a1, long _a2,
                      (long)(f))
 
 int main() {
-    return syscall(2041, 0, 0, 0, 0, 0, 0);
+    if (syscall(2041, 0, 0, 0, 0, 0, 0) == 1) {
+      return 0;
+    }
+    return 1;
 }
diff --git a/spec/src/hardfork.rs b/spec/src/hardfork.rs
index e8021f0784..76593ffb74 100644
--- a/spec/src/hardfork.rs
+++ b/spec/src/hardfork.rs
@@ -20,6 +20,8 @@ pub struct HardForkConfig {
     pub rfc_pr_0223: Option<EpochNumber>,
     /// Ref: [CKB RFC xxxx](https://github.com/nervosnetwork/rfcs/tree/master/rfcs/xxxx-rfc-title)
     pub rfc_pr_0224: Option<EpochNumber>,
+    /// Ref: [CKB RFC xxxx](https://github.com/nervosnetwork/rfcs/tree/master/rfcs/xxxx-rfc-title)
+    pub rfc_pr_0237: Option<EpochNumber>,
 }
 
 macro_rules! check_default {
@@ -66,7 +68,8 @@ impl HardForkConfig {
             .rfc_pr_0221(check_default!(self, rfc_pr_0221, ckb2021))
             .rfc_pr_0222(check_default!(self, rfc_pr_0222, ckb2021))
             .rfc_pr_0223(check_default!(self, rfc_pr_0223, ckb2021))
-            .rfc_pr_0224(check_default!(self, rfc_pr_0224, ckb2021));
+            .rfc_pr_0224(check_default!(self, rfc_pr_0224, ckb2021))
+            .rfc_pr_0237(check_default!(self, rfc_pr_0237, ckb2021));
         Ok(builder)
     }
 
@@ -79,6 +82,7 @@ impl HardForkConfig {
             .rfc_pr_0222(self.rfc_pr_0222.unwrap_or(default))
             .rfc_pr_0223(self.rfc_pr_0223.unwrap_or(default))
             .rfc_pr_0224(self.rfc_pr_0224.unwrap_or(default))
+            .rfc_pr_0237(self.rfc_pr_0237.unwrap_or(default))
             .build()
     }
 }
diff --git a/spec/src/lib.rs b/spec/src/lib.rs
index aad021eab3..0b389a1073 100644
--- a/spec/src/lib.rs
+++ b/spec/src/lib.rs
@@ -618,7 +618,7 @@ impl ChainSpec {
             })
         {
             match ScriptHashType::try_from(lock_script.hash_type()).expect("checked data") {
-                ScriptHashType::Data => {
+                ScriptHashType::Data(_) => {
                     if !data_hashes.contains_key(&lock_script.code_hash()) {
                         return Err(format!(
                             "Invalid lock script: code_hash={}, hash_type=data",
@@ -712,7 +712,7 @@ impl ChainSpec {
         let special_issued_lock = packed::Script::new_builder()
             .args(secp_lock_arg(&Privkey::from(SPECIAL_CELL_PRIVKEY.clone())).pack())
             .code_hash(CODE_HASH_SECP256K1_BLAKE160_SIGHASH_ALL.clone().pack())
-            .hash_type(ScriptHashType::Data.into())
+            .hash_type(ScriptHashType::Data(0).into())
             .build();
         let special_issued_cell = packed::CellOutput::new_builder()
             .capacity(special_cell_capacity.pack())
diff --git a/test/src/main.rs b/test/src/main.rs
index d2dc560bec..524fe5dcd7 100644
--- a/test/src/main.rs
+++ b/test/src/main.rs
@@ -424,7 +424,7 @@ fn all_specs() -> Vec<Box<dyn Spec>> {
         )),
         Box::new(SendSecpTxUseDepGroup::new(
             "send_secp_tx_use_dep_group_data_hash",
-            ScriptHashType::Data,
+            ScriptHashType::Data(0),
         )),
         Box::new(SendSecpTxUseDepGroup::new(
             "send_secp_tx_use_dep_group_type_hash",
@@ -432,7 +432,7 @@ fn all_specs() -> Vec<Box<dyn Spec>> {
         )),
         Box::new(SendMultiSigSecpTxUseDepGroup::new(
             "send_multisig_secp_tx_use_dep_group_data_hash",
-            ScriptHashType::Data,
+            ScriptHashType::Data(0),
         )),
         Box::new(SendMultiSigSecpTxUseDepGroup::new(
             "send_multisig_secp_tx_use_dep_group_type_hash",
diff --git a/test/src/node.rs b/test/src/node.rs
index 88524c9683..ff37dec155 100644
--- a/test/src/node.rs
+++ b/test/src/node.rs
@@ -192,7 +192,7 @@ impl Node {
         let always_success_code_hash = CellOutput::calc_data_hash(&always_success_raw);
         Script::new_builder()
             .code_hash(always_success_code_hash)
-            .hash_type(ScriptHashType::Data.into())
+            .hash_type(ScriptHashType::Data(0).into())
             .build()
     }
 
diff --git a/test/src/specs/hardfork/v2021/cell_deps.rs b/test/src/specs/hardfork/v2021/cell_deps.rs
index 85d9daf114..e0fb64181f 100644
--- a/test/src/specs/hardfork/v2021/cell_deps.rs
+++ b/test/src/specs/hardfork/v2021/cell_deps.rs
@@ -433,7 +433,7 @@ impl NewScript {
     fn as_data_script(&self) -> packed::Script {
         packed::Script::new_builder()
             .code_hash(self.data_hash.clone())
-            .hash_type(ScriptHashType::Data.into())
+            .hash_type(ScriptHashType::Data(0).into())
             .build()
     }
 
diff --git a/test/src/specs/mining/bootstrap.rs b/test/src/specs/mining/bootstrap.rs
index 9873428d91..bb4bc82702 100644
--- a/test/src/specs/mining/bootstrap.rs
+++ b/test/src/specs/mining/bootstrap.rs
@@ -24,7 +24,7 @@ impl Spec for BootstrapCellbase {
         let miner = packed::Script::new_builder()
             .args(Bytes::from(vec![2, 1]).pack())
             .code_hash(h256!("0xa2").pack())
-            .hash_type(ScriptHashType::Data.into())
+            .hash_type(ScriptHashType::Data(0).into())
             .build();
 
         let is_bootstrap_cellbase = |number| {
@@ -61,7 +61,7 @@ impl Spec for BootstrapCellbase {
         config.block_assembler = Some(BlockAssemblerConfig {
             code_hash: h256!("0xa2"),
             args: JsonBytes::from_bytes(Bytes::from(vec![2, 1])),
-            hash_type: ScriptHashType::Data.into(),
+            hash_type: ScriptHashType::Data(0).into(),
             message: Default::default(),
         });
     }
diff --git a/test/src/specs/tx_pool/mod.rs b/test/src/specs/tx_pool/mod.rs
index 29edb92d6c..0b056af91f 100644
--- a/test/src/specs/tx_pool/mod.rs
+++ b/test/src/specs/tx_pool/mod.rs
@@ -54,7 +54,7 @@ fn type_lock_script_code_hash() -> H256 {
 }
 
 fn new_block_assembler_config(lock_arg: Bytes, hash_type: ScriptHashType) -> BlockAssemblerConfig {
-    let code_hash = if hash_type == ScriptHashType::Data {
+    let code_hash = if hash_type == ScriptHashType::Data(0) {
         CODE_HASH_SECP256K1_BLAKE160_SIGHASH_ALL.clone()
     } else {
         type_lock_script_code_hash()
diff --git a/test/src/specs/tx_pool/send_multisig_secp_tx.rs b/test/src/specs/tx_pool/send_multisig_secp_tx.rs
index 6f54a8af3d..d3018b660a 100644
--- a/test/src/specs/tx_pool/send_multisig_secp_tx.rs
+++ b/test/src/specs/tx_pool/send_multisig_secp_tx.rs
@@ -141,7 +141,7 @@ fn type_lock_script_code_hash() -> H256 {
 }
 
 fn new_block_assembler_config(lock_arg: Bytes, hash_type: ScriptHashType) -> BlockAssemblerConfig {
-    let code_hash = if hash_type == ScriptHashType::Data {
+    let code_hash = if hash_type == ScriptHashType::Data(0) {
         CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL.clone()
     } else {
         type_lock_script_code_hash()
diff --git a/test/template/specs/integration.toml b/test/template/specs/integration.toml
index cf1b5ff7b7..9a92cb248d 100644
--- a/test/template/specs/integration.toml
+++ b/test/template/specs/integration.toml
@@ -73,6 +73,7 @@ rfc_pr_0221 = 9_223_372_036_854_775_807
 rfc_pr_0222 = 9_223_372_036_854_775_807
 rfc_pr_0223 = 9_223_372_036_854_775_807
 rfc_pr_0224 = 9_223_372_036_854_775_807
+rfc_pr_0237 = 9_223_372_036_854_775_807
 
 [pow]
 func = "Dummy"
diff --git a/util/app-config/src/configs/tx_pool.rs b/util/app-config/src/configs/tx_pool.rs
index 170d3d9f4c..318aa5cf58 100644
--- a/util/app-config/src/configs/tx_pool.rs
+++ b/util/app-config/src/configs/tx_pool.rs
@@ -1,5 +1,5 @@
 use ckb_chain_spec::consensus::TWO_IN_TWO_OUT_CYCLES;
-use ckb_jsonrpc_types::{FeeRateDef, JsonBytes, ScriptHashType};
+use ckb_jsonrpc_types::{FeeRateDef, JsonBytes, ScriptHashType, ScriptHashTypeShadow, VmVersion};
 use ckb_types::core::{Cycle, FeeRate};
 use ckb_types::H256;
 use serde::{Deserialize, Serialize};
@@ -52,13 +52,69 @@ impl Default for TxPoolConfig {
 ///
 /// The block assembler section tells CKB how to claim the miner rewards.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(try_from = "BlockAssemblerConfigShadow")]
 pub struct BlockAssemblerConfig {
     /// The miner lock script code hash.
     pub code_hash: H256,
     /// The miner lock script hash type.
+    #[serde(flatten)]
     pub hash_type: ScriptHashType,
     /// The miner lock script args.
     pub args: JsonBytes,
     /// An arbitrary message to be added into the cellbase transaction.
     pub message: JsonBytes,
 }
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct BlockAssemblerConfigShadow {
+    code_hash: H256,
+    #[serde(rename = "hash_type")]
+    hash_type_shadow: ScriptHashTypeShadow,
+    #[serde(rename = "vm_version")]
+    vm_version_opt: Option<VmVersion>,
+    args: JsonBytes,
+    message: JsonBytes,
+}
+
+struct BlockAssemblerConfigValidationError(&'static str);
+
+impl std::fmt::Display for BlockAssemblerConfigValidationError {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(formatter, "{}", self.0)
+    }
+}
+
+impl std::convert::TryFrom<BlockAssemblerConfigShadow> for BlockAssemblerConfig {
+    type Error = BlockAssemblerConfigValidationError;
+    fn try_from(shadow: BlockAssemblerConfigShadow) -> Result<Self, Self::Error> {
+        let BlockAssemblerConfigShadow {
+            code_hash,
+            hash_type_shadow,
+            vm_version_opt,
+            args,
+            message,
+        } = shadow;
+        let hash_type = match hash_type_shadow {
+            ScriptHashTypeShadow::Data => {
+                let vm_version = vm_version_opt.unwrap_or_default();
+                ScriptHashType::Data { vm_version }
+            }
+            ScriptHashTypeShadow::Type => {
+                if vm_version_opt.is_some() {
+                    return Err(BlockAssemblerConfigValidationError(
+                        "vm version is not allowed for hash-type \"type\".",
+                    ));
+                }
+                ScriptHashType::Type
+            }
+        };
+        let script = BlockAssemblerConfig {
+            code_hash,
+            hash_type,
+            args,
+            message,
+        };
+        Ok(script)
+    }
+}
diff --git a/util/jsonrpc-types/src/blockchain.rs b/util/jsonrpc-types/src/blockchain.rs
index f04095c86f..517b42908c 100644
--- a/util/jsonrpc-types/src/blockchain.rs
+++ b/util/jsonrpc-types/src/blockchain.rs
@@ -1,7 +1,7 @@
 use crate::bytes::JsonBytes;
 use crate::{
     BlockNumber, Byte32, Capacity, Cycle, EpochNumber, EpochNumberWithFraction, ProposalShortId,
-    Timestamp, Uint128, Uint32, Uint64, Version,
+    Timestamp, Uint128, Uint32, Uint64, Version, VmVersion,
 };
 use ckb_types::{core, packed, prelude::*, H256};
 use serde::{Deserialize, Serialize};
@@ -16,24 +16,38 @@ use std::fmt;
 /// and [Upgradable Script](https://github.com/nervosnetwork/rfcs/blob/master/rfcs/0022-transaction-structure/0022-transaction-structure.md#upgradable-script)
 /// in the RFC *CKB Transaction Structure*.
 #[derive(Clone, Serialize, Deserialize, PartialEq, Eq, Hash, Debug)]
-#[serde(rename_all = "snake_case")]
+#[serde(rename_all = "snake_case", deny_unknown_fields, tag = "hash_type")]
 pub enum ScriptHashType {
     /// Type "data" matches script code via cell data hash.
-    Data,
+    Data {
+        /// CKB-VM version.
+        #[serde(default, skip_serializing_if = "VmVersion::is_default")]
+        vm_version: VmVersion,
+    },
     /// Type "type" matches script code via cell type script hash.
     Type,
 }
 
+#[doc(hidden)]
+#[derive(Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ScriptHashTypeShadow {
+    Data,
+    Type,
+}
+
 impl Default for ScriptHashType {
     fn default() -> Self {
-        ScriptHashType::Data
+        ScriptHashType::Data {
+            vm_version: Default::default(),
+        }
     }
 }
 
 impl From<ScriptHashType> for core::ScriptHashType {
     fn from(json: ScriptHashType) -> Self {
         match json {
-            ScriptHashType::Data => core::ScriptHashType::Data,
+            ScriptHashType::Data { vm_version } => core::ScriptHashType::Data(vm_version.into()),
             ScriptHashType::Type => core::ScriptHashType::Type,
         }
     }
@@ -42,7 +56,9 @@ impl From<ScriptHashType> for core::ScriptHashType {
 impl From<core::ScriptHashType> for ScriptHashType {
     fn from(core: core::ScriptHashType) -> ScriptHashType {
         match core {
-            core::ScriptHashType::Data => ScriptHashType::Data,
+            core::ScriptHashType::Data(v) => ScriptHashType::Data {
+                vm_version: v.into(),
+            },
             core::ScriptHashType::Type => ScriptHashType::Type,
         }
     }
@@ -51,7 +67,9 @@ impl From<core::ScriptHashType> for ScriptHashType {
 impl fmt::Display for ScriptHashType {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         match self {
-            ScriptHashType::Data => write!(f, "data"),
+            ScriptHashType::Data { vm_version } => {
+                write!(f, "data {{ vm_version: {} }}", vm_version)
+            }
             ScriptHashType::Type => write!(f, "type"),
         }
     }
@@ -71,16 +89,68 @@ impl fmt::Display for ScriptHashType {
 /// # "#).unwrap();
 /// ```
 #[derive(Clone, Default, Serialize, Deserialize, PartialEq, Eq, Hash, Debug)]
-#[serde(deny_unknown_fields)]
+#[serde(try_from = "ScriptShadow")]
 pub struct Script {
     /// The hash used to match the script code.
     pub code_hash: H256,
     /// Specifies how to use the `code_hash` to match the script code.
+    #[serde(flatten)]
     pub hash_type: ScriptHashType,
     /// Arguments for script.
     pub args: JsonBytes,
 }
 
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ScriptShadow {
+    code_hash: H256,
+    #[serde(rename = "hash_type")]
+    hash_type_shadow: ScriptHashTypeShadow,
+    #[serde(rename = "vm_version")]
+    vm_version_opt: Option<VmVersion>,
+    args: JsonBytes,
+}
+
+struct ScriptValidationError(&'static str);
+
+impl std::fmt::Display for ScriptValidationError {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(formatter, "{}", self.0)
+    }
+}
+
+impl std::convert::TryFrom<ScriptShadow> for Script {
+    type Error = ScriptValidationError;
+    fn try_from(shadow: ScriptShadow) -> Result<Self, Self::Error> {
+        let ScriptShadow {
+            code_hash,
+            hash_type_shadow,
+            vm_version_opt,
+            args,
+        } = shadow;
+        let hash_type = match hash_type_shadow {
+            ScriptHashTypeShadow::Data => {
+                let vm_version = vm_version_opt.unwrap_or_default();
+                ScriptHashType::Data { vm_version }
+            }
+            ScriptHashTypeShadow::Type => {
+                if vm_version_opt.is_some() {
+                    return Err(ScriptValidationError(
+                        "vm version is not allowed for hash-type \"type\".",
+                    ));
+                }
+                ScriptHashType::Type
+            }
+        };
+        let script = Script {
+            code_hash,
+            hash_type,
+            args,
+        };
+        Ok(script)
+    }
+}
+
 impl From<Script> for packed::Script {
     fn from(json: Script) -> Self {
         let Script {
@@ -1239,7 +1309,7 @@ pub struct Consensus {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use ckb_types::{bytes::Bytes, core::TransactionBuilder, packed::Byte32};
+    use ckb_types::{bytes::Bytes, core::TransactionBuilder, h256, packed::Byte32, H256};
     use lazy_static::lazy_static;
     use proptest::{collection::size_range, prelude::*};
     use regex::Regex;
@@ -1248,7 +1318,7 @@ mod tests {
         packed::ScriptBuilder::default()
             .code_hash(Byte32::zero())
             .args(arg.pack())
-            .hash_type(core::ScriptHashType::Data.into())
+            .hash_type(core::ScriptHashType::Data(0).into())
             .build()
     }
 
@@ -1288,6 +1358,92 @@ mod tests {
             .build()
     }
 
+    #[test]
+    fn test_script_serialization() {
+        for (original, entity) in &[
+            (
+                "{\
+                \"code_hash\":\"0x00000000000000000000000000000000\
+                                  00000000000000000000000000000000\",\
+                \"hash_type\":\"type\",\
+                \"args\":\"0x\"\
+             }",
+                Script {
+                    code_hash: h256!("0x0"),
+                    hash_type: ScriptHashType::Type,
+                    args: JsonBytes::default(),
+                },
+            ),
+            (
+                "{\
+                \"code_hash\":\"0x00000000000000000000000000000000\
+                                  00000000000000000000000000000000\",\
+                \"hash_type\":\"data\",\
+                \"args\":\"0x\"\
+             }",
+                Script {
+                    code_hash: h256!("0x0"),
+                    hash_type: ScriptHashType::Data {
+                        vm_version: VmVersion::default(),
+                    },
+                    args: JsonBytes::default(),
+                },
+            ),
+            (
+                "{\
+                \"code_hash\":\"0x00000000000000000000000000000000\
+                                  00000000000000000000000000000000\",\
+                \"hash_type\":\"data\",\
+                \"vm_version\":\"0x2\",\
+                \"args\":\"0x\"\
+             }",
+                Script {
+                    code_hash: h256!("0x0"),
+                    hash_type: ScriptHashType::Data {
+                        vm_version: 2.into(),
+                    },
+                    args: JsonBytes::default(),
+                },
+            ),
+        ] {
+            let decoded: Script = serde_json::from_str(&original).unwrap();
+            assert_eq!(&decoded, entity);
+            let encoded = serde_json::to_string(&decoded).unwrap();
+            assert_eq!(&encoded, original);
+        }
+        for malformed in &[
+            "{\
+                \"code_hash\":\"0x00000000000000000000000000000000\
+                                  00000000000000000000000000000000\",\
+                \"hash_type\":\"type\",\
+                \"vm_version\":\"0x0\",\
+                \"args\":\"0x\"\
+             }",
+            "{\
+                \"code_hash\":\"0x00000000000000000000000000000000\
+                                  00000000000000000000000000000000\",\
+                \"hash_type\":\"data\",\
+                \"unknown_field\":\"0x0\",\
+                \"args\":\"0x\"\
+             }",
+            "{\
+                \"code_hash\":\"0x00000000000000000000000000000000\
+                                  00000000000000000000000000000000\",\
+                \"hash_type\":\"data\",\
+                \"vm_version\":\"0x2\",\
+                \"unknown_field\":\"0x0\",\
+                \"args\":\"0x\"\
+             }",
+        ] {
+            let result: Result<Script, _> = serde_json::from_str(&malformed);
+            assert!(
+                result.is_err(),
+                "should reject malformed json: [{}]",
+                malformed
+            )
+        }
+    }
+
     fn _test_block_convert(data: Bytes, arg: Bytes) -> Result<(), TestCaseError> {
         let block = mock_full_block(data, arg);
         let json_block: BlockView = block.clone().into();
diff --git a/util/jsonrpc-types/src/lib.rs b/util/jsonrpc-types/src/lib.rs
index ee4d939921..c918eafe7e 100644
--- a/util/jsonrpc-types/src/lib.rs
+++ b/util/jsonrpc-types/src/lib.rs
@@ -23,8 +23,8 @@ pub use self::block_template::{
 pub use self::blockchain::{
     Block, BlockEconomicState, BlockIssuance, BlockView, CellDep, CellInput, CellOutput, Consensus,
     DepType, EpochView, Header, HeaderView, MerkleProof, MinerReward, OutPoint, ProposalWindow,
-    Script, ScriptHashType, Status, Transaction, TransactionProof, TransactionView,
-    TransactionWithStatus, TxStatus, UncleBlock, UncleBlockView,
+    Script, ScriptHashType, ScriptHashTypeShadow, Status, Transaction, TransactionProof,
+    TransactionView, TransactionWithStatus, TxStatus, UncleBlock, UncleBlockView,
 };
 pub use self::bytes::JsonBytes;
 pub use self::cell::{CellData, CellInfo, CellWithStatus};
@@ -43,11 +43,11 @@ pub use self::pool::{
 };
 pub use self::proposal_short_id::ProposalShortId;
 pub use self::subscription::Topic;
-pub use self::uints::{Uint128, Uint32, Uint64};
+pub use self::uints::{Uint128, Uint32, Uint64, Uint8};
 pub use jsonrpc_core::types::{error, id, params, request, response, version};
 pub use primitive::{
     AsEpochNumberWithFraction, BlockNumber, Capacity, Cycle, EpochNumber, EpochNumberWithFraction,
-    Timestamp, Version,
+    Timestamp, Version, VmVersion,
 };
 pub use serde::{Deserialize, Serialize};
 
diff --git a/util/jsonrpc-types/src/primitive.rs b/util/jsonrpc-types/src/primitive.rs
index cbf4b26d1d..ff73127b65 100644
--- a/util/jsonrpc-types/src/primitive.rs
+++ b/util/jsonrpc-types/src/primitive.rs
@@ -1,4 +1,4 @@
-use crate::{Uint32, Uint64};
+use crate::{Uint32, Uint64, Uint8};
 use ckb_types::core::EpochNumberWithFraction as CkbEpochNumberWithFraction;
 
 /// Consecutive block number starting from 0.
@@ -46,6 +46,12 @@ pub type Timestamp = Uint64;
 /// This is a 32-bit unsigned integer type encoded as the 0x-prefixed hex string in JSON. See examples of [Uint32](type.Uint32.html#examples).
 pub type Version = Uint32;
 
+/// The ckb-vm version.
+///
+/// This is a 8-bit unsigned integer type encoded as the 0x-prefixed hex string in JSON.
+/// See examples of [Uint8](type.Uint8.html#examples).
+pub type VmVersion = Uint8;
+
 /// This trait is a restriction for type `Uint64`, so we can only get epoch_number, epoch_index
 /// and epoch_length from the type `EpochNumberWithFraction` instead of all `Uint64`
 pub trait AsEpochNumberWithFraction {
diff --git a/util/jsonrpc-types/src/uints.rs b/util/jsonrpc-types/src/uints.rs
index 1a7104947c..15e2077188 100644
--- a/util/jsonrpc-types/src/uints.rs
+++ b/util/jsonrpc-types/src/uints.rs
@@ -15,7 +15,7 @@ pub trait Uint: Copy + fmt::LowerHex {
 }
 
 #[derive(Copy, Clone, Default, PartialEq, PartialOrd, Ord, Eq, Hash, Debug)]
-pub struct JsonUint<T: Uint>(T);
+pub struct JsonUint<T: Uint>(pub(crate) T);
 
 struct JsonUintVisitor<T: Uint>(marker::PhantomData<T>);
 
@@ -166,9 +166,11 @@ macro_rules! impl_pack_and_unpack {
     };
 }
 
+def_json_uint!(Uint8, u8, "8-bit");
 def_json_uint!(Uint32, u32, "32-bit");
 def_json_uint!(Uint64, u64, "64-bit");
 def_json_uint!(Uint128, u128, "128-bit");
+impl_serde_deserialize!(Uint8Visitor, u8);
 impl_serde_deserialize!(Uint32Visitor, u32);
 impl_serde_deserialize!(Uint64Visitor, u64);
 impl_serde_deserialize!(Uint128Visitor, u128);
@@ -176,6 +178,12 @@ impl_pack_and_unpack!(Uint32, u32);
 impl_pack_and_unpack!(Uint64, u64);
 impl_pack_and_unpack!(Uint128, u128);
 
+impl Uint8 {
+    pub(crate) fn is_default(&self) -> bool {
+        self.0 == 0
+    }
+}
+
 impl From<core::Capacity> for JsonUint<u64> {
     fn from(value: core::Capacity) -> Self {
         JsonUint(value.as_u64())
@@ -268,6 +276,7 @@ mod tests {
         };
     }
 
+    test_json_uint!(uint8, Uint8, u8);
     test_json_uint!(uint32, Uint32, u32);
     test_json_uint!(uint64, Uint64, u64);
     test_json_uint!(uint128, Uint128, u128);
diff --git a/util/test-chain-utils/src/chain.rs b/util/test-chain-utils/src/chain.rs
index 8eb73ddd86..0117e66b6c 100644
--- a/util/test-chain-utils/src/chain.rs
+++ b/util/test-chain-utils/src/chain.rs
@@ -37,7 +37,7 @@ lazy_static! {
             .build();
 
         let script = Script::new_builder()
-            .hash_type(ScriptHashType::Data.into())
+            .hash_type(ScriptHashType::Data(0).into())
             .code_hash(CellOutput::calc_data_hash(&data))
             .build();
 
@@ -75,7 +75,7 @@ lazy_static! {
             .build();
 
         let script = Script::new_builder()
-            .hash_type(ScriptHashType::Data.into())
+            .hash_type(ScriptHashType::Data(0).into())
             .code_hash(CellOutput::calc_data_hash(&data))
             .build();
 
@@ -118,7 +118,7 @@ lazy_static! {
             .build();
 
         let script = Script::new_builder()
-            .hash_type(ScriptHashType::Data.into())
+            .hash_type(ScriptHashType::Data(0).into())
             .code_hash(CellOutput::calc_data_hash(&data))
             .build();
 
diff --git a/util/types/src/core/blockchain.rs b/util/types/src/core/blockchain.rs
index b55d47aa3a..4ae9bd83cd 100644
--- a/util/types/src/core/blockchain.rs
+++ b/util/types/src/core/blockchain.rs
@@ -7,14 +7,14 @@ use crate::packed;
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
 pub enum ScriptHashType {
     /// TODO(doc): @quake
-    Data = 0,
+    Data(u8),
     /// TODO(doc): @quake
-    Type = 1,
+    Type,
 }
 
 impl Default for ScriptHashType {
     fn default() -> Self {
-        ScriptHashType::Data
+        ScriptHashType::Data(0)
     }
 }
 
@@ -23,7 +23,7 @@ impl TryFrom<packed::Byte> for ScriptHashType {
 
     fn try_from(v: packed::Byte) -> Result<Self, Self::Error> {
         match Into::<u8>::into(v) {
-            0 => Ok(ScriptHashType::Data),
+            x if x % 2 == 0 => Ok(ScriptHashType::Data(x / 2)),
             1 => Ok(ScriptHashType::Type),
             _ => Err(OtherError::new(format!("Invalid script hash type {}", v))),
         }
@@ -33,21 +33,24 @@ impl TryFrom<packed::Byte> for ScriptHashType {
 impl ScriptHashType {
     #[inline]
     pub(crate) fn verify_value(v: u8) -> bool {
-        v <= 1
+        v % 2 == 0 || v == 1
     }
 }
 
 impl Into<u8> for ScriptHashType {
     #[inline]
     fn into(self) -> u8 {
-        self as u8
+        match self {
+            Self::Data(v) => v * 2,
+            Self::Type => 1,
+        }
     }
 }
 
 impl Into<packed::Byte> for ScriptHashType {
     #[inline]
     fn into(self) -> packed::Byte {
-        (self as u8).into()
+        Into::<u8>::into(self).into()
     }
 }
 
diff --git a/util/types/src/core/hardfork.rs b/util/types/src/core/hardfork.rs
index cb4a0e98fd..fb8262cb31 100644
--- a/util/types/src/core/hardfork.rs
+++ b/util/types/src/core/hardfork.rs
@@ -98,6 +98,7 @@ pub struct HardForkSwitch {
     rfc_pr_0222: EpochNumber,
     rfc_pr_0223: EpochNumber,
     rfc_pr_0224: EpochNumber,
+    rfc_pr_0237: EpochNumber,
 }
 
 /// Builder for [`HardForkSwitch`].
@@ -124,6 +125,10 @@ pub struct HardForkSwitchBuilder {
     ///
     /// Ref: [CKB RFC xxxx](https://github.com/nervosnetwork/rfcs/tree/master/rfcs/xxxx-rfc-title)
     pub rfc_pr_0224: Option<EpochNumber>,
+    /// CKB VM version selection, vm version 1 and syscalls 2.
+    ///
+    /// Ref: [CKB RFC xxxx](https://github.com/nervosnetwork/rfcs/tree/master/rfcs/xxxx-rfc-title)
+    pub rfc_pr_0237: Option<EpochNumber>,
 }
 
 impl HardForkSwitch {
@@ -139,6 +144,7 @@ impl HardForkSwitch {
             .rfc_pr_0222(self.rfc_pr_0222())
             .rfc_pr_0223(self.rfc_pr_0223())
             .rfc_pr_0224(self.rfc_pr_0224())
+            .rfc_pr_0237(self.rfc_pr_0237())
     }
 
     /// Creates a new instance that all hard fork features are disabled forever.
@@ -149,6 +155,7 @@ impl HardForkSwitch {
             .disable_rfc_pr_0222()
             .disable_rfc_pr_0223()
             .disable_rfc_pr_0224()
+            .disable_rfc_pr_0237()
             .build()
             .unwrap()
     }
@@ -182,6 +189,13 @@ define_methods!(
     disable_rfc_pr_0224,
     "RFC PR 0224"
 );
+define_methods!(
+    rfc_pr_0237,
+    vm_version_1_and_syscalls_2,
+    is_vm_version_1_and_syscalls_2_enabled,
+    disable_rfc_pr_0237,
+    "RFC PR 0237"
+);
 
 impl HardForkSwitchBuilder {
     /// Build a new [`HardForkSwitch`].
@@ -202,11 +216,13 @@ impl HardForkSwitchBuilder {
         let rfc_pr_0222 = try_find!(rfc_pr_0222);
         let rfc_pr_0223 = try_find!(rfc_pr_0223);
         let rfc_pr_0224 = try_find!(rfc_pr_0224);
+        let rfc_pr_0237 = try_find!(rfc_pr_0237);
         Ok(HardForkSwitch {
             rfc_pr_0221,
             rfc_pr_0222,
             rfc_pr_0223,
             rfc_pr_0224,
+            rfc_pr_0237,
         })
     }
 }
diff --git a/util/types/src/extension/check_data.rs b/util/types/src/extension/check_data.rs
index a211dac0e2..dfdf359422 100644
--- a/util/types/src/extension/check_data.rs
+++ b/util/types/src/extension/check_data.rs
@@ -146,8 +146,8 @@ mod tests {
 
     #[test]
     fn check_data() {
-        let ht_right = 1.into();
-        let ht_error = 2.into();
+        let ht_right = 2.into();
+        let ht_error = 3.into();
         let dt_right = 1.into();
         let dt_error = 2.into();
 

From e4dac8a043e9fd240c0afc90f594b6413e97bca0 Mon Sep 17 00:00:00 2001
From: Boyu Yang <yangby@cryptape.com>
Date: Tue, 15 Jun 2021 15:34:15 +0800
Subject: [PATCH 06/14] feat(hardfork): reset scripts caches when a new feature
 enabled which mays change the script results

---
 tx-pool/src/component/container.rs | 17 +++++-
 tx-pool/src/component/pending.rs   |  7 +++
 tx-pool/src/component/proposed.rs  | 11 ++++
 tx-pool/src/pool.rs                |  7 +++
 tx-pool/src/process.rs             | 86 ++++++++++++++++++++++++++----
 util/types/src/core/hardfork.rs    | 12 +++++
 6 files changed, 130 insertions(+), 10 deletions(-)

diff --git a/tx-pool/src/component/container.rs b/tx-pool/src/component/container.rs
index 59f74debe0..097d3349a8 100644
--- a/tx-pool/src/component/container.rs
+++ b/tx-pool/src/component/container.rs
@@ -3,7 +3,7 @@
 
 use crate::{component::entry::TxEntry, error::Reject};
 use ckb_types::{
-    core::Capacity,
+    core::{Capacity, TransactionView},
     packed::{OutPoint, ProposalShortId},
 };
 use std::borrow::Cow;
@@ -184,6 +184,10 @@ impl TxLinksMap {
             .get_mut(short_id)
             .map(|links| links.children.insert(child))
     }
+
+    fn clear(&mut self) {
+        self.inner.clear();
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -395,6 +399,17 @@ impl SortedTxMap {
             .rev()
             .map(move |key| self.entries.get(&key.id).expect("consistent"))
     }
+
+    /// Clear and return all transactions.
+    pub(crate) fn drain(&mut self) -> Vec<TransactionView> {
+        self.sorted_index.clear();
+        self.deps.clear();
+        self.links.clear();
+        self.entries
+            .drain()
+            .map(|(_, entry)| entry.transaction().to_owned())
+            .collect()
+    }
 }
 
 #[cfg(test)]
diff --git a/tx-pool/src/component/pending.rs b/tx-pool/src/component/pending.rs
index c93edb935a..94fce3a26f 100644
--- a/tx-pool/src/component/pending.rs
+++ b/tx-pool/src/component/pending.rs
@@ -70,6 +70,13 @@ impl PendingQueue {
             }
         }
     }
+
+    pub(crate) fn drain(&mut self) -> Vec<TransactionView> {
+        self.inner
+            .values()
+            .map(|entry| entry.transaction().clone())
+            .collect()
+    }
 }
 
 impl CellProvider for PendingQueue {
diff --git a/tx-pool/src/component/proposed.rs b/tx-pool/src/component/proposed.rs
index d526169191..1dcd9fe611 100644
--- a/tx-pool/src/component/proposed.rs
+++ b/tx-pool/src/component/proposed.rs
@@ -88,6 +88,12 @@ impl Edges {
             self.deps.remove(out_point);
         }
     }
+
+    pub(crate) fn clear(&mut self) {
+        self.outputs.clear();
+        self.inputs.clear();
+        self.deps.clear();
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -307,6 +313,11 @@ impl ProposedPool {
     pub fn calc_descendants(&self, tx_short_id: &ProposalShortId) -> HashSet<ProposalShortId> {
         self.inner.calc_descendants(&tx_short_id)
     }
+
+    pub(crate) fn drain(&mut self) -> Vec<TransactionView> {
+        self.edges.clear();
+        self.inner.drain()
+    }
 }
 
 #[cfg(test)]
diff --git a/tx-pool/src/pool.rs b/tx-pool/src/pool.rs
index 2aa4a726af..501b380ab4 100644
--- a/tx-pool/src/pool.rs
+++ b/tx-pool/src/pool.rs
@@ -451,4 +451,11 @@ impl TxPool {
 
         TxPoolEntryInfo { pending, proposed }
     }
+
+    pub(crate) fn drain_all_transactions(&mut self) -> Vec<TransactionView> {
+        let mut txs = self.proposed.drain();
+        txs.append(&mut self.gap.drain());
+        txs.append(&mut self.pending.drain());
+        txs
+    }
 }
diff --git a/tx-pool/src/process.rs b/tx-pool/src/process.rs
index e881141032..25f0727e53 100644
--- a/tx-pool/src/process.rs
+++ b/tx-pool/src/process.rs
@@ -24,6 +24,7 @@ use ckb_types::{
             get_related_dep_out_points, OverlayCellChecker, ResolvedTransaction,
             TransactionsChecker,
         },
+        hardfork::HardForkSwitch,
         BlockView, Capacity, Cycle, EpochExt, HeaderView, ScriptHashType, TransactionView,
         UncleBlockView, Version,
     },
@@ -611,6 +612,11 @@ impl TxPoolService {
     ) {
         let mut detached = LinkedHashSet::default();
         let mut attached = LinkedHashSet::default();
+        let hardfork_switch = snapshot.consensus().hardfork_switch();
+        let hardfork_during_detach =
+            check_if_hardfork_during_blocks(&hardfork_switch, &detached_blocks);
+        let hardfork_during_attach =
+            check_if_hardfork_during_blocks(&hardfork_switch, &attached_blocks);
 
         for blk in detached_blocks {
             detached.extend(blk.transactions().into_iter().skip(1))
@@ -624,16 +630,33 @@ impl TxPoolService {
         let fetched_cache = self.fetch_txs_verify_cache(retain.iter()).await;
 
         {
-            let mut tx_pool = self.tx_pool.write().await;
-            _update_tx_pool_for_reorg(
-                &mut tx_pool,
-                &attached,
-                detached_proposal_id,
-                snapshot,
-                &self.callbacks,
-            );
+            let txs_opt = {
+                // This closure is used to limit the lifetime of mutable tx_pool.
+                let mut tx_pool = self.tx_pool.write().await;
+
+                let txs_opt = if hardfork_during_detach || hardfork_during_attach {
+                    // The tx_pool is locked, remove all caches if has any hardfork.
+                    self.txs_verify_cache.write().await.clear();
+                    Some(tx_pool.drain_all_transactions())
+                } else {
+                    None
+                };
+
+                _update_tx_pool_for_reorg(
+                    &mut tx_pool,
+                    &attached,
+                    detached_proposal_id,
+                    snapshot,
+                    &self.callbacks,
+                );
+                self.readd_dettached_tx(&mut tx_pool, retain, fetched_cache);
+
+                txs_opt
+            };
 
-            self.readd_dettached_tx(&mut tx_pool, retain, fetched_cache)
+            if let Some(txs) = txs_opt {
+                self.try_process_txs(txs).await;
+            }
         }
 
         {
@@ -671,6 +694,23 @@ impl TxPoolService {
         }
     }
 
+    // # Notice
+    //
+    // This method assumes that the inputs transactions are sorted.
+    async fn try_process_txs(&self, txs: Vec<TransactionView>) {
+        if txs.is_empty() {
+            return;
+        }
+        let total = txs.len();
+        let mut count = 0usize;
+        for tx in txs {
+            if self._process_tx(tx, None).await.is_err() {
+                count += 1;
+            }
+        }
+        info!("{}/{} transactions are failed to process", count, total);
+    }
+
     pub(crate) async fn clear_pool(&mut self, new_snapshot: Arc<Snapshot>) {
         let mut tx_pool = self.tx_pool.write().await;
         let config = tx_pool.config;
@@ -833,3 +873,31 @@ fn _update_tx_pool_for_reorg(
         }
     }
 }
+
+// # Notice
+//
+// This method assumes that the inputs blocks are sorted.
+fn check_if_hardfork_during_blocks(
+    hardfork_switch: &HardForkSwitch,
+    blocks: &VecDeque<BlockView>,
+) -> bool {
+    if blocks.is_empty() {
+        false
+    } else {
+        // This method assumes that the hardfork epochs are sorted and unique.
+        let hardfork_epochs = hardfork_switch.script_result_changed_at();
+        if hardfork_epochs.is_empty() {
+            false
+        } else {
+            let epoch_first = blocks.front().unwrap().epoch().number();
+            let epoch_next = blocks
+                .back()
+                .unwrap()
+                .epoch()
+                .minimum_epoch_number_after_n_blocks(1);
+            hardfork_epochs
+                .into_iter()
+                .any(|hardfork_epoch| epoch_first < hardfork_epoch && hardfork_epoch <= epoch_next)
+        }
+    }
+}
diff --git a/util/types/src/core/hardfork.rs b/util/types/src/core/hardfork.rs
index fb8262cb31..118c051e55 100644
--- a/util/types/src/core/hardfork.rs
+++ b/util/types/src/core/hardfork.rs
@@ -159,6 +159,18 @@ impl HardForkSwitch {
             .build()
             .unwrap()
     }
+
+    /// Returns a vector of epoch numbers, and there are new features which
+    /// require refrese tx-pool caches will be enabled at those epochs.
+    pub fn script_result_changed_at(&self) -> Vec<EpochNumber> {
+        let mut epochs = vec![self.rfc_pr_0237()];
+        // In future, there could be more than one epoch,
+        // we should merge the same epochs and sort all epochs.
+        //epochs.sort_unstable();
+        //epochs.dedup();
+        epochs.retain(|&x| x != 0);
+        epochs
+    }
 }
 
 define_methods!(

From af792f2f766cc49ff24cb7aad5e0eb4e21955239 Mon Sep 17 00:00:00 2001
From: Boyu Yang <yangby@cryptape.com>
Date: Thu, 17 Jun 2021 12:16:11 +0800
Subject: [PATCH 07/14] fix(hardfork): `ckb init` will panic when specifies
 arguments for "block_assembler"

---
 ckb-bin/src/subcommand/init.rs       | 61 ++++++++++++++++++++--------
 util/app-config/src/args.rs          |  6 ++-
 util/app-config/src/cli.rs           |  9 ++++
 util/app-config/src/lib.rs           | 10 ++++-
 util/jsonrpc-types/src/blockchain.rs | 11 ++++-
 5 files changed, 74 insertions(+), 23 deletions(-)

diff --git a/ckb-bin/src/subcommand/init.rs b/ckb-bin/src/subcommand/init.rs
index d2b99a79c2..ab127febc1 100644
--- a/ckb-bin/src/subcommand/init.rs
+++ b/ckb-bin/src/subcommand/init.rs
@@ -4,7 +4,7 @@ use std::io::{self, Read};
 use crate::helper::prompt;
 use ckb_app_config::{cli, AppConfig, ExitCode, InitArgs};
 use ckb_chain_spec::ChainSpec;
-use ckb_jsonrpc_types::ScriptHashType;
+use ckb_jsonrpc_types::{ScriptHashTypeShadow, VmVersion};
 use ckb_resource::{
     Resource, TemplateContext, AVAILABLE_SPECS, CKB_CONFIG_FILE_NAME, DB_OPTIONS_FILE_NAME,
     MINER_CONFIG_FILE_NAME, SPEC_DEV_FILE_NAME,
@@ -48,7 +48,6 @@ pub fn init(args: InitArgs) -> Result<(), ExitCode> {
         let in_block_assembler_code_hash = prompt("code hash: ");
         let in_args = prompt("args: ");
         let in_hash_type = prompt("hash_type: ");
-        let in_message = prompt("message: ");
 
         args.block_assembler_code_hash = Some(in_block_assembler_code_hash.trim().to_string());
 
@@ -58,12 +57,21 @@ pub fn init(args: InitArgs) -> Result<(), ExitCode> {
             .map(|s| s.to_string())
             .collect::<Vec<String>>();
 
-        args.block_assembler_message = Some(in_message.trim().to_string());
-
-        match serde_plain::from_str::<ScriptHashType>(in_hash_type.trim()).ok() {
+        match serde_plain::from_str::<ScriptHashTypeShadow>(in_hash_type.trim()).ok() {
             Some(hash_type) => args.block_assembler_hash_type = hash_type,
             None => eprintln!("Invalid block assembler hash type"),
         }
+
+        if args.block_assembler_hash_type == ScriptHashTypeShadow::Type {
+            let in_vm_version = prompt("vm_version: ");
+            match serde_plain::from_str::<VmVersion>(in_vm_version.trim()).ok() {
+                Some(vm_version) => args.block_assembler_vm_version = Some(vm_version),
+                None => eprintln!("Invalid block assembler vm version"),
+            }
+        }
+
+        let in_message = prompt("message: ");
+        args.block_assembler_message = Some(in_message.trim().to_string());
     }
 
     // Try to find the default secp256k1 from bundled chain spec.
@@ -90,7 +98,7 @@ pub fn init(args: InitArgs) -> Result<(), ExitCode> {
     let block_assembler = match block_assembler_code_hash {
         Some(hash) => {
             if let Some(default_code_hash) = &default_code_hash_option {
-                if ScriptHashType::Type != args.block_assembler_hash_type {
+                if ScriptHashTypeShadow::Type != args.block_assembler_hash_type {
                     eprintln!(
                         "WARN: the default lock should use hash type `{}`, you are using `{}`.\n\
                          It will require `ckb run --ba-advanced` to enable this block assembler",
@@ -111,18 +119,35 @@ pub fn init(args: InitArgs) -> Result<(), ExitCode> {
                     );
                 }
             }
-            format!(
-                "[block_assembler]\n\
-                 code_hash = \"{}\"\n\
-                 args = \"{}\"\n\
-                 hash_type = \"{}\"\n\
-                 message = \"{}\"",
-                hash,
-                args.block_assembler_args.join("\", \""),
-                serde_plain::to_string(&args.block_assembler_hash_type).unwrap(),
-                args.block_assembler_message
-                    .unwrap_or_else(|| "0x".to_string()),
-            )
+            if let Some(default_vm_version) = &args.block_assembler_vm_version {
+                format!(
+                    "[block_assembler]\n\
+                    code_hash = \"{}\"\n\
+                    args = \"{}\"\n\
+                    hash_type = \"{}\"\n\
+                    vm_version = \"{}\"\n\
+                    message = \"{}\"",
+                    hash,
+                    args.block_assembler_args.join("\", \""),
+                    args.block_assembler_hash_type,
+                    serde_plain::to_string(&default_vm_version).unwrap(),
+                    args.block_assembler_message
+                        .unwrap_or_else(|| "0x".to_string()),
+                )
+            } else {
+                format!(
+                    "[block_assembler]\n\
+                    code_hash = \"{}\"\n\
+                    args = \"{}\"\n\
+                    hash_type = \"{}\"\n\
+                    message = \"{}\"",
+                    hash,
+                    args.block_assembler_args.join("\", \""),
+                    args.block_assembler_hash_type,
+                    args.block_assembler_message
+                        .unwrap_or_else(|| "0x".to_string()),
+                )
+            }
         }
         None => {
             eprintln!("WARN: mining feature is disabled because of lacking the block assembler config options");
diff --git a/util/app-config/src/args.rs b/util/app-config/src/args.rs
index 28f2d4301b..76160e3452 100644
--- a/util/app-config/src/args.rs
+++ b/util/app-config/src/args.rs
@@ -1,6 +1,6 @@
 use crate::{CKBAppConfig, MemoryTrackerConfig, MinerConfig};
 use ckb_chain_spec::consensus::Consensus;
-use ckb_jsonrpc_types::ScriptHashType;
+use ckb_jsonrpc_types::{ScriptHashTypeShadow, VmVersion};
 use ckb_pow::PowEngine;
 use ckb_types::packed::Byte32;
 use faketime::unix_time_as_millis;
@@ -114,7 +114,9 @@ pub struct InitArgs {
     /// Block assembler lock script args.
     pub block_assembler_args: Vec<String>,
     /// Block assembler lock script hash type.
-    pub block_assembler_hash_type: ScriptHashType,
+    pub block_assembler_hash_type: ScriptHashTypeShadow,
+    /// Block assembler lock script vm version when hash type is "data".
+    pub block_assembler_vm_version: Option<VmVersion>,
     /// Block assembler cellbase transaction message.
     pub block_assembler_message: Option<String>,
     /// Import the spec file.
diff --git a/util/app-config/src/cli.rs b/util/app-config/src/cli.rs
index a311536148..041effadd2 100644
--- a/util/app-config/src/cli.rs
+++ b/util/app-config/src/cli.rs
@@ -68,6 +68,8 @@ pub const ARG_BA_CODE_HASH: &str = "ba-code-hash";
 pub const ARG_BA_ARG: &str = "ba-arg";
 /// Command line argument `--ba-hash-type`.
 pub const ARG_BA_HASH_TYPE: &str = "ba-hash-type";
+/// Command line argument `--ba-vm-version`.
+pub const ARG_BA_VM_VERSION: &str = "ba-vm-version";
 /// Command line argument `--ba-message`.
 pub const ARG_BA_MESSAGE: &str = "ba-message";
 /// Command line argument `--ba-advanced`.
@@ -450,6 +452,13 @@ fn init() -> App<'static, 'static> {
                 .default_value("type")
                 .help("Sets hash type in [block_assembler]"),
         )
+        .arg(
+            Arg::with_name(ARG_BA_VM_VERSION)
+                .long(ARG_BA_VM_VERSION)
+                .value_name("vm_version")
+                .takes_value(true)
+                .help("Sets vm version for data hash-type script in [block_assembler]"),
+        )
         .group(
             ArgGroup::with_name(GROUP_BA)
                 .args(&[ARG_BA_CODE_HASH, ARG_BA_ARG])
diff --git a/util/app-config/src/lib.rs b/util/app-config/src/lib.rs
index af7389c155..f25882b9d8 100644
--- a/util/app-config/src/lib.rs
+++ b/util/app-config/src/lib.rs
@@ -16,7 +16,7 @@ pub use configs::*;
 pub use exit_code::ExitCode;
 
 use ckb_chain_spec::{consensus::Consensus, ChainSpec};
-use ckb_jsonrpc_types::ScriptHashType;
+use ckb_jsonrpc_types::{ScriptHashTypeShadow, VmVersion};
 use ckb_types::{u256, H256, U256};
 use clap::{value_t, ArgMatches, ErrorKind};
 use std::{path::PathBuf, str::FromStr};
@@ -246,7 +246,12 @@ impl Setup {
             .collect();
         let block_assembler_hash_type = matches
             .value_of(cli::ARG_BA_HASH_TYPE)
-            .and_then(|hash_type| serde_plain::from_str::<ScriptHashType>(hash_type).ok())
+            .and_then(|hash_type| serde_plain::from_str::<ScriptHashTypeShadow>(hash_type).ok())
+            .unwrap();
+        let block_assembler_vm_version = matches
+            .value_of(cli::ARG_BA_VM_VERSION)
+            .map(|vm_version| serde_plain::from_str::<VmVersion>(vm_version))
+            .transpose()
             .unwrap();
         let block_assembler_message = matches.value_of(cli::ARG_BA_MESSAGE).map(str::to_string);
 
@@ -272,6 +277,7 @@ impl Setup {
             block_assembler_code_hash,
             block_assembler_args,
             block_assembler_hash_type,
+            block_assembler_vm_version,
             block_assembler_message,
             import_spec,
             customize_spec,
diff --git a/util/jsonrpc-types/src/blockchain.rs b/util/jsonrpc-types/src/blockchain.rs
index 517b42908c..585d1e253b 100644
--- a/util/jsonrpc-types/src/blockchain.rs
+++ b/util/jsonrpc-types/src/blockchain.rs
@@ -29,7 +29,7 @@ pub enum ScriptHashType {
 }
 
 #[doc(hidden)]
-#[derive(Deserialize)]
+#[derive(Clone, Copy, Deserialize, PartialEq, Eq, Hash, Debug)]
 #[serde(rename_all = "snake_case")]
 pub enum ScriptHashTypeShadow {
     Data,
@@ -75,6 +75,15 @@ impl fmt::Display for ScriptHashType {
     }
 }
 
+impl fmt::Display for ScriptHashTypeShadow {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        match self {
+            ScriptHashTypeShadow::Data => write!(f, "data"),
+            ScriptHashTypeShadow::Type => write!(f, "type"),
+        }
+    }
+}
+
 /// Describes the lock script and type script for a cell.
 ///
 /// ## Examples

From 7fc2e6c3a64925523b299d359f05ac08ac0a55f8 Mon Sep 17 00:00:00 2001
From: Boyu Yang <yangby@cryptape.com>
Date: Thu, 17 Jun 2021 13:21:27 +0800
Subject: [PATCH 08/14] chore(deps): bump ckb-vm from 0.20.0-alpha to
 0.20.0-alpha2 and ring from 0.16.12 to 0.16.20

---
 Cargo.lock                  | 33 +++++++++-----
 script/Cargo.toml           |  4 +-
 script/src/syscalls/exec.rs |  5 ++-
 script/src/syscalls/mod.rs  | 90 ++++++++++++++++++++++++++++++-------
 4 files changed, 102 insertions(+), 30 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4b8ffb6c51..094142c51f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -326,11 +326,11 @@ checksum = "926013f2860c46252efceabb19f4a6b308197505082c609025aa6706c011d427"
 
 [[package]]
 name = "cc"
-version = "1.0.38"
+version = "1.0.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce400c638d48ee0e9ab75aef7997609ec57367ccfe1463f21bf53c3eca67bf46"
+checksum = "4a72c244c1ff497a746a7e1fb3d14bd08420ecda70c8f25c7112f2781652d787"
 dependencies = [
- "rayon",
+ "jobserver",
 ]
 
 [[package]]
@@ -1494,9 +1494,9 @@ dependencies = [
 
 [[package]]
 name = "ckb-vm"
-version = "0.20.0-alpha"
+version = "0.20.0-alpha2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca63668a4a96a895c5324edbc3f827781d043a79d82789d590f7d611ce9dff4a"
+checksum = "324a45880b65710f2dd5398ec6e941c96cedd764571e85be54b243422f228e75"
 dependencies = [
  "byteorder",
  "bytes 1.0.1",
@@ -1514,9 +1514,9 @@ dependencies = [
 
 [[package]]
 name = "ckb-vm-definitions"
-version = "0.20.0-alpha"
+version = "0.20.0-alpha2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1983bc408f08c00d8907e602f24bb54caf7b9aadbdbb20624d24a2a2fc6e3efb"
+checksum = "df4d41afe817d71386d4c8bbbc5ec75d80e53b8a01da7b477c4848000cb13e7d"
 
 [[package]]
 name = "clap"
@@ -2963,6 +2963,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "jobserver"
+version = "0.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "972f5ae5d1cb9c6ae417789196c803205313edde988685da5e3aae0827b9e7fd"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "js-sys"
 version = "0.3.45"
@@ -4366,13 +4375,13 @@ dependencies = [
 
 [[package]]
 name = "ring"
-version = "0.16.12"
+version = "0.16.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ba5a8ec64ee89a76c98c549af81ff14813df09c3e6dc4766c3856da48597a0c"
+checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
 dependencies = [
  "cc",
- "lazy_static",
  "libc",
+ "once_cell",
  "spin",
  "untrusted",
  "web-sys",
@@ -5302,9 +5311,9 @@ checksum = "35581ff83d4101e58b582e607120c7f5ffb17e632a980b1f38334d76b36908b2"
 
 [[package]]
 name = "untrusted"
-version = "0.7.0"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60369ef7a31de49bcb3f6ca728d4ba7300d9a1658f94c727d4cab8c8d9f4aece"
+checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
 
 [[package]]
 name = "uom"
diff --git a/script/Cargo.toml b/script/Cargo.toml
index f9d9c41ef4..8dc0a28bd9 100644
--- a/script/Cargo.toml
+++ b/script/Cargo.toml
@@ -21,8 +21,8 @@ ckb-traits = { path = "../traits", version = "= 0.43.0-pre" }
 byteorder = "1.3.1"
 ckb-types = {path = "../util/types", version = "= 0.43.0-pre"}
 ckb-hash = {path = "../util/hash", version = "= 0.43.0-pre"}
-ckb-vm-definitions = "0.20.0-alpha"
-ckb-vm = { version = "0.20.0-alpha", default-features = false }
+ckb-vm-definitions = "0.20.0-alpha2"
+ckb-vm = { version = "0.20.0-alpha2", default-features = false }
 faster-hex = "0.6"
 ckb-logger = { path = "../util/logger", version = "= 0.43.0-pre", optional = true }
 serde = { version = "1.0", features = ["derive"] }
diff --git a/script/src/syscalls/exec.rs b/script/src/syscalls/exec.rs
index 88d9aa7a34..b692f9a58f 100644
--- a/script/src/syscalls/exec.rs
+++ b/script/src/syscalls/exec.rs
@@ -164,7 +164,10 @@ impl<'a, Mac: SupportMachine, DL: CellDataProvider> Syscalls<Mac> for Exec<'a, D
             addr += 8;
         }
 
-        machine.reset();
+        let cycles = machine.cycles();
+        let max_cycles = machine.max_cycles();
+        machine.reset(max_cycles);
+        machine.set_cycles(cycles);
 
         match machine.load_elf(&data, true) {
             Ok(size) => {
diff --git a/script/src/syscalls/mod.rs b/script/src/syscalls/mod.rs
index b9f605fdaa..1b8921885c 100644
--- a/script/src/syscalls/mod.rs
+++ b/script/src/syscalls/mod.rs
@@ -249,7 +249,11 @@ mod tests {
     }
 
     fn _test_load_cell_not_exist(data: &[u8]) -> Result<(), TestCaseError> {
-        let mut machine = DefaultCoreMachine::<u64, SparseMemory<u64>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let size_addr: u64 = 0;
         let addr: u64 = 100;
 
@@ -297,7 +301,11 @@ mod tests {
     }
 
     fn _test_load_cell_all(data: &[u8]) -> Result<(), TestCaseError> {
-        let mut machine = DefaultCoreMachine::<u64, SparseMemory<u64>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let size_addr: u64 = 0;
         let addr: u64 = 100;
 
@@ -388,7 +396,11 @@ mod tests {
     }
 
     fn _test_load_cell_length(data: &[u8]) -> Result<(), TestCaseError> {
-        let mut machine = DefaultCoreMachine::<u64, SparseMemory<u64>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let size_addr: u64 = 0;
         let addr: u64 = 100;
 
@@ -440,7 +452,11 @@ mod tests {
     }
 
     fn _test_load_cell_partial(data: &[u8], offset: u64) -> Result<(), TestCaseError> {
-        let mut machine = DefaultCoreMachine::<u64, SparseMemory<u64>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let size_addr: u64 = 0;
         let addr: u64 = 100;
 
@@ -500,7 +516,11 @@ mod tests {
     }
 
     fn _test_load_cell_capacity(capacity: Capacity) -> Result<(), TestCaseError> {
-        let mut machine = DefaultCoreMachine::<u64, SparseMemory<u64>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let size_addr: u64 = 0;
         let addr: u64 = 100;
 
@@ -562,7 +582,11 @@ mod tests {
 
     #[test]
     fn test_load_missing_contract() {
-        let mut machine = DefaultCoreMachine::<u64, SparseMemory<u64>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let size_addr: u64 = 0;
         let addr: u64 = 100;
 
@@ -603,7 +627,11 @@ mod tests {
     }
 
     fn _test_load_header(data: &[u8]) -> Result<(), TestCaseError> {
-        let mut machine = DefaultCoreMachine::<u64, SparseMemory<u64>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let size_addr: u64 = 0;
         let addr: u64 = 100;
 
@@ -667,7 +695,11 @@ mod tests {
     }
 
     fn _test_load_epoch_number(data: &[u8]) -> Result<(), TestCaseError> {
-        let mut machine = DefaultCoreMachine::<u64, SparseMemory<u64>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let size_addr: u64 = 0;
         let addr: u64 = 100;
 
@@ -728,7 +760,11 @@ mod tests {
     }
 
     fn _test_load_tx_hash(data: &[u8]) -> Result<(), TestCaseError> {
-        let mut machine = DefaultCoreMachine::<u64, SparseMemory<u64>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let size_addr: u64 = 0;
         let addr: u64 = 100;
 
@@ -772,7 +808,11 @@ mod tests {
     }
 
     fn _test_load_tx(data: &[u8]) -> Result<(), TestCaseError> {
-        let mut machine = DefaultCoreMachine::<u64, SparseMemory<u64>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let size_addr: u64 = 0;
         let addr: u64 = 100;
 
@@ -816,7 +856,11 @@ mod tests {
     }
 
     fn _test_load_current_script_hash(data: &[u8]) -> Result<(), TestCaseError> {
-        let mut machine = DefaultCoreMachine::<u64, SparseMemory<u64>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let size_addr: u64 = 0;
         let addr: u64 = 100;
 
@@ -868,7 +912,11 @@ mod tests {
     }
 
     fn _test_load_input_lock_script_hash(data: &[u8]) -> Result<(), TestCaseError> {
-        let mut machine = DefaultCoreMachine::<u64, SparseMemory<u64>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let size_addr: u64 = 0;
         let addr: u64 = 100;
 
@@ -934,7 +982,11 @@ mod tests {
     }
 
     fn _test_load_witness(data: &[u8], source: SourceEntry) -> Result<(), TestCaseError> {
-        let mut machine = DefaultCoreMachine::<u64, SparseMemory<u64>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let size_addr: u64 = 0;
         let addr: u64 = 100;
 
@@ -989,7 +1041,11 @@ mod tests {
     }
 
     fn _test_load_group_witness(data: &[u8], source: SourceEntry) -> Result<(), TestCaseError> {
-        let mut machine = DefaultCoreMachine::<u64, SparseMemory<u64>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let size_addr: u64 = 0;
         let addr: u64 = 100;
 
@@ -1044,7 +1100,11 @@ mod tests {
     }
 
     fn _test_load_script(data: &[u8]) -> Result<(), TestCaseError> {
-        let mut machine = DefaultCoreMachine::<u64, SparseMemory<u64>>::default();
+        let mut machine = DefaultCoreMachine::<u64, WXorXMemory<SparseMemory<u64>>>::new(
+            ISA_IMC,
+            VERSION0,
+            u64::max_value(),
+        );
         let size_addr: u64 = 0;
         let addr: u64 = 100;
 

From db218247f6e9cf708511a71f88fd2fd7d4c81fbd Mon Sep 17 00:00:00 2001
From: Boyu Yang <yangby@cryptape.com>
Date: Wed, 23 Jun 2021 17:38:07 +0800
Subject: [PATCH 09/14] fix(hardfork): tx-pool drain the proposed in the
 incorrect order and not clear pending

---
 tx-pool/src/component/container.rs | 10 +++-------
 tx-pool/src/component/pending.rs   |  7 +++++--
 tx-pool/src/component/proposed.rs  |  4 ++--
 tx-pool/src/pool.rs                | 10 ++++++++--
 4 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/tx-pool/src/component/container.rs b/tx-pool/src/component/container.rs
index 097d3349a8..a8e8300571 100644
--- a/tx-pool/src/component/container.rs
+++ b/tx-pool/src/component/container.rs
@@ -3,7 +3,7 @@
 
 use crate::{component::entry::TxEntry, error::Reject};
 use ckb_types::{
-    core::{Capacity, TransactionView},
+    core::Capacity,
     packed::{OutPoint, ProposalShortId},
 };
 use std::borrow::Cow;
@@ -400,15 +400,11 @@ impl SortedTxMap {
             .map(move |key| self.entries.get(&key.id).expect("consistent"))
     }
 
-    /// Clear and return all transactions.
-    pub(crate) fn drain(&mut self) -> Vec<TransactionView> {
+    pub(crate) fn clear(&mut self) {
         self.sorted_index.clear();
         self.deps.clear();
         self.links.clear();
-        self.entries
-            .drain()
-            .map(|(_, entry)| entry.transaction().to_owned())
-            .collect()
+        self.entries.clear();
     }
 }
 
diff --git a/tx-pool/src/component/pending.rs b/tx-pool/src/component/pending.rs
index 94fce3a26f..fb75dd90e3 100644
--- a/tx-pool/src/component/pending.rs
+++ b/tx-pool/src/component/pending.rs
@@ -72,10 +72,13 @@ impl PendingQueue {
     }
 
     pub(crate) fn drain(&mut self) -> Vec<TransactionView> {
-        self.inner
+        let txs = self
+            .inner
             .values()
             .map(|entry| entry.transaction().clone())
-            .collect()
+            .collect::<Vec<_>>();
+        self.inner.clear();
+        txs
     }
 }
 
diff --git a/tx-pool/src/component/proposed.rs b/tx-pool/src/component/proposed.rs
index 1dcd9fe611..25b944c2bd 100644
--- a/tx-pool/src/component/proposed.rs
+++ b/tx-pool/src/component/proposed.rs
@@ -314,9 +314,9 @@ impl ProposedPool {
         self.inner.calc_descendants(&tx_short_id)
     }
 
-    pub(crate) fn drain(&mut self) -> Vec<TransactionView> {
+    pub(crate) fn clear(&mut self) {
         self.edges.clear();
-        self.inner.drain()
+        self.inner.clear();
     }
 }
 
diff --git a/tx-pool/src/pool.rs b/tx-pool/src/pool.rs
index 501b380ab4..9426c857a9 100644
--- a/tx-pool/src/pool.rs
+++ b/tx-pool/src/pool.rs
@@ -1,5 +1,5 @@
 //! Top-level Pool type, methods, and tests
-use super::component::TxEntry;
+use super::component::{commit_txs_scanner::CommitTxsScanner, TxEntry};
 use crate::callback::Callbacks;
 use crate::component::pending::PendingQueue;
 use crate::component::proposed::ProposedPool;
@@ -453,7 +453,13 @@ impl TxPool {
     }
 
     pub(crate) fn drain_all_transactions(&mut self) -> Vec<TransactionView> {
-        let mut txs = self.proposed.drain();
+        let mut txs = CommitTxsScanner::new(&self.proposed)
+            .txs_to_commit(self.total_tx_size, self.total_tx_cycles)
+            .0
+            .into_iter()
+            .map(|tx_entry| tx_entry.rtx.transaction)
+            .collect::<Vec<_>>();
+        self.proposed.clear();
         txs.append(&mut self.gap.drain());
         txs.append(&mut self.pending.drain());
         txs

From db2caca017fe2194702676952e137bb94b1379a9 Mon Sep 17 00:00:00 2001
From: Boyu Yang <yangby@cryptape.com>
Date: Tue, 29 Jun 2021 13:14:47 +0800
Subject: [PATCH 10/14] feat(hardfork): add the "edition" field to all
 configuration files

---
 ckb-bin/src/subcommand/list_hashes.rs |   2 +-
 docs/hashes.toml                      |   2 +-
 resource/ckb-miner.toml               |   6 ++
 resource/ckb.toml                     |   6 ++
 resource/specs/dev.toml               |   6 ++
 spec/src/legacy/mod.rs                |  12 +++
 spec/src/legacy/v2019.rs              |  38 +++++++++
 spec/src/lib.rs                       |  48 +++++++++--
 test/src/node.rs                      |  21 +++--
 util/app-config/src/app_config.rs     |  55 ++++++++++--
 util/app-config/src/legacy/mod.rs     |  12 +++
 util/app-config/src/legacy/v2019.rs   | 117 ++++++++++++++++++++++++++
 util/app-config/src/lib.rs            |   7 +-
 util/app-config/src/sentry_config.rs  |   2 +
 util/jsonrpc-types/src/hardfork.rs    |  12 +++
 util/jsonrpc-types/src/lib.rs         |   2 +
 16 files changed, 317 insertions(+), 31 deletions(-)
 create mode 100644 spec/src/legacy/mod.rs
 create mode 100644 spec/src/legacy/v2019.rs
 create mode 100644 util/app-config/src/legacy/mod.rs
 create mode 100644 util/app-config/src/legacy/v2019.rs
 create mode 100644 util/jsonrpc-types/src/hardfork.rs

diff --git a/ckb-bin/src/subcommand/list_hashes.rs b/ckb-bin/src/subcommand/list_hashes.rs
index bc8da3e277..feb3aaa566 100644
--- a/ckb-bin/src/subcommand/list_hashes.rs
+++ b/ckb-bin/src/subcommand/list_hashes.rs
@@ -130,7 +130,7 @@ pub fn list_hashes(root_dir: PathBuf, matches: &ArgMatches<'_>) -> Result<(), Ex
             resource = Resource::bundled_ckb_config();
         }
 
-        let mut config: CKBAppConfig = toml::from_slice(&resource.get()?)?;
+        let mut config = CKBAppConfig::load_from_slice(&resource.get()?)?;
         config.chain.spec.absolutize(&root_dir);
         let chain_spec = ChainSpec::load_from(&config.chain.spec).map_err(to_config_error)?;
         let spec_name = chain_spec.name.clone();
diff --git a/docs/hashes.toml b/docs/hashes.toml
index 2961520da3..f618f58d68 100644
--- a/docs/hashes.toml
+++ b/docs/hashes.toml
@@ -134,7 +134,7 @@ index = 1
 
 # Spec: ckb_dev
 [ckb_dev]
-spec_hash = "0xa8d7ab92196638cd091d49aa76849f6f102d8082eb374f089477d9c50a4bd2f1"
+spec_hash = "0xc98d591b33910a66fbdecf1c40c430876152dd325cc0a32863e2eedf9255280a"
 genesis = "0x823b2ff5785b12da8b1363cac9a5cbe566d8b715a4311441b119c39a0367488c"
 cellbase = "0xa563884b3686078ec7e7677a5f86449b15cf2693f3c1241766c6996f206cc541"
 
diff --git a/resource/ckb-miner.toml b/resource/ckb-miner.toml
index a8caf41576..1b8389f83c 100644
--- a/resource/ckb-miner.toml
+++ b/resource/ckb-miner.toml
@@ -5,6 +5,12 @@
 # staging => # Config generated by `ckb init --chain staging`
 # }}
 
+# Choose the edition, possible values:
+# - "2019"
+# - "2021"
+# The default is "2019", the latest is "2021".
+edition = "2021"
+
 data_dir = "data"
 
 [chain]
diff --git a/resource/ckb.toml b/resource/ckb.toml
index ead6aa2c4e..21d427e557 100644
--- a/resource/ckb.toml
+++ b/resource/ckb.toml
@@ -5,6 +5,12 @@
 # staging => # Config generated by `ckb init --chain staging`
 # }}
 
+# Choose the edition, possible values:
+# - "2019"
+# - "2021"
+# The default is "2019", the latest is "2021".
+edition = "2021"
+
 data_dir = "data"
 
 [chain]
diff --git a/resource/specs/dev.toml b/resource/specs/dev.toml
index 9a3801eddb..8498580d04 100644
--- a/resource/specs/dev.toml
+++ b/resource/specs/dev.toml
@@ -1,5 +1,11 @@
 name = "ckb_dev"
 
+# Choose the edition, possible values:
+# - "2019"
+# - "2021"
+# The default is "2019", the latest is "2021".
+edition = "2021"
+
 [genesis]
 version = 0
 parent_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
diff --git a/spec/src/legacy/mod.rs b/spec/src/legacy/mod.rs
new file mode 100644
index 0000000000..3709066da3
--- /dev/null
+++ b/spec/src/legacy/mod.rs
@@ -0,0 +1,12 @@
+//! Legacy CKB Chain Specification
+
+use ckb_jsonrpc_types::ChainEdition;
+use serde::{Deserialize, Serialize};
+
+pub(crate) mod v2019;
+
+/// The partial CKB block chain specification
+#[derive(Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
+pub(crate) struct PartialChainSpec {
+    pub(crate) edition: Option<ChainEdition>,
+}
diff --git a/spec/src/legacy/v2019.rs b/spec/src/legacy/v2019.rs
new file mode 100644
index 0000000000..c14d4891ef
--- /dev/null
+++ b/spec/src/legacy/v2019.rs
@@ -0,0 +1,38 @@
+//! Legacy CKB Chain Specification (Edition 2019)
+
+use ckb_jsonrpc_types as rpc;
+use ckb_pow::Pow;
+use ckb_types::packed;
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub(crate) struct ChainSpec {
+    name: String,
+    pub(crate) genesis: crate::Genesis,
+    #[serde(default)]
+    params: crate::Params,
+    pow: Pow,
+    #[serde(skip)]
+    pub(crate) hash: packed::Byte32,
+}
+
+impl From<ChainSpec> for crate::ChainSpec {
+    fn from(input: ChainSpec) -> Self {
+        let ChainSpec {
+            name,
+            genesis,
+            params,
+            pow,
+            hash,
+        } = input;
+        Self {
+            name,
+            edition: rpc::ChainEdition::V2021,
+            genesis,
+            params,
+            pow,
+            hash,
+            legacy: true,
+        }
+    }
+}
diff --git a/spec/src/lib.rs b/spec/src/lib.rs
index 13cb4eb560..7ac3f572a8 100644
--- a/spec/src/lib.rs
+++ b/spec/src/lib.rs
@@ -16,7 +16,7 @@ use crate::consensus::{
 };
 use ckb_crypto::secp::Privkey;
 use ckb_hash::{blake2b_256, new_blake2b};
-use ckb_jsonrpc_types::Script;
+use ckb_jsonrpc_types::{ChainEdition, Script};
 use ckb_pow::{Pow, PowEngine};
 use ckb_resource::{
     Resource, CODE_HASH_DAO, CODE_HASH_SECP256K1_BLAKE160_MULTISIG_ALL,
@@ -46,6 +46,7 @@ pub use hardfork::HardForkConfig;
 pub mod consensus;
 mod error;
 mod hardfork;
+mod legacy;
 
 // Just a random secp256k1 secret key for dep group input cell's lock
 const SPECIAL_CELL_PRIVKEY: H256 =
@@ -65,6 +66,8 @@ pub const OUTPUT_INDEX_SECP256K1_BLAKE160_MULTISIG_ALL: u64 = 4;
 pub struct ChainSpec {
     /// The spec name, also used identify network
     pub name: String,
+    /// The edition of CKB block chain specification
+    pub edition: ChainEdition,
     /// The genesis block information
     pub genesis: Genesis,
     /// The block chain parameters
@@ -75,6 +78,8 @@ pub struct ChainSpec {
     #[serde(skip)]
     /// Hash of blake2b_256 spec content bytes, used for check consistency between database and config
     pub hash: packed::Byte32,
+    #[serde(skip)]
+    legacy: bool,
 }
 
 /// The default_params mod defines the default parameters for CKB Mainnet
@@ -439,16 +444,33 @@ impl ChainSpec {
             return Err(SpecLoadError::file_not_found());
         }
         let config_bytes = resource.get()?;
-        let mut spec: ChainSpec = toml::from_slice(&config_bytes)?;
 
-        if let Some(parent) = resource.parent() {
-            for r in spec.genesis.system_cells.iter_mut() {
-                r.file.absolutize(parent)
+        let partial_spec: legacy::PartialChainSpec = toml::from_slice(&config_bytes)?;
+
+        let spec = match partial_spec.edition {
+            None | Some(ChainEdition::V2019) => {
+                let mut spec: legacy::v2019::ChainSpec = toml::from_slice(&config_bytes)?;
+                if let Some(parent) = resource.parent() {
+                    for r in spec.genesis.system_cells.iter_mut() {
+                        r.file.absolutize(parent)
+                    }
+                }
+                spec.hash = packed::Byte32::new(blake2b_256(&toml::to_vec(&spec)?));
+                spec.into()
             }
-        }
+            Some(ChainEdition::V2021) => {
+                let mut spec: ChainSpec = toml::from_slice(&config_bytes)?;
+                if let Some(parent) = resource.parent() {
+                    for r in spec.genesis.system_cells.iter_mut() {
+                        r.file.absolutize(parent)
+                    }
+                }
+                // leverage serialize for sanitizing
+                spec.hash = packed::Byte32::new(blake2b_256(&toml::to_vec(&spec)?));
+                spec
+            }
+        };
 
-        // leverage serialize for sanitizing
-        spec.hash = packed::Byte32::new(blake2b_256(&toml::to_vec(&spec)?));
         Ok(spec)
     }
 
@@ -838,6 +860,16 @@ impl ChainSpec {
             .witness(witness)
             .build())
     }
+
+    /// If the CKB block chain specification is for an public chain.
+    pub fn is_public_chain(&self) -> bool {
+        matches!(self.name.as_str(), "mainnet" | "testnet")
+    }
+
+    /// If the CKB block chain specification is loaded from a legacy format file.
+    pub fn is_legacy(&self) -> bool {
+        self.legacy
+    }
 }
 
 impl GenesisCell {
diff --git a/test/src/node.rs b/test/src/node.rs
index ff37dec155..545e282fb5 100644
--- a/test/src/node.rs
+++ b/test/src/node.rs
@@ -7,6 +7,7 @@ use ckb_chain_spec::consensus::Consensus;
 use ckb_chain_spec::ChainSpec;
 use ckb_jsonrpc_types::TxPoolInfo;
 use ckb_logger::{debug, error};
+use ckb_resource::Resource;
 use ckb_types::{
     bytes,
     core::{
@@ -85,7 +86,7 @@ impl Node {
         let app_config_path = self.working_dir().join("ckb.toml");
         let mut app_config: CKBAppConfig = {
             let toml = fs::read(&app_config_path).unwrap();
-            toml::from_slice(&toml).unwrap()
+            CKBAppConfig::load_from_slice(&toml).unwrap()
         };
         modifier(&mut app_config);
         fs::write(&app_config_path, toml::to_string(&app_config).unwrap()).unwrap();
@@ -97,28 +98,26 @@ impl Node {
     where
         M: Fn(&mut ChainSpec),
     {
-        let ckb_spec_path = self.working_dir().join("specs/integration.toml");
-        let mut chain_spec = {
-            let toml = fs::read(&ckb_spec_path).unwrap();
-            toml::from_slice(&toml).unwrap()
-        };
+        let chain_spec_path = self.working_dir().join("specs/integration.toml");
+        let chain_spec_res = Resource::file_system(chain_spec_path.clone());
+        let mut chain_spec = ChainSpec::load_from(&chain_spec_res).unwrap();
         modifier(&mut chain_spec);
-        fs::write(&ckb_spec_path, toml::to_string(&chain_spec).unwrap()).unwrap();
+        fs::write(&chain_spec_path, toml::to_string(&chain_spec).unwrap()).unwrap();
 
         *self = Self::init(self.working_dir());
     }
 
     // Initialize Node instance based on working directory
     fn init(working_dir: PathBuf) -> Self {
-        let app_config: CKBAppConfig = {
+        let app_config = {
             let app_config_path = working_dir.join("ckb.toml");
             let toml = fs::read(app_config_path).unwrap();
-            toml::from_slice(&toml).unwrap()
+            CKBAppConfig::load_from_slice(&toml).unwrap()
         };
         let mut chain_spec: ChainSpec = {
             let chain_spec_path = working_dir.join("specs/integration.toml");
-            let toml = fs::read(chain_spec_path).unwrap();
-            toml::from_slice(&toml).unwrap()
+            let chain_spec_res = Resource::file_system(chain_spec_path);
+            ChainSpec::load_from(&chain_spec_res).unwrap()
         };
 
         let p2p_listen = app_config.network.listen_addresses[0].to_string();
diff --git a/util/app-config/src/app_config.rs b/util/app-config/src/app_config.rs
index 679b0c020e..157dfe8ab5 100644
--- a/util/app-config/src/app_config.rs
+++ b/util/app-config/src/app_config.rs
@@ -11,14 +11,15 @@ use std::path::{Path, PathBuf};
 use serde::{Deserialize, Serialize};
 
 use ckb_chain_spec::ChainSpec;
-use ckb_logger_config::Config as LogConfig;
-use ckb_metrics_config::Config as MetricsConfig;
+use ckb_jsonrpc_types::ChainEdition;
+pub use ckb_logger_config::Config as LogConfig;
+pub use ckb_metrics_config::Config as MetricsConfig;
 use ckb_resource::Resource;
 
 use super::configs::*;
 #[cfg(feature = "with_sentry")]
 use super::sentry_config::SentryConfig;
-use super::{cli, ExitCode};
+use super::{cli, legacy, ExitCode};
 
 /// The parsed config file.
 ///
@@ -36,6 +37,9 @@ pub enum AppConfig {
 /// **Attention:** Changing the order of fields will break integration test, see module doc.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct CKBAppConfig {
+    /// The edition of CKB AppConfig
+    pub edition: ChainEdition,
+
     /// The data directory.
     pub data_dir: PathBuf,
     /// freezer files path
@@ -89,6 +93,9 @@ pub struct CKBAppConfig {
 /// **Attention:** Changing the order of fields will break integration test, see module doc.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct MinerAppConfig {
+    /// The edition of Miner AppConfig
+    pub edition: ChainEdition,
+
     /// The data directory.
     pub data_dir: PathBuf,
     /// Chain config options.
@@ -132,7 +139,7 @@ impl AppConfig {
         match subcommand_name {
             cli::CMD_MINER => {
                 let resource = ensure_ckb_dir(Resource::miner_config(root_dir.as_ref()))?;
-                let config: MinerAppConfig = toml::from_slice(&resource.get()?)?;
+                let config = MinerAppConfig::load_from_slice(&resource.get()?)?;
 
                 Ok(AppConfig::with_miner(
                     config.derive_options(root_dir.as_ref())?,
@@ -140,7 +147,7 @@ impl AppConfig {
             }
             _ => {
                 let resource = ensure_ckb_dir(Resource::ckb_config(root_dir.as_ref()))?;
-                let config: CKBAppConfig = toml::from_slice(&resource.get()?)?;
+                let config = CKBAppConfig::load_from_slice(&resource.get()?)?;
                 Ok(AppConfig::with_ckb(
                     config.derive_options(root_dir.as_ref(), subcommand_name)?,
                 ))
@@ -187,10 +194,14 @@ impl AppConfig {
             AppConfig::CKB(config) => &config.chain.spec,
             AppConfig::Miner(config) => &config.chain.spec,
         };
-        ChainSpec::load_from(spec_resource).map_err(|err| {
+        let spec = ChainSpec::load_from(spec_resource).map_err(|err| {
             eprintln!("{}", err);
             ExitCode::Config
-        })
+        })?;
+        if !spec.is_public_chain() && spec.is_legacy() {
+            eprintln!("WARN: your chain specification file is in a legacy edition");
+        }
+        Ok(spec)
     }
 
     /// Unpacks the parsed ckb.toml config file.
@@ -230,6 +241,19 @@ impl AppConfig {
 }
 
 impl CKBAppConfig {
+    /// Load a new instance from a file
+    pub fn load_from_slice(slice: &[u8]) -> Result<Self, ExitCode> {
+        let partial_config: legacy::PartialAppConfig = toml::from_slice(&slice)?;
+
+        match partial_config.edition {
+            None | Some(ChainEdition::V2019) => {
+                let legacy_config: legacy::v2019::CKBAppConfig = toml::from_slice(&slice)?;
+                Ok(legacy_config.into())
+            }
+            Some(ChainEdition::V2021) => toml::from_slice(&slice).map_err(Into::into),
+        }
+    }
+
     fn derive_options(mut self, root_dir: &Path, subcommand_name: &str) -> Result<Self, ExitCode> {
         self.data_dir = canonicalize_data_dir(self.data_dir, root_dir);
 
@@ -269,6 +293,19 @@ impl CKBAppConfig {
 }
 
 impl MinerAppConfig {
+    /// Load a new instance from a file.
+    pub fn load_from_slice(slice: &[u8]) -> Result<Self, ExitCode> {
+        let partial_config: legacy::PartialAppConfig = toml::from_slice(&slice)?;
+
+        match partial_config.edition {
+            None | Some(ChainEdition::V2019) => {
+                let legacy_config: legacy::v2019::MinerAppConfig = toml::from_slice(&slice)?;
+                Ok(legacy_config.into())
+            }
+            Some(ChainEdition::V2021) => toml::from_slice(&slice).map_err(Into::into),
+        }
+    }
+
     fn derive_options(mut self, root_dir: &Path) -> Result<Self, ExitCode> {
         self.data_dir = mkdir(canonicalize_data_dir(self.data_dir, root_dir))?;
         self.logger.log_dir = self.data_dir.join("logs");
@@ -342,11 +379,11 @@ mod tests {
     #[test]
     fn test_bundled_config_files() {
         let resource = Resource::bundled_ckb_config();
-        toml::from_slice::<CKBAppConfig>(&resource.get().expect("read bundled file"))
+        CKBAppConfig::load_from_slice(&resource.get().expect("read bundled file"))
             .expect("deserialize config");
 
         let resource = Resource::bundled_miner_config();
-        toml::from_slice::<MinerAppConfig>(&resource.get().expect("read bundled file"))
+        MinerAppConfig::load_from_slice(&resource.get().expect("read bundled file"))
             .expect("deserialize config");
     }
 
diff --git a/util/app-config/src/legacy/mod.rs b/util/app-config/src/legacy/mod.rs
new file mode 100644
index 0000000000..671cc2826c
--- /dev/null
+++ b/util/app-config/src/legacy/mod.rs
@@ -0,0 +1,12 @@
+//! Legacy CKB AppConfig and Miner AppConfig
+
+use ckb_jsonrpc_types::ChainEdition;
+use serde::{Deserialize, Serialize};
+
+pub(crate) mod v2019;
+
+/// The partial CKB AppConfig or Miner AppConfig
+#[derive(Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
+pub(crate) struct PartialAppConfig {
+    pub(crate) edition: Option<ChainEdition>,
+}
diff --git a/util/app-config/src/legacy/v2019.rs b/util/app-config/src/legacy/v2019.rs
new file mode 100644
index 0000000000..ab36a0f066
--- /dev/null
+++ b/util/app-config/src/legacy/v2019.rs
@@ -0,0 +1,117 @@
+//! Legacy CKB AppConfig (Edition 2019)
+
+use ckb_jsonrpc_types as rpc;
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub(crate) struct CKBAppConfig {
+    data_dir: PathBuf,
+    #[serde(default)]
+    ancient: PathBuf,
+    tmp_dir: Option<PathBuf>,
+    logger: crate::LogConfig,
+    #[cfg(feature = "with_sentry")]
+    #[serde(default)]
+    sentry: crate::SentryConfig,
+    #[serde(default)]
+    metrics: crate::MetricsConfig,
+    #[serde(default)]
+    memory_tracker: crate::MemoryTrackerConfig,
+    chain: crate::ChainConfig,
+    block_assembler: Option<crate::BlockAssemblerConfig>,
+    #[serde(default)]
+    db: crate::DBConfig,
+    network: crate::NetworkConfig,
+    rpc: crate::RpcConfig,
+    tx_pool: crate::TxPoolConfig,
+    #[serde(default)]
+    store: crate::StoreConfig,
+    alert_signature: Option<crate::NetworkAlertConfig>,
+    #[serde(default)]
+    notify: crate::NotifyConfig,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub(crate) struct MinerAppConfig {
+    data_dir: PathBuf,
+    chain: crate::ChainConfig,
+    logger: crate::LogConfig,
+    #[cfg(feature = "with_sentry")]
+    sentry: crate::SentryConfig,
+    #[serde(default)]
+    metrics: crate::MetricsConfig,
+    #[serde(default)]
+    memory_tracker: crate::MemoryTrackerConfig,
+    miner: crate::MinerConfig,
+}
+
+impl From<CKBAppConfig> for crate::CKBAppConfig {
+    fn from(input: CKBAppConfig) -> Self {
+        let CKBAppConfig {
+            data_dir,
+            ancient,
+            tmp_dir,
+            logger,
+            #[cfg(feature = "with_sentry")]
+            sentry,
+            metrics,
+            memory_tracker,
+            chain,
+            block_assembler,
+            db,
+            network,
+            rpc,
+            tx_pool,
+            store,
+            alert_signature,
+            notify,
+        } = input;
+        Self {
+            edition: rpc::ChainEdition::V2021,
+            data_dir,
+            ancient,
+            tmp_dir,
+            logger,
+            #[cfg(feature = "with_sentry")]
+            sentry,
+            metrics,
+            memory_tracker,
+            chain,
+            block_assembler,
+            db,
+            network,
+            rpc,
+            tx_pool,
+            store,
+            alert_signature,
+            notify,
+        }
+    }
+}
+
+impl From<MinerAppConfig> for crate::MinerAppConfig {
+    fn from(input: MinerAppConfig) -> Self {
+        let MinerAppConfig {
+            data_dir,
+            chain,
+            logger,
+            #[cfg(feature = "with_sentry")]
+            sentry,
+            metrics,
+            memory_tracker,
+            miner,
+        } = input;
+        Self {
+            edition: rpc::ChainEdition::V2021,
+            data_dir,
+            chain,
+            logger,
+            #[cfg(feature = "with_sentry")]
+            sentry,
+            metrics,
+            memory_tracker,
+            miner,
+        }
+    }
+}
diff --git a/util/app-config/src/lib.rs b/util/app-config/src/lib.rs
index f25882b9d8..97472059b6 100644
--- a/util/app-config/src/lib.rs
+++ b/util/app-config/src/lib.rs
@@ -4,16 +4,21 @@ mod args;
 pub mod cli;
 mod configs;
 mod exit_code;
+pub(crate) mod legacy;
 #[cfg(feature = "with_sentry")]
 mod sentry_config;
 
-pub use app_config::{AppConfig, CKBAppConfig, MinerAppConfig};
+pub use app_config::{
+    AppConfig, CKBAppConfig, ChainConfig, LogConfig, MetricsConfig, MinerAppConfig,
+};
 pub use args::{
     ExportArgs, ImportArgs, InitArgs, MigrateArgs, MinerArgs, PeerIDArgs, RepairArgs, ReplayArgs,
     ResetDataArgs, RunArgs, StatsArgs,
 };
 pub use configs::*;
 pub use exit_code::ExitCode;
+#[cfg(feature = "with_sentry")]
+pub use sentry_config::SentryConfig;
 
 use ckb_chain_spec::{consensus::Consensus, ChainSpec};
 use ckb_jsonrpc_types::{ScriptHashTypeShadow, VmVersion};
diff --git a/util/app-config/src/sentry_config.rs b/util/app-config/src/sentry_config.rs
index aa272651c5..6a1b0e9aa3 100644
--- a/util/app-config/src/sentry_config.rs
+++ b/util/app-config/src/sentry_config.rs
@@ -1,3 +1,5 @@
+#![doc(hidden)]
+
 use ckb_build_info::Version;
 use sentry::{
     configure_scope, init, protocol::Event, types::Dsn, ClientInitGuard, ClientOptions, Level,
diff --git a/util/jsonrpc-types/src/hardfork.rs b/util/jsonrpc-types/src/hardfork.rs
new file mode 100644
index 0000000000..3cef1cb9a0
--- /dev/null
+++ b/util/jsonrpc-types/src/hardfork.rs
@@ -0,0 +1,12 @@
+use serde::{Deserialize, Serialize};
+
+/// The CKB block chain edition.
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize)]
+pub enum ChainEdition {
+    /// The CKB 2019 edition.
+    #[serde(rename = "2019")]
+    V2019,
+    /// The CKB 2019 edition.
+    #[serde(rename = "2021")]
+    V2021,
+}
diff --git a/util/jsonrpc-types/src/lib.rs b/util/jsonrpc-types/src/lib.rs
index 48ddf010f1..10b47bf980 100644
--- a/util/jsonrpc-types/src/lib.rs
+++ b/util/jsonrpc-types/src/lib.rs
@@ -9,6 +9,7 @@ mod debug;
 mod experiment;
 mod fee_rate;
 mod fixed_bytes;
+mod hardfork;
 mod net;
 mod pool;
 mod primitive;
@@ -33,6 +34,7 @@ pub use self::debug::{ExtraLoggerConfig, MainLoggerConfig};
 pub use self::experiment::DryRunResult;
 pub use self::fee_rate::FeeRateDef;
 pub use self::fixed_bytes::Byte32;
+pub use self::hardfork::ChainEdition;
 pub use self::net::{
     BannedAddr, LocalNode, LocalNodeProtocol, NodeAddress, PeerSyncState, RemoteNode,
     RemoteNodeProtocol, SyncState,

From 40b449792f17acd23f910233f502991b6843da16 Mon Sep 17 00:00:00 2001
From: Boyu Yang <yangby@cryptape.com>
Date: Tue, 29 Jun 2021 14:07:07 +0800
Subject: [PATCH 11/14] refactor(hardfork): change field "hash_type" from a
 "String" to an "Object"

BREAKING CHANGE: The field "hash_type" in "Script" is changed from a "String" to an "Object" for all
JSON RPC methods.
---
 chain/src/tests/block_assembler.rs     |   4 +-
 chain/src/tests/util.rs                |   4 +-
 ckb-bin/src/subcommand/init.rs         |  56 ++++--
 docs/hashes.toml                       |   2 +-
 resource/specs/dev.toml                |  15 +-
 rpc/README.md                          |  76 +++++--
 rpc/src/module/chain.rs                |  25 ++-
 rpc/src/module/experiment.rs           |   5 +-
 rpc/src/module/miner.rs                |  10 +-
 rpc/src/module/pool.rs                 |   5 +-
 spec/src/legacy/v2019.rs               | 121 +++++++++++-
 test/src/main.rs                       |   3 +-
 util/app-config/src/args.rs            |   6 +-
 util/app-config/src/cli.rs             |  22 +--
 util/app-config/src/configs/miner.rs   |   2 +-
 util/app-config/src/configs/tx_pool.rs |  62 +-----
 util/app-config/src/legacy/v2019.rs    |  34 +++-
 util/app-config/src/lib.rs             |  16 +-
 util/jsonrpc-types/src/blockchain.rs   | 262 ++++++++++++++-----------
 util/jsonrpc-types/src/cell.rs         |  10 +-
 util/jsonrpc-types/src/lib.rs          |   4 +-
 util/jsonrpc-types/src/primitive.rs    |   7 +-
 util/jsonrpc-types/src/uints.rs        |   9 -
 23 files changed, 479 insertions(+), 281 deletions(-)

diff --git a/chain/src/tests/block_assembler.rs b/chain/src/tests/block_assembler.rs
index bfdabd22f5..038981198d 100644
--- a/chain/src/tests/block_assembler.rs
+++ b/chain/src/tests/block_assembler.rs
@@ -34,9 +34,7 @@ fn start_chain(consensus: Option<Consensus>) -> (ChainController, Shared) {
     let config = BlockAssemblerConfig {
         code_hash: h256!("0x0"),
         args: Default::default(),
-        hash_type: ScriptHashType::Data {
-            vm_version: 0.into(),
-        },
+        hash_type: ScriptHashType::Data { vm_version: 0 },
         message: Default::default(),
     };
     let (shared, mut pack) = builder
diff --git a/chain/src/tests/util.rs b/chain/src/tests/util.rs
index a2c3d28661..90206eddfd 100644
--- a/chain/src/tests/util.rs
+++ b/chain/src/tests/util.rs
@@ -115,9 +115,7 @@ pub(crate) fn start_chain(consensus: Option<Consensus>) -> (ChainController, Sha
     let config = BlockAssemblerConfig {
         code_hash: h256!("0x0"),
         args: Default::default(),
-        hash_type: ScriptHashType::Data {
-            vm_version: 0.into(),
-        },
+        hash_type: ScriptHashType::Data { vm_version: 0 },
         message: Default::default(),
     };
 
diff --git a/ckb-bin/src/subcommand/init.rs b/ckb-bin/src/subcommand/init.rs
index ab127febc1..ffe2e3af71 100644
--- a/ckb-bin/src/subcommand/init.rs
+++ b/ckb-bin/src/subcommand/init.rs
@@ -4,7 +4,7 @@ use std::io::{self, Read};
 use crate::helper::prompt;
 use ckb_app_config::{cli, AppConfig, ExitCode, InitArgs};
 use ckb_chain_spec::ChainSpec;
-use ckb_jsonrpc_types::{ScriptHashTypeShadow, VmVersion};
+use ckb_jsonrpc_types::{ScriptHashTypeKind, VmVersion};
 use ckb_resource::{
     Resource, TemplateContext, AVAILABLE_SPECS, CKB_CONFIG_FILE_NAME, DB_OPTIONS_FILE_NAME,
     MINER_CONFIG_FILE_NAME, SPEC_DEV_FILE_NAME,
@@ -57,17 +57,25 @@ pub fn init(args: InitArgs) -> Result<(), ExitCode> {
             .map(|s| s.to_string())
             .collect::<Vec<String>>();
 
-        match serde_plain::from_str::<ScriptHashTypeShadow>(in_hash_type.trim()).ok() {
-            Some(hash_type) => args.block_assembler_hash_type = hash_type,
-            None => eprintln!("Invalid block assembler hash type"),
-        }
+        args.block_assembler_hash_type_kind =
+            match serde_plain::from_str::<ScriptHashTypeKind>(in_hash_type.trim()).ok() {
+                Some(hash_type) => hash_type,
+                None => {
+                    eprintln!("Invalid block assembler hash type");
+                    return Err(ExitCode::Failure);
+                }
+            };
 
-        if args.block_assembler_hash_type == ScriptHashTypeShadow::Type {
+        if args.block_assembler_hash_type_kind == ScriptHashTypeKind::Data {
             let in_vm_version = prompt("vm_version: ");
-            match serde_plain::from_str::<VmVersion>(in_vm_version.trim()).ok() {
-                Some(vm_version) => args.block_assembler_vm_version = Some(vm_version),
-                None => eprintln!("Invalid block assembler vm version"),
-            }
+            args.block_assembler_hash_type_vm_version =
+                match serde_plain::from_str::<VmVersion>(in_vm_version.trim()).ok() {
+                    Some(vm_version) => Some(vm_version),
+                    None => {
+                        eprintln!("Invalid block assembler vm version");
+                        return Err(ExitCode::Failure);
+                    }
+                };
         }
 
         let in_message = prompt("message: ");
@@ -98,11 +106,11 @@ pub fn init(args: InitArgs) -> Result<(), ExitCode> {
     let block_assembler = match block_assembler_code_hash {
         Some(hash) => {
             if let Some(default_code_hash) = &default_code_hash_option {
-                if ScriptHashTypeShadow::Type != args.block_assembler_hash_type {
+                if ScriptHashTypeKind::Type != args.block_assembler_hash_type_kind {
                     eprintln!(
                         "WARN: the default lock should use hash type `{}`, you are using `{}`.\n\
                          It will require `ckb run --ba-advanced` to enable this block assembler",
-                        DEFAULT_LOCK_SCRIPT_HASH_TYPE, args.block_assembler_hash_type
+                        DEFAULT_LOCK_SCRIPT_HASH_TYPE, args.block_assembler_hash_type_kind
                     );
                 } else if *default_code_hash != *hash {
                     eprintln!(
@@ -119,31 +127,39 @@ pub fn init(args: InitArgs) -> Result<(), ExitCode> {
                     );
                 }
             }
-            if let Some(default_vm_version) = &args.block_assembler_vm_version {
+            if let Some(vm_version) = &args.block_assembler_hash_type_vm_version {
+                if ScriptHashTypeKind::Type == args.block_assembler_hash_type_kind {
+                    eprintln!("VM version is not allowed for hash-type \"type\".");
+                    return Err(ExitCode::Failure);
+                }
                 format!(
                     "[block_assembler]\n\
                     code_hash = \"{}\"\n\
                     args = \"{}\"\n\
-                    hash_type = \"{}\"\n\
-                    vm_version = \"{}\"\n\
+                    hash_type.kind = \"{}\"\n\
+                    hash_type.vm_version = {}\n\
                     message = \"{}\"",
                     hash,
                     args.block_assembler_args.join("\", \""),
-                    args.block_assembler_hash_type,
-                    serde_plain::to_string(&default_vm_version).unwrap(),
+                    args.block_assembler_hash_type_kind,
+                    vm_version,
                     args.block_assembler_message
                         .unwrap_or_else(|| "0x".to_string()),
                 )
             } else {
+                if ScriptHashTypeKind::Data == args.block_assembler_hash_type_kind {
+                    eprintln!("VM version should be provided for hash-type \"data\".");
+                    return Err(ExitCode::Failure);
+                }
                 format!(
                     "[block_assembler]\n\
                     code_hash = \"{}\"\n\
                     args = \"{}\"\n\
-                    hash_type = \"{}\"\n\
+                    hash_type.kind = \"{}\"\n\
                     message = \"{}\"",
                     hash,
                     args.block_assembler_args.join("\", \""),
-                    args.block_assembler_hash_type,
+                    args.block_assembler_hash_type_kind,
                     args.block_assembler_message
                         .unwrap_or_else(|| "0x".to_string()),
                 )
@@ -156,7 +172,7 @@ pub fn init(args: InitArgs) -> Result<(), ExitCode> {
                  # [block_assembler]\n\
                  # code_hash = \"{}\"\n\
                  # args = \"ckb-cli util blake2b --prefix-160 <compressed-pubkey>\"\n\
-                 # hash_type = \"{}\"\n\
+                 # hash_type.kind = \"{}\"\n\
                  # message = \"A 0x-prefixed hex string\"",
                 default_code_hash_option.unwrap_or_default(),
                 DEFAULT_LOCK_SCRIPT_HASH_TYPE,
diff --git a/docs/hashes.toml b/docs/hashes.toml
index f618f58d68..3fb3a56edf 100644
--- a/docs/hashes.toml
+++ b/docs/hashes.toml
@@ -134,7 +134,7 @@ index = 1
 
 # Spec: ckb_dev
 [ckb_dev]
-spec_hash = "0xc98d591b33910a66fbdecf1c40c430876152dd325cc0a32863e2eedf9255280a"
+spec_hash = "0x0b936b2fd8dbee9f10c1186aa3dc643fe3e3299abcf15e6754088d34d7d58611"
 genesis = "0x823b2ff5785b12da8b1363cac9a5cbe566d8b715a4311441b119c39a0367488c"
 cellbase = "0xa563884b3686078ec7e7677a5f86449b15cf2693f3c1241766c6996f206cc541"
 
diff --git a/resource/specs/dev.toml b/resource/specs/dev.toml
index 8498580d04..1498c0f321 100644
--- a/resource/specs/dev.toml
+++ b/resource/specs/dev.toml
@@ -22,7 +22,8 @@ message = "ckb_dev" # {{
 [genesis.genesis_cell.lock]
 code_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
 args = "0x"
-hash_type = "data"
+hash_type.kind = "data"
+hash_type.vm_version = 0
 
 # An array list paths to system cell files, which is absolute or relative to
 # the directory containing this config file.
@@ -46,7 +47,8 @@ capacity = 100_000_0000_0000
 [genesis.system_cells_lock]
 code_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
 args = "0x"
-hash_type = "data"
+hash_type.kind = "data"
+hash_type.vm_version = 0
 
 # Dep group cells
 [[genesis.dep_groups]]
@@ -66,28 +68,29 @@ files = [
 [genesis.bootstrap_lock]
 code_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
 args = "0x"
-hash_type = "type"
+hash_type.kind = "type"
 
 # Burn
 [[genesis.issued_cells]]
 capacity = 8_400_000_000_00000000
 lock.code_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
 lock.args = "0x62e907b15cbf27d5425399ebf6f0fb50ebb88f18"
-lock.hash_type = "data"
+lock.hash_type.kind = "data"
+lock.hash_type.vm_version = 0
 
 # issue for random generated private key: d00c06bfd800d27397002dca6fb0993d5ba6399b4238b2f29ee9deb97593d2bc
 [[genesis.issued_cells]]
 capacity = 20_000_000_000_00000000
 lock.code_hash = "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8"
 lock.args = "0xc8328aabcd9b9e8e64fbc566c4385c3bdeb219d7"
-lock.hash_type = "type"
+lock.hash_type.kind = "type"
 
 # issue for random generated private key: 63d86723e08f0f813a36ce6aa123bb2289d90680ae1e99d4de8cdb334553f24d
 [[genesis.issued_cells]]
 capacity = 5_198_735_037_00000000
 lock.code_hash = "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8"
 lock.args = "0x470dcdc5e44064909650113a274b3b36aecb6dc7"
-lock.hash_type = "type"
+lock.hash_type.kind = "type"
 
 [params]
 initial_primary_epoch_reward = 1_917_808_21917808
diff --git a/rpc/README.md b/rpc/README.md
index 6458ee45a1..b4880ae3c4 100644
--- a/rpc/README.md
+++ b/rpc/README.md
@@ -323,7 +323,10 @@ Response
             "lock": {
               "args": "0x",
               "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-              "hash_type": "data"
+              "hash_type": {
+                "kind": "data",
+                "vm_version": 0
+              }
             },
             "type": null
           }
@@ -439,7 +442,10 @@ Response
             "lock": {
               "args": "0x",
               "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-              "hash_type": "data"
+              "hash_type": {
+                "kind": "data",
+                "vm_version": 0
+              }
             },
             "type": null
           }
@@ -684,7 +690,10 @@ Response
           "lock": {
             "args": "0x",
             "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-            "hash_type": "data"
+            "hash_type": {
+              "kind": "data",
+              "vm_version": 0
+            }
           },
           "type": null
         }
@@ -868,7 +877,10 @@ Response
         "lock": {
           "args": "0x",
           "code_hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-          "hash_type": "data"
+          "hash_type": {
+            "kind": "data",
+            "vm_version": 0
+          }
         },
         "type": null
       }
@@ -1225,7 +1237,10 @@ Response
             "lock": {
               "args": "0x",
               "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-              "hash_type": "data"
+              "hash_type": {
+                "kind": "data",
+                "vm_version": 0
+              }
             },
             "type": null
           }
@@ -1420,7 +1435,10 @@ Request
           "lock": {
             "args": "0x",
             "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-            "hash_type": "data"
+            "hash_type": {
+              "kind": "data",
+              "vm_version": 0
+            }
           },
           "type": null
         }
@@ -1572,7 +1590,10 @@ Response
             "lock": {
               "args": "0x",
               "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-              "hash_type": "data"
+              "hash_type": {
+                "kind": "data",
+                "vm_version": 0
+              }
             },
             "type": null
           }
@@ -1682,7 +1703,10 @@ Request
               "lock": {
                 "args": "0x",
                 "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-                "hash_type": "data"
+                "hash_type": {
+                  "kind": "data",
+                  "vm_version": 0
+                }
               },
               "type": null
             }
@@ -2334,7 +2358,10 @@ Request
           "lock": {
             "args": "0x",
             "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-            "hash_type": "data"
+            "hash_type": {
+              "kind": "data",
+              "vm_version": 0
+            }
           },
           "type": null
         }
@@ -3164,7 +3191,10 @@ The JSON view of a cell combining the fields in cell output and cell data.
     "lock": {
       "args": "0x",
       "code_hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-      "hash_type": "data"
+      "hash_type": {
+        "kind": "data",
+        "vm_version": 0
+      }
     },
     "type": null
   }
@@ -3225,7 +3255,10 @@ The fields of an output cell except the cell data.
   "lock": {
     "args": "0x",
     "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-    "hash_type": "data"
+    "hash_type": {
+      "kind": "data",
+      "vm_version": 0
+    }
   },
   "type": null
 }
@@ -3266,7 +3299,10 @@ The JSON view of a cell with its status information.
       "lock": {
         "args": "0x",
         "code_hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-        "hash_type": "data"
+        "hash_type": {
+          "kind": "data",
+          "vm_version": 0
+        }
       },
       "type": null
     }
@@ -4045,7 +4081,10 @@ Describes the lock script and type script for a cell.
 {
   "args": "0x",
   "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-  "hash_type": "data"
+  "hash_type": {
+    "kind": "data",
+    "vm_version": 0
+  }
 }
 ```
 
@@ -4056,16 +4095,16 @@ Describes the lock script and type script for a cell.
 
 *   `code_hash`: [`H256`](#type-h256) - The hash used to match the script code.
 
-*   `hash_type`: [`ScriptHashType`](#type-scripthashtype) - Specifies how to use the `code_hash` to match the script code.
-
 *   `args`: [`JsonBytes`](#type-jsonbytes) - Arguments for script.
 
+*   `hash_type`: [`ScriptHashType`](#type-scripthashtype) - Specifies how to use the `code_hash` to match the script code.
+
 
 ### Type `ScriptHashType`
 
 Specifies how the script `code_hash` is used to match the script code.
 
-Allowed values: "data" and "type".
+Allowed kinds: "data" and "type". If the kind is "data", the "vm_version" must be provided. If the kind is "type", specifying "vm_version" is not allowed.
 
 Refer to the section [Code Locating](https://github.com/nervosnetwork/rfcs/blob/master/rfcs/0022-transaction-structure/0022-transaction-structure.md#code-locating) and [Upgradable Script](https://github.com/nervosnetwork/rfcs/blob/master/rfcs/0022-transaction-structure/0022-transaction-structure.md#upgradable-script) in the RFC *CKB Transaction Structure*.
 
@@ -4265,7 +4304,10 @@ This structure is serialized into a JSON object with field `hash` and all the fi
       "lock": {
         "args": "0x",
         "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-        "hash_type": "data"
+        "hash_type": {
+          "kind": "data",
+          "vm_version": 0
+        }
       },
       "type": null
     }
diff --git a/rpc/src/module/chain.rs b/rpc/src/module/chain.rs
index aac5f8e5ed..2153b8e110 100644
--- a/rpc/src/module/chain.rs
+++ b/rpc/src/module/chain.rs
@@ -125,7 +125,10 @@ pub trait ChainRpc {
     ///             "lock": {
     ///               "args": "0x",
     ///               "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-    ///               "hash_type": "data"
+    ///               "hash_type": {
+    ///                 "kind": "data",
+    ///                 "vm_version": 0
+    ///               }
     ///             },
     ///             "type": null
     ///           }
@@ -244,7 +247,10 @@ pub trait ChainRpc {
     ///             "lock": {
     ///               "args": "0x",
     ///               "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-    ///               "hash_type": "data"
+    ///               "hash_type": {
+    ///                 "kind": "data",
+    ///                 "vm_version": 0
+    ///               }
     ///             },
     ///             "type": null
     ///           }
@@ -502,7 +508,10 @@ pub trait ChainRpc {
     ///           "lock": {
     ///             "args": "0x",
     ///             "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-    ///             "hash_type": "data"
+    ///             "hash_type": {
+    ///               "kind": "data",
+    ///               "vm_version": 0
+    ///             }
     ///           },
     ///           "type": null
     ///         }
@@ -690,7 +699,10 @@ pub trait ChainRpc {
     ///         "lock": {
     ///           "args": "0x",
     ///           "code_hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-    ///           "hash_type": "data"
+    ///           "hash_type": {
+    ///             "kind": "data",
+    ///             "vm_version": 0
+    ///           }
     ///         },
     ///         "type": null
     ///       }
@@ -1045,7 +1057,10 @@ pub trait ChainRpc {
     ///             "lock": {
     ///               "args": "0x",
     ///               "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-    ///               "hash_type": "data"
+    ///               "hash_type": {
+    ///                 "kind": "data",
+    ///                 "vm_version": 0
+    ///               }
     ///             },
     ///             "type": null
     ///           }
diff --git a/rpc/src/module/experiment.rs b/rpc/src/module/experiment.rs
index 72c3809a85..cbf911fd8c 100644
--- a/rpc/src/module/experiment.rs
+++ b/rpc/src/module/experiment.rs
@@ -75,7 +75,10 @@ pub trait ExperimentRpc {
     ///           "lock": {
     ///             "args": "0x",
     ///             "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-    ///             "hash_type": "data"
+    ///             "hash_type": {
+    ///               "kind": "data",
+    ///               "vm_version": 0
+    ///             }
     ///           },
     ///           "type": null
     ///         }
diff --git a/rpc/src/module/miner.rs b/rpc/src/module/miner.rs
index 1c828607cf..6d123e9a99 100644
--- a/rpc/src/module/miner.rs
+++ b/rpc/src/module/miner.rs
@@ -79,7 +79,10 @@ pub trait MinerRpc {
     ///             "lock": {
     ///               "args": "0x",
     ///               "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-    ///               "hash_type": "data"
+    ///               "hash_type": {
+    ///                 "kind": "data",
+    ///                 "vm_version": 0
+    ///               }
     ///             },
     ///             "type": null
     ///           }
@@ -189,7 +192,10 @@ pub trait MinerRpc {
     ///               "lock": {
     ///                 "args": "0x",
     ///                 "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-    ///                 "hash_type": "data"
+    ///                 "hash_type": {
+    ///                   "kind": "data",
+    ///                   "vm_version": 0
+    ///                 }
     ///               },
     ///               "type": null
     ///             }
diff --git a/rpc/src/module/pool.rs b/rpc/src/module/pool.rs
index 563bfc1c51..2296c8ba52 100644
--- a/rpc/src/module/pool.rs
+++ b/rpc/src/module/pool.rs
@@ -70,7 +70,10 @@ pub trait PoolRpc {
     ///           "lock": {
     ///             "args": "0x",
     ///             "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-    ///             "hash_type": "data"
+    ///             "hash_type": {
+    ///               "kind": "data",
+    ///               "vm_version": 0
+    ///             }
     ///           },
     ///           "type": null
     ///         }
diff --git a/spec/src/legacy/v2019.rs b/spec/src/legacy/v2019.rs
index c14d4891ef..4cb64c7bc4 100644
--- a/spec/src/legacy/v2019.rs
+++ b/spec/src/legacy/v2019.rs
@@ -2,13 +2,13 @@
 
 use ckb_jsonrpc_types as rpc;
 use ckb_pow::Pow;
-use ckb_types::packed;
+use ckb_types::{core, packed, H256, U128};
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub(crate) struct ChainSpec {
     name: String,
-    pub(crate) genesis: crate::Genesis,
+    pub(crate) genesis: Genesis,
     #[serde(default)]
     params: crate::Params,
     pow: Pow,
@@ -16,6 +16,121 @@ pub(crate) struct ChainSpec {
     pub(crate) hash: packed::Byte32,
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub(crate) struct Genesis {
+    version: u32,
+    parent_hash: H256,
+    timestamp: u64,
+    compact_target: u32,
+    uncles_hash: H256,
+    hash: Option<H256>,
+    nonce: U128,
+    issued_cells: Vec<IssuedCell>,
+    genesis_cell: GenesisCell,
+    pub(crate) system_cells: Vec<crate::SystemCell>,
+    system_cells_lock: Script,
+    bootstrap_lock: Script,
+    dep_groups: Vec<crate::DepGroupResource>,
+    #[serde(default)]
+    satoshi_gift: crate::SatoshiGift,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct Script {
+    code_hash: H256,
+    hash_type: rpc::ScriptHashTypeKind,
+    args: rpc::JsonBytes,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+struct IssuedCell {
+    capacity: core::Capacity,
+    lock: Script,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+struct GenesisCell {
+    message: String,
+    lock: Script,
+}
+
+impl From<Script> for rpc::Script {
+    fn from(input: Script) -> Self {
+        let Script {
+            code_hash,
+            hash_type: hash_type_kind,
+            args,
+        } = input;
+        let hash_type = match hash_type_kind {
+            rpc::ScriptHashTypeKind::Data => rpc::ScriptHashType::Data { vm_version: 0 },
+            rpc::ScriptHashTypeKind::Type => rpc::ScriptHashType::Type,
+        };
+        Self {
+            code_hash,
+            hash_type,
+            args,
+        }
+    }
+}
+
+impl From<IssuedCell> for crate::IssuedCell {
+    fn from(input: IssuedCell) -> Self {
+        let IssuedCell { capacity, lock } = input;
+        Self {
+            capacity,
+            lock: lock.into(),
+        }
+    }
+}
+
+impl From<GenesisCell> for crate::GenesisCell {
+    fn from(input: GenesisCell) -> Self {
+        let GenesisCell { message, lock } = input;
+        Self {
+            message,
+            lock: lock.into(),
+        }
+    }
+}
+
+impl From<Genesis> for crate::Genesis {
+    fn from(input: Genesis) -> Self {
+        let Genesis {
+            version,
+            parent_hash,
+            timestamp,
+            compact_target,
+            uncles_hash,
+            hash,
+            nonce,
+            issued_cells,
+            genesis_cell,
+            system_cells,
+            system_cells_lock,
+            bootstrap_lock,
+            dep_groups,
+            satoshi_gift,
+        } = input;
+        Self {
+            version,
+            parent_hash,
+            timestamp,
+            compact_target,
+            uncles_hash,
+            hash,
+            nonce,
+            issued_cells: issued_cells.into_iter().map(Into::into).collect(),
+            genesis_cell: genesis_cell.into(),
+            system_cells,
+            system_cells_lock: system_cells_lock.into(),
+            bootstrap_lock: bootstrap_lock.into(),
+            dep_groups,
+            satoshi_gift,
+        }
+    }
+}
+
 impl From<ChainSpec> for crate::ChainSpec {
     fn from(input: ChainSpec) -> Self {
         let ChainSpec {
@@ -28,7 +143,7 @@ impl From<ChainSpec> for crate::ChainSpec {
         Self {
             name,
             edition: rpc::ChainEdition::V2021,
-            genesis,
+            genesis: genesis.into(),
             params,
             pow,
             hash,
diff --git a/test/src/main.rs b/test/src/main.rs
index 524fe5dcd7..b02c6798f1 100644
--- a/test/src/main.rs
+++ b/test/src/main.rs
@@ -446,7 +446,8 @@ fn all_specs() -> Vec<Box<dyn Spec>> {
         Box::new(WhitelistOnSessionLimit),
         // Box::new(IBDProcessWithWhiteList),
         Box::new(MalformedMessageWithWhitelist),
-        Box::new(InsufficientReward),
+        // TODO ckb2021 update the import json file for new ScriptHashType
+        // Box::new(InsufficientReward),
         Box::new(UncleInheritFromForkBlock),
         Box::new(UncleInheritFromForkUncle),
         Box::new(PackUnclesIntoEpochStarting),
diff --git a/util/app-config/src/args.rs b/util/app-config/src/args.rs
index 76160e3452..660ebd955d 100644
--- a/util/app-config/src/args.rs
+++ b/util/app-config/src/args.rs
@@ -1,6 +1,6 @@
 use crate::{CKBAppConfig, MemoryTrackerConfig, MinerConfig};
 use ckb_chain_spec::consensus::Consensus;
-use ckb_jsonrpc_types::{ScriptHashTypeShadow, VmVersion};
+use ckb_jsonrpc_types::{ScriptHashTypeKind, VmVersion};
 use ckb_pow::PowEngine;
 use ckb_types::packed::Byte32;
 use faketime::unix_time_as_millis;
@@ -114,9 +114,9 @@ pub struct InitArgs {
     /// Block assembler lock script args.
     pub block_assembler_args: Vec<String>,
     /// Block assembler lock script hash type.
-    pub block_assembler_hash_type: ScriptHashTypeShadow,
+    pub block_assembler_hash_type_kind: ScriptHashTypeKind,
     /// Block assembler lock script vm version when hash type is "data".
-    pub block_assembler_vm_version: Option<VmVersion>,
+    pub block_assembler_hash_type_vm_version: Option<VmVersion>,
     /// Block assembler cellbase transaction message.
     pub block_assembler_message: Option<String>,
     /// Import the spec file.
diff --git a/util/app-config/src/cli.rs b/util/app-config/src/cli.rs
index 041effadd2..6a2583564a 100644
--- a/util/app-config/src/cli.rs
+++ b/util/app-config/src/cli.rs
@@ -66,10 +66,10 @@ pub const ARG_BUNDLED: &str = "bundled";
 pub const ARG_BA_CODE_HASH: &str = "ba-code-hash";
 /// Command line argument `--ba-arg`.
 pub const ARG_BA_ARG: &str = "ba-arg";
-/// Command line argument `--ba-hash-type`.
-pub const ARG_BA_HASH_TYPE: &str = "ba-hash-type";
-/// Command line argument `--ba-vm-version`.
-pub const ARG_BA_VM_VERSION: &str = "ba-vm-version";
+/// Command line argument `--ba-hash-type-kind`.
+pub const ARG_BA_HASH_TYPE_KIND: &str = "ba-hash-type-kind";
+/// Command line argument `--ba-hash-type-vm-version`.
+pub const ARG_BA_HASH_TYPE_VM_VERSION: &str = "ba-hash-type-vm-version";
 /// Command line argument `--ba-message`.
 pub const ARG_BA_MESSAGE: &str = "ba-message";
 /// Command line argument `--ba-advanced`.
@@ -444,18 +444,18 @@ fn init() -> App<'static, 'static> {
                 .help("Sets args in [block_assembler]"),
         )
         .arg(
-            Arg::with_name(ARG_BA_HASH_TYPE)
-                .long(ARG_BA_HASH_TYPE)
-                .value_name("hash_type")
+            Arg::with_name(ARG_BA_HASH_TYPE_KIND)
+                .long(ARG_BA_HASH_TYPE_KIND)
+                .value_name("hash_type_kind")
                 .takes_value(true)
                 .possible_values(&["data", "type"])
                 .default_value("type")
-                .help("Sets hash type in [block_assembler]"),
+                .help("Sets hash type kind in [block_assembler]"),
         )
         .arg(
-            Arg::with_name(ARG_BA_VM_VERSION)
-                .long(ARG_BA_VM_VERSION)
-                .value_name("vm_version")
+            Arg::with_name(ARG_BA_HASH_TYPE_VM_VERSION)
+                .long(ARG_BA_HASH_TYPE_VM_VERSION)
+                .value_name("hash_type_vm_version")
                 .takes_value(true)
                 .help("Sets vm version for data hash-type script in [block_assembler]"),
         )
diff --git a/util/app-config/src/configs/miner.rs b/util/app-config/src/configs/miner.rs
index e92c66a798..7ae8050698 100644
--- a/util/app-config/src/configs/miner.rs
+++ b/util/app-config/src/configs/miner.rs
@@ -39,10 +39,10 @@ pub enum WorkerConfig {
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct BlockAssemblerConfig {
     pub code_hash: H256,
-    pub hash_type: ScriptHashType,
     pub args: Vec<JsonBytes>,
     #[serde(default)]
     pub message: JsonBytes,
+    pub hash_type: ScriptHashType,
 }
 
 /// Dummy worker config options.
diff --git a/util/app-config/src/configs/tx_pool.rs b/util/app-config/src/configs/tx_pool.rs
index 318aa5cf58..85c8c52900 100644
--- a/util/app-config/src/configs/tx_pool.rs
+++ b/util/app-config/src/configs/tx_pool.rs
@@ -1,5 +1,5 @@
 use ckb_chain_spec::consensus::TWO_IN_TWO_OUT_CYCLES;
-use ckb_jsonrpc_types::{FeeRateDef, JsonBytes, ScriptHashType, ScriptHashTypeShadow, VmVersion};
+use ckb_jsonrpc_types::{FeeRateDef, JsonBytes, ScriptHashType};
 use ckb_types::core::{Cycle, FeeRate};
 use ckb_types::H256;
 use serde::{Deserialize, Serialize};
@@ -52,69 +52,13 @@ impl Default for TxPoolConfig {
 ///
 /// The block assembler section tells CKB how to claim the miner rewards.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(try_from = "BlockAssemblerConfigShadow")]
 pub struct BlockAssemblerConfig {
     /// The miner lock script code hash.
     pub code_hash: H256,
-    /// The miner lock script hash type.
-    #[serde(flatten)]
-    pub hash_type: ScriptHashType,
     /// The miner lock script args.
     pub args: JsonBytes,
     /// An arbitrary message to be added into the cellbase transaction.
     pub message: JsonBytes,
-}
-
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-struct BlockAssemblerConfigShadow {
-    code_hash: H256,
-    #[serde(rename = "hash_type")]
-    hash_type_shadow: ScriptHashTypeShadow,
-    #[serde(rename = "vm_version")]
-    vm_version_opt: Option<VmVersion>,
-    args: JsonBytes,
-    message: JsonBytes,
-}
-
-struct BlockAssemblerConfigValidationError(&'static str);
-
-impl std::fmt::Display for BlockAssemblerConfigValidationError {
-    fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(formatter, "{}", self.0)
-    }
-}
-
-impl std::convert::TryFrom<BlockAssemblerConfigShadow> for BlockAssemblerConfig {
-    type Error = BlockAssemblerConfigValidationError;
-    fn try_from(shadow: BlockAssemblerConfigShadow) -> Result<Self, Self::Error> {
-        let BlockAssemblerConfigShadow {
-            code_hash,
-            hash_type_shadow,
-            vm_version_opt,
-            args,
-            message,
-        } = shadow;
-        let hash_type = match hash_type_shadow {
-            ScriptHashTypeShadow::Data => {
-                let vm_version = vm_version_opt.unwrap_or_default();
-                ScriptHashType::Data { vm_version }
-            }
-            ScriptHashTypeShadow::Type => {
-                if vm_version_opt.is_some() {
-                    return Err(BlockAssemblerConfigValidationError(
-                        "vm version is not allowed for hash-type \"type\".",
-                    ));
-                }
-                ScriptHashType::Type
-            }
-        };
-        let script = BlockAssemblerConfig {
-            code_hash,
-            hash_type,
-            args,
-            message,
-        };
-        Ok(script)
-    }
+    /// The miner lock script hash type.
+    pub hash_type: ScriptHashType,
 }
diff --git a/util/app-config/src/legacy/v2019.rs b/util/app-config/src/legacy/v2019.rs
index ab36a0f066..98ae4a57fb 100644
--- a/util/app-config/src/legacy/v2019.rs
+++ b/util/app-config/src/legacy/v2019.rs
@@ -1,6 +1,7 @@
 //! Legacy CKB AppConfig (Edition 2019)
 
 use ckb_jsonrpc_types as rpc;
+use ckb_types::H256;
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
@@ -19,7 +20,7 @@ pub(crate) struct CKBAppConfig {
     #[serde(default)]
     memory_tracker: crate::MemoryTrackerConfig,
     chain: crate::ChainConfig,
-    block_assembler: Option<crate::BlockAssemblerConfig>,
+    block_assembler: Option<BlockAssemblerConfig>,
     #[serde(default)]
     db: crate::DBConfig,
     network: crate::NetworkConfig,
@@ -46,6 +47,35 @@ pub(crate) struct MinerAppConfig {
     miner: crate::MinerConfig,
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize)]
+struct BlockAssemblerConfig {
+    code_hash: H256,
+    hash_type: rpc::ScriptHashTypeKind,
+    args: rpc::JsonBytes,
+    message: rpc::JsonBytes,
+}
+
+impl From<BlockAssemblerConfig> for crate::BlockAssemblerConfig {
+    fn from(input: BlockAssemblerConfig) -> Self {
+        let BlockAssemblerConfig {
+            code_hash,
+            hash_type: hash_type_kind,
+            args,
+            message,
+        } = input;
+        let hash_type = match hash_type_kind {
+            rpc::ScriptHashTypeKind::Data => rpc::ScriptHashType::Data { vm_version: 0 },
+            rpc::ScriptHashTypeKind::Type => rpc::ScriptHashType::Type,
+        };
+        Self {
+            code_hash,
+            hash_type,
+            args,
+            message,
+        }
+    }
+}
+
 impl From<CKBAppConfig> for crate::CKBAppConfig {
     fn from(input: CKBAppConfig) -> Self {
         let CKBAppConfig {
@@ -78,7 +108,7 @@ impl From<CKBAppConfig> for crate::CKBAppConfig {
             metrics,
             memory_tracker,
             chain,
-            block_assembler,
+            block_assembler: block_assembler.map(Into::into),
             db,
             network,
             rpc,
diff --git a/util/app-config/src/lib.rs b/util/app-config/src/lib.rs
index 97472059b6..d09230a3b0 100644
--- a/util/app-config/src/lib.rs
+++ b/util/app-config/src/lib.rs
@@ -21,7 +21,7 @@ pub use exit_code::ExitCode;
 pub use sentry_config::SentryConfig;
 
 use ckb_chain_spec::{consensus::Consensus, ChainSpec};
-use ckb_jsonrpc_types::{ScriptHashTypeShadow, VmVersion};
+use ckb_jsonrpc_types::{ScriptHashTypeKind, VmVersion};
 use ckb_types::{u256, H256, U256};
 use clap::{value_t, ArgMatches, ErrorKind};
 use std::{path::PathBuf, str::FromStr};
@@ -249,12 +249,12 @@ impl Setup {
             .unwrap_or_default()
             .map(str::to_string)
             .collect();
-        let block_assembler_hash_type = matches
-            .value_of(cli::ARG_BA_HASH_TYPE)
-            .and_then(|hash_type| serde_plain::from_str::<ScriptHashTypeShadow>(hash_type).ok())
+        let block_assembler_hash_type_kind = matches
+            .value_of(cli::ARG_BA_HASH_TYPE_KIND)
+            .and_then(|hash_type| serde_plain::from_str::<ScriptHashTypeKind>(hash_type).ok())
             .unwrap();
-        let block_assembler_vm_version = matches
-            .value_of(cli::ARG_BA_VM_VERSION)
+        let block_assembler_hash_type_vm_version = matches
+            .value_of(cli::ARG_BA_HASH_TYPE_VM_VERSION)
             .map(|vm_version| serde_plain::from_str::<VmVersion>(vm_version))
             .transpose()
             .unwrap();
@@ -281,8 +281,8 @@ impl Setup {
             log_to_stdout,
             block_assembler_code_hash,
             block_assembler_args,
-            block_assembler_hash_type,
-            block_assembler_vm_version,
+            block_assembler_hash_type_kind,
+            block_assembler_hash_type_vm_version,
             block_assembler_message,
             import_spec,
             customize_spec,
diff --git a/util/jsonrpc-types/src/blockchain.rs b/util/jsonrpc-types/src/blockchain.rs
index 585d1e253b..881430f81d 100644
--- a/util/jsonrpc-types/src/blockchain.rs
+++ b/util/jsonrpc-types/src/blockchain.rs
@@ -10,44 +10,98 @@ use std::fmt;
 
 /// Specifies how the script `code_hash` is used to match the script code.
 ///
-/// Allowed values: "data" and "type".
+/// Allowed kinds: "data" and "type".
+/// If the kind is "data", the "vm_version" must be provided.
+/// If the kind is "type", specifying "vm_version" is not allowed.
 ///
 /// Refer to the section [Code Locating](https://github.com/nervosnetwork/rfcs/blob/master/rfcs/0022-transaction-structure/0022-transaction-structure.md#code-locating)
 /// and [Upgradable Script](https://github.com/nervosnetwork/rfcs/blob/master/rfcs/0022-transaction-structure/0022-transaction-structure.md#upgradable-script)
 /// in the RFC *CKB Transaction Structure*.
 #[derive(Clone, Serialize, Deserialize, PartialEq, Eq, Hash, Debug)]
-#[serde(rename_all = "snake_case", deny_unknown_fields, tag = "hash_type")]
+#[serde(
+    rename_all = "snake_case",
+    deny_unknown_fields,
+    tag = "kind",
+    try_from = "ScriptHashTypeShadow"
+)]
 pub enum ScriptHashType {
     /// Type "data" matches script code via cell data hash.
     Data {
         /// CKB-VM version.
-        #[serde(default, skip_serializing_if = "VmVersion::is_default")]
         vm_version: VmVersion,
     },
     /// Type "type" matches script code via cell type script hash.
     Type,
 }
 
-#[doc(hidden)]
-#[derive(Clone, Copy, Deserialize, PartialEq, Eq, Hash, Debug)]
+/// Specifies how the script `code_hash` is used to match the script code.
+///
+/// Allowed kinds: "data" and "type".
+#[derive(Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash, Debug)]
 #[serde(rename_all = "snake_case")]
-pub enum ScriptHashTypeShadow {
+pub enum ScriptHashTypeKind {
+    /// Type "data" matches script code via cell data hash.
     Data,
+    /// Type "type" matches script code via cell type script hash.
     Type,
 }
 
+#[derive(Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct ScriptHashTypeShadow {
+    kind: ScriptHashTypeKind,
+    #[serde(rename = "vm_version", skip_serializing_if = "Option::is_none")]
+    vm_version_opt: Option<VmVersion>,
+}
+
+struct ScriptHashTypeValidationError(&'static str);
+
+impl std::fmt::Display for ScriptHashTypeValidationError {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(formatter, "{}", self.0)
+    }
+}
+
+impl std::convert::TryFrom<ScriptHashTypeShadow> for ScriptHashType {
+    type Error = ScriptHashTypeValidationError;
+    fn try_from(shadow: ScriptHashTypeShadow) -> Result<Self, Self::Error> {
+        let ScriptHashTypeShadow {
+            kind,
+            vm_version_opt,
+        } = shadow;
+        match kind {
+            ScriptHashTypeKind::Data => {
+                if let Some(vm_version) = vm_version_opt {
+                    Ok(ScriptHashType::Data { vm_version })
+                } else {
+                    Err(ScriptHashTypeValidationError(
+                        "vm version should be provided for hash-type \"data\".",
+                    ))
+                }
+            }
+            ScriptHashTypeKind::Type => {
+                if vm_version_opt.is_some() {
+                    Err(ScriptHashTypeValidationError(
+                        "vm version is not allowed for hash-type \"type\".",
+                    ))
+                } else {
+                    Ok(ScriptHashType::Type)
+                }
+            }
+        }
+    }
+}
+
 impl Default for ScriptHashType {
     fn default() -> Self {
-        ScriptHashType::Data {
-            vm_version: Default::default(),
-        }
+        ScriptHashType::Data { vm_version: 0 }
     }
 }
 
 impl From<ScriptHashType> for core::ScriptHashType {
     fn from(json: ScriptHashType) -> Self {
         match json {
-            ScriptHashType::Data { vm_version } => core::ScriptHashType::Data(vm_version.into()),
+            ScriptHashType::Data { vm_version } => core::ScriptHashType::Data(vm_version),
             ScriptHashType::Type => core::ScriptHashType::Type,
         }
     }
@@ -56,9 +110,7 @@ impl From<ScriptHashType> for core::ScriptHashType {
 impl From<core::ScriptHashType> for ScriptHashType {
     fn from(core: core::ScriptHashType) -> ScriptHashType {
         match core {
-            core::ScriptHashType::Data(v) => ScriptHashType::Data {
-                vm_version: v.into(),
-            },
+            core::ScriptHashType::Data(v) => ScriptHashType::Data { vm_version: v },
             core::ScriptHashType::Type => ScriptHashType::Type,
         }
     }
@@ -75,11 +127,11 @@ impl fmt::Display for ScriptHashType {
     }
 }
 
-impl fmt::Display for ScriptHashTypeShadow {
+impl fmt::Display for ScriptHashTypeKind {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         match self {
-            ScriptHashTypeShadow::Data => write!(f, "data"),
-            ScriptHashTypeShadow::Type => write!(f, "type"),
+            Self::Data => write!(f, "data"),
+            Self::Type => write!(f, "type"),
         }
     }
 }
@@ -93,71 +145,22 @@ impl fmt::Display for ScriptHashTypeShadow {
 /// {
 ///   "args": "0x",
 ///   "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-///   "hash_type": "data"
+///   "hash_type": {
+///     "kind": "data",
+///     "vm_version": 0
+///   }
 /// }
 /// # "#).unwrap();
 /// ```
 #[derive(Clone, Default, Serialize, Deserialize, PartialEq, Eq, Hash, Debug)]
-#[serde(try_from = "ScriptShadow")]
+#[serde(deny_unknown_fields)]
 pub struct Script {
     /// The hash used to match the script code.
     pub code_hash: H256,
-    /// Specifies how to use the `code_hash` to match the script code.
-    #[serde(flatten)]
-    pub hash_type: ScriptHashType,
     /// Arguments for script.
     pub args: JsonBytes,
-}
-
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-struct ScriptShadow {
-    code_hash: H256,
-    #[serde(rename = "hash_type")]
-    hash_type_shadow: ScriptHashTypeShadow,
-    #[serde(rename = "vm_version")]
-    vm_version_opt: Option<VmVersion>,
-    args: JsonBytes,
-}
-
-struct ScriptValidationError(&'static str);
-
-impl std::fmt::Display for ScriptValidationError {
-    fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(formatter, "{}", self.0)
-    }
-}
-
-impl std::convert::TryFrom<ScriptShadow> for Script {
-    type Error = ScriptValidationError;
-    fn try_from(shadow: ScriptShadow) -> Result<Self, Self::Error> {
-        let ScriptShadow {
-            code_hash,
-            hash_type_shadow,
-            vm_version_opt,
-            args,
-        } = shadow;
-        let hash_type = match hash_type_shadow {
-            ScriptHashTypeShadow::Data => {
-                let vm_version = vm_version_opt.unwrap_or_default();
-                ScriptHashType::Data { vm_version }
-            }
-            ScriptHashTypeShadow::Type => {
-                if vm_version_opt.is_some() {
-                    return Err(ScriptValidationError(
-                        "vm version is not allowed for hash-type \"type\".",
-                    ));
-                }
-                ScriptHashType::Type
-            }
-        };
-        let script = Script {
-            code_hash,
-            hash_type,
-            args,
-        };
-        Ok(script)
-    }
+    /// Specifies how to use the `code_hash` to match the script code.
+    pub hash_type: ScriptHashType,
 }
 
 impl From<Script> for packed::Script {
@@ -199,7 +202,10 @@ impl From<packed::Script> for Script {
 ///   "lock": {
 ///     "args": "0x",
 ///     "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-///     "hash_type": "data"
+///     "hash_type": {
+///       "kind": "data",
+///       "vm_version": 0
+///     }
 ///   },
 ///   "type": null
 /// }
@@ -513,7 +519,10 @@ pub struct Transaction {
 ///       "lock": {
 ///         "args": "0x",
 ///         "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
-///         "hash_type": "data"
+///         "hash_type": {
+///           "kind": "data",
+///           "vm_version": 0
+///         }
 ///       },
 ///       "type": null
 ///     }
@@ -1372,11 +1381,13 @@ mod tests {
         for (original, entity) in &[
             (
                 "{\
-                \"code_hash\":\"0x00000000000000000000000000000000\
-                                  00000000000000000000000000000000\",\
-                \"hash_type\":\"type\",\
-                \"args\":\"0x\"\
-             }",
+                    \"code_hash\":\"0x00000000000000000000000000000000\
+                                    00000000000000000000000000000000\",\
+                    \"args\":\"0x\",\
+                    \"hash_type\":{\
+                        \"kind\":\"type\"\
+                    }\
+                }",
                 Script {
                     code_hash: h256!("0x0"),
                     hash_type: ScriptHashType::Type,
@@ -1385,32 +1396,17 @@ mod tests {
             ),
             (
                 "{\
-                \"code_hash\":\"0x00000000000000000000000000000000\
-                                  00000000000000000000000000000000\",\
-                \"hash_type\":\"data\",\
-                \"args\":\"0x\"\
-             }",
-                Script {
-                    code_hash: h256!("0x0"),
-                    hash_type: ScriptHashType::Data {
-                        vm_version: VmVersion::default(),
-                    },
-                    args: JsonBytes::default(),
-                },
-            ),
-            (
-                "{\
-                \"code_hash\":\"0x00000000000000000000000000000000\
-                                  00000000000000000000000000000000\",\
-                \"hash_type\":\"data\",\
-                \"vm_version\":\"0x2\",\
-                \"args\":\"0x\"\
-             }",
+                    \"code_hash\":\"0x00000000000000000000000000000000\
+                                      00000000000000000000000000000001\",\
+                    \"args\":\"0x\",\
+                    \"hash_type\":{\
+                        \"kind\":\"data\",\
+                        \"vm_version\":2\
+                    }\
+                }",
                 Script {
-                    code_hash: h256!("0x0"),
-                    hash_type: ScriptHashType::Data {
-                        vm_version: 2.into(),
-                    },
+                    code_hash: h256!("0x1"),
+                    hash_type: ScriptHashType::Data { vm_version: 2 },
                     args: JsonBytes::default(),
                 },
             ),
@@ -1423,26 +1419,60 @@ mod tests {
         for malformed in &[
             "{\
                 \"code_hash\":\"0x00000000000000000000000000000000\
-                                  00000000000000000000000000000000\",\
-                \"hash_type\":\"type\",\
-                \"vm_version\":\"0x0\",\
+                                00000000000000000000000000000000\",\
                 \"args\":\"0x\"\
-             }",
+            }",
             "{\
                 \"code_hash\":\"0x00000000000000000000000000000000\
-                                  00000000000000000000000000000000\",\
-                \"hash_type\":\"data\",\
-                \"unknown_field\":\"0x0\",\
+                                00000000000000000000000000000000\",\
+                \"hash_type\":{\
+                    \"kind\":null\
+                },\
                 \"args\":\"0x\"\
-             }",
+            }",
+            "{\
+                \"code_hash\":\"0x00000000000000000000000000000000\
+                                00000000000000000000000000000000\",\
+                \"hash_type\":{\
+                    \"kind\":type\
+                },\
+                \"args\":\"0x\"\
+            }",
+            "{\
+                \"code_hash\":\"0x00000000000000000000000000000000\
+                                00000000000000000000000000000000\",\
+                \"hash_type\":{\
+                    \"kind\":\"data\"\
+                },\
+                \"args\":\"0x\"\
+            }",
             "{\
                 \"code_hash\":\"0x00000000000000000000000000000000\
                                   00000000000000000000000000000000\",\
-                \"hash_type\":\"data\",\
-                \"vm_version\":\"0x2\",\
-                \"unknown_field\":\"0x0\",\
+                \"hash_type\":{\
+                    \"kind\":\"type\",\
+                    \"vm_version\":0\
+                },\
+                \"args\":\"0x\"\
+            }",
+            "{\
+                \"code_hash\":\"0x00000000000000000000000000000000\
+                                00000000000000000000000000000000\",\
+                \"hash_type\":{\
+                    \"kind\":\"type\",\
+                    \"unknown_field\":0\
+                },\
+                \"args\":\"0x\"\
+            }",
+            "{\
+                \"code_hash\":\"0x00000000000000000000000000000000\
+                                00000000000000000000000000000000\",\
+                \"hash_type\":{\
+                    \"kind\":\"data\"\
+                },\
+                \"unknown_field\":0,\
                 \"args\":\"0x\"\
-             }",
+            }",
         ] {
             let result: Result<Script, _> = serde_json::from_str(&malformed);
             assert!(
diff --git a/util/jsonrpc-types/src/cell.rs b/util/jsonrpc-types/src/cell.rs
index 6e5755aefa..13b10da3c9 100644
--- a/util/jsonrpc-types/src/cell.rs
+++ b/util/jsonrpc-types/src/cell.rs
@@ -23,7 +23,10 @@ use serde::{Deserialize, Serialize};
 ///       "lock": {
 ///         "args": "0x",
 ///         "code_hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-///         "hash_type": "data"
+///         "hash_type": {
+///           "kind": "data",
+///           "vm_version": 0
+///         }
 ///       },
 ///       "type": null
 ///     }
@@ -78,7 +81,10 @@ pub struct CellWithStatus {
 ///     "lock": {
 ///       "args": "0x",
 ///       "code_hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-///       "hash_type": "data"
+///       "hash_type": {
+///         "kind": "data",
+///         "vm_version": 0
+///       }
 ///     },
 ///     "type": null
 ///   }
diff --git a/util/jsonrpc-types/src/lib.rs b/util/jsonrpc-types/src/lib.rs
index 10b47bf980..21924bb79d 100644
--- a/util/jsonrpc-types/src/lib.rs
+++ b/util/jsonrpc-types/src/lib.rs
@@ -24,7 +24,7 @@ pub use self::block_template::{
 pub use self::blockchain::{
     Block, BlockEconomicState, BlockIssuance, BlockView, CellDep, CellInput, CellOutput, Consensus,
     DepType, EpochView, Header, HeaderView, MerkleProof, MinerReward, OutPoint, ProposalWindow,
-    Script, ScriptHashType, ScriptHashTypeShadow, Status, Transaction, TransactionProof,
+    Script, ScriptHashType, ScriptHashTypeKind, Status, Transaction, TransactionProof,
     TransactionView, TransactionWithStatus, TxStatus, UncleBlock, UncleBlockView,
 };
 pub use self::bytes::JsonBytes;
@@ -45,7 +45,7 @@ pub use self::pool::{
 };
 pub use self::proposal_short_id::ProposalShortId;
 pub use self::subscription::Topic;
-pub use self::uints::{Uint128, Uint32, Uint64, Uint8};
+pub use self::uints::{Uint128, Uint32, Uint64};
 pub use primitive::{
     AsEpochNumberWithFraction, BlockNumber, Capacity, Cycle, EpochNumber, EpochNumberWithFraction,
     Timestamp, Version, VmVersion,
diff --git a/util/jsonrpc-types/src/primitive.rs b/util/jsonrpc-types/src/primitive.rs
index ff73127b65..e1aeeacaf4 100644
--- a/util/jsonrpc-types/src/primitive.rs
+++ b/util/jsonrpc-types/src/primitive.rs
@@ -1,4 +1,4 @@
-use crate::{Uint32, Uint64, Uint8};
+use crate::{Uint32, Uint64};
 use ckb_types::core::EpochNumberWithFraction as CkbEpochNumberWithFraction;
 
 /// Consecutive block number starting from 0.
@@ -47,10 +47,7 @@ pub type Timestamp = Uint64;
 pub type Version = Uint32;
 
 /// The ckb-vm version.
-///
-/// This is a 8-bit unsigned integer type encoded as the 0x-prefixed hex string in JSON.
-/// See examples of [Uint8](type.Uint8.html#examples).
-pub type VmVersion = Uint8;
+pub type VmVersion = u8;
 
 /// This trait is a restriction for type `Uint64`, so we can only get epoch_number, epoch_index
 /// and epoch_length from the type `EpochNumberWithFraction` instead of all `Uint64`
diff --git a/util/jsonrpc-types/src/uints.rs b/util/jsonrpc-types/src/uints.rs
index 15e2077188..a406be4234 100644
--- a/util/jsonrpc-types/src/uints.rs
+++ b/util/jsonrpc-types/src/uints.rs
@@ -166,11 +166,9 @@ macro_rules! impl_pack_and_unpack {
     };
 }
 
-def_json_uint!(Uint8, u8, "8-bit");
 def_json_uint!(Uint32, u32, "32-bit");
 def_json_uint!(Uint64, u64, "64-bit");
 def_json_uint!(Uint128, u128, "128-bit");
-impl_serde_deserialize!(Uint8Visitor, u8);
 impl_serde_deserialize!(Uint32Visitor, u32);
 impl_serde_deserialize!(Uint64Visitor, u64);
 impl_serde_deserialize!(Uint128Visitor, u128);
@@ -178,12 +176,6 @@ impl_pack_and_unpack!(Uint32, u32);
 impl_pack_and_unpack!(Uint64, u64);
 impl_pack_and_unpack!(Uint128, u128);
 
-impl Uint8 {
-    pub(crate) fn is_default(&self) -> bool {
-        self.0 == 0
-    }
-}
-
 impl From<core::Capacity> for JsonUint<u64> {
     fn from(value: core::Capacity) -> Self {
         JsonUint(value.as_u64())
@@ -276,7 +268,6 @@ mod tests {
         };
     }
 
-    test_json_uint!(uint8, Uint8, u8);
     test_json_uint!(uint32, Uint32, u32);
     test_json_uint!(uint64, Uint64, u64);
     test_json_uint!(uint128, Uint128, u128);

From f2b97822c7e1a9e857dbd25cb8c74485db94af51 Mon Sep 17 00:00:00 2001
From: Boyu Yang <yangby@cryptape.com>
Date: Tue, 29 Jun 2021 16:05:26 +0800
Subject: [PATCH 12/14] refactor(hardfork): disable hardfork feature if not
 set; set all to epoch 0 in default dev spec

---
 docs/hashes.toml                           |  2 +-
 resource/specs/dev.toml                    |  7 +++
 spec/src/hardfork.rs                       | 28 +++++-----
 spec/src/legacy/v2019.rs                   | 62 +++++++++++++++++++++-
 spec/src/lib.rs                            |  2 +-
 test/src/specs/hardfork/v2021/cell_deps.rs | 12 +++++
 test/src/specs/hardfork/v2021/extension.rs |  3 ++
 test/src/specs/hardfork/v2021/since.rs     |  6 +++
 test/template/specs/integration.toml       |  7 ---
 9 files changed, 105 insertions(+), 24 deletions(-)

diff --git a/docs/hashes.toml b/docs/hashes.toml
index 3fb3a56edf..f79b825d9f 100644
--- a/docs/hashes.toml
+++ b/docs/hashes.toml
@@ -134,7 +134,7 @@ index = 1
 
 # Spec: ckb_dev
 [ckb_dev]
-spec_hash = "0x0b936b2fd8dbee9f10c1186aa3dc643fe3e3299abcf15e6754088d34d7d58611"
+spec_hash = "0xc8dc9b41a93c64daf608231fd2061623c5cd73b10d6deb4ed22390324e358cc8"
 genesis = "0x823b2ff5785b12da8b1363cac9a5cbe566d8b715a4311441b119c39a0367488c"
 cellbase = "0xa563884b3686078ec7e7677a5f86449b15cf2693f3c1241766c6996f206cc541"
 
diff --git a/resource/specs/dev.toml b/resource/specs/dev.toml
index 1498c0f321..52e92b36ff 100644
--- a/resource/specs/dev.toml
+++ b/resource/specs/dev.toml
@@ -104,5 +104,12 @@ genesis_epoch_length = 1000
 # Keep difficulty be permanent if the pow is Dummy. (default: false)
 permanent_difficulty_in_dummy = true
 
+[params.hardfork]
+rfc_pr_0221 = 0
+rfc_pr_0222 = 0
+rfc_pr_0223 = 0
+rfc_pr_0224 = 0
+rfc_pr_0237 = 0
+
 [pow]
 func = "Dummy"
diff --git a/spec/src/hardfork.rs b/spec/src/hardfork.rs
index 76593ffb74..9e5cb15fd3 100644
--- a/spec/src/hardfork.rs
+++ b/spec/src/hardfork.rs
@@ -13,32 +13,34 @@ use serde::{Deserialize, Serialize};
 pub struct HardForkConfig {
     // TODO ckb2021 Update all rfc numbers and fix all links, after all proposals are merged.
     /// Ref: [CKB RFC xxxx](https://github.com/nervosnetwork/rfcs/tree/master/rfcs/xxxx-rfc-title)
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub rfc_pr_0221: Option<EpochNumber>,
     /// Ref: [CKB RFC xxxx](https://github.com/nervosnetwork/rfcs/tree/master/rfcs/xxxx-rfc-title)
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub rfc_pr_0222: Option<EpochNumber>,
     /// Ref: [CKB RFC xxxx](https://github.com/nervosnetwork/rfcs/tree/master/rfcs/xxxx-rfc-title)
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub rfc_pr_0223: Option<EpochNumber>,
     /// Ref: [CKB RFC xxxx](https://github.com/nervosnetwork/rfcs/tree/master/rfcs/xxxx-rfc-title)
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub rfc_pr_0224: Option<EpochNumber>,
     /// Ref: [CKB RFC xxxx](https://github.com/nervosnetwork/rfcs/tree/master/rfcs/xxxx-rfc-title)
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub rfc_pr_0237: Option<EpochNumber>,
 }
 
 macro_rules! check_default {
     ($config:ident, $feature:ident, $expected:expr) => {
-        match $config.$feature {
-            Some(input) if input != $expected => {
-                let errmsg = format!(
-                    "The value for hard fork feature \"{}\" is incorrect, actual: {}, expected: {}.
-                    Don't set it for mainnet or testnet, or set it as a correct value.",
-                    stringify!($feature),
-                    input,
-                    $expected,
-                );
-                Err(errmsg)
-            },
-            _ => Ok($expected),
-        }?
+        if $config.$feature.is_some() {
+            let errmsg = format!(
+                "Found the hard fork feature parameter \"{}\" is the chain specification file.
+                Don't set any hard fork parameters for \"mainnet\" or \"testnet\".",
+                stringify!($feature),
+            );
+            return Err(errmsg);
+        } else {
+            $expected
+        }
     };
 }
 
diff --git a/spec/src/legacy/v2019.rs b/spec/src/legacy/v2019.rs
index 4cb64c7bc4..31508a6e57 100644
--- a/spec/src/legacy/v2019.rs
+++ b/spec/src/legacy/v2019.rs
@@ -10,7 +10,7 @@ pub(crate) struct ChainSpec {
     name: String,
     pub(crate) genesis: Genesis,
     #[serde(default)]
-    params: crate::Params,
+    params: Params,
     pow: Pow,
     #[serde(skip)]
     pub(crate) hash: packed::Byte32,
@@ -35,6 +35,32 @@ pub(crate) struct Genesis {
     satoshi_gift: crate::SatoshiGift,
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize, Default)]
+struct Params {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    initial_primary_epoch_reward: Option<core::Capacity>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    secondary_epoch_reward: Option<core::Capacity>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    max_block_cycles: Option<core::Cycle>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    max_block_bytes: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    cellbase_maturity: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    primary_epoch_reward_halving_interval: Option<core::EpochNumber>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    epoch_duration_target: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    genesis_epoch_length: Option<core::BlockNumber>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    permanent_difficulty_in_dummy: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    max_block_proposals_limit: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    orphan_rate_target: Option<(u32, u32)>,
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 struct Script {
@@ -131,6 +157,38 @@ impl From<Genesis> for crate::Genesis {
     }
 }
 
+impl From<Params> for crate::Params {
+    fn from(input: Params) -> Self {
+        let Params {
+            initial_primary_epoch_reward,
+            secondary_epoch_reward,
+            max_block_cycles,
+            max_block_bytes,
+            cellbase_maturity,
+            primary_epoch_reward_halving_interval,
+            epoch_duration_target,
+            genesis_epoch_length,
+            permanent_difficulty_in_dummy,
+            max_block_proposals_limit,
+            orphan_rate_target,
+        } = input;
+        Self {
+            initial_primary_epoch_reward,
+            secondary_epoch_reward,
+            max_block_cycles,
+            max_block_bytes,
+            cellbase_maturity,
+            primary_epoch_reward_halving_interval,
+            epoch_duration_target,
+            genesis_epoch_length,
+            permanent_difficulty_in_dummy,
+            max_block_proposals_limit,
+            orphan_rate_target,
+            hardfork: None,
+        }
+    }
+}
+
 impl From<ChainSpec> for crate::ChainSpec {
     fn from(input: ChainSpec) -> Self {
         let ChainSpec {
@@ -144,7 +202,7 @@ impl From<ChainSpec> for crate::ChainSpec {
             name,
             edition: rpc::ChainEdition::V2021,
             genesis: genesis.into(),
-            params,
+            params: params.into(),
             pow,
             hash,
             legacy: true,
diff --git a/spec/src/lib.rs b/spec/src/lib.rs
index 7ac3f572a8..67516456d4 100644
--- a/spec/src/lib.rs
+++ b/spec/src/lib.rs
@@ -498,7 +498,7 @@ impl ChainSpec {
         match self.name.as_str() {
             "mainnet" => config.complete_mainnet(),
             "testnet" => config.complete_testnet(),
-            _ => config.complete_with_default(0),
+            _ => config.complete_with_default(EpochNumber::MAX),
         }
         .map_err(Into::into)
     }
diff --git a/test/src/specs/hardfork/v2021/cell_deps.rs b/test/src/specs/hardfork/v2021/cell_deps.rs
index e0fb64181f..65c35d1e16 100644
--- a/test/src/specs/hardfork/v2021/cell_deps.rs
+++ b/test/src/specs/hardfork/v2021/cell_deps.rs
@@ -122,6 +122,9 @@ impl Spec for DuplicateCellDepsForDataHashTypeLockScript {
     fn modify_chain_spec(&self, spec: &mut ckb_chain_spec::ChainSpec) {
         spec.params.permanent_difficulty_in_dummy = Some(true);
         spec.params.genesis_epoch_length = Some(GENESIS_EPOCH_LENGTH);
+        if spec.params.hardfork.is_none() {
+            spec.params.hardfork = Some(Default::default());
+        }
         if let Some(mut switch) = spec.params.hardfork.as_mut() {
             switch.rfc_pr_0222 = Some(CKB2021_START_EPOCH);
         }
@@ -181,6 +184,9 @@ impl Spec for DuplicateCellDepsForDataHashTypeTypeScript {
     fn modify_chain_spec(&self, spec: &mut ckb_chain_spec::ChainSpec) {
         spec.params.permanent_difficulty_in_dummy = Some(true);
         spec.params.genesis_epoch_length = Some(GENESIS_EPOCH_LENGTH);
+        if spec.params.hardfork.is_none() {
+            spec.params.hardfork = Some(Default::default());
+        }
         if let Some(mut switch) = spec.params.hardfork.as_mut() {
             switch.rfc_pr_0222 = Some(CKB2021_START_EPOCH);
         }
@@ -266,6 +272,9 @@ impl Spec for DuplicateCellDepsForTypeHashTypeLockScript {
     fn modify_chain_spec(&self, spec: &mut ckb_chain_spec::ChainSpec) {
         spec.params.permanent_difficulty_in_dummy = Some(true);
         spec.params.genesis_epoch_length = Some(GENESIS_EPOCH_LENGTH);
+        if spec.params.hardfork.is_none() {
+            spec.params.hardfork = Some(Default::default());
+        }
         if let Some(mut switch) = spec.params.hardfork.as_mut() {
             switch.rfc_pr_0222 = Some(CKB2021_START_EPOCH);
         }
@@ -350,6 +359,9 @@ impl Spec for DuplicateCellDepsForTypeHashTypeTypeScript {
     fn modify_chain_spec(&self, spec: &mut ckb_chain_spec::ChainSpec) {
         spec.params.permanent_difficulty_in_dummy = Some(true);
         spec.params.genesis_epoch_length = Some(GENESIS_EPOCH_LENGTH);
+        if spec.params.hardfork.is_none() {
+            spec.params.hardfork = Some(Default::default());
+        }
         if let Some(mut switch) = spec.params.hardfork.as_mut() {
             switch.rfc_pr_0222 = Some(CKB2021_START_EPOCH);
         }
diff --git a/test/src/specs/hardfork/v2021/extension.rs b/test/src/specs/hardfork/v2021/extension.rs
index 3359b2f5da..bae674bb7e 100644
--- a/test/src/specs/hardfork/v2021/extension.rs
+++ b/test/src/specs/hardfork/v2021/extension.rs
@@ -166,6 +166,9 @@ impl Spec for CheckBlockExtension {
     fn modify_chain_spec(&self, spec: &mut ckb_chain_spec::ChainSpec) {
         spec.params.permanent_difficulty_in_dummy = Some(true);
         spec.params.genesis_epoch_length = Some(GENESIS_EPOCH_LENGTH);
+        if spec.params.hardfork.is_none() {
+            spec.params.hardfork = Some(Default::default());
+        }
         if let Some(mut switch) = spec.params.hardfork.as_mut() {
             switch.rfc_pr_0224 = Some(2);
         }
diff --git a/test/src/specs/hardfork/v2021/since.rs b/test/src/specs/hardfork/v2021/since.rs
index b42923d62f..98cb4cefdc 100644
--- a/test/src/specs/hardfork/v2021/since.rs
+++ b/test/src/specs/hardfork/v2021/since.rs
@@ -102,6 +102,9 @@ impl Spec for CheckAbsoluteEpochSince {
     fn modify_chain_spec(&self, spec: &mut ckb_chain_spec::ChainSpec) {
         spec.params.permanent_difficulty_in_dummy = Some(true);
         spec.params.genesis_epoch_length = Some(GENESIS_EPOCH_LENGTH);
+        if spec.params.hardfork.is_none() {
+            spec.params.hardfork = Some(Default::default());
+        }
         if let Some(mut switch) = spec.params.hardfork.as_mut() {
             switch.rfc_pr_0223 = Some(2);
         }
@@ -182,6 +185,9 @@ impl Spec for CheckRelativeEpochSince {
     fn modify_chain_spec(&self, spec: &mut ckb_chain_spec::ChainSpec) {
         spec.params.permanent_difficulty_in_dummy = Some(true);
         spec.params.genesis_epoch_length = Some(GENESIS_EPOCH_LENGTH);
+        if spec.params.hardfork.is_none() {
+            spec.params.hardfork = Some(Default::default());
+        }
         if let Some(mut switch) = spec.params.hardfork.as_mut() {
             switch.rfc_pr_0223 = Some(5);
         }
diff --git a/test/template/specs/integration.toml b/test/template/specs/integration.toml
index 9a92cb248d..ba748b891c 100644
--- a/test/template/specs/integration.toml
+++ b/test/template/specs/integration.toml
@@ -68,12 +68,5 @@ primary_epoch_reward_halving_interval = 8760
 epoch_duration_target = 14400
 genesis_epoch_length = 1000
 
-[params.hardfork]
-rfc_pr_0221 = 9_223_372_036_854_775_807
-rfc_pr_0222 = 9_223_372_036_854_775_807
-rfc_pr_0223 = 9_223_372_036_854_775_807
-rfc_pr_0224 = 9_223_372_036_854_775_807
-rfc_pr_0237 = 9_223_372_036_854_775_807
-
 [pow]
 func = "Dummy"

From 59dc192ea60b7e164760d595fde663ea383168ce Mon Sep 17 00:00:00 2001
From: Boyu Yang <yangby@cryptape.com>
Date: Tue, 29 Jun 2021 17:26:00 +0800
Subject: [PATCH 13/14] fix(hardfork): the chain specification name is
 incorrect

---
 spec/src/lib.rs                       | 10 +++++++---
 util/constant/src/hardfork/mainnet.rs |  3 +++
 util/constant/src/hardfork/testnet.rs |  3 +++
 3 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/spec/src/lib.rs b/spec/src/lib.rs
index 67516456d4..376921f394 100644
--- a/spec/src/lib.rs
+++ b/spec/src/lib.rs
@@ -14,6 +14,7 @@ use crate::consensus::{
     build_genesis_dao_data, build_genesis_epoch_ext, Consensus, ConsensusBuilder,
     SATOSHI_CELL_OCCUPIED_RATIO, SATOSHI_PUBKEY_HASH, TYPE_ID_CODE_HASH,
 };
+use ckb_constant::hardfork::{mainnet, testnet};
 use ckb_crypto::secp::Privkey;
 use ckb_hash::{blake2b_256, new_blake2b};
 use ckb_jsonrpc_types::{ChainEdition, Script};
@@ -496,8 +497,8 @@ impl ChainSpec {
     fn build_hardfork_switch(&self) -> Result<HardForkSwitch, Box<dyn Error>> {
         let config = self.params.hardfork.as_ref().cloned().unwrap_or_default();
         match self.name.as_str() {
-            "mainnet" => config.complete_mainnet(),
-            "testnet" => config.complete_testnet(),
+            mainnet::CHAIN_SPEC_NAME => config.complete_mainnet(),
+            testnet::CHAIN_SPEC_NAME => config.complete_testnet(),
             _ => config.complete_with_default(EpochNumber::MAX),
         }
         .map_err(Into::into)
@@ -863,7 +864,10 @@ impl ChainSpec {
 
     /// If the CKB block chain specification is for an public chain.
     pub fn is_public_chain(&self) -> bool {
-        matches!(self.name.as_str(), "mainnet" | "testnet")
+        matches!(
+            self.name.as_str(),
+            mainnet::CHAIN_SPEC_NAME | testnet::CHAIN_SPEC_NAME
+        )
     }
 
     /// If the CKB block chain specification is loaded from a legacy format file.
diff --git a/util/constant/src/hardfork/mainnet.rs b/util/constant/src/hardfork/mainnet.rs
index 034af0f7a3..a964a7aa9d 100644
--- a/util/constant/src/hardfork/mainnet.rs
+++ b/util/constant/src/hardfork/mainnet.rs
@@ -1,3 +1,6 @@
+/// The Chain Specification name.
+pub const CHAIN_SPEC_NAME: &str = "ckb";
+
 // TODO ckb2021 Update the epoch number for mainnet.
 /// First epoch number for CKB v2021
 pub const CKB2021_START_EPOCH: u64 = u64::MAX;
diff --git a/util/constant/src/hardfork/testnet.rs b/util/constant/src/hardfork/testnet.rs
index 23a7d3adf2..c4abdd98d7 100644
--- a/util/constant/src/hardfork/testnet.rs
+++ b/util/constant/src/hardfork/testnet.rs
@@ -1,3 +1,6 @@
+/// The Chain Specification name.
+pub const CHAIN_SPEC_NAME: &str = "ckb_testnet";
+
 // TODO ckb2021 Update the epoch number for testnet.
 /// First epoch number for CKB v2021
 pub const CKB2021_START_EPOCH: u64 = u64::MAX;

From 09c79759227b3392b494511ada2c721459156e86 Mon Sep 17 00:00:00 2001
From: Boyu Yang <yangby@cryptape.com>
Date: Wed, 30 Jun 2021 02:04:05 +0800
Subject: [PATCH 14/14] feat(hardfork): reject unknown vm versions and add an
 integration test for this feature

---
 Cargo.lock                                  |   2 +
 script/src/error.rs                         |   2 +-
 test/Cargo.toml                             |   7 +
 test/src/main.rs                            |   1 +
 test/src/specs/hardfork/v2021/mod.rs        |   2 +
 test/src/specs/hardfork/v2021/vm_version.rs | 387 ++++++++++++++++++++
 util/constant/Cargo.toml                    |   3 +
 util/constant/src/lib.rs                    |  10 +
 util/jsonrpc-types/Cargo.toml               |   4 +
 util/jsonrpc-types/src/blockchain.rs        |  33 +-
 util/types/Cargo.toml                       |   4 +
 util/types/src/core/blockchain.rs           |  15 +-
 12 files changed, 459 insertions(+), 11 deletions(-)
 create mode 100644 test/src/specs/hardfork/v2021/vm_version.rs

diff --git a/Cargo.lock b/Cargo.lock
index e973fb2536..44006f5f0e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -722,6 +722,7 @@ dependencies = [
 name = "ckb-jsonrpc-types"
 version = "0.44.0-pre"
 dependencies = [
+ "ckb-constant",
  "ckb-types",
  "faster-hex",
  "lazy_static",
@@ -1426,6 +1427,7 @@ dependencies = [
  "bit-vec",
  "bytes 1.0.1",
  "ckb-channel",
+ "ckb-constant",
  "ckb-error",
  "ckb-fixed-hash",
  "ckb-hash",
diff --git a/script/src/error.rs b/script/src/error.rs
index f8b70dce2f..4dd7e70ca5 100644
--- a/script/src/error.rs
+++ b/script/src/error.rs
@@ -33,7 +33,7 @@ pub enum ScriptError {
     InvalidScriptHashType(String),
 
     /// InvalidVmVersion
-    #[error("Invalid vm version {0}")]
+    #[error("Invalid VM Version: {0}")]
     InvalidVmVersion(u8),
 
     /// Known bugs are detected in transaction script outputs
diff --git a/test/Cargo.toml b/test/Cargo.toml
index b23e21bfd4..f4086c9e7f 100644
--- a/test/Cargo.toml
+++ b/test/Cargo.toml
@@ -39,6 +39,13 @@ lazy_static = "1.4.0"
 byteorder = "1.3.1"
 jsonrpc-core = "17.1"
 
+[features]
+default = [
+    "ckb-constant/test-only",
+    "ckb-types/test-only",
+    "ckb-jsonrpc-types/test-only"
+]
+
 # Prevent this from interfering with workspaces
 [workspace]
 members = ["."]
diff --git a/test/src/main.rs b/test/src/main.rs
index b02c6798f1..7cf8eb1297 100644
--- a/test/src/main.rs
+++ b/test/src/main.rs
@@ -493,6 +493,7 @@ fn all_specs() -> Vec<Box<dyn Spec>> {
         Box::new(CheckAbsoluteEpochSince),
         Box::new(CheckRelativeEpochSince),
         Box::new(CheckBlockExtension),
+        Box::new(CheckVmVersion),
         Box::new(DuplicateCellDepsForDataHashTypeLockScript),
         Box::new(DuplicateCellDepsForDataHashTypeTypeScript),
         Box::new(DuplicateCellDepsForTypeHashTypeLockScript),
diff --git a/test/src/specs/hardfork/v2021/mod.rs b/test/src/specs/hardfork/v2021/mod.rs
index 0b4de99a0b..75162edd34 100644
--- a/test/src/specs/hardfork/v2021/mod.rs
+++ b/test/src/specs/hardfork/v2021/mod.rs
@@ -1,6 +1,7 @@
 mod cell_deps;
 mod extension;
 mod since;
+mod vm_version;
 
 pub use cell_deps::{
     DuplicateCellDepsForDataHashTypeLockScript, DuplicateCellDepsForDataHashTypeTypeScript,
@@ -8,3 +9,4 @@ pub use cell_deps::{
 };
 pub use extension::CheckBlockExtension;
 pub use since::{CheckAbsoluteEpochSince, CheckRelativeEpochSince};
+pub use vm_version::CheckVmVersion;
diff --git a/test/src/specs/hardfork/v2021/vm_version.rs b/test/src/specs/hardfork/v2021/vm_version.rs
new file mode 100644
index 0000000000..28dbf0551e
--- /dev/null
+++ b/test/src/specs/hardfork/v2021/vm_version.rs
@@ -0,0 +1,387 @@
+use crate::{
+    util::{
+        cell::gen_spendable,
+        check::{assert_epoch_should_less_than, is_transaction_committed},
+        mining::{mine, mine_until_bool, mine_until_epoch},
+    },
+    utils::{assert_send_transaction_fail, wait_until},
+    Node, Spec,
+};
+use ckb_constant::MAX_VM_VERSION as RPC_MAX_VM_VERSION;
+use ckb_jsonrpc_types as rpc;
+use ckb_logger::{debug, info};
+use ckb_types::{
+    core::{Capacity, DepType, ScriptHashType, TransactionView},
+    packed,
+    prelude::*,
+};
+use std::fmt;
+
+const MAX_VM_VERSION: u8 = RPC_MAX_VM_VERSION - 1;
+
+const GENESIS_EPOCH_LENGTH: u64 = 10;
+const CKB2021_START_EPOCH: u64 = 10;
+
+const TEST_CASES_COUNT: usize = (RPC_MAX_VM_VERSION as usize + 1 + 1) * 2;
+const INITIAL_INPUTS_COUNT: usize = 1 + TEST_CASES_COUNT * 2;
+
+pub struct CheckVmVersion;
+
+struct NewScript {
+    cell_dep: packed::CellDep,
+    data_hash: packed::Byte32,
+    type_hash: packed::Byte32,
+}
+
+#[derive(Debug, Clone, Copy)]
+enum ExpectedResult {
+    ShouldBePassed,
+    RpcInvalidVmVersion,
+    LockInvalidVmVersion,
+    TypeInvalidVmVersion,
+}
+
+struct CheckVmVersionTestRunner<'a> {
+    node: &'a Node,
+}
+
+impl Spec for CheckVmVersion {
+    crate::setup!(num_nodes: 2);
+
+    fn run(&self, nodes: &mut Vec<Node>) {
+        let epoch_length = GENESIS_EPOCH_LENGTH;
+        let ckb2019_last_epoch = CKB2021_START_EPOCH - 1;
+
+        let node = &nodes[0];
+        let node1 = &nodes[1];
+
+        mine(node, 1);
+        node1.connect(node);
+
+        {
+            let mut inputs = gen_spendable(node, INITIAL_INPUTS_COUNT)
+                .into_iter()
+                .map(|input| packed::CellInput::new(input.out_point, 0));
+            let script = NewScript::new_with_id(node, 0, &mut inputs);
+            let runner = CheckVmVersionTestRunner::new(node);
+
+            info!("CKB v2019:");
+            runner.run_all_tests(&mut inputs, &script, 0);
+
+            assert_epoch_should_less_than(node, ckb2019_last_epoch, epoch_length - 4, epoch_length);
+            mine_until_epoch(node, ckb2019_last_epoch, epoch_length - 4, epoch_length);
+
+            info!("CKB v2021:");
+            runner.run_all_tests(&mut inputs, &script, 1);
+        }
+
+        {
+            info!("Test Sync:");
+            let (rpc_client0, rpc_client1) = (node.rpc_client(), node1.rpc_client());
+
+            let ret = wait_until(20, || {
+                let header0 = rpc_client0.get_tip_header();
+                let header1 = rpc_client1.get_tip_header();
+                header0 == header1
+            });
+            assert!(
+                ret,
+                "Nodes should sync with each other until same tip chain",
+            );
+        }
+    }
+
+    fn modify_chain_spec(&self, spec: &mut ckb_chain_spec::ChainSpec) {
+        spec.params.permanent_difficulty_in_dummy = Some(true);
+        spec.params.genesis_epoch_length = Some(GENESIS_EPOCH_LENGTH);
+        if spec.params.hardfork.is_none() {
+            spec.params.hardfork = Some(Default::default());
+        }
+        if let Some(mut switch) = spec.params.hardfork.as_mut() {
+            switch.rfc_pr_0237 = Some(CKB2021_START_EPOCH);
+        }
+    }
+}
+
+impl NewScript {
+    fn new_with_id(
+        node: &Node,
+        id: u8,
+        inputs: &mut impl Iterator<Item = packed::CellInput>,
+    ) -> Self {
+        let original_data = node.always_success_raw_data();
+        let data = packed::Bytes::new_builder()
+            .extend(original_data.as_ref().iter().map(|x| (*x).into()))
+            .push(id.into())
+            .build();
+        let tx = Self::deploy(node, &data, inputs);
+        let cell_dep = packed::CellDep::new_builder()
+            .out_point(packed::OutPoint::new(tx.hash(), 0))
+            .dep_type(DepType::Code.into())
+            .build();
+        let data_hash = packed::CellOutput::calc_data_hash(&data.raw_data());
+        let type_hash = tx
+            .output(0)
+            .unwrap()
+            .type_()
+            .to_opt()
+            .unwrap()
+            .calc_script_hash();
+        Self {
+            cell_dep,
+            data_hash,
+            type_hash,
+        }
+    }
+
+    fn deploy(
+        node: &Node,
+        data: &packed::Bytes,
+        inputs: &mut impl Iterator<Item = packed::CellInput>,
+    ) -> TransactionView {
+        let type_script = node.always_success_script();
+        let tx_template = TransactionView::new_advanced_builder();
+        let cell_input = inputs.next().unwrap();
+        let cell_output = packed::CellOutput::new_builder()
+            .type_(Some(type_script).pack())
+            .build_exact_capacity(Capacity::bytes(data.len()).unwrap())
+            .unwrap();
+        let tx = tx_template
+            .cell_dep(node.always_success_cell_dep())
+            .input(cell_input)
+            .output(cell_output)
+            .output_data(data.clone())
+            .build();
+        node.submit_transaction(&tx);
+        mine_until_bool(node, || is_transaction_committed(node, &tx));
+        tx
+    }
+
+    fn cell_dep(&self) -> packed::CellDep {
+        self.cell_dep.clone()
+    }
+
+    fn as_data_script(&self, vm_version: u8) -> packed::Script {
+        packed::Script::new_builder()
+            .code_hash(self.data_hash.clone())
+            .hash_type(ScriptHashType::Data(vm_version).into())
+            .build()
+    }
+
+    fn as_type_script(&self) -> packed::Script {
+        packed::Script::new_builder()
+            .code_hash(self.type_hash.clone())
+            .hash_type(ScriptHashType::Type.into())
+            .build()
+    }
+}
+
+impl fmt::Display for ExpectedResult {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::ShouldBePassed => write!(f, "    allowed"),
+            _ => write!(f, "not allowed"),
+        }
+    }
+}
+
+impl ExpectedResult {
+    fn error_message(self) -> Option<&'static str> {
+        match self {
+            Self::ShouldBePassed => None,
+            Self::RpcInvalidVmVersion => Some(
+                "{\"code\":-32602,\"message\":\"\
+                 Invalid params: the maximum vm version currently supported is",
+            ),
+            Self::LockInvalidVmVersion => Some(
+                "{\"code\":-302,\"message\":\"TransactionFailedToVerify: \
+                 Verification failed Script(TransactionScriptError \
+                 { source: Inputs[0].Lock, cause: Invalid VM Version:",
+            ),
+            Self::TypeInvalidVmVersion => Some(
+                "{\"code\":-302,\"message\":\"TransactionFailedToVerify: \
+                 Verification failed Script(TransactionScriptError { \
+                 source: Outputs[0].Type, cause: Invalid VM Version: ",
+            ),
+        }
+    }
+}
+
+impl<'a> CheckVmVersionTestRunner<'a> {
+    fn new(node: &'a Node) -> Self {
+        Self { node }
+    }
+
+    fn test_create(
+        &self,
+        inputs: &mut impl Iterator<Item = packed::CellInput>,
+        cell_dep_opt: Option<packed::CellDep>,
+        script: packed::Script,
+        expected: ExpectedResult,
+    ) -> Option<TransactionView> {
+        let (tx_builder, co_builder) = if let Some(cell_dep) = cell_dep_opt {
+            (
+                TransactionView::new_advanced_builder().cell_dep(cell_dep),
+                packed::CellOutput::new_builder()
+                    .lock(self.node.always_success_script())
+                    .type_(Some(script).pack()),
+            )
+        } else {
+            (
+                TransactionView::new_advanced_builder(),
+                packed::CellOutput::new_builder().lock(script),
+            )
+        };
+        let cell_input = inputs.next().unwrap();
+        let input_cell = self.get_previous_output(&cell_input);
+        let cell_output = co_builder
+            .capacity((input_cell.capacity.value() - 1).pack())
+            .build();
+        let tx = tx_builder
+            .cell_dep(self.node.always_success_cell_dep())
+            .input(cell_input)
+            .output(cell_output)
+            .output_data(Default::default())
+            .build();
+        if let Some(errmsg) = expected.error_message() {
+            assert_send_transaction_fail(self.node, &tx, &errmsg);
+            None
+        } else {
+            self.submit_transaction_until_committed(&tx);
+            Some(tx)
+        }
+    }
+
+    fn test_spend(
+        &self,
+        tx: TransactionView,
+        cell_dep: packed::CellDep,
+        has_always_success: bool,
+        expected: ExpectedResult,
+    ) {
+        let out_point = packed::OutPoint::new(tx.hash(), 0);
+        let input = packed::CellInput::new(out_point, 0);
+        let output = packed::CellOutput::new_builder()
+            .build_exact_capacity(Capacity::shannons(0))
+            .unwrap();
+        let tx = if has_always_success {
+            TransactionView::new_advanced_builder().cell_dep(self.node.always_success_cell_dep())
+        } else {
+            TransactionView::new_advanced_builder()
+        }
+        .cell_dep(cell_dep)
+        .input(input)
+        .output(output)
+        .output_data(Default::default())
+        .build();
+        if let Some(errmsg) = expected.error_message() {
+            assert_send_transaction_fail(self.node, &tx, &errmsg);
+        } else {
+            self.submit_transaction_until_committed(&tx);
+        }
+    }
+
+    fn get_previous_output(&self, cell_input: &packed::CellInput) -> rpc::CellOutput {
+        let previous_output = cell_input.previous_output();
+        let previous_output_index: usize = previous_output.index().unpack();
+        self.node
+            .rpc_client()
+            .get_transaction(previous_output.tx_hash())
+            .unwrap()
+            .transaction
+            .inner
+            .outputs[previous_output_index]
+            .clone()
+    }
+
+    fn submit_transaction_until_committed(&self, tx: &TransactionView) {
+        debug!(">>> >>> submit: transaction {:#x}.", tx.hash());
+        self.node.submit_transaction(tx);
+        mine_until_bool(self.node, || is_transaction_committed(self.node, tx));
+    }
+
+    fn run_all_tests(
+        &self,
+        inputs: &mut impl Iterator<Item = packed::CellInput>,
+        script: &NewScript,
+        max_vm_version: u8,
+    ) {
+        for vm_version in 0..=RPC_MAX_VM_VERSION {
+            // TODO ckb2021 Should NOT pass if vm_version is greater than the max_vm_version?
+            let res = if vm_version <= MAX_VM_VERSION {
+                ExpectedResult::ShouldBePassed
+            } else {
+                ExpectedResult::RpcInvalidVmVersion
+            };
+            info!(
+                ">>> Create a   cell with Data({:2}) lock script is {}",
+                vm_version, res
+            );
+            let s = script.as_data_script(vm_version);
+            if let Some(tx) = self.test_create(inputs, None, s, res) {
+                let res = if vm_version <= max_vm_version {
+                    ExpectedResult::ShouldBePassed
+                } else {
+                    ExpectedResult::LockInvalidVmVersion
+                };
+                info!(
+                    ">>> Spend the  cell with Data({:2}) lock script is {}",
+                    vm_version, res
+                );
+                let dep = script.cell_dep();
+                self.test_spend(tx, dep, false, res);
+            }
+        }
+        {
+            let res = ExpectedResult::ShouldBePassed;
+            info!(">>> Create a   cell with Type     lock script is {}", res);
+            let s = script.as_type_script();
+            if let Some(tx) = self.test_create(inputs, None, s, res) {
+                let res = ExpectedResult::ShouldBePassed;
+                info!(">>> Spend the  cell with Type     lock script is {}", res);
+                let dep = script.cell_dep();
+                self.test_spend(tx, dep, false, res);
+            }
+        }
+        for vm_version in 0..=RPC_MAX_VM_VERSION {
+            let res = if vm_version <= max_vm_version {
+                ExpectedResult::ShouldBePassed
+            } else if vm_version <= MAX_VM_VERSION {
+                ExpectedResult::TypeInvalidVmVersion
+            } else {
+                ExpectedResult::RpcInvalidVmVersion
+            };
+            info!(
+                ">>> Create a   cell with Data({:2}) type script is {}",
+                vm_version, res
+            );
+            let dep = Some(script.cell_dep());
+            let s = script.as_data_script(vm_version);
+            if let Some(tx) = self.test_create(inputs, dep, s, res) {
+                let res = if vm_version <= max_vm_version {
+                    ExpectedResult::ShouldBePassed
+                } else {
+                    ExpectedResult::TypeInvalidVmVersion
+                };
+                info!(
+                    ">>> Spend the  cell with Data({:2}) type script is {}",
+                    vm_version, res
+                );
+                let dep = script.cell_dep();
+                self.test_spend(tx, dep, true, res);
+            }
+        }
+        {
+            let res = ExpectedResult::ShouldBePassed;
+            info!(">>> Create a   cell with Type     type script is {}", res);
+            let dep = Some(script.cell_dep());
+            let s = script.as_type_script();
+            if let Some(tx) = self.test_create(inputs, dep, s, res) {
+                let res = ExpectedResult::ShouldBePassed;
+                info!(">>> Spend the  cell with Type     type script is {}", res);
+                let dep = script.cell_dep();
+                self.test_spend(tx, dep, true, res);
+            }
+        }
+    }
+}
diff --git a/util/constant/Cargo.toml b/util/constant/Cargo.toml
index 6ceff83383..51ee9fd689 100644
--- a/util/constant/Cargo.toml
+++ b/util/constant/Cargo.toml
@@ -11,3 +11,6 @@ repository = "https://github.com/nervosnetwork/ckb"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+
+[features]
+test-only = []
diff --git a/util/constant/src/lib.rs b/util/constant/src/lib.rs
index 85eb438468..0c2330f108 100644
--- a/util/constant/src/lib.rs
+++ b/util/constant/src/lib.rs
@@ -6,3 +6,13 @@ pub mod hardfork;
 pub mod store;
 /// sync constant
 pub mod sync;
+
+/// The maximum vm version number.
+#[cfg(not(feature = "test-only"))]
+pub const MAX_VM_VERSION: u8 = 1;
+
+/// The fake maximum vm version number for test only.
+///
+/// This number should be 1 larger than the real maximum vm version number.
+#[cfg(feature = "test-only")]
+pub const MAX_VM_VERSION: u8 = 2;
diff --git a/util/jsonrpc-types/Cargo.toml b/util/jsonrpc-types/Cargo.toml
index ca645f2b83..052ed0db40 100644
--- a/util/jsonrpc-types/Cargo.toml
+++ b/util/jsonrpc-types/Cargo.toml
@@ -9,11 +9,15 @@ homepage = "https://github.com/nervosnetwork/ckb"
 repository = "https://github.com/nervosnetwork/ckb"
 
 [dependencies]
+ckb-constant = { path = "../constant", version = "= 0.44.0-pre" }
 ckb-types = { path = "../types", version = "= 0.44.0-pre" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 faster-hex = "0.6"
 
+[features]
+test-only = ["ckb-constant/test-only", "ckb-types/test-only"]
+
 [dev-dependencies]
 proptest = "0.9"
 regex = "1.1"
diff --git a/util/jsonrpc-types/src/blockchain.rs b/util/jsonrpc-types/src/blockchain.rs
index 881430f81d..b54eac20f6 100644
--- a/util/jsonrpc-types/src/blockchain.rs
+++ b/util/jsonrpc-types/src/blockchain.rs
@@ -3,6 +3,7 @@ use crate::{
     BlockNumber, Byte32, Capacity, Cycle, EpochNumber, EpochNumberWithFraction, ProposalShortId,
     Timestamp, Uint128, Uint32, Uint64, Version, VmVersion,
 };
+use ckb_constant::MAX_VM_VERSION;
 use ckb_types::{core, packed, prelude::*, H256};
 use serde::{Deserialize, Serialize};
 use std::convert::TryFrom;
@@ -46,15 +47,15 @@ pub enum ScriptHashTypeKind {
     Type,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Deserialize)]
 #[serde(deny_unknown_fields)]
 struct ScriptHashTypeShadow {
     kind: ScriptHashTypeKind,
-    #[serde(rename = "vm_version", skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "vm_version")]
     vm_version_opt: Option<VmVersion>,
 }
 
-struct ScriptHashTypeValidationError(&'static str);
+struct ScriptHashTypeValidationError(String);
 
 impl std::fmt::Display for ScriptHashTypeValidationError {
     fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
@@ -72,17 +73,24 @@ impl std::convert::TryFrom<ScriptHashTypeShadow> for ScriptHashType {
         match kind {
             ScriptHashTypeKind::Data => {
                 if let Some(vm_version) = vm_version_opt {
-                    Ok(ScriptHashType::Data { vm_version })
+                    if vm_version > MAX_VM_VERSION {
+                        Err(ScriptHashTypeValidationError(format!(
+                            "the maximum vm version currently supported is {}, but got {}.",
+                            MAX_VM_VERSION, vm_version
+                        )))
+                    } else {
+                        Ok(ScriptHashType::Data { vm_version })
+                    }
                 } else {
                     Err(ScriptHashTypeValidationError(
-                        "vm version should be provided for hash-type \"data\".",
+                        "vm version should be provided for hash-type \"data\".".to_owned(),
                     ))
                 }
             }
             ScriptHashTypeKind::Type => {
                 if vm_version_opt.is_some() {
                     Err(ScriptHashTypeValidationError(
-                        "vm version is not allowed for hash-type \"type\".",
+                        "vm version is not allowed for hash-type \"type\".".to_owned(),
                     ))
                 } else {
                     Ok(ScriptHashType::Type)
@@ -1401,12 +1409,12 @@ mod tests {
                     \"args\":\"0x\",\
                     \"hash_type\":{\
                         \"kind\":\"data\",\
-                        \"vm_version\":2\
+                        \"vm_version\":1\
                     }\
                 }",
                 Script {
                     code_hash: h256!("0x1"),
-                    hash_type: ScriptHashType::Data { vm_version: 2 },
+                    hash_type: ScriptHashType::Data { vm_version: 1 },
                     args: JsonBytes::default(),
                 },
             ),
@@ -1473,6 +1481,15 @@ mod tests {
                 \"unknown_field\":0,\
                 \"args\":\"0x\"\
             }",
+            "{\
+                \"code_hash\":\"0x00000000000000000000000000000000\
+                                  00000000000000000000000000000001\",\
+                \"args\":\"0x\",\
+                \"hash_type\":{\
+                    \"kind\":\"data\",\
+                    \"vm_version\":2\
+                }\
+            }",
         ] {
             let result: Result<Script, _> = serde_json::from_str(&malformed);
             assert!(
diff --git a/util/types/Cargo.toml b/util/types/Cargo.toml
index dba28aa9e8..38110a3479 100644
--- a/util/types/Cargo.toml
+++ b/util/types/Cargo.toml
@@ -9,6 +9,7 @@ homepage = "https://github.com/nervosnetwork/ckb"
 repository = "https://github.com/nervosnetwork/ckb"
 
 [dependencies]
+ckb-constant = { path = "../constant", version = "= 0.44.0-pre" }
 molecule = "=0.7.1"
 ckb-fixed-hash = { path = "../fixed-hash", version = "= 0.44.0-pre" }
 numext-fixed-uint = { version = "0.1", features = ["support_rand", "support_heapsize", "support_serde"] }
@@ -23,5 +24,8 @@ ckb-rational = { path = "../rational", version = "= 0.44.0-pre" }
 once_cell = "1.3.1"
 derive_more = { version = "0.99.0", default-features=false, features = ["display"] }
 
+[features]
+test-only = ["ckb-constant/test-only"]
+
 [dev-dependencies]
 proptest = "0.9"
diff --git a/util/types/src/core/blockchain.rs b/util/types/src/core/blockchain.rs
index 4ae9bd83cd..5ec4fba454 100644
--- a/util/types/src/core/blockchain.rs
+++ b/util/types/src/core/blockchain.rs
@@ -1,3 +1,4 @@
+use ckb_constant::MAX_VM_VERSION;
 use ckb_error::OtherError;
 use std::convert::TryFrom;
 
@@ -23,7 +24,17 @@ impl TryFrom<packed::Byte> for ScriptHashType {
 
     fn try_from(v: packed::Byte) -> Result<Self, Self::Error> {
         match Into::<u8>::into(v) {
-            x if x % 2 == 0 => Ok(ScriptHashType::Data(x / 2)),
+            x if x % 2 == 0 => {
+                let vm_version = x / 2;
+                if vm_version > MAX_VM_VERSION {
+                    Err(OtherError::new(format!(
+                        "The maximum vm version currently supported is {}, but got {}",
+                        MAX_VM_VERSION, vm_version
+                    )))
+                } else {
+                    Ok(ScriptHashType::Data(vm_version))
+                }
+            }
             1 => Ok(ScriptHashType::Type),
             _ => Err(OtherError::new(format!("Invalid script hash type {}", v))),
         }
@@ -33,7 +44,7 @@ impl TryFrom<packed::Byte> for ScriptHashType {
 impl ScriptHashType {
     #[inline]
     pub(crate) fn verify_value(v: u8) -> bool {
-        v % 2 == 0 || v == 1
+        v == 1 || ((v % 2 == 0) && (v / 2 <= MAX_VM_VERSION))
     }
 }