Update src/vm.rs

src/vm.rs

@@ -1,10 +1,19 @@
 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>,
 }
 
 impl BCNVM {
@@ -14,19 +23,35 @@ impl BCNVM {
             state: VMState::new(),
             pc: 0,
             program,
+            gas: 10_000,
+            trace: Vec::new(),
         }
     }
 
     pub fn run(&mut self) -> Result<(), String> {
         while self.pc < self.program.len() {
-            // ✅ FIX: Copy instruction into owned buffer
+            if self.gas == 0 {
+                return Err("Out of gas".into());
+            }
+
+            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 length")?;
+                .map_err(|_| "Invalid instruction")?;
 
             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)?,
@@ -40,12 +65,15 @@ impl BCNVM {
                 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()),
             }
 
             self.pc += 8;
+            self.gas -= 1;
         }
         Ok(())
     }
@@ -61,26 +89,22 @@ impl BCNVM {
     }
 
     fn trust_add(&mut self, instr: &[u8; 8]) -> Result<(), String> {
-        let imm = instr[5] as i64;
-        self.state.trust += imm;
+        self.state.trust += instr[5] as i64;
         Ok(())
     }
 
     fn trust_sub(&mut self, instr: &[u8; 8]) -> Result<(), String> {
-        let imm = instr[5] as i64;
-        self.state.trust -= imm;
+        self.state.trust -= instr[5] as i64;
         Ok(())
     }
 
     fn flow_add(&mut self, instr: &[u8; 8]) -> Result<(), String> {
-        let imm = instr[5] as i64;
-        self.state.flow_total += imm;
+        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;
+        self.state.flow_velocity = self.state.flow_total as f64 / 86400.0;
         Ok(())
     }
 
@@ -107,10 +131,8 @@ impl BCNVM {
 
     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(())
     }
 
@@ -138,4 +160,27 @@ impl BCNVM {
         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(())
+    }
 }