@aztec/stdlib 0.0.1-commit.5de5ca79e → 0.0.1-commit.6201a7b05

package/src/timetable/index.ts

@@ -25,6 +25,234 @@ export const DEFAULT_L1_PUBLISHING_TIME = 12;
 /** Minimum execution time for building a block in seconds */
 export const MIN_EXECUTION_TIME = 2;
 
+export type CheckpointTimingConfig = {
+  aztecSlotDuration: number;
+  ethereumSlotDuration?: number;
+  blockDuration?: number;
+  checkpointAssembleTime?: number;
+  checkpointInitializationTime?: number;
+  l1PublishingTime?: number;
+  minExecutionTime?: number;
+  p2pPropagationTime?: number;
+  pipelining?: boolean;
+};
+
+export interface CheckpointTiming {
+  readonly aztecSlotDuration: number;
+  readonly blockDuration: number | undefined;
+  readonly checkpointAssembleTime: number;
+  readonly checkpointInitializationTime: number;
+  readonly l1PublishingTime: number;
+  readonly minExecutionTime: number;
+  readonly p2pPropagationTime: number;
+  readonly checkpointFinalizationTime: number;
+  readonly pipeliningAttestationGracePeriod: number;
+  readonly timeReservedAtEnd: number;
+  readonly minimumBuildSlotWork: number;
+  readonly initializeDeadline: number;
+  readonly checkpointAssemblyDeadline: number;
+  readonly checkpointAttestationStartDeadline: number;
+  readonly checkpointAttestationDeadline: number;
+  readonly checkpointPublishingDeadline: number;
+
+  calculateMaxBlocksPerSlot(): number;
+}
+
+export interface PipelinedCheckpointTiming extends CheckpointTiming {
+  readonly proposalWindowIntoTargetSlot: number;
+  readonly attestationWindowIntoTargetSlot: number;
+}
+
+/**
+ * Shared base for checkpoint timing implementations.
+ *
+ * This class owns the common inputs and formulas used by both pipelined and
+ * non-pipelined scheduling. Variant-specific deadline math is delegated to the
+ * concrete subclasses below.
+ */
+abstract class BaseCheckpointTiming implements CheckpointTiming {
+  public readonly aztecSlotDuration: number;
+  public readonly blockDuration: number | undefined;
+  public readonly checkpointAssembleTime: number;
+  public readonly checkpointInitializationTime: number;
+  public readonly l1PublishingTime: number;
+  public readonly minExecutionTime: number;
+  public readonly p2pPropagationTime: number;
+
+  constructor(opts: CheckpointTimingConfig) {
+    this.aztecSlotDuration = opts.aztecSlotDuration;
+    this.blockDuration = opts.blockDuration;
+
+    this.checkpointAssembleTime = opts.checkpointAssembleTime ?? CHECKPOINT_ASSEMBLE_TIME;
+    this.checkpointInitializationTime = opts.checkpointInitializationTime ?? CHECKPOINT_INITIALIZATION_TIME;
+    this.l1PublishingTime = opts.l1PublishingTime ?? DEFAULT_L1_PUBLISHING_TIME;
+    this.minExecutionTime = opts.minExecutionTime ?? MIN_EXECUTION_TIME;
+    this.p2pPropagationTime = opts.p2pPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME;
+  }
+
+  public get checkpointFinalizationTime(): number {
+    // Allow enough time to
+    // - build the checkpoint
+    // - Round-trip over p2p
+    // - Publish to L1
+    return this.checkpointAssembleTime + this.p2pPropagationTime * 2 + this.l1PublishingTime;
+  }
+
+  public get pipeliningAttestationGracePeriod(): number {
+    // Allow enough time to
+    // - build the block
+    // - pass it back over p2p
+    return (this.blockDuration ?? 0) + this.p2pPropagationTime;
+  }
+
+  public abstract get timeReservedAtEnd(): number;
+  public abstract get minimumBuildSlotWork(): number;
+
+  public get initializeDeadline(): number {
+    return this.aztecSlotDuration - this.minimumBuildSlotWork;
+  }
+
+  public abstract get checkpointAssemblyDeadline(): number;
+
+  public get checkpointAttestationStartDeadline(): number {
+    return this.checkpointAssemblyDeadline;
+  }
+
+  public abstract get checkpointAttestationDeadline(): number;
+  public abstract get checkpointPublishingDeadline(): number;
+
+  public calculateMaxBlocksPerSlot(): number {
+    if (!this.blockDuration) {
+      return 1;
+    }
+
+    const timeAvailableForBlocks = this.aztecSlotDuration - this.checkpointInitializationTime - this.timeReservedAtEnd;
+    return Math.floor(timeAvailableForBlocks / this.blockDuration);
+  }
+}
+
+/**
+ * Checkpoint timing model for the non-pipelined sequencer flow.
+ *
+ * In this mode, checkpoint assembly, attestation collection, and L1 publishing
+ * must all complete within the current Aztec slot.
+ */
+class StandardCheckpointTimingModel extends BaseCheckpointTiming {
+  public get timeReservedAtEnd(): number {
+    return (this.blockDuration ?? 0) + this.checkpointFinalizationTime;
+  }
+
+  public get minimumBuildSlotWork(): number {
+    return this.checkpointInitializationTime + this.minExecutionTime * 2 + this.checkpointFinalizationTime;
+  }
+
+  public get checkpointAssemblyDeadline(): number {
+    return this.aztecSlotDuration - this.l1PublishingTime - 2 * this.p2pPropagationTime;
+  }
+
+  public get checkpointAttestationDeadline(): number {
+    return this.aztecSlotDuration - this.l1PublishingTime;
+  }
+
+  public get checkpointPublishingDeadline(): number {
+    return this.aztecSlotDuration - this.l1PublishingTime;
+  }
+}
+
+/**
+ * Checkpoint timing model for proposer pipelining.
+ *
+ * In this mode, the build work starts at the wall-clock slot boundary and the
+ * checkpoint proposal is broadcast early enough that attestations complete by
+ * the end of the build slot. L1 submission can then be sent at the boundary of
+ * the target slot. The extra target-slot window getters are intended for
+ * consumers such as P2P validators that need to validate pipelined messages
+ * against wallclock time.
+ */
+class PipelinedCheckpointTimingModel extends BaseCheckpointTiming implements PipelinedCheckpointTiming {
+  public get proposalWindowIntoTargetSlot(): number {
+    // Proposals no longer spill into the target slot: they are broadcast early
+    // enough in the build slot that attestations complete before the boundary.
+    // Any residual tolerance into the target slot is covered by clock disparity.
+    return 0;
+  }
+
+  public get attestationWindowIntoTargetSlot(): number {
+    // Straggler grace: attestations aim to complete by build-slot end. Allow a
+    // small window into the target slot for late arrivals (round-trip p2p).
+    return 2 * this.p2pPropagationTime;
+  }
+
+  public override get pipeliningAttestationGracePeriod(): number {
+    // Under the early-pipelining regime attestations complete inside the build
+    // slot itself, so there is no extra grace into the target slot.
+    return 0;
+  }
+
+  public get timeReservedAtEnd(): number {
+    // Reserve enough time at the end of the build slot for:
+    // - assembling and broadcasting the checkpoint proposal
+    // - round-trip p2p propagation (proposal out, attestations back)
+    // - validators re-executing the last block
+    return this.checkpointAssembleTime + 2 * this.p2pPropagationTime + (this.blockDuration ?? 0);
+  }
+
+  public get minimumBuildSlotWork(): number {
+    return this.checkpointInitializationTime + this.minExecutionTime * 2;
+  }
+
+  public get checkpointAssemblyDeadline(): number {
+    // Allow enough time to build all blocks and receive attestations. With
+    // `pipeliningAttestationGracePeriod = 0` this equals `aztecSlotDuration`.
+    return this.aztecSlotDuration + this.pipeliningAttestationGracePeriod;
+  }
+
+  public get checkpointAttestationDeadline(): number {
+    // Allowed to be into the next wallclock slot minus the allocated l1 publishing time
+    return this.aztecSlotDuration * 2 - this.l1PublishingTime;
+  }
+
+  public get checkpointPublishingDeadline(): number {
+    // Allowed to be into the next wallclock slot minus the allocated l1 Publishing time
+    return this.aztecSlotDuration * 2 - this.l1PublishingTime;
+  }
+}
+
+/**
+ * Creates a checkpoint timing model for the requested scheduling mode.
+ *
+ * Most callers should use this factory and depend only on the shared
+ * `CheckpointTiming` interface. The returned implementation is selected from
+ * `opts.pipelining`.
+ */
+export function createCheckpointTimingModel(opts: CheckpointTimingConfig): CheckpointTiming {
+  validateCheckpointTimingConfig(opts);
+  const normalizedOpts = normalizeCheckpointTimingConfig(opts);
+
+  const timing = normalizedOpts.pipelining
+    ? new PipelinedCheckpointTimingModel(normalizedOpts)
+    : new StandardCheckpointTimingModel(normalizedOpts);
+  validateCheckpointTimingModel(timing);
+  return timing;
+}
+
+/**
+ * Creates a pipelined checkpoint timing model with target-slot window accessors.
+ *
+ * Use this when the caller specifically needs the pipelined-only timing surface,
+ * such as proposal or attestation acceptance windows into the target slot.
+ */
+export function createPipelinedCheckpointTimingModel(
+  opts: Omit<CheckpointTimingConfig, 'pipelining'>,
+): PipelinedCheckpointTiming {
+  validateCheckpointTimingConfig(opts);
+  const normalizedOpts = normalizeCheckpointTimingConfig(opts);
+
+  const timing = new PipelinedCheckpointTimingModel(normalizedOpts);
+  validateCheckpointTimingModel(timing);
+  return timing;
+}
+
 /**
  * Calculates the maximum number of blocks that can be built in a slot.
  * Used by both the sequencer timetable and p2p gossipsub scoring.
@@ -42,25 +270,92 @@ export function calculateMaxBlocksPerSlot(
     checkpointAssembleTime?: number;
     p2pPropagationTime?: number;
     l1PublishingTime?: number;
+    pipelining?: boolean;
   } = {},
 ): number {
-  if (!blockDurationSec) {
-    return 1; // Single block per slot
+  return createCheckpointTimingModel({
+    aztecSlotDuration: aztecSlotDurationSec,
+    blockDuration: blockDurationSec,
+    checkpointAssembleTime: opts.checkpointAssembleTime,
+    checkpointInitializationTime: opts.checkpointInitializationTime,
+    l1PublishingTime: opts.l1PublishingTime,
+    p2pPropagationTime: opts.p2pPropagationTime,
+    pipelining: opts.pipelining,
+  }).calculateMaxBlocksPerSlot();
+}
+
+function assertNonNegative(name: string, value: number): void {
+  if (value < 0) {
+    throw new Error(`${name} must be non-negative (got ${value})`);
+  }
+}
+
+function validateCheckpointTimingConfig(opts: CheckpointTimingConfig): void {
+  if (opts.aztecSlotDuration <= 0) {
+    throw new Error(`aztecSlotDuration must be positive (got ${opts.aztecSlotDuration})`);
+  }
+
+  if (opts.ethereumSlotDuration !== undefined && opts.ethereumSlotDuration <= 0) {
+    throw new Error(`ethereumSlotDuration must be positive when provided (got ${opts.ethereumSlotDuration})`);
+  }
+
+  if (opts.blockDuration !== undefined && opts.blockDuration <= 0) {
+    throw new Error(`blockDuration must be positive when provided (got ${opts.blockDuration})`);
+  }
+
+  if (opts.minExecutionTime !== undefined && opts.minExecutionTime <= 0) {
+    throw new Error(`minExecutionTime must be positive when provided (got ${opts.minExecutionTime})`);
   }
 
-  const initOffset = opts.checkpointInitializationTime ?? CHECKPOINT_INITIALIZATION_TIME;
-  const assembleTime = opts.checkpointAssembleTime ?? CHECKPOINT_ASSEMBLE_TIME;
-  const p2pTime = opts.p2pPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME;
-  const l1Time = opts.l1PublishingTime ?? DEFAULT_L1_PUBLISHING_TIME;
+  if (opts.checkpointAssembleTime !== undefined) {
+    assertNonNegative('checkpointAssembleTime', opts.checkpointAssembleTime);
+  }
+  if (opts.checkpointInitializationTime !== undefined) {
+    assertNonNegative('checkpointInitializationTime', opts.checkpointInitializationTime);
+  }
+  if (opts.l1PublishingTime !== undefined) {
+    assertNonNegative('l1PublishingTime', opts.l1PublishingTime);
+  }
+  if (opts.p2pPropagationTime !== undefined) {
+    assertNonNegative('p2pPropagationTime', opts.p2pPropagationTime);
+  }
+}
+
+function normalizeCheckpointTimingConfig(opts: CheckpointTimingConfig): CheckpointTimingConfig {
+  let checkpointAssembleTime = opts.checkpointAssembleTime ?? CHECKPOINT_ASSEMBLE_TIME;
+  let checkpointInitializationTime = opts.checkpointInitializationTime ?? CHECKPOINT_INITIALIZATION_TIME;
+  let minExecutionTime = opts.minExecutionTime ?? MIN_EXECUTION_TIME;
+  let p2pPropagationTime = opts.p2pPropagationTime ?? DEFAULT_P2P_PROPAGATION_TIME;
 
-  // Calculate checkpoint finalization time (assembly + round-trip propagation + L1 publishing)
-  const checkpointFinalizationTime = assembleTime + p2pTime * 2 + l1Time;
+  if (opts.ethereumSlotDuration !== undefined && opts.ethereumSlotDuration < 8) {
+    p2pPropagationTime = 0;
+    checkpointAssembleTime = 0.5;
+    checkpointInitializationTime = 0.5;
+    minExecutionTime = 1;
+  }
+
+  if (opts.blockDuration !== undefined && minExecutionTime > opts.blockDuration) {
+    minExecutionTime = opts.blockDuration;
+  }
 
-  // Time reserved at end for last sub-slot (validator re-execution) + finalization
-  const timeReservedAtEnd = blockDurationSec + checkpointFinalizationTime;
+  return {
+    ...opts,
+    checkpointAssembleTime,
+    checkpointInitializationTime,
+    minExecutionTime,
+    p2pPropagationTime,
+  };
+}
 
-  // Time available for building blocks
-  const timeAvailableForBlocks = aztecSlotDurationSec - initOffset - timeReservedAtEnd;
+function validateCheckpointTimingModel(model: CheckpointTiming): void {
+  if (model.blockDuration === undefined) {
+    return;
+  }
 
-  return Math.max(1, Math.floor(timeAvailableForBlocks / blockDurationSec));
+  const timeAvailableForBlocks = model.aztecSlotDuration - model.checkpointInitializationTime - model.timeReservedAtEnd;
+  if (timeAvailableForBlocks < model.blockDuration) {
+    throw new Error(
+      `Invalid timing configuration: only ${timeAvailableForBlocks}s available for block building, which is less than one blockDuration (${model.blockDuration}s).`,
+    );
+  }
 }

package/src/trees/nullifier_leaf.ts

@@ -86,6 +86,10 @@ export class NullifierLeafPreimage implements IndexedTreeLeafPreimage {
     ];
   }
 
+  isEmpty(): boolean {
+    return this.leaf.isEmpty() && this.nextKey.isZero() && this.nextIndex === 0n;
+  }
+
   toFields(): Fr[] {
     return this.toHashInputs().map(buf => Fr.fromBuffer(buf));
   }

package/src/tx/block_header.ts

@@ -172,8 +172,8 @@ export class BlockHeader {
   }
 
   /** Manually set the hash for this block header if already computed */
