@aztec/stdlib 3.0.3-rc.3 → 3.9.9-nightly.20260312

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 { 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', // 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',
@@ -30,20 +46,58 @@ 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,
+    /**
+     * 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 +105,47 @@ 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(),
         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;
+    debugLogs?: DebugLog[];
+  }) {
     return new TxReceipt(
       fields.txHash,
       fields.status,
+      fields.executionResult,
       fields.error,
       fields.transactionFee,
       fields.blockHash,
       fields.blockNumber,
+      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,6 +35,9 @@ 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';
 

package/src/tx/validator/tx_validator.ts

@@ -1,6 +1,6 @@
 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';
@@ -20,12 +20,14 @@ 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>;
 }
 
-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/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,

package/src/validators/schemas.ts

@@ -1,4 +1,4 @@
-import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import { schemas, zodFor } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
@@ -11,20 +11,25 @@ import type {
   ValidatorsStats,
 } from './types.js';
 
-export const ValidatorStatusInSlotSchema = z.enum([
-  'block-mined',
-  'block-proposed',
-  'block-missed',
-  'attestation-sent',
-  'attestation-missed',
-]) satisfies ZodFor<ValidatorStatusInSlot>;
+export const ValidatorStatusInSlotSchema = zodFor<ValidatorStatusInSlot>()(
+  z.enum([
+    'checkpoint-mined',
+    'checkpoint-proposed',
+    'checkpoint-missed',
+    'blocks-missed',
+    'attestation-sent',
+    'attestation-missed',
+  ]),
+);
 
-export const ValidatorStatusHistorySchema = z.array(
-  z.object({
-    slot: schemas.SlotNumber,
-    status: ValidatorStatusInSlotSchema,
-  }),
-) satisfies ZodFor<ValidatorStatusHistory>;
+export const ValidatorStatusHistorySchema = zodFor<ValidatorStatusHistory>()(
+  z.array(
+    z.object({
+      slot: schemas.SlotNumber,
+      status: ValidatorStatusInSlotSchema,
+    }),
+  ),
+);
 
 export const ValidatorStatusHistorySchemaArray = z.array(ValidatorStatusHistorySchema);
 
@@ -36,40 +41,48 @@ const ValidatorTimeStatSchema = z.object({
   date: z.string(),
 });
 
-const ValidatorMissedStatsSchema = z.object({
-  currentStreak: schemas.Integer,
-  rate: z.number().optional(),
-  count: schemas.Integer,
-  total: schemas.Integer,
-}) satisfies ZodFor<ValidatorMissedStats>;
+const ValidatorMissedStatsSchema = zodFor<ValidatorMissedStats>()(
+  z.object({
+    currentStreak: schemas.Integer,
+    rate: z.number().optional(),
+    count: schemas.Integer,
+    total: schemas.Integer,
+  }),
+);
 
-export const ValidatorStatsSchema = z.object({
-  address: schemas.EthAddress,
-  lastProposal: ValidatorTimeStatSchema.optional(),
-  lastAttestation: ValidatorTimeStatSchema.optional(),
-  totalSlots: schemas.Integer,
-  missedProposals: ValidatorMissedStatsSchema,
-  missedAttestations: ValidatorMissedStatsSchema,
-  history: ValidatorStatusHistorySchema,
-}) satisfies ZodFor<ValidatorStats>;
+export const ValidatorStatsSchema = zodFor<ValidatorStats>()(
+  z.object({
+    address: schemas.EthAddress,
+    lastProposal: ValidatorTimeStatSchema.optional(),
+    lastAttestation: ValidatorTimeStatSchema.optional(),
+    totalSlots: schemas.Integer,
+    missedProposals: ValidatorMissedStatsSchema,
+    missedAttestations: ValidatorMissedStatsSchema,
+    history: ValidatorStatusHistorySchema,
+  }),
+);
 
-export const ValidatorsStatsSchema = z.object({
-  stats: z.record(ValidatorStatsSchema),
-  lastProcessedSlot: schemas.SlotNumber.optional(),
-  initialSlot: schemas.SlotNumber.optional(),
-  slotWindow: schemas.Integer,
-}) satisfies ZodFor<ValidatorsStats>;
+export const ValidatorsStatsSchema = zodFor<ValidatorsStats>()(
+  z.object({
+    stats: z.record(ValidatorStatsSchema),
+    lastProcessedSlot: schemas.SlotNumber.optional(),
+    initialSlot: schemas.SlotNumber.optional(),
+    slotWindow: schemas.Integer,
+  }),
+);
 
-export const SingleValidatorStatsSchema = z.object({
-  validator: ValidatorStatsSchema,
-  allTimeProvenPerformance: z.array(
-    z.object({
-      missed: schemas.Integer,
-      total: schemas.Integer,
-      epoch: schemas.EpochNumber,
-    }),
-  ),
-  lastProcessedSlot: schemas.SlotNumber.optional(),
-  initialSlot: schemas.SlotNumber.optional(),
-  slotWindow: schemas.Integer,
-}) satisfies ZodFor<SingleValidatorStats>;
+export const SingleValidatorStatsSchema = zodFor<SingleValidatorStats>()(
+  z.object({
+    validator: ValidatorStatsSchema,
+    allTimeProvenPerformance: z.array(
+      z.object({
+        missed: schemas.Integer,
+        total: schemas.Integer,
+        epoch: schemas.EpochNumber,
+      }),
+    ),
+    lastProcessedSlot: schemas.SlotNumber.optional(),
+    initialSlot: schemas.SlotNumber.optional(),
+    slotWindow: schemas.Integer,
+  }),
+);

package/src/validators/types.ts

@@ -1,12 +1,13 @@
 import type { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 
-export type ValidatorStatusType = 'block' | 'attestation';
+export type ValidatorStatusType = 'proposer' | 'attestation';
 
 export type ValidatorStatusInSlot =
-  | 'block-mined'
-  | 'block-proposed'
-  | 'block-missed'
+  | 'checkpoint-mined'
+  | 'checkpoint-proposed'
+  | 'checkpoint-missed'
+  | 'blocks-missed'
   | 'attestation-sent'
   | 'attestation-missed';
 

package/src/zkpassport/index.ts

@@ -5,14 +5,13 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { withoutHexPrefix } from '@aztec/foundation/string';
 
 export type ViemZkPassportProofParams = {
+  version: `0x${string}`;
   proofVerificationData: {
     vkeyHash: `0x${string}`;
     proof: `0x${string}`;
     publicInputs: `0x${string}`[];
   };
-  commitments: {
-    committedInputs: `0x${string}`;
-  };
+  committedInputs: `0x${string}`;
   serviceConfig: {
     validityPeriodInSeconds: bigint;
     domain: string;
@@ -91,7 +90,7 @@ export class ZkPassportProofParams {
       Buffer32.fromString(params.proofVerificationData.vkeyHash),
       Buffer.from(withoutHexPrefix(params.proofVerificationData.proof), 'hex'),
       params.proofVerificationData.publicInputs.map(input => Fr.fromString(input)),
-      Buffer.from(withoutHexPrefix(params.commitments.committedInputs), 'hex'),
+      Buffer.from(withoutHexPrefix(params.committedInputs), 'hex'),
       params.serviceConfig.validityPeriodInSeconds,
       params.serviceConfig.domain,
       params.serviceConfig.scope,
@@ -99,20 +98,20 @@ export class ZkPassportProofParams {
   }
 
   toViem(): ViemZkPassportProofParams {
+    // Version is set to bytes32(0) as per zkpassport library convention
     return {
-      serviceConfig: {
-        devMode: this.devMode,
-        validityPeriodInSeconds: this.validityPeriodInSeconds,
-        domain: this.domain,
-        scope: this.scope,
-      },
+      version: '0x0000000000000000000000000000000000000000000000000000000000000000',
       proofVerificationData: {
         vkeyHash: this.vkeyHash.toString(),
         proof: `0x${this.proof.toString('hex')}`,
         publicInputs: this.publicInputs.map(input => input.toString()),
       },
-      commitments: {
-        committedInputs: `0x${this.committedInputs.toString('hex')}`,
+      committedInputs: `0x${this.committedInputs.toString('hex')}`,
+      serviceConfig: {
+        devMode: this.devMode,
+        validityPeriodInSeconds: this.validityPeriodInSeconds,
+        domain: this.domain,
+        scope: this.scope,
       },
     };
   }

package/dest/block/l2_block_code_to_purge.d.ts

@@ -1,12 +0,0 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
-import type { FieldsOf } from '@aztec/foundation/types';
-import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
-import { L2BlockHeader } from './l2_block_header.js';
-export declare function makeL2BlockHeader(seed?: number, blockNumber?: number, slotNumber?: number, overrides?: Partial<FieldsOf<L2BlockHeader>>, inHash?: Fr): L2BlockHeader;
-/**
- * Makes arbitrary append only tree snapshot.
- * @param seed - The seed to use for generating the append only tree snapshot.
- * @returns An append only tree snapshot.
- */
-export declare function makeAppendOnlyTreeSnapshot(seed?: number): AppendOnlyTreeSnapshot;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibDJfYmxvY2tfY29kZV90b19wdXJnZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2Jsb2NrL2wyX2Jsb2NrX2NvZGVfdG9fcHVyZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXBELE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBSXhELE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHVDQUF1QyxDQUFDO0FBSy9FLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUVyRCx3QkFBZ0IsaUJBQWlCLENBQy9CLElBQUksU0FBSSxFQUNSLFdBQVcsQ0FBQyxFQUFFLE1BQU0sRUFDcEIsVUFBVSxDQUFDLEVBQUUsTUFBTSxFQUNuQixTQUFTLEdBQUUsT0FBTyxDQUFDLFFBQVEsQ0FBQyxhQUFhLENBQUMsQ0FBTSxFQUNoRCxNQUFNLENBQUMsRUFBRSxFQUFFLGlCQWVaO0FBRUQ7Ozs7R0FJRztBQUNILHdCQUFnQiwwQkFBMEIsQ0FBQyxJQUFJLFNBQUksR0FBRyxzQkFBc0IsQ0FFM0UifQ==

package/dest/block/l2_block_code_to_purge.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"l2_block_code_to_purge.d.ts","sourceRoot":"","sources":["../../src/block/l2_block_code_to_purge.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAIxD,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAK/E,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAErD,wBAAgB,iBAAiB,CAC/B,IAAI,SAAI,EACR,WAAW,CAAC,EAAE,MAAM,EACpB,UAAU,CAAC,EAAE,MAAM,EACnB,SAAS,GAAE,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAM,EAChD,MAAM,CAAC,EAAE,EAAE,iBAeZ;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,SAAI,GAAG,sBAAsB,CAE3E"}

package/dest/block/l2_block_code_to_purge.js

@@ -1,61 +0,0 @@
-import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
-import { compact } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { AztecAddress } from '../aztec-address/index.js';
-import { GasFees } from '../gas/gas_fees.js';
-import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
-import { ContentCommitment } from '../tx/content_commitment.js';
-import { GlobalVariables } from '../tx/global_variables.js';
-import { PartialStateReference } from '../tx/partial_state_reference.js';
-import { StateReference } from '../tx/state_reference.js';
-import { L2BlockHeader } from './l2_block_header.js';
-export function makeL2BlockHeader(seed = 0, blockNumber, slotNumber, overrides = {}, inHash) {
-    return new L2BlockHeader(makeAppendOnlyTreeSnapshot(seed + 0x100), overrides?.contentCommitment ?? makeContentCommitment(seed + 0x200, inHash), overrides?.state ?? makeStateReference(seed + 0x600), makeGlobalVariables(seed += 0x700, {
-        ...blockNumber ? {
-            blockNumber: BlockNumber(blockNumber)
-        } : {},
-        ...slotNumber ? {
-            slotNumber: SlotNumber(slotNumber)
-        } : {}
-    }), new Fr(seed + 0x300), new Fr(seed + 0x800), new Fr(seed + 0x900), new Fr(seed + 0xa00));
-}
-/**
- * Makes arbitrary append only tree snapshot.
- * @param seed - The seed to use for generating the append only tree snapshot.
- * @returns An append only tree snapshot.
- */ export function makeAppendOnlyTreeSnapshot(seed = 1) {
-    return new AppendOnlyTreeSnapshot(new Fr(seed), seed);
-}
-/**
- * Makes content commitment
- */ function makeContentCommitment(seed = 0, inHash) {
-    return new ContentCommitment(new Fr(seed + 0x100), inHash ?? new Fr(seed + 0x200), new Fr(seed + 0x300));
-}
-/**
- * Makes arbitrary state reference.
- * @param seed - The seed to use for generating the state reference.
- * @returns A state reference.
- */ function makeStateReference(seed = 0) {
-    return new StateReference(makeAppendOnlyTreeSnapshot(seed), makePartialStateReference(seed + 1));
-}
-/**
- * Makes arbitrary partial state reference.
- * @param seed - The seed to use for generating the partial state reference.
- * @returns A partial state reference.
- */ function makePartialStateReference(seed = 0) {
-    return new PartialStateReference(makeAppendOnlyTreeSnapshot(seed), makeAppendOnlyTreeSnapshot(seed + 1), makeAppendOnlyTreeSnapshot(seed + 2));
-}
-function makeGlobalVariables(seed = 1, overrides = {}) {
-    return GlobalVariables.from({
-        chainId: new Fr(seed),
-        version: new Fr(seed + 1),
-        blockNumber: BlockNumber(seed + 2),
-        slotNumber: SlotNumber(seed + 3),
-        timestamp: BigInt(seed + 4),
-        coinbase: EthAddress.fromField(new Fr(seed + 5)),
-        feeRecipient: AztecAddress.fromField(new Fr(seed + 6)),
-        gasFees: new GasFees(seed + 7, seed + 8),
-        ...compact(overrides)
-    });
-}