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

package/src/block/l2_block_new.ts

@@ -1,197 +0,0 @@
-import { type BlockBlobData, encodeBlockBlobData } from '@aztec/blob-lib/encoding';
-import { BlockNumber, CheckpointNumber, CheckpointNumberSchema } from '@aztec/foundation/branded-types';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-
-import { z } from 'zod';
-
-import type { PrivateLog } from '../logs/private_log.js';
-import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
-import { BlockHeader } from '../tx/block_header.js';
-import { Body } from './body.js';
-import type { L2BlockInfo } from './l2_block_info.js';
-
-/**
- * An L2 block with a header and a body.
- * TODO: Delete the existing `L2Block` class and rename this to `L2Block`.
- */
-export class L2BlockNew {
-  constructor(
-    /** Snapshot of archive tree after the block is applied. */
-    public archive: AppendOnlyTreeSnapshot,
-    /** Header of the block. */
-    public header: BlockHeader,
-    /** L2 block body. */
-    public body: Body,
-    /** Number of the checkpoint that the block belongs to. */
-    public checkpointNumber: CheckpointNumber,
-    /** Index of the block within the checkpoint. */
-    public indexWithinCheckpoint: number,
-    private blockHash: Fr | undefined = undefined,
-  ) {}
-
-  get number(): BlockNumber {
-    return this.header.globalVariables.blockNumber;
-  }
-
-  get timestamp(): bigint {
-    return this.header.globalVariables.timestamp;
-  }
-
-  static get schema() {
-    return z
-      .object({
-        archive: AppendOnlyTreeSnapshot.schema,
-        header: BlockHeader.schema,
-        body: Body.schema,
-        checkpointNumber: CheckpointNumberSchema,
-        indexWithinCheckpoint: z.number(),
-      })
-      .transform(
-        ({ archive, header, body, checkpointNumber, indexWithinCheckpoint }) =>
-          new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint),
-      );
-  }
-
-  /**
-   * Deserializes a block from a buffer
-   * @returns A deserialized L2 block.
-   */
-  static fromBuffer(buf: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buf);
-    const header = reader.readObject(BlockHeader);
-    const archive = reader.readObject(AppendOnlyTreeSnapshot);
-    const body = reader.readObject(Body);
-    const checkpointNumber = CheckpointNumber(reader.readNumber());
-    const indexWithinCheckpoint = reader.readNumber();
-
-    return new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint);
-  }
-
-  /**
-   * Serializes a block
-   * @returns A serialized L2 block as a Buffer.
-   */
-  toBuffer() {
-    return serializeToBuffer(this.header, this.archive, this.body, this.checkpointNumber, this.indexWithinCheckpoint);
-  }
-
-  /**
-   * Returns the block's hash (hash of block header).
-   * @returns The block's hash.
-   */
-  public async hash(): Promise<Fr> {
-    if (this.blockHash === undefined) {
-      this.blockHash = await this.header.hash();
-    }
-    return this.blockHash;
-  }
-
-  public toBlobFields(): Fr[] {
-    const blockBlobData = this.toBlockBlobData();
-    return encodeBlockBlobData(blockBlobData);
-  }
-
-  public toBlockBlobData(): BlockBlobData {
-    const isFirstBlock = this.indexWithinCheckpoint === 0;
-    return {
-      blockEndMarker: {
-        numTxs: this.body.txEffects.length,
-        timestamp: this.header.globalVariables.timestamp,
-        blockNumber: this.number,
-      },
-      blockEndStateField: {
-        l1ToL2MessageNextAvailableLeafIndex: this.header.state.l1ToL2MessageTree.nextAvailableLeafIndex,
-        noteHashNextAvailableLeafIndex: this.header.state.partial.noteHashTree.nextAvailableLeafIndex,
-        nullifierNextAvailableLeafIndex: this.header.state.partial.nullifierTree.nextAvailableLeafIndex,
-        publicDataNextAvailableLeafIndex: this.header.state.partial.publicDataTree.nextAvailableLeafIndex,
-        totalManaUsed: this.header.totalManaUsed.toBigInt(),
-      },
-      lastArchiveRoot: this.header.lastArchive.root,
-      noteHashRoot: this.header.state.partial.noteHashTree.root,
-      nullifierRoot: this.header.state.partial.nullifierTree.root,
-      publicDataRoot: this.header.state.partial.publicDataTree.root,
-      l1ToL2MessageRoot: isFirstBlock ? this.header.state.l1ToL2MessageTree.root : undefined,
-      txs: this.body.toTxBlobData(),
-    };
-  }
-
-  static empty() {
-    return new L2BlockNew(AppendOnlyTreeSnapshot.empty(), BlockHeader.empty(), Body.empty(), CheckpointNumber(0), 0);
-  }
-
-  /**
-   * Creates an L2 block containing random data.
-   * @param l2BlockNum - The number of the L2 block.
-   * @param txsPerBlock - The number of transactions to include in the block.
-   * @param numPublicCallsPerTx - The number of public function calls to include in each transaction.
-   * @param numPublicLogsPerCall - The number of public logs per 1 public function invocation.
-   * @param inHash - The hash of the L1 to L2 messages subtree which got inserted in this block.
-   * @returns The L2 block.
-   */
-  static async random(
-    blockNumber: BlockNumber,
-    {
-      checkpointNumber = CheckpointNumber(Number(blockNumber)),
-      indexWithinCheckpoint = 0,
-      txsPerBlock = 1,
-      txOptions = {},
-      makeTxOptions,
-      ...blockHeaderOverrides
-    }: {
-      checkpointNumber?: CheckpointNumber;
-      indexWithinCheckpoint?: number;
-      txsPerBlock?: number;
-      txOptions?: Partial<Parameters<typeof Body.random>[0]>;
-      makeTxOptions?: (txIndex: number) => Partial<Parameters<typeof Body.random>[0]>;
-    } & Partial<Parameters<typeof BlockHeader.random>[0]> = {},
-  ): Promise<L2BlockNew> {
-    const archive = new AppendOnlyTreeSnapshot(Fr.random(), blockNumber + 1);
-    const header = BlockHeader.random({ blockNumber, ...blockHeaderOverrides });
-    const body = await Body.random({ txsPerBlock, makeTxOptions, ...txOptions });
-    return new L2BlockNew(archive, header, body, checkpointNumber, indexWithinCheckpoint);
-  }
-
-  /**
-   * Returns stats used for logging.
-   * @returns Stats on tx count, number, and log size and count.
-   */
-  getStats() {
-    const logsStats = {
-      privateLogCount: this.body.txEffects.reduce((logCount, txEffect) => logCount + txEffect.privateLogs.length, 0),
-      publicLogCount: this.body.txEffects.reduce((logCount, txEffect) => logCount + txEffect.publicLogs.length, 0),
-      contractClassLogCount: this.body.txEffects.reduce(
-        (logCount, txEffect) => logCount + txEffect.contractClassLogs.length,
-        0,
-      ),
-      contractClassLogSize: this.body.txEffects.reduce(
-        (totalLogSize, txEffect) =>
-          totalLogSize + txEffect.contractClassLogs.reduce((acc, log) => acc + log.emittedLength, 0),
-        0,
-      ),
-    };
-
-    return {
-      txCount: this.body.txEffects.length,
-      blockNumber: this.number,
-      blockTimestamp: Number(this.header.globalVariables.timestamp),
-      ...logsStats,
-    };
-  }
-
-  getPrivateLogs(): PrivateLog[] {
-    return this.body.txEffects.map(txEffect => txEffect.privateLogs).flat();
-  }
-
-  toBlockInfo(): L2BlockInfo {
-    return {
-      blockHash: this.blockHash,
-      archive: this.archive.root,
-      lastArchive: this.header.lastArchive.root,
-      blockNumber: this.number,
-      slotNumber: this.header.getSlot(),
-      txCount: this.body.txEffects.length,
-      timestamp: this.header.globalVariables.timestamp,
-    };
-  }
-}

