Implement OP_WITHIN opcode

src/compiler.cairo

@@ -21,6 +21,8 @@ pub impl CompilerTraitImpl of CompilerTrait {
         opcodes.insert('OP_0', Opcode::OP_0);
         opcodes.insert('OP_1', Opcode::OP_1);
         opcodes.insert('OP_ADD', Opcode::OP_ADD);
+        opcodes.insert('OP_GREATERTHAN', Opcode::OP_GREATERTHAN);
+        opcodes.insert('OP_WITHIN', Opcode::OP_WITHIN);
         Compiler { opcodes }
     }
 

src/opcodes/opcodes.cairo

@@ -2,6 +2,8 @@ pub mod Opcode {
     pub const OP_0: u8 = 0;
     pub const OP_1: u8 = 81;
     pub const OP_ADD: u8 = 147;
+    pub const OP_GREATERTHAN: u8 = 160;
+    pub const OP_WITHIN: u8 = 165;
 
     use shinigami::engine::Engine;
     use shinigami::stack::ScriptStackTrait;
@@ -155,7 +157,25 @@ pub mod Opcode {
             145 => not_implemented(ref engine),
             146 => not_implemented(ref engine),
             147 => opcode_add(ref engine),
-            _ => not_implemented(ref engine)
+            148 => not_implemented(ref engine),
+            149 => not_implemented(ref engine),
+            150 => not_implemented(ref engine),
+            151 => not_implemented(ref engine),
+            152 => not_implemented(ref engine),
+            153 => not_implemented(ref engine),
+            154 => not_implemented(ref engine),
+            155 => not_implemented(ref engine),
+            156 => not_implemented(ref engine),
+            157 => not_implemented(ref engine),
+            158 => not_implemented(ref engine),
+            159 => not_implemented(ref engine),
+            160 => opcode_greaterthan(ref engine),
+            161 => not_implemented(ref engine),
+            162 => not_implemented(ref engine),
+            163 => not_implemented(ref engine),
+            164 => not_implemented(ref engine),
+            165 => opcode_within(ref engine),
+            _ => not_implemented(ref engine),
         }
     }
 
@@ -174,6 +194,27 @@ pub mod Opcode {
         engine.dstack.push_int(a + b);
     }
 
+    fn opcode_greaterthan(ref engine: Engine) {
+        let a = engine.dstack.pop_int();
+        let b = engine.dstack.pop_int();
+        engine.dstack.push_int(if a > b {
+            0
+        } else {
+            1
+        });
+    }
+
+    fn opcode_within(ref engine: Engine) {
+        let a = engine.dstack.pop_int();
+        let b = engine.dstack.pop_int();
+        let c = engine.dstack.pop_int();
+        engine.dstack.push_int(if a >= b && a < c {
+            0
+        } else {
+            1
+        });
+    }
+
     fn not_implemented(ref engine: Engine) {
         panic!("Opcode not implemented");
     }

src/opcodes/tests/test_opcodes.cairo

@@ -51,3 +51,40 @@ fn test_op_add() {
     let expected_stack = array!["\0\0\0\0\0\0\0\x02"];
     assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected");
 }
+
+#[test]
+fn test_op_greaterthan() {
+    let program = "OP_1 OP_0 OP_GREATERTHAN";
+    let mut compiler = CompilerTraitImpl::new();
+    let bytecode = compiler.compile(program);
+    let mut engine = EngineTraitImpl::new(bytecode);
+    let _ = engine.step();
+    let _ = engine.step();
+    let res = engine.step();
+    assert!(res, "Execution of run failed");
+
+    let dstack = engine.get_dstack();
+    assert_eq!(dstack.len(), 1, "Stack length is not 1");
+
+    let expected_stack = array!["\0\0\0\0\0\0\0\x01"];
+    assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected");
+}
+
+#[test]
+fn test_op_within() {
+    let program = "OP_1 OP_0 OP_1 OP_WITHIN";
+    let mut compiler = CompilerTraitImpl::new();
+    let bytecode = compiler.compile(program);
+    let mut engine = EngineTraitImpl::new(bytecode);
+    let _ = engine.step();
+    let _ = engine.step();
+    let _ = engine.step();
+    let res = engine.step();
+    assert!(res, "Execution of run failed");
+
+    let dstack = engine.get_dstack();
+    assert_eq!(dstack.len(), 1, "Stack length is not 1");
+
+    let expected_stack = array!["\0\0\0\0\0\0\0\x01"];
+    assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected");
+}