refactor: Syscall generator is now the only interfact to customize verifier

Debug printer is now part of customizing syscall generator

Author: xxuejie

script/src/scheduler.rs

@@ -5,9 +5,9 @@ use crate::syscalls::{
 };
 
 use crate::types::{
-    CoreMachineType, DataLocation, DataPieceId, DebugContext, FIRST_FD_SLOT, FIRST_VM_ID, Fd,
-    FdArgs, FullSuspendedState, Machine, Message, ReadState, RunMode, SgData, SyscallGenerator,
-    VmArgs, VmContext, VmId, VmState, WriteState,
+    CoreMachineType, DataLocation, DataPieceId, FIRST_FD_SLOT, FIRST_VM_ID, Fd, FdArgs,
+    FullSuspendedState, Machine, Message, ReadState, RunMode, SgData, SyscallGenerator, VmArgs,
+    VmContext, VmId, VmState, WriteState,
 };
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_types::core::Cycle;
@@ -43,18 +43,17 @@ pub const MAX_FDS: u64 = 64;
 /// A scheduler holds & manipulates a core, the scheduler also holds
 /// all CKB-VM machines, each CKB-VM machine also gets a mutable reference
 /// of the core for IO operations.
-pub struct Scheduler<DL>
+pub struct Scheduler<DL, V>
 where
     DL: CellDataProvider,
 {
     /// Immutable context data for current running transaction & script.
     pub sg_data: SgData<DL>,
 
-    /// Mutable context data used by current scheduler
-    pub debug_context: DebugContext,
-
     /// Syscall generator
-    pub syscall_generator: SyscallGenerator<DL>,
+    pub syscall_generator: SyscallGenerator<DL, V>,
+    /// Syscall generator context
+    pub syscall_context: V,
 
     /// Total cycles. When a scheduler executes, there are 3 variables
     /// that might all contain charged cycles: +total_cycles+,
@@ -109,20 +108,21 @@ where
     pub message_box: Arc<Mutex<Vec<Message>>>,
 }
 
-impl<DL> Scheduler<DL>
+impl<DL, V> Scheduler<DL, V>
 where
     DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