package/src/block/published_l2_block.ts

@@ -1,65 +0,0 @@
-// Ignoring import issue to fix portable inferred type issue in zod schema
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import type { FieldsOf } from '@aztec/foundation/types';
-
-import { z } from 'zod';
-
-import { L1PublishedData, PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
-import { L2Block } from './l2_block.js';
-import { CommitteeAttestation } from './proposal/committee_attestation.js';
-
-/**
- * @deprecated `PublishedCheckpoint` is what will be retrieved from L1.
- * L2 blocks do not need to link to L1PublishedData directly.
- * TODO: Create another type (AttestedL2Block?) for an L2 block and its attestations.
- */
-export class PublishedL2Block {
-  constructor(
-    public block: L2Block,
-    public l1: L1PublishedData,
-    public attestations: CommitteeAttestation[],
-  ) {}
-
-  static get schema() {
-    return z
-      .object({
-        block: L2Block.schema,
-        l1: L1PublishedData.schema,
-        attestations: z.array(CommitteeAttestation.schema),
-      })
-      .transform(obj => PublishedL2Block.fromFields(obj));
-  }
-
-  static fromBuffer(bufferOrReader: Buffer | BufferReader): PublishedL2Block {
-    const reader = BufferReader.asReader(bufferOrReader);
-    const block = reader.readObject(L2Block);
-    const l1BlockNumber = reader.readBigInt();
-    const l1BlockHash = reader.readString();
-    const l1Timestamp = reader.readBigInt();
-    const attestations = reader.readVector(CommitteeAttestation);
-    return new PublishedL2Block(block, new L1PublishedData(l1BlockNumber, l1Timestamp, l1BlockHash), attestations);
-  }
-
-  static fromFields(fields: FieldsOf<PublishedL2Block>) {
-    return new PublishedL2Block(fields.block, fields.l1, fields.attestations);
-  }
-
-  public toBuffer(): Buffer {
-    return serializeToBuffer(
-      this.block,
-      this.l1.blockNumber,
-      this.l1.blockHash,
-      this.l1.timestamp,
-      this.attestations.length,
-      this.attestations,
-    );
-  }
-
-  public toPublishedCheckpoint() {
-    return new PublishedCheckpoint(this.block.toCheckpoint(), this.l1, this.attestations);
-  }
-
-  static fromPublishedCheckpoint(checkpoint: PublishedCheckpoint) {
-    return new PublishedL2Block(L2Block.fromCheckpoint(checkpoint.checkpoint), checkpoint.l1, checkpoint.attestations);
-  }
-}

package/src/contract/contract_class_metadata.ts

@@ -1,8 +0,0 @@
-import type { ContractArtifact } from '../abi/abi.js';
-import type { ContractClassWithId } from './interfaces/contract_class.js';
-
-export interface ContractClassMetadata {
-  contractClass?: ContractClassWithId | undefined;
-  isContractClassPubliclyRegistered: boolean;
-  artifact?: ContractArtifact | undefined;
-}

package/src/contract/contract_metadata.ts

@@ -1,7 +0,0 @@
-import type { ContractInstanceWithAddress } from './interfaces/contract_instance.js';
-
-export interface ContractMetadata {
-  contractInstance?: ContractInstanceWithAddress | undefined;
-  isContractInitialized: boolean;
-  isContractPublished: boolean;
-}

package/src/database-version/index.ts

@@ -1 +0,0 @@
-export * from './version_manager.js';

package/src/logs/log_with_tx_data.ts

@@ -1,46 +0,0 @@
-import { MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_CIPHERTEXT_LEN } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { TxHash } from '@aztec/stdlib/tx';
-
-// This is used as a response for PXE's custom getPublicLogByTag oracle.
-export class PublicLogWithTxData {
-  constructor(
-    public logPayload: Fr[],
-    public txHash: TxHash,
-    public uniqueNoteHashesInTx: Fr[],
-    public firstNullifierInTx: Fr,
-  ) {}
-}
-
-// This is used as a response for PXE's custom getPrivateLogByTag oracle.
-export class PrivateLogWithTxData {
-  constructor(
-    public logPayload: Fr[],
-    public txHash: TxHash,
-    public uniqueNoteHashesInTx: Fr[],
-    public firstNullifierInTx: Fr,
-  ) {}
-
-  toNoirSerialization(): (Fr | Fr[])[] {
-    return [
-      ...toBoundedVecSerialization(this.logPayload, PRIVATE_LOG_CIPHERTEXT_LEN),
-      this.txHash.hash,
-      ...toBoundedVecSerialization(this.uniqueNoteHashesInTx, MAX_NOTE_HASHES_PER_TX),
-      this.firstNullifierInTx,
-    ];
-  }
-
-  static noirSerializationOfEmpty(): (Fr | Fr[])[] {
-    return new PrivateLogWithTxData([], TxHash.zero(), [], new Fr(0)).toNoirSerialization();
-  }
-}
-
-function toBoundedVecSerialization(array: Fr[], maxLength: number) {
-  if (array.length > maxLength) {
-    throw new Error(
-      `An array of length ${array.length} cannot be converted to a BoundedVec of max length ${maxLength}`,
-    );
-  }
-
-  return [array.concat(Array(maxLength - array.length).fill(new Fr(0))), new Fr(array.length)];
-}

package/src/note/notes_filter.ts

@@ -1,38 +0,0 @@
-import type { Fr } from '@aztec/foundation/curves/bn254';
-
-import { z } from 'zod';
-
-import type { AztecAddress } from '../aztec-address/index.js';
-import { type ZodFor, schemas } from '../schemas/index.js';
-import { NoteStatus } from './note_status.js';
-
-/**
- * A filter used to fetch notes.
- * @remarks This filter is applied as an intersection of all its params.
- */
-export type NotesFilter = {
-  /**
-   * The contract address the note belongs to.
-   * @remarks Providing a contract address is required as we need that information to trigger private state sync.
-   */
-  contractAddress: AztecAddress;
-  /** The owner of the note. */
-  owner?: AztecAddress;
-  /** The specific storage location of the note on the contract. */
-  storageSlot?: Fr;
-  /** The status of the note. Defaults to 'ACTIVE'. */
-  status?: NoteStatus;
-  /** The siloed nullifier for the note. */
-  siloedNullifier?: Fr;
-  /** The scopes in which to get notes from. This defaults to all scopes. */
-  scopes?: AztecAddress[];
-};
-
-export const NotesFilterSchema: ZodFor<NotesFilter> = z.object({
-  contractAddress: schemas.AztecAddress,
-  owner: schemas.AztecAddress.optional(),
-  storageSlot: schemas.Fr.optional(),
-  status: z.nativeEnum(NoteStatus).optional(),
-  siloedNullifier: schemas.Fr.optional(),
-  scopes: z.array(schemas.AztecAddress).optional(),
-});

package/src/tx/content_commitment.ts

@@ -1,113 +0,0 @@
-import type { ViemContentCommitment } from '@aztec/ethereum/contracts';
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
-import { bufferToHex } from '@aztec/foundation/string';
-import type { FieldsOf } from '@aztec/foundation/types';
-
-import { z } from 'zod';
-
-export class ContentCommitment {
-  constructor(
-    public blobsHash: Fr,
-    public inHash: Fr,
-    public outHash: Fr,
-  ) {}
-
-  static get schema() {
-    return z
-      .object({
-        blobsHash: schemas.Fr,
-        inHash: schemas.Fr,
-        outHash: schemas.Fr,
-      })
-      .transform(({ blobsHash, inHash, outHash }) => new ContentCommitment(blobsHash, inHash, outHash));
-  }
-
-  static getFields(fields: FieldsOf<ContentCommitment>) {
-    return [fields.blobsHash, fields.inHash, fields.outHash] as const;
-  }
-
-  static from(fields: FieldsOf<ContentCommitment>) {
-    return new ContentCommitment(...ContentCommitment.getFields(fields));
-  }
-
-  getSize() {
-    return this.toBuffer().length;
-  }
-
-  toBuffer() {
-    return serializeToBuffer(...ContentCommitment.getFields(this));
-  }
-
-  static fromBuffer(buffer: Buffer | BufferReader): ContentCommitment {
-    const reader = BufferReader.asReader(buffer);
-
-    return new ContentCommitment(reader.readObject(Fr), reader.readObject(Fr), reader.readObject(Fr));
-  }
-
-  toInspect() {
-    return {
-      blobsHash: this.blobsHash.toString(),
-      inHash: this.inHash.toString(),
-      outHash: this.outHash.toString(),
-    };
-  }
-
-  toViem(): ViemContentCommitment {
-    return {
-      blobsHash: this.blobsHash.toString(),
-      inHash: this.inHash.toString(),
-      outHash: this.outHash.toString(),
-    };
-  }
-
-  static fromViem(contentCommitment: ViemContentCommitment) {
-    return new ContentCommitment(
-      Fr.fromString(contentCommitment.blobsHash),
-      Fr.fromString(contentCommitment.inHash),
-      Fr.fromString(contentCommitment.outHash),
-    );
-  }
-
-  toFields(): Fr[] {
-    return serializeToFields(...ContentCommitment.getFields(this));
-  }
-
-  static fromFields(fields: Fr[] | FieldReader): ContentCommitment {
-    const reader = FieldReader.asReader(fields);
-    return new ContentCommitment(reader.readField(), reader.readField(), reader.readField());
-  }
-
-  static random(overrides: Partial<FieldsOf<ContentCommitment>> = {}): ContentCommitment {
-    return ContentCommitment.from({
-      blobsHash: Fr.random(),
-      inHash: Fr.random(),
-      outHash: Fr.random(),
-      ...overrides,
-    });
-  }
-
-  static empty(): ContentCommitment {
-    return new ContentCommitment(Fr.zero(), Fr.zero(), Fr.zero());
-  }
-
-  isEmpty(): boolean {
-    return this.blobsHash.isZero() && this.inHash.isZero() && this.outHash.isZero();
-  }
-
-  public toString(): string {
-    return bufferToHex(this.toBuffer());
-  }
-
-  static fromString(str: string): ContentCommitment {
-    const buffer = Buffer.from(str.replace(/^0x/i, ''), 'hex');
-    return ContentCommitment.fromBuffer(buffer);
-  }
-
-  public equals(other: this): boolean {
-    return (
-      this.blobsHash.equals(other.blobsHash) && this.inHash.equals(other.inHash) && this.outHash.equals(other.outHash)
-    );
-  }
-}

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

@@ -1,166 +0,0 @@
-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;
-  }
-}