Merge pull request #2760 from ProvableHQ/evaluate_authorization

[Perf] Speed up authorize by evaluating instead of executing

Author: vicsn

synthesizer/process/src/authorize.rs

@@ -30,6 +30,21 @@ impl<N: Network> Process<N> {
         self.get_stack(program_id)?.authorize::<A, R>(private_key, function_name, inputs, rng)
     }
 
+    /// Authorizes a call to the program function for the given inputs.
+    /// Compared to `authorize`, this method does not check for circuit satisfiability of the request.
+    #[inline]
+    pub fn authorize_unchecked<A: circuit::Aleo<Network = N>, R: Rng + CryptoRng>(
+        &self,
+        private_key: &PrivateKey<N>,
+        program_id: impl TryInto<ProgramID<N>>,
+        function_name: impl TryInto<Identifier<N>>,
+        inputs: impl ExactSizeIterator<Item = impl TryInto<Value<N>>>,
+        rng: &mut R,
+    ) -> Result<Authorization<N>> {
+        // Authorize the call.
+        self.get_stack(program_id)?.authorize_unchecked::<A, R>(private_key, function_name, inputs, rng)
+    }
+
     /// Authorizes the fee given the credits record, the fee amount (in microcredits),
     /// and the deployment or execution ID.
     #[inline]

synthesizer/process/src/evaluate.rs

@@ -29,8 +29,10 @@ impl<N: Network> Process<N> {
 
         // Retrieve the stack.
         let stack = self.get_stack(request.program_id())?;
+        // Initialize an RNG.
+        let rng = &mut rand::thread_rng();
         // Evaluate the function.
-        let response = stack.evaluate_function::<A>(CallStack::evaluate(authorization)?, None);
+        let response = stack.evaluate_function::<A, _>(CallStack::evaluate(authorization)?, None, None, rng);
         lap!(timer, "Evaluate the function");
 
         finish!(timer);

synthesizer/process/src/stack/authorize.rs

@@ -56,4 +56,46 @@ impl<N: Network> Stack<N> {
         // Return the authorization.
         Ok(authorization)
     }
+
+    /// Authorizes a call to the program function for the given inputs.
+    /// Compared to `authorize`, this method does not check for circuit satisfiability of the request.
+    #[inline]
+    pub fn authorize_unchecked<A: circuit::Aleo<Network = N>, R: Rng + CryptoRng>(
+        &self,
+        private_key: &PrivateKey<N>,
+        function_name: impl TryInto<Identifier<N>>,
+        inputs: impl ExactSizeIterator<Item = impl TryInto<Value<N>>>,
+        rng: &mut R,
+    ) -> Result<Authorization<N>> {
+        let timer = timer!("Stack::authorize_unchecked");
+
+        // Get the program ID.
+        let program_id = *self.program.id();
+        // Prepare the function name.
+        let function_name = function_name.try_into().map_err(|_| anyhow!("Invalid function name"))?;
+        // Retrieve the input types.
+        let input_types = self.get_function(&function_name)?.input_types();
+        lap!(timer, "Retrieve the input types");
+        // Set is_root to true.
+        let is_root = true;
+
+        // This is the root request and does not have a caller.
+        let caller = None;
+        // This is the root request and we do not have a root_tvk to pass on.
+        let root_tvk = None;
+        // Compute the request.
+        let request =
+            Request::sign(private_key, program_id, function_name, inputs, &input_types, root_tvk, is_root, rng)?;
+        lap!(timer, "Compute the request");
+        // Initialize the authorization.
+        let authorization = Authorization::new(request.clone());
+        // Construct the call stack.
+        let call_stack = CallStack::Authorize(vec![request], *private_key, authorization.clone());
+        // Construct the authorization from the function.
+        let _response = self.evaluate_function::<A, R>(call_stack, caller, root_tvk, rng)?;
+        finish!(timer, "Construct the authorization from the function");
+
+        // Return the authorization.
+        Ok(authorization)
+    }
 }

synthesizer/process/src/stack/call/mod.rs

