added input generation and burner private key, removing the need to provide them to the function

Author: alexpitsikoulis

wasm/src/programs/manager/execute.rs

@@ -17,8 +17,10 @@
 use super::*;
 
 use crate::{
+    Address,
     ExecutionResponse,
     OfflineQuery,
+    Plaintext,
     PrivateKey,
     RecordPlaintext,
     SnapshotQuery,
@@ -42,10 +44,12 @@ use crate::{
 use snarkvm_algorithms::snark::varuna::VarunaVersion;
 use snarkvm_console::{
     network::{ConsensusVersion, Network},
-    program::Value,
+    program::{ArrayType, PlaintextType, Value, ValueType},
 };
 use snarkvm_ledger_query::QueryTrait;
 use snarkvm_synthesizer::prelude::{InclusionVersion, execution_cost, execution_cost_for_authorization};
+use snarkvm_synthesizer_program::FunctionCore;
+use wasm_bindgen::JsValue;
 
 use crate::types::native::{PrivateKeyNative, ViewKeyNative};
 use core::ops::Add;
@@ -307,10 +311,8 @@ impl ProgramManager {
     #[wasm_bindgen(js_name = estimateExecutionFee)]
     #[allow(clippy::too_many_arguments)]
     pub async fn estimate_execution_fee(
-        private_key: &PrivateKey,
         program: &str,
         function: &str,
-        inputs: Array,
         url: Option<String>,
         imports: Option<Object>,
         offline_query: Option<OfflineQuery>,
@@ -327,6 +329,32 @@ impl ProgramManager {
         log("Check program imports are valid and add them to the process");
         let program_native = ProgramNative::from_str(program).map_err(|e| e.to_string())?;
 
+        let rng = &mut StdRng::from_entropy();
+        // Initialize a burner private key.
+        let burner_private_key = PrivateKey::new();
+        // Compute the burner address.
+        let burner_address = Address::from_private_key(&burner_private_key);
+
+        let function_native = program_native.get_function(function).map_err(|e| e.to_string())?;
+
+        let mut inputs: Vec<Value<CurrentNetwork>> = vec![];
+        for input_type in function_native.input_types() {
+            match input_type {
+                ValueType::ExternalRecord(locator) => {
+                    let stack = process.get_stack(locator.program_id()).map_err(|e| e.to_string())?;
+                    inputs.push(stack.sample_value(
+                        &burner_address,
+                        &ValueType::Record(*locator.resource()).into(),
+                        rng,
+                    ));
+                }
+                _ => {
+                    let stack = process.get_stack(program_native.id()).map_err(|e| e.to_string())?;
+                    inputs.push(stack.sample_value(&burner_address, &input_type.into(), rng));
+                }
+            }
+        }
+
         let program_id = program_native.id();
         let edition = edition.unwrap_or(1);
 
@@ -338,16 +366,9 @@ impl ProgramManager {
         }
 
         ProgramManager::resolve_imports(process, &program_native, imports)?;
-        let rng = &mut StdRng::from_entropy();
 
         let authorization = process
-            .authorize::<CurrentAleo, StdRng>(
-                private_key,
-                program_id,
-                function,
-                inputs.iter().map(|v| Value::from_str(&v.as_string().unwrap_or_default())),
-                rng,
-            )
+            .authorize::<CurrentAleo, StdRng>(&burner_private_key, program_id, function, inputs, rng)
             .map_err(|e| e.to_string())?;
 
         let node_url = url.as_deref().unwrap_or(DEFAULT_URL);
@@ -356,11 +377,16 @@ impl ProgramManager {
         } else {
             let function_name = IdentifierNative::from_str(function).map_err(|err| err.to_string())?;
             let view_key =
-                ViewKeyNative::try_from(PrivateKeyNative::from(private_key)).map_err(|err| err.to_string())?;
-            let query =
-                SnapshotQuery::try_from_inputs(node_url, &program_native, &function_name, &view_key, &inputs.to_vec())
-                    .await
-                    .map_err(|err| err.to_string())?;
+                ViewKeyNative::try_from(PrivateKeyNative::from(burner_private_key)).map_err(|err| err.to_string())?;
+            let query = SnapshotQuery::try_from_inputs(
+                node_url,
+                &program_native,
+                &function_name,
+                &view_key,
+                &inputs.iter().map(|input| JsValue::from_str(&input.to_string())).collect(),
+            )
+            .await
+            .map_err(|err| err.to_string())?;
             query.current_block_height().map_err(|e| e.to_string())?
         };
 

website/src/workers/worker.js

@@ -182,10 +182,8 @@ self.addEventListener("message", (ev) => {
 
                 // Estimate the execution fee
                 let executeFee = await aleo.ProgramManagerBase.estimateExecutionFee(
-                    privateKeyObject,
                     remoteProgram,
                     aleoFunction,
-                    inputs,
                     url,
                     imports,
                     undefined,