@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.0208eb9

package/src/tx/tx_hash.ts

@@ -1,10 +1,11 @@
-import { Fr } from '@aztec/foundation/fields';
-import { BufferReader } from '@aztec/foundation/serialize';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, serializeArrayOfBufferableToVector } from '@aztec/foundation/serialize';
 
 import { schemas } from '../schemas/index.js';
 
 /**
  * A class representing hash of Aztec transaction.
+ * @dev Computed by hashing the public inputs of the private kernel tail circuit (see Tx::getTxHash function).
  */
 export class TxHash {
   constructor(
@@ -12,10 +13,6 @@ export class TxHash {
     public readonly hash: Fr,
   ) {}
 
-  /*
-   * TxHashes are generated from the first nullifier of a transaction, which is a Fr.
-   * @returns A random TxHash.
-   */
   static random() {
     return new TxHash(Fr.random());
   }
@@ -33,6 +30,10 @@ export class TxHash {
     return new TxHash(new Fr(value));
   }
 
+  static fromField(value: Fr) {
+    return new TxHash(value);
+  }
+
   public toBuffer() {
     return this.hash.toBuffer();
   }
@@ -65,3 +66,23 @@ export class TxHash {
     return Fr.SIZE_IN_BYTES;
   }
 }
+
+/**
+ * Helper class to handle Serialization and Deserialization of TxHashes array.
+ **/
+export class TxHashArray extends Array<TxHash> {
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    try {
+      const reader = BufferReader.asReader(buffer);
+      const hashes = reader.readVector(TxHash);
+
+      return new TxHashArray(...hashes);
+    } catch {
+      return new TxHashArray();
+    }
+  }
+
+  public toBuffer(): Buffer {
+    return serializeArrayOfBufferableToVector([...this]);
+  }
+}

package/src/tx/tx_receipt.ts

@@ -1,20 +1,34 @@
-import type { Fr } from '@aztec/foundation/fields';
-import type { FieldsOf } from '@aztec/foundation/types';
+import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
 
 import { z } from 'zod';
 
-import { PublicDataWrite } from '../avm/public_data_write.js';
 import { RevertCode } from '../avm/revert_code.js';
-import { L2BlockHash } from '../block/block_hash.js';
+import { BlockHash } from '../block/block_hash.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', // TODO(#13569): Implement finalized status properly
+}
+
+/** 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',
@@ -31,22 +45,52 @@ 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?: number,
-    /** Information useful for testing/debugging, set when test flag is set to true in `waitOpts`. */
-    public debugInfo?: DebugInfo,
+    public blockNumber?: BlockNumber,
   ) {}
 
+  /** 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> {
@@ -54,68 +98,46 @@ export class TxReceipt {
       .object({
         txHash: TxHash.schema,
         status: z.nativeEnum(TxStatus),
-        error: z.string(),
-        blockHash: L2BlockHash.schema.optional(),
-        blockNumber: z.number().int().nonnegative().optional(),
+        executionResult: z.nativeEnum(TxExecutionResult).optional(),
+        error: z.string().optional(),
+        blockHash: BlockHash.schema.optional(),
+        blockNumber: BlockNumberSchema.optional(),
         transactionFee: schemas.BigInt.optional(),
-        debugInfo: DebugInfoSchema.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;
+  }) {
     return new TxReceipt(
       fields.txHash,
       fields.status,
+      fields.executionResult,
       fields.error,
       fields.transactionFee,
       fields.blockHash,
       fields.blockNumber,
-      fields.debugInfo,
     );
   }
 
-  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}`);
+      throw new Error(`Unknown revert code: ${revertCode.getCode()}`);
     }
   }
 }
-
-/**
- * Information useful for debugging/testing purposes included in the receipt when the debug flag is set to true
- * in `WaitOpts`.
- */
-interface DebugInfo {
-  /**
-   * New note hashes created by the transaction.
-   */
-  noteHashes: Fr[];
-  /**
-   * New nullifiers created by the transaction.
-   */
-  nullifiers: Fr[];
-  /**
-   * New public data writes created by the transaction.
-   */
-  publicDataWrites: PublicDataWrite[];
-  /**
-   * New L2 to L1 messages created by the transaction.
-   */
-  l2ToL1Msgs: Fr[];
-}
-
-const DebugInfoSchema = z.object({
-  noteHashes: z.array(schemas.Fr),
-  nullifiers: z.array(schemas.Fr),
-  publicDataWrites: z.array(PublicDataWrite.schema),
-  l2ToL1Msgs: z.array(schemas.Fr),
-});

package/src/tx/tx_request.ts

@@ -1,6 +1,6 @@
 import { GeneratorIndex, TX_REQUEST_LENGTH } from '@aztec/constants';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
