diff --git a/.noir-sync-commit b/.noir-sync-commit
index 5af87f396ac..af17e410445 100644
--- a/.noir-sync-commit
+++ b/.noir-sync-commit
@@ -1 +1 @@
-90b636e71333cfe46c5e3062ded34b583fcb64d5
+951e821a585fe7e0697291cadd4d3c3aa49fd8e4
diff --git a/noir/noir-repo/.github/workflows/test-js-packages.yml b/noir/noir-repo/.github/workflows/test-js-packages.yml
index 9f46e6f98e8..06436af8d27 100644
--- a/noir/noir-repo/.github/workflows/test-js-packages.yml
+++ b/noir/noir-repo/.github/workflows/test-js-packages.yml
@@ -509,6 +509,59 @@ jobs:
         working-directory: ./examples/codegen_verifier
         run: ./test.sh
 
+  external-repo-checks:
+    needs: [build-nargo]
+    runs-on: ubuntu-22.04
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        project:
+         - { repo: AztecProtocol/aztec-nr, path: ./ }
+         - { repo: AztecProtocol/aztec-packages, path: ./noir-projects/noir-contracts }
+         # Disabled as aztec-packages requires a setup-step in order to generate a `Nargo.toml`
+         #- { repo: AztecProtocol/aztec-packages, path: ./noir-projects/noir-protocol-circuits }
+         - { repo: zac-williamson/noir-edwards, path: ./, ref: 0016ce82cd58b6ebb0c43c271725590bcff4e755  }
+        # TODO: Enable these once they're passing against master again.
+        #  - { repo: zac-williamson/noir-bignum, path: ./, ref: 030c2acce1e6b97c44a3bbbf3429ed96f20d72d3  }
+        #  - { repo: vlayer-xyz/monorepo, path: ./, ref: ee46af88c025863872234eb05d890e1e447907cb }
+        #  - { repo: hashcloak/noir-bigint, path: ./, ref: 940ddba3a5201b508e7b37a2ef643551afcf5ed8 }
+
+    name: Check external repo - ${{ matrix.project.repo }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ matrix.project.repo }}
+          path: test-repo
+          ref: ${{ matrix.project.ref }}
+      
+      - name: Download nargo binary
+        uses: actions/download-artifact@v4
+        with:
+          name: nargo
+          path: ./nargo
+            
+      - name: Set nargo on PATH
+        run: |
+          nargo_binary="${{ github.workspace }}/nargo/nargo"
+          chmod +x $nargo_binary
+          echo "$(dirname $nargo_binary)" >> $GITHUB_PATH
+          export PATH="$PATH:$(dirname $nargo_binary)"
+          nargo -V
+      
+      - name: Remove requirements on compiler version
+        working-directory: ./test-repo
+        run: |
+          # Github actions seems to not expand "**" in globs by default.
+          shopt -s globstar
+          sed -i '/^compiler_version/d' ./**/Nargo.toml
+
+      - name: Run nargo check
+        working-directory: ./test-repo/${{ matrix.project.path }}
+        run: nargo check
+
   # This is a job which depends on all test jobs and reports the overall status.
   # This allows us to add/remove test jobs without having to update the required workflows.
   tests-end:
diff --git a/noir/noir-repo/Cargo.lock b/noir/noir-repo/Cargo.lock
index 1df84a80bc7..5d487f4f23f 100644
--- a/noir/noir-repo/Cargo.lock
+++ b/noir/noir-repo/Cargo.lock
@@ -2594,6 +2594,7 @@ dependencies = [
  "dirs",
  "fm",
  "nargo",
+ "noirc_driver",
  "noirc_frontend",
  "semver",
  "serde",
diff --git a/noir/noir-repo/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs b/noir/noir-repo/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
index 6478f0c7a19..6a301ec5115 100644
--- a/noir/noir-repo/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
+++ b/noir/noir-repo/acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs
@@ -277,7 +277,8 @@ impl<F: Copy> BlackBoxFuncCall<F> {
             | BlackBoxFuncCall::BigIntDiv { .. }
             | BlackBoxFuncCall::BigIntToLeBytes { .. } => Vec::new(),
             BlackBoxFuncCall::MultiScalarMul { points, scalars, .. } => {
-                let mut inputs: Vec<FunctionInput<F>> = Vec::with_capacity(points.len() * 2);
+                let mut inputs: Vec<FunctionInput<F>> =
+                    Vec::with_capacity(points.len() + scalars.len());
                 inputs.extend(points.iter().copied());
                 inputs.extend(scalars.iter().copied());
                 inputs
diff --git a/noir/noir-repo/compiler/integration-tests/package.json b/noir/noir-repo/compiler/integration-tests/package.json
index 0638fffe547..a88e55b2321 100644
--- a/noir/noir-repo/compiler/integration-tests/package.json
+++ b/noir/noir-repo/compiler/integration-tests/package.json
@@ -25,7 +25,7 @@
         "eslint": "^8.57.0",
         "eslint-plugin-prettier": "^5.1.3",
         "ethers": "^6.7.1",
-        "hardhat": "^2.17.4",
+        "hardhat": "^2.22.6",
         "prettier": "3.2.5",
         "smol-toml": "^1.1.2",
         "toml": "^3.0.0",
diff --git a/noir/noir-repo/compiler/noirc_driver/src/lib.rs b/noir/noir-repo/compiler/noirc_driver/src/lib.rs
index 2b0769e30d4..3ec8c102aec 100644
--- a/noir/noir-repo/compiler/noirc_driver/src/lib.rs
+++ b/noir/noir-repo/compiler/noirc_driver/src/lib.rs
@@ -52,9 +52,9 @@ pub const NOIR_ARTIFACT_VERSION_STRING: &str =
 
 #[derive(Args, Clone, Debug, Default)]
 pub struct CompileOptions {
-    /// Override the expression width requested by the backend.
-    #[arg(long, value_parser = parse_expression_width, default_value = "4")]
-    pub expression_width: ExpressionWidth,
+    /// Specify the backend expression width that should be targeted
+    #[arg(long, value_parser = parse_expression_width)]
+    pub expression_width: Option<ExpressionWidth>,
 
     /// Force a full recompilation.
     #[arg(long = "force")]
@@ -113,7 +113,7 @@ pub struct CompileOptions {
     pub show_artifact_paths: bool,
 }
 
-fn parse_expression_width(input: &str) -> Result<ExpressionWidth, std::io::Error> {
+pub fn parse_expression_width(input: &str) -> Result<ExpressionWidth, std::io::Error> {
     use std::io::{Error, ErrorKind};
     let width = input
         .parse::<usize>()
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa.rs
index 820374df9c1..81327cec013 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa.rs
@@ -190,12 +190,19 @@ pub fn create_program(
     let recursive = program.recursive;
     let ArtifactsAndWarnings((generated_acirs, generated_brillig, error_types), ssa_level_warnings) =
         optimize_into_acir(program, options)?;
-    assert_eq!(
-        generated_acirs.len(),
-        func_sigs.len(),
-        "The generated ACIRs should match the supplied function signatures"
-    );
-
+    if options.force_brillig_output {
+        assert_eq!(
+            generated_acirs.len(),
+            1,
+            "Only the main ACIR is expected when forcing Brillig output"
+        );
+    } else {
+        assert_eq!(
+            generated_acirs.len(),
+            func_sigs.len(),
+            "The generated ACIRs should match the supplied function signatures"
+        );
+    }
     let mut program_artifact = SsaProgramArtifact::new(generated_brillig, error_types);
 
     // Add warnings collected at the Ssa stage
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
index c7ce3aaa155..afa635ac171 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs
@@ -752,27 +752,24 @@ impl<'f> Context<'f> {
                         Instruction::Call { func, arguments }
                     }
                     Value::Intrinsic(Intrinsic::BlackBox(BlackBoxFunc::MultiScalarMul)) => {
-                        let mut array_with_predicate = im::Vector::new();
-                        let array_typ;
-                        if let Value::Array { array, typ } =
-                            &self.inserter.function.dfg[arguments[0]]
-                        {
-                            array_typ = typ.clone();
-                            for (i, value) in array.clone().iter().enumerate() {
-                                if i % 3 == 2 {
-                                    array_with_predicate.push_back(self.var_or_one(
-                                        *value,
-                                        condition,
-                                        call_stack.clone(),
-                                    ));
-                                } else {
-                                    array_with_predicate.push_back(*value);
-                                }
-                            }
+                        let points_array_idx = if matches!(
+                            self.inserter.function.dfg[arguments[0]],
+                            Value::Array { .. }
+                        ) {
+                            0
                         } else {
-                            unreachable!();
-                        }
-                        arguments[0] =
+                            // if the first argument is not an array, we assume it is a slice
+                            // which means the array is the second argument
+                            1
+                        };
+                        let (array_with_predicate, array_typ) = self
+                            .apply_predicate_to_msm_argument(
+                                arguments[points_array_idx],
+                                condition,
+                                call_stack.clone(),
+                            );
+
+                        arguments[points_array_idx] =
                             self.inserter.function.dfg.make_array(array_with_predicate, array_typ);
                         Instruction::Call { func, arguments }
                     }
@@ -785,6 +782,40 @@ impl<'f> Context<'f> {
         }
     }
 
+    /// When a MSM is done under a predicate, we need to apply the predicate
+    /// to the is_infinity property of the input points in order to ensure
+    /// that the points will be on the curve no matter what.
+    fn apply_predicate_to_msm_argument(
+        &mut self,
+        argument: ValueId,
+        predicate: ValueId,
+        call_stack: CallStack,
+    ) -> (im::Vector<ValueId>, Type) {
+        let array_typ;
+        let mut array_with_predicate = im::Vector::new();
+        if let Value::Array { array, typ } = &self.inserter.function.dfg[argument] {
+            array_typ = typ.clone();
+            for (i, value) in array.clone().iter().enumerate() {
+                if i % 3 == 2 {
+                    array_with_predicate.push_back(self.var_or_one(
+                        *value,
+                        predicate,
+                        call_stack.clone(),
+                    ));
+                } else {
+                    array_with_predicate.push_back(*value);
+                }
+            }
+        } else {
+            unreachable!(
+                "Expected an array, got {}",
+                &self.inserter.function.dfg.type_of_value(argument)
+            );
+        };
+
+        (array_with_predicate, array_typ)
+    }
+
     // Computes: if condition { var } else { 1 }
     fn var_or_one(&mut self, var: ValueId, condition: ValueId, call_stack: CallStack) -> ValueId {
         let field = self.insert_instruction(
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
index e013546f14a..8e55debec1d 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ssa_gen/context.rs
@@ -5,7 +5,7 @@ use acvm::{acir::AcirField, FieldElement};
 use iter_extended::vecmap;
 use noirc_errors::Location;
 use noirc_frontend::ast::{BinaryOpKind, Signedness};
-use noirc_frontend::monomorphization::ast::{self, LocalId, Parameters};
+use noirc_frontend::monomorphization::ast::{self, InlineType, LocalId, Parameters};
 use noirc_frontend::monomorphization::ast::{FuncId, Program};
 
 use crate::errors::RuntimeError;
@@ -121,9 +121,14 @@ impl<'a> FunctionContext<'a> {
     ///
     /// Note that the previous function cannot be resumed after calling this. Developers should
     /// avoid calling new_function until the previous function is completely finished with ssa-gen.
-    pub(super) fn new_function(&mut self, id: IrFunctionId, func: &ast::Function) {
+    pub(super) fn new_function(
+        &mut self,
+        id: IrFunctionId,
+        func: &ast::Function,
+        force_brillig_runtime: bool,
+    ) {
         self.definitions.clear();
-        if func.unconstrained {
+        if func.unconstrained || (force_brillig_runtime && func.inline_type != InlineType::Inline) {
             self.builder.new_brillig_function(func.name.clone(), id);
         } else {
             self.builder.new_function(func.name.clone(), id, func.inline_type);
diff --git a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
index afe44881830..abd251b008f 100644
--- a/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
+++ b/noir/noir-repo/compiler/noirc_evaluator/src/ssa/ssa_gen/mod.rs
@@ -111,7 +111,7 @@ pub(crate) fn generate_ssa(
     // to generate SSA for each function used within the program.
     while let Some((src_function_id, dest_id)) = context.pop_next_function_in_queue() {
         let function = &context.program[src_function_id];
-        function_context.new_function(dest_id, function);
+        function_context.new_function(dest_id, function, force_brillig_runtime);
         function_context.codegen_function_body(&function.body)?;
     }
 
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/ast/statement.rs b/noir/noir-repo/compiler/noirc_frontend/src/ast/statement.rs
index 3e6a140ff93..6b148cd5428 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/ast/statement.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/ast/statement.rs
@@ -299,6 +299,7 @@ pub enum PathKind {
     Crate,
     Dep,
     Plain,
+    Super,
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -748,6 +749,7 @@ impl Display for PathKind {
         match self {
             PathKind::Crate => write!(f, "crate"),
             PathKind::Dep => write!(f, "dep"),
+            PathKind::Super => write!(f, "super"),
             PathKind::Plain => write!(f, "plain"),
         }
     }
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/ast/traits.rs b/noir/noir-repo/compiler/noirc_frontend/src/ast/traits.rs
index b1b14e3f657..064ea8ba9d9 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/ast/traits.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/ast/traits.rs
@@ -7,6 +7,7 @@ use crate::ast::{
     BlockExpression, Expression, FunctionReturnType, Ident, NoirFunction, Path, UnresolvedGenerics,
     UnresolvedType,
 };
+use crate::macros_api::SecondaryAttribute;
 use crate::node_interner::TraitId;
 
 /// AST node for trait definitions:
@@ -18,6 +19,7 @@ pub struct NoirTrait {
     pub where_clause: Vec<UnresolvedTraitConstraint>,
     pub span: Span,
     pub items: Vec<TraitItem>,
+    pub attributes: Vec<SecondaryAttribute>,
 }
 
 /// Any declaration inside the body of a trait that a user is required to
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/elaborator/expressions.rs b/noir/noir-repo/compiler/noirc_frontend/src/elaborator/expressions.rs
index e8098723692..72e2beea570 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/elaborator/expressions.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/elaborator/expressions.rs
@@ -320,6 +320,7 @@ impl<'context> Elaborator<'context> {
         let (mut object, mut object_type) = self.elaborate_expression(method_call.object);
         object_type = object_type.follow_bindings();
 
+        let method_name_span = method_call.method_name.span();
         let method_name = method_call.method_name.0.contents.as_str();
         match self.lookup_method(&object_type, method_name, span) {
             Some(method_ref) => {
@@ -385,6 +386,9 @@ impl<'context> Elaborator<'context> {
 
                 self.interner.push_expr_type(function_id, func_type.clone());
 
+                self.interner
+                    .add_function_reference(func_id, Location::new(method_name_span, self.file));
+
                 // Type check the new call now that it has been changed from a method call
                 // to a function call. This way we avoid duplicating code.
                 let typ = self.type_check_call(&function_call, func_type, function_args, span);
@@ -399,7 +403,8 @@ impl<'context> Elaborator<'context> {
         constructor: ConstructorExpression,
     ) -> (HirExpression, Type) {
         let span = constructor.type_name.span();
-        let is_self_type = constructor.type_name.last_segment().is_self_type_name();
+        let last_segment = constructor.type_name.last_segment();
+        let is_self_type = last_segment.is_self_type_name();
 
         let (r#type, struct_generics) = if let Some(struct_id) = constructor.struct_type {
             let typ = self.interner.get_struct(struct_id);
@@ -430,7 +435,7 @@ impl<'context> Elaborator<'context> {
         });
 
         let struct_id = struct_type.borrow().id;
-        let reference_location = Location::new(span, self.file);
+        let reference_location = Location::new(last_segment.span(), self.file);
         self.interner.add_struct_reference(struct_id, reference_location, is_self_type);
 
         (expr, Type::Struct(struct_type, generics))
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/elaborator/mod.rs b/noir/noir-repo/compiler/noirc_frontend/src/elaborator/mod.rs
index 7fa05c9612e..b0fd8f79557 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/elaborator/mod.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/elaborator/mod.rs
@@ -26,6 +26,7 @@ use crate::{
         traits::TraitConstraint,
         types::{Generics, Kind, ResolvedGeneric},
     },
+    lexer::Lexer,
     macros_api::{
         BlockExpression, Ident, NodeInterner, NoirFunction, NoirStruct, Pattern,
         SecondaryAttribute, StructId,
@@ -35,6 +36,7 @@ use crate::{
         TypeAliasId,
     },
     parser::TopLevelStatement,
+    token::Tokens,
     Shared, Type, TypeBindings, TypeVariable,
 };
 use crate::{
@@ -250,11 +252,11 @@ impl<'context> Elaborator<'context> {
         }
 
         // Must resolve structs before we resolve globals.
-        let generated_items = self.collect_struct_definitions(items.types);
+        let mut generated_items = self.collect_struct_definitions(items.types);
 
         self.define_function_metas(&mut items.functions, &mut items.impls, &mut items.trait_impls);
 
-        self.collect_traits(items.traits);
+        self.collect_traits(items.traits, &mut generated_items);
 
         // Before we resolve any function symbols we must go through our impls and
         // re-collect the methods within into their proper module. This cannot be
@@ -276,6 +278,10 @@ impl<'context> Elaborator<'context> {
             self.elaborate_global(global);
         }
 
+        // We have to run any comptime attributes on functions before the function is elaborated
+        // since the generated items are checked beforehand as well.
+        self.run_attributes_on_functions(&items.functions, &mut generated_items);
+
         // After everything is collected, we can elaborate our generated items.
         // It may be better to inline these within `items` entirely since elaborating them
         // all here means any globals will not see these. Inlining them completely within `items`
@@ -718,6 +724,12 @@ impl<'context> Elaborator<'context> {
         let statements = std::mem::take(&mut func.def.body.statements);
         let body = BlockExpression { statements };
 
+        let struct_id = if let Some(Type::Struct(struct_type, _)) = &self.self_type {
+            Some(struct_type.borrow().id)
+        } else {
+            None
+        };
+
         let meta = FuncMeta {
             name: name_ident,
             kind: func.kind,
@@ -725,6 +737,7 @@ impl<'context> Elaborator<'context> {
             typ,
             direct_generics,
             all_generics: self.generics.clone(),
+            struct_id,
             trait_impl: self.current_trait_impl,
             parameters: parameters.into(),
             parameter_idents,
@@ -1230,10 +1243,11 @@ impl<'context> Elaborator<'context> {
 
             for field_index in 0..fields_len {
                 self.interner
-                    .add_definition_location(ReferenceId::StructMember(type_id, field_index));
+                    .add_definition_location(ReferenceId::StructMember(type_id, field_index), None);
             }
 
-            self.run_comptime_attributes_on_struct(attributes, type_id, span, &mut generated_items);
+            let item = Value::StructDefinition(type_id);
+            self.run_comptime_attributes_on_item(&attributes, item, span, &mut generated_items);
         }
 
         // Check whether the struct fields have nested slices
@@ -1259,17 +1273,17 @@ impl<'context> Elaborator<'context> {
         generated_items
     }
 
-    fn run_comptime_attributes_on_struct(
+    fn run_comptime_attributes_on_item(
         &mut self,
-        attributes: Vec<SecondaryAttribute>,
-        struct_id: StructId,
+        attributes: &[SecondaryAttribute],
+        item: Value,
         span: Span,
         generated_items: &mut CollectedItems,
     ) {
         for attribute in attributes {
             if let SecondaryAttribute::Custom(name) = attribute {
                 if let Err(error) =
-                    self.run_comptime_attribute_on_struct(name, struct_id, span, generated_items)
+                    self.run_comptime_attribute_on_item(name, item.clone(), span, generated_items)
                 {
                     self.errors.push(error);
                 }
@@ -1277,25 +1291,31 @@ impl<'context> Elaborator<'context> {
         }
     }
 
-    fn run_comptime_attribute_on_struct(
+    fn run_comptime_attribute_on_item(
         &mut self,
-        attribute: String,
-        struct_id: StructId,
+        attribute: &str,
+        item: Value,
         span: Span,
         generated_items: &mut CollectedItems,
     ) -> Result<(), (CompilationError, FileId)> {
+        let location = Location::new(span, self.file);
+        let (function_name, mut arguments) = Self::parse_attribute(attribute, location)
+            .unwrap_or_else(|| (attribute.to_string(), Vec::new()));
+
         let id = self
-            .lookup_global(Path::from_single(attribute, span))
+            .lookup_global(Path::from_single(function_name, span))
             .map_err(|_| (ResolverError::UnknownAnnotation { span }.into(), self.file))?;
 
         let definition = self.interner.definition(id);
         let DefinitionKind::Function(function) = definition.kind else {
             return Err((ResolverError::NonFunctionInAnnotation { span }.into(), self.file));
         };
-        let location = Location::new(span, self.file);
+
+        self.handle_varargs_attribute(function, &mut arguments, location);
+        arguments.insert(0, (item, location));
+
         let mut interpreter_errors = vec![];
         let mut interpreter = self.setup_interpreter(&mut interpreter_errors);
-        let arguments = vec![(Value::StructDefinition(struct_id), location)];
 
         let value = interpreter
             .call_function(function, arguments, TypeBindings::new(), location)
@@ -1313,6 +1333,59 @@ impl<'context> Elaborator<'context> {
         Ok(())
     }
 
+    /// Parses an attribute in the form of a function call (e.g. `#[foo(a b, c d)]`) into
+    /// the function and quoted arguments called (e.g. `("foo", vec![(a b, location), (c d, location)])`)
+    fn parse_attribute(
+        annotation: &str,
+        location: Location,
+    ) -> Option<(String, Vec<(Value, Location)>)> {
+        let (tokens, errors) = Lexer::lex(annotation);
+        if !errors.is_empty() {
+            return None;
+        }
+
+        let mut tokens = tokens.0;
+        if tokens.len() >= 4 {
+            // Remove the outer  `ident ( )` wrapping the function arguments
+            let first = tokens.remove(0).into_token();
+            let second = tokens.remove(0).into_token();
+
+            // Last token is always an EndOfInput
+            let _ = tokens.pop().unwrap().into_token();
+            let last = tokens.pop().unwrap().into_token();
+
+            use crate::lexer::token::Token::*;
+            if let (Ident(name), LeftParen, RightParen) = (first, second, last) {
+                let args = tokens.split(|token| *token.token() == Comma);
+                let args =
+                    vecmap(args, |arg| (Value::Code(Rc::new(Tokens(arg.to_vec()))), location));
+                return Some((name, args));
+            }
+        }
+
+        None
+    }
+
+    /// Checks if the given attribute function is a varargs function.
+    /// If so, we should pass its arguments in one slice rather than as separate arguments.
+    fn handle_varargs_attribute(
+        &mut self,
+        function: FuncId,
+        arguments: &mut Vec<(Value, Location)>,
+        location: Location,
+    ) {
+        let meta = self.interner.function_meta(&function);
+        let parameters = &meta.parameters.0;
+
+        // If the last parameter is a slice, this is a varargs function.
+        if parameters.last().map_or(false, |(_, typ, _)| matches!(typ, Type::Slice(_))) {
+            let typ = Type::Slice(Box::new(Type::Quoted(crate::QuotedType::Quoted)));
+            let slice_elements = arguments.drain(..).map(|(value, _)| value);
+            let slice = Value::Slice(slice_elements.collect(), typ);
+            arguments.push((slice, location));
+        }
+    }
+
     pub fn resolve_struct_fields(
         &mut self,
         unresolved: NoirStruct,
@@ -1365,7 +1438,8 @@ impl<'context> Elaborator<'context> {
             self.elaborate_comptime_global(global_id);
         }
 
-        self.interner.add_definition_location(ReferenceId::Global(global_id));
+        self.interner
+            .add_definition_location(ReferenceId::Global(global_id), Some(self.module_id()));
 
         self.local_module = old_module;
         self.file = old_file;
@@ -1672,4 +1746,23 @@ impl<'context> Elaborator<'context> {
             ));
         }
     }
+
+    fn run_attributes_on_functions(
+        &mut self,
+        function_sets: &[UnresolvedFunctions],
+        generated_items: &mut CollectedItems,
+    ) {
+        for function_set in function_sets {
+            self.file = function_set.file_id;
+            self.self_type = function_set.self_type.clone();
+
+            for (local_module, function_id, function) in &function_set.functions {
+                self.local_module = *local_module;
+                let attributes = function.secondary_attributes();
+                let item = Value::FunctionDefinition(*function_id);
+                let span = function.span();
+                self.run_comptime_attributes_on_item(attributes, item, span, generated_items);
+            }
+        }
+    }
 }
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/elaborator/scope.rs b/noir/noir-repo/compiler/noirc_frontend/src/elaborator/scope.rs
index af6fc0e5d5e..e01c7e997d4 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/elaborator/scope.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/elaborator/scope.rs
@@ -6,7 +6,6 @@ use crate::hir::resolution::path_resolver::{PathResolver, StandardPathResolver};
 use crate::hir::resolution::resolver::SELF_TYPE_NAME;
 use crate::hir::scope::{Scope as GenericScope, ScopeTree as GenericScopeTree};
 use crate::macros_api::Ident;
-use crate::node_interner::ReferenceId;
 use crate::{
     hir::{
         def_map::{ModuleDefId, TryFromModuleDefId},
@@ -48,17 +47,30 @@ impl<'context> Elaborator<'context> {
         let path_resolution;
 
         if self.interner.track_references {
-            let mut references: Vec<ReferenceId> = Vec::new();
+            let last_segment = path.last_segment();
+            let location = Location::new(last_segment.span(), self.file);
+            let is_self_type_name = last_segment.is_self_type_name();
+
+            let mut references: Vec<_> = Vec::new();
             path_resolution =
                 resolver.resolve(self.def_maps, path.clone(), &mut Some(&mut references))?;
 
             for (referenced, ident) in references.iter().zip(path.segments) {
+                let Some(referenced) = referenced else {
+                    continue;
+                };
                 self.interner.add_reference(
                     *referenced,
                     Location::new(ident.span(), self.file),
                     ident.is_self_type_name(),
                 );
             }
+
+            self.interner.add_module_def_id_reference(
+                path_resolution.module_def_id,
+                location,
+                is_self_type_name,
+            );
         } else {
             path_resolution = resolver.resolve(self.def_maps, path, &mut None)?;
         }
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/elaborator/traits.rs b/noir/noir-repo/compiler/noirc_frontend/src/elaborator/traits.rs
index 4cd20820c56..0627121f836 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/elaborator/traits.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/elaborator/traits.rs
@@ -7,7 +7,7 @@ use crate::{
     ast::{
         FunctionKind, TraitItem, UnresolvedGeneric, UnresolvedGenerics, UnresolvedTraitConstraint,
     },
-    hir::def_collector::dc_crate::UnresolvedTrait,
+    hir::def_collector::dc_crate::{CollectedItems, UnresolvedTrait},
     hir_def::traits::{TraitConstant, TraitFunction, TraitType},
     macros_api::{
         BlockExpression, FunctionDefinition, FunctionReturnType, Ident, ItemVisibility,
@@ -21,7 +21,11 @@ use crate::{
 use super::Elaborator;
 
 impl<'context> Elaborator<'context> {
-    pub fn collect_traits(&mut self, traits: BTreeMap<TraitId, UnresolvedTrait>) {
+    pub fn collect_traits(
+        &mut self,
+        traits: BTreeMap<TraitId, UnresolvedTrait>,
+        generated_items: &mut CollectedItems,
+    ) {
         for (trait_id, unresolved_trait) in traits {
             self.recover_generics(|this| {
                 let resolved_generics = this.interner.get_trait(trait_id).generics.clone();
@@ -41,6 +45,11 @@ impl<'context> Elaborator<'context> {
                 this.interner.update_trait(trait_id, |trait_def| {
                     trait_def.set_methods(methods);
                 });
+
+                let attributes = &unresolved_trait.trait_def.attributes;
+                let item = crate::hir::comptime::Value::TraitDefinition(trait_id);
+                let span = unresolved_trait.trait_def.span;
+                this.run_comptime_attributes_on_item(attributes, item, span, generated_items);
             });
 
             // This check needs to be after the trait's methods are set since
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/elaborator/types.rs b/noir/noir-repo/compiler/noirc_frontend/src/elaborator/types.rs
index 9134fc851b9..35ff421ed32 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/elaborator/types.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/elaborator/types.rs
@@ -57,12 +57,16 @@ impl<'context> Elaborator<'context> {
         use crate::ast::UnresolvedTypeData::*;
 
         let span = typ.span;
-        let (is_self_type_name, is_synthetic) = if let Named(ref named_path, _, synthetic) = typ.typ
-        {
-            (named_path.last_segment().is_self_type_name(), synthetic)
-        } else {
-            (false, false)
-        };
+        let (named_path_span, is_self_type_name, is_synthetic) =
+            if let Named(ref named_path, _, synthetic) = typ.typ {
+                (
+                    Some(named_path.last_segment().span()),
+                    named_path.last_segment().is_self_type_name(),
+                    synthetic,
+                )
+            } else {
+                (None, false, false)
+            };
 
         let resolved_type = match typ.typ {
             FieldElement => Type::FieldElement,
@@ -153,7 +157,7 @@ impl<'context> Elaborator<'context> {
         };
 
         if let Some(unresolved_span) = typ.span {
-            let location = Location::new(unresolved_span, self.file);
+            let location = Location::new(named_path_span.unwrap_or(unresolved_span), self.file);
 
             match resolved_type {
                 Type::Struct(ref struct_type, _) => {
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/interpreter.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
index 02714f77605..995ab5bd86e 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/interpreter.rs
@@ -241,6 +241,8 @@ impl<'a> Interpreter<'a> {
                 Ok(())
             }
             HirPattern::Mutable(pattern, _) => {
+                // Create a mutable reference to store to
+                let argument = Value::Pointer(Shared::new(argument), true);
                 self.define_pattern(pattern, typ, argument, location)
             }
             HirPattern::Tuple(pattern_fields, _) => match (argument, typ) {
@@ -334,8 +336,19 @@ impl<'a> Interpreter<'a> {
         }
     }
 
-    /// Evaluate an expression and return the result
+    /// Evaluate an expression and return the result.
+    /// This will automatically dereference a mutable variable if used.
     pub fn evaluate(&mut self, id: ExprId) -> IResult<Value> {
+        match self.evaluate_no_dereference(id)? {
+            Value::Pointer(elem, true) => Ok(elem.borrow().clone()),
+            other => Ok(other),
+        }
+    }
+
+    /// Evaluating a mutable variable will dereference it automatically.
+    /// This function should be used when that is not desired - e.g. when
+    /// compiling a `&mut var` expression to grab the original reference.
+    fn evaluate_no_dereference(&mut self, id: ExprId) -> IResult<Value> {
         match self.interner.expression(&id) {
             HirExpression::Ident(ident, _) => self.evaluate_ident(ident, id),
             HirExpression::Literal(literal) => self.evaluate_literal(literal, id),
@@ -592,7 +605,10 @@ impl<'a> Interpreter<'a> {
     }
 
     fn evaluate_prefix(&mut self, prefix: HirPrefixExpression, id: ExprId) -> IResult<Value> {
-        let rhs = self.evaluate(prefix.rhs)?;
+        let rhs = match prefix.operator {
+            UnaryOp::MutableReference => self.evaluate_no_dereference(prefix.rhs)?,
+            _ => self.evaluate(prefix.rhs)?,
+        };
         self.evaluate_prefix_with_value(rhs, prefix.operator, id)
     }
 
@@ -634,9 +650,17 @@ impl<'a> Interpreter<'a> {
                     Err(InterpreterError::InvalidValueForUnary { value, location, operator: "not" })
                 }
             },
-            UnaryOp::MutableReference => Ok(Value::Pointer(Shared::new(rhs))),
+            UnaryOp::MutableReference => {
+                // If this is a mutable variable (auto_deref = true), turn this into an explicit
+                // mutable reference just by switching the value of `auto_deref`. Otherwise, wrap
+                // the value in a fresh reference.
+                match rhs {
+                    Value::Pointer(elem, true) => Ok(Value::Pointer(elem, false)),
+                    other => Ok(Value::Pointer(Shared::new(other), false)),
+                }
+            }
             UnaryOp::Dereference { implicitly_added: _ } => match rhs {
-                Value::Pointer(element) => Ok(element.borrow().clone()),
+                Value::Pointer(element, _) => Ok(element.borrow().clone()),
                 value => {
                     let location = self.interner.expr_location(&id);
                     Err(InterpreterError::NonPointerDereferenced { value, location })
@@ -1303,7 +1327,7 @@ impl<'a> Interpreter<'a> {
             HirLValue::Ident(ident, typ) => self.mutate(ident.id, rhs, ident.location),
             HirLValue::Dereference { lvalue, element_type: _, location } => {
                 match self.evaluate_lvalue(&lvalue)? {
-                    Value::Pointer(value) => {
+                    Value::Pointer(value, _) => {
                         *value.borrow_mut() = rhs;
                         Ok(())
                     }
@@ -1353,10 +1377,13 @@ impl<'a> Interpreter<'a> {
 
     fn evaluate_lvalue(&mut self, lvalue: &HirLValue) -> IResult<Value> {
         match lvalue {
-            HirLValue::Ident(ident, _) => self.lookup(ident),
+            HirLValue::Ident(ident, _) => match self.lookup(ident)? {
+                Value::Pointer(elem, true) => Ok(elem.borrow().clone()),
+                other => Ok(other),
+            },
             HirLValue::Dereference { lvalue, element_type: _, location } => {
                 match self.evaluate_lvalue(lvalue)? {
-                    Value::Pointer(value) => Ok(value.borrow().clone()),
+                    Value::Pointer(value, _) => Ok(value.borrow().clone()),
                     value => {
                         Err(InterpreterError::NonPointerDereferenced { value, location: *location })
                     }
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/tests.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/tests.rs
index e8e05506c94..6fdd956caf6 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/tests.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/tests.rs
@@ -77,6 +77,18 @@ fn mutating_mutable_references() {
     assert_eq!(result, Value::I64(4));
 }
 
+#[test]
+fn mutation_leaks() {
+    let program = "comptime fn main() -> pub i8 {
+        let mut x = 3;
+        let y = &mut x;
+        *y = 5;
+        x
+    }";
+    let result = interpret(program, vec!["main".into()]);
+    assert_eq!(result, Value::I8(5));
+}
+
 #[test]
 fn mutating_arrays() {
     let program = "comptime fn main() -> pub u8 {
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/value.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/value.rs
index 9e15b73324f..6f83f9bf23e 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/value.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/hir/comptime/value.rs
@@ -8,12 +8,13 @@ use noirc_errors::Location;
 
 use crate::{
     ast::{ArrayLiteral, ConstructorExpression, Ident, IntegerBitSize, Signedness},
+    hir::def_map::ModuleId,
     hir_def::expr::{HirArrayLiteral, HirConstructorExpression, HirIdent, HirLambda, ImplKind},
     macros_api::{
         Expression, ExpressionKind, HirExpression, HirLiteral, Literal, NodeInterner, Path,
         StructId,
     },
-    node_interner::{ExprId, FuncId},
+    node_interner::{ExprId, FuncId, TraitId},
     parser::{self, NoirParser, TopLevelStatement},
     token::{SpannedToken, Token, Tokens},
     QuotedType, Shared, Type, TypeBindings,
@@ -40,11 +41,14 @@ pub enum Value {
     Closure(HirLambda, Vec<Value>, Type),
     Tuple(Vec<Value>),
     Struct(HashMap<Rc<String>, Value>, Type),
-    Pointer(Shared<Value>),
+    Pointer(Shared<Value>, /* auto_deref */ bool),
     Array(Vector<Value>, Type),
     Slice(Vector<Value>, Type),
     Code(Rc<Tokens>),
     StructDefinition(StructId),
+    TraitDefinition(TraitId),
+    FunctionDefinition(FuncId),
+    ModuleDefinition(ModuleId),
 }
 
 impl Value {
@@ -75,10 +79,13 @@ impl Value {
             Value::Slice(_, typ) => return Cow::Borrowed(typ),
             Value::Code(_) => Type::Quoted(QuotedType::Quoted),
             Value::StructDefinition(_) => Type::Quoted(QuotedType::StructDefinition),
-            Value::Pointer(element) => {
+            Value::Pointer(element, _) => {
                 let element = element.borrow().get_type().into_owned();
                 Type::MutableReference(Box::new(element))
             }
+            Value::TraitDefinition(_) => Type::Quoted(QuotedType::TraitDefinition),
+            Value::FunctionDefinition(_) => Type::Quoted(QuotedType::FunctionDefinition),
+            Value::ModuleDefinition(_) => Type::Quoted(QuotedType::Module),
         })
     }
 
@@ -192,7 +199,11 @@ impl Value {
                     }
                 };
             }
-            Value::Pointer(_) | Value::StructDefinition(_) => {
+            Value::Pointer(..)
+            | Value::StructDefinition(_)
+            | Value::TraitDefinition(_)
+            | Value::FunctionDefinition(_)
+            | Value::ModuleDefinition(_) => {
                 return Err(InterpreterError::CannotInlineMacro { value: self, location })
             }
         };
@@ -298,7 +309,11 @@ impl Value {
                 HirExpression::Literal(HirLiteral::Slice(HirArrayLiteral::Standard(elements)))
             }
             Value::Code(block) => HirExpression::Unquote(unwrap_rc(block)),
-            Value::Pointer(_) | Value::StructDefinition(_) => {
+            Value::Pointer(..)
+            | Value::StructDefinition(_)
+            | Value::TraitDefinition(_)
+            | Value::FunctionDefinition(_)
+            | Value::ModuleDefinition(_) => {
                 return Err(InterpreterError::CannotInlineMacro { value: self, location })
             }
         };
@@ -385,7 +400,7 @@ impl Display for Value {
                 let fields = vecmap(fields, |(name, value)| format!("{}: {}", name, value));
                 write!(f, "{typename} {{ {} }}", fields.join(", "))
             }
-            Value::Pointer(value) => write!(f, "&mut {}", value.borrow()),
+            Value::Pointer(value, _) => write!(f, "&mut {}", value.borrow()),
             Value::Array(values, _) => {
                 let values = vecmap(values, ToString::to_string);
                 write!(f, "[{}]", values.join(", "))
@@ -402,6 +417,9 @@ impl Display for Value {
                 write!(f, " }}")
             }
             Value::StructDefinition(_) => write!(f, "(struct definition)"),
+            Value::TraitDefinition(_) => write!(f, "(trait definition)"),
+            Value::FunctionDefinition(_) => write!(f, "(function definition)"),
+            Value::ModuleDefinition(_) => write!(f, "(module)"),
         }
     }
 }
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index ba93eb87ef8..f42819dab1f 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -202,7 +202,7 @@ pub enum CompilationError {
 }
 
 impl CompilationError {
-    fn is_error(&self) -> bool {
+    pub fn is_error(&self) -> bool {
         let diagnostic = CustomDiagnostic::from(self);
         diagnostic.is_error()
     }
@@ -347,7 +347,7 @@ impl DefCollector {
         for collected_import in std::mem::take(&mut def_collector.imports) {
             let module_id = collected_import.module_id;
             let resolved_import = if context.def_interner.track_references {
-                let mut references: Vec<ReferenceId> = Vec::new();
+                let mut references: Vec<Option<ReferenceId>> = Vec::new();
                 let resolved_import = resolve_import(
                     crate_id,
                     &collected_import,
@@ -359,6 +359,9 @@ impl DefCollector {
                 let file_id = current_def_map.file_id(module_id);
 
                 for (referenced, ident) in references.iter().zip(&collected_import.path.segments) {
+                    let Some(referenced) = referenced else {
+                        continue;
+                    };
                     context.def_interner.add_reference(
                         *referenced,
                         Location::new(ident.span(), file_id),
@@ -552,27 +555,7 @@ fn add_import_reference(
     }
 
     let location = Location::new(name.span(), file_id);
-
-    match def_id {
-        crate::macros_api::ModuleDefId::ModuleId(module_id) => {
-            interner.add_module_reference(module_id, location);
-        }
-        crate::macros_api::ModuleDefId::FunctionId(func_id) => {
-            interner.add_function_reference(func_id, location);
-        }
-        crate::macros_api::ModuleDefId::TypeId(struct_id) => {
-            interner.add_struct_reference(struct_id, location, false);
-        }
-        crate::macros_api::ModuleDefId::TraitId(trait_id) => {
-            interner.add_trait_reference(trait_id, location, false);
-        }
-        crate::macros_api::ModuleDefId::TypeAliasId(type_alias_id) => {
-            interner.add_alias_reference(type_alias_id, location);
-        }
-        crate::macros_api::ModuleDefId::GlobalId(global_id) => {
-            interner.add_global_reference(global_id, location);
-        }
-    };
+    interner.add_module_def_id_reference(def_id, location, false);
 }
 
 fn inject_prelude(
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index bcd24ca8ed3..1f30b4388b6 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -14,7 +14,7 @@ use crate::ast::{
     TypeImpl,
 };
 use crate::macros_api::NodeInterner;
-use crate::node_interner::ReferenceId;
+use crate::node_interner::{ModuleAttributes, ReferenceId};
 use crate::{
     graph::CrateId,
     hir::def_collector::dc_crate::{UnresolvedStruct, UnresolvedTrait},
@@ -90,7 +90,7 @@ pub fn collect_defs(
 
     errors.extend(collector.collect_structs(context, ast.types, crate_id));
 
-    errors.extend(collector.collect_type_aliases(context, ast.type_aliases));
+    errors.extend(collector.collect_type_aliases(context, ast.type_aliases, crate_id));
 
     errors.extend(collector.collect_functions(context, ast.functions, crate_id));
 
@@ -318,7 +318,10 @@ impl<'a> ModCollector<'a> {
             // And store the TypeId -> StructType mapping somewhere it is reachable
             self.def_collector.items.types.insert(id, unresolved);
 
-            context.def_interner.add_definition_location(ReferenceId::Struct(id));
+            context.def_interner.add_definition_location(
+                ReferenceId::Struct(id),
+                Some(ModuleId { krate, local_id: self.module_id }),
+            );
         }
         definition_errors
     }
@@ -329,6 +332,7 @@ impl<'a> ModCollector<'a> {
         &mut self,
         context: &mut Context,
         type_aliases: Vec<NoirTypeAlias>,
+        krate: CrateId,
     ) -> Vec<(CompilationError, FileId)> {
         let mut errors: Vec<(CompilationError, FileId)> = vec![];
         for type_alias in type_aliases {
@@ -365,7 +369,10 @@ impl<'a> ModCollector<'a> {
 
             self.def_collector.items.type_aliases.insert(type_alias_id, unresolved);
 
-            context.def_interner.add_definition_location(ReferenceId::Alias(type_alias_id));
+            context.def_interner.add_definition_location(
+                ReferenceId::Alias(type_alias_id),
+                Some(ModuleId { krate, local_id: self.module_id }),
+            );
         }
         errors
     }
@@ -532,7 +539,10 @@ impl<'a> ModCollector<'a> {
             };
             context.def_interner.push_empty_trait(trait_id, &unresolved, resolved_generics);
 
-            context.def_interner.add_definition_location(ReferenceId::Trait(trait_id));
+            context.def_interner.add_definition_location(
+                ReferenceId::Trait(trait_id),
+                Some(ModuleId { krate, local_id: self.module_id }),
+            );
 
             self.def_collector.items.traits.insert(trait_id, unresolved);
         }
@@ -720,7 +730,14 @@ impl<'a> ModCollector<'a> {
                 return Err(err);
             }
 
-            context.def_interner.add_module_location(mod_id, mod_location);
+            context.def_interner.add_module_attributes(
+                mod_id,
+                ModuleAttributes {
+                    name: mod_name.0.contents.clone(),
+                    location: mod_location,
+                    parent: self.module_id,
+                },
+            );
         }
 
         Ok(mod_id)
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/import.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/import.rs
index 710c12a91bf..10e18248dec 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/import.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/import.rs
@@ -41,6 +41,8 @@ pub enum PathResolutionError {
     Unresolved(Ident),
     #[error("{0} is private and not visible from the current module")]
     Private(Ident),
+    #[error("There is no super module")]
+    NoSuper(Span),
 }
 
 #[derive(Debug)]
@@ -73,6 +75,9 @@ impl<'a> From<&'a PathResolutionError> for CustomDiagnostic {
                 format!("{ident} is private"),
                 ident.span(),
             ),
+            PathResolutionError::NoSuper(span) => {
+                CustomDiagnostic::simple_error(error.to_string(), String::new(), *span)
+            }
         }
     }
 }
@@ -81,7 +86,7 @@ pub fn resolve_import(
     crate_id: CrateId,
     import_directive: &ImportDirective,
     def_maps: &BTreeMap<CrateId, CrateDefMap>,
-    path_references: &mut Option<&mut Vec<ReferenceId>>,
+    path_references: &mut Option<&mut Vec<Option<ReferenceId>>>,
 ) -> Result<ResolvedImport, PathResolutionError> {
     let module_scope = import_directive.module_id;
     let NamespaceResolution {
@@ -126,7 +131,7 @@ fn resolve_path_to_ns(
     crate_id: CrateId,
     importing_crate: CrateId,
     def_maps: &BTreeMap<CrateId, CrateDefMap>,
-    path_references: &mut Option<&mut Vec<ReferenceId>>,
+    path_references: &mut Option<&mut Vec<Option<ReferenceId>>>,
 ) -> NamespaceResolutionResult {
     let import_path = &import_directive.path.segments;
     let def_map = &def_maps[&crate_id];
@@ -187,6 +192,25 @@ fn resolve_path_to_ns(
             path_references,
             importing_crate,
         ),
+
+        crate::ast::PathKind::Super => {
+            if let Some(parent_module_id) =
+                def_maps[&crate_id].modules[import_directive.module_id.0].parent
+            {
+                resolve_name_in_module(
+                    crate_id,
+                    importing_crate,
+                    import_path,
+                    parent_module_id,
+                    def_maps,
+                    path_references,
+                )
+            } else {
+                let span_start = import_directive.path.span().start();
+                let span = Span::from(span_start..span_start + 5); // 5 == "super".len()
+                Err(PathResolutionError::NoSuper(span))
+            }
+        }
     }
 }
 
@@ -196,7 +220,7 @@ fn resolve_path_from_crate_root(
 
     import_path: &[Ident],
     def_maps: &BTreeMap<CrateId, CrateDefMap>,
-    path_references: &mut Option<&mut Vec<ReferenceId>>,
+    path_references: &mut Option<&mut Vec<Option<ReferenceId>>>,
 ) -> NamespaceResolutionResult {
     resolve_name_in_module(
         crate_id,
@@ -214,7 +238,7 @@ fn resolve_name_in_module(
     import_path: &[Ident],
     starting_mod: LocalModuleId,
     def_maps: &BTreeMap<CrateId, CrateDefMap>,
-    path_references: &mut Option<&mut Vec<ReferenceId>>,
+    path_references: &mut Option<&mut Vec<Option<ReferenceId>>>,
 ) -> NamespaceResolutionResult {
     let def_map = &def_maps[&krate];
     let mut current_mod_id = ModuleId { krate, local_id: starting_mod };
@@ -247,7 +271,7 @@ fn resolve_name_in_module(
         current_mod_id = match typ {
             ModuleDefId::ModuleId(id) => {
                 if let Some(path_references) = path_references {
-                    path_references.push(ReferenceId::Module(id));
+                    path_references.push(Some(ReferenceId::Module(id)));
                 }
                 id
             }
@@ -255,14 +279,14 @@ fn resolve_name_in_module(
             // TODO: If impls are ever implemented, types can be used in a path
             ModuleDefId::TypeId(id) => {
                 if let Some(path_references) = path_references {
-                    path_references.push(ReferenceId::Struct(id));
+                    path_references.push(Some(ReferenceId::Struct(id)));
                 }
                 id.module_id()
             }
             ModuleDefId::TypeAliasId(_) => panic!("type aliases cannot be used in type namespace"),
             ModuleDefId::TraitId(id) => {
                 if let Some(path_references) = path_references {
-                    path_references.push(ReferenceId::Trait(id));
+                    path_references.push(Some(ReferenceId::Trait(id)));
                 }
                 id.0
             }
@@ -309,7 +333,7 @@ fn resolve_external_dep(
     current_def_map: &CrateDefMap,
     directive: &ImportDirective,
     def_maps: &BTreeMap<CrateId, CrateDefMap>,
-    path_references: &mut Option<&mut Vec<ReferenceId>>,
+    path_references: &mut Option<&mut Vec<Option<ReferenceId>>>,
     importing_crate: CrateId,
 ) -> NamespaceResolutionResult {
     // Use extern_prelude to get the dep
@@ -327,6 +351,11 @@ fn resolve_external_dep(
     // See `singleton_import.nr` test case for a check that such cases are handled elsewhere.
     let path_without_crate_name = &path[1..];
 
+    // Given that we skipped the first segment, record that it doesn't refer to any module or type.
+    if let Some(path_references) = path_references {
+        path_references.push(None);
+    }
+
     let path = Path {
         segments: path_without_crate_name.to_vec(),
         kind: PathKind::Plain,
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/path_resolver.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/path_resolver.rs
index c3dc76b635f..7cd44a84018 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/path_resolver.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/path_resolver.rs
@@ -9,12 +9,13 @@ use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleId};
 pub trait PathResolver {
     /// Resolve the given path returning the resolved ModuleDefId.
     /// If `path_references` is `Some`, a `ReferenceId` for each segment in `path`
-    /// will be resolved and pushed.
+    /// will be resolved and pushed (some entries will be None if they don't refer to
+    /// a module or type).
     fn resolve(
         &self,
         def_maps: &BTreeMap<CrateId, CrateDefMap>,
         path: Path,
-        path_references: &mut Option<&mut Vec<ReferenceId>>,
+        path_references: &mut Option<&mut Vec<Option<ReferenceId>>>,
     ) -> PathResolutionResult;
 
     fn local_module_id(&self) -> LocalModuleId;
@@ -38,7 +39,7 @@ impl PathResolver for StandardPathResolver {
         &self,
         def_maps: &BTreeMap<CrateId, CrateDefMap>,
         path: Path,
-        path_references: &mut Option<&mut Vec<ReferenceId>>,
+        path_references: &mut Option<&mut Vec<Option<ReferenceId>>>,
     ) -> PathResolutionResult {
         resolve_path(def_maps, self.module_id, path, path_references)
     }
@@ -58,7 +59,7 @@ pub fn resolve_path(
     def_maps: &BTreeMap<CrateId, CrateDefMap>,
     module_id: ModuleId,
     path: Path,
-    path_references: &mut Option<&mut Vec<ReferenceId>>,
+    path_references: &mut Option<&mut Vec<Option<ReferenceId>>>,
 ) -> PathResolutionResult {
     // lets package up the path into an ImportDirective and resolve it using that
     let import =
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/resolver.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/resolver.rs
index 856a769c9dd..55cb2145ba8 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/resolver.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/hir/resolution/resolver.rs
@@ -1105,6 +1105,7 @@ impl<'a> Resolver<'a> {
             location,
             typ,
             direct_generics,
+            struct_id: None,
             trait_impl: self.current_trait_impl,
             parameters: parameters.into(),
             return_type: func.def.return_type.clone(),
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir/type_check/mod.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir/type_check/mod.rs
index 1a70bade863..57125e1e2dd 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/hir/type_check/mod.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/hir/type_check/mod.rs
@@ -570,6 +570,7 @@ pub mod test {
             .into(),
             return_visibility: Visibility::Private,
             has_body: true,
+            struct_id: None,
             trait_impl: None,
             return_type: FunctionReturnType::Default(Span::default()),
             trait_constraints: Vec::new(),
@@ -696,7 +697,7 @@ pub mod test {
             &self,
             _def_maps: &BTreeMap<CrateId, CrateDefMap>,
             path: Path,
-            _path_references: &mut Option<&mut Vec<ReferenceId>>,
+            _path_references: &mut Option<&mut Vec<Option<ReferenceId>>>,
         ) -> PathResolutionResult {
             // Not here that foo::bar and hello::foo::bar would fetch the same thing
             let name = path.segments.last().unwrap();
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir_def/function.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir_def/function.rs
index fa8bb55abee..e666f996231 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/hir_def/function.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/hir_def/function.rs
@@ -6,7 +6,7 @@ use super::stmt::HirPattern;
 use super::traits::TraitConstraint;
 use crate::ast::{FunctionKind, FunctionReturnType, Visibility};
 use crate::graph::CrateId;
-use crate::macros_api::BlockExpression;
+use crate::macros_api::{BlockExpression, StructId};
 use crate::node_interner::{ExprId, NodeInterner, TraitImplId};
 use crate::{ResolvedGeneric, Type};
 
@@ -126,6 +126,9 @@ pub struct FuncMeta {
 
     pub trait_constraints: Vec<TraitConstraint>,
 
+    /// The struct this function belongs to, if any
+    pub struct_id: Option<StructId>,
+
     /// The trait impl this function belongs to, if any
     pub trait_impl: Option<TraitImplId>,
 
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/hir_def/types.rs b/noir/noir-repo/compiler/noirc_frontend/src/hir_def/types.rs
index 8183911c845..91a374a0787 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/hir_def/types.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/hir_def/types.rs
@@ -114,79 +114,6 @@ pub enum Type {
     Error,
 }
 
-impl Type {
-    /// Returns the number of field elements required to represent the type once encoded.
-    pub fn field_count(&self) -> u32 {
-        match self {
-            Type::FieldElement | Type::Integer { .. } | Type::Bool => 1,
-            Type::Array(size, typ) => {
-                let length = size
-                    .evaluate_to_u32()
-                    .expect("Cannot have variable sized arrays as a parameter to main");
-                let typ = typ.as_ref();
-                length * typ.field_count()
-            }
-            Type::Struct(def, args) => {
-                let struct_type = def.borrow();
-                let fields = struct_type.get_fields(args);
-                fields.iter().fold(0, |acc, (_, field_type)| acc + field_type.field_count())
-            }
-            Type::Alias(def, generics) => def.borrow().get_type(generics).field_count(),
-            Type::Tuple(fields) => {
-                fields.iter().fold(0, |acc, field_typ| acc + field_typ.field_count())
-            }
-            Type::String(size) => size
-                .evaluate_to_u32()
-                .expect("Cannot have variable sized strings as a parameter to main"),
-            Type::FmtString(_, _)
-            | Type::Unit
-            | Type::TypeVariable(_, _)
-            | Type::TraitAsType(..)
-            | Type::NamedGeneric(_, _, _)
-            | Type::Function(_, _, _)
-            | Type::MutableReference(_)
-            | Type::Forall(_, _)
-            | Type::Constant(_)
-            | Type::Quoted(_)
-            | Type::Slice(_)
-            | Type::Error => unreachable!("This type cannot exist as a parameter to main"),
-        }
-    }
-
-    pub(crate) fn is_nested_slice(&self) -> bool {
-        match self {
-            Type::Slice(elem) => elem.as_ref().contains_slice(),
-            Type::Array(_, elem) => elem.as_ref().contains_slice(),
-            Type::Alias(alias, generics) => alias.borrow().get_type(generics).is_nested_slice(),
-            _ => false,
-        }
-    }
-
-    pub(crate) fn contains_slice(&self) -> bool {
-        match self {
-            Type::Slice(_) => true,
-            Type::Struct(struct_typ, generics) => {
-                let fields = struct_typ.borrow().get_fields(generics);
-                for field in fields.iter() {
-                    if field.1.contains_slice() {
-                        return true;
-                    }
-                }
-                false
-            }
-            Type::Tuple(types) => {
-                for typ in types.iter() {
-                    if typ.contains_slice() {
-                        return true;
-                    }
-                }
-                false
-            }
-            _ => false,
-        }
-    }
-}
-
 /// A Kind is the type of a Type. These are used since only certain kinds of types are allowed in
 /// certain positions.
 ///
@@ -215,6 +142,9 @@ pub enum QuotedType {
     TopLevelItem,
     Type,
     StructDefinition,
+    TraitDefinition,
+    FunctionDefinition,
+    Module,
 }
 
 /// A list of TypeVariableIds to bind to a type. Storing the
@@ -594,7 +524,7 @@ impl TypeVariable {
 
 /// TypeBindings are the mutable insides of a TypeVariable.
 /// They are either bound to some type, or are unbound.
-#[derive(Clone, PartialEq, Eq, Hash)]
+#[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub enum TypeBinding {
     Bound(Type),
     Unbound(TypeVariableId),
@@ -610,6 +540,155 @@ impl TypeBinding {
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
 pub struct TypeVariableId(pub usize);
 
+impl std::fmt::Display for Type {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Type::FieldElement => {
+                write!(f, "Field")
+            }
+            Type::Array(len, typ) => {
+                write!(f, "[{typ}; {len}]")
+            }
+            Type::Slice(typ) => {
+                write!(f, "[{typ}]")
+            }
+            Type::Integer(sign, num_bits) => match sign {
+                Signedness::Signed => write!(f, "i{num_bits}"),
+                Signedness::Unsigned => write!(f, "u{num_bits}"),
+            },
+            Type::TypeVariable(var, TypeVariableKind::Normal) => write!(f, "{}", var.borrow()),
+            Type::TypeVariable(binding, TypeVariableKind::Integer) => {
+                if let TypeBinding::Unbound(_) = &*binding.borrow() {
+                    write!(f, "{}", Type::default_int_type())
+                } else {
+                    write!(f, "{}", binding.borrow())
+                }
+            }
+            Type::TypeVariable(binding, TypeVariableKind::IntegerOrField) => {
+                if let TypeBinding::Unbound(_) = &*binding.borrow() {
+                    // Show a Field by default if this TypeVariableKind::IntegerOrField is unbound, since that is
+                    // what they bind to by default anyway. It is less confusing than displaying it
+                    // as a generic.
+                    write!(f, "Field")
+                } else {
+                    write!(f, "{}", binding.borrow())
+                }
+            }
+            Type::TypeVariable(binding, TypeVariableKind::Constant(n)) => {
+                if let TypeBinding::Unbound(_) = &*binding.borrow() {
+                    // TypeVariableKind::Constant(n) binds to Type::Constant(n) by default, so just show that.
+                    write!(f, "{n}")
+                } else {
+                    write!(f, "{}", binding.borrow())
+                }
+            }
+            Type::Struct(s, args) => {
+                let args = vecmap(args, |arg| arg.to_string());
+                if args.is_empty() {
+                    write!(f, "{}", s.borrow())
+                } else {
+                    write!(f, "{}<{}>", s.borrow(), args.join(", "))
+                }
+            }
+            Type::Alias(alias, args) => {
+                let args = vecmap(args, |arg| arg.to_string());
+                if args.is_empty() {
+                    write!(f, "{}", alias.borrow())
+                } else {
+                    write!(f, "{}<{}>", alias.borrow(), args.join(", "))
+                }
+            }
+            Type::TraitAsType(_id, name, generics) => {
+                write!(f, "impl {}", name)?;
+                if !generics.is_empty() {
+                    let generics = vecmap(generics, ToString::to_string).join(", ");
+                    write!(f, "<{generics}>")?;
+                }
+                Ok(())
+            }
+            Type::Tuple(elements) => {
+                let elements = vecmap(elements, ToString::to_string);
+                write!(f, "({})", elements.join(", "))
+            }
+            Type::Bool => write!(f, "bool"),
+            Type::String(len) => write!(f, "str<{len}>"),
+            Type::FmtString(len, elements) => {
+                write!(f, "fmtstr<{len}, {elements}>")
+            }
+            Type::Unit => write!(f, "()"),
+            Type::Error => write!(f, "error"),
+            Type::NamedGeneric(binding, name, _) => match &*binding.borrow() {
+                TypeBinding::Bound(binding) => binding.fmt(f),
+                TypeBinding::Unbound(_) if name.is_empty() => write!(f, "_"),
+                TypeBinding::Unbound(_) => write!(f, "{name}"),
+            },
+            Type::Constant(x) => x.fmt(f),
+            Type::Forall(typevars, typ) => {
+                let typevars = vecmap(typevars, |var| var.id().to_string());
+                write!(f, "forall {}. {}", typevars.join(" "), typ)
+            }
+            Type::Function(args, ret, env) => {
+                let closure_env_text = match **env {
+                    Type::Unit => "".to_string(),
+                    _ => format!(" with env {env}"),
+                };
+
+                let args = vecmap(args.iter(), ToString::to_string);
+
+                write!(f, "fn({}) -> {ret}{closure_env_text}", args.join(", "))
+            }
+            Type::MutableReference(element) => {
+                write!(f, "&mut {element}")
+            }
+            Type::Quoted(quoted) => write!(f, "{}", quoted),
+        }
+    }
+}
+
+impl std::fmt::Display for BinaryTypeOperator {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            BinaryTypeOperator::Addition => write!(f, "+"),
+            BinaryTypeOperator::Subtraction => write!(f, "-"),
+            BinaryTypeOperator::Multiplication => write!(f, "*"),
+            BinaryTypeOperator::Division => write!(f, "/"),
+            BinaryTypeOperator::Modulo => write!(f, "%"),
+        }
+    }
+}
+
+impl std::fmt::Display for TypeVariableId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "_")
+    }
+}
+
+impl std::fmt::Display for TypeBinding {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TypeBinding::Bound(typ) => typ.fmt(f),
+            TypeBinding::Unbound(id) => id.fmt(f),
+        }
+    }
+}
+
+impl std::fmt::Display for QuotedType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            QuotedType::Expr => write!(f, "Expr"),
+            QuotedType::Quoted => write!(f, "Quoted"),
+            QuotedType::TopLevelItem => write!(f, "TopLevelItem"),
+            QuotedType::Type => write!(f, "Type"),
+            QuotedType::StructDefinition => write!(f, "StructDefinition"),
+            QuotedType::TraitDefinition => write!(f, "TraitDefinition"),
+            QuotedType::FunctionDefinition => write!(f, "FunctionDefinition"),
+            QuotedType::Module => write!(f, "Module"),
+        }
+    }
+}
+
+pub struct UnificationError;
+
 impl Type {
     pub fn default_int_or_field_type() -> Type {
         Type::FieldElement
@@ -1044,155 +1123,78 @@ impl Type {
     //         | Type::Error => Kind::Normal,
     //     }
     // }
-}
 
-impl std::fmt::Display for Type {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    /// Returns the number of field elements required to represent the type once encoded.
+    pub fn field_count(&self) -> u32 {
         match self {
-            Type::FieldElement => {
-                write!(f, "Field")
-            }
-            Type::Array(len, typ) => {
-                write!(f, "[{typ}; {len}]")
-            }
-            Type::Slice(typ) => {
-                write!(f, "[{typ}]")
-            }
-            Type::Integer(sign, num_bits) => match sign {
-                Signedness::Signed => write!(f, "i{num_bits}"),
-                Signedness::Unsigned => write!(f, "u{num_bits}"),
-            },
-            Type::TypeVariable(var, TypeVariableKind::Normal) => write!(f, "{}", var.borrow()),
-            Type::TypeVariable(binding, TypeVariableKind::Integer) => {
-                if let TypeBinding::Unbound(_) = &*binding.borrow() {
-                    write!(f, "{}", Type::default_int_type())
-                } else {
-                    write!(f, "{}", binding.borrow())
-                }
-            }
-            Type::TypeVariable(binding, TypeVariableKind::IntegerOrField) => {
-                if let TypeBinding::Unbound(_) = &*binding.borrow() {
-                    // Show a Field by default if this TypeVariableKind::IntegerOrField is unbound, since that is
-                    // what they bind to by default anyway. It is less confusing than displaying it
-                    // as a generic.
-                    write!(f, "Field")
-                } else {
-                    write!(f, "{}", binding.borrow())
-                }
-            }
-            Type::TypeVariable(binding, TypeVariableKind::Constant(n)) => {
-                if let TypeBinding::Unbound(_) = &*binding.borrow() {
-                    // TypeVariableKind::Constant(n) binds to Type::Constant(n) by default, so just show that.
-                    write!(f, "{n}")
-                } else {
-                    write!(f, "{}", binding.borrow())
-                }
-            }
-            Type::Struct(s, args) => {
-                let args = vecmap(args, |arg| arg.to_string());
-                if args.is_empty() {
-                    write!(f, "{}", s.borrow())
-                } else {
-                    write!(f, "{}<{}>", s.borrow(), args.join(", "))
-                }
-            }
-            Type::Alias(alias, args) => {
-                let args = vecmap(args, |arg| arg.to_string());
-                if args.is_empty() {
-                    write!(f, "{}", alias.borrow())
-                } else {
-                    write!(f, "{}<{}>", alias.borrow(), args.join(", "))
-                }
-            }
-            Type::TraitAsType(_id, name, generics) => {
-                write!(f, "impl {}", name)?;
-                if !generics.is_empty() {
-                    let generics = vecmap(generics, ToString::to_string).join(", ");
-                    write!(f, "<{generics}>")?;
-                }
-                Ok(())
-            }
-            Type::Tuple(elements) => {
-                let elements = vecmap(elements, ToString::to_string);
-                write!(f, "({})", elements.join(", "))
-            }
-            Type::Bool => write!(f, "bool"),
-            Type::String(len) => write!(f, "str<{len}>"),
-            Type::FmtString(len, elements) => {
-                write!(f, "fmtstr<{len}, {elements}>")
-            }
-            Type::Unit => write!(f, "()"),
-            Type::Error => write!(f, "error"),
-            Type::NamedGeneric(binding, name, _) => match &*binding.borrow() {
-                TypeBinding::Bound(binding) => binding.fmt(f),
-                TypeBinding::Unbound(_) if name.is_empty() => write!(f, "_"),
-                TypeBinding::Unbound(_) => write!(f, "{name}"),
-            },
-            Type::Constant(x) => x.fmt(f),
-            Type::Forall(typevars, typ) => {
-                let typevars = vecmap(typevars, |var| var.id().to_string());
-                write!(f, "forall {}. {}", typevars.join(" "), typ)
+            Type::FieldElement | Type::Integer { .. } | Type::Bool => 1,
+            Type::Array(size, typ) => {
+                let length = size
+                    .evaluate_to_u32()
+                    .expect("Cannot have variable sized arrays as a parameter to main");
+                let typ = typ.as_ref();
+                length * typ.field_count()
             }
-            Type::Function(args, ret, env) => {
-                let closure_env_text = match **env {
-                    Type::Unit => "".to_string(),
-                    _ => format!(" with env {env}"),
-                };
-
-                let args = vecmap(args.iter(), ToString::to_string);
-
-                write!(f, "fn({}) -> {ret}{closure_env_text}", args.join(", "))
+            Type::Struct(def, args) => {
+                let struct_type = def.borrow();
+                let fields = struct_type.get_fields(args);
+                fields.iter().fold(0, |acc, (_, field_type)| acc + field_type.field_count())
             }
-            Type::MutableReference(element) => {
-                write!(f, "&mut {element}")
+            Type::Alias(def, generics) => def.borrow().get_type(generics).field_count(),
+            Type::Tuple(fields) => {
+                fields.iter().fold(0, |acc, field_typ| acc + field_typ.field_count())
             }
-            Type::Quoted(quoted) => write!(f, "{}", quoted),
-        }
-    }
-}
-
-impl std::fmt::Display for BinaryTypeOperator {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            BinaryTypeOperator::Addition => write!(f, "+"),
-            BinaryTypeOperator::Subtraction => write!(f, "-"),
-            BinaryTypeOperator::Multiplication => write!(f, "*"),
-            BinaryTypeOperator::Division => write!(f, "/"),
-            BinaryTypeOperator::Modulo => write!(f, "%"),
+            Type::String(size) => size
+                .evaluate_to_u32()
+                .expect("Cannot have variable sized strings as a parameter to main"),
+            Type::FmtString(_, _)
+            | Type::Unit
+            | Type::TypeVariable(_, _)
+            | Type::TraitAsType(..)
+            | Type::NamedGeneric(_, _, _)
+            | Type::Function(_, _, _)
+            | Type::MutableReference(_)
+            | Type::Forall(_, _)
+            | Type::Constant(_)
+            | Type::Quoted(_)
+            | Type::Slice(_)
+            | Type::Error => unreachable!("This type cannot exist as a parameter to main"),
         }
     }
-}
-
-impl std::fmt::Display for TypeVariableId {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "_")
-    }
-}
 
-impl std::fmt::Display for TypeBinding {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    pub(crate) fn is_nested_slice(&self) -> bool {
         match self {
-            TypeBinding::Bound(typ) => typ.fmt(f),
-            TypeBinding::Unbound(id) => id.fmt(f),
+            Type::Slice(elem) => elem.as_ref().contains_slice(),
+            Type::Array(_, elem) => elem.as_ref().contains_slice(),
+            Type::Alias(alias, generics) => alias.borrow().get_type(generics).is_nested_slice(),
+            _ => false,
         }
     }
-}
 
-impl std::fmt::Display for QuotedType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    pub(crate) fn contains_slice(&self) -> bool {
         match self {
-            QuotedType::Expr => write!(f, "Expr"),
-            QuotedType::Quoted => write!(f, "Quoted"),
-            QuotedType::TopLevelItem => write!(f, "TopLevelItem"),
-            QuotedType::Type => write!(f, "Type"),
-            QuotedType::StructDefinition => write!(f, "StructDefinition"),
+            Type::Slice(_) => true,
+            Type::Struct(struct_typ, generics) => {
+                let fields = struct_typ.borrow().get_fields(generics);
+                for field in fields.iter() {
+                    if field.1.contains_slice() {
+                        return true;
+                    }
+                }
+                false
+            }
+            Type::Tuple(types) => {
+                for typ in types.iter() {
+                    if typ.contains_slice() {
+                        return true;
+                    }
+                }
+                false
+            }
+            _ => false,
         }
     }
-}
 
-pub struct UnificationError;
-
-impl Type {
     /// Try to bind a MaybeConstant variable to self, succeeding if self is a Constant,
     /// MaybeConstant, or type variable. If successful, the binding is placed in the
     /// given TypeBindings map rather than linked immediately.
@@ -2007,6 +2009,83 @@ impl Type {
     pub fn from_generics(generics: &GenericTypeVars) -> Vec<Type> {
         vecmap(generics, |var| Type::TypeVariable(var.clone(), TypeVariableKind::Normal))
     }
+
+    /// Replace any `Type::NamedGeneric` in this type with a `Type::TypeVariable`
+    /// using to the same inner `TypeVariable`. This is used during monomorphization
+    /// to bind to named generics since they are unbindable during type checking.
+    pub fn replace_named_generics_with_type_variables(&mut self) {
+        match self {
+            Type::FieldElement
+            | Type::Constant(_)
+            | Type::Integer(_, _)
+            | Type::Bool
+            | Type::Unit
+            | Type::Error
+            | Type::Quoted(_) => (),
+
+            Type::Array(len, elem) => {
+                len.replace_named_generics_with_type_variables();
+                elem.replace_named_generics_with_type_variables();
+            }
+
+            Type::Slice(elem) => elem.replace_named_generics_with_type_variables(),
+            Type::String(len) => len.replace_named_generics_with_type_variables(),
+            Type::FmtString(len, captures) => {
+                len.replace_named_generics_with_type_variables();
+                captures.replace_named_generics_with_type_variables();
+            }
+            Type::Tuple(fields) => {
+                for field in fields {
+                    field.replace_named_generics_with_type_variables();
+                }
+            }
+            Type::Struct(_, generics) => {
+                for generic in generics {
+                    generic.replace_named_generics_with_type_variables();
+                }
+            }
+            Type::Alias(alias, generics) => {
+                let mut typ = alias.borrow().get_type(generics);
+                typ.replace_named_generics_with_type_variables();
+                *self = typ;
+            }
+            Type::TypeVariable(var, _) => {
+                let var = var.borrow();
+                if let TypeBinding::Bound(binding) = &*var {
+                    let mut binding = binding.clone();
+                    drop(var);
+                    binding.replace_named_generics_with_type_variables();
+                    *self = binding;
+                }
+            }
+            Type::TraitAsType(_, _, generics) => {
+                for generic in generics {
+                    generic.replace_named_generics_with_type_variables();
+                }
+            }
+            Type::NamedGeneric(var, _, _) => {
+                let type_binding = var.borrow();
+                if let TypeBinding::Bound(binding) = &*type_binding {
+                    let mut binding = binding.clone();
+                    drop(type_binding);
+                    binding.replace_named_generics_with_type_variables();
+                    *self = binding;
+                } else {
+                    drop(type_binding);
+                    *self = Type::TypeVariable(var.clone(), TypeVariableKind::Normal);
+                }
+            }
+            Type::Function(args, ret, env) => {
+                for arg in args {
+                    arg.replace_named_generics_with_type_variables();
+                }
+                ret.replace_named_generics_with_type_variables();
+                env.replace_named_generics_with_type_variables();
+            }
+            Type::MutableReference(elem) => elem.replace_named_generics_with_type_variables(),
+            Type::Forall(_, typ) => typ.replace_named_generics_with_type_variables(),
+        }
+    }
 }
 
 /// Wraps a given `expression` in `expression.as_slice()`
@@ -2203,10 +2282,10 @@ impl std::fmt::Debug for Type {
             Type::Error => write!(f, "error"),
             Type::NamedGeneric(binding, name, kind) => match kind {
                 Kind::Normal => {
-                    write!(f, "{} -> {:?}", name, binding)
+                    write!(f, "{}{:?}", name, binding)
                 }
                 Kind::Numeric(typ) => {
-                    write!(f, "({} : {}) -> {:?}", name, typ, binding)
+                    write!(f, "({} : {}){:?}", name, typ, binding)
                 }
             },
             Type::Constant(x) => x.fmt(f),
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/lexer/token.rs b/noir/noir-repo/compiler/noirc_frontend/src/lexer/token.rs
index 41de13fb17e..59ae3d8fd7a 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/lexer/token.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/lexer/token.rs
@@ -895,12 +895,14 @@ pub enum Keyword {
     Fn,
     For,
     FormatString,
+    FunctionDefinition,
     Global,
     If,
     Impl,
     In,
     Let,
     Mod,
+    Module,
     Mut,
     Pub,
     Quoted,
@@ -908,12 +910,13 @@ pub enum Keyword {
     ReturnData,
     String,
     Struct,
+    StructDefinition,
     Super,
     TopLevelItem,
     Trait,
+    TraitDefinition,
     Type,
     TypeType,
-    StructDefinition,
     Unchecked,
     Unconstrained,
     Use,
@@ -943,12 +946,14 @@ impl fmt::Display for Keyword {
             Keyword::Fn => write!(f, "fn"),
             Keyword::For => write!(f, "for"),
             Keyword::FormatString => write!(f, "fmtstr"),
+            Keyword::FunctionDefinition => write!(f, "FunctionDefinition"),
             Keyword::Global => write!(f, "global"),
             Keyword::If => write!(f, "if"),
             Keyword::Impl => write!(f, "impl"),
             Keyword::In => write!(f, "in"),
             Keyword::Let => write!(f, "let"),
             Keyword::Mod => write!(f, "mod"),
+            Keyword::Module => write!(f, "Module"),
             Keyword::Mut => write!(f, "mut"),
             Keyword::Pub => write!(f, "pub"),
             Keyword::Quoted => write!(f, "Quoted"),
@@ -956,12 +961,13 @@ impl fmt::Display for Keyword {
             Keyword::ReturnData => write!(f, "return_data"),
             Keyword::String => write!(f, "str"),
             Keyword::Struct => write!(f, "struct"),
+            Keyword::StructDefinition => write!(f, "StructDefinition"),
             Keyword::Super => write!(f, "super"),
             Keyword::TopLevelItem => write!(f, "TopLevelItem"),
             Keyword::Trait => write!(f, "trait"),
+            Keyword::TraitDefinition => write!(f, "TraitDefinition"),
             Keyword::Type => write!(f, "type"),
             Keyword::TypeType => write!(f, "Type"),
-            Keyword::StructDefinition => write!(f, "StructDefinition"),
             Keyword::Unchecked => write!(f, "unchecked"),
             Keyword::Unconstrained => write!(f, "unconstrained"),
             Keyword::Use => write!(f, "use"),
@@ -994,12 +1000,14 @@ impl Keyword {
             "fn" => Keyword::Fn,
             "for" => Keyword::For,
             "fmtstr" => Keyword::FormatString,
+            "FunctionDefinition" => Keyword::FunctionDefinition,
             "global" => Keyword::Global,
             "if" => Keyword::If,
             "impl" => Keyword::Impl,
             "in" => Keyword::In,
             "let" => Keyword::Let,
             "mod" => Keyword::Mod,
+            "Module" => Keyword::Module,
             "mut" => Keyword::Mut,
             "pub" => Keyword::Pub,
             "Quoted" => Keyword::Quoted,
@@ -1010,6 +1018,7 @@ impl Keyword {
             "super" => Keyword::Super,
             "TopLevelItem" => Keyword::TopLevelItem,
             "trait" => Keyword::Trait,
+            "TraitDefinition" => Keyword::TraitDefinition,
             "type" => Keyword::Type,
             "Type" => Keyword::TypeType,
             "StructDefinition" => Keyword::StructDefinition,
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/locations.rs b/noir/noir-repo/compiler/noirc_frontend/src/locations.rs
index 5ca8c1493eb..0ba74e22781 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/locations.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/locations.rs
@@ -4,7 +4,7 @@ use rangemap::RangeMap;
 use rustc_hash::FxHashMap;
 
 use crate::{
-    hir::def_map::ModuleId,
+    hir::def_map::{ModuleDefId, ModuleId},
     macros_api::{NodeInterner, StructId},
     node_interner::{DefinitionId, FuncId, GlobalId, ReferenceId, TraitId, TypeAliasId},
 };
@@ -17,7 +17,7 @@ pub(crate) struct LocationIndices {
 
 impl LocationIndices {
     pub(crate) fn add_location(&mut self, location: Location, node_index: PetGraphIndex) {
-        // Some location spans are empty: maybe they are from ficticious nodes?
+        // Some location spans are empty: maybe they are from fictitious nodes?
         if location.span.start() == location.span.end() {
             return;
         }
@@ -35,7 +35,7 @@ impl LocationIndices {
 impl NodeInterner {
     pub fn reference_location(&self, reference: ReferenceId) -> Location {
         match reference {
-            ReferenceId::Module(id) => self.module_location(&id),
+            ReferenceId::Module(id) => self.module_attributes(&id).location,
             ReferenceId::Function(id) => self.function_modifiers(&id).name_location,
             ReferenceId::Struct(id) => {
                 let struct_type = self.get_struct(id);
@@ -62,6 +62,38 @@ impl NodeInterner {
         }
     }
 
+    pub fn reference_module(&self, reference: ReferenceId) -> Option<&ModuleId> {
+        self.reference_modules.get(&reference)
+    }
+
+    pub(crate) fn add_module_def_id_reference(
+        &mut self,
+        def_id: ModuleDefId,
+        location: Location,
+        is_self_type: bool,
+    ) {
+        match def_id {
+            ModuleDefId::ModuleId(module_id) => {
+                self.add_module_reference(module_id, location);
+            }
+            ModuleDefId::FunctionId(func_id) => {
+                self.add_function_reference(func_id, location);
+            }
+            ModuleDefId::TypeId(struct_id) => {
+                self.add_struct_reference(struct_id, location, is_self_type);
+            }
+            ModuleDefId::TraitId(trait_id) => {
+                self.add_trait_reference(trait_id, location, is_self_type);
+            }
+            ModuleDefId::TypeAliasId(type_alias_id) => {
+                self.add_alias_reference(type_alias_id, location);
+            }
+            ModuleDefId::GlobalId(global_id) => {
+                self.add_global_reference(global_id, location);
+            }
+        };
+    }
+
     pub(crate) fn add_module_reference(&mut self, id: ModuleId, location: Location) {
         self.add_reference(ReferenceId::Module(id), location, false);
     }
@@ -129,7 +161,11 @@ impl NodeInterner {
         self.location_indices.add_location(reference_location, reference_index);
     }
 
-    pub(crate) fn add_definition_location(&mut self, referenced: ReferenceId) {
+    pub(crate) fn add_definition_location(
+        &mut self,
+        referenced: ReferenceId,
+        module_id: Option<ModuleId>,
+    ) {
         if !self.track_references {
             return;
         }
@@ -137,6 +173,9 @@ impl NodeInterner {
         let referenced_index = self.get_or_insert_reference(referenced);
         let referenced_location = self.reference_location(referenced);
         self.location_indices.add_location(referenced_location, referenced_index);
+        if let Some(module_id) = module_id {
+            self.reference_modules.insert(referenced, module_id);
+        }
     }
 
     #[tracing::instrument(skip(self), ret)]
@@ -168,7 +207,7 @@ impl NodeInterner {
 
     // Starting at the given location, find the node referenced by it. Then, gather
     // all locations that reference that node, and return all of them
-    // (the references and optionally the referenced node if `include_referencedd` is true).
+    // (the references and optionally the referenced node if `include_referenced` is true).
     // If `include_self_type_name` is true, references where "Self" is written are returned,
     // otherwise they are not.
     // Returns `None` if the location is not known to this interner.
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/monomorphization/mod.rs b/noir/noir-repo/compiler/noirc_frontend/src/monomorphization/mod.rs
index be222cc4e35..a46f32e3094 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/monomorphization/mod.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/monomorphization/mod.rs
@@ -21,7 +21,7 @@ use crate::{
         types,
     },
     node_interner::{self, DefinitionKind, NodeInterner, StmtId, TraitImplKind, TraitMethodId},
-    Type, TypeBinding, TypeBindings, TypeVariable, TypeVariableKind,
+    Type, TypeBinding, TypeBindings,
 };
 use acvm::{acir::AcirField, FieldElement};
 use iter_extended::{btree_map, try_vecmap, vecmap};
@@ -1788,24 +1788,21 @@ pub fn perform_impl_bindings(
     if let Some(trait_method) = trait_method {
         let the_trait = interner.get_trait(trait_method.trait_id);
 
-        let trait_method_type = the_trait.methods[trait_method.method_index].typ.as_monotype();
+        let mut trait_method_type =
+            the_trait.methods[trait_method.method_index].typ.as_monotype().clone();
+
+        let mut impl_method_type =
+            interner.function_meta(&impl_method).typ.unwrap_forall().1.clone();
 
         // Make each NamedGeneric in this type bindable by replacing it with a TypeVariable
         // with the same internal id and binding.
-        let (generics, impl_method_type) = interner.function_meta(&impl_method).typ.unwrap_forall();
-
-        let replace_type_variable = |var: &TypeVariable| {
-            (var.id(), (var.clone(), Type::TypeVariable(var.clone(), TypeVariableKind::Normal)))
-        };
-
-        // Replace each NamedGeneric with a TypeVariable containing the same internal type variable
-        let type_bindings = generics.iter().map(replace_type_variable).collect();
-        let impl_method_type = impl_method_type.force_substitute(&type_bindings);
+        trait_method_type.replace_named_generics_with_type_variables();
+        impl_method_type.replace_named_generics_with_type_variables();
 
         trait_method_type.try_unify(&impl_method_type, &mut bindings).map_err(|_| {
             InterpreterError::ImplMethodTypeMismatch {
-                expected: trait_method_type.clone(),
-                actual: impl_method_type,
+                expected: trait_method_type.follow_bindings(),
+                actual: impl_method_type.follow_bindings(),
                 location,
             }
         })?;
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/node_interner.rs b/noir/noir-repo/compiler/noirc_frontend/src/node_interner.rs
index a009a42df53..5ed4ad85a58 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/node_interner.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/node_interner.rs
@@ -44,6 +44,13 @@ use crate::{Shared, TypeAlias, TypeBindings, TypeVariable, TypeVariableId, TypeV
 /// This is needed to stop recursing for cases such as `impl<T> Foo for T where T: Eq`
 const IMPL_SEARCH_RECURSION_LIMIT: u32 = 10;
 
+#[derive(Debug)]
+pub struct ModuleAttributes {
+    pub name: String,
+    pub location: Location,
+    pub parent: LocalModuleId,
+}
+
 type StructAttributes = Vec<SecondaryAttribute>;
 
 /// The node interner is the central storage location of all nodes in Noir's Hir (the
@@ -68,7 +75,7 @@ pub struct NodeInterner {
     function_modules: HashMap<FuncId, ModuleId>,
 
     // The location of each module
-    module_locations: HashMap<ModuleId, Location>,
+    module_attributes: HashMap<ModuleId, ModuleAttributes>,
 
     /// This graph tracks dependencies between different global definitions.
     /// This is used to ensure the absence of dependency cycles for globals and types.
@@ -219,6 +226,10 @@ pub struct NodeInterner {
 
     /// Store the location of the references in the graph
     pub(crate) location_indices: LocationIndices,
+
+    // The module where each reference is
+    // (ReferenceId::Reference and ReferenceId::Local aren't included here)
+    pub(crate) reference_modules: HashMap<ReferenceId, ModuleId>,
 }
 
 /// A dependency in the dependency graph may be a type or a definition.
@@ -553,7 +564,7 @@ impl Default for NodeInterner {
             function_definition_ids: HashMap::new(),
             function_modifiers: HashMap::new(),
             function_modules: HashMap::new(),
-            module_locations: HashMap::new(),
+            module_attributes: HashMap::new(),
             func_id_to_trait: HashMap::new(),
             dependency_graph: petgraph::graph::DiGraph::new(),
             dependency_graph_indices: HashMap::new(),
@@ -586,6 +597,7 @@ impl Default for NodeInterner {
             location_indices: LocationIndices::default(),
             reference_graph: petgraph::graph::DiGraph::new(),
             reference_graph_indices: HashMap::new(),
+            reference_modules: HashMap::new(),
         };
 
         // An empty block expression is used often, we add this into the `node` on startup
@@ -854,7 +866,7 @@ impl NodeInterner {
         self.definitions.push(DefinitionInfo { name, mutable, comptime, kind, location });
 
         if is_local {
-            self.add_definition_location(ReferenceId::Local(id));
+            self.add_definition_location(ReferenceId::Local(id), None);
         }
 
         id
@@ -892,7 +904,7 @@ impl NodeInterner {
 
         // This needs to be done after pushing the definition since it will reference the
         // location that was stored
-        self.add_definition_location(ReferenceId::Function(id));
+        self.add_definition_location(ReferenceId::Function(id), Some(module));
         definition_id
     }
 
@@ -993,12 +1005,20 @@ impl NodeInterner {
         &self.struct_attributes[struct_id]
     }
 
-    pub fn add_module_location(&mut self, module_id: ModuleId, location: Location) {
-        self.module_locations.insert(module_id, location);
+    pub fn add_module_attributes(&mut self, module_id: ModuleId, attributes: ModuleAttributes) {
+        self.module_attributes.insert(module_id, attributes);
+    }
+
+    pub fn module_attributes(&self, module_id: &ModuleId) -> &ModuleAttributes {
+        &self.module_attributes[module_id]
+    }
+
+    pub fn try_module_attributes(&self, module_id: &ModuleId) -> Option<&ModuleAttributes> {
+        self.module_attributes.get(module_id)
     }
 
-    pub fn module_location(&self, module_id: &ModuleId) -> Location {
-        self.module_locations[module_id]
+    pub fn try_module_parent(&self, module_id: &ModuleId) -> Option<LocalModuleId> {
+        self.try_module_attributes(module_id).map(|attrs| attrs.parent)
     }
 
     pub fn global_attributes(&self, global_id: &GlobalId) -> &[SecondaryAttribute] {
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/path.rs b/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/path.rs
index e40268af410..8957fb7c40b 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/path.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/path.rs
@@ -17,6 +17,7 @@ pub(super) fn path() -> impl NoirParser<Path> {
     choice((
         path_kind(Keyword::Crate, PathKind::Crate),
         path_kind(Keyword::Dep, PathKind::Dep),
+        path_kind(Keyword::Super, PathKind::Super),
         idents().map_with_span(make_path(PathKind::Plain)),
     ))
 }
@@ -64,6 +65,7 @@ mod test {
             ("std", PathKind::Plain),
             ("hash::collections", PathKind::Plain),
             ("crate::std::hash", PathKind::Crate),
+            ("super::foo", PathKind::Super),
         ];
 
         for (src, expected_path_kind) in cases {
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/traits.rs b/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/traits.rs
index 1aec57c8e41..e64de584da4 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/traits.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/traits.rs
@@ -1,5 +1,6 @@
 use chumsky::prelude::*;
 
+use super::attributes::{attributes, validate_secondary_attributes};
 use super::function::function_return_type;
 use super::{block, expression, fresh_statement, function, function_declaration_parameters};
 
@@ -18,15 +19,24 @@ use crate::{
 use super::{generic_type_args, parse_type, path, primitives::ident};
 
 pub(super) fn trait_definition() -> impl NoirParser<TopLevelStatement> {
-    keyword(Keyword::Trait)
-        .ignore_then(ident())
+    attributes()
+        .then_ignore(keyword(Keyword::Trait))
+        .then(ident())
         .then(function::generics())
         .then(where_clause())
         .then_ignore(just(Token::LeftBrace))
         .then(trait_body())
         .then_ignore(just(Token::RightBrace))
-        .map_with_span(|(((name, generics), where_clause), items), span| {
-            TopLevelStatement::Trait(NoirTrait { name, generics, where_clause, span, items })
+        .validate(|((((attributes, name), generics), where_clause), items), span, emit| {
+            let attributes = validate_secondary_attributes(attributes, span, emit);
+            TopLevelStatement::Trait(NoirTrait {
+                name,
+                generics,
+                where_clause,
+                span,
+                items,
+                attributes,
+            })
         })
 }
 
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/types.rs b/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/types.rs
index 32929312d54..7b69b309bae 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/types.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/parser/parser/types.rs
@@ -26,6 +26,9 @@ pub(super) fn parse_type_inner<'a>(
         string_type(),
         expr_type(),
         struct_definition_type(),
+        trait_definition_type(),
+        function_definition_type(),
+        module_type(),
         top_level_item_type(),
         type_of_quoted_types(),
         quoted_type(),
@@ -54,15 +57,7 @@ pub(super) fn parenthesized_type(
 }
 
 pub(super) fn maybe_comp_time() -> impl NoirParser<bool> {
-    keyword(Keyword::Comptime).or_not().validate(|opt, span, emit| {
-        if opt.is_some() {
-            emit(ParserError::with_reason(
-                ParserErrorReason::ExperimentalFeature("Comptime values"),
-                span,
-            ));
-        }
-        opt.is_some()
-    })
+    keyword(Keyword::Comptime).or_not().map(|opt| opt.is_some())
 }
 
 pub(super) fn field_type() -> impl NoirParser<UnresolvedType> {
@@ -87,6 +82,23 @@ pub(super) fn struct_definition_type() -> impl NoirParser<UnresolvedType> {
     })
 }
 
+pub(super) fn trait_definition_type() -> impl NoirParser<UnresolvedType> {
+    keyword(Keyword::TraitDefinition).map_with_span(|_, span| {
+        UnresolvedTypeData::Quoted(QuotedType::TraitDefinition).with_span(span)
+    })
+}
+
+pub(super) fn function_definition_type() -> impl NoirParser<UnresolvedType> {
+    keyword(Keyword::FunctionDefinition).map_with_span(|_, span| {
+        UnresolvedTypeData::Quoted(QuotedType::FunctionDefinition).with_span(span)
+    })
+}
+
+pub(super) fn module_type() -> impl NoirParser<UnresolvedType> {
+    keyword(Keyword::Module)
+        .map_with_span(|_, span| UnresolvedTypeData::Quoted(QuotedType::Module).with_span(span))
+}
+
 /// This is the type `TopLevelItem` - the type of a quoted statement in the top level.
 /// E.g. a type definition, trait definition, trait impl, function, etc.
 fn top_level_item_type() -> impl NoirParser<UnresolvedType> {
diff --git a/noir/noir-repo/compiler/noirc_frontend/src/tests.rs b/noir/noir-repo/compiler/noirc_frontend/src/tests.rs
index 8cedeeeff0d..321ac3f549d 100644
--- a/noir/noir-repo/compiler/noirc_frontend/src/tests.rs
+++ b/noir/noir-repo/compiler/noirc_frontend/src/tests.rs
@@ -97,6 +97,13 @@ pub(crate) fn get_program_errors(src: &str) -> Vec<(CompilationError, FileId)> {
     get_program(src, false).2
 }
 
+fn assert_no_errors(src: &str) {
+    let errors = get_program_errors(src);
+    if !errors.is_empty() {
+        panic!("Expected no errors, got: {:?}", errors);
+    }
+}
+
 #[test]
 fn check_trait_implemented_for_all_t() {
     let src = "
@@ -141,10 +148,7 @@ fn check_trait_implemented_for_all_t() {
     fn main(a: Foo) -> pub bool {
         a.is_default()
     }";
-
-    let errors = get_program_errors(src);
-    errors.iter().for_each(|err| println!("{:?}", err));
-    assert!(errors.is_empty());
+    assert_no_errors(src);
 }
 
 #[test]
@@ -767,9 +771,7 @@ fn test_impl_self_within_default_def() {
             self
         }
     }";
-    let errors = get_program_errors(src);
-    errors.iter().for_each(|err| println!("{:?}", err));
-    assert!(errors.is_empty());
+    assert_no_errors(src);
 }
 
 #[test]
@@ -794,10 +796,7 @@ fn check_trait_as_type_as_fn_parameter() {
     fn main(a: Foo) -> pub bool {
         test_eq(a)
     }";
-
-    let errors = get_program_errors(src);
-    errors.iter().for_each(|err| println!("{:?}", err));
-    assert!(errors.is_empty());
+    assert_no_errors(src);
 }
 
 #[test]
@@ -830,10 +829,7 @@ fn check_trait_as_type_as_two_fn_parameters() {
     fn main(a: Foo, b: u64) -> pub bool {
         test_eq(a, b)
     }";
-
-    let errors = get_program_errors(src);
-    errors.iter().for_each(|err| println!("{:?}", err));
-    assert!(errors.is_empty());
+    assert_no_errors(src);
 }
 
 fn get_program_captures(src: &str) -> Vec<Vec<String>> {
@@ -898,7 +894,7 @@ fn resolve_empty_function() {
 
         }
     ";
-    assert!(get_program_errors(src).is_empty());
+    assert_no_errors(src);
 }
 #[test]
 fn resolve_basic_function() {
@@ -908,7 +904,7 @@ fn resolve_basic_function() {
             assert(y == x);
         }
     "#;
-    assert!(get_program_errors(src).is_empty());
+    assert_no_errors(src);
 }
 #[test]
 fn resolve_unused_var() {
@@ -981,7 +977,7 @@ fn resolve_literal_expr() {
             assert(y == x);
         }
     "#;
-    assert!(get_program_errors(src).is_empty());
+    assert_no_errors(src);
 }
 
 #[test]
@@ -1028,7 +1024,7 @@ fn resolve_prefix_expr() {
             let _y = -x;
         }
     "#;
-    assert!(get_program_errors(src).is_empty());
+    assert_no_errors(src);
 }
 
 #[test]
@@ -1040,7 +1036,7 @@ fn resolve_for_expr() {
             };
         }
     "#;
-    assert!(get_program_errors(src).is_empty());
+    assert_no_errors(src);
 }
 
 #[test]
@@ -1054,7 +1050,7 @@ fn resolve_call_expr() {
             x
         }
     "#;
-    assert!(get_program_errors(src).is_empty());
+    assert_no_errors(src);
 }
 
 #[test]
@@ -1071,7 +1067,7 @@ fn resolve_shadowing() {
             x
         }
     "#;
-    assert!(get_program_errors(src).is_empty());
+    assert_no_errors(src);
 }
 
 #[test]
@@ -1082,7 +1078,7 @@ fn resolve_basic_closure() {
             closure(x)
         }
     "#;
-    assert!(get_program_errors(src).is_empty());
+    assert_no_errors(src);
 }
 
 #[test]
@@ -1133,7 +1129,7 @@ fn resolve_complex_closures() {
             a + b + c + closure_with_transitive_captures(6)
         }
     "#;
-    assert!(get_program_errors(src).is_empty(), "there should be no errors");
+    assert_no_errors(src);
 
     let expected_captures = vec![
         vec![],
@@ -1636,8 +1632,7 @@ fn numeric_generic_in_function_signature() {
     let src = r#"
     fn foo<let N: u8>(arr: [Field; N]) -> [Field; N] { arr }
     "#;
-    let errors = get_program_errors(src);
-    assert!(errors.is_empty());
+    assert_no_errors(src);
 }
 
 #[test]
@@ -1749,12 +1744,14 @@ fn numeric_generic_used_in_nested_type_pass() {
         inner: [u64; N],
     }    
     "#;
-    let errors = get_program_errors(src);
-    assert!(errors.is_empty());
+    assert_no_errors(src);
 }
 
 #[test]
 fn numeric_generic_used_in_trait() {
+    // We want to make sure that `N` in `impl<let N: u64, T> Deserialize<N, T>` does
+    // not trigger `expected type, found numeric generic parameter N` as the trait
+    // does in fact expect a numeric generic.
     let src = r#"
     struct MyType<T> {
         a: Field,
@@ -1773,11 +1770,7 @@ fn numeric_generic_used_in_trait() {
         fn deserialize(fields: [Field; N], other: T) -> Self;
     }
     "#;
-    let errors = get_program_errors(src);
-    // We want to make sure that `N` in `impl<let N: u64, T> Deserialize<N, T>` does
-    // not trigger `expected type, found numeric generic parameter N` as the trait
-    // does in fact expect a numeric generic.
-    assert!(errors.is_empty());
+    assert_no_errors(src);
 }
 
 #[test]
@@ -1808,8 +1801,7 @@ fn numeric_generic_in_trait_impl_with_extra_impl_generics() {
         fn deserialize(fields: [Field; N]) -> Self;
     }
     "#;
-    let errors = get_program_errors(src);
-    assert!(errors.is_empty());
+    assert_no_errors(src);
 }
 
 #[test]
@@ -1827,8 +1819,7 @@ fn numeric_generic_used_in_where_clause() {
         T::deserialize(fields)
     }
     "#;
-    let errors = get_program_errors(src);
-    assert!(errors.is_empty());
+    assert_no_errors(src);
 }
 
 #[test]
@@ -1845,8 +1836,7 @@ fn numeric_generic_used_in_turbofish() {
         assert(double::<7 + 8>() == 30);
     }
     "#;
-    let errors = get_program_errors(src);
-    assert!(errors.is_empty());
+    assert_no_errors(src);
 }
 
 #[test]
@@ -1866,8 +1856,7 @@ fn constant_used_with_numeric_generic() {
         }
     }
     "#;
-    let errors = get_program_errors(src);
-    assert!(errors.is_empty());
+    assert_no_errors(src);
 }
 
 #[test]
@@ -2076,8 +2065,7 @@ fn turbofish_numeric_generic_nested_call() {
         let _ = bar::<M>();
     }
     "#;
-    let errors = get_program_errors(src);
-    assert!(errors.is_empty());
+    assert_no_errors(src);
 
     // Check for turbofish numeric generics used with method calls
     let src = r#"
@@ -2107,6 +2095,48 @@ fn turbofish_numeric_generic_nested_call() {
         let _ = bar::<M>();
     }
     "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn use_super() {
+    let src = r#"
+    fn some_func() {}
+
+    mod foo {
+        use super::some_func;
+    }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn use_super_in_path() {
+    let src = r#"
+    fn some_func() {}
+
+    mod foo {
+        fn func() {
+            super::some_func();
+        }
+    }
+    "#;
+    assert_no_errors(src);
+}
+
+#[test]
+fn no_super() {
+    let src = "use super::some_func;";
     let errors = get_program_errors(src);
-    assert!(errors.is_empty());
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::DefinitionError(DefCollectorErrorKind::PathResolutionError(
+        PathResolutionError::NoSuper(span),
+    )) = &errors[0].0
+    else {
+        panic!("Expected a 'no super' error, got {:?}", errors[0].0);
+    };
+
+    assert_eq!(span.start(), 4);
+    assert_eq!(span.end(), 9);
 }
diff --git a/noir/noir-repo/compiler/wasm/src/compile.rs b/noir/noir-repo/compiler/wasm/src/compile.rs
index 59b0e00e49f..05f42bc91a1 100644
--- a/noir/noir-repo/compiler/wasm/src/compile.rs
+++ b/noir/noir-repo/compiler/wasm/src/compile.rs
@@ -164,10 +164,9 @@ pub fn compile_program(
     console_error_panic_hook::set_once();
     let (crate_id, mut context) = prepare_context(entry_point, dependency_graph, file_source_map)?;
 
-    let compile_options = CompileOptions {
-        expression_width: ExpressionWidth::Bounded { width: 4 },
-        ..CompileOptions::default()
-    };
+    let expression_width = ExpressionWidth::Bounded { width: 4 };
+    let compile_options =
+        CompileOptions { expression_width: Some(expression_width), ..CompileOptions::default() };
 
     let compiled_program =
         noirc_driver::compile_main(&mut context, crate_id, &compile_options, None)
@@ -180,8 +179,7 @@ pub fn compile_program(
             })?
             .0;
 
-    let optimized_program =
-        nargo::ops::transform_program(compiled_program, compile_options.expression_width);
+    let optimized_program = nargo::ops::transform_program(compiled_program, expression_width);
     let warnings = optimized_program.warnings.clone();
 
     Ok(JsCompileProgramResult::new(optimized_program.into(), warnings))
@@ -196,10 +194,9 @@ pub fn compile_contract(
     console_error_panic_hook::set_once();
     let (crate_id, mut context) = prepare_context(entry_point, dependency_graph, file_source_map)?;
 
-    let compile_options = CompileOptions {
-        expression_width: ExpressionWidth::Bounded { width: 4 },
-        ..CompileOptions::default()
-    };
+    let expression_width = ExpressionWidth::Bounded { width: 4 };
+    let compile_options =
+        CompileOptions { expression_width: Some(expression_width), ..CompileOptions::default() };
 
     let compiled_contract =
         noirc_driver::compile_contract(&mut context, crate_id, &compile_options)
@@ -212,8 +209,7 @@ pub fn compile_contract(
             })?
             .0;
 
-    let optimized_contract =
-        nargo::ops::transform_contract(compiled_contract, compile_options.expression_width);
+    let optimized_contract = nargo::ops::transform_contract(compiled_contract, expression_width);
     let warnings = optimized_contract.warnings.clone();
 
     Ok(JsCompileContractResult::new(optimized_contract.into(), warnings))
diff --git a/noir/noir-repo/compiler/wasm/src/compile_new.rs b/noir/noir-repo/compiler/wasm/src/compile_new.rs
index d5f02833521..ef2af1dd654 100644
--- a/noir/noir-repo/compiler/wasm/src/compile_new.rs
+++ b/noir/noir-repo/compiler/wasm/src/compile_new.rs
@@ -100,7 +100,10 @@ impl CompilerContext {
         } else {
             ExpressionWidth::Bounded { width: 4 }
         };
-        let compile_options = CompileOptions { expression_width, ..CompileOptions::default() };
+        let compile_options = CompileOptions {
+            expression_width: Some(expression_width),
+            ..CompileOptions::default()
+        };
 
         let root_crate_id = *self.context.root_crate_id();
         let compiled_program =
@@ -114,8 +117,7 @@ impl CompilerContext {
                 })?
                 .0;
 
-        let optimized_program =
-            nargo::ops::transform_program(compiled_program, compile_options.expression_width);
+        let optimized_program = nargo::ops::transform_program(compiled_program, expression_width);
         let warnings = optimized_program.warnings.clone();
 
         Ok(JsCompileProgramResult::new(optimized_program.into(), warnings))
@@ -130,7 +132,10 @@ impl CompilerContext {
         } else {
             ExpressionWidth::Bounded { width: 4 }
         };
-        let compile_options = CompileOptions { expression_width, ..CompileOptions::default() };
+        let compile_options = CompileOptions {
+            expression_width: Some(expression_width),
+            ..CompileOptions::default()
+        };
 
         let root_crate_id = *self.context.root_crate_id();
         let compiled_contract =
@@ -145,7 +150,7 @@ impl CompilerContext {
                 .0;
 
         let optimized_contract =
-            nargo::ops::transform_contract(compiled_contract, compile_options.expression_width);
+            nargo::ops::transform_contract(compiled_contract, expression_width);
         let warnings = optimized_contract.warnings.clone();
 
         Ok(JsCompileContractResult::new(optimized_contract.into(), warnings))
diff --git a/noir/noir-repo/cspell.json b/noir/noir-repo/cspell.json
index 2a9bfb4b544..689b72435ef 100644
--- a/noir/noir-repo/cspell.json
+++ b/noir/noir-repo/cspell.json
@@ -206,6 +206,8 @@
         "unoptimized",
         "urem",
         "USERPROFILE",
+        "vararg",
+        "varargs",
         "vecmap",
         "vitkov",
         "wasi",
diff --git a/noir/noir-repo/docs/docs/getting_started/hello_noir/project_breakdown.md b/noir/noir-repo/docs/docs/getting_started/hello_noir/project_breakdown.md
index 29688df148f..525b8dabdd8 100644
--- a/noir/noir-repo/docs/docs/getting_started/hello_noir/project_breakdown.md
+++ b/noir/noir-repo/docs/docs/getting_started/hello_noir/project_breakdown.md
@@ -67,6 +67,7 @@ The package section defines a number of fields including:
 - `entry` (optional) - a relative filepath to use as the entry point into your package (overrides the default of `src/lib.nr` or `src/main.nr`)
 - `backend` (optional)
 - `license` (optional)
+- `expression_width` (optional) - Sets the default backend expression width. This field will override the default backend expression width specified by the Noir compiler (currently set to width 4). 
 
 #### Dependencies section
 
diff --git a/noir/noir-repo/docs/docs/noir/modules_packages_crates/modules.md b/noir/noir-repo/docs/docs/noir/modules_packages_crates/modules.md
index 9fffd925b7b..16b6307d2fd 100644
--- a/noir/noir-repo/docs/docs/noir/modules_packages_crates/modules.md
+++ b/noir/noir-repo/docs/docs/noir/modules_packages_crates/modules.md
@@ -148,4 +148,38 @@ Filename : `src/foo/bar/mod.nr`
 
 ```rust
 fn from_bar() {}
+```
+
+### Referencing a parent module 
+
+Given a submodule, you can refer to its parent module using the `super` keyword.
+
+Filename : `src/main.nr`
+
+```rust
+mod foo;
+
+fn main() {
+    foo::from_foo();
+}
+```
+
+Filename : `src/foo.nr`
+
+```rust
+mod bar;
+
+fn from_foo() {}
+```
+
+Filename : `src/foo/bar.nr`
+
+```rust
+// Same as bar::from_foo
+use super::from_foo; 
+
+fn from_bar() {
+    from_foo();        // invokes super::from_foo(), which is bar::from_foo()
+    super::from_foo(); // also invokes bar::from_foo()
+}
 ```
\ No newline at end of file
diff --git a/noir/noir-repo/noir_stdlib/src/embedded_curve_ops.nr b/noir/noir-repo/noir_stdlib/src/embedded_curve_ops.nr
index f02d2702d6b..6b70b6ddef0 100644
--- a/noir/noir-repo/noir_stdlib/src/embedded_curve_ops.nr
+++ b/noir/noir-repo/noir_stdlib/src/embedded_curve_ops.nr
@@ -102,6 +102,9 @@ pub fn multi_scalar_mul<let N: u32>(
 #[foreign(multi_scalar_mul)]
 fn multi_scalar_mul_array_return<let N: u32>(points: [EmbeddedCurvePoint; N], scalars: [EmbeddedCurveScalar; N]) -> [Field; 3] {}
 
+#[foreign(multi_scalar_mul)]
+pub(crate) fn multi_scalar_mul_slice(points: [EmbeddedCurvePoint], scalars: [EmbeddedCurveScalar]) -> [Field; 3] {}
+
 // docs:start:fixed_base_scalar_mul
 pub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint
 // docs:end:fixed_base_scalar_mul
diff --git a/noir/noir-repo/noir_stdlib/src/field/bn254.nr b/noir/noir-repo/noir_stdlib/src/field/bn254.nr
index bcdc23f80dc..e8db0a30c38 100644
--- a/noir/noir-repo/noir_stdlib/src/field/bn254.nr
+++ b/noir/noir-repo/noir_stdlib/src/field/bn254.nr
@@ -23,7 +23,7 @@ fn compute_decomposition(x: Field) -> (Field, Field) {
     (low, high)
 }
 
-unconstrained fn decompose_hint(x: Field) -> (Field, Field) {
+unconstrained pub(crate) fn decompose_hint(x: Field) -> (Field, Field) {
     compute_decomposition(x)
 }
 
diff --git a/noir/noir-repo/noir_stdlib/src/hash/mod.nr b/noir/noir-repo/noir_stdlib/src/hash/mod.nr
index 9655862dd1b..d1484271d8a 100644
--- a/noir/noir-repo/noir_stdlib/src/hash/mod.nr
+++ b/noir/noir-repo/noir_stdlib/src/hash/mod.nr
@@ -6,7 +6,8 @@ mod keccak;
 use crate::default::Default;
 use crate::uint128::U128;
 use crate::sha256::{digest, sha256_var};
-use crate::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul};
+use crate::collections::vec::Vec;
+use crate::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_slice};
 
 #[foreign(sha256)]
 // docs:start:sha256
@@ -26,38 +27,54 @@ pub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]
 // docs:end:blake3
 {}
 
-#[no_predicates]
 // docs:start:pedersen_commitment
 pub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {
     // docs:end:pedersen_commitment
-    let value = pedersen_commitment_with_separator(input, 0);
-    if (value.x == 0) & (value.y == 0) {
+    pedersen_commitment_with_separator(input, 0)
+}
+
+fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {
+    __pedersen_hash_with_separator(input, separator)
+}
+
+fn pedersen_commitment_with_separator<let N: u32>(input: [Field; N], separator: u32) -> EmbeddedCurvePoint {
+    let value = __pedersen_commitment_with_separator(input, separator);
+    if (value[0] == 0) & (value[1] == 0) {
         EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }
     } else {
-        EmbeddedCurvePoint { x: value.x, y: value.y, is_infinite: false }
+        EmbeddedCurvePoint { x: value[0], y: value[1], is_infinite: false }
     }
 }
 
 fn pedersen_commitment_with_separator_noir<let N: u32>(input: [Field; N], separator: u32) -> EmbeddedCurvePoint {
     let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];
     for i in 0..N {
-        points[i] = EmbeddedCurveScalar::from_field(input[i]);
+        // we use the unsafe version because the multi_scalar_mul will constraint the scalars.
+        points[i] = from_field_unsafe(input[i]);
     }
     let generators = derive_generators("DEFAULT_DOMAIN_SEPARATOR".as_bytes(), separator);
     multi_scalar_mul(generators, points)
 }
 
-#[no_predicates]
-pub fn pedersen_commitment_with_separator<let N: u32>(input: [Field; N], separator: u32) -> EmbeddedCurvePoint {
-    let values = __pedersen_commitment_with_separator(input, separator);
-    EmbeddedCurvePoint { x: values[0], y: values[1], is_infinite: false }
+fn pedersen_hash_with_separator_noir<let N: u32>(input: [Field; N], separator: u32) -> Field {
+    let mut scalars: Vec<EmbeddedCurveScalar> = Vec::from_slice([EmbeddedCurveScalar { lo: 0, hi: 0 }; N].as_slice()); //Vec::new();
+
+    for i in 0..N {
+        scalars.set(i, from_field_unsafe(input[i]));
+    }
+    scalars.push(EmbeddedCurveScalar { lo: N as Field, hi: 0 });
+    let domain_generators :[EmbeddedCurvePoint; N]= derive_generators("DEFAULT_DOMAIN_SEPARATOR".as_bytes(), separator);
+    let mut vec_generators = Vec::from_slice(domain_generators.as_slice());
+    let length_generator : [EmbeddedCurvePoint; 1] = derive_generators("pedersen_hash_length".as_bytes(), 0);
+    vec_generators.push(length_generator[0]);
+    multi_scalar_mul_slice(vec_generators.slice, scalars.slice)[0]
 }
 
 // docs:start:pedersen_hash
 pub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field
 // docs:end:pedersen_hash
 {
-    pedersen_hash_with_separator(input, 0)
+    __pedersen_hash_with_separator(input, 0)
 }
 
 #[field(bn254)]
@@ -67,6 +84,12 @@ fn derive_generators<let N: u32, let M: u32>(domain_separator_bytes: [u8; M], st
     __derive_generators(domain_separator_bytes, starting_index)
 }
 
+#[foreign(pedersen_hash)]
+pub fn __pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {}
+
+#[foreign(pedersen_commitment)]
+fn __pedersen_commitment_with_separator<let N: u32>(input: [Field; N], separator: u32) -> [Field; 2] {}
+
 #[builtin(derive_pedersen_generators)]
 #[field(bn254)]
 fn __derive_generators<let N: u32, let M: u32>(
@@ -74,21 +97,17 @@ fn __derive_generators<let N: u32, let M: u32>(
     starting_index: u32
 ) -> [EmbeddedCurvePoint; N] {}
 
-fn pedersen_hash_with_separator_noir<let N: u32>(input: [Field; N], separator: u32) -> Field {
-    let v1 = pedersen_commitment_with_separator(input, separator);
-    let length_generator : [EmbeddedCurvePoint; 1] = derive_generators("pedersen_hash_length".as_bytes(), 0);
-    multi_scalar_mul(
-        [length_generator[0], v1],
-        [EmbeddedCurveScalar { lo: N as Field, hi: 0 }, EmbeddedCurveScalar { lo: 1, hi: 0 }]
-    ).x
+#[field(bn254)]
+    // Same as from_field but:
+    // does not assert the limbs are 128 bits
+    // does not assert the decomposition does not overflow the EmbeddedCurveScalar
+    fn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {
+    let (xlo, xhi) = crate::field::bn254::decompose_hint(scalar);
+    // Check that the decomposition is correct
+    assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);
+    EmbeddedCurveScalar { lo: xlo, hi: xhi }
 }
 
-#[foreign(pedersen_hash)]
-pub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {}
-
-#[foreign(pedersen_commitment)]
-fn __pedersen_commitment_with_separator<let N: u32>(input: [Field; N], separator: u32) -> [Field; 2] {}
-
 pub fn hash_to_field(inputs: [Field]) -> Field {
     let mut sum = 0;
 
@@ -263,10 +282,111 @@ impl<A, B, C, D, E> Hash for (A, B, C, D, E) where A: Hash, B: Hash, C: Hash, D:
     }
 }
 
+// Some test vectors for Pedersen hash and Pedersen Commitment.
+// They have been generated using the same functions so the tests are for now useless
+// but they will be useful when we switch to Noir implementation.
 #[test]
-fn assert_pedersen_noir() {
-    // TODO: make this a fuzzer test once fuzzer supports curve-specific blackbox functions.
-    let input = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    assert_eq(pedersen_hash_with_separator(input, 4), pedersen_hash_with_separator_noir(input, 4));
-    assert_eq(pedersen_commitment_with_separator(input, 4), pedersen_commitment_with_separator_noir(input, 4));
+fn assert_pedersen() {
+    assert_eq(
+        pedersen_hash_with_separator([1], 1), 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f
+    );
+    assert_eq(
+        pedersen_commitment_with_separator([1], 1), EmbeddedCurvePoint {
+        x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,
+        y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,
+        is_infinite: false
+    }
+    );
+
+    assert_eq(
+        pedersen_hash_with_separator([1, 2], 2), 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255
+    );
+    assert_eq(
+        pedersen_commitment_with_separator([1, 2], 2), EmbeddedCurvePoint {
+        x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,
+        y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,
+        is_infinite: false
+    }
+    );
+    assert_eq(
+        pedersen_hash_with_separator([1, 2, 3], 3), 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4
+    );
+    assert_eq(
+        pedersen_commitment_with_separator([1, 2, 3], 3), EmbeddedCurvePoint {
+        x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,
+        y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,
+        is_infinite: false
+    }
+    );
+    assert_eq(
+        pedersen_hash_with_separator([1, 2, 3, 4], 4), 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc
+    );
+    assert_eq(
+        pedersen_commitment_with_separator([1, 2, 3, 4], 4), EmbeddedCurvePoint {
+        x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,
+        y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,
+        is_infinite: false
+    }
+    );
+    assert_eq(
+        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5), 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22
+    );
+    assert_eq(
+        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5), EmbeddedCurvePoint {
+        x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,
+        y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,
+        is_infinite: false
+    }
+    );
+    assert_eq(
+        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6), 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572
+    );
+    assert_eq(
+        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6), EmbeddedCurvePoint {
+        x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,
+        y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,
+        is_infinite: false
+    }
+    );
+    assert_eq(
+        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7), 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3
+    );
+    assert_eq(
+        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7), EmbeddedCurvePoint {
+        x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,
+        y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,
+        is_infinite: false
+    }
+    );
+    assert_eq(
+        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8), 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c
+    );
+    assert_eq(
+        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8), EmbeddedCurvePoint {
+        x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,
+        y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,
+        is_infinite: false
+    }
+    );
+    assert_eq(
+        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9), 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7
+    );
+    assert_eq(
+        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9), EmbeddedCurvePoint {
+        x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,
+        y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,
+        is_infinite: false
+    }
+    );
+    assert_eq(
+        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10), 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94
+    );
+    assert_eq(
+        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10), EmbeddedCurvePoint {
+        x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,
+        y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,
+        is_infinite: false
+    }
+    );
 }
+
diff --git a/noir/noir-repo/noir_stdlib/src/meta/mod.nr b/noir/noir-repo/noir_stdlib/src/meta/mod.nr
index 1825888130b..ad8ee4f8586 100644
--- a/noir/noir-repo/noir_stdlib/src/meta/mod.nr
+++ b/noir/noir-repo/noir_stdlib/src/meta/mod.nr
@@ -1 +1,8 @@
 mod type_def;
+
+/// Calling unquote as a macro (via `unquote!(arg)`) will unquote
+/// its argument. Since this is the effect `!` already does, `unquote`
+/// itself does not need to do anything besides return its argument.
+pub comptime fn unquote(code: Quoted) -> Quoted {
+    code
+}
diff --git a/noir/noir-repo/scripts/redo-typo-pr.sh b/noir/noir-repo/scripts/redo-typo-pr.sh
index 416be65a449..4b3b93b48ed 100755
--- a/noir/noir-repo/scripts/redo-typo-pr.sh
+++ b/noir/noir-repo/scripts/redo-typo-pr.sh
@@ -16,16 +16,21 @@ gh pr checkout $ORIGINAL_PR_NUMBER
 echo "Creating new local branch $NEW_BRANCH"
 git checkout -b $NEW_BRANCH
 
-# Step 3: Push the new branch to GitHub
+# Step 3: Squash commits
+echo "Squashing new local branch $NEW_BRANCH"
+git reset --soft master
+git add .
+git commit -m "chore: typo fixes"
+
+# Step 4: Push the new branch to GitHub
 echo "Pushing new branch $NEW_BRANCH to GitHub"
-git commit --amend --no-edit
 git push origin $NEW_BRANCH
 
-# Step 4: create a new pull request
+# Step 5: create a new pull request
 echo "Creating a new pull request for $NEW_BRANCH"
 gh pr create --base master --head $NEW_BRANCH --title "chore: redo typo PR by $AUTHOR" --body "Thanks $AUTHOR for https://github.com/$REPO/pull/$ORIGINAL_PR_NUMBER. Our policy is to redo typo changes to dissuade metric farming. This is an automated script."
 
-# Step 5: Close the original PR
+# Step 6: Close the original PR
 echo "Closing original PR #$ORIGINAL_PR_NUMBER"
 gh pr close $ORIGINAL_PR_NUMBER
 
diff --git a/noir/noir-repo/test_programs/compile_success_empty/attribute_args/Nargo.toml b/noir/noir-repo/test_programs/compile_success_empty/attribute_args/Nargo.toml
new file mode 100644
index 00000000000..8efe5d203d1
--- /dev/null
+++ b/noir/noir-repo/test_programs/compile_success_empty/attribute_args/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "attribute_args"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.31.0"
+
+[dependencies]
diff --git a/noir/noir-repo/test_programs/compile_success_empty/attribute_args/src/main.nr b/noir/noir-repo/test_programs/compile_success_empty/attribute_args/src/main.nr
new file mode 100644
index 00000000000..44b9c20460f
--- /dev/null
+++ b/noir/noir-repo/test_programs/compile_success_empty/attribute_args/src/main.nr
@@ -0,0 +1,20 @@
+#[attr_with_args(a b, c d)]
+#[varargs(one, two)]
+#[varargs(one, two, three, four)]
+struct Foo {}
+
+comptime fn attr_with_args(s: StructDefinition, a: Quoted, b: Quoted) {
+    // Ensure all variables are in scope.
+    // We can't print them since that breaks the test runner.
+    let _ = s;
+    let _ = a;
+    let _ = b;
+}
+
+comptime fn varargs(s: StructDefinition, t: [Quoted]) {
+    let _ = s;
+    for _ in t {}
+    assert(t.len() < 5);
+}
+
+fn main() {}
diff --git a/noir/noir-repo/test_programs/compile_success_empty/function_attribute/Nargo.toml b/noir/noir-repo/test_programs/compile_success_empty/function_attribute/Nargo.toml
new file mode 100644
index 00000000000..94b5c5da6a8
--- /dev/null
+++ b/noir/noir-repo/test_programs/compile_success_empty/function_attribute/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "function_attribute"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.31.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/noir/noir-repo/test_programs/compile_success_empty/function_attribute/src/main.nr b/noir/noir-repo/test_programs/compile_success_empty/function_attribute/src/main.nr
new file mode 100644
index 00000000000..ec22b730d3f
--- /dev/null
+++ b/noir/noir-repo/test_programs/compile_success_empty/function_attribute/src/main.nr
@@ -0,0 +1,18 @@
+#[function_attr]
+fn foo() {}
+
+struct Foo {}
+
+comptime fn function_attr(_f: FunctionDefinition) -> Quoted {
+    quote {
+        impl Default for Foo {
+            fn default() -> Foo {
+                Foo {}
+            }
+        }
+    }
+}
+
+fn main() {
+    let _ = Foo::default();
+}
diff --git a/noir/noir-repo/test_programs/compile_success_empty/regression_5428/Nargo.toml b/noir/noir-repo/test_programs/compile_success_empty/regression_5428/Nargo.toml
new file mode 100644
index 00000000000..7507b934d66
--- /dev/null
+++ b/noir/noir-repo/test_programs/compile_success_empty/regression_5428/Nargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "regression_5428"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/noir/noir-repo/test_programs/compile_success_empty/regression_5428/src/main.nr b/noir/noir-repo/test_programs/compile_success_empty/regression_5428/src/main.nr
new file mode 100644
index 00000000000..f01b89cbea4
--- /dev/null
+++ b/noir/noir-repo/test_programs/compile_success_empty/regression_5428/src/main.nr
@@ -0,0 +1,9 @@
+fn main() {
+    assert_true!();
+}
+
+comptime fn assert_true() -> Quoted {
+    let first = quote { assert( };
+    let second = quote { true); };
+    first.append(second)
+}
diff --git a/noir/noir-repo/test_programs/compile_success_empty/trait_attribute/Nargo.toml b/noir/noir-repo/test_programs/compile_success_empty/trait_attribute/Nargo.toml
new file mode 100644
index 00000000000..c72fe5e3e89
--- /dev/null
+++ b/noir/noir-repo/test_programs/compile_success_empty/trait_attribute/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "trait_attribute"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.31.0"
+
+[dependencies]
diff --git a/noir/noir-repo/test_programs/compile_success_empty/trait_attribute/src/main.nr b/noir/noir-repo/test_programs/compile_success_empty/trait_attribute/src/main.nr
new file mode 100644
index 00000000000..87f4893e3e5
--- /dev/null
+++ b/noir/noir-repo/test_programs/compile_success_empty/trait_attribute/src/main.nr
@@ -0,0 +1,19 @@
+#[trait_attr]
+trait Foo {
+    fn foo(self) -> Self;
+}
+
+comptime fn trait_attr(_t: TraitDefinition) -> Quoted {
+    quote {
+        impl Foo for Field {
+            fn foo(self) -> Self {
+                self + 1
+            }
+        }
+    }
+}
+
+fn main() {
+    assert_eq(1.foo(), 2);
+    assert_eq(10.foo(), 11);
+}
diff --git a/noir/noir-repo/test_programs/compile_success_empty/unquote/Nargo.toml b/noir/noir-repo/test_programs/compile_success_empty/unquote/Nargo.toml
new file mode 100644
index 00000000000..68b2890e37a
--- /dev/null
+++ b/noir/noir-repo/test_programs/compile_success_empty/unquote/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "unquote"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.31.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/noir/noir-repo/test_programs/compile_success_empty/unquote/src/main.nr b/noir/noir-repo/test_programs/compile_success_empty/unquote/src/main.nr
new file mode 100644
index 00000000000..2717286b810
--- /dev/null
+++ b/noir/noir-repo/test_programs/compile_success_empty/unquote/src/main.nr
@@ -0,0 +1,4 @@
+fn main() {
+    std::meta::unquote!(quote { assert(true); });
+    assert(std::meta::unquote!(quote { true }));
+}
diff --git a/noir/noir-repo/test_programs/compile_success_no_bug/check_uncostrained_regression/Nargo.toml b/noir/noir-repo/test_programs/compile_success_no_bug/check_uncostrained_regression/Nargo.toml
new file mode 100644
index 00000000000..3c6b5d9688c
--- /dev/null
+++ b/noir/noir-repo/test_programs/compile_success_no_bug/check_uncostrained_regression/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "check_unconstrained_regression"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.31.0"
+
+[dependencies]
\ No newline at end of file
diff --git a/noir/noir-repo/test_programs/compile_success_no_bug/check_uncostrained_regression/src/main.nr b/noir/noir-repo/test_programs/compile_success_no_bug/check_uncostrained_regression/src/main.nr
new file mode 100644
index 00000000000..e93e068f432
--- /dev/null
+++ b/noir/noir-repo/test_programs/compile_success_no_bug/check_uncostrained_regression/src/main.nr
@@ -0,0 +1,27 @@
+struct Trigger{
+    x: u32,
+    y: Field,
+    z: [Field;3],
+}
+struct ResultType{
+    a: u32,
+    b: Field,
+    c: [Field;3],
+}
+
+unconstrained fn convert(trigger: Trigger) -> ResultType {
+    let result= ResultType { a: trigger.x + 1, b: trigger.y - 1 + trigger.z[2], c: [trigger.z[0], 0, trigger.z[1]] };
+    result
+}
+impl Trigger {
+    fn execute(self) -> ResultType {
+        let result = convert(self);
+        assert(result.a == self.x + 1);
+        assert(result.b == self.y - 1 + self.z[2]);
+        assert(result.c[1] == 0);
+        result
+    }
+}
+fn main(x: Trigger) -> pub ResultType {
+    x.execute()
+}
diff --git a/noir/noir-repo/test_programs/execution_success/bench_ecdsa_secp256k1/Nargo.toml b/noir/noir-repo/test_programs/execution_success/bench_ecdsa_secp256k1/Nargo.toml
new file mode 100644
index 00000000000..7e83251cc5a
--- /dev/null
+++ b/noir/noir-repo/test_programs/execution_success/bench_ecdsa_secp256k1/Nargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "bench_ecdsa_secp256k1"
+description = "ECDSA secp256k1 verification"
+type = "bin"
+authors = [""]
+
+[dependencies]
diff --git a/noir/noir-repo/test_programs/execution_success/bench_ecdsa_secp256k1/Prover.toml b/noir/noir-repo/test_programs/execution_success/bench_ecdsa_secp256k1/Prover.toml
new file mode 100644
index 00000000000..e78fc19cb71
--- /dev/null
+++ b/noir/noir-repo/test_programs/execution_success/bench_ecdsa_secp256k1/Prover.toml
@@ -0,0 +1,169 @@
+
+hashed_message = [
+    0x3a,
+    0x73,
+    0xf4,
+    0x12,
+    0x3a,
+    0x5c,
+    0xd2,
+    0x12,
+    0x1f,
+    0x21,
+    0xcd,
+    0x7e,
+    0x8d,
+    0x35,
+    0x88,
+    0x35,
+    0x47,
+    0x69,
+    0x49,
+    0xd0,
+    0x35,
+    0xd9,
+    0xc2,
+    0xda,
+    0x68,
+    0x06,
+    0xb4,
+    0x63,
+    0x3a,
+    0xc8,
+    0xc1,
+    0xe2,
+]
+pub_key_x = [
+    0xa0,
+    0x43,
+    0x4d,
+    0x9e,
+    0x47,
+    0xf3,
+    0xc8,
+    0x62,
+    0x35,
+    0x47,
+    0x7c,
+    0x7b,
+    0x1a,
+    0xe6,
+    0xae,
+    0x5d,
+    0x34,
+    0x42,
+    0xd4,
+    0x9b,
+    0x19,
+    0x43,
+    0xc2,
+    0xb7,
+    0x52,
+    0xa6,
+    0x8e,
+    0x2a,
+    0x47,
+    0xe2,
+    0x47,
+    0xc7,
+]
+pub_key_y = [
+    0x89,
+    0x3a,
+    0xba,
+    0x42,
+    0x54,
+    0x19,
+    0xbc,
+    0x27,
+    0xa3,
+    0xb6,
+    0xc7,
+    0xe6,
+    0x93,
+    0xa2,
+    0x4c,
+    0x69,
+    0x6f,
+    0x79,
+    0x4c,
+    0x2e,
+    0xd8,
+    0x77,
+    0xa1,
+    0x59,
+    0x3c,
+    0xbe,
+    0xe5,
+    0x3b,
+    0x03,
+    0x73,
+    0x68,
+    0xd7,
+]
+signature = [
+    0xe5,
+    0x08,
+    0x1c,
+    0x80,
+    0xab,
+    0x42,
+    0x7d,
+    0xc3,
+    0x70,
+    0x34,
+    0x6f,
+    0x4a,
+    0x0e,
+    0x31,
+    0xaa,
+    0x2b,
+    0xad,
+    0x8d,
+    0x97,
+    0x98,
+    0xc3,
+    0x80,
+    0x61,
+    0xdb,
+    0x9a,
+    0xe5,
+    0x5a,
+    0x4e,
+    0x8d,
+    0xf4,
+    0x54,
+    0xfd,
+    0x28,
+    0x11,
+    0x98,
+    0x94,
+    0x34,
+    0x4e,
+    0x71,
+    0xb7,
+    0x87,
+    0x70,
+    0xcc,
+    0x93,
+    0x1d,
+    0x61,
+    0xf4,
+    0x80,
+    0xec,
+    0xbb,
+    0x0b,
+    0x89,
+    0xd6,
+    0xeb,
+    0x69,
+    0x69,
+    0x01,
+    0x61,
+    0xe4,
+    0x9a,
+    0x71,
+    0x5f,
+    0xcd,
+    0x55,
+]
diff --git a/noir/noir-repo/test_programs/execution_success/bench_ecdsa_secp256k1/src/main.nr b/noir/noir-repo/test_programs/execution_success/bench_ecdsa_secp256k1/src/main.nr
new file mode 100644
index 00000000000..60f182c7836
--- /dev/null
+++ b/noir/noir-repo/test_programs/execution_success/bench_ecdsa_secp256k1/src/main.nr
@@ -0,0 +1,6 @@
+use dep::std;
+
+fn main(hashed_message: [u8; 32], pub_key_x: [u8; 32], pub_key_y: [u8; 32], signature: [u8; 64]) {
+    let valid_signature = std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+    assert(valid_signature);
+}
diff --git a/noir/noir-repo/test_programs/execution_success/poseidon_bn254_hash_width_3/Nargo.toml b/noir/noir-repo/test_programs/execution_success/poseidon_bn254_hash_width_3/Nargo.toml
new file mode 100644
index 00000000000..7047f0aeef2
--- /dev/null
+++ b/noir/noir-repo/test_programs/execution_success/poseidon_bn254_hash_width_3/Nargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "poseidon_bn254_hash_width_3"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.31.0"
+# Test usage of `expression_width` field
+expression_width = "3"
+
+[dependencies]
\ No newline at end of file
diff --git a/noir/noir-repo/test_programs/execution_success/poseidon_bn254_hash_width_3/Prover.toml b/noir/noir-repo/test_programs/execution_success/poseidon_bn254_hash_width_3/Prover.toml
new file mode 100644
index 00000000000..8eecf9a3db2
--- /dev/null
+++ b/noir/noir-repo/test_programs/execution_success/poseidon_bn254_hash_width_3/Prover.toml
@@ -0,0 +1,4 @@
+x1 = [1,2]
+y1 = "0x115cc0f5e7d690413df64c6b9662e9cf2a3617f2743245519e19607a4417189a"
+x2 = [1,2,3,4]
+y2 = "0x299c867db6c1fdd79dcefa40e4510b9837e60ebb1ce0663dbaa525df65250465"
diff --git a/noir/noir-repo/test_programs/execution_success/poseidon_bn254_hash_width_3/src/main.nr b/noir/noir-repo/test_programs/execution_success/poseidon_bn254_hash_width_3/src/main.nr
new file mode 100644
index 00000000000..bb441a1ace3
--- /dev/null
+++ b/noir/noir-repo/test_programs/execution_success/poseidon_bn254_hash_width_3/src/main.nr
@@ -0,0 +1,9 @@
+use std::hash::poseidon;
+
+fn main(x1: [Field; 2], y1: pub Field, x2: [Field; 4], y2: pub Field) {
+    let hash1 = poseidon::bn254::hash_2(x1);
+    assert(hash1 == y1);
+
+    let hash2 = poseidon::bn254::hash_4(x2);
+    assert(hash2 == y2);
+}
diff --git a/noir/noir-repo/tooling/debugger/Cargo.toml b/noir/noir-repo/tooling/debugger/Cargo.toml
index 05b28f9d95a..540d6d11bc0 100644
--- a/noir/noir-repo/tooling/debugger/Cargo.toml
+++ b/noir/noir-repo/tooling/debugger/Cargo.toml
@@ -14,7 +14,7 @@ build-data.workspace = true
 acvm.workspace = true
 fm.workspace = true
 nargo.workspace = true
-noirc_frontend.workspace = true
+noirc_frontend = { workspace = true, features = ["bn254"] }
 noirc_printable_type.workspace = true
 noirc_errors.workspace = true
 noirc_driver.workspace = true
diff --git a/noir/noir-repo/tooling/debugger/ignored-tests.txt b/noir/noir-repo/tooling/debugger/ignored-tests.txt
index 2a6648b094b..745971d9b28 100644
--- a/noir/noir-repo/tooling/debugger/ignored-tests.txt
+++ b/noir/noir-repo/tooling/debugger/ignored-tests.txt
@@ -1,13 +1,5 @@
 brillig_references
 debug_logs
-fold_after_inlined_calls
-fold_basic
-fold_basic_nested_call
-fold_call_witness_condition
-fold_complex_outputs
-fold_distinct_return
-fold_fibonacci
-fold_numeric_generic_poseidon
 is_unconstrained
 macros
 references
diff --git a/noir/noir-repo/tooling/debugger/src/context.rs b/noir/noir-repo/tooling/debugger/src/context.rs
index cb36988bf0b..d18ec5f0786 100644
--- a/noir/noir-repo/tooling/debugger/src/context.rs
+++ b/noir/noir-repo/tooling/debugger/src/context.rs
@@ -1,10 +1,11 @@
 use crate::foreign_calls::DebugForeignCallExecutor;
 use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::acir::circuit::{Circuit, Opcode, OpcodeLocation};
-use acvm::acir::native_types::{Witness, WitnessMap};
+use acvm::acir::native_types::{Witness, WitnessMap, WitnessStack};
 use acvm::brillig_vm::MemoryValue;
 use acvm::pwg::{
-    ACVMStatus, BrilligSolver, BrilligSolverStatus, ForeignCallWaitInfo, StepResult, ACVM,
+    ACVMStatus, AcirCallWaitInfo, BrilligSolver, BrilligSolverStatus, ForeignCallWaitInfo,
+    OpcodeNotSolvable, StepResult, ACVM,
 };
 use acvm::{BlackBoxFunctionSolver, FieldElement};
 
@@ -15,56 +16,235 @@ use nargo::NargoError;
 use noirc_artifacts::debug::{DebugArtifact, StackFrame};
 use noirc_driver::DebugFile;
 
+use thiserror::Error;
+
 use std::collections::BTreeMap;
 use std::collections::{hash_set::Iter, HashSet};
 
+/// A Noir program is composed by
+/// `n` ACIR circuits
+///       |_ `m` ACIR opcodes
+///                |_ Acir call
+///                |_ Acir Brillig function invocation
+///                           |_ `p` Brillig opcodes
+///
+/// The purpose of this structure is to map the opcode locations in ACIR circuits into
+/// a flat contiguous address space to be able to expose them to the DAP interface.
+/// In this address space, the ACIR circuits are laid out one after the other, and
+/// Brillig functions called from such circuits are expanded inline, replacing
+/// the `BrilligCall` ACIR opcode.
+///
+/// `addresses: Vec<Vec<usize>>`
+///  * The outer vec is `n` sized - one element per ACIR circuit
+///  * Each nested vec is `m` sized - one element per ACIR opcode in circuit
+///    * Each element is the "virtual address" of such opcode
+///
+/// For flattening we map each ACIR circuit and ACIR opcode with a sequential address number
+/// We start by assigning 0 to the very first ACIR opcode and then start accumulating by
+/// traversing by depth-first
+///
+/// Even if the address space is continuous, the `addresses` tree only
+/// keeps track of the ACIR opcodes, since the Brillig opcode addresses can be
+/// calculated from the initial opcode address.
+/// As a result the flattened indexed addresses list may have "holes".
+///
+/// If between two consequent `addresses` nodes there is a "hole" (an address jump),
+/// this means that the first one is actually a ACIR Brillig call
+/// which has as many brillig opcodes as `second_address - first_address`
+///
+#[derive(Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
+pub struct AddressMap {
+    addresses: Vec<Vec<usize>>,
+
+    // virtual address of the last opcode of the program
+    last_valid_address: usize,
+}
+
+impl AddressMap {
+    pub(super) fn new(
+        circuits: &[Circuit<FieldElement>],
+        unconstrained_functions: &[BrilligBytecode<FieldElement>],
+    ) -> Self {
+        let opcode_address_size = |opcode: &Opcode<FieldElement>| {
+            if let Opcode::BrilligCall { id, .. } = opcode {
+                unconstrained_functions[*id as usize].bytecode.len()
+            } else {
+                1
+            }
+        };
+
+        let mut addresses = Vec::with_capacity(circuits.len());
+        let mut next_address = 0usize;
+
+        for circuit in circuits {
+            let mut circuit_addresses = Vec::with_capacity(circuit.opcodes.len());
+            for opcode in &circuit.opcodes {
+                circuit_addresses.push(next_address);
+                next_address += opcode_address_size(opcode);
+            }
+            addresses.push(circuit_addresses);
+        }
+
+        Self { addresses, last_valid_address: next_address - 1 }
+    }
+
+    /// Returns the absolute address of the opcode at the given location.
+    /// Absolute here means accounting for nested Brillig opcodes in BrilligCall
+    /// opcodes.
+    pub fn debug_location_to_address(&self, location: &DebugLocation) -> usize {
+        let circuit_addresses = &self.addresses[location.circuit_id as usize];
+        match &location.opcode_location {
+            OpcodeLocation::Acir(acir_index) => circuit_addresses[*acir_index],
+            OpcodeLocation::Brillig { acir_index, brillig_index } => {
+                circuit_addresses[*acir_index] + *brillig_index
+            }
+        }
+    }
+
+    pub fn address_to_debug_location(&self, address: usize) -> Option<DebugLocation> {
+        if address > self.last_valid_address {
+            return None;
+        }
+        // We binary search if the given address is the first opcode address of each circuit id
+        // if is not, this means that the address itself is "contained" in the previous
+        // circuit indicated by `Err(insert_index)`
+        let circuit_id =
+            match self.addresses.binary_search_by(|addresses| addresses[0].cmp(&address)) {
+                Ok(found_index) => found_index,
+                // This means that the address is not in `insert_index` circuit
+                // because is an `Err`, so it must be included in previous circuit vec of opcodes
+                Err(insert_index) => insert_index - 1,
+            };
+
+        // We binary search among the selected `circuit_id`` list of opcodes
+        // If Err(insert_index) this means that the given address
+        // is a Brillig addresses that's contained in previous index ACIR opcode index
+        let opcode_location = match self.addresses[circuit_id].binary_search(&address) {
+            Ok(found_index) => OpcodeLocation::Acir(found_index),
+            Err(insert_index) => {
+                let acir_index = insert_index - 1;
+                let base_offset = self.addresses[circuit_id][acir_index];
+                let brillig_index = address - base_offset;
+                OpcodeLocation::Brillig { acir_index, brillig_index }
+            }
+        };
+        Some(DebugLocation { circuit_id: circuit_id as u32, opcode_location })
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
+pub struct DebugLocation {
+    pub circuit_id: u32,
+    pub opcode_location: OpcodeLocation,
+}
+
+impl std::fmt::Display for DebugLocation {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let circuit_id = self.circuit_id;
+        match self.opcode_location {
+            OpcodeLocation::Acir(index) => write!(f, "{circuit_id}:{index}"),
+            OpcodeLocation::Brillig { acir_index, brillig_index } => {
+                write!(f, "{circuit_id}:{acir_index}.{brillig_index}")
+            }
+        }
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum DebugLocationFromStrError {
+    #[error("Invalid debug location string: {0}")]
+    InvalidDebugLocationString(String),
+}
+
+impl std::str::FromStr for DebugLocation {
+    type Err = DebugLocationFromStrError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let parts: Vec<_> = s.split(':').collect();
+        let error = Err(DebugLocationFromStrError::InvalidDebugLocationString(s.to_string()));
+
+        match parts.len() {
+            1 => OpcodeLocation::from_str(parts[0]).map_or(error, |opcode_location| {
+                Ok(DebugLocation { circuit_id: 0, opcode_location })
+            }),
+            2 => {
+                let first_part = parts[0].parse().ok();
+                let second_part = OpcodeLocation::from_str(parts[1]).ok();
+                if let (Some(circuit_id), Some(opcode_location)) = (first_part, second_part) {
+                    Ok(DebugLocation { circuit_id, opcode_location })
+                } else {
+                    error
+                }
+            }
+            _ => error,
+        }
+    }
+}
+
 #[derive(Debug)]
 pub(super) enum DebugCommandResult {
     Done,
     Ok,
-    BreakpointReached(OpcodeLocation),
+    BreakpointReached(DebugLocation),
     Error(NargoError<FieldElement>),
 }
 
+pub struct ExecutionFrame<'a, B: BlackBoxFunctionSolver<FieldElement>> {
+    circuit_id: u32,
+    acvm: ACVM<'a, FieldElement, B>,
+}
+
 pub(super) struct DebugContext<'a, B: BlackBoxFunctionSolver<FieldElement>> {
     acvm: ACVM<'a, FieldElement, B>,
+    current_circuit_id: u32,
     brillig_solver: Option<BrilligSolver<'a, FieldElement, B>>,
+
+    witness_stack: WitnessStack<FieldElement>,
+    acvm_stack: Vec<ExecutionFrame<'a, B>>,
+
+    backend: &'a B,
     foreign_call_executor: Box<dyn DebugForeignCallExecutor + 'a>,
+
     debug_artifact: &'a DebugArtifact,
-    breakpoints: HashSet<OpcodeLocation>,
-    source_to_opcodes: BTreeMap<FileId, Vec<(usize, OpcodeLocation)>>,
+    breakpoints: HashSet<DebugLocation>,
+    source_to_locations: BTreeMap<FileId, Vec<(usize, DebugLocation)>>,
+
+    circuits: &'a [Circuit<FieldElement>],
     unconstrained_functions: &'a [BrilligBytecode<FieldElement>],
 
-    // Absolute (in terms of all the opcodes ACIR+Brillig) addresses of the ACIR
-    // opcodes with one additional entry for to indicate the last valid address.
-    acir_opcode_addresses: Vec<usize>,
+    acir_opcode_addresses: AddressMap,
 }
 
 impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
     pub(super) fn new(
         blackbox_solver: &'a B,
-        circuit: &'a Circuit<FieldElement>,
+        circuits: &'a [Circuit<FieldElement>],
         debug_artifact: &'a DebugArtifact,
         initial_witness: WitnessMap<FieldElement>,
         foreign_call_executor: Box<dyn DebugForeignCallExecutor + 'a>,
         unconstrained_functions: &'a [BrilligBytecode<FieldElement>],
     ) -> Self {
         let source_to_opcodes = build_source_to_opcode_debug_mappings(debug_artifact);
-        let acir_opcode_addresses = build_acir_opcode_offsets(circuit, unconstrained_functions);
+        let current_circuit_id: u32 = 0;
+        let initial_circuit = &circuits[current_circuit_id as usize];
+        let acir_opcode_addresses = AddressMap::new(circuits, unconstrained_functions);
         Self {
-            // TODO: need to handle brillig pointer in the debugger
             acvm: ACVM::new(
                 blackbox_solver,
-                &circuit.opcodes,
+                &initial_circuit.opcodes,
                 initial_witness,
                 unconstrained_functions,
-                &circuit.assert_messages,
+                &initial_circuit.assert_messages,
             ),
+            current_circuit_id,
             brillig_solver: None,
+            witness_stack: WitnessStack::default(),
+            acvm_stack: vec![],
+            backend: blackbox_solver,
             foreign_call_executor,
             debug_artifact,
             breakpoints: HashSet::new(),
-            source_to_opcodes,
+            source_to_locations: source_to_opcodes,
+            circuits,
             unconstrained_functions,
             acir_opcode_addresses,
         }
@@ -74,6 +254,10 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
         self.acvm.opcodes()
     }
 
+    pub(super) fn get_opcodes_of_circuit(&self, circuit_id: u32) -> &[Opcode<FieldElement>] {
+        &self.circuits[circuit_id as usize].opcodes
+    }
+
     pub(super) fn get_witness_map(&self) -> &WitnessMap<FieldElement> {
         self.acvm.witness_map()
     }
@@ -86,36 +270,49 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
         self.acvm.overwrite_witness(witness, value)
     }
 
-    pub(super) fn get_current_opcode_location(&self) -> Option<OpcodeLocation> {
+    pub(super) fn get_current_debug_location(&self) -> Option<DebugLocation> {
         let ip = self.acvm.instruction_pointer();
         if ip >= self.get_opcodes().len() {
             None
-        } else if let Some(ref solver) = self.brillig_solver {
-            Some(OpcodeLocation::Brillig {
-                acir_index: ip,
-                brillig_index: solver.program_counter(),
-            })
         } else {
-            Some(OpcodeLocation::Acir(ip))
+            let opcode_location = if let Some(ref solver) = self.brillig_solver {
+                OpcodeLocation::Brillig { acir_index: ip, brillig_index: solver.program_counter() }
+            } else {
+                OpcodeLocation::Acir(ip)
+            };
+            Some(DebugLocation { circuit_id: self.current_circuit_id, opcode_location })
         }
     }
 
-    pub(super) fn get_call_stack(&self) -> Vec<OpcodeLocation> {
+    pub(super) fn get_call_stack(&self) -> Vec<DebugLocation> {
+        // Build the frames from parent ACIR calls
+        let mut frames: Vec<_> = self
+            .acvm_stack
+            .iter()
+            .map(|ExecutionFrame { circuit_id, acvm }| DebugLocation {
+                circuit_id: *circuit_id,
+                opcode_location: OpcodeLocation::Acir(acvm.instruction_pointer()),
+            })
+            .collect();
+
+        // Now add the frame(s) for the currently executing ACVM
         let instruction_pointer = self.acvm.instruction_pointer();
-        if instruction_pointer >= self.get_opcodes().len() {
-            vec![]
-        } else if let Some(ref solver) = self.brillig_solver {
-            solver
-                .get_call_stack()
-                .iter()
-                .map(|program_counter| OpcodeLocation::Brillig {
+        let circuit_id = self.current_circuit_id;
+        if let Some(ref solver) = self.brillig_solver {
+            frames.extend(solver.get_call_stack().iter().map(|program_counter| DebugLocation {
+                circuit_id,
+                opcode_location: OpcodeLocation::Brillig {
                     acir_index: instruction_pointer,
                     brillig_index: *program_counter,
-                })
-                .collect()
-        } else {
-            vec![OpcodeLocation::Acir(instruction_pointer)]
+                },
+            }));
+        } else if instruction_pointer < self.get_opcodes().len() {
+            frames.push(DebugLocation {
+                circuit_id,
+                opcode_location: OpcodeLocation::Acir(instruction_pointer),
+            });
         }
+        frames
     }
 
     pub(super) fn is_source_location_in_debug_module(&self, location: &Location) -> bool {
@@ -142,10 +339,10 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
         &self,
         file_id: &FileId,
         line: i64,
-    ) -> Option<OpcodeLocation> {
+    ) -> Option<DebugLocation> {
         let line = line as usize;
-        let line_to_opcodes = self.source_to_opcodes.get(file_id)?;
-        let found_index = match line_to_opcodes.binary_search_by(|x| x.0.cmp(&line)) {
+        let line_to_opcodes = self.source_to_locations.get(file_id)?;
+        let found_location = match line_to_opcodes.binary_search_by(|x| x.0.cmp(&line)) {
             Ok(index) => {
                 // move backwards to find the first opcode which matches the line
                 let mut index = index;
@@ -161,7 +358,7 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
                 line_to_opcodes[index].1
             }
         };
-        Some(found_index)
+        Some(found_location)
     }
 
     /// Returns the callstack in source code locations for the currently
@@ -172,9 +369,9 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
     /// This function also filters source locations that are determined to be in
     /// the internal debug module.
     pub(super) fn get_current_source_location(&self) -> Option<Vec<Location>> {
-        self.get_current_opcode_location()
+        self.get_current_debug_location()
             .as_ref()
-            .map(|opcode_location| self.get_source_location_for_opcode_location(opcode_location))
+            .map(|debug_location| self.get_source_location_for_debug_location(debug_location))
             .filter(|v: &Vec<Location>| !v.is_empty())
     }
 
@@ -184,15 +381,12 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
     /// the given opcode location cannot be mapped back to a source location
     /// (eg. it may be pure debug instrumentation code or other synthetically
     /// produced opcode by the compiler)
-    pub(super) fn get_source_location_for_opcode_location(
+    pub(super) fn get_source_location_for_debug_location(
         &self,
-        opcode_location: &OpcodeLocation,
+        debug_location: &DebugLocation,
     ) -> Vec<Location> {
-        // TODO: this assumes we're debugging a program (ie. the DebugArtifact
-        // will contain a single DebugInfo), but this assumption doesn't hold
-        // for contracts
-        self.debug_artifact.debug_symbols[0]
-            .opcode_location(opcode_location)
+        self.debug_artifact.debug_symbols[debug_location.circuit_id as usize]
+            .opcode_location(&debug_location.opcode_location)
             .map(|source_locations| {
                 source_locations
                     .into_iter()
@@ -208,48 +402,30 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
     /// general, the matching between opcode location and source location is 1
     /// to 1, but due to the compiler inlining functions a single opcode
     /// location may expand to multiple source locations.
-    pub(super) fn get_source_call_stack(&self) -> Vec<(OpcodeLocation, Location)> {
+    pub(super) fn get_source_call_stack(&self) -> Vec<(DebugLocation, Location)> {
         self.get_call_stack()
             .iter()
-            .flat_map(|opcode_location| {
-                self.get_source_location_for_opcode_location(opcode_location)
+            .flat_map(|debug_location| {
+                self.get_source_location_for_debug_location(debug_location)
                     .into_iter()
-                    .map(|source_location| (*opcode_location, source_location))
+                    .map(|source_location| (*debug_location, source_location))
             })
             .collect()
     }
 
     /// Returns the absolute address of the opcode at the given location.
-    /// Absolute here means accounting for nested Brillig opcodes in BrilligCall
-    /// opcodes.
-    pub fn opcode_location_to_address(&self, location: &OpcodeLocation) -> usize {
-        match location {
-            OpcodeLocation::Acir(acir_index) => self.acir_opcode_addresses[*acir_index],
-            OpcodeLocation::Brillig { acir_index, brillig_index } => {
-                self.acir_opcode_addresses[*acir_index] + *brillig_index
-            }
-        }
+    pub fn debug_location_to_address(&self, location: &DebugLocation) -> usize {
+        self.acir_opcode_addresses.debug_location_to_address(location)
     }
 
-    pub fn address_to_opcode_location(&self, address: usize) -> Option<OpcodeLocation> {
-        if address >= *self.acir_opcode_addresses.last().unwrap_or(&0) {
-            return None;
-        }
-        let location = match self.acir_opcode_addresses.binary_search(&address) {
-            Ok(found_index) => OpcodeLocation::Acir(found_index),
-            Err(insert_index) => {
-                let acir_index = insert_index - 1;
-                let base_offset = self.acir_opcode_addresses[acir_index];
-                let brillig_index = address - base_offset;
-                OpcodeLocation::Brillig { acir_index, brillig_index }
-            }
-        };
-        Some(location)
+    // Returns the DebugLocation associated to the given address
+    pub fn address_to_debug_location(&self, address: usize) -> Option<DebugLocation> {
+        self.acir_opcode_addresses.address_to_debug_location(address)
     }
 
-    pub(super) fn render_opcode_at_location(&self, location: &OpcodeLocation) -> String {
-        let opcodes = self.get_opcodes();
-        match location {
+    pub(super) fn render_opcode_at_location(&self, location: &DebugLocation) -> String {
+        let opcodes = self.get_opcodes_of_circuit(location.circuit_id);
+        match &location.opcode_location {
             OpcodeLocation::Acir(acir_index) => {
                 let opcode = &opcodes[*acir_index];
                 match opcode {
@@ -280,7 +456,7 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
                 self.brillig_solver = Some(solver);
                 if self.breakpoint_reached() {
                     DebugCommandResult::BreakpointReached(
-                        self.get_current_opcode_location()
+                        self.get_current_debug_location()
                             .expect("Breakpoint reached but we have no location"),
                     )
                 } else {
@@ -296,7 +472,6 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
                 self.handle_foreign_call(foreign_call)
             }
             Err(err) => DebugCommandResult::Error(NargoError::ExecutionError(
-                // TODO: debugger does not handle multiple acir calls
                 ExecutionError::SolvingError(err, None),
             )),
         }
@@ -315,24 +490,82 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
                 } else {
                     self.acvm.resolve_pending_foreign_call(foreign_call_result);
                 }
-                // TODO: should we retry executing the opcode somehow in this case?
+                // TODO: should we retry executing the opcode somehow in this
+                // case? Otherwise, executing a foreign call takes two debugging
+                // steps.
                 DebugCommandResult::Ok
             }
             Err(error) => DebugCommandResult::Error(error.into()),
         }
     }
 
-    fn handle_acvm_status(&mut self, status: ACVMStatus<FieldElement>) -> DebugCommandResult {
-        if let ACVMStatus::RequiresForeignCall(foreign_call) = status {
-            return self.handle_foreign_call(foreign_call);
+    fn handle_acir_call(
+        &mut self,
+        call_info: AcirCallWaitInfo<FieldElement>,
+    ) -> DebugCommandResult {
+        let callee_circuit = &self.circuits[call_info.id as usize];
+        let callee_witness_map = call_info.initial_witness;
+        let callee_acvm = ACVM::new(
+            self.backend,
+            &callee_circuit.opcodes,
+            callee_witness_map,
+            self.unconstrained_functions,
+            &callee_circuit.assert_messages,
+        );
+        let caller_acvm = std::mem::replace(&mut self.acvm, callee_acvm);
+        self.acvm_stack
+            .push(ExecutionFrame { circuit_id: self.current_circuit_id, acvm: caller_acvm });
+        self.current_circuit_id = call_info.id;
+
+        // Explicitly handling the new ACVM status here handles two edge cases:
+        // 1. there is a breakpoint set at the beginning of a circuit
+        // 2. the called circuit has no opcodes
+        self.handle_acvm_status(self.acvm.get_status().clone())
+    }
+
+    fn handle_acir_call_finished(&mut self) -> DebugCommandResult {
+        let caller_frame = self.acvm_stack.pop().expect("Execution stack should not be empty");
+        let caller_acvm = caller_frame.acvm;
+        let callee_acvm = std::mem::replace(&mut self.acvm, caller_acvm);
+        self.current_circuit_id = caller_frame.circuit_id;
+        let call_solved_witness = callee_acvm.finalize();
+
+        let ACVMStatus::RequiresAcirCall(call_info) = self.acvm.get_status() else {
+            unreachable!("Resolving an ACIR call, the caller is in an invalid state");
+        };
+        let acir_to_call = &self.circuits[call_info.id as usize];
+
+        let mut call_resolved_outputs = Vec::new();
+        for return_witness_index in acir_to_call.return_values.indices() {
+            if let Some(return_value) = call_solved_witness.get_index(return_witness_index) {
+                call_resolved_outputs.push(*return_value);
+            } else {
+                return DebugCommandResult::Error(
+                    ExecutionError::SolvingError(
+                        OpcodeNotSolvable::MissingAssignment(return_witness_index).into(),
+                        None, // Missing assignment errors do not supply user-facing diagnostics so we do not need to attach a call stack
+                    )
+                    .into(),
+                );
+            }
         }
+        self.acvm.resolve_pending_acir_call(call_resolved_outputs);
+
+        DebugCommandResult::Ok
+    }
 
+    fn handle_acvm_status(&mut self, status: ACVMStatus<FieldElement>) -> DebugCommandResult {
         match status {
-            ACVMStatus::Solved => DebugCommandResult::Done,
+            ACVMStatus::Solved => {
+                if self.acvm_stack.is_empty() {
+                    return DebugCommandResult::Done;
+                }
+                self.handle_acir_call_finished()
+            }
             ACVMStatus::InProgress => {
                 if self.breakpoint_reached() {
                     DebugCommandResult::BreakpointReached(
-                        self.get_current_opcode_location()
+                        self.get_current_debug_location()
                             .expect("Breakpoint reached but we have no location"),
                     )
                 } else {
@@ -340,15 +573,10 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
                 }
             }
             ACVMStatus::Failure(error) => DebugCommandResult::Error(NargoError::ExecutionError(
-                // TODO: debugger does not handle multiple acir calls
                 ExecutionError::SolvingError(error, None),
             )),
-            ACVMStatus::RequiresForeignCall(_) => {
-                unreachable!("Unexpected pending foreign call resolution");
-            }
-            ACVMStatus::RequiresAcirCall(_) => {
-                todo!("Multiple ACIR calls are not supported");
-            }
+            ACVMStatus::RequiresForeignCall(foreign_call) => self.handle_foreign_call(foreign_call),
+            ACVMStatus::RequiresAcirCall(call_info) => self.handle_acir_call(call_info),
         }
     }
 
@@ -367,9 +595,11 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
     }
 
     fn get_current_acir_index(&self) -> Option<usize> {
-        self.get_current_opcode_location().map(|opcode_location| match opcode_location {
-            OpcodeLocation::Acir(acir_index) => acir_index,
-            OpcodeLocation::Brillig { acir_index, .. } => acir_index,
+        self.get_current_debug_location().map(|debug_location| {
+            match debug_location.opcode_location {
+                OpcodeLocation::Acir(acir_index) => acir_index,
+                OpcodeLocation::Brillig { acir_index, .. } => acir_index,
+            }
         })
     }
 
@@ -394,10 +624,16 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
             return true;
         }
 
-        match self.get_current_opcode_location() {
-            Some(OpcodeLocation::Brillig { .. }) => true,
-            Some(OpcodeLocation::Acir(acir_index)) => {
-                matches!(self.get_opcodes()[acir_index], Opcode::BrilligCall { .. })
+        match self.get_current_debug_location() {
+            Some(DebugLocation { opcode_location: OpcodeLocation::Brillig { .. }, .. }) => true,
+            Some(DebugLocation {
+                circuit_id,
+                opcode_location: OpcodeLocation::Acir(acir_index),
+            }) => {
+                matches!(
+                    self.get_opcodes_of_circuit(circuit_id)[acir_index],
+                    Opcode::BrilligCall { .. }
+                )
             }
             _ => false,
         }
@@ -491,16 +727,19 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
     }
 
     fn breakpoint_reached(&self) -> bool {
-        if let Some(location) = self.get_current_opcode_location() {
+        if let Some(location) = self.get_current_debug_location() {
             self.breakpoints.contains(&location)
         } else {
             false
         }
     }
 
-    pub(super) fn is_valid_opcode_location(&self, location: &OpcodeLocation) -> bool {
-        let opcodes = self.get_opcodes();
-        match *location {
+    pub(super) fn is_valid_debug_location(&self, location: &DebugLocation) -> bool {
+        if location.circuit_id as usize >= self.circuits.len() {
+            return false;
+        }
+        let opcodes = self.get_opcodes_of_circuit(location.circuit_id);
+        match location.opcode_location {
             OpcodeLocation::Acir(acir_index) => acir_index < opcodes.len(),
             OpcodeLocation::Brillig { acir_index, brillig_index } => {
                 if acir_index < opcodes.len() {
@@ -518,19 +757,19 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
         }
     }
 
-    pub(super) fn is_breakpoint_set(&self, location: &OpcodeLocation) -> bool {
+    pub(super) fn is_breakpoint_set(&self, location: &DebugLocation) -> bool {
         self.breakpoints.contains(location)
     }
 
-    pub(super) fn add_breakpoint(&mut self, location: OpcodeLocation) -> bool {
+    pub(super) fn add_breakpoint(&mut self, location: DebugLocation) -> bool {
         self.breakpoints.insert(location)
     }
 
-    pub(super) fn delete_breakpoint(&mut self, location: &OpcodeLocation) -> bool {
+    pub(super) fn delete_breakpoint(&mut self, location: &DebugLocation) -> bool {
         self.breakpoints.remove(location)
     }
 
-    pub(super) fn iterate_breakpoints(&self) -> Iter<'_, OpcodeLocation> {
+    pub(super) fn iterate_breakpoints(&self) -> Iter<'_, DebugLocation> {
         self.breakpoints.iter()
     }
 
@@ -542,8 +781,10 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> DebugContext<'a, B> {
         matches!(self.acvm.get_status(), ACVMStatus::Solved)
     }
 
-    pub fn finalize(self) -> WitnessMap<FieldElement> {
-        self.acvm.finalize()
+    pub fn finalize(mut self) -> WitnessStack<FieldElement> {
+        let last_witness_map = self.acvm.finalize();
+        self.witness_stack.push(0, last_witness_map);
+        self.witness_stack
     }
 }
 
@@ -555,11 +796,10 @@ fn is_debug_file_in_debug_crate(debug_file: &DebugFile) -> bool {
 /// numbers and opcode locations corresponding to those line numbers
 fn build_source_to_opcode_debug_mappings(
     debug_artifact: &DebugArtifact,
-) -> BTreeMap<FileId, Vec<(usize, OpcodeLocation)>> {
+) -> BTreeMap<FileId, Vec<(usize, DebugLocation)>> {
     if debug_artifact.debug_symbols.is_empty() {
         return BTreeMap::new();
     }
-    let locations = &debug_artifact.debug_symbols[0].locations;
     let simple_files: BTreeMap<_, _> = debug_artifact
         .file_map
         .iter()
@@ -572,50 +812,34 @@ fn build_source_to_opcode_debug_mappings(
         })
         .collect();
 
-    let mut result: BTreeMap<FileId, Vec<(usize, OpcodeLocation)>> = BTreeMap::new();
-    locations.iter().for_each(|(opcode_location, source_locations)| {
-        source_locations.iter().for_each(|source_location| {
-            let span = source_location.span;
-            let file_id = source_location.file;
-            let Some(file) = simple_files.get(&file_id) else {
-                return;
-            };
-            let Ok(line_index) = file.line_index((), span.start() as usize) else {
-                return;
-            };
-            let line_number = line_index + 1;
-
-            result.entry(file_id).or_default().push((line_number, *opcode_location));
-        });
-    });
+    let mut result: BTreeMap<FileId, Vec<(usize, DebugLocation)>> = BTreeMap::new();
+
+    for (circuit_id, debug_symbols) in debug_artifact.debug_symbols.iter().enumerate() {
+        for (opcode_location, source_locations) in &debug_symbols.locations {
+            source_locations.iter().for_each(|source_location| {
+                let span = source_location.span;
+                let file_id = source_location.file;
+                let Some(file) = simple_files.get(&file_id) else {
+                    return;
+                };
+                let Ok(line_index) = file.line_index((), span.start() as usize) else {
+                    return;
+                };
+                let line_number = line_index + 1;
+
+                let debug_location = DebugLocation {
+                    circuit_id: circuit_id as u32,
+                    opcode_location: *opcode_location,
+                };
+                result.entry(file_id).or_default().push((line_number, debug_location));
+            });
+        }
+    }
     result.iter_mut().for_each(|(_, file_locations)| file_locations.sort_by_key(|x| (x.0, x.1)));
 
     result
 }
 
-fn build_acir_opcode_offsets(
-    circuit: &Circuit<FieldElement>,
-    unconstrained_functions: &[BrilligBytecode<FieldElement>],
-) -> Vec<usize> {
-    let mut result = Vec::with_capacity(circuit.opcodes.len() + 1);
-    // address of the first opcode is always 0
-    result.push(0);
-    circuit.opcodes.iter().fold(0, |acc, opcode| {
-        let acc = acc
-            + match opcode {
-                Opcode::BrilligCall { id, .. } => {
-                    unconstrained_functions[*id as usize].bytecode.len()
-                }
-                _ => 1,
-            };
-        // push the starting address of the next opcode
-        result.push(acc);
-        acc
-    });
-    result
-}
-
-// TODO: update all debugger tests to use unconstrained brillig pointers
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -625,7 +849,7 @@ mod tests {
         acir::{
             circuit::{
                 brillig::{BrilligInputs, BrilligOutputs},
-                opcodes::BlockId,
+                opcodes::{BlockId, BlockType},
             },
             native_types::Expression,
             AcirField,
@@ -675,7 +899,8 @@ mod tests {
         }];
         let brillig_funcs = &vec![brillig_bytecode];
         let current_witness_index = 2;
-        let circuit = &Circuit { current_witness_index, opcodes, ..Circuit::default() };
+        let circuit = Circuit { current_witness_index, opcodes, ..Circuit::default() };
+        let circuits = &vec![circuit];
 
         let debug_symbols = vec![];
         let file_map = BTreeMap::new();
@@ -687,51 +912,66 @@ mod tests {
             Box::new(DefaultDebugForeignCallExecutor::from_artifact(true, debug_artifact));
         let mut context = DebugContext::new(
             &StubbedBlackBoxSolver,
-            circuit,
+            circuits,
             debug_artifact,
             initial_witness,
             foreign_call_executor,
             brillig_funcs,
         );
 
-        assert_eq!(context.get_current_opcode_location(), Some(OpcodeLocation::Acir(0)));
+        assert_eq!(
+            context.get_current_debug_location(),
+            Some(DebugLocation { circuit_id: 0, opcode_location: OpcodeLocation::Acir(0) })
+        );
 
         // Execute the first Brillig opcode (calldata copy)
         let result = context.step_into_opcode();
         assert!(matches!(result, DebugCommandResult::Ok));
         assert_eq!(
-            context.get_current_opcode_location(),
-            Some(OpcodeLocation::Brillig { acir_index: 0, brillig_index: 1 })
+            context.get_current_debug_location(),
+            Some(DebugLocation {
+                circuit_id: 0,
+                opcode_location: OpcodeLocation::Brillig { acir_index: 0, brillig_index: 1 }
+            })
         );
 
         // execute the second Brillig opcode (const)
         let result = context.step_into_opcode();
         assert!(matches!(result, DebugCommandResult::Ok));
         assert_eq!(
-            context.get_current_opcode_location(),
-            Some(OpcodeLocation::Brillig { acir_index: 0, brillig_index: 2 })
+            context.get_current_debug_location(),
+            Some(DebugLocation {
+                circuit_id: 0,
+                opcode_location: OpcodeLocation::Brillig { acir_index: 0, brillig_index: 2 }
+            })
         );
 
         // try to execute the third Brillig opcode (and resolve the foreign call)
         let result = context.step_into_opcode();
         assert!(matches!(result, DebugCommandResult::Ok));
         assert_eq!(
-            context.get_current_opcode_location(),
-            Some(OpcodeLocation::Brillig { acir_index: 0, brillig_index: 2 })
+            context.get_current_debug_location(),
+            Some(DebugLocation {
+                circuit_id: 0,
+                opcode_location: OpcodeLocation::Brillig { acir_index: 0, brillig_index: 2 }
+            })
         );
 
         // retry the third Brillig opcode (foreign call should be finished)
         let result = context.step_into_opcode();
         assert!(matches!(result, DebugCommandResult::Ok));
         assert_eq!(
-            context.get_current_opcode_location(),
-            Some(OpcodeLocation::Brillig { acir_index: 0, brillig_index: 3 })
+            context.get_current_debug_location(),
+            Some(DebugLocation {
+                circuit_id: 0,
+                opcode_location: OpcodeLocation::Brillig { acir_index: 0, brillig_index: 3 }
+            })
         );
 
         // last Brillig opcode
         let result = context.step_into_opcode();
         assert!(matches!(result, DebugCommandResult::Done));
-        assert_eq!(context.get_current_opcode_location(), None);
+        assert_eq!(context.get_current_debug_location(), None);
     }
 
     #[test]
@@ -784,7 +1024,8 @@ mod tests {
             }),
         ];
         let current_witness_index = 3;
-        let circuit = &Circuit { current_witness_index, opcodes, ..Circuit::default() };
+        let circuit = Circuit { current_witness_index, opcodes, ..Circuit::default() };
+        let circuits = &vec![circuit];
 
         let debug_symbols = vec![];
         let file_map = BTreeMap::new();
@@ -797,7 +1038,7 @@ mod tests {
         let brillig_funcs = &vec![brillig_bytecode];
         let mut context = DebugContext::new(
             &StubbedBlackBoxSolver,
-            circuit,
+            circuits,
             debug_artifact,
             initial_witness,
             foreign_call_executor,
@@ -805,28 +1046,40 @@ mod tests {
         );
 
         // set breakpoint
-        let breakpoint_location = OpcodeLocation::Brillig { acir_index: 0, brillig_index: 1 };
+        let breakpoint_location = DebugLocation {
+            circuit_id: 0,
+            opcode_location: OpcodeLocation::Brillig { acir_index: 0, brillig_index: 1 },
+        };
         assert!(context.add_breakpoint(breakpoint_location));
 
         // execute the first ACIR opcode (Brillig block) -> should reach the breakpoint instead
         let result = context.step_acir_opcode();
         assert!(matches!(result, DebugCommandResult::BreakpointReached(_)));
-        assert_eq!(context.get_current_opcode_location(), Some(breakpoint_location));
+        assert_eq!(context.get_current_debug_location(), Some(breakpoint_location));
 
         // continue execution to the next ACIR opcode
         let result = context.step_acir_opcode();
         assert!(matches!(result, DebugCommandResult::Ok));
-        assert_eq!(context.get_current_opcode_location(), Some(OpcodeLocation::Acir(1)));
+        assert_eq!(
+            context.get_current_debug_location(),
+            Some(DebugLocation { circuit_id: 0, opcode_location: OpcodeLocation::Acir(1) })
+        );
 
         // last ACIR opcode
         let result = context.step_acir_opcode();
         assert!(matches!(result, DebugCommandResult::Done));
-        assert_eq!(context.get_current_opcode_location(), None);
+        assert_eq!(context.get_current_debug_location(), None);
     }
 
     #[test]
-    fn test_address_opcode_location_mapping() {
-        let brillig_bytecode = BrilligBytecode {
+    fn test_address_debug_location_mapping() {
+        let brillig_one = BrilligBytecode {
+            bytecode: vec![
+                BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
+                BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
+            ],
+        };
+        let brillig_two = BrilligBytecode {
             bytecode: vec![
                 BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
                 BrilligOpcode::Stop { return_data_offset: 0, return_data_size: 0 },
@@ -834,22 +1087,33 @@ mod tests {
             ],
         };
 
-        let opcodes = vec![
-            Opcode::BrilligCall { id: 0, inputs: vec![], outputs: vec![], predicate: None },
-            Opcode::MemoryInit {
-                block_id: BlockId(0),
-                init: vec![],
-                block_type: acvm::acir::circuit::opcodes::BlockType::Memory,
-            },
-            Opcode::BrilligCall { id: 0, inputs: vec![], outputs: vec![], predicate: None },
-            Opcode::AssertZero(Expression::default()),
-        ];
-        let circuit = Circuit { opcodes, ..Circuit::default() };
+        let circuit_one = Circuit {
+            opcodes: vec![
+                Opcode::MemoryInit {
+                    block_id: BlockId(0),
+                    init: vec![],
+                    block_type: BlockType::Memory,
+                },
+                Opcode::BrilligCall { id: 0, inputs: vec![], outputs: vec![], predicate: None },
+                Opcode::Call { id: 1, inputs: vec![], outputs: vec![], predicate: None },
+                Opcode::AssertZero(Expression::default()),
+            ],
+            ..Circuit::default()
+        };
+        let circuit_two = Circuit {
+            opcodes: vec![
+                Opcode::BrilligCall { id: 1, inputs: vec![], outputs: vec![], predicate: None },
+                Opcode::AssertZero(Expression::default()),
+            ],
+            ..Circuit::default()
+        };
+        let circuits = vec![circuit_one, circuit_two];
         let debug_artifact = DebugArtifact { debug_symbols: vec![], file_map: BTreeMap::new() };
-        let brillig_funcs = &vec![brillig_bytecode];
+        let brillig_funcs = &vec![brillig_one, brillig_two];
+
         let context = DebugContext::new(
             &StubbedBlackBoxSolver,
-            &circuit,
+            &circuits,
             &debug_artifact,
             WitnessMap::new(),
             Box::new(DefaultDebugForeignCallExecutor::new(true)),
@@ -857,46 +1121,56 @@ mod tests {
         );
 
         let locations =
-            (0..=7).map(|address| context.address_to_opcode_location(address)).collect::<Vec<_>>();
+            (0..=8).map(|address| context.address_to_debug_location(address)).collect::<Vec<_>>();
 
         // mapping from addresses to opcode locations
         assert_eq!(
             locations,
             vec![
-                Some(OpcodeLocation::Acir(0)),
-                Some(OpcodeLocation::Brillig { acir_index: 0, brillig_index: 1 }),
-                Some(OpcodeLocation::Brillig { acir_index: 0, brillig_index: 2 }),
-                Some(OpcodeLocation::Acir(1)),
-                Some(OpcodeLocation::Acir(2)),
-                Some(OpcodeLocation::Brillig { acir_index: 2, brillig_index: 1 }),
-                Some(OpcodeLocation::Brillig { acir_index: 2, brillig_index: 2 }),
-                Some(OpcodeLocation::Acir(3)),
+                Some(DebugLocation { circuit_id: 0, opcode_location: OpcodeLocation::Acir(0) }),
+                Some(DebugLocation { circuit_id: 0, opcode_location: OpcodeLocation::Acir(1) }),
+                Some(DebugLocation {
+                    circuit_id: 0,
+                    opcode_location: OpcodeLocation::Brillig { acir_index: 1, brillig_index: 1 }
+                }),
+                Some(DebugLocation { circuit_id: 0, opcode_location: OpcodeLocation::Acir(2) }),
+                Some(DebugLocation { circuit_id: 0, opcode_location: OpcodeLocation::Acir(3) }),
+                Some(DebugLocation { circuit_id: 1, opcode_location: OpcodeLocation::Acir(0) }),
+                Some(DebugLocation {
+                    circuit_id: 1,
+                    opcode_location: OpcodeLocation::Brillig { acir_index: 0, brillig_index: 1 }
+                }),
+                Some(DebugLocation {
+                    circuit_id: 1,
+                    opcode_location: OpcodeLocation::Brillig { acir_index: 0, brillig_index: 2 }
+                }),
+                Some(DebugLocation { circuit_id: 1, opcode_location: OpcodeLocation::Acir(1) }),
             ]
         );
 
         let addresses = locations
             .iter()
             .flatten()
-            .map(|location| context.opcode_location_to_address(location))
+            .map(|location| context.debug_location_to_address(location))
             .collect::<Vec<_>>();
 
         // and vice-versa
-        assert_eq!(addresses, (0..=7).collect::<Vec<_>>());
+        assert_eq!(addresses, (0..=8).collect::<Vec<_>>());
 
         // check edge cases
-        assert_eq!(None, context.address_to_opcode_location(8));
+        assert_eq!(None, context.address_to_debug_location(9));
         assert_eq!(
-            0,
-            context.opcode_location_to_address(&OpcodeLocation::Brillig {
-                acir_index: 0,
-                brillig_index: 0
+            1,
+            context.debug_location_to_address(&DebugLocation {
+                circuit_id: 0,
+                opcode_location: OpcodeLocation::Brillig { acir_index: 1, brillig_index: 0 }
             })
         );
         assert_eq!(
-            4,
-            context.opcode_location_to_address(&OpcodeLocation::Brillig {
-                acir_index: 2,
-                brillig_index: 0
+            5,
+            context.debug_location_to_address(&DebugLocation {
+                circuit_id: 1,
+                opcode_location: OpcodeLocation::Brillig { acir_index: 0, brillig_index: 0 }
             })
         );
     }
diff --git a/noir/noir-repo/tooling/debugger/src/dap.rs b/noir/noir-repo/tooling/debugger/src/dap.rs
index 77abf3093cd..cfe33a61cb5 100644
--- a/noir/noir-repo/tooling/debugger/src/dap.rs
+++ b/noir/noir-repo/tooling/debugger/src/dap.rs
@@ -2,12 +2,12 @@ use std::collections::BTreeMap;
 use std::io::{Read, Write};
 
 use acvm::acir::circuit::brillig::BrilligBytecode;
-use acvm::acir::circuit::{Circuit, OpcodeLocation};
+use acvm::acir::circuit::Circuit;
 use acvm::acir::native_types::WitnessMap;
 use acvm::{BlackBoxFunctionSolver, FieldElement};
 
-use crate::context::DebugCommandResult;
 use crate::context::DebugContext;
+use crate::context::{DebugCommandResult, DebugLocation};
 use crate::foreign_calls::DefaultDebugForeignCallExecutor;
 
 use dap::errors::ServerError;
@@ -37,8 +37,8 @@ pub struct DapSession<'a, R: Read, W: Write, B: BlackBoxFunctionSolver<FieldElem
     debug_artifact: &'a DebugArtifact,
     running: bool,
     next_breakpoint_id: BreakpointId,
-    instruction_breakpoints: Vec<(OpcodeLocation, BreakpointId)>,
-    source_breakpoints: BTreeMap<FileId, Vec<(OpcodeLocation, BreakpointId)>>,
+    instruction_breakpoints: Vec<(DebugLocation, BreakpointId)>,
+    source_breakpoints: BTreeMap<FileId, Vec<(DebugLocation, BreakpointId)>>,
 }
 
 enum ScopeReferences {
@@ -61,14 +61,14 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver<FieldElement>> DapSession<
     pub fn new(
         server: Server<R, W>,
         solver: &'a B,
-        circuit: &'a Circuit<FieldElement>,
+        circuits: &'a [Circuit<FieldElement>],
         debug_artifact: &'a DebugArtifact,
         initial_witness: WitnessMap<FieldElement>,
         unconstrained_functions: &'a [BrilligBytecode<FieldElement>],
     ) -> Self {
         let context = DebugContext::new(
             solver,
-            circuit,
+            circuits,
             debug_artifact,
             initial_witness,
             Box::new(DefaultDebugForeignCallExecutor::from_artifact(true, debug_artifact)),
@@ -100,7 +100,7 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver<FieldElement>> DapSession<
     }
 
     pub fn run_loop(&mut self) -> Result<(), ServerError> {
-        self.running = self.context.get_current_opcode_location().is_some();
+        self.running = self.context.get_current_debug_location().is_some();
 
         if self.running && self.context.get_current_source_location().is_none() {
             // TODO: remove this? This is to ensure that the tool has a proper
@@ -194,7 +194,7 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver<FieldElement>> DapSession<
             .get_source_call_stack()
             .iter()
             .enumerate()
-            .map(|(index, (opcode_location, source_location))| {
+            .map(|(index, (debug_location, source_location))| {
                 let line_number =
                     self.debug_artifact.location_line_number(*source_location).unwrap();
                 let column_number =
@@ -204,7 +204,7 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver<FieldElement>> DapSession<
                     Some(frame) => format!("{} {}", frame.function_name, index),
                     None => format!("frame #{index}"),
                 };
-                let address = self.context.opcode_location_to_address(opcode_location);
+                let address = self.context.debug_location_to_address(debug_location);
 
                 StackFrame {
                     id: index as i64,
@@ -251,18 +251,18 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver<FieldElement>> DapSession<
         let mut instructions: Vec<DisassembledInstruction> = vec![];
 
         while count > 0 {
-            let opcode_location = if address >= 0 {
-                self.context.address_to_opcode_location(address as usize)
+            let debug_location = if address >= 0 {
+                self.context.address_to_debug_location(address as usize)
             } else {
                 None
             };
 
-            if let Some(opcode_location) = opcode_location {
+            if let Some(debug_location) = debug_location {
                 instructions.push(DisassembledInstruction {
                     address: address.to_string(),
                     // we'll use the instruction_bytes field to render the OpcodeLocation
-                    instruction_bytes: Some(opcode_location.to_string()),
-                    instruction: self.context.render_opcode_at_location(&opcode_location),
+                    instruction_bytes: Some(debug_location.to_string()),
+                    instruction: self.context.render_opcode_at_location(&debug_location),
                     ..DisassembledInstruction::default()
                 });
             } else {
@@ -320,16 +320,16 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver<FieldElement>> DapSession<
         self.handle_execution_result(result)
     }
 
-    fn find_breakpoints_at_location(&self, opcode_location: &OpcodeLocation) -> Vec<i64> {
+    fn find_breakpoints_at_location(&self, debug_location: &DebugLocation) -> Vec<i64> {
         let mut result = vec![];
         for (location, id) in &self.instruction_breakpoints {
-            if opcode_location == location {
+            if debug_location == location {
                 result.push(*id);
             }
         }
         for breakpoints in self.source_breakpoints.values() {
             for (location, id) in breakpoints {
-                if opcode_location == location {
+                if debug_location == location {
                     result.push(*id);
                 }
             }
@@ -404,7 +404,7 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver<FieldElement>> DapSession<
         };
 
         // compute breakpoints to set and return
-        let mut breakpoints_to_set: Vec<(OpcodeLocation, i64)> = vec![];
+        let mut breakpoints_to_set: Vec<(DebugLocation, i64)> = vec![];
         let breakpoints: Vec<Breakpoint> = args
             .breakpoints
             .iter()
@@ -420,8 +420,8 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver<FieldElement>> DapSession<
                 };
                 let Some(location) = self
                     .context
-                    .address_to_opcode_location(address)
-                    .filter(|location| self.context.is_valid_opcode_location(location))
+                    .address_to_debug_location(address)
+                    .filter(|location| self.context.is_valid_debug_location(location))
                 else {
                     return Breakpoint {
                         verified: false,
@@ -472,7 +472,7 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver<FieldElement>> DapSession<
         let Some(ref breakpoints) = &args.breakpoints else {
             return vec![];
         };
-        let mut breakpoints_to_set: Vec<(OpcodeLocation, i64)> = vec![];
+        let mut breakpoints_to_set: Vec<(DebugLocation, i64)> = vec![];
         let breakpoints = breakpoints
             .iter()
             .map(|breakpoint| {
@@ -490,14 +490,14 @@ impl<'a, R: Read, W: Write, B: BlackBoxFunctionSolver<FieldElement>> DapSession<
                 // TODO: line will not necessarily be the one requested; we
                 // should do the reverse mapping and retrieve the actual source
                 // code line number
-                if !self.context.is_valid_opcode_location(&location) {
+                if !self.context.is_valid_debug_location(&location) {
                     return Breakpoint {
                         verified: false,
                         message: Some(String::from("Invalid opcode location")),
                         ..Breakpoint::default()
                     };
                 }
-                let breakpoint_address = self.context.opcode_location_to_address(&location);
+                let breakpoint_address = self.context.debug_location_to_address(&location);
                 let instruction_reference = format!("{}", breakpoint_address);
                 let breakpoint_id = self.get_next_breakpoint_id();
                 breakpoints_to_set.push((location, breakpoint_id));
@@ -612,7 +612,7 @@ pub fn run_session<R: Read, W: Write, B: BlackBoxFunctionSolver<FieldElement>>(
     let mut session = DapSession::new(
         server,
         solver,
-        &program.program.functions[0],
+        &program.program.functions,
         &debug_artifact,
         initial_witness,
         &program.program.unconstrained_functions,
diff --git a/noir/noir-repo/tooling/debugger/src/lib.rs b/noir/noir-repo/tooling/debugger/src/lib.rs
index 9d0059ee495..37ac088ca35 100644
--- a/noir/noir-repo/tooling/debugger/src/lib.rs
+++ b/noir/noir-repo/tooling/debugger/src/lib.rs
@@ -9,23 +9,18 @@ use std::io::{Read, Write};
 
 use ::dap::errors::ServerError;
 use ::dap::server::Server;
-use acvm::acir::circuit::brillig::BrilligBytecode;
-use acvm::{acir::circuit::Circuit, acir::native_types::WitnessMap};
+use acvm::acir::native_types::{WitnessMap, WitnessStack};
 use acvm::{BlackBoxFunctionSolver, FieldElement};
 
-use noirc_artifacts::debug::DebugArtifact;
-
 use nargo::NargoError;
 use noirc_driver::CompiledProgram;
 
-pub fn debug_circuit<B: BlackBoxFunctionSolver<FieldElement>>(
-    blackbox_solver: &B,
-    circuit: &Circuit<FieldElement>,
-    debug_artifact: DebugArtifact,
+pub fn run_repl_session<B: BlackBoxFunctionSolver<FieldElement>>(
+    solver: &B,
+    program: CompiledProgram,
     initial_witness: WitnessMap<FieldElement>,
-    unconstrained_functions: &[BrilligBytecode<FieldElement>],
-) -> Result<Option<WitnessMap<FieldElement>>, NargoError<FieldElement>> {
-    repl::run(blackbox_solver, circuit, &debug_artifact, initial_witness, unconstrained_functions)
+) -> Result<Option<WitnessStack<FieldElement>>, NargoError<FieldElement>> {
+    repl::run(solver, program, initial_witness)
 }
 
 pub fn run_dap_loop<R: Read, W: Write, B: BlackBoxFunctionSolver<FieldElement>>(
diff --git a/noir/noir-repo/tooling/debugger/src/repl.rs b/noir/noir-repo/tooling/debugger/src/repl.rs
index 7d8c6e0947d..d3462985642 100644
--- a/noir/noir-repo/tooling/debugger/src/repl.rs
+++ b/noir/noir-repo/tooling/debugger/src/repl.rs
@@ -1,11 +1,12 @@
-use crate::context::{DebugCommandResult, DebugContext};
+use crate::context::{DebugCommandResult, DebugContext, DebugLocation};
 
 use acvm::acir::circuit::brillig::BrilligBytecode;
 use acvm::acir::circuit::{Circuit, Opcode, OpcodeLocation};
-use acvm::acir::native_types::{Witness, WitnessMap};
+use acvm::acir::native_types::{Witness, WitnessMap, WitnessStack};
 use acvm::brillig_vm::brillig::Opcode as BrilligOpcode;
 use acvm::{BlackBoxFunctionSolver, FieldElement};
 use nargo::NargoError;
+use noirc_driver::CompiledProgram;
 
 use crate::foreign_calls::DefaultDebugForeignCallExecutor;
 use noirc_artifacts::debug::DebugArtifact;
@@ -19,17 +20,21 @@ use crate::source_code_printer::print_source_code_location;
 pub struct ReplDebugger<'a, B: BlackBoxFunctionSolver<FieldElement>> {
     context: DebugContext<'a, B>,
     blackbox_solver: &'a B,
-    circuit: &'a Circuit<FieldElement>,
     debug_artifact: &'a DebugArtifact,
     initial_witness: WitnessMap<FieldElement>,
     last_result: DebugCommandResult,
+
+    // ACIR functions to debug
+    circuits: &'a [Circuit<FieldElement>],
+
+    // Brillig functions referenced from the ACIR circuits above
     unconstrained_functions: &'a [BrilligBytecode<FieldElement>],
 }
 
 impl<'a, B: BlackBoxFunctionSolver<FieldElement>> ReplDebugger<'a, B> {
     pub fn new(
         blackbox_solver: &'a B,
-        circuit: &'a Circuit<FieldElement>,
+        circuits: &'a [Circuit<FieldElement>],
         debug_artifact: &'a DebugArtifact,
         initial_witness: WitnessMap<FieldElement>,
         unconstrained_functions: &'a [BrilligBytecode<FieldElement>],
@@ -38,13 +43,13 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> ReplDebugger<'a, B> {
             Box::new(DefaultDebugForeignCallExecutor::from_artifact(true, debug_artifact));
         let context = DebugContext::new(
             blackbox_solver,
-            circuit,
+            circuits,
             debug_artifact,
             initial_witness.clone(),
             foreign_call_executor,
             unconstrained_functions,
         );
-        let last_result = if context.get_current_opcode_location().is_none() {
+        let last_result = if context.get_current_debug_location().is_none() {
             // handle circuit with no opcodes
             DebugCommandResult::Done
         } else {
@@ -53,7 +58,7 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> ReplDebugger<'a, B> {
         Self {
             context,
             blackbox_solver,
-            circuit,
+            circuits,
             debug_artifact,
             initial_witness,
             last_result,
@@ -62,42 +67,43 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> ReplDebugger<'a, B> {
     }
 
     pub fn show_current_vm_status(&self) {
-        let location = self.context.get_current_opcode_location();
-        let opcodes = self.context.get_opcodes();
+        let location = self.context.get_current_debug_location();
 
         match location {
             None => println!("Finished execution"),
             Some(location) => {
-                match location {
+                let circuit_id = location.circuit_id;
+                let opcodes = self.context.get_opcodes_of_circuit(circuit_id);
+                match &location.opcode_location {
                     OpcodeLocation::Acir(ip) => {
-                        println!("At opcode {}: {}", ip, opcodes[ip]);
+                        println!("At opcode {} :: {}", location, opcodes[*ip]);
                     }
                     OpcodeLocation::Brillig { acir_index, brillig_index } => {
                         let brillig_bytecode =
-                            if let Opcode::BrilligCall { id, .. } = opcodes[acir_index] {
+                            if let Opcode::BrilligCall { id, .. } = opcodes[*acir_index] {
                                 &self.unconstrained_functions[id as usize].bytecode
                             } else {
                                 unreachable!("Brillig location does not contain Brillig opcodes");
                             };
                         println!(
-                            "At opcode {}.{}: {:?}",
-                            acir_index, brillig_index, brillig_bytecode[brillig_index]
+                            "At opcode {} :: {:?}",
+                            location, brillig_bytecode[*brillig_index]
                         );
                     }
                 }
-                let locations = self.context.get_source_location_for_opcode_location(&location);
+                let locations = self.context.get_source_location_for_debug_location(&location);
                 print_source_code_location(self.debug_artifact, &locations);
             }
         }
     }
 
-    fn show_stack_frame(&self, index: usize, location: &OpcodeLocation) {
+    fn show_stack_frame(&self, index: usize, debug_location: &DebugLocation) {
         let opcodes = self.context.get_opcodes();
-        match location {
+        match &debug_location.opcode_location {
             OpcodeLocation::Acir(instruction_pointer) => {
                 println!(
-                    "Frame #{index}, opcode {}: {}",
-                    instruction_pointer, opcodes[*instruction_pointer]
+                    "Frame #{index}, opcode {} :: {}",
+                    debug_location, opcodes[*instruction_pointer]
                 )
             }
             OpcodeLocation::Brillig { acir_index, brillig_index } => {
@@ -108,12 +114,12 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> ReplDebugger<'a, B> {
                     unreachable!("Brillig location does not contain Brillig opcodes");
                 };
                 println!(
-                    "Frame #{index}, opcode {}.{}: {:?}",
-                    acir_index, brillig_index, brillig_bytecode[*brillig_index]
+                    "Frame #{index}, opcode {} :: {:?}",
+                    debug_location, brillig_bytecode[*brillig_index]
                 );
             }
         }
-        let locations = self.context.get_source_location_for_opcode_location(location);
+        let locations = self.context.get_source_location_for_debug_location(debug_location);
         print_source_code_location(self.debug_artifact, &locations);
     }
 
@@ -130,8 +136,21 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> ReplDebugger<'a, B> {
     }
 
     fn display_opcodes(&self) {
-        let opcodes = self.context.get_opcodes();
-        let current_opcode_location = self.context.get_current_opcode_location();
+        for i in 0..self.circuits.len() {
+            self.display_opcodes_of_circuit(i as u32);
+        }
+    }
+
+    fn display_opcodes_of_circuit(&self, circuit_id: u32) {
+        let current_opcode_location =
+            self.context.get_current_debug_location().and_then(|debug_location| {
+                if debug_location.circuit_id == circuit_id {
+                    Some(debug_location.opcode_location)
+                } else {
+                    None
+                }
+            });
+        let opcodes = self.context.get_opcodes_of_circuit(circuit_id);
         let current_acir_index = match current_opcode_location {
             Some(OpcodeLocation::Acir(ip)) => Some(ip),
             Some(OpcodeLocation::Brillig { acir_index, .. }) => Some(acir_index),
@@ -144,7 +163,10 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> ReplDebugger<'a, B> {
         let outer_marker = |acir_index| {
             if current_acir_index == Some(acir_index) {
                 "->"
-            } else if self.context.is_breakpoint_set(&OpcodeLocation::Acir(acir_index)) {
+            } else if self.context.is_breakpoint_set(&DebugLocation {
+                circuit_id,
+                opcode_location: OpcodeLocation::Acir(acir_index),
+            }) {
                 " *"
             } else {
                 ""
@@ -153,10 +175,10 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> ReplDebugger<'a, B> {
         let brillig_marker = |acir_index, brillig_index| {
             if current_acir_index == Some(acir_index) && brillig_index == current_brillig_index {
                 "->"
-            } else if self
-                .context
-                .is_breakpoint_set(&OpcodeLocation::Brillig { acir_index, brillig_index })
-            {
+            } else if self.context.is_breakpoint_set(&DebugLocation {
+                circuit_id,
+                opcode_location: OpcodeLocation::Brillig { acir_index, brillig_index },
+            }) {
                 " *"
             } else {
                 ""
@@ -165,7 +187,8 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> ReplDebugger<'a, B> {
         let print_brillig_bytecode = |acir_index, bytecode: &[BrilligOpcode<FieldElement>]| {
             for (brillig_index, brillig_opcode) in bytecode.iter().enumerate() {
                 println!(
-                    "{:>3}.{:<2} |{:2} {:?}",
+                    "{:>2}:{:>3}.{:<2} |{:2} {:?}",
+                    circuit_id,
                     acir_index,
                     brillig_index,
                     brillig_marker(acir_index, brillig_index),
@@ -178,33 +201,33 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> ReplDebugger<'a, B> {
             match &opcode {
                 Opcode::BrilligCall { id, inputs, outputs, .. } => {
                     println!(
-                        "{:>3} {:2} BRILLIG CALL id={} inputs={:?}",
-                        acir_index, marker, id, inputs
+                        "{:>2}:{:>3} {:2} BRILLIG CALL id={} inputs={:?}",
+                        circuit_id, acir_index, marker, id, inputs
                     );
-                    println!("       |       outputs={:?}", outputs);
+                    println!("          |       outputs={:?}", outputs);
                     let bytecode = &self.unconstrained_functions[*id as usize].bytecode;
                     print_brillig_bytecode(acir_index, bytecode);
                 }
-                _ => println!("{:>3} {:2} {:?}", acir_index, marker, opcode),
+                _ => println!("{:>2}:{:>3} {:2} {:?}", circuit_id, acir_index, marker, opcode),
             }
         }
     }
 
-    fn add_breakpoint_at(&mut self, location: OpcodeLocation) {
-        if !self.context.is_valid_opcode_location(&location) {
-            println!("Invalid opcode location {location}");
+    fn add_breakpoint_at(&mut self, location: DebugLocation) {
+        if !self.context.is_valid_debug_location(&location) {
+            println!("Invalid location {location}");
         } else if self.context.add_breakpoint(location) {
-            println!("Added breakpoint at opcode {location}");
+            println!("Added breakpoint at {location}");
         } else {
-            println!("Breakpoint at opcode {location} already set");
+            println!("Breakpoint at {location} already set");
         }
     }
 
-    fn delete_breakpoint_at(&mut self, location: OpcodeLocation) {
+    fn delete_breakpoint_at(&mut self, location: DebugLocation) {
         if self.context.delete_breakpoint(&location) {
-            println!("Breakpoint at opcode {location} deleted");
+            println!("Breakpoint at {location} deleted");
         } else {
-            println!("Breakpoint at opcode {location} not set");
+            println!("Breakpoint at {location} not set");
         }
     }
 
@@ -281,20 +304,19 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> ReplDebugger<'a, B> {
     }
 
     fn restart_session(&mut self) {
-        let breakpoints: Vec<OpcodeLocation> =
-            self.context.iterate_breakpoints().copied().collect();
+        let breakpoints: Vec<DebugLocation> = self.context.iterate_breakpoints().copied().collect();
         let foreign_call_executor =
             Box::new(DefaultDebugForeignCallExecutor::from_artifact(true, self.debug_artifact));
         self.context = DebugContext::new(
             self.blackbox_solver,
-            self.circuit,
+            self.circuits,
             self.debug_artifact,
             self.initial_witness.clone(),
             foreign_call_executor,
             self.unconstrained_functions,
         );
-        for opcode_location in breakpoints {
-            self.context.add_breakpoint(opcode_location);
+        for debug_location in breakpoints {
+            self.context.add_breakpoint(debug_location);
         }
         self.last_result = DebugCommandResult::Ok;
         println!("Restarted debugging session.");
@@ -372,21 +394,23 @@ impl<'a, B: BlackBoxFunctionSolver<FieldElement>> ReplDebugger<'a, B> {
         self.context.is_solved()
     }
 
-    fn finalize(self) -> WitnessMap<FieldElement> {
+    fn finalize(self) -> WitnessStack<FieldElement> {
         self.context.finalize()
     }
 }
 
 pub fn run<B: BlackBoxFunctionSolver<FieldElement>>(
     blackbox_solver: &B,
-    circuit: &Circuit<FieldElement>,
-    debug_artifact: &DebugArtifact,
+    program: CompiledProgram,
     initial_witness: WitnessMap<FieldElement>,
-    unconstrained_functions: &[BrilligBytecode<FieldElement>],
-) -> Result<Option<WitnessMap<FieldElement>>, NargoError<FieldElement>> {
+) -> Result<Option<WitnessStack<FieldElement>>, NargoError<FieldElement>> {
+    let circuits = &program.program.functions;
+    let debug_artifact =
+        &DebugArtifact { debug_symbols: program.debug, file_map: program.file_map };
+    let unconstrained_functions = &program.program.unconstrained_functions;
     let context = RefCell::new(ReplDebugger::new(
         blackbox_solver,
-        circuit,
+        circuits,
         debug_artifact,
         initial_witness,
         unconstrained_functions,
@@ -480,7 +504,7 @@ pub fn run<B: BlackBoxFunctionSolver<FieldElement>>(
             "break",
             command! {
                 "add a breakpoint at an opcode location",
-                (LOCATION:OpcodeLocation) => |location| {
+                (LOCATION:DebugLocation) => |location| {
                     ref_context.borrow_mut().add_breakpoint_at(location);
                     Ok(CommandStatus::Done)
                 }
@@ -490,7 +514,7 @@ pub fn run<B: BlackBoxFunctionSolver<FieldElement>>(
             "delete",
             command! {
                 "delete breakpoint at an opcode location",
-                (LOCATION:OpcodeLocation) => |location| {
+                (LOCATION:DebugLocation) => |location| {
                     ref_context.borrow_mut().delete_breakpoint_at(location);
                     Ok(CommandStatus::Done)
                 }
@@ -576,8 +600,8 @@ pub fn run<B: BlackBoxFunctionSolver<FieldElement>>(
     drop(repl);
 
     if context.borrow().is_solved() {
-        let solved_witness = context.into_inner().finalize();
-        Ok(Some(solved_witness))
+        let solved_witness_stack = context.into_inner().finalize();
+        Ok(Some(solved_witness_stack))
     } else {
         Ok(None)
     }
diff --git a/noir/noir-repo/tooling/debugger/tests/debug.rs b/noir/noir-repo/tooling/debugger/tests/debug.rs
index 313b6b30591..2dca6b95f0e 100644
--- a/noir/noir-repo/tooling/debugger/tests/debug.rs
+++ b/noir/noir-repo/tooling/debugger/tests/debug.rs
@@ -12,7 +12,7 @@ mod tests {
         let nargo_bin =
             cargo_bin("nargo").into_os_string().into_string().expect("Cannot parse nargo path");
 
-        let timeout_seconds = 20;
+        let timeout_seconds = 25;
         let mut dbg_session =
             spawn_bash(Some(timeout_seconds * 1000)).expect("Could not start bash session");
 
diff --git a/noir/noir-repo/tooling/lsp/src/lib.rs b/noir/noir-repo/tooling/lsp/src/lib.rs
index e91e0fb3325..542876d6319 100644
--- a/noir/noir-repo/tooling/lsp/src/lib.rs
+++ b/noir/noir-repo/tooling/lsp/src/lib.rs
@@ -21,7 +21,7 @@ use async_lsp::{
 use fm::{codespan_files as files, FileManager};
 use fxhash::FxHashSet;
 use lsp_types::{
-    request::{PrepareRenameRequest, References, Rename},
+    request::{HoverRequest, PrepareRenameRequest, References, Rename},
     CodeLens,
 };
 use nargo::{
@@ -46,7 +46,7 @@ use notifications::{
 };
 use requests::{
     on_code_lens_request, on_formatting, on_goto_declaration_request, on_goto_definition_request,
-    on_goto_type_definition_request, on_initialize, on_prepare_rename_request,
+    on_goto_type_definition_request, on_hover_request, on_initialize, on_prepare_rename_request,
     on_profile_run_request, on_references_request, on_rename_request, on_shutdown,
     on_test_run_request, on_tests_request,
 };
@@ -129,6 +129,7 @@ impl NargoLspService {
             .request::<References, _>(on_references_request)
             .request::<PrepareRenameRequest, _>(on_prepare_rename_request)
             .request::<Rename, _>(on_rename_request)
+            .request::<HoverRequest, _>(on_hover_request)
             .notification::<notification::Initialized>(on_initialized)
             .notification::<notification::DidChangeConfiguration>(on_did_change_configuration)
             .notification::<notification::DidOpenTextDocument>(on_did_open_text_document)
@@ -282,6 +283,7 @@ pub(crate) fn resolve_workspace_for_source_path(
         name: CrateName::from_str(parent_folder)
             .map_err(|err| LspError::WorkspaceResolutionError(err.to_string()))?,
         dependencies: BTreeMap::new(),
+        expression_width: None,
     };
     let workspace = Workspace {
         root_dir: PathBuf::from(parent_folder),
diff --git a/noir/noir-repo/tooling/lsp/src/requests/code_lens_request.rs b/noir/noir-repo/tooling/lsp/src/requests/code_lens_request.rs
index 11ea4fa74bf..9f621a489c3 100644
--- a/noir/noir-repo/tooling/lsp/src/requests/code_lens_request.rs
+++ b/noir/noir-repo/tooling/lsp/src/requests/code_lens_request.rs
@@ -21,6 +21,8 @@ const INFO_COMMAND: &str = "nargo.info";
 const INFO_CODELENS_TITLE: &str = "Info";
 const EXECUTE_COMMAND: &str = "nargo.execute";
 const EXECUTE_CODELENS_TITLE: &str = "Execute";
+const DEBUG_COMMAND: &str = "nargo.debug.dap";
+const DEBUG_CODELENS_TITLE: &str = "Debug";
 
 const PROFILE_COMMAND: &str = "nargo.profile";
 const PROFILE_CODELENS_TITLE: &str = "Profile";
@@ -158,35 +160,22 @@ pub(crate) fn collect_lenses_for_package(
 
             lenses.push(compile_lens);
 
-            let info_command = Command {
-                title: INFO_CODELENS_TITLE.to_string(),
-                command: INFO_COMMAND.into(),
-                arguments: Some(package_selection_args(workspace, package)),
-            };
-
-            let info_lens = CodeLens { range, command: Some(info_command), data: None };
-
-            lenses.push(info_lens);
-
-            let execute_command = Command {
-                title: EXECUTE_CODELENS_TITLE.to_string(),
-                command: EXECUTE_COMMAND.into(),
-                arguments: Some(package_selection_args(workspace, package)),
-            };
-
-            let execute_lens = CodeLens { range, command: Some(execute_command), data: None };
-
-            lenses.push(execute_lens);
-
-            let profile_command = Command {
-                title: PROFILE_CODELENS_TITLE.to_string(),
-                command: PROFILE_COMMAND.into(),
-                arguments: Some(package_selection_args(workspace, package)),
-            };
-
-            let profile_lens = CodeLens { range, command: Some(profile_command), data: None };
-
-            lenses.push(profile_lens);
+            let internal_command_lenses = [
+                (INFO_CODELENS_TITLE, INFO_COMMAND),
+                (EXECUTE_CODELENS_TITLE, EXECUTE_COMMAND),
+                (PROFILE_CODELENS_TITLE, PROFILE_COMMAND),
+                (DEBUG_CODELENS_TITLE, DEBUG_COMMAND),
+            ]
+            .map(|(title, command)| {
+                let command = Command {
+                    title: title.to_string(),
+                    command: command.into(),
+                    arguments: Some(package_selection_args(workspace, package)),
+                };
+                CodeLens { range, command: Some(command), data: None }
+            });
+
+            lenses.append(&mut Vec::from(internal_command_lenses));
         }
     }
 
diff --git a/noir/noir-repo/tooling/lsp/src/requests/goto_declaration.rs b/noir/noir-repo/tooling/lsp/src/requests/goto_declaration.rs
index 1f87f2c87d4..bd0f0afb827 100644
--- a/noir/noir-repo/tooling/lsp/src/requests/goto_declaration.rs
+++ b/noir/noir-repo/tooling/lsp/src/requests/goto_declaration.rs
@@ -20,10 +20,10 @@ fn on_goto_definition_inner(
     state: &mut LspState,
     params: GotoDeclarationParams,
 ) -> Result<GotoDeclarationResult, ResponseError> {
-    process_request(state, params.text_document_position_params, |location, interner, files, _| {
-        interner.get_declaration_location_from(location).and_then(|found_location| {
+    process_request(state, params.text_document_position_params, |args| {
+        args.interner.get_declaration_location_from(args.location).and_then(|found_location| {
             let file_id = found_location.file;
-            let definition_position = to_lsp_location(files, file_id, found_location.span)?;
+            let definition_position = to_lsp_location(args.files, file_id, found_location.span)?;
             let response = GotoDeclarationResponse::from(definition_position).to_owned();
             Some(response)
         })
diff --git a/noir/noir-repo/tooling/lsp/src/requests/goto_definition.rs b/noir/noir-repo/tooling/lsp/src/requests/goto_definition.rs
index 27d3503a2fd..72fac676a72 100644
--- a/noir/noir-repo/tooling/lsp/src/requests/goto_definition.rs
+++ b/noir/noir-repo/tooling/lsp/src/requests/goto_definition.rs
@@ -29,15 +29,16 @@ fn on_goto_definition_inner(
     params: GotoDefinitionParams,
     return_type_location_instead: bool,
 ) -> Result<GotoDefinitionResult, ResponseError> {
-    process_request(state, params.text_document_position_params, |location, interner, files, _| {
-        interner.get_definition_location_from(location, return_type_location_instead).and_then(
-            |found_location| {
+    process_request(state, params.text_document_position_params, |args| {
+        args.interner
+            .get_definition_location_from(args.location, return_type_location_instead)
+            .and_then(|found_location| {
                 let file_id = found_location.file;
-                let definition_position = to_lsp_location(files, file_id, found_location.span)?;
+                let definition_position =
+                    to_lsp_location(args.files, file_id, found_location.span)?;
                 let response = GotoDefinitionResponse::from(definition_position).to_owned();
                 Some(response)
-            },
-        )
+            })
     })
 }
 
diff --git a/noir/noir-repo/tooling/lsp/src/requests/hover.rs b/noir/noir-repo/tooling/lsp/src/requests/hover.rs
new file mode 100644
index 00000000000..161fd20f555
--- /dev/null
+++ b/noir/noir-repo/tooling/lsp/src/requests/hover.rs
@@ -0,0 +1,641 @@
+use std::future::{self, Future};
+
+use async_lsp::ResponseError;
+use lsp_types::{Hover, HoverContents, HoverParams, MarkupContent, MarkupKind};
+use noirc_frontend::{
+    ast::Visibility,
+    graph::CrateId,
+    hir::def_map::ModuleId,
+    hir_def::stmt::HirPattern,
+    macros_api::{NodeInterner, StructId},
+    node_interner::{
+        DefinitionId, DefinitionKind, FuncId, GlobalId, ReferenceId, TraitId, TypeAliasId,
+    },
+    Generics, Type,
+};
+
+use crate::LspState;
+
+use super::{process_request, to_lsp_location, ProcessRequestCallbackArgs};
+
+pub(crate) fn on_hover_request(
+    state: &mut LspState,
+    params: HoverParams,
+) -> impl Future<Output = Result<Option<Hover>, ResponseError>> {
+    let result = process_request(state, params.text_document_position_params, |args| {
+        args.interner.reference_at_location(args.location).map(|reference| {
+            let location = args.interner.reference_location(reference);
+            let lsp_location = to_lsp_location(args.files, location.file, location.span);
+            Hover {
+                range: lsp_location.map(|location| location.range),
+                contents: HoverContents::Markup(MarkupContent {
+                    kind: MarkupKind::Markdown,
+                    value: format_reference(reference, &args),
+                }),
+            }
+        })
+    });
+
+    future::ready(result)
+}
+
+fn format_reference(reference: ReferenceId, args: &ProcessRequestCallbackArgs) -> String {
+    match reference {
+        ReferenceId::Module(id) => format_module(id, args),
+        ReferenceId::Struct(id) => format_struct(id, args),
+        ReferenceId::StructMember(id, field_index) => format_struct_member(id, field_index, args),
+        ReferenceId::Trait(id) => format_trait(id, args),
+        ReferenceId::Global(id) => format_global(id, args),
+        ReferenceId::Function(id) => format_function(id, args),
+        ReferenceId::Alias(id) => format_alias(id, args),
+        ReferenceId::Local(id) => format_local(id, args),
+        ReferenceId::Reference(location, _) => {
+            format_reference(args.interner.find_referenced(location).unwrap(), args)
+        }
+    }
+}
+fn format_module(id: ModuleId, args: &ProcessRequestCallbackArgs) -> String {
+    let module_attributes = args.interner.module_attributes(&id);
+
+    let mut string = String::new();
+    if format_parent_module_from_module_id(
+        &ModuleId { krate: id.krate, local_id: module_attributes.parent },
+        args,
+        &mut string,
+    ) {
+        string.push('\n');
+    }
+    string.push_str("    ");
+    string.push_str("mod ");
+    string.push_str(&module_attributes.name);
+    string
+}
+
+fn format_struct(id: StructId, args: &ProcessRequestCallbackArgs) -> String {
+    let struct_type = args.interner.get_struct(id);
+    let struct_type = struct_type.borrow();
+
+    let mut string = String::new();
+    if format_parent_module(ReferenceId::Struct(id), args, &mut string) {
+        string.push('\n');
+    }
+    string.push_str("    ");
+    string.push_str("struct ");
+    string.push_str(&struct_type.name.0.contents);
+    format_generics(&struct_type.generics, &mut string);
+    string.push_str(" {\n");
+    for (field_name, field_type) in struct_type.get_fields_as_written() {
+        string.push_str("        ");
+        string.push_str(&field_name);
+        string.push_str(": ");
+        string.push_str(&format!("{}", field_type));
+        string.push_str(",\n");
+    }
+    string.push_str("    }");
+    string
+}
+
+fn format_struct_member(
+    id: StructId,
+    field_index: usize,
+    args: &ProcessRequestCallbackArgs,
+) -> String {
+    let struct_type = args.interner.get_struct(id);
+    let struct_type = struct_type.borrow();
+    let (field_name, field_type) = struct_type.field_at(field_index);
+
+    let mut string = String::new();
+    if format_parent_module(ReferenceId::Struct(id), args, &mut string) {
+        string.push_str("::");
+    }
+    string.push_str(&struct_type.name.0.contents);
+    string.push('\n');
+    string.push_str("    ");
+    string.push_str(&field_name.0.contents);
+    string.push_str(": ");
+    string.push_str(&format!("{}", field_type));
+    string
+}
+
+fn format_trait(id: TraitId, args: &ProcessRequestCallbackArgs) -> String {
+    let a_trait = args.interner.get_trait(id);
+
+    let mut string = String::new();
+    if format_parent_module(ReferenceId::Trait(id), args, &mut string) {
+        string.push('\n');
+    }
+    string.push_str("    ");
+    string.push_str("trait ");
+    string.push_str(&a_trait.name.0.contents);
+    format_generics(&a_trait.generics, &mut string);
+    string
+}
+
+fn format_global(id: GlobalId, args: &ProcessRequestCallbackArgs) -> String {
+    let global_info = args.interner.get_global(id);
+    let definition_id = global_info.definition_id;
+    let typ = args.interner.definition_type(definition_id);
+
+    let mut string = String::new();
+    if format_parent_module(ReferenceId::Global(id), args, &mut string) {
+        string.push('\n');
+    }
+    string.push_str("    ");
+    string.push_str("global ");
+    string.push_str(&global_info.ident.0.contents);
+    string.push_str(": ");
+    string.push_str(&format!("{}", typ));
+    string
+}
+
+fn format_function(id: FuncId, args: &ProcessRequestCallbackArgs) -> String {
+    let func_meta = args.interner.function_meta(&id);
+    let func_name_definition_id = args.interner.definition(func_meta.name.id);
+
+    let mut string = String::new();
+    let formatted_parent_module =
+        format_parent_module(ReferenceId::Function(id), args, &mut string);
+    let formatted_parent_struct = if let Some(struct_id) = func_meta.struct_id {
+        let struct_type = args.interner.get_struct(struct_id);
+        let struct_type = struct_type.borrow();
+        if formatted_parent_module {
+            string.push_str("::");
+        }
+        string.push_str(&struct_type.name.0.contents);
+        true
+    } else {
+        false
+    };
+    if formatted_parent_module || formatted_parent_struct {
+        string.push('\n');
+    }
+    string.push_str("    ");
+    string.push_str("fn ");
+    string.push_str(&func_name_definition_id.name);
+    format_generics(&func_meta.direct_generics, &mut string);
+    string.push('(');
+    let parameters = &func_meta.parameters;
+    for (index, (pattern, typ, visibility)) in parameters.iter().enumerate() {
+        format_pattern(pattern, args.interner, &mut string);
+        if !pattern_is_self(pattern, args.interner) {
+            string.push_str(": ");
+            if matches!(visibility, Visibility::Public) {
+                string.push_str("pub ");
+            }
+            string.push_str(&format!("{}", typ));
+        }
+        if index != parameters.len() - 1 {
+            string.push_str(", ");
+        }
+    }
+
+    string.push(')');
+
+    let return_type = func_meta.return_type();
+    match return_type {
+        Type::Unit => (),
+        _ => {
+            string.push_str(" -> ");
+            string.push_str(&format!("{}", return_type));
+        }
+    }
+
+    string
+}
+
+fn format_alias(id: TypeAliasId, args: &ProcessRequestCallbackArgs) -> String {
+    let type_alias = args.interner.get_type_alias(id);
+    let type_alias = type_alias.borrow();
+
+    let mut string = String::new();
+    format_parent_module(ReferenceId::Alias(id), args, &mut string);
+    string.push('\n');
+    string.push_str("    ");
+    string.push_str("type ");
+    string.push_str(&type_alias.name.0.contents);
+    string.push_str(" = ");
+    string.push_str(&format!("{}", &type_alias.typ));
+    string
+}
+
+fn format_local(id: DefinitionId, args: &ProcessRequestCallbackArgs) -> String {
+    let definition_info = args.interner.definition(id);
+    let DefinitionKind::Local(expr_id) = definition_info.kind else {
+        panic!("Expected a local reference to reference a local definition")
+    };
+    let typ = args.interner.definition_type(id);
+
+    let mut string = String::new();
+    string.push_str("    ");
+    if definition_info.comptime {
+        string.push_str("comptime ");
+    }
+    if expr_id.is_some() {
+        string.push_str("let ");
+    }
+    if definition_info.mutable {
+        if expr_id.is_none() {
+            string.push_str("let ");
+        }
+        string.push_str("mut ");
+    }
+    string.push_str(&definition_info.name);
+    if !matches!(typ, Type::Error) {
+        string.push_str(": ");
+        string.push_str(&format!("{}", typ));
+    }
+    string
+}
+
+fn format_generics(generics: &Generics, string: &mut String) {
+    if generics.is_empty() {
+        return;
+    }
+
+    string.push('<');
+    for (index, generic) in generics.iter().enumerate() {
+        string.push_str(&generic.name);
+        if index != generics.len() - 1 {
+            string.push_str(", ");
+        }
+    }
+    string.push('>');
+}
+fn format_pattern(pattern: &HirPattern, interner: &NodeInterner, string: &mut String) {
+    match pattern {
+        HirPattern::Identifier(ident) => {
+            let definition = interner.definition(ident.id);
+            string.push_str(&definition.name);
+        }
+        HirPattern::Mutable(pattern, _) => {
+            string.push_str("mut ");
+            format_pattern(pattern, interner, string);
+        }
+        HirPattern::Tuple(..) | HirPattern::Struct(..) => {
+            string.push('_');
+        }
+    }
+}
+
+fn pattern_is_self(pattern: &HirPattern, interner: &NodeInterner) -> bool {
+    match pattern {
+        HirPattern::Identifier(ident) => {
+            let definition = interner.definition(ident.id);
+            definition.name == "self"
+        }
+        HirPattern::Mutable(pattern, _) => pattern_is_self(pattern, interner),
+        HirPattern::Tuple(..) | HirPattern::Struct(..) => false,
+    }
+}
+
+fn format_parent_module(
+    referenced: ReferenceId,
+    args: &ProcessRequestCallbackArgs,
+    string: &mut String,
+) -> bool {
+    let Some(module) = args.interner.reference_module(referenced) else {
+        return false;
+    };
+
+    format_parent_module_from_module_id(module, args, string)
+}
+
+fn format_parent_module_from_module_id(
+    module: &ModuleId,
+    args: &ProcessRequestCallbackArgs,
+    string: &mut String,
+) -> bool {
+    let crate_id = module.krate;
+    let crate_name = match crate_id {
+        CrateId::Root(_) => Some(args.root_crate_name.clone()),
+        CrateId::Crate(_) => args
+            .root_crate_dependencies
+            .iter()
+            .find(|dep| dep.crate_id == crate_id)
+            .map(|dep| format!("{}", dep.name)),
+        CrateId::Stdlib(_) => Some("std".to_string()),
+        CrateId::Dummy => None,
+    };
+
+    let wrote_crate = if let Some(crate_name) = crate_name {
+        string.push_str("    ");
+        string.push_str(&crate_name);
+        true
+    } else {
+        false
+    };
+
+    let Some(module_attributes) = args.interner.try_module_attributes(module) else {
+        return wrote_crate;
+    };
+
+    if wrote_crate {
+        string.push_str("::");
+    } else {
+        string.push_str("    ");
+    }
+
+    let mut segments = Vec::new();
+    let mut current_attributes = module_attributes;
+    while let Some(parent_attributes) = args.interner.try_module_attributes(&ModuleId {
+        krate: module.krate,
+        local_id: current_attributes.parent,
+    }) {
+        segments.push(&parent_attributes.name);
+        current_attributes = parent_attributes;
+    }
+
+    for segment in segments.iter().rev() {
+        string.push_str(segment);
+        string.push_str("::");
+    }
+
+    string.push_str(&module_attributes.name);
+
+    true
+}
+
+#[cfg(test)]
+mod hover_tests {
+    use crate::test_utils;
+
+    use super::*;
+    use lsp_types::{
+        Position, TextDocumentIdentifier, TextDocumentPositionParams, Url, WorkDoneProgressParams,
+    };
+    use tokio::test;
+
+    async fn assert_hover(directory: &str, file: &str, position: Position, expected_text: &str) {
+        let (mut state, noir_text_document) = test_utils::init_lsp_server(directory).await;
+
+        // noir_text_document is always `src/main.nr` in the workspace directory, so let's go to the workspace dir
+        let noir_text_document = noir_text_document.to_file_path().unwrap();
+        let workspace_dir = noir_text_document.parent().unwrap().parent().unwrap();
+
+        let file_uri = Url::from_file_path(workspace_dir.join(file)).unwrap();
+
+        let hover = on_hover_request(
+            &mut state,
+            HoverParams {
+                text_document_position_params: TextDocumentPositionParams {
+                    text_document: TextDocumentIdentifier { uri: file_uri },
+                    position,
+                },
+                work_done_progress_params: WorkDoneProgressParams { work_done_token: None },
+            },
+        )
+        .await
+        .expect("Could not execute hover")
+        .unwrap();
+
+        let HoverContents::Markup(markup) = hover.contents else {
+            panic!("Expected hover contents to be Markup");
+        };
+
+        assert_eq!(markup.value, expected_text);
+    }
+
+    #[test]
+    async fn hover_on_module() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 6, character: 9 },
+            r#"    one
+    mod subone"#,
+        )
+        .await;
+    }
+
+    #[test]
+    async fn hover_on_struct() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 9, character: 20 },
+            r#"    one::subone
+    struct SubOneStruct {
+        some_field: i32,
+        some_other_field: Field,
+    }"#,
+        )
+        .await;
+    }
+
+    #[test]
+    async fn hover_on_generic_struct() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 46, character: 17 },
+            r#"    one::subone
+    struct GenericStruct<A, B> {
+    }"#,
+        )
+        .await;
+    }
+
+    #[test]
+    async fn hover_on_struct_member() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 9, character: 35 },
+            r#"    one::subone::SubOneStruct
+    some_field: i32"#,
+        )
+        .await;
+    }
+
+    #[test]
+    async fn hover_on_trait() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 12, character: 17 },
+            r#"    one::subone
+    trait SomeTrait"#,
+        )
+        .await;
+    }
+
+    #[test]
+    async fn hover_on_global() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 15, character: 25 },
+            r#"    one::subone
+    global some_global: Field"#,
+        )
+        .await;
+    }
+
+    #[test]
+    async fn hover_on_function() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 3, character: 4 },
+            r#"    one
+    fn function_one<A, B>()"#,
+        )
+        .await;
+    }
+
+    #[test]
+    async fn hover_on_local_function() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 2, character: 7 },
+            r#"    two
+    fn function_two()"#,
+        )
+        .await;
+    }
+
+    #[test]
+    async fn hover_on_struct_method() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 20, character: 6 },
+            r#"    one::subone::SubOneStruct
+    fn foo(self, x: i32, y: i32) -> Field"#,
+        )
+        .await;
+    }
+
+    #[test]
+    async fn hover_on_local_var() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 25, character: 12 },
+            "    let regular_var: Field",
+        )
+        .await;
+    }
+
+    #[test]
+    async fn hover_on_local_mut_var() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 27, character: 4 },
+            "    let mut mutable_var: Field",
+        )
+        .await;
+    }
+
+    #[test]
+    async fn hover_on_parameter() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 31, character: 12 },
+            "    some_param: i32",
+        )
+        .await;
+    }
+
+    #[test]
+    async fn hover_on_alias() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 34, character: 17 },
+            r#"    one::subone
+    type SomeAlias = i32"#,
+        )
+        .await;
+    }
+
+    #[test]
+    async fn hover_on_trait_on_call() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 39, character: 17 },
+            r#"    std::default
+    trait Default"#,
+        )
+        .await;
+    }
+
+    #[test]
+    async fn hover_on_std_module_in_use() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 36, character: 9 },
+            r#"    std
+    mod default"#,
+        )
+        .await;
+    }
+
+    #[test]
+    async fn hover_on_crate_module_in_call() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 15, character: 17 },
+            r#"    one
+    mod subone"#,
+        )
+        .await;
+    }
+
+    #[test]
+    async fn hover_on_module_without_crate_or_std_prefix() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 43, character: 4 },
+            r#"    two
+    mod other"#,
+        )
+        .await;
+    }
+
+    #[test]
+    async fn hover_on_module_with_crate_prefix() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 44, character: 11 },
+            r#"    two
+    mod other"#,
+        )
+        .await;
+    }
+
+    #[test]
+    async fn hover_on_module_on_struct_constructor() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 19, character: 12 },
+            r#"    one
+    mod subone"#,
+        )
+        .await;
+    }
+
+    #[test]
+    async fn hover_on_type_inside_generic_arguments() {
+        assert_hover(
+            "workspace",
+            "two/src/lib.nr",
+            Position { line: 51, character: 30 },
+            r#"    one::subone
+    struct SubOneStruct {
+        some_field: i32,
+        some_other_field: Field,
+    }"#,
+        )
+        .await;
+    }
+}
diff --git a/noir/noir-repo/tooling/lsp/src/requests/mod.rs b/noir/noir-repo/tooling/lsp/src/requests/mod.rs
index 9ece797a57a..e029750e589 100644
--- a/noir/noir-repo/tooling/lsp/src/requests/mod.rs
+++ b/noir/noir-repo/tooling/lsp/src/requests/mod.rs
@@ -14,7 +14,7 @@ use lsp_types::{
 use nargo::insert_all_files_for_workspace_into_file_manager;
 use nargo_fmt::Config;
 use noirc_driver::file_manager_with_stdlib;
-use noirc_frontend::macros_api::NodeInterner;
+use noirc_frontend::{graph::Dependency, macros_api::NodeInterner};
 use serde::{Deserialize, Serialize};
 
 use crate::{
@@ -35,6 +35,7 @@ use crate::{
 mod code_lens_request;
 mod goto_declaration;
 mod goto_definition;
+mod hover;
 mod profile_run;
 mod references;
 mod rename;
@@ -44,9 +45,10 @@ mod tests;
 pub(crate) use {
     code_lens_request::collect_lenses_for_package, code_lens_request::on_code_lens_request,
     goto_declaration::on_goto_declaration_request, goto_definition::on_goto_definition_request,
-    goto_definition::on_goto_type_definition_request, profile_run::on_profile_run_request,
-    references::on_references_request, rename::on_prepare_rename_request,
-    rename::on_rename_request, test_run::on_test_run_request, tests::on_tests_request,
+    goto_definition::on_goto_type_definition_request, hover::on_hover_request,
+    profile_run::on_profile_run_request, references::on_references_request,
+    rename::on_prepare_rename_request, rename::on_rename_request, test_run::on_test_run_request,
+    tests::on_tests_request,
 };
 
 /// LSP client will send initialization request after the server has started.
@@ -127,6 +129,11 @@ pub(crate) fn on_initialize(
                         work_done_progress: None,
                     },
                 })),
+                hover_provider: Some(lsp_types::OneOf::Right(lsp_types::HoverOptions {
+                    work_done_progress_options: WorkDoneProgressOptions {
+                        work_done_progress: None,
+                    },
+                })),
             },
             server_info: None,
         })
@@ -264,13 +271,22 @@ pub(crate) fn on_shutdown(
     async { Ok(()) }
 }
 
+pub(crate) struct ProcessRequestCallbackArgs<'a> {
+    location: noirc_errors::Location,
+    files: &'a FileMap,
+    interner: &'a NodeInterner,
+    interners: &'a HashMap<String, NodeInterner>,
+    root_crate_name: String,
+    root_crate_dependencies: &'a Vec<Dependency>,
+}
+
 pub(crate) fn process_request<F, T>(
     state: &mut LspState,
     text_document_position_params: TextDocumentPositionParams,
     callback: F,
 ) -> Result<T, ResponseError>
 where
-    F: FnOnce(noirc_errors::Location, &NodeInterner, &FileMap, &HashMap<String, NodeInterner>) -> T,
+    F: FnOnce(ProcessRequestCallbackArgs) -> T,
 {
     let file_path =
         text_document_position_params.text_document.uri.to_file_path().map_err(|_| {
@@ -309,7 +325,14 @@ where
         &text_document_position_params.position,
     )?;
 
-    Ok(callback(location, interner, files, &state.cached_definitions))
+    Ok(callback(ProcessRequestCallbackArgs {
+        location,
+        files,
+        interner,
+        interners: &state.cached_definitions,
+        root_crate_name: package.name.to_string(),
+        root_crate_dependencies: &context.crate_graph[context.root_crate_id()].dependencies,
+    }))
 }
 pub(crate) fn find_all_references_in_workspace(
     location: noirc_errors::Location,
diff --git a/noir/noir-repo/tooling/lsp/src/requests/references.rs b/noir/noir-repo/tooling/lsp/src/requests/references.rs
index 6c872656c28..badea8921b2 100644
--- a/noir/noir-repo/tooling/lsp/src/requests/references.rs
+++ b/noir/noir-repo/tooling/lsp/src/requests/references.rs
@@ -12,20 +12,16 @@ pub(crate) fn on_references_request(
     params: ReferenceParams,
 ) -> impl Future<Output = Result<Option<Vec<Location>>, ResponseError>> {
     let include_declaration = params.context.include_declaration;
-    let result = process_request(
-        state,
-        params.text_document_position,
-        |location, interner, files, cached_interners| {
-            find_all_references_in_workspace(
-                location,
-                interner,
-                cached_interners,
-                files,
-                include_declaration,
-                true,
-            )
-        },
-    );
+    let result = process_request(state, params.text_document_position, |args| {
+        find_all_references_in_workspace(
+            args.location,
+            args.interner,
+            args.interners,
+            args.files,
+            include_declaration,
+            true,
+        )
+    });
     future::ready(result)
 }
 
diff --git a/noir/noir-repo/tooling/lsp/src/requests/rename.rs b/noir/noir-repo/tooling/lsp/src/requests/rename.rs
index 245c2ed0882..84956681167 100644
--- a/noir/noir-repo/tooling/lsp/src/requests/rename.rs
+++ b/noir/noir-repo/tooling/lsp/src/requests/rename.rs
@@ -17,8 +17,8 @@ pub(crate) fn on_prepare_rename_request(
     state: &mut LspState,
     params: TextDocumentPositionParams,
 ) -> impl Future<Output = Result<Option<PrepareRenameResponse>, ResponseError>> {
-    let result = process_request(state, params, |location, interner, _, _| {
-        let reference_id = interner.reference_at_location(location);
+    let result = process_request(state, params, |args| {
+        let reference_id = args.interner.reference_at_location(args.location);
         let rename_possible = match reference_id {
             // Rename shouldn't be possible when triggered on top of "Self"
             Some(ReferenceId::Reference(_, true /* is self type name */)) => false,
@@ -34,40 +34,36 @@ pub(crate) fn on_rename_request(
     state: &mut LspState,
     params: RenameParams,
 ) -> impl Future<Output = Result<Option<WorkspaceEdit>, ResponseError>> {
-    let result = process_request(
-        state,
-        params.text_document_position,
-        |location, interner, files, cached_interners| {
-            let rename_changes = find_all_references_in_workspace(
-                location,
-                interner,
-                cached_interners,
-                files,
-                true,
-                false,
-            )
-            .map(|locations| {
-                let rs = locations.iter().fold(
-                    HashMap::new(),
-                    |mut acc: HashMap<Url, Vec<TextEdit>>, location| {
-                        let edit =
-                            TextEdit { range: location.range, new_text: params.new_name.clone() };
-                        acc.entry(location.uri.clone()).or_default().push(edit);
-                        acc
-                    },
-                );
-                rs
-            });
-
-            let response = WorkspaceEdit {
-                changes: rename_changes,
-                document_changes: None,
-                change_annotations: None,
-            };
+    let result = process_request(state, params.text_document_position, |args| {
+        let rename_changes = find_all_references_in_workspace(
+            args.location,
+            args.interner,
+            args.interners,
+            args.files,
+            true,
+            false,
+        )
+        .map(|locations| {
+            let rs = locations.iter().fold(
+                HashMap::new(),
+                |mut acc: HashMap<Url, Vec<TextEdit>>, location| {
+                    let edit =
+                        TextEdit { range: location.range, new_text: params.new_name.clone() };
+                    acc.entry(location.uri.clone()).or_default().push(edit);
+                    acc
+                },
+            );
+            rs
+        });
+
+        let response = WorkspaceEdit {
+            changes: rename_changes,
+            document_changes: None,
+            change_annotations: None,
+        };
 
-            Some(response)
-        },
-    );
+        Some(response)
+    });
     future::ready(result)
 }
 
@@ -174,6 +170,11 @@ mod rename_tests {
         check_rename_succeeds("rename_function_use", "some_function").await;
     }
 
+    #[test]
+    async fn test_rename_method() {
+        check_rename_succeeds("rename_function", "some_method").await;
+    }
+
     #[test]
     async fn test_rename_struct() {
         check_rename_succeeds("rename_struct", "Foo").await;
diff --git a/noir/noir-repo/tooling/lsp/src/types.rs b/noir/noir-repo/tooling/lsp/src/types.rs
index 57eb2dd3618..991773ce94f 100644
--- a/noir/noir-repo/tooling/lsp/src/types.rs
+++ b/noir/noir-repo/tooling/lsp/src/types.rs
@@ -1,7 +1,7 @@
 use fm::FileId;
 use lsp_types::{
-    DeclarationCapability, DefinitionOptions, OneOf, ReferencesOptions, RenameOptions,
-    TypeDefinitionProviderCapability,
+    DeclarationCapability, DefinitionOptions, HoverOptions, OneOf, ReferencesOptions,
+    RenameOptions, TypeDefinitionProviderCapability,
 };
 use noirc_driver::DebugFile;
 use noirc_errors::{debug_info::OpCodesCount, Location};
@@ -144,6 +144,10 @@ pub(crate) struct ServerCapabilities {
     /// The server provides references support.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub(crate) references_provider: Option<OneOf<bool, ReferencesOptions>>,
+
+    /// The server provides hover support.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub(crate) hover_provider: Option<OneOf<bool, HoverOptions>>,
 }
 
 #[derive(Debug, PartialEq, Clone, Default, Deserialize, Serialize)]
diff --git a/noir/noir-repo/tooling/lsp/test_programs/rename_function/src/main.nr b/noir/noir-repo/tooling/lsp/test_programs/rename_function/src/main.nr
index 7a70084276e..e77b50c0b26 100644
--- a/noir/noir-repo/tooling/lsp/test_programs/rename_function/src/main.nr
+++ b/noir/noir-repo/tooling/lsp/test_programs/rename_function/src/main.nr
@@ -25,3 +25,16 @@ use foo::some_other_function as bar;
 fn x() {
     bar();
 }
+
+struct SomeStruct {
+
+}
+
+impl SomeStruct {
+    fn some_method(self) {}
+}
+
+fn y() {
+    let some_struct = SomeStruct {};
+    some_struct.some_method();
+}
diff --git a/noir/noir-repo/tooling/lsp/test_programs/workspace/one/src/lib.nr b/noir/noir-repo/tooling/lsp/test_programs/workspace/one/src/lib.nr
index d4f660e35fb..61f282fa2a7 100644
--- a/noir/noir-repo/tooling/lsp/test_programs/workspace/one/src/lib.nr
+++ b/noir/noir-repo/tooling/lsp/test_programs/workspace/one/src/lib.nr
@@ -1 +1,25 @@
-pub fn function_one() {}
+pub fn function_one<A, B>() {}
+
+mod subone {
+    struct SubOneStruct {
+        some_field: i32,
+        some_other_field: Field,
+    }
+
+    impl SubOneStruct {
+        fn foo(self, x: i32, y: i32) -> Field {
+            0
+        }
+    }
+
+    trait SomeTrait {
+    }
+
+    global some_global = 2;
+
+    type SomeAlias = i32;
+
+    struct GenericStruct<A, B> {
+
+    }
+}
diff --git a/noir/noir-repo/tooling/lsp/test_programs/workspace/two/src/lib.nr b/noir/noir-repo/tooling/lsp/test_programs/workspace/two/src/lib.nr
index adf7079b4c9..3f0f0f117b7 100644
--- a/noir/noir-repo/tooling/lsp/test_programs/workspace/two/src/lib.nr
+++ b/noir/noir-repo/tooling/lsp/test_programs/workspace/two/src/lib.nr
@@ -3,3 +3,51 @@ use one::function_one;
 pub fn function_two() {
     function_one()
 }
+
+use one::subone;
+
+fn use_struct() {
+    let _ = subone::SubOneStruct { some_field: 0, some_other_field: 2 };
+}
+
+use one::subone::SomeTrait;
+
+fn use_global() {
+    let _ = one::subone::some_global;
+}
+
+fn use_struct_method() {
+    let s = subone::SubOneStruct { some_field: 0, some_other_field: 2 };
+    s.foo(0, 1);
+}
+
+fn use_local_var() {
+    let regular_var = 0;
+    let _ = regular_var;
+    let mut mutable_var = 0;
+    mutable_var = 1;
+}
+
+fn use_parameter(some_param: i32) {
+    let _ = some_param;
+}
+
+use one::subone::SomeAlias;
+
+use std::default::Default;
+
+fn use_impl_method() {
+    let _: i32 = Default::default();
+}
+
+mod other;
+use other::another_function;
+use crate::other::other_function;
+
+use one::subone::GenericStruct;
+
+use std::collections::bounded_vec::BoundedVec;
+
+fn instantiate_generic() {
+    let x: BoundedVec<subone::SubOneStruct, 3> = BoundedVec::new();
+}
diff --git a/noir/noir-repo/tooling/lsp/test_programs/workspace/two/src/other.nr b/noir/noir-repo/tooling/lsp/test_programs/workspace/two/src/other.nr
new file mode 100644
index 00000000000..4d2fffcee80
--- /dev/null
+++ b/noir/noir-repo/tooling/lsp/test_programs/workspace/two/src/other.nr
@@ -0,0 +1,2 @@
+fn other_function() {}
+fn another_function() {}
diff --git a/noir/noir-repo/tooling/nargo/src/package.rs b/noir/noir-repo/tooling/nargo/src/package.rs
index 44f0a3504f7..f55ca5550a3 100644
--- a/noir/noir-repo/tooling/nargo/src/package.rs
+++ b/noir/noir-repo/tooling/nargo/src/package.rs
@@ -1,5 +1,6 @@
 use std::{collections::BTreeMap, fmt::Display, path::PathBuf};
 
+use acvm::acir::circuit::ExpressionWidth;
 use noirc_frontend::graph::CrateName;
 
 use crate::constants::PROVER_INPUT_FILE;
@@ -51,6 +52,7 @@ pub struct Package {
     pub entry_path: PathBuf,
     pub name: CrateName,
     pub dependencies: BTreeMap<CrateName, Dependency>,
+    pub expression_width: Option<ExpressionWidth>,
 }
 
 impl Package {
diff --git a/noir/noir-repo/tooling/nargo_cli/build.rs b/noir/noir-repo/tooling/nargo_cli/build.rs
index 9dfa0dfe861..2756b58bf81 100644
--- a/noir/noir-repo/tooling/nargo_cli/build.rs
+++ b/noir/noir-repo/tooling/nargo_cli/build.rs
@@ -35,6 +35,7 @@ fn main() {
     generate_noir_test_failure_tests(&mut test_file, &test_dir);
     generate_compile_success_empty_tests(&mut test_file, &test_dir);
     generate_compile_success_contract_tests(&mut test_file, &test_dir);
+    generate_compile_success_no_bug_tests(&mut test_file, &test_dir);
     generate_compile_failure_tests(&mut test_file, &test_dir);
 }
 
@@ -61,7 +62,7 @@ const IGNORED_BRILLIG_TESTS: [&str; 11] = [
 /// Certain features are only available in the elaborator.
 /// We skip these tests for non-elaborator code since they are not
 /// expected to work there. This can be removed once the old code is removed.
-const IGNORED_NEW_FEATURE_TESTS: [&str; 9] = [
+const IGNORED_NEW_FEATURE_TESTS: [&str; 13] = [
     "macros",
     "wildcard_type",
     "type_definition_annotation",
@@ -71,6 +72,10 @@ const IGNORED_NEW_FEATURE_TESTS: [&str; 9] = [
     "comptime_slice_methods",
     "unary_operator_overloading",
     "unquote_multiple_items_from_annotation",
+    "function_attribute",
+    "trait_attribute",
+    "regression_5428",
+    "unquote",
 ];
 
 fn read_test_cases(
@@ -314,7 +319,6 @@ fn generate_compile_success_contract_tests(test_file: &mut File, test_data_dir:
             &test_dir,
             r#"
         nargo.arg("compile").arg("--force");
-        
         nargo.assert().success();"#,
         );
 
@@ -331,6 +335,36 @@ fn generate_compile_success_contract_tests(test_file: &mut File, test_data_dir:
     }
 }
 
+/// Generate tests for checking that the contract compiles and there are no "bugs" in stderr
+fn generate_compile_success_no_bug_tests(test_file: &mut File, test_data_dir: &Path) {
+    let test_type = "compile_success_no_bug";
+    let test_cases = read_test_cases(test_data_dir, test_type);
+    for (test_name, test_dir) in test_cases {
+        let test_dir = test_dir.display();
+
+        generate_test_case(
+            test_file,
+            test_type,
+            &test_name,
+            &test_dir,
+            r#"
+        nargo.arg("compile").arg("--force");
+        nargo.assert().success().stderr(predicate::str::contains("bug:").not());"#,
+        );
+
+        generate_test_case(
+            test_file,
+            test_type,
+            &format!("legacy_{test_name}"),
+            &test_dir,
+            r#"
+        nargo.arg("compile").arg("--force").arg("--use-legacy");
+        
+        nargo.assert().success().stderr(predicate::str::contains("bug:").not());"#,
+        );
+    }
+}
+
 fn generate_compile_failure_tests(test_file: &mut File, test_data_dir: &Path) {
     let test_type = "compile_failure";
     let test_cases = read_test_cases(test_data_dir, test_type);
diff --git a/noir/noir-repo/tooling/nargo_cli/src/cli/compile_cmd.rs b/noir/noir-repo/tooling/nargo_cli/src/cli/compile_cmd.rs
index e83b1728c93..a2877ebdeac 100644
--- a/noir/noir-repo/tooling/nargo_cli/src/cli/compile_cmd.rs
+++ b/noir/noir-repo/tooling/nargo_cli/src/cli/compile_cmd.rs
@@ -2,6 +2,7 @@ use std::io::Write;
 use std::path::Path;
 use std::time::Duration;
 
+use acvm::acir::circuit::ExpressionWidth;
 use fm::FileManager;
 use nargo::ops::{collect_errors, compile_contract, compile_program, report_errors};
 use nargo::package::Package;
@@ -190,7 +191,11 @@ fn compile_programs(
                 compile_options,
                 load_cached_program(package),
             )?;
-            let program = nargo::ops::transform_program(program, compile_options.expression_width);
+
+            let target_width =
+                get_target_width(package.expression_width, compile_options.expression_width);
+            let program = nargo::ops::transform_program(program, target_width);
+
             save_program_to_file(
                 &program.clone().into(),
                 &package.name,
@@ -216,8 +221,9 @@ fn compiled_contracts(
         .map(|package| {
             let (contract, warnings) =
                 compile_contract(file_manager, parsed_files, package, compile_options)?;
-            let contract =
-                nargo::ops::transform_contract(contract, compile_options.expression_width);
+            let target_width =
+                get_target_width(package.expression_width, compile_options.expression_width);
+            let contract = nargo::ops::transform_contract(contract, target_width);
             save_contract(contract, package, target_dir, compile_options.show_artifact_paths);
             Ok(((), warnings))
         })
@@ -243,3 +249,21 @@ fn save_contract(
         println!("Saved contract artifact to: {}", artifact_path.display());
     }
 }
+
+/// Default expression width used for Noir compilation.
+/// The ACVM native type `ExpressionWidth` has its own default which should always be unbounded,
+/// while we can sometimes expect the compilation target width to change.
+/// Thus, we set it separately here rather than trying to alter the default derivation of the type.
+const DEFAULT_EXPRESSION_WIDTH: ExpressionWidth = ExpressionWidth::Bounded { width: 4 };
+
+/// If a target width was not specified in the CLI we can safely override the default.
+pub(crate) fn get_target_width(
+    package_default_width: Option<ExpressionWidth>,
+    compile_options_width: Option<ExpressionWidth>,
+) -> ExpressionWidth {
+    if let (Some(manifest_default_width), None) = (package_default_width, compile_options_width) {
+        manifest_default_width
+    } else {
+        compile_options_width.unwrap_or(DEFAULT_EXPRESSION_WIDTH)
+    }
+}
diff --git a/noir/noir-repo/tooling/nargo_cli/src/cli/debug_cmd.rs b/noir/noir-repo/tooling/nargo_cli/src/cli/debug_cmd.rs
index 778009bf791..311af9b9db0 100644
--- a/noir/noir-repo/tooling/nargo_cli/src/cli/debug_cmd.rs
+++ b/noir/noir-repo/tooling/nargo_cli/src/cli/debug_cmd.rs
@@ -1,6 +1,6 @@
 use std::path::PathBuf;
 
-use acvm::acir::native_types::{WitnessMap, WitnessStack};
+use acvm::acir::native_types::WitnessStack;
 use acvm::FieldElement;
 use bn254_blackbox_solver::Bn254BlackBoxSolver;
 use clap::Args;
@@ -15,7 +15,6 @@ use nargo::{insert_all_files_for_workspace_into_file_manager, parse_all};
 use nargo_toml::{get_package_manifest, resolve_workspace_from_toml, PackageSelection};
 use noirc_abi::input_parser::{Format, InputValue};
 use noirc_abi::InputMap;
-use noirc_artifacts::debug::DebugArtifact;
 use noirc_driver::{
     file_manager_with_stdlib, CompileOptions, CompiledProgram, NOIR_ARTIFACT_VERSION_STRING,
 };
@@ -23,6 +22,7 @@ use noirc_frontend::debug::DebugInstrumenter;
 use noirc_frontend::graph::CrateName;
 use noirc_frontend::hir::ParsedFiles;
 
+use super::compile_cmd::get_target_width;
 use super::fs::{inputs::read_inputs_from_file, witness::save_witness_to_dir};
 use super::NargoConfig;
 use crate::errors::CliError;
@@ -81,8 +81,10 @@ pub(crate) fn run(args: DebugCommand, config: NargoConfig) -> Result<(), CliErro
         args.compile_options.clone(),
     )?;
 
-    let compiled_program =
-        nargo::ops::transform_program(compiled_program, args.compile_options.expression_width);
+    let target_width =
+        get_target_width(package.expression_width, args.compile_options.expression_width);
+
+    let compiled_program = nargo::ops::transform_program(compiled_program, target_width);
 
     run_async(package, compiled_program, &args.prover_name, &args.witness_name, target_dir)
 }
@@ -169,10 +171,10 @@ fn run_async(
 
     runtime.block_on(async {
         println!("[{}] Starting debugger", package.name);
-        let (return_value, solved_witness) =
+        let (return_value, witness_stack) =
             debug_program_and_decode(program, package, prover_name)?;
 
-        if let Some(solved_witness) = solved_witness {
+        if let Some(solved_witness_stack) = witness_stack {
             println!("[{}] Circuit witness successfully solved", package.name);
 
             if let Some(return_value) = return_value {
@@ -180,11 +182,8 @@ fn run_async(
             }
 
             if let Some(witness_name) = witness_name {
-                let witness_path = save_witness_to_dir(
-                    WitnessStack::from(solved_witness),
-                    witness_name,
-                    target_dir,
-                )?;
+                let witness_path =
+                    save_witness_to_dir(solved_witness_stack, witness_name, target_dir)?;
 
                 println!("[{}] Witness saved to {}", package.name, witness_path.display());
             }
@@ -200,38 +199,32 @@ fn debug_program_and_decode(
     program: CompiledProgram,
     package: &Package,
     prover_name: &str,
-) -> Result<(Option<InputValue>, Option<WitnessMap<FieldElement>>), CliError> {
+) -> Result<(Option<InputValue>, Option<WitnessStack<FieldElement>>), CliError> {
     // Parse the initial witness values from Prover.toml
     let (inputs_map, _) =
         read_inputs_from_file(&package.root_dir, prover_name, Format::Toml, &program.abi)?;
-    let solved_witness = debug_program(&program, &inputs_map)?;
-
-    match solved_witness {
-        Some(witness) => {
-            let (_, return_value) = program.abi.decode(&witness)?;
-            Ok((return_value, Some(witness)))
+    let program_abi = program.abi.clone();
+    let witness_stack = debug_program(program, &inputs_map)?;
+
+    match witness_stack {
+        Some(witness_stack) => {
+            let main_witness = &witness_stack
+                .peek()
+                .expect("Should have at least one witness on the stack")
+                .witness;
+            let (_, return_value) = program_abi.decode(main_witness)?;
+            Ok((return_value, Some(witness_stack)))
         }
         None => Ok((None, None)),
     }
 }
 
 pub(crate) fn debug_program(
-    compiled_program: &CompiledProgram,
+    compiled_program: CompiledProgram,
     inputs_map: &InputMap,
-) -> Result<Option<WitnessMap<FieldElement>>, CliError> {
+) -> Result<Option<WitnessStack<FieldElement>>, CliError> {
     let initial_witness = compiled_program.abi.encode(inputs_map, None)?;
 
-    let debug_artifact = DebugArtifact {
-        debug_symbols: compiled_program.debug.clone(),
-        file_map: compiled_program.file_map.clone(),
-    };
-
-    noir_debugger::debug_circuit(
-        &Bn254BlackBoxSolver,
-        &compiled_program.program.functions[0],
-        debug_artifact,
-        initial_witness,
-        &compiled_program.program.unconstrained_functions,
-    )
-    .map_err(CliError::from)
+    noir_debugger::run_repl_session(&Bn254BlackBoxSolver, compiled_program, initial_witness)
+        .map_err(CliError::from)
 }
diff --git a/noir/noir-repo/tooling/nargo_cli/src/cli/info_cmd.rs b/noir/noir-repo/tooling/nargo_cli/src/cli/info_cmd.rs
index 3759fb31c76..a6395d1c8c9 100644
--- a/noir/noir-repo/tooling/nargo_cli/src/cli/info_cmd.rs
+++ b/noir/noir-repo/tooling/nargo_cli/src/cli/info_cmd.rs
@@ -16,7 +16,9 @@ use serde::Serialize;
 use crate::errors::CliError;
 
 use super::{
-    compile_cmd::compile_workspace_full, fs::program::read_program_from_file, NargoConfig,
+    compile_cmd::{compile_workspace_full, get_target_width},
+    fs::program::read_program_from_file,
+    NargoConfig,
 };
 
 /// Provides detailed information on each of a program's function (represented by a single circuit)
@@ -84,11 +86,9 @@ pub(crate) fn run(args: InfoCommand, config: NargoConfig) -> Result<(), CliError
         .into_iter()
         .par_bridge()
         .map(|(package, program)| {
-            count_opcodes_and_gates_in_program(
-                program,
-                &package,
-                args.compile_options.expression_width,
-            )
+            let target_width =
+                get_target_width(package.expression_width, args.compile_options.expression_width);
+            count_opcodes_and_gates_in_program(program, &package, target_width)
         })
         .collect();
 
diff --git a/noir/noir-repo/tooling/nargo_cli/src/cli/mod.rs b/noir/noir-repo/tooling/nargo_cli/src/cli/mod.rs
index 485ccc7abaf..10ec38ad1d5 100644
--- a/noir/noir-repo/tooling/nargo_cli/src/cli/mod.rs
+++ b/noir/noir-repo/tooling/nargo_cli/src/cli/mod.rs
@@ -63,7 +63,6 @@ enum NargoCommand {
     Execute(execute_cmd::ExecuteCommand),
     #[command(hide = true)] // Hidden while the feature is being built out
     Export(export_cmd::ExportCommand),
-    #[command(hide = true)] // Hidden while the feature is being built out
     Debug(debug_cmd::DebugCommand),
     Test(test_cmd::TestCommand),
     Info(info_cmd::InfoCommand),
diff --git a/noir/noir-repo/tooling/nargo_cli/tests/stdlib-tests.rs b/noir/noir-repo/tooling/nargo_cli/tests/stdlib-tests.rs
index 10711b6d011..cc44b269c6a 100644
--- a/noir/noir-repo/tooling/nargo_cli/tests/stdlib-tests.rs
+++ b/noir/noir-repo/tooling/nargo_cli/tests/stdlib-tests.rs
@@ -27,6 +27,7 @@ fn run_stdlib_tests() {
         entry_path: PathBuf::from("main.nr"),
         name: "stdlib".parse().unwrap(),
         dependencies: BTreeMap::new(),
+        expression_width: None,
     };
 
     let (mut context, dummy_crate_id) =
diff --git a/noir/noir-repo/tooling/nargo_fmt/src/rewrite/imports.rs b/noir/noir-repo/tooling/nargo_fmt/src/rewrite/imports.rs
index 564ef3fa370..025d354259e 100644
--- a/noir/noir-repo/tooling/nargo_fmt/src/rewrite/imports.rs
+++ b/noir/noir-repo/tooling/nargo_fmt/src/rewrite/imports.rs
@@ -14,6 +14,7 @@ pub(crate) enum UseSegment {
     List(Vec<UseTree>),
     Dep,
     Crate,
+    Super,
 }
 
 impl UseSegment {
@@ -50,6 +51,7 @@ impl UseSegment {
             }
             UseSegment::Dep => "dep".into(),
             UseSegment::Crate => "crate".into(),
+            UseSegment::Super => "super".into(),
         }
     }
 }
@@ -66,6 +68,7 @@ impl UseTree {
         match use_tree.prefix.kind {
             ast::PathKind::Crate => result.path.push(UseSegment::Crate),
             ast::PathKind::Dep => result.path.push(UseSegment::Dep),
+            ast::PathKind::Super => result.path.push(UseSegment::Super),
             ast::PathKind::Plain => {}
         };
 
diff --git a/noir/noir-repo/tooling/nargo_fmt/tests/expected/use_super.nr b/noir/noir-repo/tooling/nargo_fmt/tests/expected/use_super.nr
new file mode 100644
index 00000000000..91fbe7a9df1
--- /dev/null
+++ b/noir/noir-repo/tooling/nargo_fmt/tests/expected/use_super.nr
@@ -0,0 +1,5 @@
+fn some_func() {}
+
+mod foo {
+    use super::some_func;
+}
diff --git a/noir/noir-repo/tooling/nargo_fmt/tests/input/use_super.nr b/noir/noir-repo/tooling/nargo_fmt/tests/input/use_super.nr
new file mode 100644
index 00000000000..a3b7d4cb4e2
--- /dev/null
+++ b/noir/noir-repo/tooling/nargo_fmt/tests/input/use_super.nr
@@ -0,0 +1,7 @@
+fn some_func() {
+
+}
+
+mod foo {
+    use super::some_func;
+}
diff --git a/noir/noir-repo/tooling/nargo_toml/Cargo.toml b/noir/noir-repo/tooling/nargo_toml/Cargo.toml
index 574972d99e7..7c9faa4562a 100644
--- a/noir/noir-repo/tooling/nargo_toml/Cargo.toml
+++ b/noir/noir-repo/tooling/nargo_toml/Cargo.toml
@@ -18,6 +18,7 @@ serde.workspace = true
 thiserror.workspace = true
 toml.workspace = true
 url.workspace = true
+noirc_driver.workspace = true
 semver = "1.0.20"
 
 [dev-dependencies]
diff --git a/noir/noir-repo/tooling/nargo_toml/src/errors.rs b/noir/noir-repo/tooling/nargo_toml/src/errors.rs
index 77fe77bcdbb..1ee8e90c8e5 100644
--- a/noir/noir-repo/tooling/nargo_toml/src/errors.rs
+++ b/noir/noir-repo/tooling/nargo_toml/src/errors.rs
@@ -72,6 +72,9 @@ pub enum ManifestError {
 
     #[error("Cyclic package dependency found when processing {cycle}")]
     CyclicDependency { cycle: String },
+
+    #[error("Failed to parse expression width with the following error: {0}")]
+    ParseExpressionWidth(String),
 }
 
 #[allow(clippy::enum_variant_names)]
diff --git a/noir/noir-repo/tooling/nargo_toml/src/lib.rs b/noir/noir-repo/tooling/nargo_toml/src/lib.rs
index 985cb30dc24..c0d8c7997fd 100644
--- a/noir/noir-repo/tooling/nargo_toml/src/lib.rs
+++ b/noir/noir-repo/tooling/nargo_toml/src/lib.rs
@@ -14,6 +14,7 @@ use nargo::{
     package::{Dependency, Package, PackageType},
     workspace::Workspace,
 };
+use noirc_driver::parse_expression_width;
 use noirc_frontend::graph::CrateName;
 use serde::Deserialize;
 
@@ -199,6 +200,16 @@ impl PackageConfig {
             })?;
         }
 
+        let expression_width = self
+            .package
+            .expression_width
+            .as_ref()
+            .map(|expression_width| {
+                parse_expression_width(expression_width)
+                    .map_err(|err| ManifestError::ParseExpressionWidth(err.to_string()))
+            })
+            .map_or(Ok(None), |res| res.map(Some))?;
+
         Ok(Package {
             version: self.package.version.clone(),
             compiler_required_version: self.package.compiler_version.clone(),
@@ -207,6 +218,7 @@ impl PackageConfig {
             package_type,
             name,
             dependencies,
+            expression_width,
         })
     }
 }
@@ -275,6 +287,7 @@ struct PackageMetadata {
     // so you will not need to supply an ACIR and compiler version
     compiler_version: Option<String>,
     license: Option<String>,
+    expression_width: Option<String>,
 }
 
 #[derive(Debug, Deserialize, Clone)]
@@ -531,3 +544,18 @@ fn parse_workspace_default_member_toml() {
     assert!(Config::try_from(String::from(src)).is_ok());
     assert!(Config::try_from(src).is_ok());
 }
+
+#[test]
+fn parse_package_expression_width_toml() {
+    let src = r#"
+    [package]
+    name = "test"
+    version = "0.1.0"
+    type = "bin"
+    authors = [""]
+    expression_width = "3"
+    "#;
+
+    assert!(Config::try_from(String::from(src)).is_ok());
+    assert!(Config::try_from(src).is_ok());
+}
diff --git a/noir/noir-repo/tooling/nargo_toml/src/semver.rs b/noir/noir-repo/tooling/nargo_toml/src/semver.rs
index 7c6e2a18b31..253ac82aa34 100644
--- a/noir/noir-repo/tooling/nargo_toml/src/semver.rs
+++ b/noir/noir-repo/tooling/nargo_toml/src/semver.rs
@@ -89,6 +89,7 @@ mod tests {
             name: CrateName::from_str("test").unwrap(),
             dependencies: BTreeMap::new(),
             version: Some("1.0".to_string()),
+            expression_width: None,
         };
         if let Err(err) = semver_check_package(&package, &compiler_version) {
             panic!("semver check should have passed. compiler version is 0.1.0 and required version from the package is 0.1.0\n error: {err:?}")
@@ -120,6 +121,7 @@ mod tests {
             name: CrateName::from_str("test").unwrap(),
             dependencies: BTreeMap::new(),
             version: Some("1.0".to_string()),
+            expression_width: None,
         };
 
         let valid_dependency = Package {
@@ -130,6 +132,7 @@ mod tests {
             name: CrateName::from_str("good_dependency").unwrap(),
             dependencies: BTreeMap::new(),
             version: Some("1.0".to_string()),
+            expression_width: None,
         };
         let invalid_dependency = Package {
             compiler_required_version: Some("0.2.0".to_string()),
@@ -139,6 +142,7 @@ mod tests {
             name: CrateName::from_str("bad_dependency").unwrap(),
             dependencies: BTreeMap::new(),
             version: Some("1.0".to_string()),
+            expression_width: None,
         };
 
         package.dependencies.insert(
@@ -179,6 +183,7 @@ mod tests {
             name: CrateName::from_str("test").unwrap(),
             dependencies: BTreeMap::new(),
             version: Some("1.0".to_string()),
+            expression_width: None,
         };
 
         if let Err(err) = semver_check_package(&package, &compiler_version) {
@@ -198,6 +203,7 @@ mod tests {
             name: CrateName::from_str("test").unwrap(),
             dependencies: BTreeMap::new(),
             version: Some("1.0".to_string()),
+            expression_width: None,
         };
 
         if let Err(err) = semver_check_package(&package, &compiler_version) {
diff --git a/noir/noir-repo/yarn.lock b/noir/noir-repo/yarn.lock
index 181b6b3b206..f77e9f7e72e 100644
--- a/noir/noir-repo/yarn.lock
+++ b/noir/noir-repo/yarn.lock
@@ -1746,52 +1746,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@chainsafe/as-sha256@npm:^0.3.1":
-  version: 0.3.1
-  resolution: "@chainsafe/as-sha256@npm:0.3.1"
-  checksum: 58ea733be1657b0e31dbf48b0dba862da0833df34a81c1460c7352f04ce90874f70003cbf34d0afb9e5e53a33ee2d63a261a8b12462be85b2ba0a6f7f13d6150
-  languageName: node
-  linkType: hard
-
-"@chainsafe/persistent-merkle-tree@npm:^0.4.2":
-  version: 0.4.2
-  resolution: "@chainsafe/persistent-merkle-tree@npm:0.4.2"
-  dependencies:
-    "@chainsafe/as-sha256": ^0.3.1
-  checksum: f9cfcb2132a243992709715dbd28186ab48c7c0c696f29d30857693cca5526bf753974a505ef68ffd5623bbdbcaa10f9083f4dd40bf99eb6408e451cc26a1a9e
-  languageName: node
-  linkType: hard
-
-"@chainsafe/persistent-merkle-tree@npm:^0.5.0":
-  version: 0.5.0
-  resolution: "@chainsafe/persistent-merkle-tree@npm:0.5.0"
-  dependencies:
-    "@chainsafe/as-sha256": ^0.3.1
-  checksum: 2c67203da776c79cd3a6132e2d672fe132393b2e63dc71604e3134acc8c0ec25cc5e431051545939ea0f7c5ff2066fb806b9e5cab974ca085d046226a1671f7d
-  languageName: node
-  linkType: hard
-
-"@chainsafe/ssz@npm:^0.10.0":
-  version: 0.10.2
-  resolution: "@chainsafe/ssz@npm:0.10.2"
-  dependencies:
-    "@chainsafe/as-sha256": ^0.3.1
-    "@chainsafe/persistent-merkle-tree": ^0.5.0
-  checksum: 6bb70cf741d0a19dd0b28b3f6f067b96fa39f556e2eefa6ac745b21db9c3b3a8393dc3cca8ff4a6ce065ed71ddc3fb1b2b390a92004b9d01067c26e2558e5503
-  languageName: node
-  linkType: hard
-
-"@chainsafe/ssz@npm:^0.9.2":
-  version: 0.9.4
-  resolution: "@chainsafe/ssz@npm:0.9.4"
-  dependencies:
-    "@chainsafe/as-sha256": ^0.3.1
-    "@chainsafe/persistent-merkle-tree": ^0.4.2
-    case: ^1.6.3
-  checksum: c6eaedeae9e5618b3c666ff4507a27647f665a8dcf17d5ca86da4ed4788c5a93868f256d0005467d184fdf35ec03f323517ec2e55ec42492d769540a2ec396bc
-  languageName: node
-  linkType: hard
-
 "@colors/colors@npm:1.5.0":
   version: 1.5.0
   resolution: "@colors/colors@npm:1.5.0"
@@ -3500,7 +3454,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/abi@npm:5.7.0, @ethersproject/abi@npm:^5.1.2, @ethersproject/abi@npm:^5.7.0":
+"@ethersproject/abi@npm:^5.1.2":
   version: 5.7.0
   resolution: "@ethersproject/abi@npm:5.7.0"
   dependencies:
@@ -3517,7 +3471,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/abstract-provider@npm:5.7.0, @ethersproject/abstract-provider@npm:^5.7.0":
+"@ethersproject/abstract-provider@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/abstract-provider@npm:5.7.0"
   dependencies:
@@ -3532,7 +3486,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/abstract-signer@npm:5.7.0, @ethersproject/abstract-signer@npm:^5.7.0":
+"@ethersproject/abstract-signer@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/abstract-signer@npm:5.7.0"
   dependencies:
@@ -3545,7 +3499,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/address@npm:5.7.0, @ethersproject/address@npm:^5.7.0":
+"@ethersproject/address@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/address@npm:5.7.0"
   dependencies:
@@ -3558,7 +3512,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/base64@npm:5.7.0, @ethersproject/base64@npm:^5.7.0":
+"@ethersproject/base64@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/base64@npm:5.7.0"
   dependencies:
@@ -3567,17 +3521,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/basex@npm:5.7.0, @ethersproject/basex@npm:^5.7.0":
-  version: 5.7.0
-  resolution: "@ethersproject/basex@npm:5.7.0"
-  dependencies:
-    "@ethersproject/bytes": ^5.7.0
-    "@ethersproject/properties": ^5.7.0
-  checksum: 326087b7e1f3787b5fe6cd1cf2b4b5abfafbc355a45e88e22e5e9d6c845b613ffc5301d629b28d5c4d5e2bfe9ec424e6782c804956dff79be05f0098cb5817de
-  languageName: node
-  linkType: hard
-
-"@ethersproject/bignumber@npm:5.7.0, @ethersproject/bignumber@npm:^5.7.0":
+"@ethersproject/bignumber@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/bignumber@npm:5.7.0"
   dependencies:
@@ -3588,7 +3532,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/bytes@npm:5.7.0, @ethersproject/bytes@npm:^5.7.0":
+"@ethersproject/bytes@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/bytes@npm:5.7.0"
   dependencies:
@@ -3597,7 +3541,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/constants@npm:5.7.0, @ethersproject/constants@npm:^5.7.0":
+"@ethersproject/constants@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/constants@npm:5.7.0"
   dependencies:
@@ -3606,25 +3550,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/contracts@npm:5.7.0":
-  version: 5.7.0
-  resolution: "@ethersproject/contracts@npm:5.7.0"
-  dependencies:
-    "@ethersproject/abi": ^5.7.0
-    "@ethersproject/abstract-provider": ^5.7.0
-    "@ethersproject/abstract-signer": ^5.7.0
-    "@ethersproject/address": ^5.7.0
-    "@ethersproject/bignumber": ^5.7.0
-    "@ethersproject/bytes": ^5.7.0
-    "@ethersproject/constants": ^5.7.0
-    "@ethersproject/logger": ^5.7.0
-    "@ethersproject/properties": ^5.7.0
-    "@ethersproject/transactions": ^5.7.0
-  checksum: 6ccf1121cba01b31e02f8c507cb971ab6bfed85706484a9ec09878ef1594a62215f43c4fdef8f4a4875b99c4a800bc95e3be69b1803f8ce479e07634b5a740c0
-  languageName: node
-  linkType: hard
-
-"@ethersproject/hash@npm:5.7.0, @ethersproject/hash@npm:^5.7.0":
+"@ethersproject/hash@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/hash@npm:5.7.0"
   dependencies:
@@ -3641,48 +3567,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/hdnode@npm:5.7.0, @ethersproject/hdnode@npm:^5.7.0":
-  version: 5.7.0
-  resolution: "@ethersproject/hdnode@npm:5.7.0"
-  dependencies:
-    "@ethersproject/abstract-signer": ^5.7.0
-    "@ethersproject/basex": ^5.7.0
-    "@ethersproject/bignumber": ^5.7.0
-    "@ethersproject/bytes": ^5.7.0
-    "@ethersproject/logger": ^5.7.0
-    "@ethersproject/pbkdf2": ^5.7.0
-    "@ethersproject/properties": ^5.7.0
-    "@ethersproject/sha2": ^5.7.0
-    "@ethersproject/signing-key": ^5.7.0
-    "@ethersproject/strings": ^5.7.0
-    "@ethersproject/transactions": ^5.7.0
-    "@ethersproject/wordlists": ^5.7.0
-  checksum: bfe5ca2d89a42de73655f853170ef4766b933c5f481cddad709b3aca18823275b096e572f92d1602a052f80b426edde44ad6b9d028799775a7dad4a5bbed2133
-  languageName: node
-  linkType: hard
-
-"@ethersproject/json-wallets@npm:5.7.0, @ethersproject/json-wallets@npm:^5.7.0":
-  version: 5.7.0
-  resolution: "@ethersproject/json-wallets@npm:5.7.0"
-  dependencies:
-    "@ethersproject/abstract-signer": ^5.7.0
-    "@ethersproject/address": ^5.7.0
-    "@ethersproject/bytes": ^5.7.0
-    "@ethersproject/hdnode": ^5.7.0
-    "@ethersproject/keccak256": ^5.7.0
-    "@ethersproject/logger": ^5.7.0
-    "@ethersproject/pbkdf2": ^5.7.0
-    "@ethersproject/properties": ^5.7.0
-    "@ethersproject/random": ^5.7.0
-    "@ethersproject/strings": ^5.7.0
-    "@ethersproject/transactions": ^5.7.0
-    aes-js: 3.0.0
-    scrypt-js: 3.0.1
-  checksum: f583458d22db62efaaf94d38dd243482776a45bf90f9f3882fbad5aa0b8fd288b41eb7c1ff8ec0b99c9b751088e43d6173530db64dd33c59f9d8daa8d7ad5aa2
-  languageName: node
-  linkType: hard
-
-"@ethersproject/keccak256@npm:5.7.0, @ethersproject/keccak256@npm:^5.7.0":
+"@ethersproject/keccak256@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/keccak256@npm:5.7.0"
   dependencies:
@@ -3692,14 +3577,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/logger@npm:5.7.0, @ethersproject/logger@npm:^5.7.0":
+"@ethersproject/logger@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/logger@npm:5.7.0"
   checksum: 075ab2f605f1fd0813f2e39c3308f77b44a67732b36e712d9bc085f22a84aac4da4f71b39bee50fe78da3e1c812673fadc41180c9970fe5e486e91ea17befe0d
   languageName: node
   linkType: hard
 
-"@ethersproject/networks@npm:5.7.1, @ethersproject/networks@npm:^5.7.0":
+"@ethersproject/networks@npm:^5.7.0":
   version: 5.7.1
   resolution: "@ethersproject/networks@npm:5.7.1"
   dependencies:
@@ -3708,17 +3593,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/pbkdf2@npm:5.7.0, @ethersproject/pbkdf2@npm:^5.7.0":
-  version: 5.7.0
-  resolution: "@ethersproject/pbkdf2@npm:5.7.0"
-  dependencies:
-    "@ethersproject/bytes": ^5.7.0
-    "@ethersproject/sha2": ^5.7.0
-  checksum: b895adb9e35a8a127e794f7aadc31a2424ef355a70e51cde10d457e3e888bb8102373199a540cf61f2d6b9a32e47358f9c65b47d559f42bf8e596b5fd67901e9
-  languageName: node
-  linkType: hard
-
-"@ethersproject/properties@npm:5.7.0, @ethersproject/properties@npm:^5.7.0":
+"@ethersproject/properties@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/properties@npm:5.7.0"
   dependencies:
@@ -3727,45 +3602,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/providers@npm:5.7.2, @ethersproject/providers@npm:^5.7.1, @ethersproject/providers@npm:^5.7.2":
-  version: 5.7.2
-  resolution: "@ethersproject/providers@npm:5.7.2"
-  dependencies:
-    "@ethersproject/abstract-provider": ^5.7.0
-    "@ethersproject/abstract-signer": ^5.7.0
-    "@ethersproject/address": ^5.7.0
-    "@ethersproject/base64": ^5.7.0
-    "@ethersproject/basex": ^5.7.0
-    "@ethersproject/bignumber": ^5.7.0
-    "@ethersproject/bytes": ^5.7.0
-    "@ethersproject/constants": ^5.7.0
-    "@ethersproject/hash": ^5.7.0
-    "@ethersproject/logger": ^5.7.0
-    "@ethersproject/networks": ^5.7.0
-    "@ethersproject/properties": ^5.7.0
-    "@ethersproject/random": ^5.7.0
-    "@ethersproject/rlp": ^5.7.0
-    "@ethersproject/sha2": ^5.7.0
-    "@ethersproject/strings": ^5.7.0
-    "@ethersproject/transactions": ^5.7.0
-    "@ethersproject/web": ^5.7.0
-    bech32: 1.1.4
-    ws: 7.4.6
-  checksum: 1754c731a5ca6782ae9677f4a9cd8b6246c4ef21a966c9a01b133750f3c578431ec43ec254e699969c4a0f87e84463ded50f96b415600aabd37d2056aee58c19
-  languageName: node
-  linkType: hard
-
-"@ethersproject/random@npm:5.7.0, @ethersproject/random@npm:^5.7.0":
-  version: 5.7.0
-  resolution: "@ethersproject/random@npm:5.7.0"
-  dependencies:
-    "@ethersproject/bytes": ^5.7.0
-    "@ethersproject/logger": ^5.7.0
-  checksum: 017829c91cff6c76470852855108115b0b52c611b6be817ed1948d56ba42d6677803ec2012aa5ae298a7660024156a64c11fcf544e235e239ab3f89f0fff7345
-  languageName: node
-  linkType: hard
-
-"@ethersproject/rlp@npm:5.7.0, @ethersproject/rlp@npm:^5.7.0":
+"@ethersproject/rlp@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/rlp@npm:5.7.0"
   dependencies:
@@ -3775,18 +3612,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/sha2@npm:5.7.0, @ethersproject/sha2@npm:^5.7.0":
-  version: 5.7.0
-  resolution: "@ethersproject/sha2@npm:5.7.0"
-  dependencies:
-    "@ethersproject/bytes": ^5.7.0
-    "@ethersproject/logger": ^5.7.0
-    hash.js: 1.1.7
-  checksum: 09321057c022effbff4cc2d9b9558228690b5dd916329d75c4b1ffe32ba3d24b480a367a7cc92d0f0c0b1c896814d03351ae4630e2f1f7160be2bcfbde435dbc
-  languageName: node
-  linkType: hard
-
-"@ethersproject/signing-key@npm:5.7.0, @ethersproject/signing-key@npm:^5.7.0":
+"@ethersproject/signing-key@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/signing-key@npm:5.7.0"
   dependencies:
@@ -3800,21 +3626,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/solidity@npm:5.7.0":
-  version: 5.7.0
-  resolution: "@ethersproject/solidity@npm:5.7.0"
-  dependencies:
-    "@ethersproject/bignumber": ^5.7.0
-    "@ethersproject/bytes": ^5.7.0
-    "@ethersproject/keccak256": ^5.7.0
-    "@ethersproject/logger": ^5.7.0
-    "@ethersproject/sha2": ^5.7.0
-    "@ethersproject/strings": ^5.7.0
-  checksum: 9a02f37f801c96068c3e7721f83719d060175bc4e80439fe060e92bd7acfcb6ac1330c7e71c49f4c2535ca1308f2acdcb01e00133129aac00581724c2d6293f3
-  languageName: node
-  linkType: hard
-
-"@ethersproject/strings@npm:5.7.0, @ethersproject/strings@npm:^5.7.0":
+"@ethersproject/strings@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/strings@npm:5.7.0"
   dependencies:
@@ -3825,7 +3637,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/transactions@npm:5.7.0, @ethersproject/transactions@npm:^5.7.0":
+"@ethersproject/transactions@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/transactions@npm:5.7.0"
   dependencies:
@@ -3842,41 +3654,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/units@npm:5.7.0":
-  version: 5.7.0
-  resolution: "@ethersproject/units@npm:5.7.0"
-  dependencies:
-    "@ethersproject/bignumber": ^5.7.0
-    "@ethersproject/constants": ^5.7.0
-    "@ethersproject/logger": ^5.7.0
-  checksum: 304714f848cd32e57df31bf545f7ad35c2a72adae957198b28cbc62166daa929322a07bff6e9c9ac4577ab6aa0de0546b065ed1b2d20b19e25748b7d475cb0fc
-  languageName: node
-  linkType: hard
-
-"@ethersproject/wallet@npm:5.7.0":
-  version: 5.7.0
-  resolution: "@ethersproject/wallet@npm:5.7.0"
-  dependencies:
-    "@ethersproject/abstract-provider": ^5.7.0
-    "@ethersproject/abstract-signer": ^5.7.0
-    "@ethersproject/address": ^5.7.0
-    "@ethersproject/bignumber": ^5.7.0
-    "@ethersproject/bytes": ^5.7.0
-    "@ethersproject/hash": ^5.7.0
-    "@ethersproject/hdnode": ^5.7.0
-    "@ethersproject/json-wallets": ^5.7.0
-    "@ethersproject/keccak256": ^5.7.0
-    "@ethersproject/logger": ^5.7.0
-    "@ethersproject/properties": ^5.7.0
-    "@ethersproject/random": ^5.7.0
-    "@ethersproject/signing-key": ^5.7.0
-    "@ethersproject/transactions": ^5.7.0
-    "@ethersproject/wordlists": ^5.7.0
-  checksum: a4009bf7331eddab38e3015b5e9101ef92de7f705b00a6196b997db0e5635b6d83561674d46c90c6f77b87c0500fe4a6b0183ba13749efc22db59c99deb82fbd
-  languageName: node
-  linkType: hard
-
-"@ethersproject/web@npm:5.7.1, @ethersproject/web@npm:^5.7.0":
+"@ethersproject/web@npm:^5.7.0":
   version: 5.7.1
   resolution: "@ethersproject/web@npm:5.7.1"
   dependencies:
@@ -3889,19 +3667,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/wordlists@npm:5.7.0, @ethersproject/wordlists@npm:^5.7.0":
-  version: 5.7.0
-  resolution: "@ethersproject/wordlists@npm:5.7.0"
-  dependencies:
-    "@ethersproject/bytes": ^5.7.0
-    "@ethersproject/hash": ^5.7.0
-    "@ethersproject/logger": ^5.7.0
-    "@ethersproject/properties": ^5.7.0
-    "@ethersproject/strings": ^5.7.0
-  checksum: 30eb6eb0731f9ef5faa44bf9c0c6e950bcaaef61e4d2d9ce0ae6d341f4e2d6d1f4ab4f8880bfce03b7aac4b862fb740e1421170cfbf8e2aafc359277d49e6e97
-  languageName: node
-  linkType: hard
-
 "@fastify/busboy@npm:^2.0.0":
   version: 2.1.0
   resolution: "@fastify/busboy@npm:2.1.0"
@@ -4547,161 +4312,117 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@nomicfoundation/ethereumjs-block@npm:5.0.2":
-  version: 5.0.2
-  resolution: "@nomicfoundation/ethereumjs-block@npm:5.0.2"
-  dependencies:
-    "@nomicfoundation/ethereumjs-common": 4.0.2
-    "@nomicfoundation/ethereumjs-rlp": 5.0.2
-    "@nomicfoundation/ethereumjs-trie": 6.0.2
-    "@nomicfoundation/ethereumjs-tx": 5.0.2
-    "@nomicfoundation/ethereumjs-util": 9.0.2
-    ethereum-cryptography: 0.1.3
-    ethers: ^5.7.1
-  checksum: 7ff744f44a01f1c059ca7812a1cfc8089f87aa506af6cb39c78331dca71b32993cbd6fa05ad03f8c4f4fab73bb998a927af69e0d8ff01ae192ee5931606e09f5
+"@nomicfoundation/edr-darwin-arm64@npm:0.4.2":
+  version: 0.4.2
+  resolution: "@nomicfoundation/edr-darwin-arm64@npm:0.4.2"
+  checksum: 7835e998c2ef83924efac0694bb4392f6abf770dc7f935dd28abc1a291f830cade14750d83a46a3205338e4ddff943dda60a9849317cf42edd38d7a2ce843588
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-blockchain@npm:7.0.2":
-  version: 7.0.2
-  resolution: "@nomicfoundation/ethereumjs-blockchain@npm:7.0.2"
-  dependencies:
-    "@nomicfoundation/ethereumjs-block": 5.0.2
-    "@nomicfoundation/ethereumjs-common": 4.0.2
-    "@nomicfoundation/ethereumjs-ethash": 3.0.2
-    "@nomicfoundation/ethereumjs-rlp": 5.0.2
-    "@nomicfoundation/ethereumjs-trie": 6.0.2
-    "@nomicfoundation/ethereumjs-tx": 5.0.2
-    "@nomicfoundation/ethereumjs-util": 9.0.2
-    abstract-level: ^1.0.3
-    debug: ^4.3.3
-    ethereum-cryptography: 0.1.3
-    level: ^8.0.0
-    lru-cache: ^5.1.1
-    memory-level: ^1.0.0
-  checksum: b7e440dcd73e32aa72d13bfd28cb472773c9c60ea808a884131bf7eb3f42286ad594a0864215f599332d800f3fe1f772fff4b138d2dcaa8f41e4d8389bff33e7
+"@nomicfoundation/edr-darwin-x64@npm:0.4.2":
+  version: 0.4.2
+  resolution: "@nomicfoundation/edr-darwin-x64@npm:0.4.2"
+  checksum: 94daa26610621e85cb025feb37bb93e9b89c59f908bf3eae70720d2b86632dbb1236420ae3ae6f685d563ba52519d5f860e68ccd898fa1fced831961dea2c08a
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-common@npm:4.0.2":
-  version: 4.0.2
-  resolution: "@nomicfoundation/ethereumjs-common@npm:4.0.2"
-  dependencies:
-    "@nomicfoundation/ethereumjs-util": 9.0.2
-    crc-32: ^1.2.0
-  checksum: f0d84704d6254d374299c19884312bd5666974b4b6f342d3f10bc76e549de78d20e45a53d25fbdc146268a52335497127e4f069126da7c60ac933a158e704887
+"@nomicfoundation/edr-linux-arm64-gnu@npm:0.4.2":
+  version: 0.4.2
+  resolution: "@nomicfoundation/edr-linux-arm64-gnu@npm:0.4.2"
+  checksum: a7181e237f6ece8bd97e0f75972044dbf584c506bbac5bef586d9f7d627a2c07a279a2d892837bbedc80ea3dfb39fa66becc297238b5d715a942eed2a50745cd
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-ethash@npm:3.0.2":
-  version: 3.0.2
-  resolution: "@nomicfoundation/ethereumjs-ethash@npm:3.0.2"
-  dependencies:
-    "@nomicfoundation/ethereumjs-block": 5.0.2
-    "@nomicfoundation/ethereumjs-rlp": 5.0.2
-    "@nomicfoundation/ethereumjs-util": 9.0.2
-    abstract-level: ^1.0.3
-    bigint-crypto-utils: ^3.0.23
-    ethereum-cryptography: 0.1.3
-  checksum: e4011e4019dd9b92f7eeebfc1e6c9a9685c52d8fd0ee4f28f03e50048a23b600c714490827f59fdce497b3afb503b3fd2ebf6815ff307e9949c3efeff1403278
+"@nomicfoundation/edr-linux-arm64-musl@npm:0.4.2":
+  version: 0.4.2
+  resolution: "@nomicfoundation/edr-linux-arm64-musl@npm:0.4.2"
+  checksum: 5a849484b7a104a7e1497774c4117afc58f64d57d30889d4f6f676dddb5c695192c0789b8be0b71171a2af770167a28aa301ae3ece7a2a156d82d94388639b66
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-evm@npm:2.0.2":
-  version: 2.0.2
-  resolution: "@nomicfoundation/ethereumjs-evm@npm:2.0.2"
-  dependencies:
-    "@ethersproject/providers": ^5.7.1
-    "@nomicfoundation/ethereumjs-common": 4.0.2
-    "@nomicfoundation/ethereumjs-tx": 5.0.2
-    "@nomicfoundation/ethereumjs-util": 9.0.2
-    debug: ^4.3.3
-    ethereum-cryptography: 0.1.3
-    mcl-wasm: ^0.7.1
-    rustbn.js: ~0.2.0
-  checksum: a23cf570836ddc147606b02df568069de946108e640f902358fef67e589f6b371d856056ee44299d9b4e3497f8ae25faa45e6b18fefd90e9b222dc6a761d85f0
+"@nomicfoundation/edr-linux-x64-gnu@npm:0.4.2":
+  version: 0.4.2
+  resolution: "@nomicfoundation/edr-linux-x64-gnu@npm:0.4.2"
+  checksum: 0520dd9a583976fd0f49dfe6c23227f03cd811a395dc5eed1a2922b4358d7c71fdcfea8f389d4a0e23b4ec53e1435959a544380f94e48122a75f94a42b177ac7
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-rlp@npm:5.0.2":
-  version: 5.0.2
-  resolution: "@nomicfoundation/ethereumjs-rlp@npm:5.0.2"
-  bin:
-    rlp: bin/rlp
-  checksum: a74434cadefca9aa8754607cc1ad7bb4bbea4ee61c6214918e60a5bbee83206850346eb64e39fd1fe97f854c7ec0163e01148c0c881dda23881938f0645a0ef2
+"@nomicfoundation/edr-linux-x64-musl@npm:0.4.2":
+  version: 0.4.2
+  resolution: "@nomicfoundation/edr-linux-x64-musl@npm:0.4.2"
+  checksum: 80c3b4346d8c27539bc005b09db233dedd8930310d1a049827661e69a8e03be9cbac27eb620a6ae9bfd46a2fbe22f83cee5af8d9e63178925d74d9c656246708
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-statemanager@npm:2.0.2":
-  version: 2.0.2
-  resolution: "@nomicfoundation/ethereumjs-statemanager@npm:2.0.2"
-  dependencies:
-    "@nomicfoundation/ethereumjs-common": 4.0.2
-    "@nomicfoundation/ethereumjs-rlp": 5.0.2
-    debug: ^4.3.3
-    ethereum-cryptography: 0.1.3
-    ethers: ^5.7.1
-    js-sdsl: ^4.1.4
-  checksum: 3ab6578e252e53609afd98d8ba42a99f182dcf80252f23ed9a5e0471023ffb2502130f85fc47fa7c94cd149f9be799ed9a0942ca52a143405be9267f4ad94e64
+"@nomicfoundation/edr-win32-x64-msvc@npm:0.4.2":
+  version: 0.4.2
+  resolution: "@nomicfoundation/edr-win32-x64-msvc@npm:0.4.2"
+  checksum: 736fb866fd5c2708560cbd5ae72815b5fc96e650cd74bc8bab0a1cb0e8baede4f595fdceb445c159814a6a7e8e691de227a5db49f61b3cd0ddfafd5715b397ab
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-trie@npm:6.0.2":
-  version: 6.0.2
-  resolution: "@nomicfoundation/ethereumjs-trie@npm:6.0.2"
+"@nomicfoundation/edr@npm:^0.4.1":
+  version: 0.4.2
+  resolution: "@nomicfoundation/edr@npm:0.4.2"
   dependencies:
-    "@nomicfoundation/ethereumjs-rlp": 5.0.2
-    "@nomicfoundation/ethereumjs-util": 9.0.2
-    "@types/readable-stream": ^2.3.13
-    ethereum-cryptography: 0.1.3
-    readable-stream: ^3.6.0
-  checksum: d4da918d333851b9f2cce7dbd25ab5753e0accd43d562d98fd991b168b6a08d1794528f0ade40fe5617c84900378376fe6256cdbe52c8d66bf4c53293bbc7c40
+    "@nomicfoundation/edr-darwin-arm64": 0.4.2
+    "@nomicfoundation/edr-darwin-x64": 0.4.2
+    "@nomicfoundation/edr-linux-arm64-gnu": 0.4.2
+    "@nomicfoundation/edr-linux-arm64-musl": 0.4.2
+    "@nomicfoundation/edr-linux-x64-gnu": 0.4.2
+    "@nomicfoundation/edr-linux-x64-musl": 0.4.2
+    "@nomicfoundation/edr-win32-x64-msvc": 0.4.2
+  checksum: 8c8457257b59ed9a29d88b7492e98e974d24e8318903e876a14dc0f6d5dc77948cd9053937d9730f54f920ba82ce3d244cab518d068359bcc20df88623f171ef
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-tx@npm:5.0.2":
-  version: 5.0.2
-  resolution: "@nomicfoundation/ethereumjs-tx@npm:5.0.2"
+"@nomicfoundation/ethereumjs-common@npm:4.0.4":
+  version: 4.0.4
+  resolution: "@nomicfoundation/ethereumjs-common@npm:4.0.4"
   dependencies:
-    "@chainsafe/ssz": ^0.9.2
-    "@ethersproject/providers": ^5.7.2
-    "@nomicfoundation/ethereumjs-common": 4.0.2
-    "@nomicfoundation/ethereumjs-rlp": 5.0.2
-    "@nomicfoundation/ethereumjs-util": 9.0.2
-    ethereum-cryptography: 0.1.3
-  checksum: 0bbcea75786b2ccb559afe2ecc9866fb4566a9f157b6ffba4f50960d14f4b3da2e86e273f6fadda9b860e67cfcabf589970fb951b328cb5f900a585cd21842a2
+    "@nomicfoundation/ethereumjs-util": 9.0.4
+  checksum: ce3f6e4ae15b976efdb7ccda27e19aadb62b5ffee209f9503e68b4fd8633715d4d697c0cc10ccd35f5e4e977edd05100d0f214e28880ec64fff77341dc34fcdf
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-util@npm:9.0.2":
-  version: 9.0.2
-  resolution: "@nomicfoundation/ethereumjs-util@npm:9.0.2"
+"@nomicfoundation/ethereumjs-rlp@npm:5.0.4":
+  version: 5.0.4
+  resolution: "@nomicfoundation/ethereumjs-rlp@npm:5.0.4"
+  bin:
+    rlp: bin/rlp.cjs
+  checksum: ee2c2e5776c73801dc5ed636f4988b599b4563c2d0037da542ea57eb237c69dd1ac555f6bcb5e06f70515b6459779ba0d68252a6e105132b4659ab4bf62919b0
+  languageName: node
+  linkType: hard
+
+"@nomicfoundation/ethereumjs-tx@npm:5.0.4":
+  version: 5.0.4
+  resolution: "@nomicfoundation/ethereumjs-tx@npm:5.0.4"
   dependencies:
-    "@chainsafe/ssz": ^0.10.0
-    "@nomicfoundation/ethereumjs-rlp": 5.0.2
+    "@nomicfoundation/ethereumjs-common": 4.0.4
+    "@nomicfoundation/ethereumjs-rlp": 5.0.4
+    "@nomicfoundation/ethereumjs-util": 9.0.4
     ethereum-cryptography: 0.1.3
-  checksum: 3a08f7b88079ef9f53b43da9bdcb8195498fd3d3911c2feee2571f4d1204656053f058b2f650471c86f7d2d0ba2f814768c7cfb0f266eede41c848356afc4900
+  peerDependencies:
+    c-kzg: ^2.1.2
+  peerDependenciesMeta:
+    c-kzg:
+      optional: true
+  checksum: 0f1c87716682ccbcf4d92ffc6cf8ab557e658b90319d82be3219a091a736859f8803c73c98e4863682e3e86d264751c472d33ff6d3c3daf4e75b5f01d0af8fa3
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-vm@npm:7.0.2":
-  version: 7.0.2
-  resolution: "@nomicfoundation/ethereumjs-vm@npm:7.0.2"
-  dependencies:
-    "@nomicfoundation/ethereumjs-block": 5.0.2
-    "@nomicfoundation/ethereumjs-blockchain": 7.0.2
-    "@nomicfoundation/ethereumjs-common": 4.0.2
-    "@nomicfoundation/ethereumjs-evm": 2.0.2
-    "@nomicfoundation/ethereumjs-rlp": 5.0.2
-    "@nomicfoundation/ethereumjs-statemanager": 2.0.2
-    "@nomicfoundation/ethereumjs-trie": 6.0.2
-    "@nomicfoundation/ethereumjs-tx": 5.0.2
-    "@nomicfoundation/ethereumjs-util": 9.0.2
-    debug: ^4.3.3
+"@nomicfoundation/ethereumjs-util@npm:9.0.4":
+  version: 9.0.4
+  resolution: "@nomicfoundation/ethereumjs-util@npm:9.0.4"
+  dependencies:
+    "@nomicfoundation/ethereumjs-rlp": 5.0.4
     ethereum-cryptography: 0.1.3
-    mcl-wasm: ^0.7.1
-    rustbn.js: ~0.2.0
-  checksum: 1c25ba4d0644cadb8a2b0241a4bb02e578bfd7f70e3492b855c2ab5c120cb159cb8f7486f84dc1597884bd1697feedbfb5feb66e91352afb51f3694fd8e4a043
+  peerDependencies:
+    c-kzg: ^2.1.2
+  peerDependenciesMeta:
+    c-kzg:
+      optional: true
+  checksum: 754439f72b11cad2d8986707ad020077dcc763c4055f73e2668a0b4cadb22aa4407faa9b3c587d9eb5b97ac337afbe037eb642bc1d5a16197284f83db3462cbe
   languageName: node
   linkType: hard
 
@@ -6126,16 +5847,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/readable-stream@npm:^2.3.13":
-  version: 2.3.15
-  resolution: "@types/readable-stream@npm:2.3.15"
-  dependencies:
-    "@types/node": "*"
-    safe-buffer: ~5.1.1
-  checksum: ec36f525cad09b6c65a1dafcb5ad99b9e2ed824ec49b7aa23180ac427e5d35b8a0706193ecd79ab4253a283ad485ba03d5917a98daaaa144f0ea34f4823e9d82
-  languageName: node
-  linkType: hard
-
 "@types/readable-stream@npm:^4":
   version: 4.0.10
   resolution: "@types/readable-stream@npm:4.0.10"
@@ -7046,21 +6757,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"abstract-level@npm:^1.0.0, abstract-level@npm:^1.0.2, abstract-level@npm:^1.0.3":
-  version: 1.0.3
-  resolution: "abstract-level@npm:1.0.3"
-  dependencies:
-    buffer: ^6.0.3
-    catering: ^2.1.0
-    is-buffer: ^2.0.5
-    level-supports: ^4.0.0
-    level-transcoder: ^1.0.1
-    module-error: ^1.0.1
-    queue-microtask: ^1.2.3
-  checksum: 70d61a3924526ebc257b138992052f9ff571a6cee5a7660836e37a1cc7081273c3acf465dd2f5e1897b38dc743a6fd9dba14a5d8a2a9d39e5787cd3da99f301d
-  languageName: node
-  linkType: hard
-
 "abstract-leveldown@npm:~0.12.0, abstract-leveldown@npm:~0.12.1":
   version: 0.12.4
   resolution: "abstract-leveldown@npm:0.12.4"
@@ -7135,13 +6831,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"aes-js@npm:3.0.0":
-  version: 3.0.0
-  resolution: "aes-js@npm:3.0.0"
-  checksum: 251e26d533cd1a915b44896b17d5ed68c24a02484cfdd2e74ec700a309267db96651ea4eb657bf20aac32a3baa61f6e34edf8e2fec2de440a655da9942d334b8
-  languageName: node
-  linkType: hard
-
 "aes-js@npm:4.0.0-beta.5":
   version: 4.0.0-beta.5
   resolution: "aes-js@npm:4.0.0-beta.5"
@@ -7772,13 +7461,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"bech32@npm:1.1.4":
-  version: 1.1.4
-  resolution: "bech32@npm:1.1.4"
-  checksum: 0e98db619191548390d6f09ff68b0253ba7ae6a55db93dfdbb070ba234c1fd3308c0606fbcc95fad50437227b10011e2698b89f0181f6e7f845c499bd14d0f4b
-  languageName: node
-  linkType: hard
-
 "big.js@npm:^5.2.2":
   version: 5.2.2
   resolution: "big.js@npm:5.2.2"
@@ -7786,13 +7468,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"bigint-crypto-utils@npm:^3.0.23":
-  version: 3.3.0
-  resolution: "bigint-crypto-utils@npm:3.3.0"
-  checksum: 9598ce57b23f776c8936d44114c9f051e62b5fa654915b664784cbcbacc5aa0485f4479571c51ff58008abb1210c0d6a234853742f07cf84bda890f2a1e01000
-  languageName: node
-  linkType: hard
-
 "binary-extensions@npm:^2.0.0":
   version: 2.2.0
   resolution: "binary-extensions@npm:2.2.0"
@@ -7895,7 +7570,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"boxen@npm:^5.0.0":
+"boxen@npm:^5.0.0, boxen@npm:^5.1.2":
   version: 5.1.2
   resolution: "boxen@npm:5.1.2"
   dependencies:
@@ -7978,18 +7653,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"browser-level@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "browser-level@npm:1.0.1"
-  dependencies:
-    abstract-level: ^1.0.2
-    catering: ^2.1.1
-    module-error: ^1.0.2
-    run-parallel-limit: ^1.1.0
-  checksum: 67fbc77ce832940bfa25073eccff279f512ad56f545deb996a5b23b02316f5e76f4a79d381acc27eda983f5c9a2566aaf9c97e4fdd0748288c4407307537a29b
-  languageName: node
-  linkType: hard
-
 "browser-stdout@npm:1.3.1":
   version: 1.3.1
   resolution: "browser-stdout@npm:1.3.1"
@@ -8262,20 +7925,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"case@npm:^1.6.3":
-  version: 1.6.3
-  resolution: "case@npm:1.6.3"
-  checksum: febe73278f910b0d28aab7efd6f51c235f9aa9e296148edb56dfb83fd58faa88308c30ce9a0122b6e53e0362c44f4407105bd5ef89c46860fc2b184e540fd68d
-  languageName: node
-  linkType: hard
-
-"catering@npm:^2.1.0, catering@npm:^2.1.1":
-  version: 2.1.1
-  resolution: "catering@npm:2.1.1"
-  checksum: 205daefa69c935b0c19f3d8f2e0a520dd69aebe9bda55902958003f7c9cff8f967dfb90071b421bd6eb618576f657a89d2bc0986872c9bc04bbd66655e9d4bd6
-  languageName: node
-  linkType: hard
-
 "ccount@npm:^1.0.0":
   version: 1.1.0
   resolution: "ccount@npm:1.1.0"
@@ -8565,20 +8214,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"classic-level@npm:^1.2.0":
-  version: 1.3.0
-  resolution: "classic-level@npm:1.3.0"
-  dependencies:
-    abstract-level: ^1.0.2
-    catering: ^2.1.0
-    module-error: ^1.0.1
-    napi-macros: ^2.2.2
-    node-gyp: latest
-    node-gyp-build: ^4.3.0
-  checksum: 773da48aef52a041115d413fee8340b357a4da2eb505764f327183b155edd7cc9d24819eb4f707c83dbdae8588024f5dddeb322125567c59d5d1f6f16334cdb9
-  languageName: node
-  linkType: hard
-
 "clean-css@npm:^5.2.2, clean-css@npm:^5.3.0, clean-css@npm:^5.3.2, clean-css@npm:~5.3.2":
   version: 5.3.3
   resolution: "clean-css@npm:5.3.3"
@@ -8881,13 +8516,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"commander@npm:3.0.2":
-  version: 3.0.2
-  resolution: "commander@npm:3.0.2"
-  checksum: 6d14ad030d1904428139487ed31febcb04c1604db2b8d9fae711f60ee6718828dc0e11602249e91c8a97b0e721e9c6d53edbc166bad3cde1596851d59a8f824d
-  languageName: node
-  linkType: hard
-
 "commander@npm:^10.0.0, commander@npm:^10.0.1":
   version: 10.0.1
   resolution: "commander@npm:10.0.1"
@@ -8923,7 +8551,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"commander@npm:^8.3.0":
+"commander@npm:^8.1.0, commander@npm:^8.3.0":
   version: 8.3.0
   resolution: "commander@npm:8.3.0"
   checksum: 0f82321821fc27b83bd409510bb9deeebcfa799ff0bf5d102128b500b7af22872c0c92cb6a0ebc5a4cf19c6b550fba9cedfa7329d18c6442a625f851377bacf0
@@ -9231,15 +8859,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"crc-32@npm:^1.2.0":
-  version: 1.2.2
-  resolution: "crc-32@npm:1.2.2"
-  bin:
-    crc32: bin/crc32.njs
-  checksum: ad2d0ad0cbd465b75dcaeeff0600f8195b686816ab5f3ba4c6e052a07f728c3e70df2e3ca9fd3d4484dc4ba70586e161ca5a2334ec8bf5a41bf022a6103ff243
-  languageName: node
-  linkType: hard
-
 "create-hash@npm:^1.1.0, create-hash@npm:^1.1.2, create-hash@npm:^1.2.0":
   version: 1.2.0
   resolution: "create-hash@npm:1.2.0"
@@ -9669,7 +9288,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"debug@npm:4, debug@npm:4.3.4, debug@npm:^4.0.0, debug@npm:^4.1.0, debug@npm:^4.1.1, debug@npm:^4.2.0, debug@npm:^4.3.1, debug@npm:^4.3.2, debug@npm:^4.3.3, debug@npm:^4.3.4":
+"debug@npm:4, debug@npm:4.3.4, debug@npm:^4.0.0, debug@npm:^4.1.0, debug@npm:^4.1.1, debug@npm:^4.2.0, debug@npm:^4.3.1, debug@npm:^4.3.2, debug@npm:^4.3.4":
   version: 4.3.4
   resolution: "debug@npm:4.3.4"
   dependencies:
@@ -10922,44 +10541,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ethers@npm:^5.7.1":
-  version: 5.7.2
-  resolution: "ethers@npm:5.7.2"
-  dependencies:
-    "@ethersproject/abi": 5.7.0
-    "@ethersproject/abstract-provider": 5.7.0
-    "@ethersproject/abstract-signer": 5.7.0
-    "@ethersproject/address": 5.7.0
-    "@ethersproject/base64": 5.7.0
-    "@ethersproject/basex": 5.7.0
-    "@ethersproject/bignumber": 5.7.0
-    "@ethersproject/bytes": 5.7.0
-    "@ethersproject/constants": 5.7.0
-    "@ethersproject/contracts": 5.7.0
-    "@ethersproject/hash": 5.7.0
-    "@ethersproject/hdnode": 5.7.0
-    "@ethersproject/json-wallets": 5.7.0
-    "@ethersproject/keccak256": 5.7.0
-    "@ethersproject/logger": 5.7.0
-    "@ethersproject/networks": 5.7.1
-    "@ethersproject/pbkdf2": 5.7.0
-    "@ethersproject/properties": 5.7.0
-    "@ethersproject/providers": 5.7.2
-    "@ethersproject/random": 5.7.0
-    "@ethersproject/rlp": 5.7.0
-    "@ethersproject/sha2": 5.7.0
-    "@ethersproject/signing-key": 5.7.0
-    "@ethersproject/solidity": 5.7.0
-    "@ethersproject/strings": 5.7.0
-    "@ethersproject/transactions": 5.7.0
-    "@ethersproject/units": 5.7.0
-    "@ethersproject/wallet": 5.7.0
-    "@ethersproject/web": 5.7.1
-    "@ethersproject/wordlists": 5.7.0
-  checksum: b7c08cf3e257185a7946117dbbf764433b7ba0e77c27298dec6088b3bc871aff711462b0621930c56880ff0a7ceb8b1d3a361ffa259f93377b48e34107f62553
-  languageName: node
-  linkType: hard
-
 "ethers@npm:^6.7.1":
   version: 6.9.0
   resolution: "ethers@npm:6.9.0"
@@ -11557,19 +11138,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fs-extra@npm:^0.30.0":
-  version: 0.30.0
-  resolution: "fs-extra@npm:0.30.0"
-  dependencies:
-    graceful-fs: ^4.1.2
-    jsonfile: ^2.1.0
-    klaw: ^1.0.0
-    path-is-absolute: ^1.0.0
-    rimraf: ^2.2.8
-  checksum: 6edfd65fc813baa27f1603778c0f5ec11f8c5006a20b920437813ee2023eba18aeec8bef1c89b2e6c84f9fc90fdc7c916f4a700466c8c69d22a35d018f2570f0
-  languageName: node
-  linkType: hard
-
 "fs-extra@npm:^10.0.0, fs-extra@npm:^10.1.0":
   version: 10.1.0
   resolution: "fs-extra@npm:10.1.0"
@@ -11703,13 +11271,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"functional-red-black-tree@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "functional-red-black-tree@npm:1.0.1"
-  checksum: ca6c170f37640e2d94297da8bb4bf27a1d12bea3e00e6a3e007fd7aa32e37e000f5772acf941b4e4f3cf1c95c3752033d0c509af157ad8f526e7f00723b9eb9f
-  languageName: node
-  linkType: hard
-
 "fwd-stream@npm:^1.0.4":
   version: 1.0.4
   resolution: "fwd-stream@npm:1.0.4"
@@ -12050,7 +11611,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"graceful-fs@npm:^4.1.11, graceful-fs@npm:^4.1.2, graceful-fs@npm:^4.1.6, graceful-fs@npm:^4.1.9, graceful-fs@npm:^4.2.0, graceful-fs@npm:^4.2.4, graceful-fs@npm:^4.2.6, graceful-fs@npm:^4.2.9":
+"graceful-fs@npm:^4.1.11, graceful-fs@npm:^4.1.2, graceful-fs@npm:^4.1.6, graceful-fs@npm:^4.2.0, graceful-fs@npm:^4.2.4, graceful-fs@npm:^4.2.6, graceful-fs@npm:^4.2.9":
   version: 4.2.11
   resolution: "graceful-fs@npm:4.2.11"
   checksum: ac85f94da92d8eb6b7f5a8b20ce65e43d66761c55ce85ac96df6865308390da45a8d3f0296dd3a663de65d30ba497bd46c696cc1e248c72b13d6d567138a4fc7
@@ -12092,22 +11653,16 @@ __metadata:
   languageName: node
   linkType: hard
 
-"hardhat@npm:^2.17.4":
-  version: 2.19.2
-  resolution: "hardhat@npm:2.19.2"
+"hardhat@npm:^2.22.6":
+  version: 2.22.6
+  resolution: "hardhat@npm:2.22.6"
   dependencies:
     "@ethersproject/abi": ^5.1.2
     "@metamask/eth-sig-util": ^4.0.0
-    "@nomicfoundation/ethereumjs-block": 5.0.2
-    "@nomicfoundation/ethereumjs-blockchain": 7.0.2
-    "@nomicfoundation/ethereumjs-common": 4.0.2
-    "@nomicfoundation/ethereumjs-evm": 2.0.2
-    "@nomicfoundation/ethereumjs-rlp": 5.0.2
-    "@nomicfoundation/ethereumjs-statemanager": 2.0.2
-    "@nomicfoundation/ethereumjs-trie": 6.0.2
-    "@nomicfoundation/ethereumjs-tx": 5.0.2
-    "@nomicfoundation/ethereumjs-util": 9.0.2
-    "@nomicfoundation/ethereumjs-vm": 7.0.2
+    "@nomicfoundation/edr": ^0.4.1
+    "@nomicfoundation/ethereumjs-common": 4.0.4
+    "@nomicfoundation/ethereumjs-tx": 5.0.4
+    "@nomicfoundation/ethereumjs-util": 9.0.4
     "@nomicfoundation/solidity-analyzer": ^0.1.0
     "@sentry/node": ^5.18.1
     "@types/bn.js": ^5.1.0
@@ -12115,6 +11670,7 @@ __metadata:
     adm-zip: ^0.4.16
     aggregate-error: ^3.0.0
     ansi-escapes: ^4.3.0
+    boxen: ^5.1.2
     chalk: ^2.4.2
     chokidar: ^3.4.0
     ci-info: ^2.0.0
@@ -12137,7 +11693,7 @@ __metadata:
     raw-body: ^2.4.1
     resolve: 1.17.0
     semver: ^6.3.0
-    solc: 0.7.3
+    solc: 0.8.26
     source-map-support: ^0.5.13
     stacktrace-parser: ^0.1.10
     tsort: 0.0.1
@@ -12154,7 +11710,7 @@ __metadata:
       optional: true
   bin:
     hardhat: internal/cli/bootstrap.js
-  checksum: 0b5499890e46750ca8c51bbe1205599b1424a2e5293b40c9f7cb56320d56b9935fbd4e276de370e07664ae81fa57dc7ab227bf2b2363f5732ef9f06df1a9a6d9
+  checksum: 5aec1824db3575d63754de18c2629bcd820bc836d836f8a6346bcd9aa2ae4c397e090c43ea482ee765b704e018001015b5c84c5ded301a6a1144129c1a4c509b
   languageName: node
   linkType: hard
 
@@ -13119,7 +12675,7 @@ __metadata:
     eslint: ^8.57.0
     eslint-plugin-prettier: ^5.1.3
     ethers: ^6.7.1
-    hardhat: ^2.17.4
+    hardhat: ^2.22.6
     prettier: 3.2.5
     smol-toml: ^1.1.2
     toml: ^3.0.0
@@ -13247,7 +12803,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-buffer@npm:^2.0.0, is-buffer@npm:^2.0.5":
+"is-buffer@npm:^2.0.0":
   version: 2.0.5
   resolution: "is-buffer@npm:2.0.5"
   checksum: 764c9ad8b523a9f5a32af29bdf772b08eb48c04d2ad0a7240916ac2688c983bf5f8504bf25b35e66240edeb9d9085461f9b5dae1f3d2861c6b06a65fe983de42
@@ -13800,13 +13356,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"js-sdsl@npm:^4.1.4":
-  version: 4.4.2
-  resolution: "js-sdsl@npm:4.4.2"
-  checksum: ba705adc1788bf3c6f6c8e5077824f2bb4f0acab5a984420ce5cc492c7fff3daddc26335ad2c9a67d4f5e3241ec790f9e5b72a625adcf20cf321d2fd85e62b8b
-  languageName: node
-  linkType: hard
-
 "js-sha3@npm:0.8.0":
   version: 0.8.0
   resolution: "js-sha3@npm:0.8.0"
@@ -13943,18 +13492,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"jsonfile@npm:^2.1.0":
-  version: 2.4.0
-  resolution: "jsonfile@npm:2.4.0"
-  dependencies:
-    graceful-fs: ^4.1.6
-  dependenciesMeta:
-    graceful-fs:
-      optional: true
-  checksum: f5064aabbc9e35530dc471d8b203ae1f40dbe949ddde4391c6f6a6d310619a15f0efdae5587df594d1d70c555193aaeee9d2ed4aec9ffd5767bd5e4e62d49c3d
-  languageName: node
-  linkType: hard
-
 "jsonfile@npm:^4.0.0":
   version: 4.0.0
   resolution: "jsonfile@npm:4.0.0"
@@ -14053,18 +13590,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"klaw@npm:^1.0.0":
-  version: 1.3.1
-  resolution: "klaw@npm:1.3.1"
-  dependencies:
-    graceful-fs: ^4.1.9
-  dependenciesMeta:
-    graceful-fs:
-      optional: true
-  checksum: 8f69e4797c26e7c3f2426bfa85f38a3da3c2cb1b4c6bd850d2377aed440d41ce9d806f2885c2e2e224372c56af4b1d43b8a499adecf9a05e7373dc6b8b7c52e4
-  languageName: node
-  linkType: hard
-
 "kleur@npm:^3.0.3":
   version: 3.0.3
   resolution: "kleur@npm:3.0.3"
@@ -14266,33 +13791,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"level-supports@npm:^4.0.0":
-  version: 4.0.1
-  resolution: "level-supports@npm:4.0.1"
-  checksum: d4552b42bb8cdeada07b0f6356c7a90fefe76279147331f291aceae26e3e56d5f927b09ce921647c0230bfe03ddfbdcef332be921e5c2194421ae2bfa3cf6368
-  languageName: node
-  linkType: hard
-
-"level-transcoder@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "level-transcoder@npm:1.0.1"
-  dependencies:
-    buffer: ^6.0.3
-    module-error: ^1.0.1
-  checksum: 304f08d802faf3491a533b6d87ad8be3cabfd27f2713bbe9d4c633bf50fcb9460eab5a6776bf015e101ead7ba1c1853e05e7f341112f17a9d0cb37ee5a421a25
-  languageName: node
-  linkType: hard
-
-"level@npm:^8.0.0":
-  version: 8.0.0
-  resolution: "level@npm:8.0.0"
-  dependencies:
-    browser-level: ^1.0.1
-    classic-level: ^1.2.0
-  checksum: 13eb25bd71bfdca6cd714d1233adf9da97de9a8a4bf9f28d62a390b5c96d0250abaf983eb90eb8c4e89c7a985bb330750683d106f12670e5ea8fba1d7e608a1f
-  languageName: node
-  linkType: hard
-
 "levelup@npm:^0.18.2":
   version: 0.18.6
   resolution: "levelup@npm:0.18.6"
@@ -14718,13 +14216,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"mcl-wasm@npm:^0.7.1":
-  version: 0.7.9
-  resolution: "mcl-wasm@npm:0.7.9"
-  checksum: 6b6ed5084156b98b2db70b223e1ba2c01953970b48a2e0c4ea3eeb9296610e6b3bfb2a2cce9e92e2d7ad61778b5f5a630e705e663835e915ba188c174a0a37fa
-  languageName: node
-  linkType: hard
-
 "md5.js@npm:^1.3.4":
   version: 1.3.5
   resolution: "md5.js@npm:1.3.5"
@@ -15086,17 +14577,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"memory-level@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "memory-level@npm:1.0.0"
-  dependencies:
-    abstract-level: ^1.0.0
-    functional-red-black-tree: ^1.0.1
-    module-error: ^1.0.1
-  checksum: 80b1b7aedaf936e754adbcd7b9303018c3684fb32f9992fd967c448f145d177f16c724fbba9ed3c3590a9475fd563151eae664d69b83d2ad48714852e9fc5c72
-  languageName: node
-  linkType: hard
-
 "memorystream@npm:^0.3.1":
   version: 0.3.1
   resolution: "memorystream@npm:0.3.1"
@@ -15944,13 +15424,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"module-error@npm:^1.0.1, module-error@npm:^1.0.2":
-  version: 1.0.2
-  resolution: "module-error@npm:1.0.2"
-  checksum: 5d653e35bd55b3e95f8aee2cdac108082ea892e71b8f651be92cde43e4ee86abee4fa8bd7fc3fe5e68b63926d42f63c54cd17b87a560c31f18739295575a3962
-  languageName: node
-  linkType: hard
-
 "mrmime@npm:^1.0.0":
   version: 1.0.1
   resolution: "mrmime@npm:1.0.1"
@@ -16016,13 +15489,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"napi-macros@npm:^2.2.2":
-  version: 2.2.2
-  resolution: "napi-macros@npm:2.2.2"
-  checksum: c6f9bd71cdbbc37ddc3535aa5be481238641d89585b8a3f4d301cb89abf459e2d294810432bb7d12056d1f9350b1a0899a5afcf460237a3da6c398cf0fec7629
-  languageName: node
-  linkType: hard
-
 "natural-compare@npm:^1.4.0":
   version: 1.4.0
   resolution: "natural-compare@npm:1.4.0"
@@ -16125,7 +15591,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"node-gyp-build@npm:^4.2.0, node-gyp-build@npm:^4.3.0":
+"node-gyp-build@npm:^4.2.0":
   version: 4.7.1
   resolution: "node-gyp-build@npm:4.7.1"
   bin:
@@ -17685,7 +17151,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"queue-microtask@npm:^1.2.2, queue-microtask@npm:^1.2.3":
+"queue-microtask@npm:^1.2.2":
   version: 1.2.3
   resolution: "queue-microtask@npm:1.2.3"
   checksum: b676f8c040cdc5b12723ad2f91414d267605b26419d5c821ff03befa817ddd10e238d22b25d604920340fd73efd8ba795465a0377c4adf45a4a41e4234e42dc4
@@ -18420,7 +17886,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"require-from-string@npm:^2.0.0, require-from-string@npm:^2.0.2":
+"require-from-string@npm:^2.0.2":
   version: 2.0.2
   resolution: "require-from-string@npm:2.0.2"
   checksum: a03ef6895445f33a4015300c426699bc66b2b044ba7b670aa238610381b56d3f07c686251740d575e22f4c87531ba662d06937508f0f3c0f1ddc04db3130560b
@@ -18588,17 +18054,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"rimraf@npm:^2.2.8":
-  version: 2.7.1
-  resolution: "rimraf@npm:2.7.1"
-  dependencies:
-    glob: ^7.1.3
-  bin:
-    rimraf: ./bin.js
-  checksum: cdc7f6eacb17927f2a075117a823e1c5951792c6498ebcce81ca8203454a811d4cf8900314154d3259bb8f0b42ab17f67396a8694a54cae3283326e57ad250cd
-  languageName: node
-  linkType: hard
-
 "rimraf@npm:^3.0.2":
   version: 3.0.2
   resolution: "rimraf@npm:3.0.2"
@@ -18724,15 +18179,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"run-parallel-limit@npm:^1.1.0":
-  version: 1.1.0
-  resolution: "run-parallel-limit@npm:1.1.0"
-  dependencies:
-    queue-microtask: ^1.2.2
-  checksum: 672c3b87e7f939c684b9965222b361421db0930223ed1e43ebf0e7e48ccc1a022ea4de080bef4d5468434e2577c33b7681e3f03b7593fdc49ad250a55381123c
-  languageName: node
-  linkType: hard
-
 "run-parallel@npm:^1.1.9":
   version: 1.2.0
   resolution: "run-parallel@npm:1.2.0"
@@ -18742,13 +18188,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"rustbn.js@npm:~0.2.0":
-  version: 0.2.0
-  resolution: "rustbn.js@npm:0.2.0"
-  checksum: 2148e7ba34e70682907ee29df4784639e6eb025481b2c91249403b7ec57181980161868d9aa24822a5075dd1bb5a180dfedc77309e5f0d27b6301f9b563af99a
-  languageName: node
-  linkType: hard
-
 "rxjs@npm:^7.5.4":
   version: 7.8.1
   resolution: "rxjs@npm:7.8.1"
@@ -18840,7 +18279,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"scrypt-js@npm:3.0.1, scrypt-js@npm:^3.0.0":
+"scrypt-js@npm:^3.0.0":
   version: 3.0.1
   resolution: "scrypt-js@npm:3.0.1"
   checksum: b7c7d1a68d6ca946f2fbb0778e0c4ec63c65501b54023b2af7d7e9f48fdb6c6580d6f7675cd53bda5944c5ebc057560d5a6365079752546865defb3b79dea454
@@ -19332,22 +18771,20 @@ __metadata:
   languageName: node
   linkType: hard
 
-"solc@npm:0.7.3":
-  version: 0.7.3
-  resolution: "solc@npm:0.7.3"
+"solc@npm:0.8.26":
+  version: 0.8.26
+  resolution: "solc@npm:0.8.26"
   dependencies:
     command-exists: ^1.2.8
-    commander: 3.0.2
+    commander: ^8.1.0
     follow-redirects: ^1.12.1
-    fs-extra: ^0.30.0
     js-sha3: 0.8.0
     memorystream: ^0.3.1
-    require-from-string: ^2.0.0
     semver: ^5.5.0
     tmp: 0.0.33
   bin:
-    solcjs: solcjs
-  checksum: 2d8eb16c6d8f648213c94dc8d977cffe5099cba7d41c82d92d769ef71ae8320a985065ce3d6c306440a85f8e8d2b27fb30bdd3ac38f69e5c1fa0ab8a3fb2f217
+    solcjs: solc.js
+  checksum: e3eaeac76e60676377b357af8f3919d4c8c6a74b74112b49279fe8c74a3dfa1de8afe4788689fc307453bde336edc8572988d2cf9e909f84d870420eb640400c
   languageName: node
   linkType: hard
 
@@ -21628,21 +21065,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ws@npm:7.4.6":
-  version: 7.4.6
-  resolution: "ws@npm:7.4.6"
-  peerDependencies:
-    bufferutil: ^4.0.1
-    utf-8-validate: ^5.0.2
-  peerDependenciesMeta:
-    bufferutil:
-      optional: true
-    utf-8-validate:
-      optional: true
-  checksum: 3a990b32ed08c72070d5e8913e14dfcd831919205be52a3ff0b4cdd998c8d554f167c9df3841605cde8b11d607768cacab3e823c58c96a5c08c987e093eb767a
-  languageName: node
-  linkType: hard
-
 "ws@npm:8.16.0, ws@npm:^8.16.0":
   version: 8.16.0
   resolution: "ws@npm:8.16.0"