@aztec/stdlib 0.86.0-starknet.1 → 0.87.0

package/src/avm/revert_code.ts

@@ -13,10 +13,10 @@ export enum RevertCodeEnum {
 
 function isRevertCodeEnum(value: number): value is RevertCodeEnum {
   return (
-    value === RevertCodeEnum.OK ||
-    value === RevertCodeEnum.APP_LOGIC_REVERTED ||
-    value === RevertCodeEnum.TEARDOWN_REVERTED ||
-    value === RevertCodeEnum.BOTH_REVERTED
+    (value as RevertCodeEnum) === RevertCodeEnum.OK ||
+    (value as RevertCodeEnum) === RevertCodeEnum.APP_LOGIC_REVERTED ||
+    (value as RevertCodeEnum) === RevertCodeEnum.TEARDOWN_REVERTED ||
+    (value as RevertCodeEnum) === RevertCodeEnum.BOTH_REVERTED
   );
 }
 
@@ -46,7 +46,7 @@ export class RevertCode {
   }
 
   public getDescription() {
-    switch (this.code) {
+    switch (this.code as RevertCodeEnum) {
       case RevertCodeEnum.OK:
         return 'OK';
       case RevertCodeEnum.APP_LOGIC_REVERTED:

package/src/block/body.ts

@@ -1,7 +1,7 @@
 import { BLOBS_PER_BLOCK, FIELDS_PER_BLOB } from '@aztec/constants';
 import { timesParallel } from '@aztec/foundation/collection';
 import type { Fr } from '@aztec/foundation/fields';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
 import { z } from 'zod';
@@ -73,17 +73,11 @@ export class Body {
    * Decodes a block from blob fields.
    */
   static fromBlobFields(fields: Fr[]) {
-    const txEffectsFields: Fr[][] = [];
-    let checkedFields = 0;
-    while (checkedFields !== fields.length) {
-      if (!TxEffect.isFirstField(fields[checkedFields])) {
-        throw new Error('Invalid fields given to Body.fromBlobFields(): First field invalid.');
-      }
-      const len = TxEffect.decodeFirstField(fields[checkedFields]).length;
-      txEffectsFields.push(fields.slice(checkedFields, checkedFields + len));
-      checkedFields += len;
+    const txEffects: TxEffect[] = [];
+    const reader = new FieldReader(fields);
+    while (!reader.isFinished()) {
+      txEffects.push(TxEffect.fromBlobFields(reader));
     }
-    const txEffects = txEffectsFields.filter(effect => effect.length).map(effect => TxEffect.fromBlobFields(effect));
     return new this(txEffects);
   }
 

package/src/block/l2_block.ts

@@ -130,7 +130,7 @@ export class L2Block {
       ),
       contractClassLogSize: this.body.txEffects.reduce(
         (totalLogSize, txEffect) =>
-          totalLogSize + txEffect.contractClassLogs.reduce((logSize, log) => logSize + log.getEmittedLength(), 0),
+          totalLogSize + txEffect.contractClassLogs.reduce((acc, log) => acc + log.emittedLength, 0),
         0,
       ),
     };

package/src/config/index.ts

@@ -1 +1,2 @@
-export * from './config.js';
+export * from './chain-config.js';
+export * from './node-rpc-config.js';

package/src/config/node-rpc-config.ts

@@ -0,0 +1,14 @@
+import { type ConfigMappingsType, numberConfigHelper } from '@aztec/foundation/config';
+
+export const nodeRpcConfigMappings: ConfigMappingsType<NodeRPCConfig> = {
+  rpcSimulatePublicMaxGasLimit: {
+    env: 'RPC_SIMULATE_PUBLIC_MAX_GAS_LIMIT',
+    description: 'Maximum gas limit for public tx simulation in the node on `simulatePublicCalls`.',
+    ...numberConfigHelper(10e9),
+  },
+};
+
+export type NodeRPCConfig = {
+  /** Maximum gas limit for public tx simulation in the node on `simulatePublicCalls`. */
+  rpcSimulatePublicMaxGasLimit: number;
+};

package/src/contract/artifact_hash.ts

@@ -4,6 +4,8 @@ import { createLogger } from '@aztec/foundation/log';
 import { numToUInt8 } from '@aztec/foundation/serialize';
 import { MerkleTree, MerkleTreeCalculator } from '@aztec/foundation/trees';
 
+import deterministicStringify from 'json-stringify-deterministic';
+
 import { type ContractArtifact, type FunctionArtifact, FunctionSelector, FunctionType } from '../abi/index.js';
 
 const VERSION = 1;
@@ -58,7 +60,7 @@ export async function computeArtifactHashPreimage(artifact: ContractArtifact) {
 }
 
 export function computeArtifactMetadataHash(artifact: ContractArtifact) {
-  return sha256Fr(Buffer.from(JSON.stringify({ name: artifact.name, outputs: artifact.outputs }), 'utf-8'));
+  return sha256Fr(Buffer.from(deterministicStringify({ name: artifact.name, outputs: artifact.outputs }), 'utf-8'));
 }
 
 export async function computeArtifactFunctionTreeRoot(artifact: ContractArtifact, fnType: FunctionType) {
@@ -103,7 +105,7 @@ export async function computeFunctionArtifactHash(
 }
 
 export function computeFunctionMetadataHash(fn: FunctionArtifact) {
-  return sha256Fr(Buffer.from(JSON.stringify(fn.returnTypes), 'utf8'));
+  return sha256Fr(Buffer.from(deterministicStringify(fn.returnTypes), 'utf8'));
 }
 
 function getLogger() {
@@ -111,5 +113,5 @@ function getLogger() {
 }
 
 export function getArtifactMerkleTreeHasher() {
-  return (l: Buffer, r: Buffer) => Promise.resolve(sha256Fr(Buffer.concat([l, r])).toBuffer());
+  return (l: Buffer, r: Buffer) => Promise.resolve(sha256Fr(Buffer.concat([l, r])).toBuffer() as Buffer<ArrayBuffer>);
 }

package/src/contract/private_function.ts

@@ -36,11 +36,13 @@ export async function computePrivateFunctionLeaf(fn: PrivateFunction): Promise<B
 
 async function getPrivateFunctionTreeCalculator(): Promise<MerkleTreeCalculator> {
   if (!privateFunctionTreeCalculator) {
-    const functionTreeZeroLeaf = (await pedersenHash(new Array(PRIVATE_FUNCTION_SIZE).fill(0))).toBuffer();
+    const functionTreeZeroLeaf = (
+      await pedersenHash(new Array(PRIVATE_FUNCTION_SIZE).fill(0))
+    ).toBuffer() as Buffer<ArrayBuffer>;
     privateFunctionTreeCalculator = await MerkleTreeCalculator.create(
       FUNCTION_TREE_HEIGHT,
       functionTreeZeroLeaf,
-      async (left, right) => (await poseidon2Hash([left, right])).toBuffer(),
+      async (left, right) => (await poseidon2Hash([left, right])).toBuffer() as Buffer<ArrayBuffer>,
     );
   }
   return privateFunctionTreeCalculator;

package/src/errors/proving_error.ts

@@ -10,7 +10,11 @@ export class ProvingError extends Error {
    * @param cause - The cause of the error.
    * @param retry - Whether the proof should be retried.
    */
-  constructor(message: string, cause?: unknown, public readonly retry: boolean = false) {
+  constructor(
+    message: string,
+    cause?: unknown,
+    public readonly retry: boolean = false,
+  ) {
     super(message);
     this.name = ProvingError.NAME;
     this.cause = cause;

package/src/file-store/factory.ts

@@ -36,7 +36,7 @@ export async function createFileStore(
       const store = new GoogleCloudFileStore(bucket, path);
       await store.checkCredentials();
       return store;
-    } catch (err) {
+    } catch {
       throw new Error(`Invalid google cloud store definition: '${config}'.`);
     }
   } else {

package/src/file-store/http.ts

@@ -1,6 +1,7 @@
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
 
+import axios, { type AxiosInstance, type AxiosRequestConfig, type AxiosResponse } from 'axios';
 import { createWriteStream } from 'fs';
 import { mkdir } from 'fs/promises';
 import { dirname } from 'path';
@@ -10,13 +11,18 @@ import { finished } from 'stream/promises';
 import type { ReadOnlyFileStore } from './interface.js';
 
 export class HttpFileStore implements ReadOnlyFileStore {
-  private readonly fetch: typeof fetch;
+  private readonly axiosInstance: AxiosInstance;
+  private readonly fetch: <T>(config: AxiosRequestConfig) => Promise<AxiosResponse<T>>;
 
-  constructor(private readonly baseUrl: string, private readonly log: Logger = createLogger('stdlib:http-file-store')) {
-    this.fetch = async (...args: Parameters<typeof fetch>): Promise<Response> => {
+  constructor(
+    private readonly baseUrl: string,
+    private readonly log: Logger = createLogger('stdlib:http-file-store'),
+  ) {
+    this.axiosInstance = axios.create();
+    this.fetch = async <T>(config: AxiosRequestConfig) => {
       return await retry(
-        () => fetch(...args),
-        `Fetching ${args[0]}`,
+        () => this.axiosInstance.request<T>(config),
+        `Fetching ${config.url}`,
         makeBackoff([1, 1, 3]),
         this.log,
         /*failSilently=*/ true,
@@ -26,30 +32,33 @@ export class HttpFileStore implements ReadOnlyFileStore {
 
   public async read(pathOrUrl: string): Promise<Buffer> {
     const url = this.getUrl(pathOrUrl);
-    const response = await this.fetch(url);
-    if (response.ok) {
-      return Buffer.from(await response.arrayBuffer());
-    } else {
-      throw new Error(`Error fetching file from ${url}: ${response.statusText}`);
+    try {
+      const response = await this.fetch<ArrayBuffer>({ url, method: 'GET', responseType: 'arraybuffer' });
+      return Buffer.from(response.data);
+    } catch (error) {
+      throw new Error(`Error fetching file from ${url}: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
 
   public async download(pathOrUrl: string, destPath: string): Promise<void> {
     const url = this.getUrl(pathOrUrl);
-    const response = await this.fetch(url);
-    if (response.ok) {
+    try {
+      const response = await this.fetch<Readable>({ url, method: 'GET', responseType: 'stream' });
       await mkdir(dirname(destPath), { recursive: true });
-      // Typescript complains about Readable.fromWeb, hence the cast
-      await finished(Readable.fromWeb(response.body! as any).pipe(createWriteStream(destPath)));
-    } else {
-      throw new Error(`Error fetching file from ${url}: ${response.statusText}`);
+      await finished(response.data.pipe(createWriteStream(destPath)));
+    } catch (error) {
+      throw new Error(`Error fetching file from ${url}: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
 
   public async exists(pathOrUrl: string): Promise<boolean> {
     const url = this.getUrl(pathOrUrl);
-    const response = await this.fetch(url);
-    return response.ok;
+    try {
+      await this.fetch<unknown>({ url, method: 'HEAD' });
+      return true;
+    } catch {
+      return false;
+    }
   }
 
   private getUrl(path: string): string {

package/src/gas/gas.ts

@@ -14,7 +14,10 @@ export type GasDimensions = (typeof GasDimensions)[number];
 
 /** Gas amounts in each dimension. */
 export class Gas {
-  constructor(public readonly daGas: UInt32, public readonly l2Gas: UInt32) {}
+  constructor(
+    public readonly daGas: UInt32,
+    public readonly l2Gas: UInt32,
+  ) {}
 
   static get schema() {
     return z

package/src/interfaces/aztec-node-admin.ts

@@ -28,12 +28,28 @@ export interface AztecNodeAdmin {
    * @param location - The location to upload the snapshot to.
    */
   startSnapshotUpload(location: string): Promise<void>;
+
+  /**
+   * Pauses syncing and rolls back the database to the target L2 block number.
+   * @param targetBlockNumber - The block number to roll back to.
+   * @param force - If true, clears the world state db and p2p dbs if rolling back to behind the finalized block.
+   */
+  rollbackTo(targetBlockNumber: number, force?: boolean): Promise<void>;
+
+  /** Pauses archiver and world state syncing. */
+  pauseSync(): Promise<void>;
+
+  /** Resumes archiver and world state syncing. */
+  resumeSync(): Promise<void>;
 }
 
 export const AztecNodeAdminApiSchema: ApiSchemaFor<AztecNodeAdmin> = {
   setConfig: z.function().args(SequencerConfigSchema.merge(ProverConfigSchema).partial()).returns(z.void()),
   flushTxs: z.function().returns(z.void()),
   startSnapshotUpload: z.function().args(z.string()).returns(z.void()),
+  rollbackTo: z.function().args(z.number()).returns(z.void()),
+  pauseSync: z.function().returns(z.void()),
+  resumeSync: z.function().returns(z.void()),
 };
 
 export function createAztecNodeAdminClient(

package/src/interfaces/aztec-node.ts

@@ -7,7 +7,7 @@ import {
 } from '@aztec/constants';
 import { type L1ContractAddresses, L1ContractAddressesSchema } from '@aztec/ethereum/l1-contract-addresses';
 import type { Fr } from '@aztec/foundation/fields';
-import { createSafeJsonRpcClient, defaultFetch } from '@aztec/foundation/json-rpc/client';
+import { createSafeJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
 import { SiblingPath } from '@aztec/foundation/trees';
 
 import { z } from 'zod';
@@ -551,11 +551,13 @@ export const AztecNodeApiSchema: ApiSchemaFor<AztecNode> = {
 export function createAztecNodeClient(
   url: string,
   versions: Partial<ComponentsVersions> = {},
-  fetch = defaultFetch,
+  fetch = makeFetch([1, 2, 3], false),
+  batchWindowMS = 0,
 ): AztecNode {
   return createSafeJsonRpcClient<AztecNode>(url, AztecNodeApiSchema, {
     namespaceMethods: 'node',
     fetch,
+    batchWindowMS,
     onResponse: getVersioningResponseHandler(versions),
   });
 }

package/src/interfaces/configs.ts

@@ -16,6 +16,8 @@ export interface SequencerConfig {
   maxTxsPerBlock?: number;
   /** The minimum number of txs to include in a block. */
   minTxsPerBlock?: number;
+  /** Whether to publish txs with the block proposals */
+  publishTxsWithProposals?: boolean;
   /** The maximum L2 block gas. */
   maxL2BlockGas?: number;
   /** The maximum DA block gas. */
@@ -45,6 +47,7 @@ export const SequencerConfigSchema = z.object({
   maxTxsPerBlock: z.number().optional(),
   minTxsPerBlock: z.number().optional(),
   maxL2BlockGas: z.number().optional(),
+  publishTxsWithProposals: z.boolean().optional(),
   maxDABlockGas: z.number().optional(),
   coinbase: schemas.EthAddress.optional(),
   feeRecipient: schemas.AztecAddress.optional(),

package/src/interfaces/p2p.ts

@@ -30,6 +30,9 @@ export interface P2PApiWithoutAttestations {
    */
   getPendingTxs(): Promise<Tx[]>;
 
+  /** Returns the number of pending txs in the p2p tx pool. */
+  getPendingTxCount(): Promise<number>;
+
   /**
    * Returns the ENR for this node, if any.
    */
@@ -65,6 +68,7 @@ export const P2PApiSchema: ApiSchemaFor<P2PApi> = {
     .args(schemas.BigInt, optional(z.string()))
     .returns(z.array(BlockAttestation.schema)),
   getPendingTxs: z.function().returns(z.array(Tx.schema)),
+  getPendingTxCount: z.function().returns(schemas.Integer),
   getEncodedEnr: z.function().returns(z.string().optional()),
   getPeers: z.function().args(optional(z.boolean())).returns(z.array(PeerInfoSchema)),
   addAttestation: z.function().args(BlockAttestation.schema).returns(z.void()),

package/src/interfaces/prover-client.ts

@@ -113,7 +113,10 @@ export class BlockProofError extends Error {
   static #name = 'BlockProofError';
   override name = BlockProofError.#name;
 
-  constructor(message: string, public readonly txHashes: TxHash[]) {
+  constructor(
+    message: string,
+    public readonly txHashes: TxHash[],
+  ) {
     super(message);
   }
 

package/src/interfaces/pxe.ts

@@ -6,7 +6,6 @@ import { SiblingPath } from '@aztec/foundation/trees';
 import { z } from 'zod';
 
 import { type AbiType, AbiTypeSchema, type ContractArtifact, ContractArtifactSchema } from '../abi/abi.js';
-import type { AbiDecoded } from '../abi/decoder.js';
 import type { EventSelector } from '../abi/event_selector.js';
 import { AuthWitness } from '../auth_witness/auth_witness.js';
 import type { AztecAddress } from '../aztec-address/index.js';
@@ -38,7 +37,7 @@ import {
   TxSimulationResult,
   indexedTxSchema,
 } from '../tx/index.js';
-import { TxProfileResult } from '../tx/profiling.js';
+import { TxProfileResult, UtilitySimulationResult } from '../tx/profiling.js';
 import { TxProvingResult } from '../tx/proven_tx.js';
 import {
   type GetContractClassLogsResponse,
@@ -291,7 +290,7 @@ export interface PXE {
     authwits?: AuthWitness[],
     from?: AztecAddress,
     scopes?: AztecAddress[],
-  ): Promise<AbiDecoded>;
+  ): Promise<UtilitySimulationResult>;
 
   /**
    * Gets public logs based on the provided filter.
@@ -510,7 +509,7 @@ export const PXESchema: ApiSchemaFor<PXE> = {
       optional(schemas.AztecAddress),
       optional(z.array(schemas.AztecAddress)),
     )
-    .returns(AbiDecodedSchema),
+    .returns(UtilitySimulationResult.schema),
   getPublicLogs: z.function().args(LogFilterSchema).returns(GetPublicLogsResponseSchema),
   getContractClassLogs: z.function().args(LogFilterSchema).returns(GetContractClassLogsResponseSchema),
   getBlockNumber: z.function().returns(z.number()),

package/src/interfaces/service.ts

@@ -1,5 +1,4 @@
 import type { Logger } from '@aztec/foundation/log';
-import type { Maybe } from '@aztec/foundation/types';
 
 /** Represents a local service that can be started and stopped. */
 export interface Service {
@@ -17,7 +16,7 @@ export interface Service {
 }
 
 /** Tries to call stop on a given object and awaits it. Logs any errors and does not rethrow. */
-export async function tryStop(service: Maybe<Service>, logger?: Logger): Promise<void> {
+export async function tryStop(service?: Partial<Service>, logger?: Logger): Promise<void> {
   try {
     return typeof service === 'object' && service && 'stop' in service && typeof service.stop === 'function'
       ? await service.stop()
@@ -27,7 +26,7 @@ export async function tryStop(service: Maybe<Service>, logger?: Logger): Promise
   }
 }
 
-export function tryRestart(service: Maybe<Service>, logger?: Logger) {
+export function tryRestart(service?: Partial<Service>, logger?: Logger) {
   try {
     return typeof service === 'object' && service && 'restart' in service && typeof service.restart === 'function'
       ? service.restart()

package/src/interfaces/world_state.ts

@@ -1,3 +1,5 @@
+import type { PromiseWithResolvers } from '@aztec/foundation/promise';
+
 import { z } from 'zod';
 
 import type { SnapshotDataKeys } from '../snapshots/types.js';
@@ -52,7 +54,7 @@ export interface ForkMerkleTreeOperations {
 /** Defines the interface for a world state synchronizer. */
 export interface WorldStateSynchronizer extends ForkMerkleTreeOperations {
   /** Starts the synchronizer. */
-  start(): void;
+  start(): Promise<void | PromiseWithResolvers<void>>;
 
   /** Returns the current status of the synchronizer. */
   status(): Promise<WorldStateSynchronizerStatus>;
@@ -76,6 +78,9 @@ export interface WorldStateSynchronizer extends ForkMerkleTreeOperations {
 
   /** Returns an instance of MerkleTreeAdminOperations that will not include uncommitted data. */
   getCommitted(): MerkleTreeReadOperations;
+
+  /** Deletes the db */
+  clear(): Promise<void>;
 }
 
 export const WorldStateSyncStatusSchema = z.object({

package/src/kernel/hints/note_hash_read_request_hints.ts

@@ -42,7 +42,10 @@ export class NoteHashReadRequestHintsBuilder<PENDING extends number, SETTLED ext
   public numPendingReadHints = 0;
   public numSettledReadHints = 0;
 
-  constructor(public readonly maxPending: PENDING, public readonly maxSettled: SETTLED) {
+  constructor(
+    public readonly maxPending: PENDING,
+    public readonly maxSettled: SETTLED,
+  ) {
     this.hints = new ReadRequestResetHints(
       makeTuple(MAX_NOTE_HASH_READ_REQUESTS_PER_TX, ReadRequestStatus.nada),
       makeTuple(maxPending, () => PendingReadHint.nada(MAX_NOTE_HASH_READ_REQUESTS_PER_TX)),

package/src/kernel/hints/nullifier_read_request_hints.ts

@@ -40,7 +40,10 @@ export class NullifierReadRequestHintsBuilder<PENDING extends number, SETTLED ex
   private numPendingReadHints = 0;
   private numSettledReadHints = 0;
 
-  constructor(public readonly maxPending: PENDING, public readonly maxSettled: SETTLED) {
+  constructor(
+    public readonly maxPending: PENDING,
+    public readonly maxSettled: SETTLED,
+  ) {
     this.hints = new ReadRequestResetHints(
       makeTuple(MAX_NULLIFIER_READ_REQUESTS_PER_TX, ReadRequestStatus.nada),
       makeTuple(maxPending, () => PendingReadHint.nada(MAX_NULLIFIER_READ_REQUESTS_PER_TX)),

package/src/kernel/hints/read_request.ts

@@ -71,7 +71,10 @@ export class ReadRequest {
  * ReadRequest with context of the contract emitting the request.
  */
 export class ScopedReadRequest {
-  constructor(public readRequest: ReadRequest, public contractAddress: AztecAddress) {}
+  constructor(
+    public readRequest: ReadRequest,
+    public contractAddress: AztecAddress,
+  ) {}
 
   get value() {
     return this.readRequest.value;

package/src/kernel/hints/read_request_hints.ts

@@ -9,7 +9,10 @@ export enum ReadRequestState {
 }
 
 export class ReadRequestStatus {
-  constructor(public state: ReadRequestState, public hintIndex: number) {}
+  constructor(
+    public state: ReadRequestState,
+    public hintIndex: number,
+  ) {}
 
   static nada() {
     return new ReadRequestStatus(ReadRequestState.NADA, 0);
@@ -34,7 +37,10 @@ export class ReadRequestStatus {
 }
 
 export class PendingReadHint {
-  constructor(public readRequestIndex: number, public pendingValueIndex: number) {}
+  constructor(
+    public readRequestIndex: number,
+    public pendingValueIndex: number,
+  ) {}
 
   static nada(readRequestLen: number) {
     return new PendingReadHint(readRequestLen, 0);
@@ -154,7 +160,10 @@ export class ReadRequestResetHints<
 }
 
 export class ReadRequestResetStates<NUM_READS extends number> {
-  constructor(public states: Tuple<ReadRequestState, NUM_READS>, public pendingReadHints: PendingReadHint[]) {}
+  constructor(
+    public states: Tuple<ReadRequestState, NUM_READS>,
+    public pendingReadHints: PendingReadHint[],
+  ) {}
 
   static empty<NUM_READS extends number>(numReads: NUM_READS) {
     return new ReadRequestResetStates(

package/src/kernel/hints/transient_data_index_hint.ts

@@ -4,7 +4,10 @@ import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/
 import { inspect } from 'util';
 
 export class TransientDataIndexHint {
-  constructor(public nullifierIndex: number, public noteHashIndex: number) {}
+  constructor(
+    public nullifierIndex: number,
+    public noteHashIndex: number,
+  ) {}
 
   toFields(): Fr[] {
     return [new Fr(this.nullifierIndex), new Fr(this.noteHashIndex)];

package/src/kernel/hints/tree_leaf_read_request.ts

@@ -2,7 +2,10 @@ import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 export class TreeLeafReadRequest {
-  constructor(public value: Fr, public leafIndex: Fr) {}
+  constructor(
+    public value: Fr,
+    public leafIndex: Fr,
+  ) {}
 
   toBuffer(): Buffer {
     return serializeToBuffer(this.value, this.leafIndex);