@@ -16,16 +16,19 @@ export class TxRequest {
   constructor(
     /** Sender. */
     public origin: AztecAddress,
-    /** Function data representing the function to call. */
-    public functionData: FunctionData,
     /** Pedersen hash of function arguments. */
     public argsHash: Fr,
     /** Transaction context. */
     public txContext: TxContext,
+    /** Function data representing the function to call. */
+    public functionData: FunctionData,
+    /** A salt to make the hash difficult to predict. The hash is used as the first nullifier if there is no nullifier emitted throughout the tx. */
+    public salt: Fr,
   ) {}
   // docs:end:constructor
+
   static getFields(fields: FieldsOf<TxRequest>) {
-    return [fields.origin, fields.functionData, fields.argsHash, fields.txContext] as const;
+    return [fields.origin, fields.argsHash, fields.txContext, fields.functionData, fields.salt] as const;
   }
 
   static from(fields: FieldsOf<TxRequest>): TxRequest {
@@ -57,9 +60,10 @@ export class TxRequest {
     const reader = BufferReader.asReader(buffer);
     return new TxRequest(
       reader.readObject(AztecAddress),
-      reader.readObject(FunctionData),
       Fr.fromBuffer(reader),
       reader.readObject(TxContext),
+      reader.readObject(FunctionData),
+      Fr.fromBuffer(reader),
     );
   }
 
@@ -68,10 +72,16 @@ export class TxRequest {
   }
 
   static empty() {
-    return new TxRequest(AztecAddress.ZERO, FunctionData.empty(), Fr.zero(), TxContext.empty());
+    return new TxRequest(AztecAddress.ZERO, Fr.zero(), TxContext.empty(), FunctionData.empty(), Fr.zero());
   }
 
   isEmpty() {
-    return this.origin.isZero() && this.functionData.isEmpty() && this.argsHash.isZero() && this.txContext.isEmpty();
+    return (
+      this.origin.isZero() &&
+      this.argsHash.isZero() &&
+      this.txContext.isEmpty() &&
+      this.functionData.isEmpty() &&
+      this.salt.isZero()
+    );
   }
 }

package/src/tx/validator/error_texts.ts

@@ -0,0 +1,41 @@
+// Gas and fees
+export const TX_ERROR_INSUFFICIENT_FEE_PER_GAS = 'Insufficient fee per gas';
+export const TX_ERROR_INSUFFICIENT_FEE_PAYER_BALANCE = 'Insufficient fee payer balance';
+export const TX_ERROR_INSUFFICIENT_GAS_LIMIT = 'Gas limit is below the minimum fixed cost';
+export const TX_ERROR_GAS_LIMIT_TOO_HIGH = 'Gas limit is higher than the amount of gas that the AVM can process';
+
+// Phases
+export const TX_ERROR_SETUP_FUNCTION_NOT_ALLOWED = 'Setup function not on allow list';
+
+// 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_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';
+export const TX_ERROR_INCORRECT_PROTOCOL_CONTRACTS_HASH = 'Incorrect protocol contracts hash';
+
+// Proof
+export const TX_ERROR_INVALID_PROOF = 'Invalid proof';
+
+//Data
+export const TX_ERROR_INCORRECT_CALLDATA = 'Incorrect calldata for public call';
+export const TX_ERROR_CALLDATA_COUNT_MISMATCH = 'Wrong number of calldata for public calls';
+export const TX_ERROR_CALLDATA_COUNT_TOO_LARGE = 'Total calldata too large for enqueued public calls';
+export const TX_ERROR_CONTRACT_CLASS_LOG_COUNT = 'Mismatched number of contract class logs';
+export const TX_ERROR_CONTRACT_CLASS_LOG_LENGTH = 'Incorrect contract class logs length';
+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';
+
+// General
+export const TX_ERROR_DURING_VALIDATION = 'Unexpected error during validation';

package/src/tx/validator/tx_validator.ts

@@ -1,11 +1,16 @@
 import { z } from 'zod';
 
-import type { ZodFor } from '../../schemas/schemas.js';
+import { zodFor } from '../../schemas/schemas.js';
 import type { ProcessedTx } from '../processed_tx.js';
 import type { Tx } from '../tx.js';
+import type { TxHash } from '../tx_hash.js';
 
 export type AnyTx = Tx | ProcessedTx;
 
+export function getTxHash(tx: AnyTx): TxHash {
+  return 'txHash' in tx ? tx.txHash : tx.hash;
+}
+
 export function hasPublicCalls(tx: AnyTx): boolean {
   return tx.data.numberOfPublicCallRequests() > 0;
 }
@@ -19,8 +24,10 @@ export interface TxValidator<T extends AnyTx = AnyTx> {
   validateTx(tx: T): Promise<TxValidationResult>;
 }
 
-export const TxValidationResultSchema = z.discriminatedUnion('result', [
-  z.object({ result: z.literal('valid'), reason: z.array(z.string()).optional() }),
-  z.object({ result: z.literal('invalid'), reason: z.array(z.string()) }),
-  z.object({ result: z.literal('skipped'), reason: z.array(z.string()) }),
-]) satisfies ZodFor<TxValidationResult>;
+export const TxValidationResultSchema = zodFor<TxValidationResult>()(
+  z.discriminatedUnion('result', [
+    z.object({ result: z.literal('valid') }),
+    z.object({ result: z.literal('invalid'), reason: z.array(z.string()) }),
+    z.object({ result: z.literal('skipped'), reason: z.array(z.string()) }),
+  ]),
+);

package/src/types/shared.ts

@@ -25,6 +25,16 @@ export class Vector<T extends Bufferable> {
  */
 export type UInt32 = number;
 
+/**
+ * A type alias for a 64-bit unsigned integer.
+ */
+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;
@@ -34,12 +44,3 @@ export enum CircuitType {
   STANDARD = 0,
   ULTRA = 1,
 }
-
-/**
- * Rollup types.
- */
-export enum RollupTypes {
-  Base = 0,
-  Merge = 1,
-  Root = 2,
-}

package/src/update-checker/index.ts

@@ -0,0 +1 @@
+export { UpdateChecker, getPackageVersion } from './update-checker.js';

package/src/update-checker/update-checker.ts

@@ -0,0 +1,166 @@
+import { RegistryContract } from '@aztec/ethereum/contracts';
+import type { ViemClient } from '@aztec/ethereum/types';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { fileURLToPath } from '@aztec/foundation/url';
+
+import { EventEmitter } from 'events';
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { isDeepStrictEqual } from 'util';
+import { z } from 'zod';
+
+const updateConfigSchema = z.object({
+  version: z.string().optional(),
+  publicTelemetry: z.any().optional(),
+  config: z.any().optional(),
+});
+
+export type EventMap = {
+  newRollupVersion: [{ currentVersion: bigint; latestVersion: bigint }];
+  newNodeVersion: [{ currentVersion: string; latestVersion: string }];
+  updateNodeConfig: [object];
+  updatePublicTelemetryConfig: [object];
+};
+
+type Config = {
+  baseURL: URL;
+  nodeVersion?: string;
+  checkIntervalMs?: number;
+  registryContractAddress: EthAddress;
+  publicClient: ViemClient;
+  fetch?: typeof fetch;
+};
+
+export class UpdateChecker extends EventEmitter<EventMap> {
+  private runningPromise: RunningPromise;
+  private lastPatchedConfig: object = {};
+  private lastPatchedPublicTelemetryConfig: object = {};
+
+  constructor(
+    private updatesUrl: URL,
+    private nodeVersion: string | undefined,
+    private rollupVersion: bigint,
+    private fetch: typeof globalThis.fetch,
+    private getLatestRollupVersion: () => Promise<bigint>,
+    private checkIntervalMs = 10 * 60_000, // every 10 mins
+    private log = createLogger('foundation:update-check'),
+  ) {
+    super();
+    this.runningPromise = new RunningPromise(this.runChecks, this.log, this.checkIntervalMs);
+  }
+
+  public static async new(config: Config): Promise<UpdateChecker> {
+    const registryContract = new RegistryContract(config.publicClient, config.registryContractAddress);
+    const getLatestRollupVersion = () => registryContract.getRollupVersions().then(versions => versions.at(-1)!);
+
+    return new UpdateChecker(
+      config.baseURL,
+      config.nodeVersion ?? getPackageVersion(),
+      await getLatestRollupVersion(),
+      config.fetch ?? fetch,
+      getLatestRollupVersion,
+      config.checkIntervalMs,
+    );
+  }
+
+  public start(): void {
+    if (this.runningPromise.isRunning()) {
+      this.log.debug(`Can't start update checker again`);
+      return;
+    }
+
+    this.log.info('Starting update checker', {
+      nodeVersion: this.nodeVersion,
+      rollupVersion: this.rollupVersion,
+    });
+    this.runningPromise.start();
+  }
+
+  public stop(): Promise<void> {
+    if (!this.runningPromise.isRunning()) {
+      this.log.debug(`Can't stop update checker because it is not running`);
+      return Promise.resolve();
+    }
+    return this.runningPromise.stop();
+  }
+
+  public trigger(): Promise<void> {
+    return this.runningPromise.trigger();
+  }
+
+  private runChecks = async (): Promise<void> => {
+    await Promise.all([this.checkRollupVersion(), this.checkConfig()]);
+  };
+
+  private async checkRollupVersion(): Promise<void> {
+    try {
+      const canonicalRollupVersion = await this.getLatestRollupVersion();
+      if (canonicalRollupVersion !== this.rollupVersion) {
+        this.log.debug('New canonical rollup version', {
+          currentVersion: this.rollupVersion,
+          latestVersion: canonicalRollupVersion,
+        });
+        this.emit('newRollupVersion', { currentVersion: this.rollupVersion, latestVersion: canonicalRollupVersion });
+      }
+    } catch (err) {
+      this.log.warn(`Failed to check if there is a new rollup`, err);
+    }
+  }
+
+  private async checkConfig(): Promise<void> {
+    try {
+      const response = await this.fetch(this.updatesUrl);
+      const body = await response.json();
+      if (!response.ok) {
+        this.log.warn(`Unexpected HTTP response checking for updates`, {
+          status: response.status,
+          body: await response.text(),
+          url: this.updatesUrl,
+        });
+      }
+
+      const { version, config, publicTelemetry } = updateConfigSchema.parse(body);
+
+      if (this.nodeVersion && version && version !== this.nodeVersion) {
+        this.log.debug('New node version', { currentVersion: this.nodeVersion, latestVersion: version });
+        this.emit('newNodeVersion', { currentVersion: this.nodeVersion, latestVersion: version });
+      }
+
+      if (config && Object.keys(config).length > 0 && !isDeepStrictEqual(config, this.lastPatchedConfig)) {
+        this.log.debug('New node config', { config });
+        this.lastPatchedConfig = config;
+        this.emit('updateNodeConfig', config);
+      }
+
+      if (
+        publicTelemetry &&
+        Object.keys(publicTelemetry).length > 0 &&
+        !isDeepStrictEqual(publicTelemetry, this.lastPatchedPublicTelemetryConfig)
+      ) {
+        this.log.debug('New metrics config', { config });
+        this.lastPatchedPublicTelemetryConfig = publicTelemetry;
+        this.emit('updatePublicTelemetryConfig', publicTelemetry);
+      }
+    } catch (err) {
+      this.log.warn(`Failed to check if there is an update`, err);
+    }
+  }
+}
+
+/**
+ * Returns package version.
+ */
+export function getPackageVersion(): string | undefined {
+  try {
+    const releasePleaseManifestPath = resolve(
+      dirname(fileURLToPath(import.meta.url)),
+      '../../../../.release-please-manifest.json',
+    );
+    const version = JSON.parse(readFileSync(releasePleaseManifestPath).toString())['.'];
+    return version;
+  } catch {
+    return undefined;
+  }
+}

package/src/validators/errors.ts

@@ -0,0 +1,58 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { TxHash } from '@aztec/stdlib/tx';
+
+export class ValidatorError extends Error {
+  constructor(message: string) {
+    super(`Validator Error: ${message}`);
+  }
+}
+
+export class InvalidValidatorPrivateKeyError extends ValidatorError {
+  constructor() {
+    super('Invalid validator private key provided');
+  }
+}
+
+export class AttestationTimeoutError extends ValidatorError {
+  constructor(
+    public readonly collectedCount: number,
+    public readonly requiredCount: number,
+    public readonly slot: SlotNumber,
+  ) {
+    super(`Timeout collecting attestations for slot ${slot}: ${collectedCount}/${requiredCount}`);
+  }
+}
+
+export class TransactionsNotAvailableError extends ValidatorError {
+  constructor(txHashes: TxHash[]) {
+    super(`Transactions not available: ${txHashes.join(', ')}`);
+  }
+}
+
+export class FailedToReExecuteTransactionsError extends ValidatorError {
+  constructor(txHashes: TxHash[]) {
+    super(`Failed to re-execute transactions: ${txHashes.join(', ')}`);
+  }
+}
+
+export class ReExStateMismatchError extends ValidatorError {
+  constructor(
+    public readonly expectedArchiveRoot: Fr,
+    public readonly actualArchiveRoot: Fr,
+  ) {
+    super('Re-execution state mismatch');
+  }
+}
+
+export class ReExFailedTxsError extends ValidatorError {
+  constructor(numFailedTxs: number) {
+    super(`Re-execution failed to process ${numFailedTxs} txs`);
+  }
+}
+
+export class ReExTimeoutError extends ValidatorError {
+  constructor() {
+    super('Re-execution timed out or failed to process all txs in the proposal');
+  }
+}

package/src/validators/index.ts

@@ -0,0 +1,3 @@
+export * from './errors.js';
+export * from './schemas.js';
+export type * from './types.js';