@aztec/stdlib 0.77.0-testnet-ignition.17

package/src/proofs/proof.ts

@@ -0,0 +1,115 @@
+import { AGGREGATION_OBJECT_LENGTH } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+
+const EMPTY_PROOF_SIZE = 42;
+
+/**
+ * The Proof class is a wrapper around the circuits proof.
+ * Underlying it is a buffer of proof data in a form a barretenberg prover understands.
+ * It provides methods to easily create, serialize, and deserialize the proof data for efficient
+ * communication and storage.
+ */
+export class Proof {
+  // Make sure this type is not confused with other buffer wrappers
+  readonly __proofBrand: any;
+
+  // Honk proofs start with a 4 byte length prefix
+  // the proof metadata starts immediately after
+  private readonly metadataOffset = 4;
+  // the metadata is 3 Frs long
+  // the public inputs are after it
+  private readonly publicInputsOffset = 100;
+
+  constructor(
+    /**
+     * Holds the serialized proof data in a binary buffer format.
+     */
+    public buffer: Buffer,
+
+    public numPublicInputs: number,
+  ) {}
+
+  /**
+   * Create a Proof from a Buffer or BufferReader.
+   * Expects a length-encoding.
+   *
+   * @param buffer - A Buffer or BufferReader containing the length-encoded proof data.
+   * @returns A Proof instance containing the decoded proof data.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): Proof {
+    const reader = BufferReader.asReader(buffer);
+    const size = reader.readNumber();
+    const buf = reader.readBytes(size);
+    const numPublicInputs = reader.readNumber();
+    return new Proof(buf, numPublicInputs);
+  }
+
+  /**
+   * Convert the Proof instance to a custom Buffer format.
+   * This function serializes the Proof's buffer length and data sequentially into a new Buffer.
+   *
+   * @returns A Buffer containing the serialized proof data in custom format.
+   */
+  public toBuffer() {
+    return serializeToBuffer(this.buffer.length, this.buffer, this.numPublicInputs);
+  }
+
+  /**
+   * Serialize the Proof instance to a hex string.
+   * @returns The hex string representation of the proof data.
+   */
+  public toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  public withoutPublicInputs(): Buffer {
+    return Buffer.concat([
+      this.buffer.subarray(this.metadataOffset, this.publicInputsOffset),
+      this.buffer.subarray(this.publicInputsOffset + Fr.SIZE_IN_BYTES * this.numPublicInputs),
+    ]);
+  }
+
+  public extractPublicInputs(): Fr[] {
+    const reader = BufferReader.asReader(
+      this.buffer.subarray(this.publicInputsOffset, this.publicInputsOffset + Fr.SIZE_IN_BYTES * this.numPublicInputs),
+    );
+    return reader.readArray(this.numPublicInputs, Fr);
+  }
+
+  public extractAggregationObject(): Fr[] {
+    const publicInputs = this.extractPublicInputs();
+    return publicInputs.slice(-1 * AGGREGATION_OBJECT_LENGTH);
+  }
+
+  /**
+   * Deserialize a Proof instance from a hex string.
+   * @param str - A hex string to deserialize from.
+   * @returns - A new Proof instance.
+   */
+  static fromString(str: string) {
+    return Proof.fromBuffer(hexToBuffer(str));
+  }
+
+  /** Returns whether this proof is actually empty. */
+  public isEmpty() {
+    return (
+      this.buffer.length === EMPTY_PROOF_SIZE && this.buffer.every(byte => byte === 0) && this.numPublicInputs === 0
+    );
+  }
+
+  /** Returns an empty proof. */
+  static empty() {
+    return makeEmptyProof();
+  }
+}
+
+/**
+ * Makes an empty proof.
+ * Note: Used for local devnet milestone where we are not proving anything yet.
+ * @returns The empty "proof".
+ */
+export function makeEmptyProof() {
+  return new Proof(Buffer.alloc(EMPTY_PROOF_SIZE, 0), 0);
+}

package/src/proofs/proving_request_type.ts

@@ -0,0 +1,17 @@
+export enum ProvingRequestType {
+  PUBLIC_VM,
+
+  PRIVATE_BASE_ROLLUP,
+  PUBLIC_BASE_ROLLUP,
+  MERGE_ROLLUP,
+  EMPTY_BLOCK_ROOT_ROLLUP,
+  BLOCK_ROOT_ROLLUP,
+  SINGLE_TX_BLOCK_ROOT_ROLLUP,
+  BLOCK_MERGE_ROLLUP,
+  ROOT_ROLLUP,
+
+  BASE_PARITY,
+  ROOT_PARITY,
+  /** Recursive Client IVC verification to connect private to public or rollup */
+  TUBE_PROOF,
+}

