Update opcodes and instructions

Author: Joon-Mo Yang

vm/src/decoder.rs

@@ -31,7 +31,18 @@ pub fn decode(bytes: &[u8]) -> Result<Vec<Instruction>, DecoderError> {
  opcode::NOP => result.push(Instruction::Nop),
  opcode::NOT => result.push(Instruction::Not),
  opcode::EQ => result.push(Instruction::Eq),
- opcode::JMP => result.push(Instruction::Jmp),
+ opcode::JMP => {
+ let val = *iter.next().ok_or(DecoderError::ScriptTooShort)?;
+ result.push(Instruction::Jmp(val));
+ },
+ opcode::JNZ => {
+ let val = *iter.next().ok_or(DecoderError::ScriptTooShort)?;
+ result.push(Instruction::Jnz(val));
+ },
+ opcode::JZ => {
+ let val = *iter.next().ok_or(DecoderError::ScriptTooShort)?;
+ result.push(Instruction::Jz(val));
+ },
  opcode::PUSH => {
  let val = *iter.next().ok_or(DecoderError::ScriptTooShort)?;
  result.push(Instruction::Push(val));
@@ -48,8 +59,18 @@ pub fn decode(bytes: &[u8]) -> Result<Vec<Instruction>, DecoderError> {
  }
  opcode::DUP => result.push(Instruction::Dup),
  opcode::SWAP => result.push(Instruction::Swap),
- opcode::BLAKE256 => result.push(Instruction::Blake256),
+ opcode::COPY => {
+ let val = *iter.next().ok_or(DecoderError::ScriptTooShort)?;
+ result.push(Instruction::Copy(val));
+ },
+ opcode::DROP => {
+ let val = *iter.next().ok_or(DecoderError::ScriptTooShort)?;
+ result.push(Instruction::Drop(val));
+ },
  opcode::CHKSIG => result.push(Instruction::ChkSig),
+ opcode::BLAKE256 => result.push(Instruction::Blake256),
+ opcode::SHA256 => result.push(Instruction::Sha256),
+ opcode::RIPEMD160 => result.push(Instruction::Ripemd160),
  invalid_opcode => return Err(DecoderError::InvalidOpCode(invalid_opcode)),
  }
  }

vm/src/executor.rs

@@ -125,15 +125,18 @@ pub fn execute(
  Instruction::Nop => {}
  Instruction::Not => unimplemented!(),
  Instruction::Eq => unimplemented!(),
- Instruction::Jmp => unimplemented!(),
+ Instruction::Jmp(..) => unimplemented!(),
+ Instruction::Jnz(..) => unimplemented!(),
+ Instruction::Jz(..) => unimplemented!(),
  Instruction::Push(val) => stack.push(Item(vec![*val]))?,
  Instruction::Pop => {
  stack.pop()?;
  }
  Instruction::PushB(blob) => stack.push(Item(blob.clone()))?,
  Instruction::Dup => unimplemented!(),
  Instruction::Swap => unimplemented!(),
- Instruction::Blake256 => unimplemented!(),
+ Instruction::Copy(..) => unimplemented!(),
+ Instruction::Drop(..) => unimplemented!(),
  Instruction::ChkSig => {
  let pubkey = Public::from_slice(stack.pop()?.assert_len(64)?.as_ref());
  let signature = ECDSASignature::from(H520::from(stack.pop()?.assert_len(65)?.as_ref()));
@@ -142,7 +145,10 @@ pub fn execute(
  _ => 0,
  };
  stack.push(Item(vec![result]))?;
- }
+ },
+ Instruction::Blake256 => unimplemented!(),
+ Instruction::Sha256 => unimplemented!(),
+ Instruction::Ripemd160 => unimplemented!(),
  }
  pc += 1;
  }

vm/src/instruction.rs

@@ -19,12 +19,18 @@ pub enum Instruction {
  Nop,
  Not,
  Eq,
- Jmp,
+ Jmp(u8),
+ Jnz(u8),
+ Jz(u8),
  Push(u8),
  Pop,
  PushB(Vec<u8>),
  Dup,
  Swap,
- Blake256,
+ Copy(u8),
+ Drop(u8),
  ChkSig,
+ Blake256,
+ Sha256,
+ Ripemd160,
 }

