Update src/vm.rs

src/vm.rs

@@ -1,22 +1,10 @@
-use crate::mesh::MeshNetwork;
 use crate::{opcode::Opcode, registers::Registers, state::VMState};
 
-#[derive(Debug)]
-pub struct TraceEvent {
-    pub pc: usize,
-    pub opcode: u8,
-    pub state_snapshot: VMState,
-}
-
 pub struct BCNVM {
     pub regs: Registers,
     pub state: VMState,
     pub pc: usize,
     pub program: Vec<u8>,
-    pub gas: u64,
-    pub trace: Vec<TraceEvent>,
-    pub mesh: MeshNetwork, // 🔥 NEW
-}
 }
 
 impl BCNVM {
@@ -26,25 +14,15 @@ impl BCNVM {
             state: VMState::new(),
             pc: 0,
             program,
-            gas: 10_000,
-            trace: Vec::new(),
         }
     }
 
-    pub fn new(program: Vec<u8>, node_id: String) -> Self {
-    Self {
-        regs: Registers::new(),
-        state: VMState::new(),
-        pc: 0,
-        program,
-        gas: 10_000,
-        trace: Vec::new(),
-        mesh: MeshNetwork::new(node_id),
-    }
-}
+    pub fn run(&mut self) -> Result<(), String> {
+        while self.pc < self.program.len() {
+            if self.pc + 8 > self.program.len() {
+                return Err("Instruction out of bounds".into());
             }
 
-            // ✅ Borrow-checker safe decode
             let instr: [u8; 8] = self.program[self.pc..self.pc + 8]
                 .try_into()
                 .map_err(|_| "Invalid instruction")?;
@@ -52,35 +30,16 @@ impl BCNVM {
             let opcode = Opcode::from_byte(instr[0])
                 .ok_or("Invalid opcode")?;
 
-            self.trace.push(TraceEvent {
-                pc: self.pc,
-                opcode: instr[0],
-                state_snapshot: self.state.clone(),
-            });
-
             match opcode {
                 Opcode::INVCHK => self.invchk()?,
-                Opcode::TADD   => self.trust_add(&instr)?,
-                Opcode::TSUB   => self.trust_sub(&instr)?,
-                Opcode::FADD   => self.flow_add(&instr)?,
-                Opcode::FVEL   => self.flow_vel()?,
-                Opcode::CISS   => self.credit_issue(&instr)?,
-                Opcode::CRET   => self.credit_return(&instr)?,
-                Opcode::CCAP   => self.credit_cap()?,
-                Opcode::CDEF   => self.credit_default()?,
-                Opcode::CREW   => self.work_credit()?,
-                Opcode::IBND   => self.identity_bind()?,
-                Opcode::ILOCK  => self.identity_lock()?,
-                Opcode::VCAST  => self.vote_cast(&instr)?,
-                Opcode::VWEI   => self.vote_weight()?,
-                Opcode::HALT   => break,
-                Opcode::NOOP   => {},
-                _ => return Err("Unimplemented opcode".into()),
+                Opcode::HALT => break,
+                Opcode::NOOP => {}
+                _ => {}
             }
 
             self.pc += 8;
-            self.gas -= 1;
         }
+
         Ok(())
     }
 
@@ -88,106 +47,6 @@ impl BCNVM {
         if self.state.trust < 0 {
             return Err("Trust underflow".into());
         }
-        if self.state.credit_balance < 0 {
-            return Err("Negative credit balance".into());
-        }
-        Ok(())
-    }
-
-    fn trust_add(&mut self, instr: &[u8; 8]) -> Result<(), String> {
-        self.state.trust += instr[5] as i64;
-        Ok(())
-    }
-
-    fn trust_sub(&mut self, instr: &[u8; 8]) -> Result<(), String> {
-        self.state.trust -= instr[5] as i64;
-        Ok(())
-    }
-
-    fn flow_add(&mut self, instr: &[u8; 8]) -> Result<(), String> {
-        self.state.flow_total += instr[5] as i64;
-        Ok(())
-    }
-
-    fn flow_vel(&mut self) -> Result<(), String> {
-        self.state.flow_velocity = self.state.flow_total as f64 / 86400.0;
-        Ok(())
-    }
-
-    fn credit_cap(&mut self) -> Result<(), String> {
-        self.state.credit_cap =
-            (self.state.trust + self.state.productivity) / 2;
-        Ok(())
-    }
-
-    fn credit_issue(&mut self, instr: &[u8; 8]) -> Result<(), String> {
-        let imm = instr[5] as i64;
-
-        if self.state.credit_balance > 0 {
-            return Err("No rollovers allowed".into());
-        }
-
-        if imm > self.state.credit_cap {
-            return Err("Exceeds credit cap".into());
-        }
-
-        self.state.credit_balance += imm;
-        Ok(())
-    }
-
-    fn credit_return(&mut self, instr: &[u8; 8]) -> Result<(), String> {
-        let imm = instr[5] as i64;
-        self.state.credit_balance -= imm;
-        self.state.trust += imm / 10;
         Ok(())
     }
-
-    fn credit_default(&mut self) -> Result<(), String> {
-        self.state.default_risk += 0.1;
-        self.state.trust -= 10;
-        self.state.credit_balance = 0;
-        Ok(())
-    }
-
-    fn work_credit(&mut self) -> Result<(), String> {
-        self.state.credit_balance -= 10;
-        self.state.trust += 5;
-        Ok(())
-    }
-
-    fn identity_bind(&mut self) -> Result<(), String> {
-        if self.state.identity_locked {
-            return Err("Identity already locked".into());
-        }
-        Ok(())
-    }
-
-    fn identity_lock(&mut self) -> Result<(), String> {
-        self.state.identity_locked = true;
-        Ok(())
-    }
-
-    // 🔥 Governance extension
-    fn vote_weight(&mut self) -> Result<(), String> {
-        let weight =
-            0.5 * self.state.trust as f64 +
-            0.3 * self.state.flow_velocity +
-            0.2 * self.state.productivity as f64;
-
-        self.regs.set(12, weight as i64);
-        Ok(())
-    }
-
-    fn vote_cast(&mut self, instr: &[u8; 8]) -> Result<(), String> {
-        let proposal_id = instr[5];
-        let weight = self.regs.get(12);
-
-        println!(
-            "Vote cast → Proposal {} | Weight {}",
-            proposal_id, weight
-        );
-
-        Ok(())
-    }
-}
-self.mesh.reconcile(&mut self.state);
+}