feat: include oracles in ABI

compiler/noirc_driver/src/abi_gen.rs

@@ -4,7 +4,8 @@ use acvm::acir::circuit::ErrorSelector;
 use acvm::AcirField;
 use iter_extended::vecmap;
 use noirc_abi::{
-    Abi, AbiErrorType, AbiParameter, AbiReturnType, AbiType, AbiValue, AbiVisibility, Sign,
+    Abi, AbiErrorType, AbiParameter, AbiReturnType, AbiType, AbiValue, AbiVisibility, Oracle,
+    OracleParameter, Sign,
 };
 use noirc_frontend::ast::{Signedness, Visibility};
 use noirc_frontend::TypeBinding;
@@ -36,7 +37,8 @@ pub(super) fn gen_abi(
         .into_iter()
         .map(|(selector, typ)| (selector, build_abi_error_type(context, &typ)))
         .collect();
-    Abi { parameters, return_type, error_types }
+    let oracles = compute_oracles(context);
+    Abi { parameters, return_type, error_types, oracles }
 }
 
 fn build_abi_error_type(context: &Context, typ: &Type) -> AbiErrorType {
@@ -141,6 +143,21 @@ pub(super) fn compute_function_abi(
     (parameters, return_type)
 }
 
+fn compute_oracles(context: &Context) -> Vec<Oracle> {
+    context
+        .def_interner
+        .oracle_functions()
+        .map(|(func_id, oracle_name)| {
+            let (parameters, return_type) = compute_function_abi(context, func_id);
+            let parameters = vecmap(parameters, |parameter| OracleParameter {
+                name: parameter.name,
+                typ: parameter.typ,
+            });
+            Oracle { name: oracle_name.to_string(), parameters, return_type }
+        })
+        .collect()
+}
+
 /// Attempts to retrieve the name of this parameter. Returns None
 /// if this parameter is a tuple or struct pattern.
 fn get_param_name<'a>(pattern: &HirPattern, interner: &'a NodeInterner) -> Option<&'a str> {

compiler/noirc_frontend/src/node_interner.rs

@@ -220,12 +220,12 @@
     interned_statement_kinds: noirc_arena::Arena<StatementKind>,
 
     // Interned `UnresolvedTypeData`s during comptime code.
     interned_unresolved_type_datas: noirc_arena::Arena<UnresolvedTypeData>,
 
     // Interned `Pattern`s during comptime code.
     interned_patterns: noirc_arena::Arena<Pattern>,
 
     /// Determins whether to run in LSP mode. In LSP mode references are tracked.
     pub(crate) lsp_mode: bool,
 
     /// Store the location of the references in the graph.
@@ -670,7 +670,7 @@
             quoted_types: Default::default(),
             interned_expression_kinds: Default::default(),
             interned_statement_kinds: Default::default(),
             interned_unresolved_type_datas: Default::default(),
             interned_patterns: Default::default(),
             lsp_mode: false,
             location_indices: LocationIndices::default(),
@@ -2206,11 +2206,11 @@
         &mut self,
         typ: UnresolvedTypeData,
     ) -> InternedUnresolvedTypeData {
         InternedUnresolvedTypeData(self.interned_unresolved_type_datas.insert(typ))
     }
 
     pub fn get_unresolved_type_data(&self, id: InternedUnresolvedTypeData) -> &UnresolvedTypeData {
         &self.interned_unresolved_type_datas[id.0]
     }
 
     /// Returns the type of an operator (which is always a function), along with its return type.
@@ -2326,6 +2326,12 @@
     ) -> &std::collections::HashMap<ModuleId, std::collections::HashMap<Ident, UnusedItem>> {
         self.usage_tracker.unused_items()
     }
+
+    pub fn oracle_functions(&self) -> impl Iterator<Item = (&FuncId, &String)> {
+        self.function_modifiers.iter().filter_map(|(func_id, modifiers)| {
+            Some((func_id, modifiers.attributes.function.as_ref()?.oracle()?))
+        })
+    }
 }
 
 impl Methods {

tooling/noirc_abi/src/arbitrary.rs

@@ -82,7 +82,7 @@
 
 fn arb_primitive_abi_type() -> SBoxedStrategy<AbiType> {
     const MAX_STRING_LEN: u32 = 1000;
     proptest::prop_oneof![
         Just(AbiType::Field),
         Just(AbiType::Boolean),
         any::<(Sign, u32)>().prop_map(|(sign, width)| {
@@ -103,7 +103,7 @@
         256, // Shoot for maximum size of 256 nodes
         10,  // We put up to 10 items per collection
         |inner| {
             prop_oneof![
                 (1..10u32, inner.clone())
                     .prop_map(|(length, typ)| { AbiType::Array { length, typ: Box::new(typ) } })
                     .boxed(),
@@ -121,6 +121,10 @@
     .boxed()
 }
 
+pub(super) fn optional_arb_abi_type() -> BoxedStrategy<Option<AbiType>> {
+    prop_oneof![Just(None), arb_abi_type().prop_map(Some)].boxed()
+}
+
 fn arb_abi_param_and_value() -> BoxedStrategy<(AbiParameter, InputValue)> {
     arb_abi_type()
         .prop_flat_map(|typ| {
@@ -147,6 +151,6 @@
             let parameters  = vecmap(&parameters_with_values, |(param, _)| param.clone());
             let input_map = btree_map(parameters_with_values, |(param, value)| (param.name, value));
 
-            (Abi { parameters, return_type, error_types: BTreeMap::default() }, input_map)
+            (Abi { parameters, return_type, error_types: BTreeMap::default(), oracles: Vec::default() }, input_map)
     }
 }

tooling/noirc_abi/src/input_parser/mod.rs

@@ -268,6 +268,7 @@ mod serialization_tests {
                 visibility: AbiVisibility::Public,
             }),
             error_types: Default::default(),
+            oracles: vec![],
         };
 
         let input_map: BTreeMap<String, InputValue> = BTreeMap::from([

tooling/noirc_abi/src/lib.rs

@@ -171,6 +171,23 @@ pub struct AbiReturnType {
     pub visibility: AbiVisibility,
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(arbitrary::Arbitrary))]
+pub struct OracleParameter {
+    pub name: String,
+    #[cfg_attr(test, proptest(strategy = "arbitrary::arb_abi_type()"))]
+    pub typ: AbiType,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(test, derive(arbitrary::Arbitrary))]
+pub struct Oracle {
+    pub name: String,
+    pub parameters: Vec<OracleParameter>,
+    #[cfg_attr(test, proptest(strategy = "arbitrary::optional_arb_abi_type()"))]
+    pub return_type: Option<AbiType>,
+}
+
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]
 #[cfg_attr(test, derive(arbitrary::Arbitrary))]
 pub struct Abi {
@@ -179,6 +196,7 @@ pub struct Abi {
     pub return_type: Option<AbiReturnType>,
     #[cfg_attr(test, proptest(strategy = "proptest::prelude::Just(BTreeMap::from([]))"))]
     pub error_types: BTreeMap<ErrorSelector, AbiErrorType>,
+    pub oracles: Vec<Oracle>,
 }
 
 impl Abi {