add navori libs

Move.toml

@@ -4,13 +4,17 @@ version = "1.0.0"
 authors = []
 
 [addresses]
-starknet_addr = "0xb50b1b8157ebf7315813c1f745a1e1c68c73111afe2b6761975223d317569b69"
+starknet_addr = "_"
+lib_addr = "_"
 
 [dev-addresses]
+starknet_addr = "0xb50b1b8157ebf7315813c1f745a1e1c68c73111afe2b6761975223d317569b69"
+lib_addr = "54ba5979fbdf5fa56c4f4b5147fa33068148d08f6f191c23bca865c21192dcaa"
 
 [dependencies.AptosFramework]
 git = "https://github.com/aptos-labs/aptos-core.git"
-rev = "aptos-release-v1.17"
+rev = "mainnet"
 subdir = "aptos-move/framework/aptos-framework"
 
-[dev-dependencies]
+[dependencies]
+libs = { git = "https://github.com/sota-zk-labs/navori", rev = "layout6", subdir = "libs" }

sources/components/fact_registry.move

@@ -1,33 +1,39 @@
-// TODO: Add Navori as a dependency
 module starknet_addr::fact_registry {
+    use std::signer::address_of;
     use aptos_std::smart_table;
-    use aptos_std::smart_table::{ SmartTable, borrow, upsert, new };
+    use aptos_std::smart_table::SmartTable;
+    use aptos_framework::event;
+
+    #[event]
+    struct FactRegistered has store, drop {
+        fact_hash: u256
+    }
 
     struct VerifierFact has key, store {
-        verified_fact: SmartTable<vector<u8>, bool>,
+        verified_fact: SmartTable<u256, bool>,
         any_fact_registered: bool
     }
 
-    public entry fun init_fact_registry(s: &signer) {
+    public fun init_fact_registry(s: &signer) {
         move_to(s, VerifierFact {
-            verified_fact: new<vector<u8>, bool>(),
+            verified_fact: smart_table::new<u256, bool>(),
             any_fact_registered: false
         });
     }
 
     #[view]
-    public fun is_valid(fact: vector<u8>): bool acquires VerifierFact {
-        let verifier_fact = borrow_global<VerifierFact>(@starknet_addr);
+    public fun is_valid(address: address, fact: u256): bool acquires VerifierFact {
+        let verifier_fact = borrow_global<VerifierFact>(address);
         *smart_table::borrow_with_default(&verifier_fact.verified_fact, fact, &false)
     }
 
-    #[view]
-    public fun fact_check(fact: vector<u8>): bool acquires VerifierFact {
-        *borrow(&borrow_global<VerifierFact>(@starknet_addr).verified_fact, fact)
-    }
+    public fun register_fact(s: &signer, fact_hash: u256) acquires VerifierFact {
+        let verifier_fact = borrow_global_mut<VerifierFact>(address_of(s));
+        smart_table::upsert(&mut verifier_fact.verified_fact, fact_hash, true);
+        event::emit<FactRegistered>(FactRegistered { fact_hash });
 
-    public entry fun register_fact(fact_hash: vector<u8>) acquires VerifierFact {
-        let verifier_fact = borrow_global_mut<VerifierFact>(@starknet_addr);
-        upsert(&mut verifier_fact.verified_fact, fact_hash, true);
+        if (verifier_fact.any_fact_registered == false) {
+            verifier_fact.any_fact_registered = true;
+        }
     }
 }

sources/components/onchain_data_fact_tree_encoded.move

@@ -1,9 +1,8 @@
 module starknet_addr::onchain_data_fact_tree_encoded {
     use std::bcs::to_bytes;
-    use std::vector;
+    use std::vector::{length, reverse_append, append};
     use aptos_std::aptos_hash::keccak256;
-
-    use starknet_addr::bytes;
+    use lib_addr::bytes::{num_to_bytes_le, bytes32_to_u256, vec_to_bytes_le};
 
     struct DataAvailabilityFact has store, drop {
         onchain_data_hash: u256,
@@ -14,16 +13,16 @@ module starknet_addr::onchain_data_fact_tree_encoded {
         program_output: &vector<u256>,
         fact_data: DataAvailabilityFact
     ): vector<u8> {
-        let main_public_input_length: u256 = (vector::length(program_output) as u256);
-        let main_public_input_hash: vector<u8> = keccak256(bytes::vec_to_bytes_be(program_output));
-        vector::reverse_append(&mut main_public_input_hash, to_bytes(&main_public_input_length));
-        vector::append(&mut main_public_input_hash, bytes::num_to_bytes_be(&fact_data.onchain_data_hash));
-        vector::append(
+        let main_public_input_length: u256 = (length(program_output) as u256);
+        let main_public_input_hash: vector<u8> = keccak256(vec_to_bytes_le(program_output));
+        reverse_append(&mut main_public_input_hash, to_bytes(&main_public_input_length));
+        append(&mut main_public_input_hash, num_to_bytes_le(&fact_data.onchain_data_hash));
+        append(
             &mut main_public_input_hash,
-            bytes::num_to_bytes_be(&(main_public_input_length + fact_data.onchain_data_size))
+            num_to_bytes_le(&(main_public_input_length + fact_data.onchain_data_size))
         );
         let hash_result: vector<u8> = keccak256(main_public_input_hash);
-        let result = bytes::num_to_bytes_be(&(bytes::u256_from_bytes_be(&hash_result) + 1));
+        let result = num_to_bytes_le(&(bytes32_to_u256(hash_result) + 1));
         return result
     }
 

sources/kzg/pre_compile.move

@@ -1,7 +1,7 @@
 module starknet_addr::pre_compile {
-    use std::vector;
+    use std::vector::{length, trim, trim_reverse, append};
+    use lib_addr::bytes;
 
-    use starknet_addr::bytes;
     use starknet_addr::kzg_helper;
     use starknet_addr::kzg_verify;
 
@@ -25,14 +25,14 @@ module starknet_addr::pre_compile {
 
     public fun point_evaluation_precompile(bytes: vector<u8>): vector<u8> {
         assert!(
-            vector::length(&bytes) == 192,
+            length(&bytes) == 192,
             EINVALID_PRE_COMPILE_INPUT_SIZE
         );
 
-        let proof = vector::trim(&mut bytes, 144);
-        let commitment = vector::trim(&mut bytes, 96);
-        let y = vector::trim_reverse(&mut bytes, 64);
-        let z = vector::trim_reverse(&mut bytes, 32);
+        let proof = trim(&mut bytes, 144);
+        let commitment = trim(&mut bytes, 96);
+        let y = trim_reverse(&mut bytes, 64);
+        let z = trim_reverse(&mut bytes, 32);
         let versioned_hash = bytes;
 
         // Verify commitment matches versioned_hash
@@ -46,8 +46,8 @@ module starknet_addr::pre_compile {
             EINVALID_KZG_COMMITMENT
         );
 
-        let output = bytes::num_to_bytes_be(&FIELD_ELEMENTS_PER_BLOB);
-        vector::append(&mut output, bytes::num_to_bytes_be(&BLS_MODULUS));
+        let output = bytes::num_to_bytes_le(&FIELD_ELEMENTS_PER_BLOB);
+        append(&mut output, bytes::num_to_bytes_le(&BLS_MODULUS));
         return output
     }