@aztec/simulator 0.60.0 → 0.61.0

package/src/avm/serialization/bytecode_serialization.ts

@@ -31,6 +31,8 @@ import {
   Or,
   Poseidon2,
   Return,
+  ReturndataCopy,
+  ReturndataSize,
   Revert,
   SLoad,
   SStore,
@@ -41,7 +43,7 @@ import {
   Shr,
   StaticCall,
   Sub,
-  ToRadixLE,
+  ToRadixBE,
   Xor,
 } from '../opcodes/index.js';
 import { MultiScalarMul } from '../opcodes/multi_scalar_mul.js';
@@ -96,6 +98,8 @@ const INSTRUCTION_SET = () =>
     // Execution Environment
     [Opcode.GETENVVAR_16, GetEnvVar.as(GetEnvVar.wireFormat16).deserialize],
     [CalldataCopy.opcode, Instruction.deserialize.bind(CalldataCopy)],
+    [Opcode.RETURNDATASIZE, Instruction.deserialize.bind(ReturndataSize)],
+    [Opcode.RETURNDATACOPY, Instruction.deserialize.bind(ReturndataCopy)],
 
     // Machine State - Internal Control Flow
     [Jump.opcode, Instruction.deserialize.bind(Jump)],
@@ -141,7 +145,7 @@ const INSTRUCTION_SET = () =>
     [Sha256Compression.opcode, Instruction.deserialize.bind(Sha256Compression)],
     [MultiScalarMul.opcode, Instruction.deserialize.bind(MultiScalarMul)],
     // Conversions
-    [ToRadixLE.opcode, Instruction.deserialize.bind(ToRadixLE)],
+    [ToRadixBE.opcode, Instruction.deserialize.bind(ToRadixBE)],
     // Future Gadgets -- pending changes in noir
     // SHA256COMPRESSION,
     [KeccakF1600.opcode, Instruction.deserialize.bind(KeccakF1600)],

package/src/avm/serialization/instruction_serialization.ts

@@ -41,6 +41,8 @@ export enum Opcode {
   // Execution environment
   GETENVVAR_16,
   CALLDATACOPY,
+  RETURNDATASIZE,
+  RETURNDATACOPY,
   // Control flow
   JUMP_16,
   JUMPI_16,
@@ -81,7 +83,7 @@ export enum Opcode {
   ECADD,
   MSM,
   // Conversion
-  TORADIXLE,
+  TORADIXBE,
 }
 
 // Possible types for an instruction's operand in its wire format. (Keep in sync with CPP code.

package/src/avm/test_utils.ts

@@ -1,4 +1,4 @@
-import { type ContractInstanceWithAddress, Fr } from '@aztec/circuits.js';
+import { type ContractClassPublic, type ContractInstanceWithAddress, Fr } from '@aztec/circuits.js';
 
 import { type jest } from '@jest/globals';
 import { mock } from 'jest-mock-extended';
@@ -61,3 +61,7 @@ export function mockL1ToL2MessageExists(
 export function mockGetContractInstance(worldStateDB: WorldStateDB, contractInstance: ContractInstanceWithAddress) {
   (worldStateDB as jest.Mocked<WorldStateDB>).getContractInstance.mockResolvedValue(contractInstance);
 }
+
+export function mockGetContractClass(worldStateDB: WorldStateDB, contractClass: ContractClassPublic) {
+  (worldStateDB as jest.Mocked<WorldStateDB>).getContractClass.mockResolvedValue(contractClass);
+}

package/src/client/client_execution_context.ts

@@ -602,33 +602,6 @@ export class ClientExecutionContext extends ViewDataOracle {
     );
   }
 
-  /**
-   * Read the public storage data.
-   * @param contractAddress - The address to read storage from.
-   * @param startStorageSlot - The starting storage slot.
-   * @param blockNumber - The block number to read storage at.
-   * @param numberOfElements - Number of elements to read from the starting storage slot.
-   */
-  public override async storageRead(
-    contractAddress: Fr,
-    startStorageSlot: Fr,
-    blockNumber: number,
-    numberOfElements: number,
-  ): Promise<Fr[]> {
-    const values = [];
-    for (let i = 0n; i < numberOfElements; i++) {
-      const storageSlot = new Fr(startStorageSlot.value + i);
-
-      const value = await this.aztecNode.getPublicStorageAt(contractAddress, storageSlot, blockNumber);
-      this.log.debug(
-        `Oracle storage read: slot=${storageSlot.toString()} address-${contractAddress.toString()} value=${value}`,
-      );
-
-      values.push(value);
-    }
-    return values;
-  }
-
   public override debugLog(message: string, fields: Fr[]) {
     this.log.verbose(`debug_log ${applyStringFormatting(message, fields)}`);
   }

package/src/client/db_oracle.ts

@@ -9,6 +9,7 @@ import {
   type CompleteAddress,
   type ContractInstance,
   type Header,
+  type IndexedTaggingSecret,
   type KeyValidationRequest,
 } from '@aztec/circuits.js';
 import { type FunctionArtifact, type FunctionSelector } from '@aztec/foundation/abi';
@@ -193,4 +194,29 @@ export interface DBOracle extends CommitmentsDB {
    * @returns The block number.
    */
   getBlockNumber(): Promise<number>;
+
+  /**
+   * Returns the tagging secret for a given sender and recipient pair. For this to work, the ivpsk_m of the sender must be known.
+   * Includes the last known index used for tagging with this secret.
+   * @param contractAddress - The contract address to silo the secret for
+   * @param sender - The address sending the note
+   * @param recipient - The address receiving the note
+   * @returns A tagging secret that can be used to tag notes.
+   */
+  getAppTaggingSecret(
+    contractAddress: AztecAddress,
+    sender: AztecAddress,
+    recipient: AztecAddress,
+  ): Promise<IndexedTaggingSecret>;
+
+  /**
+   * Returns the siloed tagging secrets for a given recipient and all the senders in the address book
+   * @param contractAddress - The contract address to silo the secret for
+   * @param recipient - The address receiving the notes
+   * @returns A list of siloed tagging secrets
+   */
+  getAppTaggingSecretsForSenders(
+    contractAddress: AztecAddress,
+    recipient: AztecAddress,
+  ): Promise<IndexedTaggingSecret[]>;
 }

package/src/client/view_data_oracle.ts

@@ -7,7 +7,12 @@ import {
   type NullifierMembershipWitness,
   type PublicDataWitness,
 } from '@aztec/circuit-types';
-import { type ContractInstance, type Header, type KeyValidationRequest } from '@aztec/circuits.js';
+import {
+  type ContractInstance,
+  type Header,
+  type IndexedTaggingSecret,
+  type KeyValidationRequest,
+} from '@aztec/circuits.js';
 import { siloNullifier } from '@aztec/circuits.js/hash';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
@@ -288,4 +293,29 @@ export class ViewDataOracle extends TypedOracle {
     const formattedStr = applyStringFormatting(message, fields);
     this.log.verbose(`debug_log ${formattedStr}`);
   }
+
+  /**
+   * Returns the tagging secret for a given sender and recipient pair, siloed to the current contract address.
+   * Includes the last known index used for tagging with this secret.
+   * For this to work, the ivpsk_m of the sender must be known.
+   * @param sender - The address sending the note
+   * @param recipient - The address receiving the note
+   * @returns A tagging secret that can be used to tag notes.
+   */
+  public override async getAppTaggingSecret(
+    sender: AztecAddress,
+    recipient: AztecAddress,
+  ): Promise<IndexedTaggingSecret> {
+    return await this.db.getAppTaggingSecret(this.contractAddress, sender, recipient);
+  }
+
+  /**
+   * Returns the siloed tagging secrets for a given recipient and all the senders in the address book
+   * @param contractAddress - The contract address to silo the secret for
+   * @param recipient - The address receiving the notes
+   * @returns A list of siloed tagging secrets
+   */
+  public override async getAppTaggingSecretsForSenders(recipient: AztecAddress): Promise<IndexedTaggingSecret[]> {
+    return await this.db.getAppTaggingSecretsForSenders(this.contractAddress, recipient);
+  }
 }

package/src/common/index.ts

@@ -1,3 +1,2 @@
 export * from './packed_values_cache.js';
 export * from './errors.js';
-export * from './side_effect_counter.js';

package/src/public/dual_side_effect_trace.ts

@@ -1,7 +1,8 @@
 import {
   type CombinedConstantData,
-  type ContractInstanceWithAddress,
+  type ContractClassIdPreimage,
   type Gas,
+  type SerializableContractInstance,
   type VMCircuitPublicInputs,
 } from '@aztec/circuits.js';
 import { type Fr } from '@aztec/foundation/fields';
@@ -15,8 +16,6 @@ import { type PublicExecutionResult } from './execution.js';
 import { type PublicSideEffectTrace } from './side_effect_trace.js';
 import { type PublicSideEffectTraceInterface } from './side_effect_trace_interface.js';
 
-export type TracedContractInstance = { exists: boolean } & ContractInstanceWithAddress;
-
 export class DualSideEffectTrace implements PublicSideEffectTraceInterface {
   constructor(
     public readonly innerCallTrace: PublicSideEffectTrace,
@@ -78,9 +77,24 @@ export class DualSideEffectTrace implements PublicSideEffectTraceInterface {
     this.enqueuedCallTrace.traceUnencryptedLog(contractAddress, log);
   }
 
-  public traceGetContractInstance(instance: TracedContractInstance) {
-    this.innerCallTrace.traceGetContractInstance(instance);
-    this.enqueuedCallTrace.traceGetContractInstance(instance);
+  public traceGetContractInstance(
+    contractAddress: Fr,
+    exists: boolean,
+    instance: SerializableContractInstance | undefined,
+  ) {
+    this.innerCallTrace.traceGetContractInstance(contractAddress, exists, instance);
+    this.enqueuedCallTrace.traceGetContractInstance(contractAddress, exists, instance);
+  }
+
+  public traceGetBytecode(
+    contractAddress: Fr,
+    exists: boolean,
+    bytecode: Buffer,
+    contractInstance: SerializableContractInstance | undefined,
+    contractClass: ContractClassIdPreimage | undefined,
+  ) {
+    this.innerCallTrace.traceGetBytecode(contractAddress, exists, bytecode, contractInstance, contractClass);
+    this.enqueuedCallTrace.traceGetBytecode(contractAddress, exists, bytecode, contractInstance, contractClass);
   }
 
   /**

package/src/public/enqueued_call_side_effect_trace.ts

@@ -1,5 +1,6 @@
 import { UnencryptedL2Log } from '@aztec/circuit-types';
 import {
+  AvmContractBytecodeHints,
   AvmContractInstanceHint,
   AvmExecutionHints,
   AvmExternalCallHint,
@@ -7,7 +8,7 @@ import {
   AztecAddress,
   CallContext,
   type CombinedConstantData,
-  type ContractInstanceWithAddress,
+  type ContractClassIdPreimage,
   ContractStorageRead,
   ContractStorageUpdateRequest,
   EthAddress,
@@ -44,6 +45,7 @@ import {
   ScopedNoteHash,
   type ScopedNullifier,
   ScopedReadRequest,
+  SerializableContractInstance,
   TreeLeafReadRequest,
   VMCircuitPublicInputs,
 } from '@aztec/circuits.js';
@@ -58,8 +60,6 @@ import { type AvmExecutionEnvironment } from '../avm/avm_execution_environment.j
 import { SideEffectLimitReachedError } from './side_effect_errors.js';
 import { type PublicSideEffectTraceInterface } from './side_effect_trace_interface.js';
 
-export type TracedContractInstance = { exists: boolean } & ContractInstanceWithAddress;
-
 /**
  * A struct containing just the side effects as regular arrays
  * as opposed to "Tuple" arrays used by circuit public inputs.
@@ -307,14 +307,17 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     this.incrementSideEffectCounter();
   }
 
-  public traceGetContractInstance(instance: TracedContractInstance) {
+  public traceGetContractInstance(
+    contractAddress: Fr,
+    exists: boolean,
+    instance: SerializableContractInstance = SerializableContractInstance.default(),
+  ) {
     this.enforceLimitOnNullifierChecks('(contract address nullifier from GETCONTRACTINSTANCE)');
-    // TODO(dbanks12): should emit a nullifier read request
 
     this.avmCircuitHints.contractInstances.items.push(
       new AvmContractInstanceHint(
-        instance.address,
-        new Fr(instance.exists ? 1 : 0),
+        contractAddress,
+        exists,
         instance.salt,
         instance.deployer,
         instance.contractClassId,
@@ -326,6 +329,40 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     this.incrementSideEffectCounter();
   }
 
+  // This tracing function gets called everytime we start simulation/execution.
+  // This happens both when starting a new top-level trace and the start of every nested trace
+  // We use this to collect the AvmContractBytecodeHints
+  public traceGetBytecode(
+    contractAddress: Fr,
+    exists: boolean,
+    bytecode: Buffer = Buffer.alloc(0),
+    contractInstance: SerializableContractInstance = SerializableContractInstance.default(),
+    contractClass: ContractClassIdPreimage = {
+      artifactHash: Fr.zero(),
+      privateFunctionsRoot: Fr.zero(),
+      publicBytecodeCommitment: Fr.zero(),
+    },
+  ) {
+    const instance = new AvmContractInstanceHint(
+      contractAddress,
+      exists,
+      contractInstance.salt,
+      contractInstance.deployer,
+      contractInstance.contractClassId,
+      contractInstance.initializationHash,
+      contractInstance.publicKeys,
+    );
+    // We need to deduplicate the contract instances based on addresses
+    this.avmCircuitHints.contractBytecodeHints.items.push(
+      new AvmContractBytecodeHints(bytecode, instance, contractClass),
+    );
+    this.log.debug(
+      `Bytecode retrieval for contract execution traced: exists=${exists}, instance=${JSON.stringify(
+        contractInstance,
+      )}`,
+    );
+  }
+
   /**
    * Trace a nested call.
    * Accept some results from a finished nested call's trace into this one.
@@ -334,7 +371,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
     /** The trace of the nested call. */
     nestedCallTrace: this,
     /** The execution environment of the nested call. */
-    _nestedEnvironment: AvmExecutionEnvironment,
+    nestedEnvironment: AvmExecutionEnvironment,
     /** How much gas was available for this public execution. */
     startGasLeft: Gas,
     /** How much gas was left after this public execution. */
@@ -368,6 +405,7 @@ export class PublicEnqueuedCallSideEffectTrace implements PublicSideEffectTraceI
         avmCallResults.output,
         gasUsed,
         endSideEffectCounter,
+        nestedEnvironment.address,
       ),
     );
   }

package/src/public/enqueued_call_simulator.ts

@@ -1,17 +1,16 @@
 import {
-  AVM_REQUEST,
   type AvmProvingRequest,
   MerkleTreeId,
   NestedProcessReturnValues,
   ProvingRequestType,
   type PublicExecutionRequest,
   PublicKernelPhase,
-  type PublicProvingRequest,
   type SimulationError,
   type Tx,
   UnencryptedFunctionL2Logs,
 } from '@aztec/circuit-types';
 import {
+  AvmCircuitInputs,
   AztecAddress,
   ContractStorageRead,
   ContractStorageUpdateRequest,
@@ -52,6 +51,7 @@ import {
   RevertCode,
   TreeLeafReadRequest,
   VMCircuitPublicInputs,
+  VerificationKeyData,
   makeEmptyProof,
   makeEmptyRecursiveProof,
 } from '@aztec/circuits.js';
@@ -59,33 +59,22 @@ import { computeVarArgsHash } from '@aztec/circuits.js/hash';
 import { makeTuple } from '@aztec/foundation/array';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
-import { ProtocolCircuitVks } from '@aztec/noir-protocol-circuits-types';
 import { type MerkleTreeReadOperations } from '@aztec/world-state';
 
 import { type PublicExecutionResult, accumulatePublicReturnValues, collectExecutionResults } from './execution.js';
 import { type PublicExecutor } from './executor.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
 
-function makeAvmProvingRequest(
-  inputs: PublicKernelInnerCircuitPrivateInputs,
-  result: PublicExecutionResult,
-): AvmProvingRequest {
+function makeAvmProvingRequest(inputs: PublicCircuitPublicInputs, result: PublicExecutionResult): AvmProvingRequest {
   return {
-    type: AVM_REQUEST,
-    functionName: result.functionName,
-    calldata: result.calldata,
-    bytecode: result.bytecode!,
-    avmHints: result.avmCircuitHints,
-    kernelRequest: {
-      type: ProvingRequestType.PUBLIC_KERNEL_INNER,
-      inputs,
-    },
+    type: ProvingRequestType.PUBLIC_VM,
+    inputs: new AvmCircuitInputs(result.functionName, result.calldata, inputs, result.avmCircuitHints),
   };
 }
 
 export type EnqueuedCallResult = {
   /** Inputs to be used for proving */
-  provingRequests: PublicProvingRequest[];
+  avmProvingRequest: AvmProvingRequest;
   /** The public kernel output at the end of the enqueued call */
   kernelOutput: VMCircuitPublicInputs;
   /** Unencrypted logs generated during the execution of this enqueued call */
@@ -186,7 +175,7 @@ export class EnqueuedCallSimulator {
   ): Promise<EnqueuedCallResult> {
     const executionResults = collectExecutionResults(topResult);
 
-    const provingRequests: AvmProvingRequest[] = [];
+    let avmProvingRequest: AvmProvingRequest;
     let gasUsed = Gas.empty();
     let revertReason;
     let kernelOutput = startVMCircuitOutput;
@@ -215,7 +204,7 @@ export class EnqueuedCallSimulator {
       kernelOutput = output;
 
       // Capture the inputs for later proving in the AVM and kernel.
-      provingRequests.push(makeAvmProvingRequest(inputs, result));
+      avmProvingRequest = makeAvmProvingRequest(inputs.publicCall.publicInputs, result);
 
       // Safely return the revert reason and the kernel output (which has had its revertible side effects dropped)
       // TODO(@leila) we shouldn't drop everything when it reverts. The tail kernel needs the data to prove that it's reverted for the correct reason.
@@ -226,7 +215,7 @@ export class EnqueuedCallSimulator {
         // TODO(@spalladino): Check gasUsed is correct. The AVM should take care of setting gasLeft to zero upon a revert.
 
         return {
-          provingRequests,
+          avmProvingRequest,
           kernelOutput,
           newUnencryptedLogs: UnencryptedFunctionL2Logs.empty(),
           returnValues: NestedProcessReturnValues.empty(),
@@ -237,7 +226,7 @@ export class EnqueuedCallSimulator {
     }
 
     return {
-      provingRequests,
+      avmProvingRequest: avmProvingRequest!,
       kernelOutput,
       newUnencryptedLogs: topResult.allUnencryptedLogs,
       returnValues: accumulatePublicReturnValues(topResult),
@@ -257,7 +246,7 @@ export class EnqueuedCallSimulator {
   ): Promise<{ inputs: PublicKernelInnerCircuitPrivateInputs; output: VMCircuitPublicInputs }> {
     // The proof is not used in simulation
     const proof = makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH);
-    const vk = ProtocolCircuitVks.PublicKernelInnerArtifact;
+    const vk = VerificationKeyData.makeFakeHonk();
     const previousKernel = new PublicKernelInnerData(previousOutput, proof, vk);
     const inputs = new PublicKernelInnerCircuitPrivateInputs(previousKernel, callData);
     return { inputs, output: await this.publicKernelSimulator.publicKernelCircuitInner(inputs) };
@@ -283,9 +272,24 @@ export class EnqueuedCallSimulator {
       callContext: result.executionRequest.callContext,
       proverAddress: AztecAddress.ZERO,
       argsHash: computeVarArgsHash(result.executionRequest.args),
-      noteHashes: padArrayEnd(result.noteHashes, NoteHash.empty(), MAX_NOTE_HASHES_PER_CALL),
-      nullifiers: padArrayEnd(result.nullifiers, Nullifier.empty(), MAX_NULLIFIERS_PER_CALL),
-      l2ToL1Msgs: padArrayEnd(result.l2ToL1Messages, L2ToL1Message.empty(), MAX_L2_TO_L1_MSGS_PER_CALL),
+      noteHashes: padArrayEnd(
+        result.noteHashes,
+        NoteHash.empty(),
+        MAX_NOTE_HASHES_PER_CALL,
+        `Too many note hashes. Got ${result.noteHashes.length} with max being ${MAX_NOTE_HASHES_PER_CALL}`,
+      ),
+      nullifiers: padArrayEnd(
+        result.nullifiers,
+        Nullifier.empty(),
+        MAX_NULLIFIERS_PER_CALL,
+        `Too many nullifiers. Got ${result.nullifiers.length} with max being ${MAX_NULLIFIERS_PER_CALL}`,
+      ),
+      l2ToL1Msgs: padArrayEnd(
+        result.l2ToL1Messages,
+        L2ToL1Message.empty(),
+        MAX_L2_TO_L1_MSGS_PER_CALL,
+        `Too many L2 to L1 messages. Got ${result.l2ToL1Messages.length} with max being ${MAX_L2_TO_L1_MSGS_PER_CALL}`,
+      ),
       startSideEffectCounter: result.startSideEffectCounter,
       endSideEffectCounter: result.endSideEffectCounter,
       returnsHash: computeVarArgsHash(result.returnValues),
@@ -293,38 +297,50 @@ export class EnqueuedCallSimulator {
         result.noteHashReadRequests,
         TreeLeafReadRequest.empty(),
         MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
+        `Too many note hash read requests. Got ${result.noteHashReadRequests.length} with max being ${MAX_NOTE_HASH_READ_REQUESTS_PER_CALL}`,
       ),
       nullifierReadRequests: padArrayEnd(
         result.nullifierReadRequests,
         ReadRequest.empty(),
         MAX_NULLIFIER_READ_REQUESTS_PER_CALL,
+        `Too many nullifier read requests. Got ${result.nullifierReadRequests.length} with max being ${MAX_NULLIFIER_READ_REQUESTS_PER_CALL}`,
       ),
       nullifierNonExistentReadRequests: padArrayEnd(
         result.nullifierNonExistentReadRequests,
         ReadRequest.empty(),
         MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL,
+        `Too many nullifier non-existent read requests. Got ${result.nullifierNonExistentReadRequests.length} with max being ${MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL}`,
       ),
       l1ToL2MsgReadRequests: padArrayEnd(
         result.l1ToL2MsgReadRequests,
         TreeLeafReadRequest.empty(),
         MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_CALL,
+        `Too many L1 to L2 message read requests. Got ${result.l1ToL2MsgReadRequests.length} with max being ${MAX_L1_TO_L2_MSG_READ_REQUESTS_PER_CALL}`,
       ),
       contractStorageReads: padArrayEnd(
         result.contractStorageReads,
         ContractStorageRead.empty(),
         MAX_PUBLIC_DATA_READS_PER_CALL,
+        `Too many public data reads. Got ${result.contractStorageReads.length} with max being ${MAX_PUBLIC_DATA_READS_PER_CALL}`,
       ),
       contractStorageUpdateRequests: padArrayEnd(
         result.contractStorageUpdateRequests,
         ContractStorageUpdateRequest.empty(),
         MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
+        `Too many public data update requests. Got ${result.contractStorageUpdateRequests.length} with max being ${MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL}`,
       ),
       publicCallRequests: padArrayEnd(
         result.publicCallRequests,
         PublicInnerCallRequest.empty(),
         MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
+        `Too many public call requests. Got ${result.publicCallRequests.length} with max being ${MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL}`,
+      ),
+      unencryptedLogsHashes: padArrayEnd(
+        result.unencryptedLogsHashes,
+        LogHash.empty(),
+        MAX_UNENCRYPTED_LOGS_PER_CALL,
+        `Too many unencrypted logs. Got ${result.unencryptedLogsHashes.length} with max being ${MAX_UNENCRYPTED_LOGS_PER_CALL}`,
       ),
-      unencryptedLogsHashes: padArrayEnd(result.unencryptedLogsHashes, LogHash.empty(), MAX_UNENCRYPTED_LOGS_PER_CALL),
       historicalHeader: this.historicalHeader,
       globalVariables: this.globalVariables,
       startGasLeft: Gas.from(result.startGasLeft),