Initial instruction definition implemented

Author: nemothenoone

Cargo.toml

@@ -19,6 +19,7 @@ similar = { features = [ 'bytes' ], optional = true, version = '2.2.0' }
 ton_block = { git = 'https://github.com/tonlabs/ever-block.git', tag = '1.9.101' }
 ton_types = { git = 'https://github.com/tonlabs/ever-types.git', tag = '2.0.26' }
 zstd = { default-features = false, optional = true, version = '0.11' }
+crusty3_zk = { git = 'https://github.com/nilfoundation/crusty3-zk.git', branch = '6-extended-vk-encrypted-input-verification' }
 
 [features]
 fift_check = [  ]

src/executor/crypto.rs

@@ -25,11 +25,20 @@ use crate::{
     },
     types::{Exception, Status}
 };
+
+use crusty3_zk::create_random_proof;
 use ed25519::signature::Verifier;
 use std::borrow::Cow;
 use ton_block::GlobalCapabilities;
+use sha2::Digest;
+use ed25519::signature::{Signature, Verifier};
+use std::sync::Arc;
 use ton_types::{BuilderData, error, GasConsumer, ExceptionCode, UInt256};
 
+use crusty3_zk::{groth16::{verify_proof, prepare_verifying_key, Parameters},
+                 bls::{Bls12, Fr}
+                };
+
 const PUBLIC_KEY_BITS:  usize = PUBLIC_KEY_BYTES * 8;
 const SIGNATURE_BITS:   usize = SIGNATURE_BYTES * 8;
 const PUBLIC_KEY_BYTES: usize = ed25519_dalek::PUBLIC_KEY_LENGTH;
@@ -80,6 +89,34 @@ pub(super) fn execute_sha256u(engine: &mut Engine) -> Status {
     }
 }
 
+pub(super) fn execute_vergrth16(engine: &mut Engine) -> Failure {
+    engine.load_instruction(Instruction::new("VERGRTH16"))
+        .and_then(|ctx| fetch_stack(ctx, 1))
+        .and_then(|ctx| {
+            let builder = BuilderData::from(ctx.engine.cmd.var(0).as_cell()?);
+            let cell_proof_data_length = builder.length_in_bits();
+            //let data = builder.data();
+            let cell_proof = ctx.engine.finalize_cell(builder)?;
+            let cell_proof_data = cell_proof.data();
+            if cell_proof_data_length % 8 == 0 {
+
+                let de_params = Parameters::read(&cell_proof_data[..], true).unwrap();
+
+                let pvk = prepare_verifying_key::<Bls12>(&de_params.vk);
+
+                //let de_proof = Proof::read(&v[..]).unwrap();
+
+                //let result = verify_proof();
+                let result = true;
+                ctx.engine.cc.stack.push(boolean!(result));
+                Ok(ctx)
+            } else {
+                err!(ExceptionCode::CellUnderflow)
+            }
+        })
+        .err()
+}
+
 enum DataForSignature {
     Hash(BuilderData),
     Slice(Vec<u8>)

src/executor/engine/handlers.rs

@@ -894,6 +894,7 @@ impl Handlers {
             .set(0x02, execute_sha256u)
             .set(0x10, execute_chksignu)
             .set(0x11, execute_chksigns)
+            .set(0x12, execute_vergrth16)
             .set(0x40, execute_cdatasizeq)
             .set(0x41, execute_cdatasize)
             .set(0x42, execute_sdatasizeq)