-  setHash(hashed: Fr) {
-    this._cachedHash = Promise.resolve(new BlockHash(hashed));
+  setHash(hashed: BlockHash) {
+    this._cachedHash = Promise.resolve(hashed);
   }
 
   /** Recomputes the cached hash. Used for testing when header fields are mutated via unfreeze. */

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/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/profiling.ts

@@ -133,12 +133,12 @@ export class TxProfileResult {
       ],
       {
         nodeRPCCalls: {
-          perMethod: { getBlockHeader: { times: [1] } },
+          perMethod: { getBlock: { times: [1] } },
           roundTrips: {
             roundTrips: 1,
             totalBlockingTime: 1,
             roundTripDurations: [1],
-            roundTripMethods: [['getBlockHeader']],
+            roundTripMethods: [['getBlock']],
           },
         },
         timings: {
@@ -184,12 +184,12 @@ export class UtilityExecutionResult {
   static random(): UtilityExecutionResult {
     return new UtilityExecutionResult([Fr.random()], [], 0n, {
       nodeRPCCalls: {
-        perMethod: { getBlockHeader: { times: [1] } },
+        perMethod: { getBlock: { times: [1] } },
         roundTrips: {
           roundTrips: 1,
           totalBlockingTime: 1,
           roundTripDurations: [1],
-          roundTripMethods: [['getBlockHeader']],
+          roundTripMethods: [['getBlock']],
         },
       },
       timings: {

package/src/tx/simulated_tx.ts

@@ -38,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
@@ -157,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,5 +1,5 @@
 import { DA_GAS_PER_FIELD, TX_DA_GAS_OVERHEAD } from '@aztec/constants';
-import { Buffer32 } from '@aztec/foundation/buffer';
+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';
@@ -64,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()));
   }
 

package/src/tx/tx_receipt.ts

@@ -31,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',
 }
 
 /**
@@ -143,16 +150,6 @@ export class TxReceipt {
   }
 
   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/validator/error_texts.ts

@@ -41,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/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,
-}