Merge pull request #26 from chainwayxyz/ekrem/presign

Ekrem/presign

src/actor.rs

@@ -11,13 +11,15 @@ use bitcoin::{
 };
 use rand::Rng;
 
+use crate::wire::{HashValue, PreimageValue};
+
 pub struct Actor {
     secp: Secp256k1<All>,
     keypair: Keypair,
     pub secret_key: SecretKey,
     pub public_key: XOnlyPublicKey,
     pub address: Address,
-    challenge_preimages: Vec<Vec<[u8; 32]>>,
+    challenge_preimages: Vec<Vec<PreimageValue>>,
 }
 
 impl Default for Actor {
@@ -80,20 +82,20 @@ impl Actor {
         )
     }
 
-    pub fn generate_challenge_hashes(&mut self, num_gates: usize) -> Vec<[u8; 32]> {
+    pub fn generate_challenge_hashes(&mut self, num_gates: usize) -> Vec<HashValue> {
         let mut challenge_hashes = Vec::new();
         let mut rng = rand::thread_rng();
         let mut preimages = Vec::new();
         for _ in 0..num_gates {
-            let preimage: [u8; 32] = rng.gen();
+            let preimage: PreimageValue = rng.gen();
             preimages.push(preimage);
             challenge_hashes.push(sha256::Hash::hash(&preimage).to_byte_array());
         }
         self.challenge_preimages.push(preimages);
         challenge_hashes
     }
 
-    pub fn generate_challenge_script(&self, challenge_hash: &[u8; 32]) -> ScriptBuf {
+    pub fn generate_challenge_script(&self, challenge_hash: &HashValue) -> ScriptBuf {
         Builder::new()
             .push_slice(challenge_hash)
             .push_opcode(OP_EQUALVERIFY)

src/circuit.rs

@@ -11,6 +11,7 @@ use bitcoin::{Address, ScriptBuf};
 use crate::actor::Actor;
 use crate::utils::taproot_address_from_script_leaves;
 use crate::wire::HashTuple;
+use crate::wire::HashValue;
 use crate::{
     gates::{AndGate, NotGate, XorGate},
     traits::{circuit::CircuitTrait, gate::GateTrait, wire::WireTrait},
@@ -200,7 +201,7 @@ impl CircuitTrait for Circuit {
         secp: &Secp256k1<All>,
         _prover: &Actor,
         verifier: &Actor,
-        challenge_hashes: Vec<[u8; 32]>,
+        challenge_hashes: Vec<HashValue>,
     ) -> (Address, TaprootSpendInfo) {
         assert_eq!(
             challenge_hashes.len(),
@@ -222,7 +223,7 @@ impl CircuitTrait for Circuit {
         secp: &Secp256k1<All>,
         prover: &Actor,
         verifier: &Actor,
-        challenge_hashes: Vec<[u8; 32]>,
+        challenge_hashes: Vec<HashValue>,
     ) -> (Address, TaprootSpendInfo) {
         assert_eq!(
             challenge_hashes.len(),

src/gates.rs

@@ -5,6 +5,7 @@ use bitcoin::script::Builder;
 use bitcoin::ScriptBuf;
 
 use crate::traits::wire::WireTrait;
+use crate::wire::HashValue;
 use crate::{traits::gate::GateTrait, wire::Wire};
 use std::cell::RefCell;
 use std::rc::Rc;
@@ -34,7 +35,7 @@ impl GateTrait for NotGate {
         out.selector = Some(w);
     }
 
-    fn create_response_script(&self, lock_hash: [u8; 32]) -> ScriptBuf {
+    fn create_response_script(&self, lock_hash: HashValue) -> ScriptBuf {
         let builder = Builder::new()
             .push_opcode(OP_SHA256)
             .push_slice(lock_hash)
@@ -81,7 +82,7 @@ impl GateTrait for AndGate {
         out.selector = Some(w);
     }
 
-    fn create_response_script(&self, lock_hash: [u8; 32]) -> ScriptBuf {
+    fn create_response_script(&self, lock_hash: HashValue) -> ScriptBuf {
         let builder = Builder::new()
             .push_opcode(OP_SHA256)
             .push_slice(lock_hash)
@@ -134,7 +135,7 @@ impl GateTrait for XorGate {
         out.selector = Some(w);
     }
 
-    fn create_response_script(&self, lock_hash: [u8; 32]) -> ScriptBuf {
+    fn create_response_script(&self, lock_hash: HashValue) -> ScriptBuf {
         let builder = Builder::new()
             .push_opcode(OP_SHA256)
             .push_slice(lock_hash)
@@ -164,6 +165,8 @@ impl GateTrait for XorGate {
 
 #[cfg(test)]
 mod tests {
+    use crate::wire::PreimageValue;
+
     use super::*;
     use bitcoin::hashes::sha256;
     use bitcoin::hashes::Hash;
@@ -187,7 +190,7 @@ mod tests {
 
         let mut rng = rand::thread_rng();
 
-        let lock_preimage: [u8; 32] = rng.gen();
+        let lock_preimage: PreimageValue = rng.gen();
 
         let lock_hash = sha256::Hash::hash(&lock_preimage).to_byte_array();
 

src/traits/circuit.rs

@@ -1,4 +1,7 @@
-use crate::{actor::Actor, wire::HashTuple};
+use crate::{
+    actor::Actor,
+    wire::{HashTuple, HashValue},
+};
 use bitcoin::{
     secp256k1::{All, Secp256k1},
     taproot::TaprootSpendInfo,
@@ -20,14 +23,14 @@ pub trait CircuitTrait {
         secp: &Secp256k1<All>,
         prover: &Actor,
         verifier: &Actor,
-        challenge_hashes: Vec<[u8; 32]>,
+        challenge_hashes: Vec<HashValue>,
     ) -> (Address, TaprootSpendInfo);
 
     fn generate_response_tree(
         &self,
         secp: &Secp256k1<All>,
         prover: &Actor,
         verifier: &Actor,
-        challenge_hashes: Vec<[u8; 32]>,
+        challenge_hashes: Vec<HashValue>,
     ) -> (Address, TaprootSpendInfo);
 }

src/traits/gate.rs

@@ -1,10 +1,8 @@
-//use crate::wire::Wire;
-//use std::rc::Rc;
-//use std::cell::RefCell;
-
 use bitcoin::ScriptBuf;
 
+use crate::wire::HashValue;
+
 pub trait GateTrait {
     fn evaluate(&mut self);
-    fn create_response_script(&self, lock_hash: [u8; 32]) -> ScriptBuf;
+    fn create_response_script(&self, lock_hash: HashValue) -> ScriptBuf;
 }

src/verifier.rs

@@ -2,6 +2,7 @@
 use bitvm::{
     actor::Actor,
     communication::{receive_message, send_message},
+    wire::HashTuple,
 };
 use tokio::net::{TcpListener, TcpStream};
 use tokio_tungstenite::accept_async;
@@ -31,7 +32,7 @@ async fn handle_connection(stream: TcpStream) {
         .await
         .unwrap();
 
-    let wire_hashes: Vec<[[u8; 32]; 2]> = receive_message(&mut ws_stream).await.unwrap();
+    let wire_hashes: Vec<HashTuple> = receive_message(&mut ws_stream).await.unwrap();
 
     println!("Wire hashes: {:?}", wire_hashes);
 }

src/wire.rs

@@ -11,16 +11,19 @@ use rand::Rng;
 use serde::Deserialize;
 use serde::Serialize;
 
+pub type HashValue = [u8; 32];
+pub type PreimageValue = [u8; 32];
+
 #[derive(Serialize, Deserialize, Debug, Clone, Copy)]
 pub struct HashTuple {
-    pub zero: [u8; 32],
-    pub one: [u8; 32],
+    pub zero: HashValue,
+    pub one: HashValue,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, Copy)]
 pub struct PreimageTuple {
-    pub zero: [u8; 32],
-    pub one: [u8; 32],
+    pub zero: PreimageValue,
+    pub one: PreimageValue,
 }
 
 #[derive(Clone)]