Cairo version update + improvements

.github/workflows/ci.yml

@@ -9,5 +9,4 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - uses: software-mansion/setup-scarb@v1
-      - run: scarb fmt --check
       - run: scarb test

.tool-versions

@@ -1 +1 @@
-scarb 0.7.0
+scarb nightly-2024-04-20

Scarb.lock

@@ -0,0 +1,6 @@
+# Code generated by scarb DO NOT EDIT.
+version = 1
+
+[[package]]
+name = "cairo_lib"
+version = "0.2.0"

benchmark/benchmark.py

@@ -0,0 +1,80 @@
+import argparse
+import subprocess
+import re
+import os
+import pandas as pd
+
+def bench(name, force):
+    try:
+        with open(os.path.join("results", name), "w" if force else "x") as f:
+            test_out = subprocess.check_output(["scarb", "test"], cwd="..")
+            results = []
+            for line in test_out.decode("utf-8").split("\n"):
+                m = re.match(r"^test ([a-zA-Z0-9_:]+) ... ok \(gas usage est\.: (\d+)\)$", line)
+                if m:
+                    results.append(f"{m.group(1)} {m.group(2)}")
+            f.write("\n".join(results))
+    except FileExistsError:
+        print(f"Bench {name} already exists. If you want to overwrite it, pass the --force flag.")
+
+
+def results():
+    bench_names = []
+    for file in os.listdir("results"):
+        if file.startswith("."):
+            continue
+        bench_names.append(file)
+
+    results = {}
+    test_names = set()
+    for bench in bench_names:
+        with open(os.path.join("results", bench), "r") as f:
+            for line in f.read().split("\n"):
+                test_name, gas = line.split(" ")
+                test_names.add(test_name)
+                if not test_name in results:
+                    results[test_name] = {}
+                results[test_name][bench] = gas
+    test_names = list(test_names)
+    test_names.sort()
+
+    table = [[None for _ in bench_names] for _ in test_names]
+    for i, test in enumerate(test_names):
+        for j, bench in enumerate(bench_names):
+            try:
+                table[i][j] = results[test][bench]
+            except KeyError:
+                pass
+    df = pd.DataFrame(table, index=test_names, columns=bench_names)
+    df.to_excel("results.xlsx")
+
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Process some commands.")
+
+    # Create a subparser object
+    subparsers = parser.add_subparsers(dest="command", help='sub-command help')
+
+    # Create the parser for the "bench" command
+    parser_bench = subparsers.add_parser('bench', help='Run a benchmark')
+    parser_bench.add_argument('benchmark_name', type=str, help='The name of the benchmark to run')
+    parser_bench.add_argument('--force', action='store_true', help='Overwrite the benchmark if it already exists')
+
+    # Create the parser for the "results" command
+    parser_results = subparsers.add_parser('results', help='Show results')
+
+    # Parse the arguments
+    args = parser.parse_args()
+
+    # Decide what to do based on the command
+    if args.command == 'bench':
+        bench(args.benchmark_name, args.force)
+    elif args.command == 'results':
+        results()
+    else:
+        parser.print_help()
+
+
+if __name__ == '__main__':
+    main()

src/data_structures/eth_mpt.cairo

