@aztec/simulator 0.33.0 → 0.35.0

package/src/avm/journal/trace.ts

@@ -1,23 +1,28 @@
 import { Fr } from '@aztec/foundation/fields';
 
-import { type TracedL1toL2MessageCheck, type TracedNoteHashCheck, type TracedNullifierCheck } from './trace_types.js';
+import {
+  type TracedL1toL2MessageCheck,
+  type TracedNoteHash,
+  type TracedNoteHashCheck,
+  type TracedNullifier,
+  type TracedNullifierCheck,
+  type TracedPublicStorageRead,
+  type TracedPublicStorageWrite,
+} from './trace_types.js';
 
 export class WorldStateAccessTrace {
   public accessCounter: number;
-  //public contractCalls: Array<TracedContractCall> = [];
 
-  //public publicStorageReads: Array<TracedPublicStorageRead> = [];
-  public publicStorageReads: Map<bigint, Map<bigint, Fr[]>> = new Map();
-  //public publicStorageWrites: Array<TracedPublicStorageWrite> = [];
-  public publicStorageWrites: Map<bigint, Map<bigint, Fr[]>> = new Map();
+  public publicStorageReads: TracedPublicStorageRead[] = [];
+  public publicStorageWrites: TracedPublicStorageWrite[] = [];
 
   public noteHashChecks: TracedNoteHashCheck[] = [];
-  //public newNoteHashes: TracedNoteHash[] = [];
-  public newNoteHashes: Fr[] = [];
+  public newNoteHashes: TracedNoteHash[] = [];
   public nullifierChecks: TracedNullifierCheck[] = [];
-  //public newNullifiers: TracedNullifier[] = [];
-  public newNullifiers: Fr[] = [];
+  public newNullifiers: TracedNullifier[] = [];
   public l1ToL2MessageChecks: TracedL1toL2MessageCheck[] = [];
+
+  //public contractCalls: TracedContractCall[] = [];
   //public archiveChecks: TracedArchiveLeafCheck[] = [];
 
   constructor(parentTrace?: WorldStateAccessTrace) {
@@ -28,76 +33,73 @@ export class WorldStateAccessTrace {
     return this.accessCounter;
   }
 
-  public tracePublicStorageRead(storageAddress: Fr, slot: Fr, value: Fr /*, _exists: boolean*/) {
+  public tracePublicStorageRead(storageAddress: Fr, slot: Fr, value: Fr, exists: boolean) {
     // TODO(4805): check if some threshold is reached for max storage reads
     // (need access to parent length, or trace needs to be initialized with parent's contents)
-    //const traced: TracedPublicStorageRead = {
-    //  callPointer: Fr.ZERO,
-    //  storageAddress,
-    //  slot,
-    //  value,
-    //  exists,
-    //  counter: new Fr(this.accessCounter),
-    //  endLifetime: Fr.ZERO,
-    //};
-    //this.publicStorageReads.push(traced);
-    this.journalRead(storageAddress, slot, value);
+    const traced: TracedPublicStorageRead = {
+      //  callPointer: Fr.ZERO,
+      storageAddress,
+      slot,
+      value,
+      exists,
+      counter: new Fr(this.accessCounter),
+      //  endLifetime: Fr.ZERO,
+    };
+    this.publicStorageReads.push(traced);
     this.incrementAccessCounter();
   }
 
   public tracePublicStorageWrite(storageAddress: Fr, slot: Fr, value: Fr) {
     // TODO(4805): check if some threshold is reached for max storage writes
     // (need access to parent length, or trace needs to be initialized with parent's contents)
-    //const traced: TracedPublicStorageWrite = {
-    //  callPointer: Fr.ZERO,
-    //  storageAddress,
-    //  slot,
-    //  value,
-    //  counter: new Fr(this.accessCounter),
-    //  endLifetime: Fr.ZERO,
-    //};
-    //this.publicStorageWrites.push(traced);
-    this.journalWrite(storageAddress, slot, value);
+    const traced: TracedPublicStorageWrite = {
+      //  callPointer: Fr.ZERO,
+      storageAddress,
+      slot,
+      value,
+      counter: new Fr(this.accessCounter),
+      //  endLifetime: Fr.ZERO,
+    };
+    this.publicStorageWrites.push(traced);
     this.incrementAccessCounter();
   }
 
   public traceNoteHashCheck(storageAddress: Fr, noteHash: Fr, exists: boolean, leafIndex: Fr) {
     const traced: TracedNoteHashCheck = {
-      callPointer: Fr.ZERO, // FIXME
+      // callPointer: Fr.ZERO,
       storageAddress,
       noteHash,
       exists,
       counter: new Fr(this.accessCounter),
-      endLifetime: Fr.ZERO,
+      // endLifetime: Fr.ZERO,
       leafIndex,
     };
     this.noteHashChecks.push(traced);
     this.incrementAccessCounter();
   }
 
-  public traceNewNoteHash(_storageAddress: Fr, noteHash: Fr) {
+  public traceNewNoteHash(storageAddress: Fr, noteHash: Fr) {
     // TODO(4805): check if some threshold is reached for max new note hash
-    //const traced: TracedNoteHash = {
-    //  callPointer: Fr.ZERO,
-    //  storageAddress,
-    //  noteHash,
-    //  counter: new Fr(this.accessCounter),
-    //  endLifetime: Fr.ZERO,
-    //};
-    //this.newNoteHashes.push(traced);
-    this.newNoteHashes.push(noteHash);
+    const traced: TracedNoteHash = {
+      //  callPointer: Fr.ZERO,
+      storageAddress,
+      noteHash,
+      counter: new Fr(this.accessCounter),
+      //  endLifetime: Fr.ZERO,
+    };
+    this.newNoteHashes.push(traced);
     this.incrementAccessCounter();
   }
 
   public traceNullifierCheck(storageAddress: Fr, nullifier: Fr, exists: boolean, isPending: boolean, leafIndex: Fr) {
     // TODO(4805): check if some threshold is reached for max new nullifier
     const traced: TracedNullifierCheck = {
-      callPointer: Fr.ZERO, // FIXME
+      // callPointer: Fr.ZERO,
       storageAddress,
       nullifier,
       exists,
       counter: new Fr(this.accessCounter),
-      endLifetime: Fr.ZERO,
+      // endLifetime: Fr.ZERO,
       isPending,
       leafIndex,
     };
@@ -105,17 +107,16 @@ export class WorldStateAccessTrace {
     this.incrementAccessCounter();
   }
 
-  public traceNewNullifier(_storageAddress: Fr, nullifier: Fr) {
+  public traceNewNullifier(storageAddress: Fr, nullifier: Fr) {
     // TODO(4805): check if some threshold is reached for max new nullifier
-    //const traced: TracedNullifier = {
-    //  callPointer: Fr.ZERO,
-    //  storageAddress,
-    //  nullifier,
-    //  counter: new Fr(this.accessCounter),
-    //  endLifetime: Fr.ZERO,
-    //};
-    //this.newNullifiers.push(traced);
-    this.newNullifiers.push(nullifier);
+    const tracedNullifier: TracedNullifier = {
+      // callPointer: Fr.ZERO,
+      storageAddress,
+      nullifier,
+      counter: new Fr(this.accessCounter),
+      // endLifetime: Fr.ZERO,
+    };
+    this.newNullifiers.push(tracedNullifier);
     this.incrementAccessCounter();
   }
 
@@ -146,8 +147,8 @@ export class WorldStateAccessTrace {
    */
   public acceptAndMerge(incomingTrace: WorldStateAccessTrace) {
     // Merge storage read and write journals
-    mergeContractJournalMaps(this.publicStorageReads, incomingTrace.publicStorageReads);
-    mergeContractJournalMaps(this.publicStorageWrites, incomingTrace.publicStorageWrites);
+    this.publicStorageReads = this.publicStorageReads.concat(incomingTrace.publicStorageReads);
+    this.publicStorageWrites = this.publicStorageWrites.concat(incomingTrace.publicStorageWrites);
     // Merge new note hashes and nullifiers
     this.noteHashChecks = this.noteHashChecks.concat(incomingTrace.noteHashChecks);
     this.newNoteHashes = this.newNoteHashes.concat(incomingTrace.newNoteHashes);
@@ -157,67 +158,4 @@ export class WorldStateAccessTrace {
     // it is assumed that the incoming trace was initialized with this as parent, so accept counter
     this.accessCounter = incomingTrace.accessCounter;
   }
-
-  /**
-   * We want to keep track of all performed reads in the journal
-   * This information is hinted to the avm circuit
-
-   * @param contractAddress -
-   * @param key -
-   * @param value -
-   */
-  journalUpdate(map: Map<bigint, Map<bigint, Fr[]>>, contractAddress: Fr, key: Fr, value: Fr): void {
-    let contractMap = map.get(contractAddress.toBigInt());
-    if (!contractMap) {
-      contractMap = new Map<bigint, Array<Fr>>();
-      map.set(contractAddress.toBigInt(), contractMap);
-    }
-
-    let accessArray = contractMap.get(key.toBigInt());
-    if (!accessArray) {
-      accessArray = new Array<Fr>();
-      contractMap.set(key.toBigInt(), accessArray);
-    }
-    accessArray.push(value);
-  }
-
-  // Create an instance of journalUpdate that appends to the read array
-  private journalRead = this.journalUpdate.bind(this, this.publicStorageReads);
-  // Create an instance of journalUpdate that appends to the writes array
-  private journalWrite = this.journalUpdate.bind(this, this.publicStorageWrites);
-}
-
-/**
- * Merges two contract journalling maps together
- * For read maps, we just append the childMap arrays into the host map arrays, as the order is important
- *
- * @param hostMap - The map to be merged into
- * @param childMap - The map to be merged from
- */
-function mergeContractJournalMaps(hostMap: Map<bigint, Map<bigint, Fr[]>>, childMap: Map<bigint, Map<bigint, Fr[]>>) {
-  for (const [key, value] of childMap) {
-    const map1Value = hostMap.get(key);
-    if (!map1Value) {
-      hostMap.set(key, value);
-    } else {
-      mergeStorageJournalMaps(map1Value, value);
-    }
-  }
-}
-
-/**
- * Merge two storage journalling maps together (for a particular contract).
- *
- * @param hostMap - The map to be merge into
- * @param childMap - The map to be merged from
- */
-function mergeStorageJournalMaps(hostMap: Map<bigint, Fr[]>, childMap: Map<bigint, Fr[]>) {
-  for (const [key, value] of childMap) {
-    const readArr = hostMap.get(key);
-    if (!readArr) {
-      hostMap.set(key, value);
-    } else {
-      hostMap.set(key, readArr?.concat(...value));
-    }
-  }
 }

package/src/avm/journal/trace_types.ts

@@ -6,64 +6,64 @@ import { type Fr } from '@aztec/foundation/fields';
 //  storageAddress: Fr;
 //  endLifetime: Fr;
 //};
-//
-//export type TracedPublicStorageRead = {
-//  callPointer: Fr;
-//  storageAddress: Fr;
-//  exists: boolean;
-//  slot: Fr;
-//  value: Fr;
-//  counter: Fr;
-//  endLifetime: Fr;
-//};
-//
-//export type TracedPublicStorageWrite = {
-//  callPointer: Fr;
-//  storageAddress: Fr;
-//  slot: Fr;
-//  value: Fr;
-//  counter: Fr;
-//  endLifetime: Fr;
-//};
-//
+
+export type TracedPublicStorageRead = {
+  //  callPointer: Fr;
+  storageAddress: Fr;
+  exists: boolean;
+  slot: Fr;
+  value: Fr;
+  counter: Fr;
+  //  endLifetime: Fr;
+};
+
+export type TracedPublicStorageWrite = {
+  //  callPointer: Fr;
+  storageAddress: Fr;
+  slot: Fr;
+  value: Fr;
+  counter: Fr;
+  //  endLifetime: Fr;
+};
+
 export type TracedNoteHashCheck = {
-  callPointer: Fr;
+  // callPointer: Fr;
   storageAddress: Fr;
   leafIndex: Fr;
   noteHash: Fr;
   exists: boolean;
   counter: Fr;
-  endLifetime: Fr;
+  // endLifetime: Fr;
+};
+
+export type TracedNoteHash = {
+  //  callPointer: Fr;
+  storageAddress: Fr;
+  noteHash: Fr;
+  counter: Fr;
+  //  endLifetime: Fr;
 };
-//
-//export type TracedNoteHash = {
-//  callPointer: Fr;
-//  storageAddress: Fr;
-//  noteHash: Fr;
-//  counter: Fr;
-//  endLifetime: Fr;
-//};
 
 export type TracedNullifierCheck = {
-  callPointer: Fr;
+  // callPointer: Fr;
   storageAddress: Fr;
   nullifier: Fr;
   exists: boolean;
   counter: Fr;
-  endLifetime: Fr;
+  // endLifetime: Fr;
   // the fields below are relevant only to the public kernel
   // and are therefore omitted from VM inputs
   isPending: boolean;
   leafIndex: Fr;
 };
 
-//export type TracedNullifier = {
-//  callPointer: Fr;
-//  storageAddress: Fr;
-//  nullifier: Fr;
-//  counter: Fr;
-//  endLifetime: Fr;
-//};
+export type TracedNullifier = {
+  // callPointer: Fr;
+  storageAddress: Fr;
+  nullifier: Fr;
+  counter: Fr;
+  // endLifetime: Fr;
+};
 
 export type TracedL1toL2MessageCheck = {
   //callPointer: Fr;

package/src/avm/opcodes/accrued_substate.ts

@@ -69,7 +69,7 @@ export class EmitNoteHash extends Instruction {
     }
 
     const noteHash = memory.get(this.noteHashOffset).toFr();
-    context.persistableState.writeNoteHash(noteHash);
+    context.persistableState.writeNoteHash(context.environment.storageAddress, noteHash);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
@@ -80,19 +80,31 @@ export class NullifierExists extends Instruction {
   static type: string = 'NULLIFIEREXISTS';
   static readonly opcode: Opcode = Opcode.NULLIFIEREXISTS;
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32, OperandType.UINT32];
+  static readonly wireFormat = [
+    OperandType.UINT8,
+    OperandType.UINT8,
+    OperandType.UINT32,
+    OperandType.UINT32,
+    OperandType.UINT32,
+  ];
 
-  constructor(private indirect: number, private nullifierOffset: number, private existsOffset: number) {
+  constructor(
+    private indirect: number,
+    private nullifierOffset: number,
+    private addressOffset: number,
+    private existsOffset: number,
+  ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: 1, writes: 1, indirect: this.indirect };
+    const memoryOperations = { reads: 2, writes: 1, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
     const nullifier = memory.get(this.nullifierOffset).toFr();
-    const exists = await context.persistableState.checkNullifierExists(context.environment.storageAddress, nullifier);
+    const address = memory.get(this.addressOffset).toFr();
+    const exists = await context.persistableState.checkNullifierExists(address, nullifier);
 
     memory.set(this.existsOffset, exists ? new Uint8(1) : new Uint8(0));
 

package/src/avm/opcodes/context_getters.ts

@@ -7,7 +7,7 @@ export class L2GasLeft extends GetterInstruction {
   static type: string = 'L2GASLEFT';
   static readonly opcode: Opcode = Opcode.L2GASLEFT;
 
-  // TODO(@spalladino) Yellow paper specifies that the value should be an Uint32, not a Field.
+  // TODO(@spalladino) Protocol specs specifies that the value should be an Uint32, not a Field.
   protected getValue(context: AvmContext): MemoryValue {
     return new Field(context.machineState.l2GasLeft);
   }

package/src/avm/opcodes/external_calls.ts

@@ -1,10 +1,16 @@
 import { FunctionSelector } from '@aztec/circuits.js';
 import { padArrayEnd } from '@aztec/foundation/collection';
 
+import { executePublicFunction } from '../../public/executor.js';
+import {
+  convertPublicExecutionResult,
+  createPublicExecutionContext,
+  updateAvmContextFromPublicExecutionResult,
+} from '../../public/transitional_adaptors.js';
 import type { AvmContext } from '../avm_context.js';
 import { gasLeftToGas, sumGas } from '../avm_gas.js';
 import { Field, Uint8 } from '../avm_memory_types.js';
-import { AvmSimulator } from '../avm_simulator.js';
+import { type AvmContractCallResults } from '../avm_message_call_result.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
@@ -30,7 +36,7 @@ abstract class ExternalCall extends Instruction {
     private gasOffset: number /* Unused due to no formal gas implementation at this moment */,
     private addrOffset: number,
     private argsOffset: number,
-    private argsSize: number,
+    private argsSizeOffset: number,
     private retOffset: number,
     private retSize: number,
     private successOffset: number,
@@ -44,23 +50,27 @@ abstract class ExternalCall extends Instruction {
 
   public async execute(context: AvmContext) {
     const memory = context.machineState.memory.track(this.type);
-    const [gasOffset, addrOffset, argsOffset, retOffset, successOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.gasOffset, this.addrOffset, this.argsOffset, this.retOffset, this.successOffset],
+    const [gasOffset, addrOffset, argsOffset, argsSizeOffset, retOffset, successOffset] = Addressing.fromWire(
+      this.indirect,
+    ).resolve(
+      [this.gasOffset, this.addrOffset, this.argsOffset, this.argsSizeOffset, this.retOffset, this.successOffset],
       memory,
     );
 
     const callAddress = memory.getAs<Field>(addrOffset);
-    const calldata = memory.getSlice(argsOffset, this.argsSize).map(f => f.toFr());
+    const calldataSize = memory.get(argsSizeOffset).toNumber();
+    const calldata = memory.getSlice(argsOffset, calldataSize).map(f => f.toFr());
     const l1Gas = memory.get(gasOffset).toNumber();
     const l2Gas = memory.getAs<Field>(gasOffset + 1).toNumber();
     const daGas = memory.getAs<Field>(gasOffset + 2).toNumber();
     const functionSelector = memory.getAs<Field>(this.temporaryFunctionSelectorOffset).toFr();
 
     const allocatedGas = { l1Gas, l2Gas, daGas };
-    const memoryOperations = { reads: this.argsSize + 5, writes: 1 + this.retSize, indirect: this.indirect };
+    const memoryOperations = { reads: calldataSize + 6, writes: 1 + this.retSize, indirect: this.indirect };
     const totalGas = sumGas(this.gasCost(memoryOperations), allocatedGas);
     context.machineState.consumeGas(totalGas);
 
+    // TRANSITIONAL: This should be removed once the AVM is fully operational and the public executor is gone.
     const nestedContext = context.createNestedContractCallContext(
       callAddress.toFr(),
       calldata,
@@ -68,8 +78,21 @@ abstract class ExternalCall extends Instruction {
       this.type,
       FunctionSelector.fromField(functionSelector),
     );
+    const pxContext = createPublicExecutionContext(nestedContext, calldata);
+    const pxResults = await executePublicFunction(pxContext, /*nested=*/ true);
+    const nestedCallResults: AvmContractCallResults = convertPublicExecutionResult(pxResults);
+    updateAvmContextFromPublicExecutionResult(nestedContext, pxResults);
+    const nestedPersistableState = nestedContext.persistableState;
+    // const nestedContext = context.createNestedContractCallContext(
+    //   callAddress.toFr(),
+    //   calldata,
+    //   allocatedGas,
+    //   this.type,
+    //   FunctionSelector.fromField(functionSelector),
+    // );
+    // const nestedCallResults: AvmContractCallResults = await new AvmSimulator(nestedContext).execute();
+    // const nestedPersistableState = nestedContext.persistableState;
 
-    const nestedCallResults = await new AvmSimulator(nestedContext).execute();
     const success = !nestedCallResults.reverted;
 
     // We only take as much data as was specified in the return size and pad with zeroes if the return data is smaller
@@ -90,9 +113,9 @@ abstract class ExternalCall extends Instruction {
 
     // TODO: Should we merge the changes from a nested call in the case of a STATIC call?
     if (success) {
-      context.persistableState.acceptNestedCallState(nestedContext.persistableState);
+      context.persistableState.acceptNestedCallState(nestedPersistableState);
     } else {
-      context.persistableState.rejectNestedCallState(nestedContext.persistableState);
+      context.persistableState.rejectNestedCallState(nestedPersistableState);
     }
 
     memory.assert(memoryOperations);

package/src/avm/opcodes/hashing.ts

@@ -1,15 +1,15 @@
-import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
-import { keccak, pedersenHash, poseidonHash, sha256 } from '@aztec/foundation/crypto';
+import { keccak256, pedersenHash, poseidon2Permutation, sha256 } from '@aztec/foundation/crypto';
 
 import { type AvmContext } from '../avm_context.js';
-import { Field } from '../avm_memory_types.js';
+import { Field, Uint8 } from '../avm_memory_types.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
 import { Instruction } from './instruction.js';
 
 export class Poseidon2 extends Instruction {
   static type: string = 'POSEIDON2';
-  static readonly opcode: Opcode = Opcode.POSEIDON;
+  static readonly opcode: Opcode = Opcode.POSEIDON2;
+  static readonly stateSize = 4;
 
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [
@@ -17,34 +17,28 @@ export class Poseidon2 extends Instruction {
     OperandType.UINT8,
     OperandType.UINT32,
     OperandType.UINT32,
-    OperandType.UINT32,
   ];
 
-  constructor(
-    private indirect: number,
-    private dstOffset: number,
-    private messageOffset: number,
-    private messageSize: number,
-  ) {
+  constructor(private indirect: number, private inputStateOffset: number, private outputStateOffset: number) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: this.messageSize, writes: 1, indirect: this.indirect };
+    const memoryOperations = { reads: Poseidon2.stateSize, writes: Poseidon2.stateSize, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    // We hash a set of field elements
-    const [dstOffset, messageOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.dstOffset, this.messageOffset],
+    const [inputOffset, outputOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.inputStateOffset, this.outputStateOffset],
       memory,
     );
 
-    // Memory pointer will be indirect
-    const hashData = memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
-
-    const hash = poseidonHash(hashData);
-    memory.set(dstOffset, new Field(hash));
+    const inputState = memory.getSlice(inputOffset, Poseidon2.stateSize);
+    const outputState = poseidon2Permutation(inputState);
+    memory.setSlice(
+      outputOffset,
+      outputState.map(word => new Field(word)),
+    );
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
@@ -68,33 +62,28 @@ export class Keccak extends Instruction {
     private indirect: number,
     private dstOffset: number,
     private messageOffset: number,
-    private messageSize: number,
+    private messageSizeOffset: number,
   ) {
     super();
   }
 
-  // Note hash output is 32 bytes, so takes up two fields
+  // pub fn keccak256(input: [u8], message_size: u32) -> [u8; 32]
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: this.messageSize, writes: 2, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
-
-    // We hash a set of field elements
-    const [dstOffset, messageOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.dstOffset, this.messageOffset],
+    const [dstOffset, messageOffset, messageSizeOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.dstOffset, this.messageOffset, this.messageSizeOffset],
       memory,
     );
+    const messageSize = memory.get(messageSizeOffset).toNumber();
+    const memoryOperations = { reads: messageSize + 1, writes: 32, indirect: this.indirect };
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const hashData = memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
-
-    const hash = keccak(Buffer.concat(hashData));
-
-    // Split output into two fields
-    const high = new Field(toBigIntBE(hash.subarray(0, 16)));
-    const low = new Field(toBigIntBE(hash.subarray(16, 32)));
+    const messageData = Buffer.concat(memory.getSlice(messageOffset, messageSize).map(word => word.toBuffer()));
+    const hashBuffer = keccak256(messageData);
 
-    memory.set(dstOffset, high);
-    memory.set(dstOffset + 1, low);
+    // We need to convert the hashBuffer because map doesn't work as expected on an Uint8Array (Buffer).
+    const res = [...hashBuffer].map(byte => new Uint8(byte));
+    memory.setSlice(dstOffset, res);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
@@ -118,33 +107,28 @@ export class Sha256 extends Instruction {
     private indirect: number,
     private dstOffset: number,
     private messageOffset: number,
-    private messageSize: number,
+    private messageSizeOffset: number,
   ) {
     super();
   }
 
-  // Note hash output is 32 bytes, so takes up two fields
+  // pub fn sha256_slice(input: [u8]) -> [u8; 32]
   public async execute(context: AvmContext): Promise<void> {
-    const memoryOperations = { reads: this.messageSize, writes: 2, indirect: this.indirect };
     const memory = context.machineState.memory.track(this.type);
-    context.machineState.consumeGas(this.gasCost(memoryOperations));
-
-    const [dstOffset, messageOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.dstOffset, this.messageOffset],
+    const [dstOffset, messageOffset, messageSizeOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.dstOffset, this.messageOffset, this.messageSizeOffset],
       memory,
     );
+    const messageSize = memory.get(messageSizeOffset).toNumber();
+    const memoryOperations = { reads: messageSize + 1, writes: 32, indirect: this.indirect };
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    // We hash a set of field elements
-    const hashData = memory.getSlice(messageOffset, this.messageSize).map(word => word.toBuffer());
-
-    const hash = sha256(Buffer.concat(hashData));
-
-    // Split output into two fields
-    const high = new Field(toBigIntBE(hash.subarray(0, 16)));
-    const low = new Field(toBigIntBE(hash.subarray(16, 32)));
+    const messageData = Buffer.concat(memory.getSlice(messageOffset, messageSize).map(word => word.toBuffer()));
+    const hashBuffer = sha256(messageData);
 
-    memory.set(dstOffset, high);
-    memory.set(dstOffset + 1, low);
+    // We need to convert the hashBuffer because map doesn't work as expected on an Uint8Array (Buffer).
+    const res = [...hashBuffer].map(byte => new Uint8(byte));
+    memory.setSlice(dstOffset, res);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();