package/src/proofs/recursive_proof.ts

@@ -0,0 +1,124 @@
+import { makeTuple } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+
+import { Proof, makeEmptyProof } from './proof.js';
+
+/**
+ * The Recursive proof class is a wrapper around the circuit's proof.
+ * We store the proof in 2 forms for convenience. The first is in the 'fields' format.
+ * This is a list of fields, for which there are distinct lengths based on the level of recursion.
+ * This 'fields' version does not contain the circuits public inputs
+ * We also store the raw binary proof which van be directly verified.
+ *
+ * The 'fieldsValid' member is set to false in the case where this object is constructed solely from the 'binary' proof
+ * This is usually when the proof has been received from clients and signals to provers that the 'fields' version needs to be generated
+ */
+export class RecursiveProof<N extends number> {
+  constructor(
+    /**
+     * Holds the serialized proof data in an array of fields, this is without the public inputs
+     */
+    public proof: Fr[],
+
+    /**
+     * Holds the serialized proof data in a binary buffer, this contains the public inputs
+     */
+    public binaryProof: Proof,
+    /**
+     * This flag determines if the 'proof' member is valid, or if we need to generate it from the 'binaryProof' first
+     */
+    public fieldsValid: boolean,
+    public proofLength: N,
+  ) {
+    if (proof.length !== proofLength) {
+      throw new Error(`Proof length ${proof.length} does not match expected length ${proofLength}.`);
+    }
+  }
+
+  /**
+   * Create a Proof from a Buffer or BufferReader.
+   * Expects a length-encoding.
+   *
+   * @param buffer - A Buffer or BufferReader containing the length-encoded proof data.
+   * @returns A Proof instance containing the decoded proof data.
+   */
+  static fromBuffer<N extends number>(buffer: Buffer | BufferReader, expectedSize?: N): RecursiveProof<N> {
+    const reader = BufferReader.asReader(buffer);
+    const size = reader.readNumber();
+    if (typeof expectedSize === 'number' && expectedSize !== size) {
+      throw new Error(`Expected proof length ${expectedSize}, got ${size}`);
+    }
+    return new RecursiveProof(
+      reader.readArray(size, Fr) as any,
+      Proof.fromBuffer(reader),
+      reader.readBoolean(),
+      size as N,
+    );
+  }
+
+  /**
+   * Convert the Proof instance to a custom Buffer format.
+   * This function serializes the Proof's buffer length and data sequentially into a new Buffer.
+   *
+   * @returns A Buffer containing the serialized proof data in custom format.
+   */
+  public toBuffer() {
+    return serializeToBuffer(this.proof.length, this.proof, this.binaryProof, this.fieldsValid);
+  }
+
+  /**
+   * Serialize the Proof instance to a hex string.
+   * @returns The hex string representation of the proof data.
+   */
+  public toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /**
+   * Deserialize a Proof instance from a hex string.
+   * @param str - A hex string to deserialize from.
+   * @returns - A new Proof instance.
+   */
+  static fromString<N extends number>(str: string, expectedSize?: N): RecursiveProof<N> {
+    return RecursiveProof.fromBuffer(hexToBuffer(str), expectedSize);
+  }
+
+  /** Returns a buffer representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a hex string with expected size. */
+  static schemaFor<N extends number>(expectedSize?: N) {
+    return schemas.Buffer.transform(b => RecursiveProof.fromBuffer(b, expectedSize));
+  }
+}
+
+/**
+ * Makes an empty proof.
+ * Note: Used for local devnet milestone where we are not proving anything yet.
+ * @returns The empty "proof".
+ */
+export function makeEmptyRecursiveProof<N extends number>(size: N) {
+  return new RecursiveProof(makeTuple<Fr, N>(size, Fr.zero), makeEmptyProof(), true, size);
+}
+
+export function makeRecursiveProof<PROOF_LENGTH extends number>(size: PROOF_LENGTH, seed = 1) {
+  return new RecursiveProof<PROOF_LENGTH>(
+    makeTuple<Fr, PROOF_LENGTH>(size, (i: number) => new Fr(i), seed),
+    makeEmptyProof(),
+    true,
+    size,
+  );
+}
+
+/**
+ * Makes an instance of the recursive proof from a binary only proof
+ * @returns The proof object
+ */
+export function makeRecursiveProofFromBinary<PROOF_LENGTH extends number>(proof: Proof, size: PROOF_LENGTH) {
+  return new RecursiveProof<PROOF_LENGTH>(makeTuple<Fr, PROOF_LENGTH>(size, Fr.zero), proof, false, size);
+}

