ADD: SIGCHECK inst

core/src/vm/error.rs

@@ -28,4 +28,13 @@ pub enum ProcessorError {
 
     #[error("Tload flag is invalid: {0}")]
     TloadFlagInvalid(u64),
+
+    #[error("Pubkey is invalid: {0}")]
+    PubKeyInvalid(String),
+
+    #[error("Signature is invalid: {0}")]
+    SignatureInvalid(String),
+
+    #[error("Message is invalid: {0}")]
+    MessageInvalid(String),
 }

executor/Cargo.toml

@@ -26,5 +26,7 @@ rand = "0.8"
 bincode = "1"
 byteorder = "1.3"
 tokio = { version = "1", features = ["full"] }
+secp256k1 = { version = "0.28.1", default-features = false, features = ["hashes-std", "std", "recovery"] }
+num = "0.4.1"
 
 [dev-dependencies]

executor/src/decode.rs

@@ -75,12 +75,7 @@ pub fn decode_raw_instruction(
                     instruction += &reg2_name;
                 }
             }
-            Opcode::CJMP
-            | Opcode::TSTORE
-            | Opcode::SCCALL
-            | Opcode::SLOAD
-            | Opcode::SSTORE
-            | Opcode::SIGCHECK => {
+            Opcode::CJMP | Opcode::TSTORE | Opcode::SCCALL | Opcode::SLOAD | Opcode::SSTORE => {
                 instruction += &op_code.to_string();
                 instruction += " ";
                 let reg1_name = format!("r{}", reg1);
@@ -95,7 +90,7 @@ pub fn decode_raw_instruction(
                     instruction += &reg2_name;
                 }
             }
-            Opcode::MOV | Opcode::NOT => {
+            Opcode::MOV | Opcode::NOT | Opcode::SIGCHECK => {
                 instruction += &op_code.to_string();
                 instruction += " ";
                 let reg0_name = format!("r{}", reg0);

executor/src/ecdsa.rs

@@ -0,0 +1,38 @@
+use core::types::merkle_tree::{tree_key_to_u8_arr, u8_arr_to_tree_key};
+use core::types::merkle_tree::{TreeKey, TreeValue};
+use core::vm::error::ProcessorError;
+use num::{BigUint, Num};
+use secp256k1::{ecdsa, Message, PublicKey, Secp256k1};
+pub fn ecdsa_verify(
+    x: TreeValue,
+    y: TreeValue,
+    r: TreeValue,
+    s: TreeValue,
+    msg: TreeValue,
+) -> Result<bool, ProcessorError> {
+    let secp = Secp256k1::new();
+
+    let x_arr = tree_key_to_u8_arr(&x);
+    let y_arr = tree_key_to_u8_arr(&y);
+
+    let mut pub_key_bytes = [0u8; 65];
+    pub_key_bytes[0] = 4;
+    pub_key_bytes[1..33].copy_from_slice(&x_arr);
+    pub_key_bytes[33..].copy_from_slice(&y_arr);
+    let pubkey = PublicKey::from_slice(&pub_key_bytes)
+        .map_err(|e| ProcessorError::PubKeyInvalid(e.to_string()))?;
+
+    let mut signature_bytes = [0u8; 64];
+    let r_arr = tree_key_to_u8_arr(&r);
+    let s_arr = tree_key_to_u8_arr(&s);
+
+    signature_bytes[..32].copy_from_slice(&r_arr);
+    signature_bytes[32..].copy_from_slice(&s_arr);
+    let sig = ecdsa::Signature::from_compact(&signature_bytes)
+        .map_err(|e| ProcessorError::SignatureInvalid(e.to_string()))?;
+
+    let msg_arr = tree_key_to_u8_arr(&msg);
+    let message =
+        Message::from_slice(&msg_arr).map_err(|e| ProcessorError::MessageInvalid(e.to_string()))?;
+    Ok(secp.verify_ecdsa(&message, &sig, &pubkey).is_ok())
+}

executor/src/lib.rs

@@ -39,6 +39,7 @@ use plonky2::field::types::{Field, PrimeField64};
 use regex::Regex;
 use std::collections::{BTreeMap, HashMap};
 
+use crate::ecdsa::ecdsa_verify;
 use crate::load_tx::{init_ctx_addr_info, load_ctx_addr_info};
 use crate::tape::TapeTree;
 use crate::trace::{gen_memory_table, gen_tape_table};
@@ -51,6 +52,7 @@ use std::time::Instant;
 
 mod decode;
 
+mod ecdsa;
 pub mod load_tx;
 pub mod storage;
 mod tape;
@@ -2020,7 +2022,10 @@ impl Process {
                         memory_op!(self, sig_s_addr + i, data, Opcode::SIGCHECK);
                         sig_s[i as usize] = data;
                     }
-
+                    self.registers[dst_index] = GoldilocksField::from_canonical_u8(ecdsa_verify(
+                        pk_x, pk_y, sig_r, sig_s, msg,
+                    )?
+                        as u8);
                     self.register_selector.dst = self.registers[dst_index];
                 }
                 _ => panic!("not match opcode:{}", opcode),

executor/src/tests.rs

@@ -15,6 +15,7 @@ use core::types::merkle_tree::tree_key_default;
 use core::types::merkle_tree::{decode_addr, encode_addr};
 use core::vm::transaction::init_tx_context_mock;
 use log::{debug, LevelFilter};
+use num::{BigInt, BigUint, Num};
 use plonky2::field::goldilocks_field::GoldilocksField;
 use plonky2::field::types::Field;
 use std::collections::HashMap;
@@ -468,7 +469,6 @@ fn ecdsa_test() {
     );
 }
 
-
 #[test]
 fn gen_storage_table_test() {
     let mut program: Program = Program::default();