vm/src/opcode.rs

@@ -18,10 +18,16 @@ pub const NOP: u8 = 0x00;
 pub const NOT: u8 = 0x10;
 pub const EQ: u8 = 0x11;
 pub const JMP: u8 = 0x20;
+pub const JNZ: u8 = 0x21;
+pub const JZ: u8 = 0x22;
 pub const PUSH: u8 = 0x30;
 pub const POP: u8 = 0x31;
 pub const PUSHB: u8 = 0x32;
 pub const DUP: u8 = 0x33;
 pub const SWAP: u8 = 0x34;
-pub const BLAKE256: u8 = 0x80;
-pub const CHKSIG: u8 = 0x81;
+pub const COPY: u8 = 0x35;
+pub const DROP: u8 = 0x36;
+pub const CHKSIG: u8 = 0x80;
+pub const BLAKE256: u8 = 0x90;
+pub const SHA256: u8 = 0x91;
+pub const RIPEMD160: u8 = 0x92;

vm/src/tests/decoder.rs

@@ -24,12 +24,13 @@ fn test_single_byte_opcodes() {
  (opcode::NOP, Instruction::Nop),
  (opcode::NOT, Instruction::Not),
  (opcode::EQ, Instruction::Eq),
- (opcode::JMP, Instruction::Jmp),
  (opcode::POP, Instruction::Pop),
  (opcode::DUP, Instruction::Dup),
  (opcode::SWAP, Instruction::Swap),
- (opcode::BLAKE256, Instruction::Blake256),
  (opcode::CHKSIG, Instruction::ChkSig),
+ (opcode::BLAKE256, Instruction::Blake256),
+ (opcode::SHA256, Instruction::Sha256),
+ (opcode::RIPEMD160, Instruction::Ripemd160),
  ];
  for &(ref byte, ref code) in target.into_iter() {
  let script = decode(&[byte.clone(), byte.clone(), byte.clone()]);
@@ -43,6 +44,36 @@ fn push() {
  assert_eq!(decode(&[opcode::PUSH, 0, opcode::PUSH]), Err(DecoderError::ScriptTooShort));
 }
 
+#[test]
+fn copy() {
+ assert_eq!(decode(&[opcode::COPY, 0, opcode::COPY, 10]), Ok(vec![Instruction::Copy(0), Instruction::Copy(10)]));
+ assert_eq!(decode(&[opcode::COPY, 0, opcode::COPY]), Err(DecoderError::ScriptTooShort));
+}
+
+#[test]
+fn drop() {
+ assert_eq!(decode(&[opcode::DROP, 0, opcode::DROP, 10]), Ok(vec![Instruction::Drop(0), Instruction::Drop(10)]));
+ assert_eq!(decode(&[opcode::DROP, 0, opcode::DROP]), Err(DecoderError::ScriptTooShort));
+}
+
+#[test]
+fn jmp() {
+ assert_eq!(decode(&[opcode::JMP, 0, opcode::JMP, 10]), Ok(vec![Instruction::Jmp(0), Instruction::Jmp(10)]));
+ assert_eq!(decode(&[opcode::JMP, 0, opcode::JMP]), Err(DecoderError::ScriptTooShort));
+}
+
+#[test]
+fn jnz() {
+ assert_eq!(decode(&[opcode::JNZ, 0, opcode::JNZ, 10]), Ok(vec![Instruction::Jnz(0), Instruction::Jnz(10)]));
+ assert_eq!(decode(&[opcode::JNZ, 0, opcode::JNZ]), Err(DecoderError::ScriptTooShort));
+}
+
+#[test]
+fn jz() {
+ assert_eq!(decode(&[opcode::JZ, 0, opcode::JZ, 10]), Ok(vec![Instruction::Jz(0), Instruction::Jz(10)]));
+ assert_eq!(decode(&[opcode::JZ, 0, opcode::JZ]), Err(DecoderError::ScriptTooShort));
+}
+
 #[test]
 fn pushb() {
  let blobs: Vec<&[u8]> = vec![&[0xed, 0x11, 0xe7], &[0x8b, 0x0c, 0x92, 0x24, 0x3f]];