package/src/rollup/avm_proof_data.ts

@@ -0,0 +1,35 @@
+import { AVM_PROOF_LENGTH_IN_FIELDS } from '@aztec/constants';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { AvmCircuitPublicInputs } from '../avm/avm_circuit_public_inputs.js';
+import { RecursiveProof, makeEmptyRecursiveProof } from '../proofs/recursive_proof.js';
+import { VkWitnessData } from '../vks/vk_witness_data.js';
+
+export class AvmProofData {
+  constructor(
+    public publicInputs: AvmCircuitPublicInputs,
+    public proof: RecursiveProof<typeof AVM_PROOF_LENGTH_IN_FIELDS>,
+    public vkData: VkWitnessData,
+  ) {}
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new AvmProofData(
+      reader.readObject(AvmCircuitPublicInputs),
+      RecursiveProof.fromBuffer(reader),
+      reader.readObject(VkWitnessData),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(this.publicInputs, this.proof, this.vkData);
+  }
+
+  static empty() {
+    return new AvmProofData(
+      AvmCircuitPublicInputs.empty(),
+      makeEmptyRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS),
+      VkWitnessData.empty(),
+    );
+  }
+}

package/src/rollup/base_or_merge_rollup_public_inputs.ts

@@ -0,0 +1,146 @@
+import { SpongeBlob } from '@aztec/blob-lib';
+import { Fr } from '@aztec/foundation/fields';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+
+import { PartialStateReference } from '../tx/partial_state_reference.js';
+import { RollupTypes } from '../types/shared.js';
+import { ConstantRollupData } from './constant_rollup_data.js';
+
+/**
+ * Output of the base and merge rollup circuits.
+ */
+export class BaseOrMergeRollupPublicInputs {
+  constructor(
+    /**
+     * Specifies from which type of rollup circuit these inputs are from.
+     */
+    public rollupType: RollupTypes,
+    /**
+     * Number of txs in this rollup.
+     */
+    public numTxs: number,
+    /**
+     * Data which is forwarded through the rollup circuits unchanged.
+     */
+    public constants: ConstantRollupData,
+    /**
+     * Partial state reference at the start of the rollup circuit.
+     */
+    public start: PartialStateReference,
+    /**
+     * Partial state reference at the end of the rollup circuit.
+     */
+    public end: PartialStateReference,
+    /**
+     * Sponge state to absorb blob inputs at the start of the rollup circuit.
+     */
+    public startSpongeBlob: SpongeBlob,
+    /**
+     * Sponge state to absorb blob inputs at the end of the rollup circuit.
+     */
+    public endSpongeBlob: SpongeBlob,
+    /**
+     * SHA256 hash of L2 to L1 messages. Used to make public inputs constant-sized (to then be opened on-chain).
+     * Note: Truncated to 31 bytes to fit in Fr.
+     */
+    public outHash: Fr,
+    /**
+     * The summed `transaction_fee` of the constituent transactions.
+     */
+    public accumulatedFees: Fr,
+    /**
+     * The summed `mana_used` of the constituent transactions.
+     */
+    public accumulatedManaUsed: Fr,
+  ) {}
+
+  /** Returns an empty instance. */
+  static empty() {
+    return new BaseOrMergeRollupPublicInputs(
+      RollupTypes.Base,
+      0,
+      ConstantRollupData.empty(),
+      PartialStateReference.empty(),
+      PartialStateReference.empty(),
+      SpongeBlob.empty(),
+      SpongeBlob.empty(),
+      Fr.zero(),
+      Fr.zero(),
+      Fr.zero(),
+    );
+  }
+
+  /**
+   * Deserializes from a buffer or reader.
+   * Note: Corresponds to a write in cpp.
+   * @param buffer - Buffer or reader to read from.
+   * @returns The deserialized public inputs.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): BaseOrMergeRollupPublicInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new BaseOrMergeRollupPublicInputs(
+      reader.readNumber(),
+      reader.readNumber(),
+      reader.readObject(ConstantRollupData),
+      reader.readObject(PartialStateReference),
+      reader.readObject(PartialStateReference),
+      reader.readObject(SpongeBlob),
+      reader.readObject(SpongeBlob),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+    );
+  }
+
+  /**
+   * Serialize this as a buffer.
+   * @returns The buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(
+      this.rollupType,
+      this.numTxs,
+      this.constants,
+
+      this.start,
+      this.end,
+
+      this.startSpongeBlob,
+      this.endSpongeBlob,
+
+      this.outHash,
+
+      this.accumulatedFees,
+      this.accumulatedManaUsed,
+    );
+  }
+
+  /**
+   * Serialize this as a hex string.
+   * @returns - The hex string.
+   */
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /**
+   * Deserializes from a hex string.
+   * @param str - A hex string to deserialize from.
+   * @returns A new BaseOrMergeRollupPublicInputs instance.
+   */
+  static fromString(str: string) {
+    return BaseOrMergeRollupPublicInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  /** Returns a buffer representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a hex string. */
+  static get schema() {
+    return bufferSchemaFor(BaseOrMergeRollupPublicInputs);
+  }
+}

package/src/rollup/base_rollup_hints.ts

@@ -0,0 +1,182 @@
+import { SpongeBlob } from '@aztec/blob-lib';
+import { ARCHIVE_HEIGHT, MAX_CONTRACT_CLASS_LOGS_PER_TX } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import { MembershipWitness } from '@aztec/foundation/trees';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { PublicDataHint } from '../avm/public_data_hint.js';
+import { ContractClassLog } from '../logs/contract_class_log.js';
+import { PartialStateReference } from '../tx/partial_state_reference.js';
+import { ConstantRollupData } from './constant_rollup_data.js';
+import { PrivateBaseStateDiffHints } from './state_diff_hints.js';
+
+export type BaseRollupHints = PrivateBaseRollupHints | PublicBaseRollupHints;
+
+export class PrivateBaseRollupHints {
+  constructor(
+    /**
+     * Partial state reference at the start of the rollup.
+     */
+    public start: PartialStateReference,
+    /**
+     * Sponge state to absorb blob inputs at the start of the rollup.
+     */
+    public startSpongeBlob: SpongeBlob,
+    /**
+     * Hints used while proving state diff validity.
+     */
+    public stateDiffHints: PrivateBaseStateDiffHints,
+    /**
+     * Public data read hint for accessing the balance of the fee payer.
+     */
+    public feePayerFeeJuiceBalanceReadHint: PublicDataHint,
+    /**
+     * Membership witnesses of blocks referred by each of the 2 kernels.
+     */
+    public archiveRootMembershipWitness: MembershipWitness<typeof ARCHIVE_HEIGHT>,
+    /**
+     * Preimages to the kernel's contractClassLogsHashes.
+     */
+    public contractClassLogsPreimages: Tuple<ContractClassLog, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
+    /**
+     * Data which is not modified by the base rollup circuit.
+     */
+    public constants: ConstantRollupData,
+  ) {}
+
+  static from(fields: FieldsOf<PrivateBaseRollupHints>): PrivateBaseRollupHints {
+    return new PrivateBaseRollupHints(...PrivateBaseRollupHints.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<PrivateBaseRollupHints>) {
+    return [
+      fields.start,
+      fields.startSpongeBlob,
+      fields.stateDiffHints,
+      fields.feePayerFeeJuiceBalanceReadHint,
+      fields.archiveRootMembershipWitness,
+      fields.contractClassLogsPreimages,
+      fields.constants,
+    ] as const;
+  }
+
+  /**
+   * Serializes the inputs to a buffer.
+   * @returns The inputs serialized to a buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(...PrivateBaseRollupHints.getFields(this));
+  }
+
+  /**
+   * Serializes the inputs to a hex string.
+   * @returns The instance serialized to a hex string.
+   */
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateBaseRollupHints {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateBaseRollupHints(
+      reader.readObject(PartialStateReference),
+      reader.readObject(SpongeBlob),
+      reader.readObject(PrivateBaseStateDiffHints),
+      reader.readObject(PublicDataHint),
+      MembershipWitness.fromBuffer(reader, ARCHIVE_HEIGHT),
+      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog),
+      reader.readObject(ConstantRollupData),
+    );
+  }
+
+  static fromString(str: string) {
+    return PrivateBaseRollupHints.fromBuffer(hexToBuffer(str));
+  }
+
+  static empty() {
+    return new PrivateBaseRollupHints(
+      PartialStateReference.empty(),
+      SpongeBlob.empty(),
+      PrivateBaseStateDiffHints.empty(),
+      PublicDataHint.empty(),
+      MembershipWitness.empty(ARCHIVE_HEIGHT),
+      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog.empty),
+      ConstantRollupData.empty(),
+    );
+  }
+}
+
+export class PublicBaseRollupHints {
+  constructor(
+    /**
+     * Sponge state to absorb blob inputs at the start of the rollup.
+     */
+    public startSpongeBlob: SpongeBlob,
+    /**
+     * Membership witnesses of blocks referred by each of the 2 kernels.
+     */
+    public archiveRootMembershipWitness: MembershipWitness<typeof ARCHIVE_HEIGHT>,
+    /**
+     * Preimages to the kernel's contractClassLogsHashes.
+     */
+    public contractClassLogsPreimages: Tuple<ContractClassLog, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
+    /**
+     * Data which is not modified by the base rollup circuit.
+     */
+    public constants: ConstantRollupData,
+  ) {}
+
+  static from(fields: FieldsOf<PublicBaseRollupHints>): PublicBaseRollupHints {
+    return new PublicBaseRollupHints(...PublicBaseRollupHints.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<PublicBaseRollupHints>) {
+    return [
+      fields.startSpongeBlob,
+      fields.archiveRootMembershipWitness,
+      fields.contractClassLogsPreimages,
+      fields.constants,
+    ] as const;
+  }
+
+  /**
+   * Serializes the inputs to a buffer.
+   * @returns The inputs serialized to a buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(...PublicBaseRollupHints.getFields(this));
+  }
+
+  /**
+   * Serializes the inputs to a hex string.
+   * @returns The instance serialized to a hex string.
+   */
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PublicBaseRollupHints {
+    const reader = BufferReader.asReader(buffer);
+    return new PublicBaseRollupHints(
+      reader.readObject(SpongeBlob),
+      MembershipWitness.fromBuffer(reader, ARCHIVE_HEIGHT),
+      reader.readArray(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog),
+      reader.readObject(ConstantRollupData),
+    );
+  }
+
+  static fromString(str: string) {
+    return PublicBaseRollupHints.fromBuffer(hexToBuffer(str));
+  }
+
+  static empty() {
+    return new PublicBaseRollupHints(
+      SpongeBlob.empty(),
+      MembershipWitness.empty(ARCHIVE_HEIGHT),
+      makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLog.empty),
+      ConstantRollupData.empty(),
+    );
+  }
+}