+    V: Send + Clone,
 {
     /// Create a new scheduler from empty state
     pub fn new(
         sg_data: SgData<DL>,
-        debug_context: DebugContext,
-        syscall_generator: SyscallGenerator<DL>,
+        syscall_generator: SyscallGenerator<DL, V>,
+        syscall_context: V,
     ) -> Self {
         Self {
             sg_data,
-            debug_context,
             syscall_generator,
+            syscall_context,
             total_cycles: Arc::new(AtomicU64::new(0)),
             iteration_cycles: 0,
             next_vm_id: FIRST_VM_ID,
@@ -157,14 +157,14 @@ where
     /// Resume a previously suspended scheduler state
     pub fn resume(
         sg_data: SgData<DL>,
-        debug_context: DebugContext,
-        syscall_generator: SyscallGenerator<DL>,
+        syscall_generator: SyscallGenerator<DL, V>,
+        syscall_context: V,
         full: FullSuspendedState,
     ) -> Self {
         let mut scheduler = Self {
             sg_data,
-            debug_context,
             syscall_generator,
+            syscall_context,
             total_cycles: Arc::new(AtomicU64::new(full.total_cycles)),
             iteration_cycles: 0,
             next_vm_id: full.next_vm_id,
@@ -908,7 +908,7 @@ where
         let machine_builder = DefaultMachineBuilder::new(core_machine)
             .instruction_cycle_func(Box::new(estimate_cycles));
         let machine_builder =
-            (self.syscall_generator)(id, &self.sg_data, &vm_context, &self.debug_context)
+            (self.syscall_generator)(id, &self.sg_data, &vm_context, &self.syscall_context)
                 .into_iter()
                 .fold(machine_builder, |builder, syscall| builder.syscall(syscall));
         let default_machine = machine_builder.build();

script/src/syscalls/debugger.rs

@@ -1,5 +1,5 @@
 use crate::types::{
-    DebugContext, DebugPrinter, {SgData, SgInfo},
+    DebugPrinter, {SgData, SgInfo},
 };
 use crate::{cost_model::transferred_byte_cycles, syscalls::DEBUG_PRINT_SYSCALL_NUMBER};
 use ckb_vm::{
@@ -14,10 +14,10 @@ pub struct Debugger {
 }
 
 impl Debugger {
-    pub fn new<DL>(sg_data: &SgData<DL>, debug_context: &DebugContext) -> Debugger {
+    pub fn new<DL>(sg_data: &SgData<DL>, debug_printer: &DebugPrinter) -> Debugger {
         Debugger {
             sg_info: Arc::clone(&sg_data.sg_info),
-            printer: Arc::clone(&debug_context.debug_printer),
+            printer: Arc::clone(debug_printer),
         }
     }
 }

script/src/syscalls/generator.rs

@@ -4,7 +4,7 @@ use crate::{
         LoadCellData, LoadHeader, LoadInput, LoadScript, LoadScriptHash, LoadTx, LoadWitness, Pipe,
         ProcessID, Read, Spawn, VMVersion, Wait, Write,
     },
-    types::{CoreMachine, DebugContext, ScriptVersion, SgData, VmContext, VmId},
+    types::{CoreMachine, DebugPrinter, ScriptVersion, SgData, VmContext, VmId},
 };
 use ckb_traits::{CellDataProvider, ExtensionProvider, HeaderProvider};
 use ckb_vm::Syscalls;
@@ -14,7 +14,7 @@ pub fn generate_ckb_syscalls<DL>(
     vm_id: &VmId,
     sg_data: &SgData<DL>,
     vm_context: &VmContext<DL>,
-    debug_context: &DebugContext,
+    debug_printer: &DebugPrinter,
 ) -> Vec<Box<(dyn Syscalls<CoreMachine>)>>
 where
     DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
@@ -28,7 +28,7 @@ where
         Box::new(LoadWitness::new(sg_data)),
         Box::new(LoadScript::new(sg_data)),
         Box::new(LoadCellData::new(vm_context)),
-        Box::new(Debugger::new(sg_data, debug_context)),
+        Box::new(Debugger::new(sg_data, debug_printer)),
     ];
     let script_version = &sg_data.sg_info.script_version;
     if script_version >= &ScriptVersion::V1 {
@@ -54,9 +54,5 @@ where
             Box::new(Close::new(vm_id, vm_context)),
         ]);
     }
-    #[cfg(test)]
-    syscalls.push(Box::new(crate::syscalls::Pause::new(
-        std::sync::Arc::clone(&debug_context.skip_pause),
-    )));
     syscalls
 }

script/src/types.rs

@@ -72,25 +72,8 @@ pub type Machine = TraceMachine<CoreMachine>;
 /// Debug printer function type
 pub type DebugPrinter = Arc<dyn Fn(&Byte32, &str) + Send + Sync>;
 /// Syscall generator function type
-pub type SyscallGenerator<DL> = Arc<
-    dyn Fn(
-            &VmId,
-            &SgData<DL>,
-            &VmContext<DL>,
-            &DebugContext,
-        ) -> Vec<Box<(dyn Syscalls<CoreMachine>)>>
-        + Send
-        + Sync,
->;
-
-/// VM context used for debugging purposes
-pub struct DebugContext {
-    /// Debug printer in use.
-    pub debug_printer: DebugPrinter,
-    /// A flag to control pausing, only used in tests.
-    #[cfg(test)]
-    pub skip_pause: Arc<std::sync::atomic::AtomicBool>,
-}
+pub type SyscallGenerator<DL, V> =
+    fn(&VmId, &SgData<DL>, &VmContext<DL>, &V) -> Vec<Box<(dyn Syscalls<CoreMachine>)>>;
 
 /// The version of CKB Script Verifier.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]

script/src/verify.rs

@@ -6,9 +6,8 @@ use crate::{
     syscalls::generator::generate_ckb_syscalls,
     type_id::TypeIdSystemScript,
     types::{
-        CoreMachine, DebugContext, DebugPrinter, FullSuspendedState, RunMode, ScriptGroup,
-        ScriptGroupType, ScriptVersion, SgData, SyscallGenerator, TransactionState, TxData,
-        VerifyResult, VmContext, VmId,
+        DebugPrinter, FullSuspendedState, RunMode, ScriptGroup, ScriptGroupType, ScriptVersion,
+        SgData, SyscallGenerator, TransactionState, TxData, VerifyResult,
     },
     verify_env::TxVerifyEnv,
 };
@@ -23,19 +22,16 @@ use ckb_types::{
     packed::{Byte32, Script},
     prelude::*,
 };
+use ckb_vm::Error as VMInternalError;
 #[cfg(not(target_family = "wasm"))]
 use ckb_vm::machine::Pause as VMPause;
-use ckb_vm::{Error as VMInternalError, Syscalls};
 use std::sync::Arc;
 #[cfg(not(target_family = "wasm"))]
 use tokio::sync::{
     oneshot,
     watch::{self, Receiver},
 };
 
-#[cfg(test)]
-use core::sync::atomic::{AtomicBool, Ordering};
-
 #[cfg(test)]
 mod tests;
 
@@ -56,33 +52,23 @@ impl ChunkState {
 }
 
 /// This struct leverages CKB VM to verify transaction inputs.
-pub struct TransactionScriptsVerifier<DL: CellDataProvider> {
+pub struct TransactionScriptsVerifier<DL: CellDataProvider, V> {
     tx_data: Arc<TxData<DL>>,
-
-    debug_printer: DebugPrinter,
-    syscall_generator: SyscallGenerator<DL>,
-    #[cfg(test)]
-    skip_pause: Arc<AtomicBool>,
+    syscall_generator: SyscallGenerator<DL, V>,
+    syscall_context: V,
 }
 
-impl<DL> TransactionScriptsVerifier<DL>
+impl<DL> TransactionScriptsVerifier<DL, DebugPrinter>
 where
     DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
 {
-    /// Creates a script verifier for the transaction.
-    ///
-    /// ## Params
-    ///
-    /// * `rtx` - transaction which cell out points have been resolved.
-    /// * `data_loader` - used to load cell data.
+    /// Create a script verifier using default CKB syscalls and a default debug printer
     pub fn new(
         rtx: Arc<ResolvedTransaction>,
         data_loader: DL,
         consensus: Arc<Consensus>,
         tx_env: Arc<TxVerifyEnv>,
-    ) -> TransactionScriptsVerifier<DL> {
-        let tx_data = Arc::new(TxData::new(rtx, data_loader, consensus, tx_env));
-
+    ) -> Self {
         let debug_printer: DebugPrinter = Arc::new(
             #[allow(unused_variables)]
             |hash: &Byte32, message: &str| {
@@ -91,50 +77,58 @@ where
             },
         );
 
-        #[cfg(test)]
-        let skip_pause = Arc::new(AtomicBool::new(false));
+        Self::new_with_debug_printer(rtx, data_loader, consensus, tx_env, debug_printer)
+    }
 
-        TransactionScriptsVerifier {
-            tx_data,
+    /// Create a script verifier using default CKB syscalls and a custom debug printer
+    pub fn new_with_debug_printer(
+        rtx: Arc<ResolvedTransaction>,
+        data_loader: DL,
+        consensus: Arc<Consensus>,
+        tx_env: Arc<TxVerifyEnv>,
+        debug_printer: DebugPrinter,
+    ) -> Self {
+        Self::new_with_generator(
+            rtx,
+            data_loader,
+            consensus,
+            tx_env,
+            generate_ckb_syscalls,
             debug_printer,
-            syscall_generator: Arc::new(generate_ckb_syscalls),
-            #[cfg(test)]
-            skip_pause,
-        }
+        )
     }
+}
 
-    /// Sets a callback to handle the debug syscall.
-    ///
-    ///
-    /// Script can print a message using the [debug syscall](github.com/nervosnetwork/rfcs/blob/master/rfcs/0009-vm-syscalls/0009-vm-syscalls.md#debug).
+impl<DL, V> TransactionScriptsVerifier<DL, V>
+where
+    DL: CellDataProvider + HeaderProvider + ExtensionProvider + Send + Sync + Clone + 'static,
+    V: Send + Clone + 'static,
+{
+    /// Creates a script verifier for the transaction.
     ///
-    /// The callback receives two parameters:
+    /// ## Params
     ///
-    /// * `hash: &Byte32`: this is the script hash of currently running script group.
-    /// * `message: &str`: message passed to the debug syscall.
-    pub fn set_debug_printer<F: Fn(&Byte32, &str) + Sync + Send + 'static>(&mut self, func: F) {
-        self.debug_printer = Arc::new(func);
-    }
-
-    /// Sets a new syscall generator for special usages
-    pub fn set_syscall_generator<F>(&mut self, func: F)
-    where
-        F: Fn(
-                &VmId,
-                &SgData<DL>,
-                &VmContext<DL>,
-                &DebugContext,
-            ) -> Vec<Box<(dyn Syscalls<CoreMachine>)>>
-            + Sync
-            + Send
-            + 'static,
-    {
-        self.syscall_generator = Arc::new(func);
-    }
+    /// * `rtx` - transaction which cell out points have been resolved.
+    /// * `data_loader` - used to load cell data.
+    /// * `consensus` - consensus parameters.
+    /// * `tx_env` - enviroment for verifying transaction, such as committed block, etc.
+    /// * `syscall_generator` - a syscall generator for current verifier
+    /// * `syscall_context` - context for syscall generator
+    pub fn new_with_generator(
+        rtx: Arc<ResolvedTransaction>,
+        data_loader: DL,
+        consensus: Arc<Consensus>,
+        tx_env: Arc<TxVerifyEnv>,
+        syscall_generator: SyscallGenerator<DL, V>,
+        syscall_context: V,
+    ) -> TransactionScriptsVerifier<DL, V> {
+        let tx_data = Arc::new(TxData::new(rtx, data_loader, consensus, tx_env));
 
-    #[cfg(test)]
-    pub(crate) fn set_skip_pause(&self, skip_pause: bool) {
-        self.skip_pause.store(skip_pause, Ordering::SeqCst);
+        TransactionScriptsVerifier {
+            tx_data,
+            syscall_generator,
+            syscall_context,
+        }
     }
 
     //////////////////////////////////////////////////////////////////
@@ -570,17 +564,12 @@ where
     pub fn create_scheduler(
         &self,
         script_group: &ScriptGroup,
-    ) -> Result<Scheduler<DL>, ScriptError> {
+    ) -> Result<Scheduler<DL, V>, ScriptError> {
         let sg_data = SgData::new(&self.tx_data, script_group)?;
-        let debug_context = DebugContext {
-            debug_printer: Arc::clone(&self.debug_printer),
-            #[cfg(test)]
-            skip_pause: Arc::clone(&self.skip_pause),
-        };
         Ok(Scheduler::new(
             sg_data,
-            debug_context,
-            Arc::clone(&self.syscall_generator),
+            self.syscall_generator,
+            self.syscall_context.clone(),
         ))
     }
 
@@ -589,17 +578,12 @@ where
         &self,
         script_group: &ScriptGroup,
         state: &FullSuspendedState,
-    ) -> Result<Scheduler<DL>, ScriptError> {
+    ) -> Result<Scheduler<DL, V>, ScriptError> {
         let sg_data = SgData::new(&self.tx_data, script_group)?;
-        let debug_context = DebugContext {
-            debug_printer: Arc::clone(&self.debug_printer),
-            #[cfg(test)]
-            skip_pause: Arc::clone(&self.skip_pause),
-        };
         Ok(Scheduler::resume(
             sg_data,
-            debug_context,
-            Arc::clone(&self.syscall_generator),
+            self.syscall_generator,
+            self.syscall_context.clone(),
             state.clone(),
         ))
     }