@aztec/stdlib 0.0.1-commit.aada20e3 → 0.0.1-commit.b2a5d0dd1

package/src/tx/capsule.ts

@@ -19,6 +19,8 @@ export class Capsule {
     public readonly storageSlot: Fr,
     /** Data passed to the contract  */
     public readonly data: Fr[],
+    /** Optional namespace for the capsule contents */
+    public readonly scope?: AztecAddress,
   ) {}
 
   static get schema() {
@@ -30,12 +32,18 @@ export class Capsule {
   }
 
   toBuffer() {
-    return serializeToBuffer(this.contractAddress, this.storageSlot, new Vector(this.data));
+    return this.scope
+      ? serializeToBuffer(this.contractAddress, this.storageSlot, new Vector(this.data), true, this.scope)
+      : serializeToBuffer(this.contractAddress, this.storageSlot, new Vector(this.data), false);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader): Capsule {
     const reader = BufferReader.asReader(buffer);
-    return new Capsule(AztecAddress.fromBuffer(reader), Fr.fromBuffer(reader), reader.readVector(Fr));
+    const contractAddress = AztecAddress.fromBuffer(reader);
+    const storageSlot = Fr.fromBuffer(reader);
+    const data = reader.readVector(Fr);
+    const hasScope = reader.readBoolean();
+    return new Capsule(contractAddress, storageSlot, data, hasScope ? AztecAddress.fromBuffer(reader) : undefined);
   }
 
   toString() {

package/src/tx/fee_provider.ts

@@ -0,0 +1,10 @@
+import type { ManaUsageEstimate } from '../gas/fee_math.js';
+import type { GasFees } from '../gas/gas_fees.js';
+
+/** Provides current and predicted fee information for transaction pricing. */
+export interface FeeProvider {
+  /** Returns the current minimum fees for inclusion in the next block. */
+  getCurrentMinFees(): Promise<GasFees>;
+  /** Returns predicted min fees for each slot in the prediction window. */
+  getPredictedMinFees(manaUsage?: ManaUsageEstimate): Promise<GasFees[]>;
+}

package/src/tx/global_variable_builder.ts

@@ -1,8 +1,8 @@
+import type { SimulationOverridesPlan } from '@aztec/ethereum/contracts';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { SlotNumber } from '@aztec/foundation/schemas';
 
 import type { AztecAddress } from '../aztec-address/index.js';
-import type { GasFees } from '../gas/gas_fees.js';
 import type { UInt32 } from '../types/index.js';
 import type { CheckpointGlobalVariables, GlobalVariables } from './global_variables.js';
 
@@ -10,8 +10,6 @@ import type { CheckpointGlobalVariables, GlobalVariables } from './global_variab
  * Interface for building global variables for Aztec blocks.
  */
 export interface GlobalVariableBuilder {
-  getCurrentMinFees(): Promise<GasFees>;
-
   /**
    * Builds global variables for a given block.
    * @param blockNumber - The block number to build global variables for.
@@ -32,5 +30,6 @@ export interface GlobalVariableBuilder {
     coinbase: EthAddress,
     feeRecipient: AztecAddress,
     slotNumber: SlotNumber,
+    simulationOverridesPlan?: SimulationOverridesPlan,
   ): Promise<CheckpointGlobalVariables>;
 }

package/src/tx/global_variables.ts

@@ -22,10 +22,10 @@ import { schemas } from '../schemas/index.js';
 import type { UInt64 } from '../types/index.js';
 
 /**
- * Global variables that are constant across the entire slot.
- * TODO(palla/mbps): Should timestamp be included here as well?
+ * Global variables that are constant across the entire checkpoint (slot).
+ * Excludes blockNumber since that varies per block within a checkpoint.
  */
-export type CheckpointGlobalVariables = Omit<FieldsOf<GlobalVariables>, 'blockNumber' | 'timestamp'>;
+export type CheckpointGlobalVariables = Omit<FieldsOf<GlobalVariables>, 'blockNumber'>;
 
 /**
  * Global variables of the L2 block.

package/src/tx/index.ts

@@ -24,6 +24,7 @@ export * from './validator/tx_validator.js';
 export * from './validator/empty_validator.js';
 export * from './validator/error_texts.js';
 export * from './capsule.js';
+export * from './fee_provider.js';
 export * from './global_variable_builder.js';
 export * from './hashed_values.js';
 export * from './indexed_tx_effect.js';

package/src/tx/indexed_tx_effect.ts

@@ -1,5 +1,4 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
@@ -27,7 +26,7 @@ export function serializeIndexedTxEffect(effect: IndexedTxEffect): Buffer {
 export function deserializeIndexedTxEffect(buffer: Buffer): IndexedTxEffect {
   const reader = BufferReader.asReader(buffer);
 
-  const l2BlockHash = new BlockHash(reader.readObject(Fr));
+  const l2BlockHash = BlockHash.fromBuffer(reader);
   const l2BlockNumber = BlockNumber(reader.readNumber());
   const txIndexInBlock = reader.readNumber();
   const data = reader.readObject(TxEffect);

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';
@@ -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,6 +3,7 @@ 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';
 
@@ -157,23 +158,31 @@ 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()], {
+  static random(): UtilityExecutionResult {
+    return new UtilityExecutionResult([Fr.random()], [], 0n, {
       nodeRPCCalls: {
         perMethod: { getBlockHeader: { times: [1] } },
         roundTrips: {

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';
@@ -36,7 +38,11 @@ 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 contracts?: ContractOverrides;
+
+  constructor(contracts: ContractOverrides = {}) {
+    this.contracts = Object.keys(contracts).length > 0 ? contracts : undefined;
+  }
 
   static get schema() {
     return z
@@ -84,6 +90,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 +117,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,
@@ -150,7 +161,7 @@ export class TxSimulationResult {
 }
 
 /**
- * Recursively accummulate the return values of a call result and its nested executions,
+ * Recursively accumulate the return values of a call result and its nested executions,
  * so they can be retrieved in order.
  * @param executionResult
  * @returns

package/src/tx/tx.ts

@@ -1,8 +1,9 @@
-import { Buffer32 } from '@aztec/foundation/buffer';
+import { DA_GAS_PER_FIELD, TX_DA_GAS_OVERHEAD } from '@aztec/constants';
+import { type BaseBuffer32, Buffer32 } from '@aztec/foundation/buffer';
 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';
 
@@ -63,7 +64,7 @@ export class Tx extends Gossipable {
   // docs:end:tx_class
 
   // Gossipable method
-  override generateP2PMessageIdentifier(): Promise<Buffer32> {
+  override generateP2PMessageIdentifier(): Promise<BaseBuffer32> {
     return Promise.resolve(new Buffer32(this.getTxHash().toBuffer()));
   }
 
@@ -264,16 +265,24 @@ export class Tx extends Gossipable {
   }
 
   /**
-   * 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;
   }
 
   /**
@@ -309,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_receipt.ts

@@ -1,9 +1,10 @@
-import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
+import { BlockNumber, BlockNumberSchema, EpochNumber, EpochNumberSchema } from '@aztec/foundation/branded-types';
 
 import { z } from 'zod';
 
 import { RevertCode } from '../avm/revert_code.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';
 
@@ -14,7 +15,7 @@ export enum TxStatus {
   PROPOSED = 'proposed',
   CHECKPOINTED = 'checkpointed',
   PROVEN = 'proven',
-  FINALIZED = 'finalized', // TODO(#13569): Implement finalized status properly
+  FINALIZED = 'finalized',
 }
 
 /** Tx status sorted by finalization progress. */
@@ -30,9 +31,16 @@ export const SortedTxStatuses: TxStatus[] = [
 /** 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',
-  BOTH_REVERTED = 'both_reverted',
+  REVERTED = 'reverted',
+  /** @deprecated Use REVERTED instead. */
+  // eslint-disable-next-line @typescript-eslint/no-duplicate-enum-values
+  APP_LOGIC_REVERTED = 'reverted',
+  /** @deprecated Use REVERTED instead. */
+  // eslint-disable-next-line @typescript-eslint/no-duplicate-enum-values
+  TEARDOWN_REVERTED = 'reverted',
+  /** @deprecated Use REVERTED instead. */
+  // eslint-disable-next-line @typescript-eslint/no-duplicate-enum-values
+  BOTH_REVERTED = 'reverted',
 }
 
 /**
@@ -57,6 +65,14 @@ export class TxReceipt {
     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. */
@@ -102,7 +118,9 @@ export class TxReceipt {
         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(fields => TxReceipt.from(fields));
   }
@@ -115,6 +133,8 @@ export class TxReceipt {
     transactionFee?: bigint;
     blockHash?: BlockHash;
     blockNumber?: BlockNumber;
+    epochNumber?: EpochNumber;
+    debugLogs?: DebugLog[];
   }) {
     return new TxReceipt(
       fields.txHash,
@@ -124,20 +144,12 @@ export class TxReceipt {
       fields.transactionFee,
       fields.blockHash,
       fields.blockNumber,
+      fields.epochNumber,
+      fields.debugLogs,
     );
   }
 
   public static executionResultFromRevertCode(revertCode: RevertCode): TxExecutionResult {
-    if (revertCode.equals(RevertCode.OK)) {
-      return TxExecutionResult.SUCCESS;
-    } else if (revertCode.equals(RevertCode.APP_LOGIC_REVERTED)) {
-      return TxExecutionResult.APP_LOGIC_REVERTED;
-    } else if (revertCode.equals(RevertCode.TEARDOWN_REVERTED)) {
-      return TxExecutionResult.TEARDOWN_REVERTED;
-    } else if (revertCode.equals(RevertCode.BOTH_REVERTED)) {
-      return TxExecutionResult.BOTH_REVERTED;
-    } else {
-      throw new Error(`Unknown revert code: ${revertCode.getCode()}`);
-    }
+    return revertCode.isOK() ? TxExecutionResult.SUCCESS : TxExecutionResult.REVERTED;
   }
 }

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';
@@ -37,5 +41,13 @@ 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/types/shared.ts

@@ -34,13 +34,3 @@ export type UInt64 = bigint;
  * A type alias for a 128-bit unsigned integer.
  */
 export type UInt128 = bigint;
-
-/**
- * CircuitType replaces ComposerType for now. When using Plonk, CircuitType is equivalent to the information of the proving system that will be used
- * to construct a proof. In the future Aztec zk stack, more information must be specified (e.g., the curve over which circuits are  constructed;
- * Plonk vs Honk; zk-SNARK or just SNARK; etc).
- */
-export enum CircuitType {
-  STANDARD = 0,
-  ULTRA = 1,
-}

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;
+}

package/src/update-checker/version_checker.ts

@@ -0,0 +1,65 @@
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/promise';
+
+import { EventEmitter } from 'node:events';
+
+export type EventMap = {
+  newVersion: [{ name: string; currentVersion: string; latestVersion: string }];
+};
+
+export type VersionCheck = {
+  name: string;
+  currentVersion: string;
+  getLatestVersion: () => Promise<string | undefined>;
+};
+
+export class VersionChecker extends EventEmitter<EventMap> {
+  private runningPromise: RunningPromise;
+  constructor(
+    private checks: Array<VersionCheck>,
+    intervalCheckMs = 60_000,
+    private logger = createLogger('version_checker'),
+  ) {
+    super();
+    this.runningPromise = new RunningPromise(this.run, logger, intervalCheckMs);
+  }
+
+  public start(): void {
+    if (this.runningPromise.isRunning()) {
+      this.logger.warn('VersionChecker is already running');
+      return;
+    }
+
+    this.runningPromise.start();
+    this.logger.info('Version check started');
+  }
+
+  public trigger(): Promise<void> {
+    return this.runningPromise.trigger();
+  }
+
+  public async stop(): Promise<void> {
+    if (!this.runningPromise.isRunning()) {
+      this.logger.warn('VersionChecker is not running');
+      return;
+    }
+
+    await this.runningPromise.stop();
+    this.logger.info('Version checker stopped');
+  }
+
+  private run = async () => {
+    await Promise.allSettled(this.checks.map(check => this.checkVersion(check)));
+  };
+
+  private async checkVersion({ name, currentVersion, getLatestVersion }: VersionCheck): Promise<void> {
+    try {
+      const latestVersion = await getLatestVersion();
+      if (latestVersion && latestVersion !== currentVersion) {
+        this.emit('newVersion', { name, latestVersion, currentVersion });
+      }
+    } catch (err) {
+      this.logger.warn(`Error checking for new ${name} versions: ${err}`, { err });
+    }
+  }
+}

package/src/validators/errors.ts

@@ -36,6 +36,15 @@ export class FailedToReExecuteTransactionsError extends ValidatorError {
   }
 }
 
+export class ReExInitialStateMismatchError extends ValidatorError {
+  constructor(
+    public readonly expectedArchiveRoot: Fr,
+    public readonly actualArchiveRoot: Fr,
+  ) {
+    super('Re-execution initial state mismatch');
+  }
+}
+
 export class ReExStateMismatchError extends ValidatorError {
   constructor(
     public readonly expectedArchiveRoot: Fr,