PR cleanup - remove redundent logic & structs

Author: Manyfestation

Cargo.lock

@@ -1,2 +1,3 @@
 pub mod presentation;
 pub mod session;
+pub mod util;

debugger/session/src/lib.rs

@@ -1,6 +1,7 @@
 use silverscript_lang::debug_info::SourceSpan;
 
 use crate::session::DebugValue;
+use crate::util::{decode_i64, encode_hex};
 
 #[derive(Debug, Clone)]
 pub struct SourceContextLine {
@@ -110,28 +111,3 @@ fn array_element_size(element_type: &str) -> Option<usize> {
         other => other.strip_prefix("bytes").and_then(|v| v.parse::<usize>().ok()),
     }
 }
-
-fn decode_i64(bytes: &[u8]) -> Result<i64, String> {
-    if bytes.is_empty() {
-        return Ok(0);
-    }
-    if bytes.len() > 8 {
-        return Err("numeric value is longer than 8 bytes".to_string());
-    }
-    let msb = bytes[bytes.len() - 1];
-    let sign = 1 - 2 * ((msb >> 7) as i64);
-    let first_byte = (msb & 0x7f) as i64;
-    let mut value = first_byte;
-    for byte in bytes[..bytes.len() - 1].iter().rev() {
-        value = (value << 8) + (*byte as i64);
-    }
-    Ok(value * sign)
-}
-
-fn encode_hex(bytes: &[u8]) -> String {
-    let mut out = vec![0u8; bytes.len() * 2];
-    if faster_hex::hex_encode(bytes, &mut out).is_err() {
-        return String::new();
-    }
-    String::from_utf8(out).unwrap_or_default()
-}

debugger/session/src/presentation.rs

@@ -6,7 +6,6 @@ use kaspa_txscript::caches::Cache;
 use kaspa_txscript::covenants::CovenantsContext;
 use kaspa_txscript::script_builder::ScriptBuilder;
 use kaspa_txscript::{DynOpcodeImplementation, EngineCtx, EngineFlags, TxScriptEngine, parse_script};
-use serde::{Deserialize, Serialize};
 
 use silverscript_lang::ast::{Expr, ExprKind};
 use silverscript_lang::compiler::compile_debug_expr;
