build node from leafs and final root

Author: DmitriiKJ

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

@@ -1,3 +1,6 @@
+// First proof
+// Checks if user own coresponding utxos and acumulate amount
+
 mod constants;
 
 use constants::MAX_COINS_DATABASE_AMOUNT;

circuits/app/proof_of_reserve/nodes_tree/Nargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "nodes_tree"
+type = "bin"
+authors = [""]
+
+[dependencies]
+utils = { path = "../../../crates/utils" }

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

@@ -0,0 +1,7 @@
+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 = 33;

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

@@ -0,0 +1,34 @@
+// Third proof
+// Build root from many nodes
+
+mod constants;
+
+use constants::{
+    HONK_IDENTIFIER, HONK_PROOF_SIZE, HONK_VK_SIZE,
+    MAX_MERKLE_TREE_LEVELS, PUBLIC_INPUTS, MAX_NODES_AMOUNT
+};
+use utils::merkle_root::merkle_root;
+
+struct NodeProof {
+    proof: [Field; HONK_PROOF_SIZE],
+    public_inputs: [Field; PUBLIC_INPUTS],
+}
+
+fn main(
+    verification_key: [Field; HONK_VK_SIZE],
+    node_proofs: [NodeProof; MAX_NODES_AMOUNT]
+) -> pub ([u8; 32], u64) {
+    let mut nodes = [[0; 32]; MAX_NODES_AMOUNT];
+    let mut owned_amount = 0;
+
+    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..32 {
+            nodes[i][j] = node_proofs[i].public_inputs[j] as u8;
+        }
+
+        owned_amount += node_proofs[i].public_inputs[32] as u64;
+    }
+
+    (merkle_root::<MAX_NODES_AMOUNT, MAX_MERKLE_TREE_LEVELS>(nodes), owned_amount)
+}

circuits/app/proof_of_reserve/utxos_tree/Nargo.toml

@@ -3,4 +3,4 @@ name = "utxos_tree"
 type = "bin"
 
 [dependencies]
-sha256 = { tag = "v0.1.0", git = "https://github.com/noir-lang/sha256" }
+utils = { path = "../../../crates/utils" }

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

@@ -1 +1,7 @@
-pub global MAX_MERKLE_TREE_LEVELS: u32 = 6;
+pub global MAX_COINS_DATABASE_AMOUNT: u32 = 3;
+pub global MAX_MERKLE_TREE_LEVELS: 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;

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

@@ -1,83 +1,30 @@
-mod constants;
-
-use constants::MAX_MERKLE_TREE_LEVELS;
-use std::cmp::max;
-
-fn main() {
-    // let mut utxos = [[0; 32]; MAX_COINS_DATABASE_AMOUNT];
-
-    // for i in 0..MAX_COINS_DATABASE_AMOUNT {
-    //     // There is a bug with append, so we fill the array manually
-    //     let mut utx_bytes = [0; 33];
-
-    //     let amount_bytes = u64_to_be_bytes(coins_database[i].amount);
-    //     for j in 0..8 {
-    //         utx_bytes[j] = amount_bytes[j];
-    //     }
-
-    //     for j in 0..25 {
-    //         utx_bytes[j + 8] = coins_database[i].script_pub_key[j];
-    //     }
-
-    //     utxos[i] = if coins_database[i].amount != 0 {
-    //         sha256::digest(utx_bytes)
-    //     } else {
-    //         [0; 32]
-    //     };
-    // }
-
-    // (merkle_root(utxos), 0)
-}
+// Second proof
+// Build node from one chunk leafs
 
