Update src/vm.rs

src/vm.rs

@@ -19,18 +19,22 @@ impl BCNVM {
 
     pub fn run(&mut self) -> Result<(), String> {
         while self.pc < self.program.len() {
-            let instr = &self.program[self.pc..self.pc + 8];
+            // ✅ FIX: Copy instruction into owned buffer
+            let instr: [u8; 8] = self.program[self.pc..self.pc + 8]
+                .try_into()
+                .map_err(|_| "Invalid instruction length")?;
+
             let opcode = Opcode::from_byte(instr[0])
                 .ok_or("Invalid opcode")?;
 
             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::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::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()?,
@@ -38,7 +42,7 @@ impl BCNVM {
                 Opcode::ILOCK  => self.identity_lock()?,
                 Opcode::HALT   => break,
                 Opcode::NOOP   => {},
-                _ => {}
+                _ => return Err("Unimplemented opcode".into()),
             }
 
             self.pc += 8;
@@ -51,24 +55,24 @@ impl BCNVM {
             return Err("Trust underflow".into());
         }
         if self.state.credit_balance < 0 {
-            return Err("Negative credit".into());
+            return Err("Negative credit balance".into());
         }
         Ok(())
     }
 
-    fn trust_add(&mut self, instr: &[u8]) -> Result<(), String> {
+    fn trust_add(&mut self, instr: &[u8; 8]) -> Result<(), String> {
         let imm = instr[5] as i64;
         self.state.trust += imm;
         Ok(())
     }
 
-    fn trust_sub(&mut self, instr: &[u8]) -> Result<(), String> {
+    fn trust_sub(&mut self, instr: &[u8; 8]) -> Result<(), String> {
         let imm = instr[5] as i64;
         self.state.trust -= imm;
         Ok(())
     }
 
-    fn flow_add(&mut self, instr: &[u8]) -> Result<(), String> {
+    fn flow_add(&mut self, instr: &[u8; 8]) -> Result<(), String> {
         let imm = instr[5] as i64;
         self.state.flow_total += imm;
         Ok(())
@@ -86,22 +90,27 @@ impl BCNVM {
         Ok(())
     }
 
-    fn credit_issue(&mut self, instr: &[u8]) -> Result<(), String> {
+    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]) -> Result<(), String> {
+    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(())
     }