@aztec/blob-lib 3.0.0-nightly.20251026 → 3.0.0-nightly.20251031

package/src/deserialize.ts

@@ -1,93 +1,38 @@
 import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
+import { BufferReader } from '@aztec/foundation/serialize';
 
-import { getNumBlobFieldsFromTxStartMarker, isBlockEndMarker } from './encoding.js';
+import { checkBlobFieldsEncoding } from './encoding.js';
+import { BlobDeserializationError } from './errors.js';
 
 /**
- * Deserializes a blob buffer into an array of field elements.
+ * Deserializes a buffer into an array of field elements.
  *
- * Blobs are converted into BN254 fields to perform a poseidon2 hash on them (fieldHash).
- * This method is sparse, meaning it does not include trailing zeros at the end of the blob.
+ * This function returns the fields that were actually added in a checkpoint. The number of fields is specified by the
+ * first field.
  *
- * However, we cannot simply trim the zero's from the end of the blob, as some logs may include zero's
- * within them.
- * If we end on a set of zeros, such as the log below:
- * length 7: [ a, b, c, d, e, 0, 0]
- *
- * we will end up with the incorrect hash if we trim the zeros from the end.
- *
- * Each transactions logs contains a TX start prefix, which includes a string followed
- * by the length ( in field elements ) of the transaction's log.
- *
- * This function finds the end of the last transaction's logs, and returns the array up to this point.
- *
- * We search for a series of Tx Prefixes progressing the cursor in the field reader until we hit
- * a field that is not a Tx Prefix, this indicates that we have reached the end of the last transaction's logs.
- *
- * +------------------+------------------+------------------+------------------+
- * | TX1 Start Prefix | TX1 Log Fields   | TX2 Start Prefix | Padded zeros     |
- * | [3 a,b,c]        | [3, a, b, c]     | [5 d,e,f,0,0]    | [0, 0, 0, .., 0] |
- * +------------------+------------------+------------------+------------------+
- *                                                          ^
- *                                                          |
- * Function reads until here --------------------------------
- *
- * @param blob - The blob buffer to deserialize.
+ * @param buf - The buffer to deserialize.
+ * @param checkEncoding - Whether to check if the encoding is correct. If false, it will still check the checkpoint
+ * prefix and throw if there's not enough fields.
  * @returns An array of field elements.
  */
