feat(avm-transpiler): add support for nested contract calls

avm-transpiler/src/opcodes.rs

@@ -66,7 +66,7 @@ pub enum AvmOpcode {
     EMITNOTEHASH,    // Notes & Nullifiers
     NULLIFIEREXISTS, // Notes & Nullifiers
     EMITNULLIFIER,   // Notes & Nullifiers
-    READL1TOL2MSG,   // Messages
+    L1TOL2MSGEXISTS, // Messages
     HEADERMEMBER,    // Archive tree & Headers
 
     // Accrued Substate
@@ -154,7 +154,7 @@ impl AvmOpcode {
             AvmOpcode::EMITNOTEHASH => "EMITNOTEHASH", // Notes & Nullifiers
             AvmOpcode::NULLIFIEREXISTS => "NULLIFIEREXISTS", // Notes & Nullifiers
             AvmOpcode::EMITNULLIFIER => "EMITNULLIFIER", // Notes & Nullifiers
-            AvmOpcode::READL1TOL2MSG => "READL1TOL2MSG", // Messages
+            AvmOpcode::L1TOL2MSGEXISTS => "L1TOL2MSGEXISTS", // Messages
             AvmOpcode::HEADERMEMBER => "HEADERMEMBER", // Archive tree & Headers
 
             // Accrued Substate

avm-transpiler/src/transpile.rs

@@ -239,17 +239,20 @@ fn handle_foreign_call(
 ) {
     match function.as_str() {
         "avmOpcodeNoteHashExists" => handle_note_hash_exists(avm_instrs, destinations, inputs),
-        "emitNoteHash" | "emitNullifier" => handle_emit_note_hash_or_nullifier(
-            function.as_str() == "emitNullifier",
+        "avmOpcodeEmitNoteHash" | "avmOpcodeEmitNullifier" => handle_emit_note_hash_or_nullifier(
+            function.as_str() == "avmOpcodeEmitNullifier",
             avm_instrs,
             destinations,
             inputs,
         ),
-        "nullifierExists" => handle_nullifier_exists(avm_instrs, destinations, inputs),
-        "keccak256" | "sha256" => {
+        "avmOpcodeNullifierExists" => handle_nullifier_exists(avm_instrs, destinations, inputs),
+        "avmOpcodeL1ToL2MsgExists" => handle_l1_to_l2_msg_exists(avm_instrs, destinations, inputs),
+        "avmOpcodeSendL2ToL1Msg" => handle_send_l2_to_l1_msg(avm_instrs, destinations, inputs),
+        "avmOpcodeCall" => handle_external_call(avm_instrs, destinations, inputs),
+        "avmOpcodeKeccak256" | "avmOpcodeSha256" => {
             handle_2_field_hash_instruction(avm_instrs, function, destinations, inputs)
         }
-        "poseidon" => {
+        "avmOpcodePoseidon" => {
             handle_single_field_hash_instruction(avm_instrs, function, destinations, inputs)
         }
         _ => handle_getter_instruction(avm_instrs, function, destinations, inputs),
@@ -374,6 +377,174 @@ fn handle_nullifier_exists(
     });
 }
 
+/// Handle an AVM L1TOL2MSGEXISTS instruction
+/// (a l1ToL2MsgExists brillig foreign call was encountered)
+/// Adds the new instruction to the avm instructions list.
+fn handle_l1_to_l2_msg_exists(
+    avm_instrs: &mut Vec<AvmInstruction>,
+    destinations: &Vec<ValueOrArray>,
+    inputs: &Vec<ValueOrArray>,
+) {
+    if destinations.len() != 1 || inputs.len() != 2 {
+        panic!(
+            "Transpiler expects ForeignCall::L1TOL2MSGEXISTS to have 1 destinations and 2 input, got {} and {}",
+            destinations.len(),
+            inputs.len()
+        );
+    }
+    let msg_hash_offset_operand = match &inputs[0] {
+        ValueOrArray::MemoryAddress(offset) => offset.to_usize() as u32,
+        _ => panic!(
+            "Transpiler does not know how to handle ForeignCall::L1TOL2MSGEXISTS with HeapArray/Vector inputs",
+        ),
+    };
+    let msg_leaf_index_offset_operand = match &inputs[1] {
+        ValueOrArray::MemoryAddress(offset) => offset.to_usize() as u32,
+        _ => panic!(
+            "Transpiler does not know how to handle ForeignCall::L1TOL2MSGEXISTS with HeapArray/Vector inputs",
+        ),
+    };
+    let exists_offset_operand = match &destinations[0] {
+        ValueOrArray::MemoryAddress(offset) => offset.to_usize() as u32,
+        _ => panic!(
+            "Transpiler does not know how to handle ForeignCall::L1TOL2MSGEXISTS with HeapArray/Vector inputs",
+        ),
+    };
+    avm_instrs.push(AvmInstruction {
+        opcode: AvmOpcode::L1TOL2MSGEXISTS,
+        indirect: Some(ALL_DIRECT),
+        operands: vec![
+            AvmOperand::U32 {
+                value: msg_hash_offset_operand,
+            },
+            AvmOperand::U32 {
+                value: msg_leaf_index_offset_operand,
+            },
+            AvmOperand::U32 {
+                value: exists_offset_operand,
+            },
+        ],
+        ..Default::default()
+    });
+}
+
+/// Handle an AVM SENDL2TOL1MSG
+/// (a sendL2ToL1Msg brillig foreign call was encountered)
+/// Adds the new instruction to the avm instructions list.
+fn handle_send_l2_to_l1_msg(
+    avm_instrs: &mut Vec<AvmInstruction>,
+    destinations: &Vec<ValueOrArray>,
+    inputs: &Vec<ValueOrArray>,
+) {
+    if destinations.len() != 0 || inputs.len() != 2 {
+        panic!(
+            "Transpiler expects ForeignCall::SENDL2TOL1MSG to have 0 destinations and 2 inputs, got {} and {}",
+            destinations.len(),
+            inputs.len()
+        );
+    }
+    let recipient_offset_operand = match &inputs[0] {
+        ValueOrArray::MemoryAddress(offset) => offset.to_usize() as u32,
+        _ => panic!(
+            "Transpiler does not know how to handle ForeignCall::SENDL2TOL1MSG with HeapArray/Vector inputs",
+        ),
+    };
+    let content_offset_operand = match &inputs[1] {
+        ValueOrArray::MemoryAddress(offset) => offset.to_usize() as u32,
+        _ => panic!(
+            "Transpiler does not know how to handle ForeignCall::SENDL2TOL1MSG with HeapArray/Vector inputs",
+        ),
+    };
+    avm_instrs.push(AvmInstruction {
+        opcode: AvmOpcode::SENDL2TOL1MSG,
+        indirect: Some(ALL_DIRECT),
+        operands: vec![
+            AvmOperand::U32 {
+                value: recipient_offset_operand,
+            },
+            AvmOperand::U32 {
+                value: content_offset_operand,
+            },
+        ],
+        ..Default::default()
+    });
+}
+
+/// Handle an AVM CALL
+/// (an external 'call' brillig foreign call was encountered)
+/// Adds the new instruction to the avm instructions list.
+fn handle_external_call(
+    avm_instrs: &mut Vec<AvmInstruction>,
+    destinations: &Vec<ValueOrArray>,
+    inputs: &Vec<ValueOrArray>,
+) {
+    if destinations.len() != 2 || inputs.len() != 4 {
+        panic!(
+            "Transpiler expects ForeignCall::CALL to have 2 destinations and 4 inputs, got {} and {}.
+            Make sure your call instructions's input/return arrays have static length (`[Field; <size>]`)!",
+            destinations.len(),
+            inputs.len()
+        );
+    }
+    let gas_offset_maybe = inputs[0];
+    let gas_offset = match gas_offset_maybe {
+        ValueOrArray::HeapArray(HeapArray { pointer, size }) => {
+            assert!(size == 3, "Call instruction's gas input should be a HeapArray of size 3 (`[l1Gas, l2Gas, daGas]`)");
+            pointer.0 as u64
+        }
+        ValueOrArray::HeapVector(_) => panic!("Call instruction's gas input must be a HeapArray, not a HeapVector. Make sure you are explicitly defining its size as 3 (`[l1Gas, l2Gas, daGas]`)!"),
+        _ => panic!("Call instruction's gas input should be a HeapArray"),
+    };
+    let address_offset = match &inputs[1] {
+        ValueOrArray::MemoryAddress(offset) => offset.to_usize() as u32,
+        _ => panic!("Call instruction's target address input should be a basic MemoryAddress",),
+    };
+    let args_offset_maybe = inputs[2];
+    let (args_offset, args_size) = match args_offset_maybe {
+        ValueOrArray::HeapArray(HeapArray { pointer, size }) => (pointer.0 as u64, size as u32),
+        ValueOrArray::HeapVector(_) => panic!("Call instruction's args must be a HeapArray, not a HeapVector. Make sure you are explicitly defining its size (`[arg0, arg1, ... argN]`)!"),
+        _ => panic!("Call instruction's args input should be a HeapArray input"),
+    };
+    let temporary_function_selector_offset = match &inputs[3] {
+        ValueOrArray::MemoryAddress(offset) => offset.to_usize() as u32,
+        _ => panic!(
+            "Call instruction's temporary function selector input should be a basic MemoryAddress",
+        ),
+    };
+
+    let ret_offset_maybe = destinations[0];
+    let (ret_offset, ret_size) = match ret_offset_maybe {
+        ValueOrArray::HeapArray(HeapArray { pointer, size }) => (pointer.0 as u64, size as u32),
+        ValueOrArray::HeapVector(_) => panic!("Call instruction's return data must be a HeapArray, not a HeapVector. Make sure you are explicitly defining its size (`let returnData: [Field; <size>] = ...`)!"),
+        _ => panic!("Call instruction's returnData destination should be a HeapArray input"),
+    };
+    let success_offset = match &destinations[1] {
+        ValueOrArray::MemoryAddress(offset) => offset.to_usize() as u32,
+        _ => panic!("Call instruction's success destination should be a basic MemoryAddress",),
+    };
+    avm_instrs.push(AvmInstruction {
+        opcode: AvmOpcode::CALL,
+        indirect: Some(0b01101), // (left to right) selector direct, ret offset INDIRECT, args offset INDIRECT, address offset direct, gas offset INDIRECT
+        operands: vec![
+            AvmOperand::U64 { value: gas_offset },
+            AvmOperand::U32 {
+                value: address_offset,
+            },
+            AvmOperand::U64 { value: args_offset },
+            AvmOperand::U32 { value: args_size },
+            AvmOperand::U64 { value: ret_offset },
+            AvmOperand::U32 { value: ret_size },
+            AvmOperand::U32 {
+                value: success_offset,
+            },
+            AvmOperand::U32 {
+                value: temporary_function_selector_offset,
+            },
+        ],
+        ..Default::default()
+    });
+}
+
 /// Two field hash instructions represent instruction's that's outputs are larger than a field element
 ///
 /// This includes:
@@ -406,8 +577,8 @@ fn handle_2_field_hash_instruction(
     };
 
     let opcode = match function.as_str() {
-        "keccak256" => AvmOpcode::KECCAK,
-        "sha256" => AvmOpcode::SHA256,
+        "avmOpcodeKeccak256" => AvmOpcode::KECCAK,
+        "avmOpcodeSha256" => AvmOpcode::SHA256,
         _ => panic!(
             "Transpiler doesn't know how to process ForeignCall function {:?}",
             function
@@ -416,13 +587,13 @@ fn handle_2_field_hash_instruction(
 
     avm_instrs.push(AvmInstruction {
         opcode,
-        indirect: Some(3), // 11 - addressing mode, indirect for input and output
+        indirect: Some(0b011), // dest offset and hash offset indirect
         operands: vec![
-            AvmOperand::U32 {
-                value: dest_offset as u32,
+            AvmOperand::U64 {
+                value: dest_offset as u64,
             },
-            AvmOperand::U32 {
-                value: hash_offset as u32,
+            AvmOperand::U64 {
+                value: hash_offset as u64,
             },
             AvmOperand::U32 {
                 value: hash_size as u32,
@@ -462,7 +633,7 @@ fn handle_single_field_hash_instruction(
     };
 
     let opcode = match function.as_str() {
-        "poseidon" => AvmOpcode::POSEIDON,
+        "avmOpcodePoseidon" => AvmOpcode::POSEIDON,
         _ => panic!(
             "Transpiler doesn't know how to process ForeignCall function {:?}",
             function
@@ -471,13 +642,13 @@ fn handle_single_field_hash_instruction(
 
     avm_instrs.push(AvmInstruction {
         opcode,
-        indirect: Some(1),
+        indirect: Some(0b10), // hash offset indirect
         operands: vec![
             AvmOperand::U32 {
                 value: dest_offset as u32,
             },
-            AvmOperand::U32 {
-                value: hash_offset as u32,
+            AvmOperand::U64 {
+                value: hash_offset as u64,
             },
             AvmOperand::U32 {
                 value: hash_size as u32,
@@ -511,18 +682,18 @@ fn handle_getter_instruction(
     };
 
     let opcode = match function.as_str() {
-        "address" => AvmOpcode::ADDRESS,
-        "storageAddress" => AvmOpcode::STORAGEADDRESS,
-        "origin" => AvmOpcode::ORIGIN,
-        "sender" => AvmOpcode::SENDER,
-        "portal" => AvmOpcode::PORTAL,
-        "feePerL1Gas" => AvmOpcode::FEEPERL1GAS,
-        "feePerL2Gas" => AvmOpcode::FEEPERL2GAS,
-        "feePerDaGas" => AvmOpcode::FEEPERDAGAS,
-        "chainId" => AvmOpcode::CHAINID,
-        "version" => AvmOpcode::VERSION,
-        "blockNumber" => AvmOpcode::BLOCKNUMBER,
-        "timestamp" => AvmOpcode::TIMESTAMP,
+        "avmOpcodeAddress" => AvmOpcode::ADDRESS,
+        "avmOpcodeStorageAddress" => AvmOpcode::STORAGEADDRESS,
+        "avmOpcodeOrigin" => AvmOpcode::ORIGIN,
+        "avmOpcodeSender" => AvmOpcode::SENDER,
+        "avmOpcodePortal" => AvmOpcode::PORTAL,
+        "avmOpcodeFeePerL1Gas" => AvmOpcode::FEEPERL1GAS,
+        "avmOpcodeFeePerL2Gas" => AvmOpcode::FEEPERL2GAS,
+        "avmOpcodeFeePerDaGas" => AvmOpcode::FEEPERDAGAS,
+        "avmOpcodeChainId" => AvmOpcode::CHAINID,
+        "avmOpcodeVersion" => AvmOpcode::VERSION,
+        "avmOpcodeBlockNumber" => AvmOpcode::BLOCKNUMBER,
+        "avmOpcodeTimestamp" => AvmOpcode::TIMESTAMP,
         // "callStackDepth" => AvmOpcode::CallStackDepth,
         _ => panic!(
             "Transpiler doesn't know how to process ForeignCall function {:?}",
@@ -638,7 +809,7 @@ fn handle_black_box_function(avm_instrs: &mut Vec<AvmInstruction>, operation: &B
 
             avm_instrs.push(AvmInstruction {
                 opcode: AvmOpcode::PEDERSEN,
-                indirect: Some(1),
+                indirect: Some(0b10), // hash offset indirect
                 operands: vec![
                     AvmOperand::U32 {
                         value: dest_offset as u32,

barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_opcode.cpp

@@ -72,7 +72,7 @@ const std::unordered_map<OpCode, size_t> Bytecode::OPERANDS_NUM = {
     //{ OpCode::EMITNOTEHASH, }, // Notes & Nullifiers
     //{ OpCode::NULLIFIEREXISTS, }, // Notes & Nullifiers
     //{ OpCode::EMITNULLIFIER, }, // Notes & Nullifiers
-    //{ OpCode::READL1TOL2MSG, }, // Messages
+    //{ OpCode::L1TOL2MSGEXISTS, }, // Messages
     //{ OpCode::HEADERMEMBER, },
 
     //// Accrued Substate
@@ -146,7 +146,7 @@ bool Bytecode::has_in_tag(OpCode const op_code)
     case OpCode::EMITNOTEHASH:
     case OpCode::NULLIFIEREXISTS:
     case OpCode::EMITNULLIFIER:
-    case OpCode::READL1TOL2MSG:
+    case OpCode::L1TOL2MSGEXISTS:
     case OpCode::HEADERMEMBER:
     case OpCode::EMITUNENCRYPTEDLOG:
     case OpCode::SENDL2TOL1MSG:

barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_opcode.hpp

@@ -80,7 +80,7 @@ enum class OpCode : uint8_t {
     EMITNOTEHASH,    // Notes & Nullifiers
     NULLIFIEREXISTS, // Notes & Nullifiers
     EMITNULLIFIER,   // Notes & Nullifiers
-    READL1TOL2MSG,   // Messages
+    L1TOL2MSGEXISTS, // Messages
     HEADERMEMBER,    // Archive tree & Headers
 
     // Accrued Substate

noir-projects/aztec-nr/aztec/src/avm/hash.nr

@@ -1,8 +1,8 @@
-#[oracle(keccak256)]
+#[oracle(avmOpcodeKeccak256)]
 pub fn keccak256<N>(input: [Field; N]) -> [Field; 2] {}
 
-#[oracle(poseidon)]
+#[oracle(avmOpcodePoseidon)]
 pub fn poseidon<N>(input: [Field; N]) -> Field {}
 
-#[oracle(sha256)]
+#[oracle(avmOpcodeSha256)]
 pub fn sha256<N>(input: [Field; N]) -> [Field; 2] {}