@aztec/stdlib 0.0.1-commit.6d3c34e → 0.0.1-commit.6ebe706df

package/src/tx/private_execution_result.ts

@@ -11,7 +11,7 @@ import { PrivateCircuitPublicInputs } from '../kernel/private_circuit_public_inp
 import type { IsEmpty } from '../kernel/utils/interfaces.js';
 import { sortByCounter } from '../kernel/utils/order_and_comparison.js';
 import { ContractClassLog, ContractClassLogFields } from '../logs/contract_class_log.js';
-import { type PreTag, PreTagSchema } from '../logs/pre_tag.js';
+import { type TaggingIndexRange, TaggingIndexRangeSchema } from '../logs/tagging_index_range.js';
 import { Note } from '../note/note.js';
 import { type ZodFor, mapSchema, schemas } from '../schemas/index.js';
 import { HashedValues } from './hashed_values.js';
@@ -79,7 +79,7 @@ export class CountedContractClassLog implements IsEmpty {
 export class PrivateExecutionResult {
   constructor(
     public entrypoint: PrivateCallExecutionResult,
-    /** The first non revertible nullifier, or zero if there was none. */
+    /** The first non-revertible nullifier emitted by any private call, or the protocol nullifier if there was none. */
     public firstNullifier: Fr,
     /** An array of calldata for the enqueued public function calls and the teardown function call. */
     public publicFunctionCalldata: HashedValues[],
@@ -137,8 +137,8 @@ export class PrivateCallExecutionResult {
     public returnValues: Fr[],
     /** The offchain effects emitted during execution of this function call via the `emit_offchain_effect` oracle. */
     public offchainEffects: { data: Fr[] }[],
-    /** The pre-tags used in this tx to compute tags for private logs */
-    public preTags: PreTag[],
+    /** The tagging index ranges used in this tx to compute tags for private logs */
+    public taggingIndexRanges: TaggingIndexRange[],
     /** The nested executions. */
     public nestedExecutionResults: PrivateCallExecutionResult[],
     /**
@@ -161,7 +161,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) })),
-        preTags: z.array(PreTagSchema),
+        taggingIndexRanges: z.array(TaggingIndexRangeSchema),
         nestedExecutionResults: z.array(z.lazy(() => PrivateCallExecutionResult.schema)),
         contractClassLogs: z.array(CountedContractClassLog.schema),
       })
@@ -178,7 +178,7 @@ export class PrivateCallExecutionResult {
       fields.noteHashNullifierCounterMap,
       fields.returnValues,
       fields.offchainEffects,
-      fields.preTags,
+      fields.taggingIndexRanges,
       fields.nestedExecutionResults,
       fields.contractClassLogs,
     );

package/src/tx/profiling.ts

@@ -3,12 +3,39 @@ import { type ZodFor, optional, schemas } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
+import { AztecAddress } from '../aztec-address/index.js';
 import type { AztecNode } from '../interfaces/aztec-node.js';
 import { type PrivateExecutionStep, PrivateExecutionStepSchema } from '../kernel/private_kernel_prover_output.js';
 
-export type NodeStats = Partial<Record<keyof AztecNode, { times: number[] }>>;
+export type RoundTripStats = {
+  /** Number of round trips (times we blocked waiting for node responses) */
+  roundTrips: number;
+  /** Total wall-clock time spent waiting on node (excludes parallel overlap) */
+  totalBlockingTime: number;
+  /** Individual round trip durations */
+  roundTripDurations: number[];
+  /** Methods called in each round trip (parallel calls grouped together) */
+  roundTripMethods: string[][];
+};
+
+const RoundTripStatsSchema = z.object({
+  roundTrips: z.number(),
+  totalBlockingTime: z.number(),
+  roundTripDurations: z.array(z.number()),
+  roundTripMethods: z.array(z.array(z.string())),
+});
+
+export type NodeStats = {
+  /** Per-method call stats */
+  perMethod: Partial<Record<keyof AztecNode, { times: number[] }>>;
+  /** Round trip stats tracking actual blocking waits */
+  roundTrips: RoundTripStats;
+};
 
-const NodeStatsSchema = z.record(z.string(), z.object({ times: z.array(z.number()) }));
+const NodeStatsSchema = z.object({
+  perMethod: z.record(z.string(), z.object({ times: z.array(z.number()) })),
+  roundTrips: RoundTripStatsSchema,
+});
 
 type FunctionTiming = {
   functionName: string;
@@ -105,7 +132,15 @@ export class TxProfileResult {
         },
       ],
       {
-        nodeRPCCalls: { getBlockHeader: { times: [1] } },
+        nodeRPCCalls: {
+          perMethod: { getBlockHeader: { times: [1] } },
+          roundTrips: {
+            roundTrips: 1,
+            totalBlockingTime: 1,
+            roundTripDurations: [1],
+            roundTripMethods: [['getBlockHeader']],
+          },
+        },
         timings: {
           sync: 1,
           proving: 1,
@@ -123,24 +158,40 @@ export class TxProfileResult {
   }
 }
 
-export class UtilitySimulationResult {
+export class UtilityExecutionResult {
   constructor(
     public result: Fr[],
+    public offchainEffects: { data: Fr[]; contractAddress: AztecAddress }[],
+    /** Timestamp of the anchor block used during utility execution. */
+    public anchorBlockTimestamp: bigint,
     public stats?: SimulationStats,
   ) {}
 
-  static get schema(): ZodFor<UtilitySimulationResult> {
+  static get schema(): ZodFor<UtilityExecutionResult> {
     return z
       .object({
         result: z.array(schemas.Fr),
+        offchainEffects: z.array(z.object({ data: z.array(schemas.Fr), contractAddress: AztecAddress.schema })),
+        anchorBlockTimestamp: schemas.BigInt,
         stats: optional(SimulationStatsSchema),
       })
-      .transform(({ result, stats }) => new UtilitySimulationResult(result, stats));
+      .transform(
+        ({ result, offchainEffects, anchorBlockTimestamp, stats }) =>
+          new UtilityExecutionResult(result, offchainEffects, anchorBlockTimestamp, stats),
+      );
   }
 
-  static random(): UtilitySimulationResult {
-    return new UtilitySimulationResult([Fr.random()], {
-      nodeRPCCalls: { getBlockHeader: { times: [1] } },
+  static random(): UtilityExecutionResult {
+    return new UtilityExecutionResult([Fr.random()], [], 0n, {
+      nodeRPCCalls: {
+        perMethod: { getBlockHeader: { times: [1] } },
+        roundTrips: {
+          roundTrips: 1,
+          totalBlockingTime: 1,
+          roundTripDurations: [1],
+          roundTripMethods: [['getBlockHeader']],
+        },
+      },
       timings: {
         sync: 1,
         publicSimulation: 1,

package/src/tx/protocol_contracts.ts

@@ -1,4 +1,4 @@
-import { GeneratorIndex, MAX_PROTOCOL_CONTRACTS } from '@aztec/constants';
+import { DomainSeparator, MAX_PROTOCOL_CONTRACTS } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
@@ -71,7 +71,7 @@ export class ProtocolContracts {
   }
 
   hash() {
-    return poseidon2HashWithSeparator(this.derivedAddresses, GeneratorIndex.PROTOCOL_CONTRACTS);
+    return poseidon2HashWithSeparator(this.derivedAddresses, DomainSeparator.PROTOCOL_CONTRACTS);
   }
 
   static get schema() {

package/src/tx/public_simulation_output.ts

@@ -7,6 +7,7 @@ import { z } from 'zod';
 import { SimulationError } from '../errors/simulation_error.js';
 import { Gas } from '../gas/gas.js';
 import type { GasUsed } from '../gas/gas_used.js';
+import { DebugLog } from '../logs/debug_log.js';
 import { NullishToUndefined } from '../schemas/schemas.js';
 import { TxEffect } from '../tx/tx_effect.js';
 import { GlobalVariables } from './global_variables.js';
@@ -71,6 +72,7 @@ export class PublicSimulationOutput {
     public txEffect: TxEffect,
     public publicReturnValues: NestedProcessReturnValues[],
     public gasUsed: GasUsed,
+    public debugLogs: DebugLog[] = [],
   ) {}
 
   static get schema(): ZodFor<PublicSimulationOutput> {
@@ -86,6 +88,7 @@ export class PublicSimulationOutput {
           publicGas: Gas.schema,
           billedGas: Gas.schema,
         }),
+        debugLogs: z.array(DebugLog.schema).default([]),
       })
       .transform(
         fields =>
@@ -95,6 +98,7 @@ export class PublicSimulationOutput {
             fields.txEffect,
             fields.publicReturnValues,
             fields.gasUsed,
+            fields.debugLogs,
           ),
       );
   }

package/src/tx/simulated_tx.ts

@@ -12,9 +12,11 @@ import { Gas } from '../gas/gas.js';
 import type { GasUsed } from '../gas/gas_used.js';
 import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
 import { ChonkProof } from '../proofs/chonk_proof.js';
+import type { OffchainEffect } from './offchain_effect.js';
 import {
   PrivateCallExecutionResult,
   PrivateExecutionResult,
+  collectOffchainEffects,
   collectSortedContractClassLogs,
 } from './private_execution_result.js';
 import { type SimulationStats, SimulationStatsSchema } from './profiling.js';
@@ -84,6 +86,11 @@ export class TxSimulationResult {
     public stats?: SimulationStats,
   ) {}
 
+  /** Returns offchain effects collected from private execution. */
+  get offchainEffects(): OffchainEffect[] {
+    return collectOffchainEffects(this.privateExecutionResult);
+  }
+
   get gasUsed(): GasUsed {
     return (
       this.publicOutput?.gasUsed ?? {
@@ -106,7 +113,7 @@ export class TxSimulationResult {
       .transform(TxSimulationResult.from);
   }
 
-  static from(fields: Omit<FieldsOf<TxSimulationResult>, 'gasUsed'>) {
+  static from(fields: Omit<FieldsOf<TxSimulationResult>, 'gasUsed' | 'offchainEffects'>) {
     return new TxSimulationResult(
       fields.privateExecutionResult,
       fields.publicInputs,

package/src/tx/tx.ts

@@ -1,9 +1,9 @@
+import { DA_GAS_PER_FIELD, TX_DA_GAS_OVERHEAD } from '@aztec/constants';
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { arraySerializedSizeOfNonEmpty } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { ZodFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeArrayOfBufferableToVector, serializeToBuffer } from '@aztec/foundation/serialize';
-import type { FieldsOf } from '@aztec/foundation/types';
+import { type FieldsOf, unfreeze } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
@@ -247,7 +247,7 @@ export class Tx extends Gossipable {
       contractClassLogSize: this.data.getEmittedContractClassLogsLength(),
 
       proofSize: this.chonkProof.fields.length,
-      size: this.toBuffer().length,
+      size: this.getSize(),
 
       feePaymentMethod:
         // needsSetup? then we pay through a fee payment contract
@@ -255,26 +255,34 @@ export class Tx extends Gossipable {
     };
   }
 
-  getSize() {
-    return (
-      this.data.getSize() +
-      this.chonkProof.fields.length * Fr.SIZE_IN_BYTES +
-      arraySerializedSizeOfNonEmpty(this.contractClassLogFields) +
-      this.publicFunctionCalldata.reduce((accum, cd) => accum + cd.getSize(), 0)
-    );
+  private sizeCache: number | undefined;
+
+  getSize(): number {
+    if (this.sizeCache == undefined) {
+      this.sizeCache = this.toBuffer().length;
+    }
+    return this.sizeCache;
   }
 
   /**
-   * Estimates the tx size based on its private effects. Note that the actual size of the tx
-   * after processing will probably be larger, as public execution would generate more data.
+   * Returns the number of fields this tx's effects will occupy in the blob,
+   * based on its private side effects only. Accurate for txs without public calls.
+   * For txs with public calls, the actual size will be larger due to public execution outputs.
    */
-  getEstimatedPrivateTxEffectsSize() {
-    return (
-      this.data.getNonEmptyNoteHashes().length * Fr.SIZE_IN_BYTES +
-      this.data.getNonEmptyNullifiers().length * Fr.SIZE_IN_BYTES +
-      this.data.getEmittedPrivateLogsLength() * Fr.SIZE_IN_BYTES +
-      this.data.getEmittedContractClassLogsLength() * Fr.SIZE_IN_BYTES
-    );
+  getPrivateTxEffectsSizeInFields(): number {
+    // 3 fields overhead: tx_start_marker, tx_hash, tx_fee.
+    // TX_DA_GAS_OVERHEAD is defined as N * DA_GAS_PER_FIELD, so this division is always exact.
+    const overheadFields = TX_DA_GAS_OVERHEAD / DA_GAS_PER_FIELD;
+    const noteHashes = this.data.getNonEmptyNoteHashes().length;
+    const nullifiers = this.data.getNonEmptyNullifiers().length;
+    const l2ToL1Msgs = this.data.getNonEmptyL2ToL1Msgs().length;
+    // Each private log occupies (emittedLength + 1) fields: content + length field
+    const privateLogFields = this.data.getNonEmptyPrivateLogs().reduce((acc, log) => acc + log.emittedLength + 1, 0);
+    // Each contract class log occupies (length + 1) fields: content + contract address
+    const contractClassLogFields = this.data
+      .getNonEmptyContractClassLogsHashes()
+      .reduce((acc, log) => acc + log.logHash.length + 1, 0);
+    return overheadFields + noteHashes + nullifiers + l2ToL1Msgs + privateLogFields + contractClassLogFields;
   }
 
   /**
@@ -310,7 +318,7 @@ export class Tx extends Gossipable {
 
   /** Recomputes the tx hash. Used for testing purposes only when a property of the tx was mutated. */
   public async recomputeHash(): Promise<TxHash> {
-    (this as any).txHash = await Tx.computeTxHash(this);
+    unfreeze(this).txHash = await Tx.computeTxHash(this);
     return this.txHash;
   }
 

package/src/tx/tx_effect.ts

@@ -28,7 +28,6 @@ import { RevertCode } from '../avm/revert_code.js';
 import { ContractClassLog } from '../logs/contract_class_log.js';
 import { PrivateLog } from '../logs/private_log.js';
 import { FlatPublicLogs, PublicLog } from '../logs/public_log.js';
-import { computeTxOutHash } from '../messaging/out_hash.js';
 import { TxHash } from './tx_hash.js';
 
 export class TxEffect {
@@ -184,14 +183,6 @@ export class TxEffect {
     );
   }
 
-  /**
-   * Computes txOutHash of this tx effect.
-   * @dev Follows new_sha in unbalanced_merkle_tree.nr
-   */
-  txOutHash(): Fr {
-    return computeTxOutHash(this.l2ToL1Msgs);
-  }
-
   static async random({
     numNoteHashes,
     numNullifiers,

package/src/tx/tx_receipt.ts

@@ -1,19 +1,35 @@
-import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
-import type { FieldsOf } from '@aztec/foundation/types';
+import { BlockNumber, BlockNumberSchema, EpochNumber, EpochNumberSchema } from '@aztec/foundation/branded-types';
 
 import { z } from 'zod';
 
 import { RevertCode } from '../avm/revert_code.js';
-import { L2BlockHash } from '../block/block_hash.js';
+import { BlockHash } from '../block/block_hash.js';
+import { DebugLog } from '../logs/debug_log.js';
 import { type ZodFor, schemas } from '../schemas/schemas.js';
 import { TxHash } from './tx_hash.js';
 
-/**
- * Possible status of a transaction.
- */
+/** Block inclusion/finalization status. */
 export enum TxStatus {
   DROPPED = 'dropped',
   PENDING = 'pending',
+  PROPOSED = 'proposed',
+  CHECKPOINTED = 'checkpointed',
+  PROVEN = 'proven',
+  FINALIZED = 'finalized',
+}
+
+/** Tx status sorted by finalization progress. */
+export const SortedTxStatuses: TxStatus[] = [
+  TxStatus.DROPPED,
+  TxStatus.PENDING,
+  TxStatus.PROPOSED,
+  TxStatus.CHECKPOINTED,
+  TxStatus.PROVEN,
+  TxStatus.FINALIZED,
+];
+
+/** Execution result - only set when tx is in a block. */
+export enum TxExecutionResult {
   SUCCESS = 'success',
   APP_LOGIC_REVERTED = 'app_logic_reverted',
   TEARDOWN_REVERTED = 'teardown_reverted',
@@ -30,20 +46,60 @@ export class TxReceipt {
   constructor(
     /** A unique identifier for a transaction. */
     public txHash: TxHash,
-    /** The transaction's status. */
+    /** The transaction's block finalization status. */
     public status: TxStatus,
+    /** The execution result of the transaction, only set when tx is in a block. */
+    public executionResult: TxExecutionResult | undefined,
     /** Description of transaction error, if any. */
-    public error: string,
+    public error: string | undefined,
     /** The transaction fee paid for the transaction. */
     public transactionFee?: bigint,
     /** The hash of the block containing the transaction. */
-    public blockHash?: L2BlockHash,
+    public blockHash?: BlockHash,
     /** The block number in which the transaction was included. */
     public blockNumber?: BlockNumber,
+    /** The epoch number in which the transaction was included. */
+    public epochNumber?: EpochNumber,
+    /**
+     * Debug logs collected during public function execution. Served only when the node is in test mode and placed on
+     * the receipt only because it's a convenient place for it (the logs are printed out by the wallet when a mined
+     * tx receipt is obtained).
+     */
+    public debugLogs?: DebugLog[],
   ) {}
 
+  /** Returns true if the transaction was executed successfully. */
+  hasExecutionSucceeded(): boolean {
+    return this.executionResult === TxExecutionResult.SUCCESS;
+  }
+
+  /** Returns true if the transaction execution reverted. */
+  hasExecutionReverted(): boolean {
+    return this.executionResult !== undefined && this.executionResult !== TxExecutionResult.SUCCESS;
+  }
+
+  /** Returns true if the transaction has been included in a block (proposed, checkpointed, proven, or finalized). */
+  isMined(): boolean {
+    return (
+      this.status === TxStatus.PROPOSED ||
+      this.status === TxStatus.CHECKPOINTED ||
+      this.status === TxStatus.PROVEN ||
+      this.status === TxStatus.FINALIZED
+    );
+  }
+
+  /** Returns true if the transaction is pending. */
+  isPending(): boolean {
+    return this.status === TxStatus.PENDING;
+  }
+
+  /** Returns true if the transaction was dropped. */
+  isDropped(): boolean {
+    return this.status === TxStatus.DROPPED;
+  }
+
   static empty() {
-    return new TxReceipt(TxHash.zero(), TxStatus.DROPPED, '');
+    return new TxReceipt(TxHash.zero(), TxStatus.DROPPED, undefined, undefined);
   }
 
   static get schema(): ZodFor<TxReceipt> {
@@ -51,34 +107,50 @@ export class TxReceipt {
       .object({
         txHash: TxHash.schema,
         status: z.nativeEnum(TxStatus),
-        error: z.string(),
-        blockHash: L2BlockHash.schema.optional(),
+        executionResult: z.nativeEnum(TxExecutionResult).optional(),
+        error: z.string().optional(),
+        blockHash: BlockHash.schema.optional(),
         blockNumber: BlockNumberSchema.optional(),
+        epochNumber: EpochNumberSchema.optional(),
         transactionFee: schemas.BigInt.optional(),
+        debugLogs: z.array(DebugLog.schema).optional(),
       })
-      .transform(TxReceipt.from);
+      .transform(fields => TxReceipt.from(fields));
   }
 
-  static from(fields: FieldsOf<TxReceipt>) {
+  static from(fields: {
+    txHash: TxHash;
+    status: TxStatus;
+    executionResult?: TxExecutionResult;
+    error?: string;
+    transactionFee?: bigint;
+    blockHash?: BlockHash;
+    blockNumber?: BlockNumber;
+    epochNumber?: EpochNumber;
+    debugLogs?: DebugLog[];
+  }) {
     return new TxReceipt(
       fields.txHash,
       fields.status,
+      fields.executionResult,
       fields.error,
       fields.transactionFee,
       fields.blockHash,
       fields.blockNumber,
+      fields.epochNumber,
+      fields.debugLogs,
     );
   }
 
-  public static statusFromRevertCode(revertCode: RevertCode) {
+  public static executionResultFromRevertCode(revertCode: RevertCode): TxExecutionResult {
     if (revertCode.equals(RevertCode.OK)) {
-      return TxStatus.SUCCESS;
+      return TxExecutionResult.SUCCESS;
     } else if (revertCode.equals(RevertCode.APP_LOGIC_REVERTED)) {
-      return TxStatus.APP_LOGIC_REVERTED;
+      return TxExecutionResult.APP_LOGIC_REVERTED;
     } else if (revertCode.equals(RevertCode.TEARDOWN_REVERTED)) {
-      return TxStatus.TEARDOWN_REVERTED;
+      return TxExecutionResult.TEARDOWN_REVERTED;
     } else if (revertCode.equals(RevertCode.BOTH_REVERTED)) {
-      return TxStatus.BOTH_REVERTED;
+      return TxExecutionResult.BOTH_REVERTED;
     } else {
       throw new Error(`Unknown revert code: ${revertCode.getCode()}`);
     }

package/src/tx/tx_request.ts

@@ -1,4 +1,4 @@
-import { GeneratorIndex, TX_REQUEST_LENGTH } from '@aztec/constants';
+import { DomainSeparator, TX_REQUEST_LENGTH } from '@aztec/constants';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
@@ -68,7 +68,7 @@ export class TxRequest {
   }
 
   hash() {
-    return poseidon2HashWithSeparator(this.toFields(), GeneratorIndex.TX_REQUEST);
+    return poseidon2HashWithSeparator(this.toFields(), DomainSeparator.TX_REQUEST);
   }
 
   static empty() {

package/src/tx/validator/empty_validator.ts

@@ -1,6 +1,6 @@
 import type { AnyTx, TxValidationResult, TxValidator } from './tx_validator.js';
 
-export class EmptyTxValidator<T extends AnyTx = AnyTx> implements TxValidator<T> {
+export class EmptyTxValidator<T = AnyTx> implements TxValidator<T> {
   public validateTx(_tx: T): Promise<TxValidationResult> {
     return Promise.resolve({ result: 'valid' });
   }

package/src/tx/validator/error_texts.ts

@@ -6,13 +6,17 @@ export const TX_ERROR_GAS_LIMIT_TOO_HIGH = 'Gas limit is higher than the amount
 
 // Phases
 export const TX_ERROR_SETUP_FUNCTION_NOT_ALLOWED = 'Setup function not on allow list';
+export const TX_ERROR_SETUP_FUNCTION_UNKNOWN_CONTRACT = 'Setup function targets unknown contract';
+export const TX_ERROR_SETUP_ONLY_SELF_WRONG_SENDER = 'Setup only_self function called with incorrect msg_sender';
+export const TX_ERROR_SETUP_NULL_MSG_SENDER = 'Setup function called with null msg sender';
+export const TX_ERROR_SETUP_WRONG_CALLDATA_LENGTH = 'Setup function called with wrong calldata length';
 
 // Nullifiers
 export const TX_ERROR_DUPLICATE_NULLIFIER_IN_TX = 'Duplicate nullifier in tx';
 export const TX_ERROR_EXISTING_NULLIFIER = 'Existing nullifier';
 
 // Metadata
-export const TX_ERROR_INVALID_INCLUDE_BY_TIMESTAMP = 'Invalid expiration timestamp';
+export const TX_ERROR_INVALID_EXPIRATION_TIMESTAMP = 'Invalid expiration timestamp';
 export const TX_ERROR_INCORRECT_L1_CHAIN_ID = 'Incorrect L1 chain id';
 export const TX_ERROR_INCORRECT_ROLLUP_VERSION = 'Incorrect rollup version';
 export const TX_ERROR_INCORRECT_VK_TREE_ROOT = 'Incorrect verification keys tree root';
@@ -31,8 +35,19 @@ export const TX_ERROR_CONTRACT_CLASS_LOGS = 'Mismatched contract class logs';
 export const TX_ERROR_CONTRACT_CLASS_LOG_SORTING = 'Incorrectly sorted contract class logs';
 export const TX_ERROR_INCORRECT_HASH = 'Incorrect tx hash';
 
+// Size
+export const TX_ERROR_SIZE_ABOVE_LIMIT = 'Transaction size above size limit';
+
 // Block header
 export const TX_ERROR_BLOCK_HEADER = 'Block header not found';
 
+// Contract instance
+export const TX_ERROR_INCORRECT_CONTRACT_ADDRESS = 'Incorrect contract instance deployment address';
+export const TX_ERROR_MALFORMED_CONTRACT_INSTANCE_LOG = 'Failed to parse contract instance deployment log';
+
+// Contract class
+export const TX_ERROR_INCORRECT_CONTRACT_CLASS_ID = 'Incorrect contract class id';
+export const TX_ERROR_MALFORMED_CONTRACT_CLASS_LOG = 'Failed to parse contract class registration log';
+
 // General
 export const TX_ERROR_DURING_VALIDATION = 'Unexpected error during validation';

package/src/tx/validator/tx_validator.ts

@@ -20,7 +20,7 @@ export type TxValidationResult =
   | { result: 'invalid'; reason: string[] }
   | { result: 'skipped'; reason: string[] };
 
-export interface TxValidator<T extends AnyTx = AnyTx> {
+export interface TxValidator<T = AnyTx> {
   validateTx(tx: T): Promise<TxValidationResult>;
 }
 

package/src/update-checker/index.ts

@@ -1 +1,2 @@
-export { UpdateChecker, getPackageVersion } from './update-checker.js';
+export * from './package_version.js';
+export * from './version_checker.js';

package/src/update-checker/package_version.ts

@@ -0,0 +1,30 @@
+import { fileURLToPath } from '@aztec/foundation/url';
+
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+
+/** Returns the package version from the release-please manifest or the package.json, or undefined if not found. */
+export function getPackageVersion(): string | undefined {
+  const dir = dirname(fileURLToPath(import.meta.url));
+
+  // Try the release-please manifest first (works in dev/repo checkout).
+  try {
+    const releasePleaseManifestPath = resolve(dir, '../../../../.release-please-manifest.json');
+    return JSON.parse(readFileSync(releasePleaseManifestPath).toString())['.'];
+  } catch {
+    // Not in a repo checkout, fall through.
+  }
+
+  // Fall back to the stdlib package.json version (works in npm-installed packages).
+  try {
+    const packageJsonPath = resolve(dir, '../../package.json');
+    const version = JSON.parse(readFileSync(packageJsonPath).toString()).version;
+    if (version && version !== '0.1.0') {
+      return version;
+    }
+  } catch {
+    // No package.json found either.
+  }
+
+  return undefined;
+}