scarb fmt

keep-starknet-strange · Mar 21, 2024 · fea97e0 · fea97e0
1 parent 08a57cc
commit fea97e0
Show file tree

Hide file tree

Showing 5 changed files with 35 additions and 54 deletions.
diff --git a/src/tree/binary/tests/test_merkle_proof.cairo b/src/tree/binary/tests/test_merkle_proof.cairo
@@ -253,8 +253,8 @@ fn verify_invalid_proof_data_test() {
     let key: u256 = 1;
     let num_leaves: u256 = 5;
     let proof: BinaryMerkleProof = BinaryMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty()// correct .encode_packed(0x01_u8);
-    .encode_packed(0x012345_u32);
+    let mut data = BytesTrait::new_empty() // correct .encode_packed(0x01_u8);
+        .encode_packed(0x012345_u32);
     let (is_valid, error_code) = merkle_tree::verify(root, @proof, @data);
     assert!(error_code == ErrorCodes::NoError, "verify invalid proof data test failed with error");
     assert_eq!(is_valid, false, "verify invalid proof data test should be invalid");

diff --git a/src/tree/namespace/hasher.cairo b/src/tree/namespace/hasher.cairo
@@ -9,9 +9,9 @@ use blobstream_sn::tree::namespace::merkle_tree::{
 
 fn leaf_digest(namespace: Namespace, data: @Bytes) -> NamespaceNode {
     let mut bytes = BytesTrait::new_empty()
-    .encode_packed(LEAF_PREFIX)
-    .encode_packed(namespace.version)
-    .encode_packed(SolBytesTrait::bytes28(namespace.id));
+        .encode_packed(LEAF_PREFIX)
+        .encode_packed(namespace.version)
+        .encode_packed(SolBytesTrait::bytes28(namespace.id));
     bytes.concat(data);
     return NamespaceNode { min: namespace, max: namespace, digest: bytes.sha256() };
 }
@@ -40,17 +40,17 @@ fn node_digest(left: NamespaceNode, right: NamespaceNode) -> NamespaceNode {
     }
 
     let mut bytes = BytesTrait::new_empty()
-    .encode_packed(NODE_PREFIX)
-    .encode_packed(left.min.version)
-    .encode_packed(SolBytesTrait::bytes28(left.min.id))
-    .encode_packed(left.max.version)
-    .encode_packed(SolBytesTrait::bytes28(left.max.id))
-    .encode_packed(left.digest)
-    .encode_packed(right.min.version)
-    .encode_packed(SolBytesTrait::bytes28(right.min.id))
-    .encode_packed(right.max.version)
-    .encode_packed(SolBytesTrait::bytes28(right.max.id))
-    .encode_packed(right.digest);
+        .encode_packed(NODE_PREFIX)
+        .encode_packed(left.min.version)
+        .encode_packed(SolBytesTrait::bytes28(left.min.id))
+        .encode_packed(left.max.version)
+        .encode_packed(SolBytesTrait::bytes28(left.max.id))
+        .encode_packed(left.digest)
+        .encode_packed(right.min.version)
+        .encode_packed(SolBytesTrait::bytes28(right.min.id))
+        .encode_packed(right.max.version)
+        .encode_packed(SolBytesTrait::bytes28(right.max.id))
+        .encode_packed(right.digest);
 
     return NamespaceNode { min: min, max: max, digest: bytes.sha256() };
 }

diff --git a/src/tree/namespace/tests/test_hasher.cairo b/src/tree/namespace/tests/test_hasher.cairo
@@ -38,8 +38,7 @@ fn test_leaf_digest_some() {
         digest: 0x3624c7f7169cb5bbd0d010b851ebd0edca10b2a1b126f5fb1a6d5e0d98356e63
     };
 
-    let mut data = BytesTrait::new_empty()
-    .encode_packed(0x69_u8);
+    let mut data = BytesTrait::new_empty().encode_packed(0x69_u8);
 
     let node = hasher::leaf_digest(nid, @data);
     assert!(node.digest == expected.digest, "Not equal to expected digest");

diff --git a/src/tree/namespace/tests/test_merkle_multi_proof.cairo b/src/tree/namespace/tests/test_merkle_multi_proof.cairo
@@ -40,10 +40,8 @@ fn verify_multi_01() {
     let begin_key: u256 = 1;
     let end_key: u256 = 3;
     let proof = NamespaceMerkleMultiproof { begin_key, end_key, side_nodes };
-    let mut data_val1: Bytes = BytesTrait::new_empty()
-    .encode_packed(0x02_u8);
-    let mut data_val2: Bytes = BytesTrait::new_empty()
-    .encode_packed(0x03_u8);
+    let mut data_val1: Bytes = BytesTrait::new_empty().encode_packed(0x02_u8);
+    let mut data_val2: Bytes = BytesTrait::new_empty().encode_packed(0x03_u8);
     let data: Array<Bytes> = array![data_val1, data_val2];
     let is_valid = NamespaceMerkleTree::verify_multi(root, proof, nid, data);
     assert!(is_valid, "verify_multi_01 failed");

diff --git a/src/tree/namespace/tests/test_merkle_tree.cairo b/src/tree/namespace/tests/test_merkle_tree.cairo
@@ -52,8 +52,7 @@ fn verify_one_leaf_some_test() {
     let key: u256 = 0;
     let num_leaves: u256 = 1;
     let proof = NamespaceMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty()
-    .encode_packed(0xdeadbeef_u32);
+    let mut data = BytesTrait::new_empty().encode_packed(0xdeadbeef_u32);
     let is_valid = NamespaceMerkleTree::verify(root, proof, nid, data);
     assert!(is_valid, "One leaf some proof should be valid");
 }
@@ -70,8 +69,7 @@ fn verify_one_leaf_01_test() {
     let key: u256 = 0;
     let num_leaves: u256 = 1;
     let proof = NamespaceMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty()
-    .encode_packed(0x01_u8);
+    let mut data = BytesTrait::new_empty().encode_packed(0x01_u8);
     let is_valid = NamespaceMerkleTree::verify(root, proof, nid, data);
     assert!(is_valid, "One leaf 01 proof should be valid");
 }
@@ -101,8 +99,7 @@ fn verify_leaf_one_of_two_test() {
     let key: u256 = 0;
     let num_leaves: u256 = 2;
     let proof = NamespaceMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty()
-    .encode_packed(0x01_u8);
+    let mut data = BytesTrait::new_empty().encode_packed(0x01_u8);
     let is_valid = NamespaceMerkleTree::verify(root, proof, node10, data);
     assert!(is_valid, "Leaf one of two proof should be valid");
 }
@@ -145,8 +142,7 @@ fn verify_leaf_one_of_four_test() {
     let key: u256 = 0;
     let num_leaves: u256 = 4;
     let proof = NamespaceMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty()
-    .encode_packed(0x01_u8);
+    let mut data = BytesTrait::new_empty().encode_packed(0x01_u8);
     let is_valid = NamespaceMerkleTree::verify(root, proof, node10, data);
     assert!(is_valid, "Leaf one of four proof should be valid");
 }
@@ -194,8 +190,7 @@ fn verify_leaf_one_of_eight_test() {
     let key: u256 = 0;
     let num_leaves: u256 = 8;
     let proof = NamespaceMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty()
-    .encode_packed(0x01_u8);
+    let mut data = BytesTrait::new_empty().encode_packed(0x01_u8);
     let is_valid = NamespaceMerkleTree::verify(root, proof, node10, data);
     assert!(is_valid, "Leaf one of eight proof should be valid");
 }
@@ -235,8 +230,7 @@ fn verify_leaf_seven_of_eight_test() {
     let key: u256 = 6;
     let num_leaves: u256 = 8;
     let proof = NamespaceMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty()
-    .encode_packed(0x07_u8);
+    let mut data = BytesTrait::new_empty().encode_packed(0x07_u8);
     let is_valid = NamespaceMerkleTree::verify(root, proof, consts::parity_share_namespace(), data);
     assert!(is_valid, "Leaf seven of eight proof should be valid");
 }
@@ -276,8 +270,7 @@ fn verify_leaf_eight_of_eight_test() {
     let key: u256 = 7;
     let num_leaves: u256 = 8;
     let proof = NamespaceMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty()
-    .encode_packed(0x08_u8);
+    let mut data = BytesTrait::new_empty().encode_packed(0x08_u8);
     let is_valid = NamespaceMerkleTree::verify(root, proof, consts::parity_share_namespace(), data);
     assert!(is_valid, "Leaf eight of eight proof should be valid");
 }
@@ -317,8 +310,7 @@ fn verify_leaf_five_of_eight_test() {
     let key: u256 = 4;
     let num_leaves: u256 = 8;
     let proof = NamespaceMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty()
-    .encode_packed(0x05_u8);
+    let mut data = BytesTrait::new_empty().encode_packed(0x05_u8);
     let is_valid = NamespaceMerkleTree::verify(root, proof, consts::parity_share_namespace(), data);
     assert!(is_valid, "Leaf five of eight proof should be valid");
 }
@@ -366,8 +358,7 @@ fn verify_leaf_four_of_eight_test() {
     let key: u256 = 3;
     let num_leaves: u256 = 8;
     let proof = NamespaceMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty()
-    .encode_packed(0x04_u8);
+    let mut data = BytesTrait::new_empty().encode_packed(0x04_u8);
     let is_valid = NamespaceMerkleTree::verify(root, proof, node40, data);
     assert!(is_valid, "Leaf four of eight proof should be valid");
 }
@@ -415,8 +406,7 @@ fn verify_leaf_three_of_eight_test() {
     let key: u256 = 2;
     let num_leaves: u256 = 8;
     let proof = NamespaceMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty()
-    .encode_packed(0x03_u8);
+    let mut data = BytesTrait::new_empty().encode_packed(0x03_u8);
     let is_valid = NamespaceMerkleTree::verify(root, proof, node30, data);
     assert!(is_valid, "Leaf three of eight proof should be valid");
 }
@@ -456,8 +446,7 @@ fn verify_leaf_five_of_seven_test() {
     let key: u256 = 4;
     let num_leaves: u256 = 7;
     let proof = NamespaceMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty()
-    .encode_packed(0x05_u8);
+    let mut data = BytesTrait::new_empty().encode_packed(0x05_u8);
     let is_valid = NamespaceMerkleTree::verify(root, proof, consts::parity_share_namespace(), data);
     assert!(is_valid, "Leaf five of seven proof should be valid");
 }
@@ -492,8 +481,7 @@ fn verify_leaf_nine_of_ten_test() {
     let key: u256 = 8;
     let num_leaves: u256 = 10;
     let proof = NamespaceMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty()
-    .encode_packed(0x09_u8);
+    let mut data = BytesTrait::new_empty().encode_packed(0x09_u8);
     let is_valid = NamespaceMerkleTree::verify(root, proof, consts::parity_share_namespace(), data);
     assert!(is_valid, "Leaf nine of ten proof should be valid");
 }
@@ -538,8 +526,7 @@ fn verify_leaf_twelve_of_thirteen_test() {
     let key: u256 = 11;
     let num_leaves: u256 = 13;
     let proof = NamespaceMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty()
-    .encode_packed(0x0c_u8);
+    let mut data = BytesTrait::new_empty().encode_packed(0x0c_u8);
     let is_valid = NamespaceMerkleTree::verify(root, proof, consts::parity_share_namespace(), data);
     assert!(is_valid, "Leaf twelve of thirteen proof should be valid");
 }
@@ -574,8 +561,7 @@ fn verify_leaf_thirteen_of_thirteen_test() {
     let key: u256 = 12;
     let num_leaves: u256 = 13;
     let proof = NamespaceMerkleProof { side_nodes, key, num_leaves };
-    let mut data = BytesTrait::new_empty()
-    .encode_packed(0x0d_u8);
+    let mut data = BytesTrait::new_empty().encode_packed(0x0d_u8);
     let is_valid = NamespaceMerkleTree::verify(root, proof, consts::parity_share_namespace(), data);
     assert!(is_valid, "Leaf thirteen of thirteen proof should be valid");
 }
@@ -601,8 +587,7 @@ fn verify_internal_node_one_and_two_of_four_test() {
     let key: u256 = 1;
     let num_leaves: u256 = 4;
     let starting_height: u256 = 2;
-    let mut data = BytesTrait::new_empty()
-    .encode_packed(0x01_u8);
+    let mut data = BytesTrait::new_empty().encode_packed(0x01_u8);
 
     let node1 = hasher::leaf_digest(node10, @data);
     let node2 = hasher::leaf_digest(node20, @data);
@@ -637,8 +622,7 @@ fn verify_internal_node_one_and_two_of_three_test() {
     let key: u256 = 0;
     let num_leaves: u256 = 3;
     let starting_height: u256 = 2;
-    let mut data = BytesTrait::new_empty()
-    .encode_packed(0x01_u8);
+    let mut data = BytesTrait::new_empty().encode_packed(0x01_u8);
 
     let node1 = hasher::leaf_digest(node10, @data);
     let node2 = hasher::leaf_digest(node20, @data);