@aztec/simulator 0.33.0 → 0.34.0

package/dest/public/transitional_adaptors.js

@@ -0,0 +1,161 @@
+// All code in this file needs to die once the public executor is phased out in favor of the AVM.
+import { UnencryptedFunctionL2Logs, UnencryptedL2Log } from '@aztec/circuit-types';
+import { CallContext, ContractStorageRead, ContractStorageUpdateRequest, FunctionData, L2ToL1Message, ReadRequest, SideEffect, SideEffectLinkedToNoteHash, } from '@aztec/circuits.js';
+import { Fr } from '@aztec/foundation/fields';
+import { AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
+import { AvmContractCallResults } from '../avm/avm_message_call_result.js';
+import { Mov } from '../avm/opcodes/memory.js';
+import { createSimulationError } from '../common/errors.js';
+import { PackedArgsCache, SideEffectCounter } from '../index.js';
+import { PublicExecutionContext } from './public_execution_context.js';
+/**
+ * Convert a PublicExecution(Environment) object to an AvmExecutionEnvironment
+ *
+ * @param current
+ * @param globalVariables
+ * @returns
+ */
+export function createAvmExecutionEnvironment(current, header, globalVariables) {
+    return new AvmExecutionEnvironment(current.contractAddress, current.callContext.storageContractAddress, current.callContext.msgSender, // TODO: origin is not available
+    current.callContext.msgSender, current.callContext.portalContractAddress, 
+    /*feePerL1Gas=*/ Fr.zero(), 
+    /*feePerL2Gas=*/ Fr.zero(), 
+    /*feePerDaGas=*/ Fr.zero(), 
+    /*contractCallDepth=*/ Fr.zero(), header, globalVariables, current.callContext.isStaticCall, current.callContext.isDelegateCall, current.args, current.functionData.selector);
+}
+export function createPublicExecutionContext(avmContext, calldata) {
+    const sideEffectCounter = avmContext.persistableState.trace.accessCounter;
+    const callContext = CallContext.from({
+        msgSender: avmContext.environment.sender,
+        storageContractAddress: avmContext.environment.storageAddress,
+        portalContractAddress: avmContext.environment.portal,
+        functionSelector: avmContext.environment.temporaryFunctionSelector,
+        isDelegateCall: avmContext.environment.isDelegateCall,
+        isStaticCall: avmContext.environment.isStaticCall,
+        sideEffectCounter: sideEffectCounter,
+    });
+    const functionData = new FunctionData(avmContext.environment.temporaryFunctionSelector, /*isPrivate=*/ false);
+    const execution = {
+        contractAddress: avmContext.environment.address,
+        callContext,
+        args: calldata,
+        functionData,
+    };
+    const packedArgs = PackedArgsCache.create([]);
+    const context = new PublicExecutionContext(execution, avmContext.environment.header, avmContext.environment.globals, packedArgs, new SideEffectCounter(sideEffectCounter), avmContext.persistableState.hostStorage.publicStateDb, avmContext.persistableState.hostStorage.contractsDb, avmContext.persistableState.hostStorage.commitmentsDb);
+    return context;
+}
+/**
+ * Convert the result of an AVM contract call to a PublicExecutionResult for the public kernel
+ *
+ * @param execution
+ * @param newWorldState
+ * @param result
+ * @returns
+ */
+export async function convertAvmResults(executionContext, newWorldState, result) {
+    const execution = executionContext.execution;
+    const contractStorageReads = newWorldState.storageReads.map(read => new ContractStorageRead(read.slot, read.value, read.counter.toNumber()));
+    const contractStorageUpdateRequests = newWorldState.storageWrites.map(write => new ContractStorageUpdateRequest(write.slot, write.value, write.counter.toNumber()));
+    // We need to write the storage updates to the DB, because that's what the ACVM expects.
+    // Assumes the updates are in the right order.
+    for (const write of newWorldState.storageWrites) {
+        await executionContext.stateDb.storageWrite(write.storageAddress, write.slot, write.value);
+    }
+    const newNoteHashes = newWorldState.newNoteHashes.map(noteHash => new SideEffect(noteHash.noteHash, noteHash.counter));
+    const nullifierReadRequests = newWorldState.nullifierChecks
+        .filter(nullifierCheck => nullifierCheck.exists)
+        .map(nullifierCheck => new ReadRequest(nullifierCheck.nullifier, nullifierCheck.counter.toNumber()));
+    const nullifierNonExistentReadRequests = newWorldState.nullifierChecks
+        .filter(nullifierCheck => !nullifierCheck.exists)
+        .map(nullifierCheck => new ReadRequest(nullifierCheck.nullifier, nullifierCheck.counter.toNumber()));
+    const newNullifiers = newWorldState.newNullifiers.map(tracedNullifier => new SideEffectLinkedToNoteHash(
+    /*value=*/ tracedNullifier.nullifier, 
+    /*noteHash=*/ Fr.ZERO, // NEEDED?
+    tracedNullifier.counter));
+    const unencryptedLogs = new UnencryptedFunctionL2Logs(newWorldState.newLogs.map(log => new UnencryptedL2Log(log.contractAddress, log.selector, log.data)));
+    const newL2ToL1Messages = newWorldState.newL1Messages.map(m => new L2ToL1Message(m.recipient, m.content));
+    const returnValues = result.output;
+    // TODO: Support nested executions.
+    const nestedExecutions = [];
+    // TODO keep track of side effect counters
+    const startSideEffectCounter = Fr.ZERO;
+    const endSideEffectCounter = Fr.ZERO;
+    return {
+        execution,
+        nullifierReadRequests,
+        nullifierNonExistentReadRequests,
+        newNoteHashes,
+        newL2ToL1Messages,
+        startSideEffectCounter,
+        endSideEffectCounter,
+        newNullifiers,
+        contractStorageReads,
+        contractStorageUpdateRequests,
+        returnValues,
+        nestedExecutions,
+        unencryptedLogs,
+        reverted: result.reverted,
+        revertReason: result.revertReason ? createSimulationError(result.revertReason) : undefined,
+    };
+}
+export function convertPublicExecutionResult(res) {
+    return new AvmContractCallResults(res.reverted, res.returnValues, res.revertReason);
+}
+export function updateAvmContextFromPublicExecutionResult(ctx, result) {
+    // We have to push these manually and not use the trace* functions
+    // so that we respect the side effect counters.
+    for (const readRequest of result.contractStorageReads) {
+        ctx.persistableState.trace.publicStorageReads.push({
+            storageAddress: ctx.environment.storageAddress,
+            exists: true, // FIXME
+            slot: readRequest.storageSlot,
+            value: readRequest.currentValue,
+            counter: new Fr(readRequest.sideEffectCounter ?? Fr.ZERO),
+        });
+    }
+    for (const updateRequest of result.contractStorageUpdateRequests) {
+        ctx.persistableState.trace.publicStorageWrites.push({
+            storageAddress: ctx.environment.storageAddress,
+            slot: updateRequest.storageSlot,
+            value: updateRequest.newValue,
+            counter: new Fr(updateRequest.sideEffectCounter ?? Fr.ZERO),
+        });
+        // We need to manually populate the cache.
+        ctx.persistableState.publicStorage.write(ctx.environment.storageAddress, updateRequest.storageSlot, updateRequest.newValue);
+    }
+    for (const nullifier of result.newNullifiers) {
+        ctx.persistableState.trace.newNullifiers.push({
+            storageAddress: ctx.environment.storageAddress,
+            nullifier: nullifier.value,
+            counter: nullifier.counter,
+        });
+    }
+    for (const noteHash of result.newNoteHashes) {
+        ctx.persistableState.trace.newNoteHashes.push({
+            storageAddress: ctx.environment.storageAddress,
+            noteHash: noteHash.value,
+            counter: noteHash.counter,
+        });
+    }
+    for (const message of result.newL2ToL1Messages) {
+        ctx.persistableState.newL1Messages.push(message);
+    }
+    for (const log of result.unencryptedLogs.logs) {
+        ctx.persistableState.newLogs.push(new UnencryptedL2Log(log.contractAddress, log.selector, log.data));
+    }
+}
+const AVM_MAGIC_SUFFIX = Buffer.from([
+    Mov.opcode, // opcode
+    0x00, // indirect
+    ...Buffer.from('000018ca', 'hex'), // srcOffset
+    ...Buffer.from('000018ca', 'hex'), // dstOffset
+]);
+export function markBytecodeAsAvm(bytecode) {
+    return Buffer.concat([bytecode, AVM_MAGIC_SUFFIX]);
+}
+export function isAvmBytecode(bytecode) {
+    const magicSize = AVM_MAGIC_SUFFIX.length;
+    return bytecode.subarray(-magicSize).equals(AVM_MAGIC_SUFFIX);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transitional_adaptors.js","sourceRoot":"","sources":["../../src/public/transitional_adaptors.ts"],"names":[],"mappings":"AAAA,iGAAiG;AACjG,OAAO,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACnF,OAAO,EACL,WAAW,EACX,mBAAmB,EACnB,4BAA4B,EAC5B,YAAY,EAGZ,aAAa,EACb,WAAW,EACX,UAAU,EACV,0BAA0B,GAC3B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAG9C,OAAO,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AAC9E,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAE3E,OAAO,EAAE,GAAG,EAAE,MAAM,0BAA0B,CAAC;AAC/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEjE,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAEvE;;;;;;GAMG;AACH,MAAM,UAAU,6BAA6B,CAC3C,OAAwB,EACxB,MAAc,EACd,eAAgC;IAEhC,OAAO,IAAI,uBAAuB,CAChC,OAAO,CAAC,eAAe,EACvB,OAAO,CAAC,WAAW,CAAC,sBAAsB,EAC1C,OAAO,CAAC,WAAW,CAAC,SAAS,EAAE,gCAAgC;IAC/D,OAAO,CAAC,WAAW,CAAC,SAAS,EAC7B,OAAO,CAAC,WAAW,CAAC,qBAAqB;IACzC,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE;IAC1B,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE;IAC1B,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE;IAC1B,sBAAsB,CAAC,EAAE,CAAC,IAAI,EAAE,EAChC,MAAM,EACN,eAAe,EACf,OAAO,CAAC,WAAW,CAAC,YAAY,EAChC,OAAO,CAAC,WAAW,CAAC,cAAc,EAClC,OAAO,CAAC,IAAI,EACZ,OAAO,CAAC,YAAY,CAAC,QAAQ,CAC9B,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,4BAA4B,CAAC,UAAsB,EAAE,QAAc;IACjF,MAAM,iBAAiB,GAAG,UAAU,CAAC,gBAAgB,CAAC,KAAK,CAAC,aAAa,CAAC;IAC1E,MAAM,WAAW,GAAG,WAAW,CAAC,IAAI,CAAC;QACnC,SAAS,EAAE,UAAU,CAAC,WAAW,CAAC,MAAM;QACxC,sBAAsB,EAAE,UAAU,CAAC,WAAW,CAAC,cAAc;QAC7D,qBAAqB,EAAE,UAAU,CAAC,WAAW,CAAC,MAAM;QACpD,gBAAgB,EAAE,UAAU,CAAC,WAAW,CAAC,yBAAyB;QAClE,cAAc,EAAE,UAAU,CAAC,WAAW,CAAC,cAAc;QACrD,YAAY,EAAE,UAAU,CAAC,WAAW,CAAC,YAAY;QACjD,iBAAiB,EAAE,iBAAiB;KACrC,CAAC,CAAC;IACH,MAAM,YAAY,GAAG,IAAI,YAAY,CAAC,UAAU,CAAC,WAAW,CAAC,yBAAyB,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC;IAC9G,MAAM,SAAS,GAAoB;QACjC,eAAe,EAAE,UAAU,CAAC,WAAW,CAAC,OAAO;QAC/C,WAAW;QACX,IAAI,EAAE,QAAQ;QACd,YAAY;KACb,CAAC;IACF,MAAM,UAAU,GAAG,eAAe,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IAE9C,MAAM,OAAO,GAAG,IAAI,sBAAsB,CACxC,SAAS,EACT,UAAU,CAAC,WAAW,CAAC,MAAM,EAC7B,UAAU,CAAC,WAAW,CAAC,OAAO,EAC9B,UAAU,EACV,IAAI,iBAAiB,CAAC,iBAAiB,CAAC,EACxC,UAAU,CAAC,gBAAgB,CAAC,WAAW,CAAC,aAAa,EACrD,UAAU,CAAC,gBAAgB,CAAC,WAAW,CAAC,WAAW,EACnD,UAAU,CAAC,gBAAgB,CAAC,WAAW,CAAC,aAAa,CACtD,CAAC;IAEF,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,gBAAwC,EACxC,aAA0B,EAC1B,MAA8B;IAE9B,MAAM,SAAS,GAAG,gBAAgB,CAAC,SAAS,CAAC;IAE7C,MAAM,oBAAoB,GAA0B,aAAa,CAAC,YAAY,CAAC,GAAG,CAChF,IAAI,CAAC,EAAE,CAAC,IAAI,mBAAmB,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAChF,CAAC;IACF,MAAM,6BAA6B,GAAmC,aAAa,CAAC,aAAa,CAAC,GAAG,CACnG,KAAK,CAAC,EAAE,CAAC,IAAI,4BAA4B,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAC7F,CAAC;IACF,wFAAwF;IACxF,8CAA8C;IAC9C,KAAK,MAAM,KAAK,IAAI,aAAa,CAAC,aAAa,EAAE,CAAC;QAChD,MAAM,gBAAgB,CAAC,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,cAAc,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IAC7F,CAAC;IAED,MAAM,aAAa,GAAG,aAAa,CAAC,aAAa,CAAC,GAAG,CACnD,QAAQ,CAAC,EAAE,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,CAChE,CAAC;IACF,MAAM,qBAAqB,GAAkB,aAAa,CAAC,eAAe;SACvE,MAAM,CAAC,cAAc,CAAC,EAAE,CAAC,cAAc,CAAC,MAAM,CAAC;SAC/C,GAAG,CAAC,cAAc,CAAC,EAAE,CAAC,IAAI,WAAW,CAAC,cAAc,CAAC,SAAS,EAAE,cAAc,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;IACvG,MAAM,gCAAgC,GAAkB,aAAa,CAAC,eAAe;SAClF,MAAM,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,cAAc,CAAC,MAAM,CAAC;SAChD,GAAG,CAAC,cAAc,CAAC,EAAE,CAAC,IAAI,WAAW,CAAC,cAAc,CAAC,SAAS,EAAE,cAAc,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;IACvG,MAAM,aAAa,GAAiC,aAAa,CAAC,aAAa,CAAC,GAAG,CACjF,eAAe,CAAC,EAAE,CAChB,IAAI,0BAA0B;IAC5B,UAAU,CAAC,eAAe,CAAC,SAAS;IACpC,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU;IACjC,eAAe,CAAC,OAAO,CACxB,CACJ,CAAC;IACF,MAAM,eAAe,GAA8B,IAAI,yBAAyB,CAC9E,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,gBAAgB,CAAC,GAAG,CAAC,eAAe,EAAE,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CACpG,CAAC;IACF,MAAM,iBAAiB,GAAG,aAAa,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;IAE1G,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC;IAEnC,mCAAmC;IACnC,MAAM,gBAAgB,GAA4B,EAAE,CAAC;IACrD,0CAA0C;IAC1C,MAAM,sBAAsB,GAAG,EAAE,CAAC,IAAI,CAAC;IACvC,MAAM,oBAAoB,GAAG,EAAE,CAAC,IAAI,CAAC;IAErC,OAAO;QACL,SAAS;QACT,qBAAqB;QACrB,gCAAgC;QAChC,aAAa;QACb,iBAAiB;QACjB,sBAAsB;QACtB,oBAAoB;QACpB,aAAa;QACb,oBAAoB;QACpB,6BAA6B;QAC7B,YAAY;QACZ,gBAAgB;QAChB,eAAe;QACf,QAAQ,EAAE,MAAM,CAAC,QAAQ;QACzB,YAAY,EAAE,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,qBAAqB,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,SAAS;KAC3F,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,4BAA4B,CAAC,GAA0B;IACrE,OAAO,IAAI,sBAAsB,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,YAAY,EAAE,GAAG,CAAC,YAAY,CAAC,CAAC;AACtF,CAAC;AAED,MAAM,UAAU,yCAAyC,CAAC,GAAe,EAAE,MAA6B;IACtG,kEAAkE;IAClE,+CAA+C;IAC/C,KAAK,MAAM,WAAW,IAAI,MAAM,CAAC,oBAAoB,EAAE,CAAC;QACtD,GAAG,CAAC,gBAAgB,CAAC,KAAK,CAAC,kBAAkB,CAAC,IAAI,CAAC;YACjD,cAAc,EAAE,GAAG,CAAC,WAAW,CAAC,cAAc;YAC9C,MAAM,EAAE,IAAI,EAAE,QAAQ;YACtB,IAAI,EAAE,WAAW,CAAC,WAAW;YAC7B,KAAK,EAAE,WAAW,CAAC,YAAY;YAC/B,OAAO,EAAE,IAAI,EAAE,CAAC,WAAW,CAAC,iBAAiB,IAAI,EAAE,CAAC,IAAI,CAAC;SAC1D,CAAC,CAAC;IACL,CAAC;IAED,KAAK,MAAM,aAAa,IAAI,MAAM,CAAC,6BAA6B,EAAE,CAAC;QACjE,GAAG,CAAC,gBAAgB,CAAC,KAAK,CAAC,mBAAmB,CAAC,IAAI,CAAC;YAClD,cAAc,EAAE,GAAG,CAAC,WAAW,CAAC,cAAc;YAC9C,IAAI,EAAE,aAAa,CAAC,WAAW;YAC/B,KAAK,EAAE,aAAa,CAAC,QAAQ;YAC7B,OAAO,EAAE,IAAI,EAAE,CAAC,aAAa,CAAC,iBAAiB,IAAI,EAAE,CAAC,IAAI,CAAC;SAC5D,CAAC,CAAC;QAEH,0CAA0C;QAC1C,GAAG,CAAC,gBAAgB,CAAC,aAAa,CAAC,KAAK,CACtC,GAAG,CAAC,WAAW,CAAC,cAAc,EAC9B,aAAa,CAAC,WAAW,EACzB,aAAa,CAAC,QAAQ,CACvB,CAAC;IACJ,CAAC;IAED,KAAK,MAAM,SAAS,IAAI,MAAM,CAAC,aAAa,EAAE,CAAC;QAC7C,GAAG,CAAC,gBAAgB,CAAC,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC;YAC5C,cAAc,EAAE,GAAG,CAAC,WAAW,CAAC,cAAc;YAC9C,SAAS,EAAE,SAAS,CAAC,KAAK;YAC1B,OAAO,EAAE,SAAS,CAAC,OAAO;SAC3B,CAAC,CAAC;IACL,CAAC;IAED,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,aAAa,EAAE,CAAC;QAC5C,GAAG,CAAC,gBAAgB,CAAC,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC;YAC5C,cAAc,EAAE,GAAG,CAAC,WAAW,CAAC,cAAc;YAC9C,QAAQ,EAAE,QAAQ,CAAC,KAAK;YACxB,OAAO,EAAE,QAAQ,CAAC,OAAO;SAC1B,CAAC,CAAC;IACL,CAAC;IAED,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,iBAAiB,EAAE,CAAC;QAC/C,GAAG,CAAC,gBAAgB,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACnD,CAAC;IAED,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC;QAC9C,GAAG,CAAC,gBAAgB,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,gBAAgB,CAAC,GAAG,CAAC,eAAe,EAAE,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IACvG,CAAC;AACH,CAAC;AAED,MAAM,gBAAgB,GAAG,MAAM,CAAC,IAAI,CAAC;IACnC,GAAG,CAAC,MAAM,EAAE,SAAS;IACrB,IAAI,EAAE,WAAW;IACjB,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,EAAE,YAAY;IAC/C,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,EAAE,YAAY;CAChD,CAAC,CAAC;AAEH,MAAM,UAAU,iBAAiB,CAAC,QAAgB;IAChD,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC,CAAC;AACrD,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,QAAgB;IAC5C,MAAM,SAAS,GAAG,gBAAgB,CAAC,MAAM,CAAC;IAC1C,OAAO,QAAQ,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;AAChE,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/simulator",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "type": "module",
   "exports": "./dest/index.js",
   "typedocOptions": {
@@ -37,10 +37,10 @@
     ]
   },
   "dependencies": {
-    "@aztec/circuit-types": "0.33.0",
-    "@aztec/circuits.js": "0.33.0",
-    "@aztec/foundation": "0.33.0",
-    "@aztec/types": "0.33.0",
+    "@aztec/circuit-types": "0.34.0",
+    "@aztec/circuits.js": "0.34.0",
+    "@aztec/foundation": "0.34.0",
+    "@aztec/types": "0.34.0",
     "@noir-lang/acvm_js": "portal:../../noir/packages/acvm_js",
     "@noir-lang/types": "portal:../../noir/packages/types",
     "levelup": "^5.1.1",

package/src/acvm/acvm.ts

@@ -95,7 +95,7 @@ export async function acvm(
     initialWitness,
     async (name: string, args: ForeignCallInput[]) => {
       try {
-        logger(`Oracle callback ${name}`);
+        logger.verbose(`Oracle callback ${name}`);
         const oracleFunction = callback[name as ORACLE_NAMES];
         if (!oracleFunction) {
           throw new Error(`Oracle callback ${name} not found`);

package/src/acvm/oracle/oracle.ts

@@ -304,12 +304,12 @@ export class Oracle {
   }
 
   debugLog(...args: ACVMField[][]): ACVMField {
-    this.log(oracleDebugCallToFormattedStr(args));
+    this.log.verbose(oracleDebugCallToFormattedStr(args));
     return toACVMField(0);
   }
 
   debugLogWithPrefix(arg0: ACVMField[], ...args: ACVMField[][]): ACVMField {
-    this.log(`${acvmFieldMessageToString(arg0)}: ${oracleDebugCallToFormattedStr(args)}`);
+    this.log.verbose(`${acvmFieldMessageToString(arg0)}: ${oracleDebugCallToFormattedStr(args)}`);
     return toACVMField(0);
   }
 

package/src/avm/avm_execution_environment.ts

@@ -1,4 +1,4 @@
-import { FunctionSelector, type GlobalVariables } from '@aztec/circuits.js';
+import { FunctionSelector, type GlobalVariables, type Header } from '@aztec/circuits.js';
 import { computeVarArgsHash } from '@aztec/circuits.js/hash';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { type EthAddress } from '@aztec/foundation/eth-address';
@@ -22,29 +22,18 @@ export class AvmContextInputs {
 export class AvmExecutionEnvironment {
   constructor(
     public readonly address: AztecAddress,
-
     public readonly storageAddress: AztecAddress,
-
     public readonly origin: AztecAddress,
-
     public readonly sender: AztecAddress,
-
     public readonly portal: EthAddress,
-
     public readonly feePerL1Gas: Fr,
-
     public readonly feePerL2Gas: Fr,
-
     public readonly feePerDaGas: Fr,
-
     public readonly contractCallDepth: Fr,
-
+    public readonly header: Header,
     public readonly globals: GlobalVariables,
-
     public readonly isStaticCall: boolean,
-
     public readonly isDelegateCall: boolean,
-
     public readonly calldata: Fr[],
 
     // Function selector is temporary since eventually public contract bytecode will be one blob
@@ -59,20 +48,21 @@ export class AvmExecutionEnvironment {
   }
 
   public deriveEnvironmentForNestedCall(
-    address: AztecAddress,
+    targetAddress: AztecAddress,
     calldata: Fr[],
     temporaryFunctionSelector: FunctionSelector = FunctionSelector.empty(),
   ): AvmExecutionEnvironment {
     return new AvmExecutionEnvironment(
-      address,
-      /*storageAddress=*/ address,
+      targetAddress,
+      /*storageAddress=*/ targetAddress,
       this.origin,
-      this.sender,
+      this.address,
       this.portal,
       this.feePerL1Gas,
       this.feePerL2Gas,
       this.feePerDaGas,
       this.contractCallDepth,
+      this.header,
       this.globals,
       this.isStaticCall,
       this.isDelegateCall,
@@ -96,6 +86,7 @@ export class AvmExecutionEnvironment {
       this.feePerL2Gas,
       this.feePerDaGas,
       this.contractCallDepth,
+      this.header,
       this.globals,
       /*isStaticCall=*/ true,
       this.isDelegateCall,
@@ -119,6 +110,7 @@ export class AvmExecutionEnvironment {
       this.feePerL2Gas,
       this.feePerDaGas,
       this.contractCallDepth,
+      this.header,
       this.globals,
       this.isStaticCall,
       /*isDelegateCall=*/ true,

package/src/avm/avm_memory_types.ts

@@ -238,7 +238,7 @@ export class TaggedMemory implements TaggedMemoryInterface {
   public getAs<T>(offset: number): T {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     const word = this._mem[offset];
-    TaggedMemory.log(`get(${offset}) = ${word}`);
+    TaggedMemory.log.debug(`get(${offset}) = ${word}`);
     if (word === undefined) {
       TaggedMemory.log.warn(`Memory at offset ${offset} is undefined! This might be OK if it's stack dumping.`);
     }
@@ -249,7 +249,7 @@ export class TaggedMemory implements TaggedMemoryInterface {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     assert(offset + size < TaggedMemory.MAX_MEMORY_SIZE);
     const value = this._mem.slice(offset, offset + size);
-    TaggedMemory.log(`getSlice(${offset}, ${size}) = ${value}`);
+    TaggedMemory.log.debug(`getSlice(${offset}, ${size}) = ${value}`);
     assert(!value.some(e => e === undefined), 'Memory slice contains undefined values.');
     assert(value.length === size, `Expected slice of size ${size}, got ${value.length}.`);
     return value;
@@ -270,7 +270,7 @@ export class TaggedMemory implements TaggedMemoryInterface {
   public set(offset: number, v: MemoryValue) {
     assert(offset < TaggedMemory.MAX_MEMORY_SIZE);
     this._mem[offset] = v;
-    TaggedMemory.log(`set(${offset}, ${v})`);
+    TaggedMemory.log.debug(`set(${offset}, ${v})`);
   }
 
   public setSlice(offset: number, vs: MemoryValue[]) {
@@ -281,7 +281,7 @@ export class TaggedMemory implements TaggedMemoryInterface {
       this._mem.length = offset + vs.length;
     }
     this._mem.splice(offset, vs.length, ...vs);
-    TaggedMemory.log(`setSlice(${offset}, ${vs})`);
+    TaggedMemory.log.debug(`setSlice(${offset}, ${vs})`);
   }
 
   public getTag(offset: number): TypeTag {

package/src/avm/avm_simulator.ts

@@ -69,26 +69,26 @@ export class AvmSimulator {
         await instruction.execute(this.context);
 
         if (machineState.pc >= instructions.length) {
-          this.log('Passed end of program!');
+          this.log.warn('Passed end of program');
           throw new InvalidProgramCounterError(machineState.pc, /*max=*/ instructions.length);
         }
       }
 
       // Return results for processing by calling context
       const results = machineState.getResults();
-      this.log(`Context execution results: ${results.toString()}`);
+      this.log.debug(`Context execution results: ${results.toString()}`);
       return results;
     } catch (e) {
-      this.log('Exceptional halt');
+      this.log.verbose('Exceptional halt');
       if (!(e instanceof AvmExecutionError)) {
-        this.log(`Unknown error thrown by avm: ${e}`);
+        this.log.verbose(`Unknown error thrown by avm: ${e}`);
         throw e;
       }
 
       // Return results for processing by calling context
       // Note: "exceptional halts" cannot return data
       const results = new AvmContractCallResults(/*reverted=*/ true, /*output=*/ [], /*revertReason=*/ e);
-      this.log(`Context execution results: ${results.toString()}`);
+      this.log.debug(`Context execution results: ${results.toString()}`);
       return results;
     }
   }

package/src/avm/fixtures/index.ts

@@ -1,5 +1,5 @@
 import { SiblingPath } from '@aztec/circuit-types';
-import { GlobalVariables, L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/circuits.js';
+import { GlobalVariables, Header, L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/circuits.js';
 import { FunctionSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -67,6 +67,7 @@ export function initExecutionEnvironment(overrides?: Partial<AvmExecutionEnviron
     overrides?.feePerL2Gas ?? Fr.zero(),
     overrides?.feePerDaGas ?? Fr.zero(),
     overrides?.contractCallDepth ?? Fr.zero(),
+    overrides?.header ?? Header.empty(),
     overrides?.globals ?? GlobalVariables.empty(),
     overrides?.isStaticCall ?? false,
     overrides?.isDelegateCall ?? false,

package/src/avm/journal/journal.ts

@@ -7,16 +7,27 @@ import { type HostStorage } from './host_storage.js';
 import { Nullifiers } from './nullifiers.js';
 import { PublicStorage } from './public_storage.js';
 import { WorldStateAccessTrace } from './trace.js';
-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';
 
 /**
  * Data held within the journal
  */
 export type JournalData = {
+  storageWrites: TracedPublicStorageWrite[];
+  storageReads: TracedPublicStorageRead[];
+
   noteHashChecks: TracedNoteHashCheck[];
-  newNoteHashes: Fr[];
+  newNoteHashes: TracedNoteHash[];
   nullifierChecks: TracedNullifierCheck[];
-  newNullifiers: Fr[];
+  newNullifiers: TracedNullifier[];
   l1ToL2MessageChecks: TracedL1toL2MessageCheck[];
 
   newL1Messages: L2ToL1Message[];
@@ -24,11 +35,6 @@ export type JournalData = {
 
   /** contract address -\> key -\> value */
   currentStorageValue: Map<bigint, Map<bigint, Fr>>;
-
-  /** contract address -\> key -\> value[] (stored in order of access) */
-  storageWrites: Map<bigint, Map<bigint, Fr[]>>;
-  /** contract address -\> key -\> value[] (stored in order of access) */
-  storageReads: Map<bigint, Map<bigint, Fr[]>>;
 };
 
 /**
@@ -44,18 +50,19 @@ export class AvmPersistableStateManager {
   /** Reference to node storage */
   public readonly hostStorage: HostStorage;
 
+  // TODO: make members private once this is not used in transitional_adaptors.ts.
   /** World State */
   /** Public storage, including cached writes */
-  private publicStorage: PublicStorage;
+  public publicStorage: PublicStorage;
   /** Nullifier set, including cached/recently-emitted nullifiers */
-  private nullifiers: Nullifiers;
+  public nullifiers: Nullifiers;
 
   /** World State Access Trace */
-  private trace: WorldStateAccessTrace;
+  public trace: WorldStateAccessTrace;
 
   /** Accrued Substate **/
-  private newL1Messages: L2ToL1Message[] = [];
-  private newLogs: UnencryptedL2Log[] = [];
+  public newL1Messages: L2ToL1Message[] = [];
+  public newLogs: UnencryptedL2Log[] = [];
 
   constructor(hostStorage: HostStorage, parent?: AvmPersistableStateManager) {
     this.hostStorage = hostStorage;
@@ -93,9 +100,9 @@ export class AvmPersistableStateManager {
    * @returns the latest value written to slot, or 0 if never written to before
    */
   public async readStorage(storageAddress: Fr, slot: Fr): Promise<Fr> {
-    const [_exists, value] = await this.publicStorage.read(storageAddress, slot);
+    const [exists, value] = await this.publicStorage.read(storageAddress, slot);
     // We want to keep track of all performed reads (even reverted ones)
-    this.trace.tracePublicStorageRead(storageAddress, slot, value);
+    this.trace.tracePublicStorageRead(storageAddress, slot, value, exists);
     return Promise.resolve(value);
   }
 
@@ -119,8 +126,8 @@ export class AvmPersistableStateManager {
    * Write a note hash, trace the write.
    * @param noteHash - the unsiloed note hash to write
    */
-  public writeNoteHash(noteHash: Fr) {
-    this.trace.traceNewNoteHash(/*storageAddress*/ Fr.ZERO, noteHash);
+  public writeNoteHash(storageAddress: Fr, noteHash: Fr) {
+    this.trace.traceNewNoteHash(storageAddress, noteHash);
   }
 
   /**