@@ -75,21 +75,18 @@ impl MPTImpl of MPTTrait {
             // If it's not the last node and more than 9 words, it must be a branch node
             let (decoded, rlp_byte_len) = if proof_index != proof_len - 1 && node.len() > 9 {
                 let current_nibble = (key / key_pow2) & 0xf;
-                // Unwrap impossible to fail, as we are masking with 0xf, meaning the result is always a nibble
+                // Unwrap impossible to fail, as we are masking with 0xf, meaning the result is
+                // always a nibble
                 match MPTTrait::lazy_rlp_decode_branch_node(
                     node, current_nibble.try_into().unwrap()
                 ) {
                     Result::Ok(d) => d,
-                    Result::Err(e) => {
-                        break Result::Err(e);
-                    }
+                    Result::Err(e) => { break Result::Err(e); }
                 }
             } else {
                 match MPTTrait::decode_rlp_node(node) {
                     Result::Ok(d) => d,
-                    Result::Err(e) => {
-                        break Result::Err(e);
-                    }
+                    Result::Err(e) => { break Result::Err(e); }
                 }
             };
 
@@ -111,17 +108,16 @@ impl MPTImpl of MPTTrait {
                     }
 
                     let current_nibble = (key / key_pow2) & 0xf;
-                    // Unwrap impossible to fail, as we are masking with 0xf, meaning the result is always a nibble
+                    // Unwrap impossible to fail, as we are masking with 0xf, meaning the result is
+                    // always a nibble
                     let current_hash_words = *nibbles.at(current_nibble.try_into().unwrap());
                     current_hash =
                         if current_hash_words.len() == 0 {
                             break Result::Ok(array![].span());
                         } else {
-                            match current_hash_words.as_u256_le(32) {
+                            match current_hash_words.as_u256_le() {
                                 Result::Ok(h) => h,
-                                Result::Err(_) => {
-                                    break Result::Err('Invalid hash');
-                                }
+                                Result::Err(_) => { break Result::Err('Invalid hash'); }
                             }
                         };
                     key_pow2 = key_pow2 / 16;
@@ -192,9 +188,7 @@ impl MPTImpl of MPTTrait {
                             }
                             current_hash = next_hash;
                         },
-                        Result::Err(e) => {
-                            break Result::Err(e);
-                        }
+                        Result::Err(e) => { break Result::Err(e); }
                     }
                 },
                 MPTNode::Leaf((
@@ -277,21 +271,22 @@ impl MPTImpl of MPTTrait {
                 } else if len == 2 {
                     let (first, first_len) = *l.at(0);
                     let (second, _) = *l.at(1);
-                    // Unwrap impossible to fail, as we are making with 0xff, meaning the result always fits in a byte
+                    // Unwrap impossible to fail, as we are making with 0xff, meaning the result
+                    // always fits in a byte
                     let prefix_byte: Byte = (*first.at(0) & 0xff).try_into().unwrap();
                     let (prefix, _) = prefix_byte.extract_nibbles();
 
                     let n_nibbles = (first_len * 2) - 1;
 
                     if prefix == 0 {
-                        match second.as_u256_le(32) {
+                        match second.as_u256_le() {
                             Result::Ok(n) => Result::Ok(
                                 (MPTNode::Extension((first, n, 2, n_nibbles - 1)), rlp_byte_len)
                             ),
                             Result::Err(_) => Result::Err('Invalid next node')
                         }
                     } else if prefix == 1 {
-                        match second.as_u256_le(32) {
+                        match second.as_u256_le() {
                             Result::Ok(n) => Result::Ok(
                                 (MPTNode::Extension((first, n, 1, n_nibbles)), rlp_byte_len)
                             ),
@@ -322,7 +317,7 @@ impl MPTImpl of MPTTrait {
             RLPItem::Bytes(_) => Result::Err('Invalid RLP for node'),
             RLPItem::List(l) => {
                 let (hash_words, _) = *l.at(0);
-                match hash_words.as_u256_le(32) {
+                match hash_words.as_u256_le() {
                     Result::Ok(h) => Result::Ok((MPTNode::LazyBranch(h), rlp_byte_len)),
                     Result::Err(_) => Result::Err('Invalid hash')
                 }

src/data_structures/mmr/mmr.cairo

@@ -1,15 +1,19 @@
 use cairo_lib::data_structures::mmr::peaks::{Peaks, PeaksTrait};
 use cairo_lib::data_structures::mmr::proof::{Proof, ProofTrait};
 use cairo_lib::data_structures::mmr::utils::{
-    compute_root, get_height, mmr_size_to_leaf_count, leaf_count_to_peaks_count, get_peak_info
+    compute_root, get_height, mmr_size_to_leaf_count, leaf_count_to_peaks_count, trailing_ones,
+    get_peak_info
 };
 use cairo_lib::hashing::poseidon::PoseidonHasher;
 
+type MmrElement = felt252;
+type MmrSize = u256;
+
 // @notice Merkle Mountatin Range struct
 #[derive(Drop, Clone, Serde, starknet::Store)]
 struct MMR {
-    root: felt252,
-    last_pos: usize
+    root: MmrElement,
+    last_pos: MmrSize
 }
 
 impl MMRDefault of Default<MMR> {
@@ -27,17 +31,19 @@ impl MMRImpl of MMRTrait {
     // @param last_pos The last position in the MMR
     // @return MMR with the given root and last_pos
     #[inline(always)]
-    fn new(root: felt252, last_pos: usize) -> MMR {
+    fn new(root: MmrElement, last_pos: MmrSize) -> MMR {
         MMR { root, last_pos }
     }
 
     // @notice Appends an element to the MMR
     // @param hash The hashed element to append
     // @param peaks The peaks of the MMR
     // @return Result with the new root and new peaks of the MMR
-    fn append(ref self: MMR, hash: felt252, peaks: Peaks) -> Result<(felt252, Peaks), felt252> {
-        let leaf_count = mmr_size_to_leaf_count(self.last_pos.into());
-        if leaf_count_to_peaks_count(leaf_count) != peaks.len().into() {
+    fn append(ref self: MMR, hash: MmrElement, peaks: Peaks) -> Result<(MmrElement, Peaks), felt252> {
+        let leaf_count = mmr_size_to_leaf_count(self.last_pos);
+        let peaks_count= peaks.len();
+
+        if leaf_count_to_peaks_count(leaf_count) != peaks_count.into() {
             return Result::Err('Invalid peaks count');
         }
         if !peaks.valid(self.last_pos, self.root) {
@@ -46,54 +52,35 @@ impl MMRImpl of MMRTrait {
 
         self.last_pos += 1;
 
-        let mut peaks_arr = ArrayTrait::new();
-        let mut i: usize = 0;
-        loop {
-            if i == peaks.len() {
-                break ();
-            }
-
-            peaks_arr.append(*peaks.at(i));
-
-            i += 1;
-        };
-        peaks_arr.append(hash);
+        // number of new nodes = trailing_ones(leaf_count)
+        // explanation: https://mmr.herodotus.dev/append
+        let no_merged_peaks = trailing_ones(leaf_count);
+        let no_preserved_peaks = peaks_count - no_merged_peaks;
+        let mut preserved_peaks = peaks.slice(0, no_preserved_peaks);
+        let mut merged_peaks = peaks.slice(no_preserved_peaks, no_merged_peaks);
 
-        let mut height = 0;
+        let mut last_peak = hash;
         loop {
-            if get_height(self.last_pos + 1) <= height {
-                break ();
-            }
+            match merged_peaks.pop_back() {
+                Option::Some(x) => { last_peak = PoseidonHasher::hash_double(*x, last_peak); },
+                Option::None => { break; }
+            };
             self.last_pos += 1;
+        };
 
-            let mut peaks_span = peaks_arr.span();
-            // As the above condition verifies that a merge is happening, we have at least 2 peaks (that are about to be merged)
-            let right = peaks_span.pop_back().unwrap();
-            let left = peaks_span.pop_back().unwrap();
-
-            let mut new_peaks = ArrayTrait::new();
-            i = 0;
-            loop {
-                if i == peaks_arr.len() - 2 {
-                    break ();
-                }
-
-                new_peaks.append(*peaks_arr.at(i));
-
-                i += 1;
+        let mut new_peaks = ArrayTrait::new();
+        loop {
+            match preserved_peaks.pop_front() {
+                Option::Some(x) => { new_peaks.append(*x); },
+                Option::None => { break; }
             };
-
-            let hash = PoseidonHasher::hash_double(*left, *right);
-            new_peaks.append(hash);
-            peaks_arr = new_peaks;
-
-            height += 1;
         };
+        new_peaks.append(last_peak);
 
-        let new_root = compute_root(self.last_pos.into(), peaks_arr.span());
+        let new_root = compute_root(self.last_pos, new_peaks.span());
         self.root = new_root;
 
-        Result::Ok((new_root, peaks_arr.span()))
+        Result::Ok((new_root, new_peaks.span()))
     }
 
     // @notice Verifies a proof for an element in the MMR
@@ -103,9 +90,9 @@ impl MMRImpl of MMRTrait {
     // @param proof The proof for the element
     // @return Result with true if the proof is valid, false otherwise
     fn verify_proof(
-        self: @MMR, index: usize, hash: felt252, peaks: Peaks, proof: Proof
+        self: @MMR, index: MmrSize, hash: MmrElement, peaks: Peaks, proof: Proof
     ) -> Result<bool, felt252> {
-        let leaf_count = mmr_size_to_leaf_count((*self.last_pos).into());
+        let leaf_count = mmr_size_to_leaf_count(*self.last_pos);
         if leaf_count_to_peaks_count(leaf_count) != peaks.len().into() {
             return Result::Err('Invalid peaks count');
         }

src/data_structures/mmr/peaks.cairo

@@ -1,15 +1,16 @@
 use cairo_lib::hashing::poseidon::PoseidonHasher;
 use cairo_lib::data_structures::mmr::utils::compute_root;
+use cairo_lib::data_structures::mmr::mmr::{MmrSize, MmrElement};
 use cairo_lib::utils::array::span_contains;
 
 // @notice Represents the peaks of the MMR
-type Peaks = Span<felt252>;
+type Peaks = Span<MmrElement>;
 
 #[generate_trait]
 impl PeaksImpl of PeaksTrait {
     // @notice Bags the peaks (hashing them together)
     // @return The bagged peaks
-    fn bag(self: Peaks) -> felt252 {
+    fn bag(self: Peaks) -> MmrElement {
         if self.is_empty() {
             return 0;
         }
@@ -35,16 +36,8 @@ impl PeaksImpl of PeaksTrait {
     // @param last_pos The last position in the MMR
     // @param root The root of the MMR
     // @return True if the peaks are valid
-    fn valid(self: Peaks, last_pos: usize, root: felt252) -> bool {
-        let computed_root = compute_root(last_pos.into(), self);
+    fn valid(self: Peaks, last_pos: MmrSize, root: MmrElement) -> bool {
+        let computed_root = compute_root(last_pos, self);
         computed_root == root
     }
-
-    // @notice Checks if the peaks contain a peak
-    // @param peak The peak to check inclusion
-    // @return True if the peaks contain the peak
-    #[inline(always)]
-    fn contains_peak(self: Peaks, peak: felt252) -> bool {
-        span_contains(self, peak)
-    }
 }