improve code

Author: DmitriiKJ

circuits/app/proof_of_reserve/coins/src/constants.nr

@@ -1 +1,5 @@
 pub global MAX_COINS_DATABASE_AMOUNT: u32 = 3;
+pub global MAX_MERKLE_TREE_LEVELS: u32 = 3;
+
+pub global SHA256_HASH_SIZE: u32 = 32;
+pub global RIPEMD160_HASH_SIZE: u32 = 20;

circuits/app/proof_of_reserve/coins/src/main.nr

@@ -3,12 +3,14 @@
 
 mod constants;
 
-use constants::MAX_COINS_DATABASE_AMOUNT;
+use constants::{
+    MAX_COINS_DATABASE_AMOUNT, MAX_MERKLE_TREE_LEVELS, RIPEMD160_HASH_SIZE, SHA256_HASH_SIZE,
+};
 use crypto::ecdsa::{
     ecdsa_verify, get_rs_from_signature, get_xy_from_compressed_pubkey,
     get_xy_from_uncompressed_pubkey,
 };
-use utils::convert::u64_to_be_bytes;
+use utils::merkle_root::merkle_root;
 
 // p2pkh
 struct CoinsDatabaseElement {
@@ -22,17 +24,17 @@ struct OwnUtxo {
 }
 
 fn main(
-    const_message_hash: pub [u8; 32],
+    const_message_hash: pub [u8; SHA256_HASH_SIZE],
     coins_database: [CoinsDatabaseElement; MAX_COINS_DATABASE_AMOUNT],
     own_utxos: [OwnUtxo; MAX_COINS_DATABASE_AMOUNT],
-) -> pub ([[u8; 32]; MAX_COINS_DATABASE_AMOUNT], u64) {
+) -> pub ([u8; SHA256_HASH_SIZE], u64) {
     let mut owned_amount = 0;
-    let mut coins_hashes = [[0; 32]; MAX_COINS_DATABASE_AMOUNT];
+    let mut coins_hashes = [[0; SHA256_HASH_SIZE]; MAX_COINS_DATABASE_AMOUNT];
 
     for i in 0..MAX_COINS_DATABASE_AMOUNT {
         if !own_utxos[i].witness.all(|e| e == 0) {
             let signature = get_rs_from_signature(own_utxos[i].witness);
-            let mut key_hash = [0; 20];
+            let mut key_hash = [0; RIPEMD160_HASH_SIZE];
 
             let (x, y) = if own_utxos[i].pub_key[0] == 4 {
                 key_hash = ripemd160::ripemd160(sha256::digest(own_utxos[i].pub_key));
@@ -47,8 +49,8 @@ fn main(
                 get_xy_from_compressed_pubkey(c_key)
             };
 
-            let mut hash_in_spk = [0; 20];
-            for j in 0..20 {
+            let mut hash_in_spk = [0; RIPEMD160_HASH_SIZE];
+            for j in 0..RIPEMD160_HASH_SIZE {
                 hash_in_spk[j] = coins_database[i].script_pub_key[j + 3];
             }
 
@@ -66,7 +68,7 @@ fn main(
 
         let mut utx_bytes = [0; 33];
 
-        let amount_bytes = u64_to_be_bytes(coins_database[i].amount);
+        let amount_bytes = Field::to_le_bytes::<8>(coins_database[i].amount as Field);
         for j in 0..8 {
             utx_bytes[j] = amount_bytes[j];
         }
@@ -78,9 +80,9 @@ fn main(
         coins_hashes[i] = if coins_database[i].amount != 0 {
             sha256::digest(utx_bytes)
         } else {
-            [0; 32]
+            [0; SHA256_HASH_SIZE]
         };
     }
 
-    (coins_hashes, owned_amount)
+    (merkle_root::<MAX_COINS_DATABASE_AMOUNT, MAX_MERKLE_TREE_LEVELS>(coins_hashes), owned_amount)
 }

circuits/app/proof_of_reserve/nodes_tree/Nargo.toml

@@ -3,4 +3,4 @@ name = "utxos_tree"
 type = "bin"
 
 [dependencies]
-utils = { path = "../../../crates/utils" }
+utils = { path = "../../../crates/utils" }

circuits/app/proof_of_reserve/nodes_tree/src/constants.nr

@@ -1,7 +1,9 @@
-pub global MAX_COINS_DATABASE_AMOUNT: u32 = 3;
 pub global MAX_MERKLE_TREE_LEVELS: u32 = 3;
+pub global MAX_NODES_AMOUNT: u32 = 3;
 
 pub global HONK_VK_SIZE: u32 = 128;
 pub global HONK_PROOF_SIZE: u32 = 456;
 pub global HONK_IDENTIFIER: u32 = 1;
-pub global PUBLIC_INPUTS: u32 = 32 + 32 * MAX_COINS_DATABASE_AMOUNT + 1;
+pub global PUBLIC_INPUTS_SIZE: u32 = 65;
+
+pub global SHA256_HASH_SIZE: u32 = 32;

circuits/app/proof_of_reserve/nodes_tree/src/main.nr

@@ -1,30 +1,40 @@
 // Second proof
-// Build node from one chunk leafs
+// Build root from many nodes
 
 mod constants;
 
 use constants::{
-    HONK_IDENTIFIER, HONK_PROOF_SIZE, HONK_VK_SIZE, MAX_COINS_DATABASE_AMOUNT,
-    MAX_MERKLE_TREE_LEVELS, PUBLIC_INPUTS,
+    HONK_IDENTIFIER, HONK_PROOF_SIZE, HONK_VK_SIZE, MAX_MERKLE_TREE_LEVELS, MAX_NODES_AMOUNT,
+    PUBLIC_INPUTS_SIZE, SHA256_HASH_SIZE,
 };
 use utils::merkle_root::merkle_root;
 
+struct NodeProof {
+    proof: [Field; HONK_PROOF_SIZE],
+    public_inputs: [Field; PUBLIC_INPUTS_SIZE],
+}
+
 fn main(
     verification_key: [Field; HONK_VK_SIZE],
-    proof: [Field; HONK_PROOF_SIZE],
-    public_inputs: [Field; PUBLIC_INPUTS],
-) -> pub ([u8; 32], u64) {
-    std::verify_proof_with_type(verification_key, proof, public_inputs, 0x0, HONK_IDENTIFIER);
-    let mut leafs = [[0; 32]; MAX_COINS_DATABASE_AMOUNT];
+    node_proofs: [NodeProof; MAX_NODES_AMOUNT],
+) -> pub ([u8; SHA256_HASH_SIZE], u64) {
+    let mut nodes = [[0; SHA256_HASH_SIZE]; MAX_NODES_AMOUNT];
+    let mut owned_amount = 0;
 
-    for i in 0..MAX_COINS_DATABASE_AMOUNT {
-        for j in 0..32 {
-            leafs[i][j] = public_inputs[i * 32 + 32 + j] as u8;
+    for i in 0..MAX_NODES_AMOUNT {
+        std::verify_proof_with_type(
+            verification_key,
+            node_proofs[i].proof,
+            node_proofs[i].public_inputs,
+            0x0,
+            HONK_IDENTIFIER,
+        );
+        for j in 0..SHA256_HASH_SIZE {
+            nodes[i][j] = node_proofs[i].public_inputs[j + SHA256_HASH_SIZE] as u8;
         }
+
+        owned_amount += node_proofs[i].public_inputs[64] as u64;
     }
 
-    (
-        merkle_root::<MAX_COINS_DATABASE_AMOUNT, MAX_MERKLE_TREE_LEVELS>(leafs),
-        public_inputs[MAX_COINS_DATABASE_AMOUNT * 32 + 32] as u64,
-    )
+    (merkle_root::<MAX_NODES_AMOUNT, MAX_MERKLE_TREE_LEVELS>(nodes), owned_amount)
 }

circuits/app/proof_of_reserve/utxos_tree/Nargo.toml

@@ -19,15 +19,6 @@ pub fn u32_to_be_bytes(value: u32) -> [u8; 4] {
     res
 }
 
-pub fn u64_to_be_bytes(value: u64) -> [u8; 8] {
-    let mut res = [0; 8];
-    for i in 0..8 {
-        res[i] = (value >> ((7 - i) << 3)) as u8;
-    }
-
-    res
-}
-
 pub fn sha256_to_le_bytes(value: str<64>) -> [u8; 32] {
     let mut res = [0; 32];
     let value = value.as_bytes();