-export function deserializeEncodedBlobToFields(blob: Uint8Array): Fr[] {
-  // Convert blob buffer to array of field elements
-  const reader = BufferReader.asReader(blob);
-  const array = reader.readArray(blob.length >> 5, Fr); // >> 5 = / 32 (bytes per field)
-  const fieldReader = FieldReader.asReader(array);
-
-  // Read fields until we hit zeros at the end
-  while (!fieldReader.isFinished()) {
-    const currentField = fieldReader.peekField();
-
-    // Stop when we hit a zero field
-    if (!currentField || currentField.isZero()) {
-      break;
-    }
-
-    // This comes before `getLengthFromFirstField` because an empty block doesn't have fields for the tx effect.
-    if (isBlockEndMarker(currentField)) {
-      // Include the block end marker in the result
-      fieldReader.skip(1);
-      break;
-    }
-
-    // Skip the remaining fields in this transaction
-    const len = getNumBlobFieldsFromTxStartMarker(currentField);
-    fieldReader.skip(len);
+export function deserializeEncodedBlobToFields(buf: Uint8Array, checkEncoding = false): Fr[] {
+  const reader = BufferReader.asReader(buf);
+  const firstField = reader.readObject(Fr);
+
+  // Use toBigInt instead of toNumber so that we can catch it and throw a more descriptive error below if the first
+  // field is larger than a javascript integer.
+  const numFields = firstField.toBigInt();
+  const totalFieldsInBuffer = BigInt(buf.length / Fr.SIZE_IN_BYTES);
+  if (numFields > totalFieldsInBuffer) {
+    throw new BlobDeserializationError(`Failed to deserialize blob fields, this blob was likely not created by us`);
   }
 
-  // Return array up to last non-zero field
-  return array.slice(0, fieldReader.cursor);
-}
-
-/**
- * Extract the fields from a blob buffer, but do not take into account encoding
- * that will include trailing zeros.
- *
- * +------------------+------------------+------------------+------------------+
- * |                  |                  |                  | Padded zeros     |
- * | [3 a,b,c]        | [3, a, b, c]     | [5 d,e,f,0,0]    | [0, 0, 0, .., 0] |
- * +------------------+------------------+------------------+------------------+
- *                                                ^
- *                                                |
- * Function reads until here ----------------------
- */
-export function extractBlobFieldsFromBuffer(blob: Uint8Array): Fr[] {
-  const reader = BufferReader.asReader(blob);
-  const array = reader.readArray(blob.length >> 5, Fr);
+  const numFieldsWithoutPrefix = Number(numFields) - 1;
+  const blobFields = [firstField].concat(reader.readArray(numFieldsWithoutPrefix, Fr));
 
-  // Find the index of the last non-zero field
-  let lastNonZeroIndex = array.length - 1;
-  while (lastNonZeroIndex >= 0 && array[lastNonZeroIndex].isZero()) {
-    lastNonZeroIndex--;
+  if (checkEncoding && !checkBlobFieldsEncoding(blobFields)) {
+    throw new BlobDeserializationError(`Incorrect encoding of blob fields, this blob was likely not created by us`);
   }
 
-  // Return the trimmed array
-  return array.slice(0, lastNonZeroIndex + 1);
+  return blobFields;
 }

package/src/encoding.ts

@@ -1,5 +1,6 @@
 import { BLOCK_END_PREFIX, TX_START_PREFIX } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
+import { FieldReader } from '@aztec/foundation/serialize';
 
 const NUM_BLOB_FIELDS_BIT_SIZE = 32n;
 const REVERT_CODE_BIT_SIZE = 8n;
@@ -107,3 +108,47 @@ export function isBlockEndMarker(field: Fr) {
   const numTxs = value & 0xffffn;
   return value - numTxs === BLOCK_END_PREFIX * 256n * 256n;
 }
+
+/**
+ * Check that the fields are emitted from the circuits and conform to the encoding.
+ * @param blobFields - The concatenated fields from all blobs of an L1 block.
+ */
+export function checkBlobFieldsEncoding(blobFields: Fr[]) {
+  const reader = FieldReader.asReader(blobFields);
+
+  const checkpointPrefix = reader.readField();
+  if (checkpointPrefix.toBigInt() !== BigInt(blobFields.length)) {
+    return false;
+  }
+
+  const numFieldsInCheckpoint = checkpointPrefix.toNumber();
+  let seenNumTxs = 0;
+  while (reader.cursor < numFieldsInCheckpoint) {
+    const currentField = reader.readField();
+
+    if (isBlockEndMarker(currentField)) {
+      // Found a block end marker. Confirm that the number of txs in this block is correct.
+      const numTxs = getNumTxsFromBlockEndMarker(currentField);
+      if (numTxs !== seenNumTxs) {
+        return false;
+      }
+      seenNumTxs = 0;
+      // Continue the loop to process the next field.
+      continue;
+    }
+
+    // If the field is not a block end marker, it must be a tx start marker.
+    const txStartMarker = decodeTxStartMarker(currentField);
+    if (!isValidTxStartMarker(txStartMarker)) {
+      return false;
+    }
+
+    seenNumTxs += 1;
+
+    // Skip the remaining fields in this tx. -1 because we already read the tx start marker.
+    reader.skip(txStartMarker.numBlobFields - 1);
+    // TODO: Check the encoding of the tx if we want to be more strict.
+  }
+
+  return true;
+}

package/src/hash.ts

@@ -0,0 +1,77 @@
+import { poseidon2Hash, sha256, sha256ToField } from '@aztec/foundation/crypto';
+import { BLS12Fr, Fr } from '@aztec/foundation/fields';
+
+import { BYTES_PER_BLOB, BYTES_PER_COMMITMENT, kzg } from './kzg_context.js';
+
+const VERSIONED_HASH_VERSION_KZG = 0x01;
+
+/**
+ * Returns ethereum's versioned blob hash, following kzg_to_versioned_hash: https://eips.ethereum.org/EIPS/eip-4844#helpers
+ */
+export function computeEthVersionedBlobHash(commitment: Buffer): Buffer {
+  const hash = sha256(commitment);
+  hash[0] = VERSIONED_HASH_VERSION_KZG;
+  return hash;
+}
+
+// TODO(#13430): The blobsHash is confusingly similar to blobCommitmentsHash, calculated from below blobCommitments:
+// - blobsHash := sha256([blobhash_0, ..., blobhash_m]) = a hash of all blob hashes in a block with m+1 blobs inserted into the header, exists so a user can cross check blobs.
+// - blobCommitmentsHash := sha256( ...sha256(sha256(C_0), C_1) ... C_n) = iteratively calculated hash of all blob commitments in an epoch with n+1 blobs (see calculateBlobCommitmentsHash()),
+//   exists so we can validate injected commitments to the rollup circuits correspond to the correct real blobs.
+// We may be able to combine these values e.g. blobCommitmentsHash := sha256( ...sha256(sha256(blobshash_0), blobshash_1) ... blobshash_l) for an epoch with l+1 blocks.
+export function computeBlobsHash(evmVersionedBlobHashes: Buffer[]): Fr {
+  return sha256ToField(evmVersionedBlobHashes);
+}
+
+/**
+ * The hash of the fields added throughout the checkpoint. The exact number of fields is specified by the checkpoint
+ * prefix (the first field). It's verified in the circuit against the fields absorbed into the sponge blob.
+ * This hash is used in generating the challenge z for all blobs in the same checkpoint.
+ */
+export async function computeBlobFieldsHash(fields: Fr[]): Promise<Fr> {
+  return await poseidon2Hash(fields);
+}
+
+export function computeBlobCommitment(data: Uint8Array): Buffer {
+  if (data.length !== BYTES_PER_BLOB) {
+    throw new Error(`Expected ${BYTES_PER_BLOB} bytes per blob. Got ${data.length}.`);
+  }
+
+  return Buffer.from(kzg.blobToKzgCommitment(data));
+}
+
+/**
+ * Get the commitment fields of the blob, to compute the challenge z.
+ *
+ * The 48-byte commitment is encoded into two field elements:
+ * +-------------------+------------------------+
+ * |      31 bytes     |         17 bytes       |
+ * +-------------------+------------------------+
+ * |  Field Element 1  |     Field Element 2    |
+ * |  [0][bytes 0-30]  |  [0...0][bytes 31-47]  |
+ * +-------------------+------------------------+
+ *
+ * @param commitment - The commitment to convert to fields. Computed from `computeBlobCommitment`.
+ * @returns The fields representing the commitment buffer.
+ */
+export function commitmentToFields(commitment: Buffer): [Fr, Fr] {
+  if (commitment.length !== BYTES_PER_COMMITMENT) {
+    throw new Error(`Expected ${BYTES_PER_COMMITMENT} bytes for blob commitment. Got ${commitment.length}.`);
+  }
+
+  return [new Fr(commitment.subarray(0, 31)), new Fr(commitment.subarray(31, BYTES_PER_COMMITMENT))];
+}
+
+export async function computeChallengeZ(blobFieldsHash: Fr, commitment: Buffer): Promise<Fr> {
+  const commitmentFields = commitmentToFields(commitment);
+  return await poseidon2Hash([blobFieldsHash, commitmentFields[0], commitmentFields[1]]);
+}
+
+/**
+ * Hash each u128 limb of the noir bignum struct representing the BLS field, to mimic the hash accumulation in the
+ * rollup circuits.
+ */
+export async function hashNoirBigNumLimbs(field: BLS12Fr): Promise<Fr> {
+  const num = field.toNoirBigNum();
+  return await poseidon2Hash(num.limbs.map(Fr.fromHexString));
+}

package/src/index.ts

@@ -1,8 +1,10 @@
 export * from './blob.js';
 export * from './blob_batching.js';
+export * from './blob_utils.js';
+export * from './circuit_types/index.js';
 export * from './deserialize.js';
 export * from './encoding.js';
-export * from './interface.js';
 export * from './errors.js';
-export * from './blob_batching_public_inputs.js';
+export * from './hash.js';
+export * from './interface.js';
 export * from './sponge_blob.js';

package/src/sponge_blob.ts

@@ -1,3 +1,4 @@
+import { TWO_POW_64 } from '@aztec/constants';
 import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
 import { poseidon2Permutation } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
@@ -10,17 +11,17 @@ import {
 } from '@aztec/foundation/serialize';
 
 /**
- * A Poseidon2 sponge used to accumulate data that will be added to a blob.
+ * A Poseidon2 sponge used to accumulate data that will be added to blobs.
  * See noir-projects/noir-protocol-circuits/crates/types/src/abis/sponge_blob.nr.
  */
 export class SpongeBlob {
   constructor(
-    /** Sponge with absorbed tx effects that will go into a blob. */
+    /** Sponge with absorbed fields that will go into one or more blobs. */
     public readonly sponge: Poseidon2Sponge,
     /** Number of effects absorbed so far. */
-    public fields: number,
+    public numAbsorbedFields: number,
     /** Number of effects that will be absorbed. */
-    public readonly expectedFields: number,
+    public readonly numExpectedFields: number,
   ) {}
 
   static fromBuffer(buffer: Buffer | BufferReader): SpongeBlob {
@@ -29,11 +30,11 @@ export class SpongeBlob {
   }
 
   toBuffer() {
-    return serializeToBuffer(this.sponge, this.fields, this.expectedFields);
+    return serializeToBuffer(...SpongeBlob.getFields(this));
   }
 
   static getFields(fields: FieldsOf<SpongeBlob>) {
-    return [fields.sponge, fields.fields, fields.expectedFields];
+    return [fields.sponge, fields.numAbsorbedFields, fields.numExpectedFields];
   }
 
   toFields(): Fr[] {
@@ -54,19 +55,19 @@ export class SpongeBlob {
   }
 
   async absorb(fields: Fr[]) {
-    if (this.fields + fields.length > this.expectedFields) {
+    if (this.numAbsorbedFields + fields.length > this.numExpectedFields) {
       throw new Error(
-        `Attempted to fill spongeblob with ${this.fields + fields.length}, but it has a max of ${this.expectedFields}`,
+        `Attempted to fill spongeBlob with ${this.numAbsorbedFields + fields.length}, but it has a max of ${this.numExpectedFields}`,
       );
     }
     await this.sponge.absorb(fields);
-    this.fields += fields.length;
+    this.numAbsorbedFields += fields.length;
   }
 
   async squeeze(): Promise<Fr> {
     // If the blob sponge is not 'full', we append 1 to match Poseidon2::hash_internal()
     // NB: There is currently no use case in which we don't 'fill' a blob sponge, but adding for completeness
-    if (this.fields != this.expectedFields) {
+    if (this.numAbsorbedFields != this.numExpectedFields) {
       await this.sponge.absorb([Fr.ONE]);
     }
     return this.sponge.squeeze();
@@ -76,8 +77,17 @@ export class SpongeBlob {
     return new SpongeBlob(Poseidon2Sponge.empty(), 0, 0);
   }
 
-  static init(expectedFields: number): SpongeBlob {
-    return new SpongeBlob(Poseidon2Sponge.init(expectedFields), 0, expectedFields);
+  /**
+   * Initialize the sponge blob with the number of expected fields in the checkpoint and absorb it as the first field.
+   * Note: `numExpectedFields` includes the first field absorbed in this method.
+   */
+  static async init(numExpectedFields: number): Promise<SpongeBlob> {
+    // This must match what the checkpoint root rollup circuit expects.
+    // See noir-projects/noir-protocol-circuits/types/src/abis/sponge_blob.nr -> init_for_checkpoint.
+    const sponge = Poseidon2Sponge.init(numExpectedFields);
+    await sponge.absorb([new Fr(numExpectedFields)]);
+    const numAbsorbedFields = 1;
+    return new SpongeBlob(sponge, numAbsorbedFields, numExpectedFields);
   }
 }
 
@@ -131,8 +141,8 @@ export class Poseidon2Sponge {
     );
   }
 
-  static init(expectedFields: number): Poseidon2Sponge {
-    const iv = new Fr(expectedFields).mul(new Fr(BigInt('18446744073709551616')));
+  static init(numExpectedFields: number): Poseidon2Sponge {
+    const iv = new Fr(numExpectedFields).mul(new Fr(TWO_POW_64));
     const sponge = Poseidon2Sponge.empty();
     sponge.state[3] = iv;
     return sponge;

package/src/testing.ts

@@ -1,9 +1,13 @@
+import { FIELDS_PER_BLOB } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
+import { randomInt } from '@aztec/foundation/crypto';
 import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
 
 import { Blob } from './blob.js';
-import { BatchedBlobAccumulator, FinalBlobBatchingChallenges } from './blob_batching.js';
-import { encodeTxStartMarker } from './encoding.js';
+import { BatchedBlobAccumulator } from './blob_batching.js';
+import { getBlobsPerL1Block } from './blob_utils.js';
+import { FinalBlobBatchingChallenges } from './circuit_types/index.js';
+import { createBlockEndMarker, encodeTxStartMarker } from './encoding.js';
 import { Poseidon2Sponge, SpongeBlob } from './sponge_blob.js';
 
 /**
@@ -44,18 +48,12 @@ export function makeBatchedBlobAccumulator(seed = 1): BatchedBlobAccumulator {
   );
 }
 
-/**
- * Make an encoded blob with the given length
- *
- * This will deserialise correctly in the archiver
- * @param length
- * @returns
- */
-export function makeEncodedBlob(length: number): Promise<Blob> {
+export function makeEncodedTxBlobFields(length: number): Fr[] {
   const txStartMarker = {
     numBlobFields: length,
-    // The rest of the values don't matter. The test components using it only look at `numBlobFields` to split the blobs
-    // into fields for tx effects.
+    // The rest of the values don't matter. The test components using it do not try to deserialize everything.
+    // Only `checkBlobFieldsEncoding` is used and it only looks at `numBlobFields`. This might change in the future
+    // when we add more thorough checks to `checkBlobFieldsEncoding`.
     revertCode: 0,
     numNoteHashes: 0,
     numNullifiers: 0,
@@ -65,10 +63,49 @@ export function makeEncodedBlob(length: number): Promise<Blob> {
     publicLogsLength: 0,
     contractClassLogLength: 0,
   };
-  return Blob.fromFields([
+
+  return [
     encodeTxStartMarker(txStartMarker),
-    ...Array.from({ length: length - 1 }, () => Fr.random()),
-  ]);
+    ...Array.from({ length: length - 1 }, () => new Fr(randomInt(Number.MAX_SAFE_INTEGER))), // -1 to account for the tx start marker.
+  ];
+}
+
+export function makeEncodedBlockBlobFields(...lengths: number[]): Fr[] {
+  return [
+    ...(lengths.length > 0 ? makeEncodedTxBlobFields(lengths[0] - 1) : []), // -1 to account for the block end marker.
+    ...lengths.slice(1).flatMap(length => makeEncodedTxBlobFields(length)),
+    createBlockEndMarker(lengths.length),
+  ];
+}
+
+// Create blob fields for a checkpoint with a single block.
+export function makeEncodedBlobFields(length: number): Fr[] {
+  if (length <= 2) {
+    throw new Error('Encoded blob fields length must be greater than 2');
+  }
+
+  const checkpointPrefix = new Fr(length);
+  return [checkpointPrefix, ...makeEncodedBlockBlobFields(length - 1)]; // -1 to account for the checkpoint prefix.
+}
+
+/**
+ * Make an encoded blob with the given length
+ *
+ * This will deserialise correctly in the archiver
+ * @param length
+ * @returns
+ */
+export function makeEncodedBlob(length: number): Blob {
+  if (length > FIELDS_PER_BLOB) {
+    throw new Error(`A single encoded blob must be less than ${FIELDS_PER_BLOB} fields`);
+  }
+
+  return Blob.fromFields(makeEncodedBlobFields(length));
+}
+
+export function makeEncodedBlobs(length: number): Blob[] {
+  const fields = makeEncodedBlobFields(length);
+  return getBlobsPerL1Block(fields);
 }
 
 /**
@@ -78,6 +115,6 @@ export function makeEncodedBlob(length: number): Promise<Blob> {
  * @param length
  * @returns
  */
-export function makeRandomBlob(length: number): Promise<Blob> {
+export function makeRandomBlob(length: number): Blob {
   return Blob.fromFields([...Array.from({ length: length }, () => Fr.random())]);
 }

package/src/types.ts

@@ -1,7 +1,7 @@
+export * from './circuit_types/index.js';
+export * from './interface.js';
 export * from './sponge_blob.js';
 
-// TODO: Separate functions that use c-kzg from classes and export those classes here.
-
 /**
  * Type definition for the KZG instance returned by Blob.getViemKzgInstance().
  * Contains the cryptographic functions needed for blob commitment and proof generation.

package/dest/blob_batching_public_inputs.d.ts

@@ -1,57 +0,0 @@
-import { BLS12Fr, BLS12Point, Fr } from '@aztec/foundation/fields';
-import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
-import { inspect } from 'util';
-import { Blob } from './blob.js';
-import { BatchedBlob, BatchedBlobAccumulator, FinalBlobBatchingChallenges } from './blob_batching.js';
-/**
- * See nr BlobAccumulator and ts BatchedBlobAccumulator for documentation.
- */
-export declare class BlobAccumulator {
-    blobCommitmentsHashAcc: Fr;
-    zAcc: Fr;
-    yAcc: BLS12Fr;
-    cAcc: BLS12Point;
-    gammaAcc: Fr;
-    gammaPowAcc: BLS12Fr;
-    constructor(blobCommitmentsHashAcc: Fr, zAcc: Fr, yAcc: BLS12Fr, cAcc: BLS12Point, gammaAcc: Fr, gammaPowAcc: BLS12Fr);
-    static empty(): BlobAccumulator;
-    equals(other: BlobAccumulator): boolean;
-    static fromBuffer(buffer: Buffer | BufferReader): BlobAccumulator;
-    toBuffer(): Buffer<ArrayBufferLike>;
-    /**
-     * Given blobs, accumulate all public inputs state.
-     * We assume the input blobs have not been evaluated at z.
-     * NOTE: Does NOT accumulate non circuit values including Q. This exists to simulate/check exactly what the circuit is doing
-     * and is unsafe for other use. For that reason, a toBatchedBlobAccumulator does not exist. See evaluateBlobs() oracle for usage.
-     * @returns An updated blob accumulator.
-     */
-    accumulateBlobs(blobs: Blob[], finalBlobChallenges: FinalBlobBatchingChallenges): Promise<BlobAccumulator>;
-    toFields(): Fr[];
-    static fromFields(fields: Fr[] | FieldReader): BlobAccumulator;
-    /**
-     * Converts from an accumulator to a struct for the public inputs of our rollup circuits.
-     * @returns A BlobAccumulator instance.
-     */
-    static fromBatchedBlobAccumulator(accumulator: BatchedBlobAccumulator): BlobAccumulator;
-}
-/**
- * See nr FinalBlobAccumulator and ts BatchedBlobAccumulator for documentation.
- */
-export declare class FinalBlobAccumulator {
-    blobCommitmentsHash: Fr;
-    z: Fr;
-    y: BLS12Fr;
-    c: BLS12Point;
-    constructor(blobCommitmentsHash: Fr, z: Fr, y: BLS12Fr, c: BLS12Point);
-    static empty(): FinalBlobAccumulator;
-    static fromBuffer(buffer: Buffer | BufferReader): FinalBlobAccumulator;
-    toBuffer(): Buffer<ArrayBufferLike>;
-    static fromBatchedBlob(blob: BatchedBlob): FinalBlobAccumulator;
-    toFields(): Fr[];
-    toString(): string;
-    equals(other: FinalBlobAccumulator): boolean;
-    static random(): FinalBlobAccumulator;
-    static fromBatchedBlobAccumulator(accumulator: BatchedBlobAccumulator): FinalBlobAccumulator;
-    [inspect.custom](): string;
-}
-//# sourceMappingURL=blob_batching_public_inputs.d.ts.map

package/dest/blob_batching_public_inputs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"blob_batching_public_inputs.d.ts","sourceRoot":"","sources":["../src/blob_batching_public_inputs.ts"],"names":[],"mappings":"AACA,OAAO,EAAW,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC5E,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,6BAA6B,CAAC;AAE3F,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAE/B,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEtG;;GAEG;AACH,qBAAa,eAAe;IAEjB,sBAAsB,EAAE,EAAE;IAC1B,IAAI,EAAE,EAAE;IACR,IAAI,EAAE,OAAO;IACb,IAAI,EAAE,UAAU;IAChB,QAAQ,EAAE,EAAE;IACZ,WAAW,EAAE,OAAO;gBALpB,sBAAsB,EAAE,EAAE,EAC1B,IAAI,EAAE,EAAE,EACR,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,EAAE,EACZ,WAAW,EAAE,OAAO;IAG7B,MAAM,CAAC,KAAK,IAAI,eAAe;IAI/B,MAAM,CAAC,KAAK,EAAE,eAAe;IAW7B,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,eAAe;IAYjE,QAAQ;IAWR;;;;;;OAMG;IACG,eAAe,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,mBAAmB,EAAE,2BAA2B;IAerF,QAAQ;IAaR,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,eAAe;IAgB9D;;;OAGG;IACH,MAAM,CAAC,0BAA0B,CAAC,WAAW,EAAE,sBAAsB;CAUtE;AAED;;GAEG;AACH,qBAAa,oBAAoB;IAEtB,mBAAmB,EAAE,EAAE;IACvB,CAAC,EAAE,EAAE;IACL,CAAC,EAAE,OAAO;IACV,CAAC,EAAE,UAAU;gBAHb,mBAAmB,EAAE,EAAE,EACvB,CAAC,EAAE,EAAE,EACL,CAAC,EAAE,OAAO,EACV,CAAC,EAAE,UAAU;IAGtB,MAAM,CAAC,KAAK,IAAI,oBAAoB;IAIpC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,oBAAoB;IAUtE,QAAQ;IAIR,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,WAAW;IAIxC,QAAQ;IAUR,QAAQ;IAQR,MAAM,CAAC,KAAK,EAAE,oBAAoB;IAUlC,MAAM,CAAC,MAAM;IAKb,MAAM,CAAC,0BAA0B,CAAC,WAAW,EAAE,sBAAsB;IASrE,CAAC,OAAO,CAAC,MAAM,CAAC;CAQjB"}