package/src/rollup/block_merge_rollup.ts

@@ -0,0 +1,65 @@
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+
+import { PreviousRollupBlockData } from './previous_rollup_block_data.js';
+
+/**
+ * Represents inputs of the block merge rollup circuit.
+ */
+export class BlockMergeRollupInputs {
+  constructor(
+    /**
+     * Previous rollup data from the 2 block merge or block root rollup circuits that preceded this merge rollup circuit.
+     */
+    public previousRollupData: [PreviousRollupBlockData, PreviousRollupBlockData],
+  ) {}
+
+  /**
+   * Serializes the inputs to a buffer.
+   * @returns The inputs serialized to a buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(this.previousRollupData);
+  }
+
+  /**
+   * Serializes the inputs to a hex string.
+   * @returns The instance serialized to a hex string.
+   */
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /**
+   * Deserializes the inputs from a buffer.
+   * @param buffer - The buffer to deserialize from.
+   * @returns A new BlockMergeRollupInputs instance.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new BlockMergeRollupInputs([
+      reader.readObject(PreviousRollupBlockData),
+      reader.readObject(PreviousRollupBlockData),
+    ]);
+  }
+
+  /**
+   * Deserializes the inputs from a hex string.
+   * @param str - A hex string to deserialize from.
+   * @returns A new BlockMergeRollupInputs instance.
+   */
+  static fromString(str: string) {
+    return BlockMergeRollupInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  /** Returns a hex representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a hex string. */
+  static get schema() {
+    return bufferSchemaFor(BlockMergeRollupInputs);
+  }
+}