@@ -16,6 +15,7 @@ use silverscript_lang::debug_info::{
 
 pub use crate::presentation::{SourceContext, SourceContextLine};
 use crate::presentation::{build_source_context, format_value as format_debug_value};
+use crate::util::{decode_i64, encode_hex};
 
 pub type DebugTx<'a> = PopulatedTransaction<'a>;
 pub type DebugReused = SigHashReusedValuesUnsync;
@@ -76,20 +76,6 @@ pub struct SessionState {
     pub stack: Vec<String>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct StackSnapshot {
-    pub dstack: Vec<String>,
-    pub astack: Vec<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct OpcodeMeta {
-    pub index: usize,
-    pub byte_offset: usize,
-    pub display: String,
-    pub mapping: Option<DebugMapping>,
-}
-
 pub struct DebugSession<'a, 'i> {
     engine: DebugEngine<'a>,
     shadow_tx_context: Option<ShadowTxContext<'a>>,
@@ -124,17 +110,6 @@ struct VariableContext<'a> {
 impl<'a, 'i> DebugSession<'a, 'i> {
     // --- Session construction + stepping ---
 
-    /// Creates a debug session for lockscript-only execution.
-    /// Use this when debugging pure contract logic without sigscript setup.
-    pub fn lockscript_only(
-        script: &[u8],
-        source: &str,
-        debug_info: Option<DebugInfo<'i>>,
-        engine: DebugEngine<'a>,
-    ) -> Result<Self, kaspa_txscript_errors::TxScriptError> {
-        Self::from_scripts(script, source, debug_info, engine)
-    }
-
     /// Creates a debug session simulating a full transaction spend.
     /// Executes sigscript first to seed the stack, then debugs lockscript execution.
     pub fn full(
@@ -239,11 +214,6 @@ impl<'a, 'i> DebugSession<'a, 'i> {
         self.step_with_depth_predicate(|candidate, current| candidate < current)
     }
 
-    /// Backward-compatible statement stepping alias.
-    pub fn step_statement(&mut self) -> Result<Option<SessionState>, kaspa_txscript_errors::TxScriptError> {
-        self.step_over()
-    }
-
     /// Shared stepping loop for `step_into`, `step_over`, and `step_out`.
     /// Picks the next steppable mapping whose call depth satisfies `predicate`,
     /// executes opcodes until that mapping becomes active, and skips candidates
@@ -354,35 +324,6 @@ impl<'a, 'i> DebugSession<'a, 'i> {
         self.engine.is_executing()
     }
 
-    /// Returns the current data and alt stack contents.
-    pub fn stacks_snapshot(&self) -> StackSnapshot {
-        let stacks = self.engine.stacks();
-        StackSnapshot {
-            dstack: stacks.dstack.iter().map(|item| encode_hex(item)).collect(),
-            astack: stacks.astack.iter().map(|item| encode_hex(item)).collect(),
-        }
-    }
-
-    /// Returns metadata for all opcodes (executed/pending status, byte offset).
-    pub fn opcode_metas(&self) -> Vec<OpcodeMeta> {
-        (0..self.op_displays.len())
-            .map(|index| {
-                let byte_offset = self.opcode_offsets.get(index).copied().unwrap_or(self.script_len);
-                OpcodeMeta {
-                    index,
-                    byte_offset,
-                    display: self.op_displays.get(index).cloned().unwrap_or_default(),
-                    mapping: self.mapping_for_offset(byte_offset).cloned(),
-                }
-            })
-            .collect()
-    }
-
-    /// Returns the total number of opcodes in the script.
-    pub fn opcode_count(&self) -> usize {
-        self.op_displays.len()
-    }
-
     pub fn debug_info(&self) -> &DebugInfo<'i> {
         &self.debug_info
     }
@@ -807,26 +748,6 @@ fn decode_value_by_type(type_name: &str, bytes: Vec<u8>) -> Result<DebugValue, S
     }
 }
 
-/// Decodes a txscript script number (little-endian sign-magnitude, max 8 bytes).
-/// Mirrors txscript's internal numeric decode logic; kept local because txscript
-/// exposes this helper only as crate-private internals today.
-fn decode_i64(bytes: &[u8]) -> Result<i64, String> {
-    if bytes.is_empty() {
-        return Ok(0);
-    }
-    if bytes.len() > 8 {
-        return Err("numeric value is longer than 8 bytes".to_string());
-    }
-    let msb = bytes[bytes.len() - 1];
-    let sign = 1 - 2 * ((msb >> 7) as i64);
-    let first_byte = (msb & 0x7f) as i64;
-    let mut value = first_byte;
-    for byte in bytes[..bytes.len() - 1].iter().rev() {
-        value = (value << 8) + (*byte as i64);
-    }
-    Ok(value * sign)
-}
-
 /// Executes sigscript to seed the stack before debugging lockscript.
 fn seed_engine_with_sigscript(engine: &mut DebugEngine<'_>, sigscript: &[u8]) -> Result<(), kaspa_txscript_errors::TxScriptError> {
     for opcode in parse_script::<DebugTx<'_>, DebugReused>(sigscript) {
@@ -853,7 +774,6 @@ fn mapping_kind_order(kind: &MappingKind) -> u8 {
         MappingKind::Virtual {} => 1,
         MappingKind::Statement {} => 2,
         MappingKind::InlineCallExit { .. } => 3,
-        MappingKind::Synthetic { .. } => 4,
     }
 }
 
@@ -865,14 +785,6 @@ fn mapping_matches_offset(mapping: &DebugMapping, offset: usize) -> bool {
     }
 }
 
-fn encode_hex(bytes: &[u8]) -> String {
-    let mut out = vec![0u8; bytes.len() * 2];
-    if faster_hex::hex_encode(bytes, &mut out).is_err() {
-        return String::new();
-    }
-    String::from_utf8(out).unwrap_or_default()
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

debugger/session/src/session.rs

@@ -0,0 +1,27 @@
+/// Decodes a txscript script number (little-endian sign-magnitude, max 8 bytes).
+/// Mirrors txscript's internal numeric decode logic; kept local because txscript
+/// exposes this helper only as crate-private internals today.
+pub fn decode_i64(bytes: &[u8]) -> Result<i64, String> {
+    if bytes.is_empty() {
+        return Ok(0);
+    }
+    if bytes.len() > 8 {
+        return Err("numeric value is longer than 8 bytes".to_string());
+    }
+    let msb = bytes[bytes.len() - 1];
+    let sign = 1 - 2 * ((msb >> 7) as i64);
+    let first_byte = (msb & 0x7f) as i64;
+    let mut value = first_byte;
+    for byte in bytes[..bytes.len() - 1].iter().rev() {
+        value = (value << 8) + (*byte as i64);
+    }
+    Ok(value * sign)
+}
+
+pub fn encode_hex(bytes: &[u8]) -> String {
+    let mut out = vec![0u8; bytes.len() * 2];
+    if faster_hex::hex_encode(bytes, &mut out).is_err() {
+        return String::new();
+    }
+    String::from_utf8(out).unwrap_or_default()
+}

debugger/session/src/util.rs

@@ -114,7 +114,7 @@ fn debug_session_steps_forward() -> Result<(), Box<dyn Error>> {
         session.run_to_first_executed_statement()?;
         let before = session.state().pc;
         let before_span = session.current_span();
-        session.step_statement()?;
+        session.step_over()?;
         let after = session.state().pc;
         let after_span = session.current_span();
         assert!(after > before || after_span != before_span, "expected statement step to make source progress");