@aztec/stdlib 1.2.0 → 2.0.0-nightly.20250813

package/src/tests/factories.ts

@@ -45,11 +45,11 @@ import {
   VK_TREE_HEIGHT,
 } from '@aztec/constants';
 import { type FieldsOf, makeHalfFullTuple, makeTuple } from '@aztec/foundation/array';
-import { compact } from '@aztec/foundation/collection';
+import { compact, padArrayEnd } from '@aztec/foundation/collection';
 import { SchnorrSignature, poseidon2HashWithSeparator, sha256 } from '@aztec/foundation/crypto';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { BLS12Point, Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
-import type { Bufferable } from '@aztec/foundation/serialize';
+import type { Bufferable, Serializable, Tuple } from '@aztec/foundation/serialize';
 import { MembershipWitness } from '@aztec/foundation/trees';
 
 import { FunctionSelector } from '../abi/function_selector.js';
@@ -99,8 +99,8 @@ import type { MerkleTreeReadOperations } from '../interfaces/merkle_tree_operati
 import { KeyValidationRequest } from '../kernel/hints/key_validation_request.js';
 import { KeyValidationRequestAndGenerator } from '../kernel/hints/key_validation_request_and_generator.js';
 import { ReadRequest } from '../kernel/hints/read_request.js';
-import { RollupValidationRequests } from '../kernel/hints/rollup_validation_requests.js';
 import {
+  ClaimedLengthArray,
   PartialPrivateTailPublicInputsForPublic,
   PartialPrivateTailPublicInputsForRollup,
   PrivateKernelTailCircuitPublicInputs,
@@ -109,7 +109,6 @@ import {
   PrivateToPublicAccumulatedData,
   PrivateToPublicKernelCircuitPublicInputs,
   PrivateToRollupAccumulatedData,
-  mergeAccumulatedData,
 } from '../kernel/index.js';
 import { CountedLogHash, LogHash, ScopedLogHash } from '../kernel/log_hash.js';
 import { NoteHash } from '../kernel/note_hash.js';
@@ -167,7 +166,6 @@ import { CallContext } from '../tx/call_context.js';
 import { ContentCommitment } from '../tx/content_commitment.js';
 import { FunctionData } from '../tx/function_data.js';
 import { GlobalVariables } from '../tx/global_variables.js';
-import { IncludeByTimestamp } from '../tx/include_by_timestamp.js';
 import { PartialStateReference } from '../tx/partial_state_reference.js';
 import { makeProcessedTxFromPrivateOnlyTx, makeProcessedTxFromTxWithPublicCalls } from '../tx/processed_tx.js';
 import { PublicCallRequestWithCalldata } from '../tx/public_call_request_with_calldata.js';
@@ -309,10 +307,6 @@ export function makeContractStorageRead(seed = 1): ContractStorageRead {
   return new ContractStorageRead(fr(seed), fr(seed + 1), seed + 2);
 }
 
-export function makeRollupValidationRequests(seed = 1) {
-  return new RollupValidationRequests(new IncludeByTimestamp(true, BigInt(seed + 0x31415)));
-}
-
 function makeTxConstantData(seed = 1) {
   return new TxConstantData(makeHeader(seed), makeTxContext(seed + 0x100), new Fr(seed + 0x200), new Fr(seed + 0x201));
 }
@@ -411,9 +405,9 @@ export function makePrivateKernelTailCircuitPublicInputs(
     : undefined;
   return new PrivateKernelTailCircuitPublicInputs(
     makeTxConstantData(seed + 0x300),
-    makeRollupValidationRequests(seed + 0x500),
     makeGas(seed + 0x600),
     makeAztecAddress(seed + 0x700),
+    BigInt(seed + 0x800),
     forPublic,
     forRollup,
   );
@@ -422,12 +416,12 @@ export function makePrivateKernelTailCircuitPublicInputs(
 function makePrivateToPublicKernelCircuitPublicInputs(seed = 1) {
   return new PrivateToPublicKernelCircuitPublicInputs(
     makeTxConstantData(seed),
-    makeRollupValidationRequests(seed + 0x100),
     makePrivateToPublicAccumulatedData(seed + 0x200),
     makePrivateToPublicAccumulatedData(seed + 0x300),
     makePublicCallRequest(seed + 0x400),
     makeGas(seed + 0x500),
     makeAztecAddress(seed + 0x600),
+    BigInt(seed + 0x700),
   );
 }
 
@@ -442,10 +436,10 @@ export function makePrivateToRollupKernelCircuitPublicInputs(
 ): PrivateToRollupKernelCircuitPublicInputs {
   return new PrivateToRollupKernelCircuitPublicInputs(
     makeTxConstantData(seed + 0x100),
-    makeRollupValidationRequests(seed),
     makePrivateToRollupAccumulatedData(seed, fullAccumulatedData),
     makeGas(seed + 0x600),
     makeAztecAddress(seed + 0x700),
+    BigInt(seed + 0x800),
   );
 }
 
@@ -562,6 +556,15 @@ export function makeTxRequest(seed = 1): TxRequest {
   });
 }
 
+function makeClaimedLengthArray<T extends Serializable, N extends number>(
+  arraySize: N,
+  makeItem: (seed: number) => T,
+  seed: number,
+  length = arraySize,
+): ClaimedLengthArray<T, N> {
+  return new ClaimedLengthArray(makeTuple(arraySize, makeItem, seed) as Tuple<T, N>, length);
+}
+
 /**
  * Makes arbitrary private circuit public inputs.
  * @param seed - The seed to use for generating the private circuit public inputs.
@@ -569,26 +572,30 @@ export function makeTxRequest(seed = 1): TxRequest {
  */
 export function makePrivateCircuitPublicInputs(seed = 0): PrivateCircuitPublicInputs {
   return PrivateCircuitPublicInputs.from({
-    includeByTimestamp: new IncludeByTimestamp(true, BigInt(seed + 0x31415)),
+    includeByTimestamp: BigInt(seed + 0x31415),
     callContext: makeCallContext(seed, { isStaticCall: true }),
     argsHash: fr(seed + 0x100),
     returnsHash: fr(seed + 0x200),
     minRevertibleSideEffectCounter: fr(0),
-    noteHashReadRequests: makeTuple(MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, makeReadRequest, seed + 0x300),
-    nullifierReadRequests: makeTuple(MAX_NULLIFIER_READ_REQUESTS_PER_CALL, makeReadRequest, seed + 0x310),
-    keyValidationRequestsAndGenerators: makeTuple(
+    noteHashReadRequests: makeClaimedLengthArray(MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, makeReadRequest, seed + 0x300),
+    nullifierReadRequests: makeClaimedLengthArray(MAX_NULLIFIER_READ_REQUESTS_PER_CALL, makeReadRequest, seed + 0x310),
+    keyValidationRequestsAndGenerators: makeClaimedLengthArray(
       MAX_KEY_VALIDATION_REQUESTS_PER_CALL,
       makeKeyValidationRequestAndGenerators,
       seed + 0x320,
     ),
-    noteHashes: makeTuple(MAX_NOTE_HASHES_PER_CALL, makeNoteHash, seed + 0x400),
-    nullifiers: makeTuple(MAX_NULLIFIERS_PER_CALL, makeNullifier, seed + 0x500),
-    privateCallRequests: makeTuple(MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, makePrivateCallRequest, seed + 0x600),
-    publicCallRequests: makeTuple(MAX_ENQUEUED_CALLS_PER_CALL, makeCountedPublicCallRequest, seed + 0x700),
+    noteHashes: makeClaimedLengthArray(MAX_NOTE_HASHES_PER_CALL, makeNoteHash, seed + 0x400),
+    nullifiers: makeClaimedLengthArray(MAX_NULLIFIERS_PER_CALL, makeNullifier, seed + 0x500),
+    privateCallRequests: makeClaimedLengthArray(
+      MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,
+      makePrivateCallRequest,
+      seed + 0x600,
+    ),
+    publicCallRequests: makeClaimedLengthArray(MAX_ENQUEUED_CALLS_PER_CALL, makeCountedPublicCallRequest, seed + 0x700),
     publicTeardownCallRequest: makePublicCallRequest(seed + 0x800),
-    l2ToL1Msgs: makeTuple(MAX_L2_TO_L1_MSGS_PER_CALL, makeCountedL2ToL1Message, seed + 0x800),
-    privateLogs: makeTuple(MAX_PRIVATE_LOGS_PER_CALL, makePrivateLogData, seed + 0x875),
-    contractClassLogsHashes: makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeCountedLogHash, seed + 0xa00),
+    l2ToL1Msgs: makeClaimedLengthArray(MAX_L2_TO_L1_MSGS_PER_CALL, makeCountedL2ToL1Message, seed + 0x800),
+    privateLogs: makeClaimedLengthArray(MAX_PRIVATE_LOGS_PER_CALL, makePrivateLogData, seed + 0x875),
+    contractClassLogsHashes: makeClaimedLengthArray(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeCountedLogHash, seed + 0xa00),
     startSideEffectCounter: fr(seed + 0x849),
     endSideEffectCounter: fr(seed + 0x850),
     historicalHeader: makeHeader(seed + 0xd00, undefined),
@@ -1475,7 +1482,6 @@ export async function makePublicCallRequestWithCalldata(seed = 0): Promise<Publi
 export async function makeAvmTxHint(seed = 0): Promise<AvmTxHint> {
   return new AvmTxHint(
     `txhash-${seed}`,
-    makeGlobalVariables(seed),
     makeGasSettings(),
     makeGasFees(seed + 0x1000),
     {
@@ -1510,6 +1516,7 @@ export async function makeAvmExecutionHints(
   const baseLength = lengthOffset + (seed % lengthSeedMod);
 
   const fields = {
+    globalVariables: makeGlobalVariables(seed + 0x4000),
     tx: await makeAvmTxHint(seed + 0x4100),
     contractInstances: makeArray(baseLength + 2, makeAvmContractInstanceHint, seed + 0x4700),
     contractClasses: makeArray(baseLength + 5, makeAvmContractClassHint, seed + 0x4900),
@@ -1542,6 +1549,7 @@ export async function makeAvmExecutionHints(
   };
 
   return new AvmExecutionHints(
+    fields.globalVariables,
     fields.tx,
     fields.contractInstances,
     fields.contractClasses,
@@ -1650,6 +1658,7 @@ export async function makeBloatedProcessedTx({
 
     tx.data.forRollup!.end = data;
 
+    await tx.recomputeHash();
     return makeProcessedTxFromPrivateOnlyTx(tx, transactionFee, feePaymentPublicDataWrite, globalVariables);
   } else {
     const dataFromPrivate = tx.data.forPublic!;
@@ -1693,9 +1702,9 @@ export async function makeBloatedProcessedTx({
       avmOutput.previousRevertibleAccumulatedData.getArrayLengths();
     // Assign final data emitted from avm.
     avmOutput.accumulatedData.noteHashes = revertibleData.noteHashes;
-    avmOutput.accumulatedData.nullifiers = mergeAccumulatedData(
-      nonRevertibleData.nullifiers,
-      revertibleData.nullifiers,
+    avmOutput.accumulatedData.nullifiers = padArrayEnd(
+      nonRevertibleData.nullifiers.concat(revertibleData.nullifiers).filter(n => !n.isEmpty()),
+      Fr.ZERO,
       MAX_NULLIFIERS_PER_TX,
     );
     avmOutput.accumulatedData.l2ToL1Msgs = revertibleData.l2ToL1Msgs;
@@ -1715,6 +1724,7 @@ export async function makeBloatedProcessedTx({
       billedGas: Gas.empty(),
     } satisfies GasUsed;
 
+    await tx.recomputeHash();
     return makeProcessedTxFromTxWithPublicCalls(
       tx,
       {

package/src/tests/mocks.ts

@@ -1,4 +1,4 @@
-import { MAX_ENQUEUED_CALLS_PER_TX } from '@aztec/constants';
+import { MAX_ENQUEUED_CALLS_PER_TX, MAX_INCLUDE_BY_TIMESTAMP_DURATION } from '@aztec/constants';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { times } from '@aztec/foundation/collection';
 import { Secp256k1Signer, randomBytes } from '@aztec/foundation/crypto';
@@ -126,6 +126,9 @@ export const mockTx = async (
   data.constants.vkTreeRoot = vkTreeRoot;
   data.constants.protocolContractTreeRoot = protocolContractTreeRoot;
 
+  // Set includeByTimestamp to the maximum allowed duration from the current time.
+  data.includeByTimestamp = BigInt(Math.floor(Date.now() / 1000) + MAX_INCLUDE_BY_TIMESTAMP_DURATION);
+
   const publicFunctionCalldata: HashedValues[] = [];
   if (!isForPublic) {
     data.forRollup!.end.nullifiers[0] = firstNullifier.value;
@@ -163,7 +166,12 @@ export const mockTx = async (
       .build();
   }
 
-  return new Tx(data, clientIvcProof, [], publicFunctionCalldata);
+  return await Tx.create({
+    data,
+    clientIvcProof,
+    contractClassLogFields: [],
+    publicFunctionCalldata,
+  });
 };
 
 export const mockTxForRollup = (seed = 1, opts: Parameters<typeof mockTx>[1] = {}) =>
@@ -214,7 +222,6 @@ export const randomContractArtifact = (): ContractArtifact => ({
   },
   fileMap: {},
   storageLayout: {},
-  notes: {},
 });
 
 export const randomContractInstanceWithAddress = async (
@@ -252,18 +259,12 @@ const makeAndSignConsensusPayload = (
   options?: MakeConsensusPayloadOptions,
 ) => {
   const header = options?.header ?? makeHeader(1);
-  const {
-    signer = Secp256k1Signer.random(),
-    archive = Fr.random(),
-    stateReference = header.state,
-    txHashes = [0, 1, 2, 3, 4, 5].map(() => TxHash.random()),
-  } = options ?? {};
+  const { signer = Secp256k1Signer.random(), archive = Fr.random(), stateReference = header.state } = options ?? {};
 
   const payload = ConsensusPayload.fromFields({
     header: header.toPropose(),
     archive,
     stateReference,
-    txHashes,
   });
 
   const hash = getHashedSignaturePayloadEthSignedMessage(payload, domainSeparator);
@@ -277,7 +278,8 @@ export const makeBlockProposal = (options?: MakeConsensusPayloadOptions): BlockP
     SignatureDomainSeparator.blockProposal,
     options,
   );
-  return new BlockProposal(blockNumber, payload, signature, options?.txs ?? []);
+  const txHashes = options?.txHashes ?? [0, 1, 2, 3, 4, 5].map(() => TxHash.random());
+  return new BlockProposal(blockNumber, payload, signature, txHashes, options?.txs ?? []);
 };
 
 // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8028)
@@ -289,6 +291,16 @@ export const makeBlockAttestation = (options?: MakeConsensusPayloadOptions): Blo
   return new BlockAttestation(blockNumber, payload, signature);
 };
 
+export const makeBlockAttestationFromBlock = (block: L2Block, signer?: Secp256k1Signer): BlockAttestation => {
+  return makeBlockAttestation({
+    signer,
+    header: block.header,
+    archive: block.archive.root,
+    stateReference: block.header.state,
+    txHashes: block.body.txEffects.map(tx => tx.txHash),
+  });
+};
+
 export async function randomPublishedL2Block(
   l2BlockNumber: number,
   opts: { signers?: Secp256k1Signer[] } = {},
@@ -301,17 +313,7 @@ export async function randomPublishedL2Block(
   };
 
   const signers = opts.signers ?? times(3, () => Secp256k1Signer.random());
-  const atts = await Promise.all(
-    signers.map(signer =>
-      makeBlockAttestation({
-        signer,
-        header: block.header,
-        archive: block.archive.root,
-        stateReference: block.header.state,
-        txHashes: block.body.txEffects.map(tx => tx.txHash),
-      }),
-    ),
-  );
+  const atts = await Promise.all(signers.map(signer => makeBlockAttestationFromBlock(block, signer)));
   const attestations = atts.map(
     (attestation, i) => new CommitteeAttestation(signers[i].address, attestation.signature),
   );

package/src/tx/index.ts

@@ -1,7 +1,6 @@
 export * from './block_header.js';
 export * from './call_context.js';
 export * from './global_variables.js';
-export * from './include_by_timestamp.js';
 export * from './content_commitment.js';
 export * from './state_reference.js';
 export * from './partial_state_reference.js';

package/src/tx/private_execution_result.ts

@@ -136,7 +136,7 @@ export class PrivateCallExecutionResult {
     /** The offchain effects emitted during execution of this function call via the `emit_offchain_effect` oracle. */
     public offchainEffects: { data: Fr[] }[],
     /** The nested executions. */
-    public nestedExecutions: PrivateCallExecutionResult[],
+    public nestedExecutionResults: PrivateCallExecutionResult[],
     /**
      * Contract class logs emitted during execution of this function call.
      * Note: We only need to collect the ContractClassLogFields as preimages for the tx.
@@ -158,7 +158,7 @@ export class PrivateCallExecutionResult {
         noteHashNullifierCounterMap: mapSchema(z.coerce.number(), z.number()),
         returnValues: z.array(schemas.Fr),
         offchainEffects: z.array(z.object({ data: z.array(schemas.Fr) })),
-        nestedExecutions: z.array(z.lazy(() => PrivateCallExecutionResult.schema)),
+        nestedExecutionResults: z.array(z.lazy(() => PrivateCallExecutionResult.schema)),
         contractClassLogs: z.array(CountedContractClassLog.schema),
       })
       .transform(PrivateCallExecutionResult.from);
@@ -175,7 +175,7 @@ export class PrivateCallExecutionResult {
       fields.noteHashNullifierCounterMap,
       fields.returnValues,
       fields.offchainEffects,
-      fields.nestedExecutions,
+      fields.nestedExecutionResults,
       fields.contractClassLogs,
     );
   }
@@ -205,7 +205,7 @@ export function collectNoteHashLeafIndexMap(execResult: PrivateExecutionResult)
   const accum: Map<bigint, bigint> = new Map();
   const collectNoteHashLeafIndexMapRecursive = (callResult: PrivateCallExecutionResult, accum: Map<bigint, bigint>) => {
     callResult.noteHashLeafIndexMap.forEach((value, key) => accum.set(key, value));
-    callResult.nestedExecutions.forEach(nested => collectNoteHashLeafIndexMapRecursive(nested, accum));
+    callResult.nestedExecutionResults.forEach(nested => collectNoteHashLeafIndexMapRecursive(nested, accum));
   };
   collectNoteHashLeafIndexMapRecursive(execResult.entrypoint, accum);
   return accum;
@@ -218,7 +218,7 @@ export function collectNoteHashNullifierCounterMap(execResult: PrivateExecutionR
     accum: Map<number, number>,
   ) => {
     callResult.noteHashNullifierCounterMap.forEach((value, key) => accum.set(key, value));
-    callResult.nestedExecutions.forEach(nested => collectNoteHashNullifierCounterMapRecursive(nested, accum));
+    callResult.nestedExecutionResults.forEach(nested => collectNoteHashNullifierCounterMapRecursive(nested, accum));
   };
   collectNoteHashNullifierCounterMapRecursive(execResult.entrypoint, accum);
   return accum;
@@ -230,7 +230,7 @@ export function collectNoteHashNullifierCounterMap(execResult: PrivateExecutionR
  * @returns All contract class logs.
  */
 function collectContractClassLogs(execResult: PrivateCallExecutionResult): CountedContractClassLog[] {
-  return [execResult.contractClassLogs, ...execResult.nestedExecutions.flatMap(collectContractClassLogs)].flat();
+  return [execResult.contractClassLogs, ...execResult.nestedExecutionResults.flatMap(collectContractClassLogs)].flat();
 }
 
 /**
@@ -256,7 +256,7 @@ export function collectOffchainEffects(execResult: PrivateExecutionResult): Offc
         ...msg,
         contractAddress: callResult.publicInputs.callContext.contractAddress, // contract that emitted the effect
       })),
-      ...callResult.nestedExecutions.flatMap(nested => collectEffectsRecursive(nested)),
+      ...callResult.nestedExecutionResults.flatMap(nested => collectEffectsRecursive(nested)),
     ];
   };
   return collectEffectsRecursive(execResult.entrypoint);
@@ -264,7 +264,7 @@ export function collectOffchainEffects(execResult: PrivateExecutionResult): Offc
 
 export function getFinalMinRevertibleSideEffectCounter(execResult: PrivateExecutionResult): number {
   const collectFinalMinRevertibleSideEffectCounterRecursive = (callResult: PrivateCallExecutionResult): number => {
-    return callResult.nestedExecutions.reduce((counter, exec) => {
+    return callResult.nestedExecutionResults.reduce((counter, exec) => {
       const nestedCounter = collectFinalMinRevertibleSideEffectCounterRecursive(exec);
       return nestedCounter ? nestedCounter : counter;
     }, callResult.publicInputs.minRevertibleSideEffectCounter.toNumber());
@@ -279,7 +279,9 @@ export function collectNested<T>(
   const thisExecutionReads = executionStack.flatMap(extractExecutionItems);
 
   return thisExecutionReads.concat(
-    executionStack.flatMap(({ nestedExecutions }) => collectNested(nestedExecutions, extractExecutionItems)),
+    executionStack.flatMap(({ nestedExecutionResults }) =>
+      collectNested(nestedExecutionResults, extractExecutionItems),
+    ),
   );
 }
 

package/src/tx/processed_tx.ts

@@ -77,16 +77,16 @@ export type FailedTx = {
   error: Error;
 };
 
-export async function makeProcessedTxFromPrivateOnlyTx(
+export function makeProcessedTxFromPrivateOnlyTx(
   tx: Tx,
   transactionFee: Fr,
   feePaymentPublicDataWrite: PublicDataWrite,
   globalVariables: GlobalVariables,
-): Promise<ProcessedTx> {
+): ProcessedTx {
   const data = tx.data.forRollup!;
   const txEffect = new TxEffect(
     RevertCode.OK,
-    await tx.getTxHash(),
+    tx.getTxHash(),
     transactionFee,
     data.end.noteHashes.filter(h => !h.isZero()),
     data.end.nullifiers.filter(h => !h.isZero()),
@@ -134,13 +134,13 @@ export function toNumBlobFields(txs: ProcessedTx[]): number {
   }, 0);
 }
 
-export async function makeProcessedTxFromTxWithPublicCalls(
+export function makeProcessedTxFromTxWithPublicCalls(
   tx: Tx,
   avmProvingRequest: AvmProvingRequest,
   gasUsed: GasUsed,
   revertCode: RevertCode,
   revertReason: SimulationError | undefined,
-): Promise<ProcessedTx> {
+): ProcessedTx {
   const avmPublicInputs = avmProvingRequest.inputs.publicInputs;
 
   const globalVariables = avmPublicInputs.globalVariables;
@@ -158,7 +158,7 @@ export async function makeProcessedTxFromTxWithPublicCalls(
 
   const txEffect = new TxEffect(
     revertCode,
-    await tx.getTxHash(),
+    tx.getTxHash(),
     avmPublicInputs.transactionFee,
     avmPublicInputs.accumulatedData.noteHashes.filter(h => !h.isZero()),
     avmPublicInputs.accumulatedData.nullifiers.filter(h => !h.isZero()),

package/src/tx/proven_tx.ts

@@ -22,16 +22,15 @@ export class TxProvingResult {
     public stats?: ProvingStats,
   ) {}
 
-  toTx(): Tx {
+  async toTx(): Promise<Tx> {
     const contractClassLogs = collectSortedContractClassLogs(this.privateExecutionResult);
 
-    const tx = new Tx(
-      this.publicInputs,
-      this.clientIvcProof,
-      contractClassLogs,
-      this.privateExecutionResult.publicFunctionCalldata,
-    );
-    return tx;
+    return await Tx.create({
+      data: this.publicInputs,
+      clientIvcProof: this.clientIvcProof,
+      contractClassLogFields: contractClassLogs,
+      publicFunctionCalldata: this.privateExecutionResult.publicFunctionCalldata,
+    });
   }
 
   getOffchainEffects(): OffchainEffect[] {

package/src/tx/simulated_tx.ts

@@ -4,7 +4,6 @@ import type { FieldsOf } from '@aztec/foundation/types';
 import { z } from 'zod';
 
 import { type ContractArtifact, ContractArtifactSchema } from '../abi/abi.js';
-import { AztecAddress } from '../aztec-address/index.js';
 import {
   type ContractInstanceWithAddress,
   ContractInstanceWithAddressSchema,
@@ -37,10 +36,7 @@ export type ContractOverrides = Record<
  * set, it *must* be run without the kernel circuits, or validations will fail
  */
 export class SimulationOverrides {
-  constructor(
-    public contracts?: ContractOverrides,
-    public msgSender?: AztecAddress,
-  ) {}
+  constructor(public contracts?: ContractOverrides) {}
 
   static get schema() {
     return z
@@ -51,10 +47,9 @@ export class SimulationOverrides {
             z.object({ instance: ContractInstanceWithAddressSchema, artifact: ContractArtifactSchema }),
           ),
         ),
-        msgSender: optional(AztecAddress.schema),
       })
-      .transform(({ contracts, msgSender }) => {
-        return new SimulationOverrides(contracts, msgSender);
+      .transform(({ contracts }) => {
+        return new SimulationOverrides(contracts);
       });
   }
 }
@@ -69,16 +64,15 @@ export class PrivateSimulationResult {
     return accumulatePrivateReturnValues(this.privateExecutionResult);
   }
 
-  toSimulatedTx(): Tx {
+  async toSimulatedTx(): Promise<Tx> {
     const contractClassLogs = collectSortedContractClassLogs(this.privateExecutionResult);
 
-    const tx = new Tx(
-      this.publicInputs,
-      ClientIvcProof.empty(),
-      contractClassLogs,
-      this.privateExecutionResult.publicFunctionCalldata,
-    );
-    return tx;
+    return await Tx.create({
+      data: this.publicInputs,
+      clientIvcProof: ClientIvcProof.empty(),
+      contractClassLogFields: contractClassLogs,
+      publicFunctionCalldata: this.privateExecutionResult.publicFunctionCalldata,
+    });
   }
 }
 
@@ -146,7 +140,7 @@ export class TxSimulationResult {
     return new PrivateSimulationResult(this.privateExecutionResult, this.publicInputs).getPrivateReturnValues();
   }
 
-  toSimulatedTx(): Tx {
+  toSimulatedTx(): Promise<Tx> {
     return new PrivateSimulationResult(this.privateExecutionResult, this.publicInputs).toSimulatedTx();
   }
 
@@ -166,8 +160,8 @@ export function accumulatePrivateReturnValues(executionResult: PrivateExecutionR
     executionResult: PrivateCallExecutionResult,
   ): NestedProcessReturnValues => {
     const acc = new NestedProcessReturnValues(executionResult.returnValues);
-    acc.nested = executionResult.nestedExecutions.map(nestedExecution =>
-      collectPrivateReturnValuesRecursive(nestedExecution),
+    acc.nested = executionResult.nestedExecutionResults.map(nestedExecutionResult =>
+      collectPrivateReturnValuesRecursive(nestedExecutionResult),
     );
     return acc;
   };