feat(avm): storage

avm-transpiler/src/instructions.rs

@@ -7,6 +7,7 @@ use crate::opcodes::AvmOpcode;
 pub const ALL_DIRECT: u8 = 0b00000000;
 pub const ZEROTH_OPERAND_INDIRECT: u8 = 0b00000001;
 pub const FIRST_OPERAND_INDIRECT: u8 = 0b00000010;
+pub const SECOND_OPERAND_INDIRECT: u8 = 0b00000100;
 pub const ZEROTH_FIRST_OPERANDS_INDIRECT: u8 = ZEROTH_OPERAND_INDIRECT | FIRST_OPERAND_INDIRECT;
 
 /// A simple representation of an AVM instruction for the purpose

avm-transpiler/src/transpile.rs

@@ -7,7 +7,7 @@ use acvm::brillig_vm::brillig::{
 
 use crate::instructions::{
     AvmInstruction, AvmOperand, AvmTypeTag, ALL_DIRECT, FIRST_OPERAND_INDIRECT,
-    ZEROTH_OPERAND_INDIRECT,
+    SECOND_OPERAND_INDIRECT, ZEROTH_OPERAND_INDIRECT,
 };
 use crate::opcodes::AvmOpcode;
 use crate::utils::{dbg_print_avm_program, dbg_print_brillig_program};
@@ -257,8 +257,10 @@ fn handle_foreign_call(
         "avmOpcodePoseidon" => {
             handle_single_field_hash_instruction(avm_instrs, function, destinations, inputs)
         }
+        "storageWrite" => emit_storage_write(avm_instrs, destinations, inputs),
+        "storageRead" => emit_storage_read(avm_instrs, destinations, inputs),
         // Getters.
-        _ if inputs.len() == 0 && destinations.len() == 1 => {
+        _ if inputs.is_empty() && destinations.len() == 1 => {
             handle_getter_instruction(avm_instrs, function, destinations, inputs)
         }
         // Anything else.
@@ -361,7 +363,7 @@ fn handle_emit_note_hash_or_nullifier(
         "EMITNOTEHASH"
     };
 
-    if destinations.len() != 0 || inputs.len() != 1 {
+    if !destinations.is_empty() || inputs.len() != 1 {
         panic!(
             "Transpiler expects ForeignCall::{} to have 0 destinations and 1 input, got {} and {}",
             function_name,
@@ -390,6 +392,88 @@ fn handle_emit_note_hash_or_nullifier(
     });
 }
 
+/// Emit a storage write opcode
+/// The current implementation writes an array of values into storage ( contiguous slots in memory )
+fn emit_storage_write(
+    avm_instrs: &mut Vec<AvmInstruction>,
+    destinations: &Vec<ValueOrArray>,
+    inputs: &Vec<ValueOrArray>,
+) {
+    // For the foreign calls we want to handle, we do not want inputs, as they are getters
+    assert!(inputs.len() == 2);
+    assert!(destinations.len() == 1); // TODO: we want this to be empty - change aztec nr?
+
+    let slot_offset_maybe = inputs[0];
+    let slot_offset = match slot_offset_maybe {
+        ValueOrArray::MemoryAddress(slot_offset) => slot_offset.0,
+        _ => panic!("ForeignCall address destination should be a single value"),
+    };
+
+    let src_offset_maybe = inputs[1];
+    let (src_offset, src_size) = match src_offset_maybe {
+        ValueOrArray::HeapArray(HeapArray { pointer, size }) => (pointer.0, size),
+        _ => panic!("Storage write address inputs should be an array of values"),
+    };
+
+    avm_instrs.push(AvmInstruction {
+        opcode: AvmOpcode::SSTORE,
+        indirect: Some(ZEROTH_OPERAND_INDIRECT),
+        operands: vec![
+            AvmOperand::U32 {
+                value: src_offset as u32,
+            },
+            AvmOperand::U32 {
+                value: src_size as u32,
+            },
+            AvmOperand::U32 {
+                value: slot_offset as u32,
+            },
+        ],
+        ..Default::default()
+    })
+}
+
+/// Emit a storage read opcode
+/// The current implementation reads an array of values from storage ( contiguous slots in memory )
+fn emit_storage_read(
+    avm_instrs: &mut Vec<AvmInstruction>,
+    destinations: &Vec<ValueOrArray>,
+    inputs: &Vec<ValueOrArray>,
+) {
+    // For the foreign calls we want to handle, we do not want inputs, as they are getters
+    assert!(inputs.len() == 2); // output, len - but we dont use this len - its for the oracle
+    assert!(destinations.len() == 1);
+
+    let slot_offset_maybe = inputs[0];
+    let slot_offset = match slot_offset_maybe {
+        ValueOrArray::MemoryAddress(slot_offset) => slot_offset.0,
+        _ => panic!("ForeignCall address destination should be a single value"),
+    };
+
+    let dest_offset_maybe = destinations[0];
+    let (dest_offset, src_size) = match dest_offset_maybe {
+        ValueOrArray::HeapArray(HeapArray { pointer, size }) => (pointer.0, size),
+        _ => panic!("Storage write address inputs should be an array of values"),
+    };
+
+    avm_instrs.push(AvmInstruction {
+        opcode: AvmOpcode::SLOAD,
+        indirect: Some(SECOND_OPERAND_INDIRECT),
+        operands: vec![
+            AvmOperand::U32 {
+                value: slot_offset as u32,
+            },
+            AvmOperand::U32 {
+                value: src_size as u32,
+            },
+            AvmOperand::U32 {
+                value: dest_offset as u32,
+            },
+        ],
+        ..Default::default()
+    })
+}
+
 /// Handle an AVM NULLIFIEREXISTS instruction
 /// (a nullifierExists brillig foreign call was encountered)
 /// Adds the new instruction to the avm instructions list.
@@ -483,7 +567,7 @@ fn handle_send_l2_to_l1_msg(
     destinations: &Vec<ValueOrArray>,
     inputs: &Vec<ValueOrArray>,
 ) {
-    if destinations.len() != 0 || inputs.len() != 2 {
+    if !destinations.is_empty() || inputs.len() != 2 {
         panic!(
             "Transpiler expects ForeignCall::SENDL2TOL1MSG to have 0 destinations and 2 inputs, got {} and {}",
             destinations.len(),

noir-projects/aztec-nr/aztec/src/context.nr

@@ -14,18 +14,23 @@ use avm::AVMContext;
 struct Context {
     private: Option<&mut PrivateContext>,
     public: Option<&mut PublicContext>,
+    public_vm: Option<&mut AVMContext>,
 }
 
 impl Context {
     pub fn private(context: &mut PrivateContext) -> Context {
-        Context { private: Option::some(context), public: Option::none() }
+        Context { private: Option::some(context), public: Option::none(), public_vm: Option::none() }
     }
 
     pub fn public(context: &mut PublicContext) -> Context {
-        Context { public: Option::some(context), private: Option::none() }
+        Context { public: Option::some(context), private: Option::none(), public_vm: Option::none() }
+    }
+
+    pub fn public_vm(context: &mut AVMContext) -> Context {
+        Context { public_vm: Option::some(context), public: Option::none(), private: Option::none() }
     }
 
     pub fn none() -> Context {
-        Context { public: Option::none(), private: Option::none() }
+        Context { public: Option::none(), private: Option::none(), public_vm: Option::none() }
     }
 }

noir-projects/noir-contracts/contracts/avm_test_contract/src/main.nr

@@ -1,5 +1,6 @@
 contract AvmTest {
     // Libs
+    use dep::aztec::state_vars::PublicMutable;
     use dep::aztec::protocol_types::{address::{AztecAddress, EthAddress}, constants::L1_TO_L2_MESSAGE_LENGTH};
     use dep::compressed_string::CompressedString;
 
@@ -9,7 +10,21 @@ contract AvmTest {
     #[aztec(private)]
     fn constructor() {}
 
-    // Public-vm macro will prefix avm to the function name for transpilation
+    struct Storage {
+        owner: PublicMutable<AztecAddress>
+    }
+
+    #[aztec(public-vm)]
+    fn setAdmin() {
+        storage.owner.write(context.sender());
+    }
+
+    #[aztec(public-vm)]
+    fn setAndRead() -> pub AztecAddress {
+        storage.owner.write(context.sender());
+        storage.owner.read()
+    }
+
     #[aztec(public-vm)]
     fn addArgsReturn(argA: Field, argB: Field) -> pub Field {
         argA + argB
@@ -41,7 +56,6 @@ contract AvmTest {
     // fn setOpcodeUint128() -> pub u128 {
     //     1 << 120 as u128
     // }
-
     // Field should fit in 128 bits
     // ACIR only supports fields of up to 126 bits!
     // Same with internal fields for unconstrained functions, apprently.

noir/noir-repo/aztec_macros/src/lib.rs

@@ -727,8 +727,14 @@ fn transform_function(
 /// Transform a function to work with AVM bytecode
 fn transform_vm_function(
     func: &mut NoirFunction,
-    _storage_defined: bool,
+    storage_defined: bool,
 ) -> Result<(), AztecMacroError> {
+    // Create access to storage
+    if storage_defined {
+        let storage = abstract_storage("public_vm", true);
+        func.def.body.0.insert(0, storage);
+    }
+
     // Push Avm context creation to the beginning of the function
     let create_context = create_avm_context()?;
     func.def.body.0.insert(0, create_context);

noir/noir-repo/compiler/noirc_evaluator/src/brillig/brillig_ir.rs

@@ -32,7 +32,7 @@ use num_bigint::BigUint;
 /// The Brillig VM does not apply a limit to the memory address space,
 /// As a convention, we take use 64 bits. This means that we assume that
 /// memory has 2^64 memory slots.
-pub(crate) const BRILLIG_MEMORY_ADDRESSING_BIT_SIZE: u32 = 32;
+pub(crate) const BRILLIG_MEMORY_ADDRESSING_BIT_SIZE: u32 = 64;
 
 // Registers reserved in runtime for special purposes.
 pub(crate) enum ReservedRegisters {
@@ -562,6 +562,7 @@ impl BrilligContext {
         bit_size: u32,
     ) {
         self.debug_show.const_instruction(result, constant);
+
         self.push_opcode(BrilligOpcode::Const { destination: result, value: constant, bit_size });
     }
 

noir/noir-repo/test_programs/noir_test_failure/should_fail_suite_with_one_failure/Nargo.toml

@@ -0,0 +1,5 @@
+[package]
+name = "should_fail_with_mismatch"
+type = "bin"
+authors = [""]
+[dependencies]

yarn-project/simulator/src/avm/avm_memory_types.ts

@@ -255,6 +255,12 @@ export class TaggedMemory {
     }
   }
 
+  public checkTagLessThanEqual(tag: TypeTag, offset: number) {
+    if (this.getTag(offset) > tag) {
+      throw TagCheckError.forOffset(offset, TypeTag[this.getTag(offset)], TypeTag[tag]);
+    }
+  }
+
   public static checkIsIntegralTag(tag: TypeTag) {
     if (![TypeTag.UINT8, TypeTag.UINT16, TypeTag.UINT32, TypeTag.UINT64, TypeTag.UINT128].includes(tag)) {
       throw TagCheckError.forTag(TypeTag[tag], 'integral');

yarn-project/simulator/src/avm/avm_simulator.test.ts

@@ -111,6 +111,68 @@ describe('AVM simulator', () => {
       });
     });
 
+    describe('Storage accesses', () => {
+      it('Should set a single value in storage', async () => {
+        // We want to set
+        const calldata: Fr[] = [];
+        // We are setting the owner
+        const slot = 1n;
+        const sender = AztecAddress.fromField(new Fr(1));
+        const address = AztecAddress.fromField(new Fr(420));
+
+        // Get contract function artifact
+        const artifact = AvmTestContractArtifact.functions.find(f => f.name === 'avm_setAdmin')!;
+
+        // Decode bytecode into instructions
+        const bytecode = Buffer.from(artifact.bytecode, 'base64');
+
+        const context = initContext({
+          env: initExecutionEnvironment({ calldata, sender, address, storageAddress: address }),
+        });
+        jest
+          .spyOn(context.persistableState.hostStorage.contractsDb, 'getBytecode')
+          .mockReturnValue(Promise.resolve(bytecode));
+
+        const simulator = new AvmSimulator(context);
+        const results = await simulator.execute();
+        expect(results.reverted).toBe(false);
+
+        // Contract 420 - Storage slot 1 should contain the value 1
+        const worldState = context.persistableState.flush();
+
+        const storageSlot = worldState.currentStorageValue.get(address.toBigInt())!;
+        const adminSlotValue = storageSlot.get(slot)!;
+        expect(adminSlotValue).toEqual(sender.toField());
+      });
+
+      it('Should read a value from storage', async () => {
+        const calldata: Fr[] = [];
+        // We are setting the owner
+        const sender = AztecAddress.fromField(new Fr(1));
+        const address = AztecAddress.fromField(new Fr(420));
+
+        // Get contract function artifact
+        const artifact = AvmTestContractArtifact.functions.find(f => f.name === 'avm_setAndRead')!;
+
+        // Decode bytecode into instructions
+        const bytecode = Buffer.from(artifact.bytecode, 'base64');
+
+        const context = initContext({
+          env: initExecutionEnvironment({ calldata, sender, address, storageAddress: address }),
+        });
+        jest
+          .spyOn(context.persistableState.hostStorage.contractsDb, 'getBytecode')
+          .mockReturnValue(Promise.resolve(bytecode));
+
+        const simulator = new AvmSimulator(context);
+        const results = await simulator.execute();
+        expect(results.reverted).toBe(false);
+
+        const returnData = results.output;
+        expect(returnData[0]).toEqual(sender.toField());
+      });
+    });
+
     describe('Test env getters from noir contract', () => {
       const testEnvGetter = async (valueName: string, value: any, functionName: string, globalVar: boolean = false) => {
         // Execute

yarn-project/simulator/src/avm/journal/journal.test.ts

@@ -39,7 +39,7 @@ describe('journal', () => {
       expect(cacheMissResult).toEqual(storedValue);
 
       // Write to storage
-      journal.writeStorage(contractAddress, key, cachedValue);
+      journal.writeStorage(contractAddress, key, [cachedValue]);
 
       // Get the storage value
       const cachedResult = await journal.readStorage(contractAddress, key);
@@ -157,7 +157,7 @@ describe('journal', () => {
     const index = new Fr(42);
     const indexT1 = new Fr(24);
 
-    journal.writeStorage(contractAddress, key, value);
+    journal.writeStorage(contractAddress, key, [value]);
     await journal.readStorage(contractAddress, key);
     journal.writeNoteHash(commitment);
     journal.writeLog(new Fr(log.address), new Fr(log.selector), log.data);
@@ -167,7 +167,7 @@ describe('journal', () => {
     await journal.checkL1ToL2MessageExists(commitment, index);
 
     const childJournal = new AvmPersistableStateManager(journal.hostStorage, journal);
-    childJournal.writeStorage(contractAddress, key, valueT1);
+    childJournal.writeStorage(contractAddress, key, [valueT1]);
     await childJournal.readStorage(contractAddress, key);
     childJournal.writeNoteHash(commitmentT1);
     childJournal.writeLog(new Fr(logT1.address), new Fr(logT1.selector), logT1.data);
@@ -246,7 +246,7 @@ describe('journal', () => {
     const index = new Fr(42);
     const indexT1 = new Fr(24);
 
-    journal.writeStorage(contractAddress, key, value);
+    journal.writeStorage(contractAddress, key, [value]);
     await journal.readStorage(contractAddress, key);
     journal.writeNoteHash(commitment);
     await journal.writeNullifier(contractAddress, commitment);
@@ -256,7 +256,7 @@ describe('journal', () => {
     journal.writeL1Message(recipient, commitment);
 
     const childJournal = new AvmPersistableStateManager(journal.hostStorage, journal);
-    childJournal.writeStorage(contractAddress, key, valueT1);
+    childJournal.writeStorage(contractAddress, key, [valueT1]);
     await childJournal.readStorage(contractAddress, key);
     childJournal.writeNoteHash(commitmentT1);
     await childJournal.writeNullifier(contractAddress, commitmentT1);

yarn-project/simulator/src/avm/journal/journal.ts

@@ -78,11 +78,11 @@ export class AvmPersistableStateManager {
    * @param slot - the slot in the contract's storage being written to
    * @param value - the value being written to the slot
    */
-  public writeStorage(storageAddress: Fr, slot: Fr, value: Fr) {
+  public writeStorage(storageAddress: Fr, slot: Fr, values: /*temporarily an array*/ Fr[]) {
     // Cache storage writes for later reference/reads
-    this.publicStorage.write(storageAddress, slot, value);
+    this.publicStorage.write(storageAddress, slot, values);
     // Trace all storage writes (even reverted ones)
-    this.trace.tracePublicStorageWrite(storageAddress, slot, value);
+    this.trace.tracePublicStorageWrite(storageAddress, slot, values);
   }
 
   /**