-fn hash(leaf1: [u8; 32], leaf2: [u8; 32]) -> [u8; 32] {
-    sha256::digest(leaf1.as_slice().append(leaf2).as_array::<64>())
-}
-
-fn merkle_root<let N: u32>(mut leafs: [[u8; 32]; N]) -> [u8; 32] {
-    assert((N as Field).lt(2.pow_32(MAX_MERKLE_TREE_LEVELS as Field)));
-    let mut mtree = [[0; 32]; MAX_MERKLE_TREE_LEVELS];
-    let mut last_level = 0;
-
-    for i in 0..N {
-        let mut leaf = leafs[i];
-        for j in 0..MAX_MERKLE_TREE_LEVELS {
-            if !leaf.all(|e| e == 0) {
-                if mtree[j].all(|e| e == 0) {
-                    mtree[j] = leaf;
-                    leaf = [0; 32];
-                } else {
-                    leaf = hash(mtree[j], leaf);
-                    mtree[j] = [0; 32];
-                }
-                last_level = max(j, last_level);
-            }
-        }
-    }
-
-    let mut tmp_node = [0; 32];
-    for i in 0..MAX_MERKLE_TREE_LEVELS {
-        if (
-            (i < last_level & tmp_node.all(|e| e == 0))
-                | (i <= last_level & !tmp_node.all(|e| e == 0))
-        ) {
-            if !mtree[i].all(|e| e == 0) {
-                let right = if tmp_node.all(|e| e == 0) {
-                    mtree[i]
-                } else {
-                    tmp_node
-                };
+mod constants;
 
-                tmp_node = hash(mtree[i], right);
-                mtree[i] = [0; 32];
-            } else if !tmp_node.all(|e| e == 0) {
-                tmp_node = hash(tmp_node, tmp_node);
-            }
+use constants::{
+    HONK_IDENTIFIER, HONK_PROOF_SIZE, HONK_VK_SIZE, MAX_COINS_DATABASE_AMOUNT,
+    MAX_MERKLE_TREE_LEVELS, PUBLIC_INPUTS,
+};
+use utils::merkle_root::merkle_root;
+
+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];
+
+    for i in 0..MAX_COINS_DATABASE_AMOUNT {
+        for j in 0..32 {
+            leafs[i][j] = public_inputs[i * 32 + 32 + j] as u8;
         }
     }
 
-    if tmp_node.all(|e| e == 0) {
-        mtree[last_level]
-    } else {
-        tmp_node
-    }
+    (
+        merkle_root::<MAX_COINS_DATABASE_AMOUNT, MAX_MERKLE_TREE_LEVELS>(leafs),
+        public_inputs[MAX_COINS_DATABASE_AMOUNT * 32 + 32] as u64,
+    )
 }

circuits/crates/utils/src/lib.nr

@@ -1,3 +1,4 @@
 pub mod convert;
 pub mod encode;
 pub mod decode;
+pub mod merkle_root;

circuits/crates/utils/src/merkle_root.nr

@@ -0,0 +1,56 @@
+use std::cmp::max;
+
+fn hash(leaf1: [u8; 32], leaf2: [u8; 32]) -> [u8; 32] {
+    sha256::digest(leaf1.as_slice().append(leaf2).as_array::<64>())
+}
+
+pub fn merkle_root<let N: u32, let MAX_MERKLE_TREE_LEVELS: u32>(
+    mut leafs: [[u8; 32]; N],
+) -> [u8; 32] {
+    assert((N as Field).lt(2.pow_32(MAX_MERKLE_TREE_LEVELS as Field)));
+    let mut mtree = [[0; 32]; MAX_MERKLE_TREE_LEVELS];
+    let mut last_level = 0;
+
+    for i in 0..N {
+        let mut leaf = leafs[i];
+        for j in 0..MAX_MERKLE_TREE_LEVELS {
+            if !leaf.all(|e| e == 0) {
+                if mtree[j].all(|e| e == 0) {
+                    mtree[j] = leaf;
+                    leaf = [0; 32];
+                } else {
+                    leaf = hash(mtree[j], leaf);
+                    mtree[j] = [0; 32];
+                }
+                last_level = max(j, last_level);
+            }
+        }
+    }
+
+    let mut tmp_node = [0; 32];
+    for i in 0..MAX_MERKLE_TREE_LEVELS {
+        if (
+            (i < last_level & tmp_node.all(|e| e == 0))
+                | (i <= last_level & !tmp_node.all(|e| e == 0))
+        ) {
+            if !mtree[i].all(|e| e == 0) {
+                let right = if tmp_node.all(|e| e == 0) {
+                    mtree[i]
+                } else {
+                    tmp_node
+                };
+
+                tmp_node = hash(mtree[i], right);
+                mtree[i] = [0; 32];
+            } else if !tmp_node.all(|e| e == 0) {
+                tmp_node = hash(tmp_node, tmp_node);
+            }
+        }
+    }
+
+    if tmp_node.all(|e| e == 0) {
+        mtree[last_level]
+    } else {
+        tmp_node
+    }
+}