@@ -32,7 +32,12 @@ use synthesizer_program::{
 
 pub trait CallTrait<N: Network> {
     /// Evaluates the instruction.
-    fn evaluate<A: circuit::Aleo<Network = N>>(&self, stack: &Stack<N>, registers: &mut Registers<N, A>) -> Result<()>;
+    fn evaluate<A: circuit::Aleo<Network = N>, R: CryptoRng + Rng>(
+        &self,
+        stack: &Stack<N>,
+        registers: &mut Registers<N, A>,
+        rng: &mut R,
+    ) -> Result<()>;
 
     /// Executes the instruction.
     fn execute<A: circuit::Aleo<Network = N>, R: CryptoRng + Rng>(
@@ -46,7 +51,12 @@ pub trait CallTrait<N: Network> {
 impl<N: Network> CallTrait<N> for Call<N> {
     /// Evaluates the instruction.
     #[inline]
-    fn evaluate<A: circuit::Aleo<Network = N>>(&self, stack: &Stack<N>, registers: &mut Registers<N, A>) -> Result<()> {
+    fn evaluate<A: circuit::Aleo<Network = N>, R: CryptoRng + Rng>(
+        &self,
+        stack: &Stack<N>,
+        registers: &mut Registers<N, A>,
+        rng: &mut R,
+    ) -> Result<()> {
         let timer = timer!("Call::evaluate");
 
         // Load the operands values.
@@ -97,10 +107,38 @@ impl<N: Network> CallTrait<N> for Call<N> {
             if function.inputs().len() != inputs.len() {
                 bail!("Expected {} inputs, found {}", function.inputs().len(), inputs.len())
             }
+
+            // Get the 'root_tvk'.
+            let root_tvk = Some(registers.root_tvk()?);
+
+            // Get the call stack.
+            let mut call_stack = registers.call_stack();
+
+            // In Authorize mode, we need to compute the new request and push it onto the call stack.
+            if let CallStack::Authorize(ref mut requests, private_key, authorization) = &mut call_stack {
+                // Set 'is_root'.
+                let is_root = false;
+                // Compute the request.
+                let request = Request::sign(
+                    private_key,
+                    *substack.program_id(),
+                    *function.name(),
+                    inputs.iter(),
+                    &function.input_types(),
+                    root_tvk,
+                    is_root,
+                    rng,
+                )?;
+                // Add the request to the requests.
+                requests.push(request.clone());
+                // Add the request to the authorization.
+                authorization.push(request.clone())?;
+            };
+
             // Set the (console) caller.
             let console_caller = Some(*stack.program_id());
             // Evaluate the function.
-            let response = substack.evaluate_function::<A>(registers.call_stack(), console_caller)?;
+            let response = substack.evaluate_function::<A, R>(call_stack, console_caller, root_tvk, rng)?;
             // Load the outputs.
             response.outputs().to_vec()
         }
@@ -122,7 +160,7 @@ impl<N: Network> CallTrait<N> for Call<N> {
 
     /// Executes the instruction.
     #[inline]
-    fn execute<A: circuit::Aleo<Network = N>, R: Rng + CryptoRng>(
+    fn execute<A: circuit::Aleo<Network = N>, R: CryptoRng + Rng>(
         &self,
         stack: &Stack<N>,
         registers: &mut Registers<N, A>,
@@ -212,12 +250,12 @@ impl<N: Network> CallTrait<N> for Call<N> {
                 // Check if the substack has a proving key or not.
                 let pk_missing = !substack.contains_proving_key(function.name());
 
-                match registers.call_stack() {
+                match registers.call_stack_ref() {
                     // If the circuit is in authorize mode, then add any external calls to the stack.
                     CallStack::Authorize(_, private_key, authorization) => {
                         // Compute the request.
                         let request = Request::sign(
-                            &private_key,
+                            private_key,
                             *substack.program_id(),
                             *function.name(),
                             inputs.iter(),
@@ -245,7 +283,7 @@ impl<N: Network> CallTrait<N> for Call<N> {
                     CallStack::Synthesize(_, private_key, ..) if pk_missing => {
                         // Compute the request.
                         let request = Request::sign(
-                            &private_key,
+                            private_key,
                             *substack.program_id(),
                             *function.name(),
                             inputs.iter(),
@@ -271,7 +309,7 @@ impl<N: Network> CallTrait<N> for Call<N> {
                     CallStack::Synthesize(_, private_key, _) | CallStack::CheckDeployment(_, private_key, ..) => {
                         // Compute the request.
                         let request = Request::sign(
-                            &private_key,
+                            private_key,
                             *substack.program_id(),
                             *function.name(),
                             inputs.iter(),
@@ -282,7 +320,7 @@ impl<N: Network> CallTrait<N> for Call<N> {
                         )?;
 
                         // Compute the address.
-                        let address = Address::try_from(&private_key)?;
+                        let address = Address::try_from(private_key)?;
 
                         // For each output, if it's a record, compute the randomizer and nonce.
                         let outputs = function
@@ -339,7 +377,7 @@ impl<N: Network> CallTrait<N> for Call<N> {
                     CallStack::PackageRun(_, private_key, ..) => {
                         // Compute the request.
                         let request = Request::sign(
-                            &private_key,
+                            private_key,
                             *substack.program_id(),
                             *function.name(),
                             inputs.iter(),
@@ -375,8 +413,12 @@ impl<N: Network> CallTrait<N> for Call<N> {
                         })?;
 
                         // Evaluate the function, and load the outputs.
-                        let console_response =
-                            substack.evaluate_function::<A>(registers.call_stack().replicate(), console_caller)?;
+                        let console_response = substack.evaluate_function::<A, R>(
+                            registers.call_stack(),
+                            console_caller,
+                            root_tvk,
+                            rng,
+                        )?;
                         // Execute the request.
                         let response =
                             substack.execute_function::<A, R>(registers.call_stack(), console_caller, root_tvk, rng)?;

synthesizer/process/src/stack/evaluate.rs

@@ -97,15 +97,18 @@ impl<N: Network> Stack<N> {
     ///
     /// # Errors
     /// This method will halt if the given inputs are not the same length as the input statements.
-    pub fn evaluate_function<A: circuit::Aleo<Network = N>>(
+    pub fn evaluate_function<A: circuit::Aleo<Network = N>, R: CryptoRng + Rng>(
         &self,
-        call_stack: CallStack<N>,
+        mut call_stack: CallStack<N>,
         caller: Option<ProgramID<N>>,
+        root_tvk: Option<Field<N>>,
+        rng: &mut R,
     ) -> Result<Response<N>> {
         let timer = timer!("Stack::evaluate_function");
 
         // Retrieve the next request, based on the call stack mode.
-        let (request, call_stack) = match &call_stack {
+        let (request, call_stack) = match &mut call_stack {
+            CallStack::Authorize(..) => (call_stack.pop()?, call_stack),
             CallStack::Evaluate(authorization) => (authorization.next()?, call_stack),
             // If the evaluation is performed in the `Execute` mode, create a new `Evaluate` mode.
             // This is done to ensure that evaluation during execution is performed consistently.
@@ -117,7 +120,9 @@ impl<N: Network> Stack<N> {
                 let call_stack = CallStack::Evaluate(authorization);
                 (request, call_stack)
             }
-            _ => bail!("Illegal operation: call stack must be `Evaluate` or `Execute` in `evaluate_function`."),
+            _ => bail!(
+                "Illegal operation: call stack must be `Authorize`, `Evaluate` or `Execute` in `evaluate_function`."
+            ),
         };
         lap!(timer, "Retrieve the next request");
 
@@ -161,10 +166,16 @@ impl<N: Network> Stack<N> {
         registers.set_caller(caller);
         // Set the transition view key.
         registers.set_tvk(tvk);
+        // Set the root tvk.
+        if let Some(root_tvk) = root_tvk {
+            registers.set_root_tvk(root_tvk);
+        } else {
+            registers.set_root_tvk(tvk);
+        }
         lap!(timer, "Initialize the registers");
 
         // Ensure the request is well-formed.
-        ensure!(request.verify(&function.input_types(), is_root), "Request is invalid");
+        ensure!(request.verify(&function.input_types(), is_root), "[Evaluate] Request is invalid");
         lap!(timer, "Verify the request");
 
         // Store the inputs.
@@ -180,7 +191,7 @@ impl<N: Network> Stack<N> {
             // Evaluate the instruction.
             let result = match instruction {
                 // If the instruction is a `call` instruction, we need to handle it separately.
-                Instruction::Call(call) => CallTrait::evaluate(call, self, &mut registers),
+                Instruction::Call(call) => CallTrait::evaluate(call, self, &mut registers, rng),
                 // Otherwise, evaluate the instruction normally.
                 _ => instruction.evaluate(self, &mut registers),
             };
@@ -243,9 +254,18 @@ impl<N: Network> Stack<N> {
             outputs,
             &function.output_types(),
             &output_registers,
-        );
+        )?;
         finish!(timer);
 
-        response
+        // If the circuit is in `Authorize` mode, then save the transition.
+        if let CallStack::Authorize(_, _, authorization) = registers.call_stack_ref() {
+            // Construct the transition.
+            let transition = Transition::from(&request, &response, &function.output_types(), &output_registers)?;
+            // Add the transition to the authorization.
+            authorization.insert_transition(transition)?;
+            lap!(timer, "Save the transition");
+        }
+
+        Ok(response)
     }
 }

synthesizer/process/src/stack/execute.rs

@@ -56,7 +56,7 @@ impl<N: Network> Stack<N> {
         // Store the inputs.
         closure.inputs().iter().map(|i| i.register()).zip_eq(inputs).try_for_each(|(register, input)| {
             // If the circuit is in execute mode, then store the console input.
-            if let CallStack::Execute(..) = registers.call_stack() {
+            if let CallStack::Execute(..) = registers.call_stack_ref() {
                 use circuit::Eject;
                 // Assign the console input to the register.
                 registers.store(self, register, input.eject_value())?;
@@ -69,7 +69,7 @@ impl<N: Network> Stack<N> {
         // Execute the instructions.
         for instruction in closure.instructions() {
             // If the circuit is in execute mode, then evaluate the instructions.
-            if let CallStack::Execute(..) = registers.call_stack() {
+            if let CallStack::Execute(..) = registers.call_stack_ref() {
                 // If the evaluation fails, bail and return the error.
                 if let Err(error) = instruction.evaluate(self, &mut registers) {
                     bail!("Failed to evaluate instruction ({instruction}): {error}");
@@ -267,7 +267,7 @@ impl<N: Network> Stack<N> {
         // Store the inputs.
         function.inputs().iter().map(|i| i.register()).zip_eq(request.inputs()).try_for_each(|(register, input)| {
             // If the circuit is in execute mode, then store the console input.
-            if let CallStack::Execute(..) = registers.call_stack() {
+            if let CallStack::Execute(..) = registers.call_stack_ref() {
                 // Assign the console input to the register.
                 registers.store(self, register, input.eject_value())?;
             }
@@ -282,11 +282,11 @@ impl<N: Network> Stack<N> {
         // Execute the instructions.
         for instruction in function.instructions() {
             // If the circuit is in execute mode, then evaluate the instructions.
-            if let CallStack::Execute(..) = registers.call_stack() {
+            if let CallStack::Execute(..) = registers.call_stack_ref() {
                 // Evaluate the instruction.
                 let result = match instruction {
                     // If the instruction is a `call` instruction, we need to handle it separately.
-                    Instruction::Call(call) => CallTrait::evaluate(call, self, &mut registers),
+                    Instruction::Call(call) => CallTrait::evaluate(call, self, &mut registers, rng),
                     // Otherwise, evaluate the instruction normally.
                     _ => instruction.evaluate(self, &mut registers),
                 };
@@ -410,7 +410,7 @@ impl<N: Network> Stack<N> {
         })?;
 
         // If the circuit is in `Execute` or `PackageRun` mode, then ensure the circuit is satisfied.
-        if matches!(registers.call_stack(), CallStack::Execute(..) | CallStack::PackageRun(..)) {
+        if matches!(registers.call_stack_ref(), CallStack::Execute(..) | CallStack::PackageRun(..)) {
             // If the circuit is empty or not satisfied, then throw an error.
             ensure!(
                 A::num_constraints() > 0 && A::is_satisfied(),
@@ -425,7 +425,7 @@ impl<N: Network> Stack<N> {
         let assignment = A::eject_assignment_and_reset();
 
         // If the circuit is in `Synthesize` or `Execute` mode, synthesize the circuit key, if it does not exist.
-        if matches!(registers.call_stack(), CallStack::Synthesize(..) | CallStack::Execute(..)) {
+        if matches!(registers.call_stack_ref(), CallStack::Synthesize(..) | CallStack::Execute(..)) {
             // If the proving key does not exist, then synthesize it.
             if !self.contains_proving_key(function.name()) {
                 // Add the circuit key to the mapping.
@@ -434,15 +434,15 @@ impl<N: Network> Stack<N> {
             }
         }
         // If the circuit is in `Authorize` mode, then save the transition.
-        if let CallStack::Authorize(_, _, authorization) = registers.call_stack() {
+        if let CallStack::Authorize(_, _, authorization) = registers.call_stack_ref() {
             // Construct the transition.
             let transition = Transition::from(&console_request, &response, &output_types, &output_registers)?;
             // Add the transition to the authorization.
             authorization.insert_transition(transition)?;
             lap!(timer, "Save the transition");
         }
         // If the circuit is in `CheckDeployment` mode, then save the assignment.
-        else if let CallStack::CheckDeployment(_, _, ref assignments, _, _) = registers.call_stack() {
+        else if let CallStack::CheckDeployment(_, _, ref assignments, _, _) = registers.call_stack_ref() {
             // Construct the call metrics.
             let metrics = CallMetrics {
                 program_id: *self.program_id(),
@@ -457,7 +457,7 @@ impl<N: Network> Stack<N> {
             lap!(timer, "Save the circuit assignment");
         }
         // If the circuit is in `Execute` mode, then execute the circuit into a transition.
-        else if let CallStack::Execute(_, ref trace) = registers.call_stack() {
+        else if let CallStack::Execute(_, ref trace) = registers.call_stack_ref() {
             registers.ensure_console_and_circuit_registers_match()?;
 
             // Construct the transition.
@@ -484,7 +484,7 @@ impl<N: Network> Stack<N> {
             )?;
         }
         // If the circuit is in `PackageRun` mode, then save the assignment.
-        else if let CallStack::PackageRun(_, _, ref assignments) = registers.call_stack() {
+        else if let CallStack::PackageRun(_, _, ref assignments) = registers.call_stack_ref() {
             // Construct the call metrics.
             let metrics = CallMetrics {
                 program_id: *self.program_id(),