extract extract_failure_payload function to improve readability

manastech · Jul 1, 2024 · e184be1 · e184be1
1 parent 5ace5b6
commit e184be1
Showing 1 changed file with 61 additions and 52 deletions.
diff --git a/acvm-repo/acvm/src/pwg/brillig.rs b/acvm-repo/acvm/src/pwg/brillig.rs
@@ -169,69 +169,78 @@ impl<'b, B: BlackBoxFunctionSolver<F>, F: AcirField> BrilligSolver<'b, F, B> {
                         brillig_index: *brillig_index,
                     })
                     .collect();
-                match reason {
-                    FailureReason::RuntimeError { message } => {
-                        Err(OpcodeResolutionError::BrilligFunctionFailed {
-                            payload: Some(ResolvedAssertionPayload::String(message)),
-                            call_stack,
-                        })
-                    }
-
-                    FailureReason::Trap { revert_data_offset, revert_data_size } => {
-                        // Since noir can only revert with strings currently, we can parse return data as a string
-                        let payload = if revert_data_size == 0 {
-                            None
-                        } else {
-                            let memory = self.vm.get_memory();
-                            let mut revert_values_iter = memory
-                                [revert_data_offset..(revert_data_offset + revert_data_size)]
-                                .iter();
-                            let error_selector = ErrorSelector::new(
-                                revert_values_iter
-                                    .next()
-                                    .expect("Incorrect revert data size")
-                                    .try_into()
-                                    .expect("Error selector is not u64"),
-                            );
-
-                            match error_selector {
-                                STRING_ERROR_SELECTOR => {
-                                    // If the error selector is 0, it means the error is a string
-                                    let string = revert_values_iter
-                                        .map(|memory_value| {
-                                            let as_u8: u8 = memory_value
-                                                .try_into()
-                                                .expect("String item is not u8");
-                                            as_u8 as char
-                                        })
-                                        .collect();
-                                    Some(ResolvedAssertionPayload::String(string))
-                                }
-                                _ => {
-                                    // If the error selector is not 0, it means the error is a custom error
-                                    Some(ResolvedAssertionPayload::Raw(RawAssertionPayload {
-                                        selector: error_selector,
-                                        data: revert_values_iter
-                                            .map(|value| value.to_field())
-                                            .collect(),
-                                    }))
-                                }
-                            }
-                        };
+                let payload = self.extract_failure_payload(&reason);
 
-                        Err(OpcodeResolutionError::BrilligFunctionUnsatisfiedConstrain {
+                let resolution_error = |payload, call_stack: Vec<OpcodeLocation>| match &reason {
+                    FailureReason::RuntimeError { .. } => {
+                        OpcodeResolutionError::BrilligFunctionFailed { payload, call_stack }
+                    }
+                    FailureReason::Trap { .. } => {
+                        OpcodeResolutionError::BrilligFunctionUnsatisfiedConstrain {
                             payload,
                             call_stack,
-                        })
+                        }
                     }
-                }
+                };
+
+                Err(resolution_error(payload, call_stack))
             }
             VMStatus::ForeignCallWait { function, inputs } => {
                 Ok(BrilligSolverStatus::ForeignCallWait(ForeignCallWaitInfo { function, inputs }))
             }
         }
     }
 
+    fn extract_failure_payload(
+        &self,
+        reason: &FailureReason,
+    ) -> Option<ResolvedAssertionPayload<F>> {
+        match reason {
+            FailureReason::RuntimeError { message } => {
+                Some(ResolvedAssertionPayload::String(message.clone()))
+            }
+            FailureReason::Trap { revert_data_offset, revert_data_size } => {
+                // Since noir can only revert with strings currently, we can parse return data as a string
+                if *revert_data_size == 0 {
+                    None
+                } else {
+                    let memory = self.vm.get_memory();
+                    let mut revert_values_iter = memory
+                        [*revert_data_offset..(*revert_data_offset + *revert_data_size)]
+                        .iter();
+                    let error_selector = ErrorSelector::new(
+                        revert_values_iter
+                            .next()
+                            .expect("Incorrect revert data size")
+                            .try_into()
+                            .expect("Error selector is not u64"),
+                    );
+
+                    match error_selector {
+                        STRING_ERROR_SELECTOR => {
+                            // If the error selector is 0, it means the error is a string
+                            let string = revert_values_iter
+                                .map(|memory_value| {
+                                    let as_u8: u8 =
+                                        memory_value.try_into().expect("String item is not u8");
+                                    as_u8 as char
+                                })
+                                .collect();
+                            Some(ResolvedAssertionPayload::String(string))
+                        }
+                        _ => {
+                            // If the error selector is not 0, it means the error is a custom error
+                            Some(ResolvedAssertionPayload::Raw(RawAssertionPayload {
+                                selector: error_selector,
+                                data: revert_values_iter.map(|value| value.to_field()).collect(),
+                            }))
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     pub(crate) fn finalize(
         self,
         witness: &mut WitnessMap<F>,