reorganize

Author: christianwwwwwwww

wasm/src/programs/manager/execute.rs

@@ -27,7 +27,6 @@ use crate::{
     execute_program,
     log,
     process_inputs,
-    programs::SnapshotQuery,
     types::native::{
         CurrentAleo,
         CurrentNetwork,
@@ -39,24 +38,15 @@ use crate::{
     },
 };
 use snarkvm_algorithms::snark::varuna::VarunaVersion;
-use snarkvm_console::{
-    network::{ConsensusVersion},
-    types::Field,
-};
+use snarkvm_console::network::{ConsensusVersion, Network};
 use snarkvm_ledger_query::QueryTrait;
-use snarkvm_synthesizer::prelude::{
-    InclusionVersion,
-    cost_in_microcredits_v1,
-    execution_cost_v1,
-    execution_cost_v2,
-};
+use snarkvm_synthesizer::prelude::{InclusionVersion, cost_in_microcredits_v1, execution_cost_v1, execution_cost_v2};
 
 use core::ops::Add;
 use js_sys::{Array, Object};
 use rand::{SeedableRng, rngs::StdRng};
 use std::str::FromStr;
 
-
 #[wasm_bindgen]
 impl ProgramManager {
     /// Execute an arbitrary function locally
@@ -121,23 +111,13 @@ impl ProgramManager {
         let mut execution_response = if prove_execution {
             log("Preparing inclusion proofs for execution");
             if let Some(offline_query) = offline_query {
-                trace.prepare_async(&offline_query).await.map_err(|e| e.to_string())?;
+                trace.prepare_async(&offline_query).await.map_err(|err| err.to_string())?;
             } else {
-                // NEW: try snapshot query, fallback to QueryNative (TODO, for now)
-                let commitments = snapshot_helpers::collect_commitments_from_trace(&trace)?;
-                match snapshot_helpers::build_snapshot_query(node_url, &commitments).await {
-                    Ok(snapshot_query) => {
-                        trace.prepare_async(&snapshot_query).await.map_err(|e| e.to_string())?;
-                    }
-                    Err(_e) => {
-                        // TODO: remove this fallback once snapshot builder is implemented
-                        let query = QueryNative::from(node_url);
-                        trace.prepare_async(&query).await.map_err(|err| err.to_string())?;
-                    }
-                }
+                let query = QueryNative::from(node_url);
+                // todo change this to new query struct and to try_from rather than from
+                trace.prepare_async(&query).await.map_err(|err| err.to_string())?;
             }
 
-
             log("Proving execution");
             let locator = program_native.id().to_string().add("/").add(function);
             let execution =
@@ -223,20 +203,10 @@ impl ProgramManager {
         if let Some(offline_query) = offline_query.as_ref() {
             trace.prepare_async(offline_query).await.map_err(|err| err.to_string())?;
         } else {
-            // NEW: try snapshot query, fallback to QueryNative (TODO, for now)
-            let commitments = snapshot_helpers::collect_commitments_from_trace(&trace)?;
-            match snapshot_helpers::build_snapshot_query(node_url, &commitments).await {
-                Ok(snapshot_query) => {
-                    trace.prepare_async(&snapshot_query).await.map_err(|e| e.to_string())?;
-                }
-                Err(_e) => {
-                    let query = QueryNative::from(node_url);
-                    trace.prepare_async(&query).await.map_err(|err| err.to_string())?;
-                }
-            }
+            let query = QueryNative::from(node_url);
+            trace.prepare_async(&query).await.map_err(|err| err.to_string())?;
         }
 
-
         log("Proving execution");
         let locator = program_native.id().to_string().add("/").add(function);
         let execution = trace
@@ -356,23 +326,11 @@ impl ProgramManager {
             trace.prepare_async(&offline_query).await.map_err(|err| err.to_string())?;
             block_height
         } else {
-            // try snapshot query, fallback to QueryNative (TODO, for now)
-            let commitments = snapshot_helpers::collect_commitments_from_trace(&trace)?;
-            match snapshot_helpers::build_snapshot_query(node_url, &commitments).await {
-                Ok(snapshot_query) => {
-                    let bh = snapshot_query.current_block_height().map_err(|e| e.to_string())?;
-                    trace.prepare_async(&snapshot_query).await.map_err(|e| e.to_string())?;
-                    bh
-                }
-                Err(_e) => {
-                    let query = QueryNative::from(node_url);
-                    let bh = query.current_block_height_async().await.map_err(|e| e.to_string())?;
-                    trace.prepare_async(&query).await.map_err(|err| err.to_string())?;
-                    bh
-                }
-            }
+            let query = QueryNative::from(node_url);
+            let block_height = query.current_block_height_async().await.map_err(|e| e.to_string())?;
+            trace.prepare_async(&query).await.map_err(|err| err.to_string())?;
+            block_height
         };
-
         let execution =
             trace.prove_execution::<CurrentAleo, _>(&locator, VarunaVersion::V2, rng).map_err(|e| e.to_string())?;
 
@@ -431,51 +389,6 @@ impl ProgramManager {
     }
 }
 
-mod snapshot_helpers {
-    use super::*;
-    type StateRootNative = <CurrentNetwork as snarkvm_console::network::Network>::StateRoot;
-
-    pub fn collect_commitments_from_trace<T>(
-        _trace: &T,
-    ) -> Result<Vec<Field<CurrentNetwork>>, String> {
-        Ok(vec![])
-    }
-
-    pub async fn build_snapshot_query(
-        node_url: &str,
-        commitments: &[Field<CurrentNetwork>],
-    ) -> Result<SnapshotQuery, String> {
-        let (state_root, block_height) = snapshot_head(node_url).await?;
-        let mut query = SnapshotQuery::new(block_height, &state_root_to_string(state_root))?;
-
-        for c in commitments {
-            let c_str = c.to_string();
-            let sp_str = fetch_state_path_at_root(node_url, &c_str, &state_root_to_string(state_root)).await?;
-            query.add_state_path(&c_str, &sp_str)?;
-        }
-        Ok(query)
-    }
-
-    // Prefer an API that returns both in one call; otherwise fetch root then height immediately.
-    async fn snapshot_head(node_url: &str) -> Result<(StateRootNative, u32), String> {
-        // TODO: call existing client / REST: (root, height)
-        Err("snapshot_head() not implemented".into())
-    }
-
-    async fn fetch_state_path_at_root(
-        node_url: &str,
-        commitment: &str,
-        state_root: &str,
-    ) -> Result<String, String> {
-        // TODO: call endpoint that returns a StatePath string for (commitment, state_root)
-        Err("fetch_state_path_at_root() not implemented".into())
-    }
-
-    fn state_root_to_string(root: StateRootNative) -> String {
-        root.to_string()
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -517,4 +430,4 @@ mod tests {
 
         assert!(transaction.is_execute());
     }
-}
+}

wasm/src/programs/snapshot_query.rs

@@ -112,3 +112,49 @@ impl QueryTrait<CurrentNetwork> for SnapshotQuery {
         Ok(self.block_height)
     }
 }
+
+
+mod snapshot_helpers {
+    use super::*;
+    type StateRootNative = <CurrentNetwork as snarkvm_console::network::Network>::StateRoot;
+
+    pub fn collect_commitments_from_trace<T>(
+        _trace: &T,
+    ) -> Result<Vec<Field<CurrentNetwork>>, String> {
+        Ok(vec![])
+    }
+
+    pub async fn build_snapshot_query(
+        node_url: &str,
+        commitments: &[Field<CurrentNetwork>],
+    ) -> Result<SnapshotQuery, String> {
+        let (state_root, block_height) = snapshot_head(node_url).await?;
+        let mut query = SnapshotQuery::new(block_height, &state_root_to_string(state_root))?;
+
+        for c in commitments {
+            let c_str = c.to_string();
+            let sp_str = fetch_state_path_at_root(node_url, &c_str, &state_root_to_string(state_root)).await?;
+            query.add_state_path(&c_str, &sp_str)?;
+        }
+        Ok(query)
+    }
+
+    // Prefer an API that returns both in one call; otherwise fetch root then height immediately.
+    async fn snapshot_head(node_url: &str) -> Result<(StateRootNative, u32), String> {
+        // TODO: call existing client / REST: (root, height)
+        Err("snapshot_head() not implemented".into())
+    }
+
+    async fn fetch_state_path_at_root(
+        node_url: &str,
+        commitment: &str,
+        state_root: &str,
+    ) -> Result<String, String> {
+        // TODO: call endpoint that returns a StatePath string for (commitment, state_root)
+        Err("fetch_state_path_at_root() not implemented".into())
+    }
+
+    fn state_root_to_string(root: StateRootNative) -> String {
+        root.to_string()
+    }
+}