@aztec/archiver 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/src/test/mock_l2_block_source.ts

@@ -1,24 +1,44 @@
-import { DefaultL1ContractsConfig } from '@aztec/ethereum';
+import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
+import { DefaultL1ContractsConfig } from '@aztec/ethereum/config';
+import { BlockNumber, CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
-import { L2Block, L2BlockHash, type L2BlockSource, type L2Tips } from '@aztec/stdlib/block';
-import { type L1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import {
+  CheckpointedL2Block,
+  L2Block,
+  L2BlockHash,
+  L2BlockNew,
+  type L2BlockSource,
+  type L2Tips,
+  PublishedL2Block,
+  type ValidateCheckpointResult,
+} from '@aztec/stdlib/block';
+import { type Checkpoint, L1PublishedData } from '@aztec/stdlib/checkpoint';
+import type { ContractClassPublic, ContractDataSource, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import { EmptyL1RollupConstants, type L1RollupConstants, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
 import { type BlockHeader, TxHash, TxReceipt, TxStatus } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
 
 /**
  * A mocked implementation of L2BlockSource to be used in tests.
  */
-export class MockL2BlockSource implements L2BlockSource {
+export class MockL2BlockSource implements L2BlockSource, ContractDataSource {
   protected l2Blocks: L2Block[] = [];
 
   private provenBlockNumber: number = 0;
+  private finalizedBlockNumber: number = 0;
+  private checkpointedBlockNumber: number = 0;
 
   private log = createLogger('archiver:mock_l2_block_source');
 
   public async createBlocks(numBlocks: number) {
     for (let i = 0; i < numBlocks; i++) {
       const blockNum = this.l2Blocks.length + 1;
-      const block = await L2Block.random(blockNum);
+      const block = await L2Block.random(BlockNumber(blockNum));
       this.l2Blocks.push(block);
     }
 
@@ -39,6 +59,17 @@ export class MockL2BlockSource implements L2BlockSource {
     this.provenBlockNumber = provenBlockNumber;
   }
 
+  public setFinalizedBlockNumber(finalizedBlockNumber: number) {
+    if (finalizedBlockNumber > this.provenBlockNumber) {
+      this.provenBlockNumber = finalizedBlockNumber;
+    }
+    this.finalizedBlockNumber = finalizedBlockNumber;
+  }
+
+  public setCheckpointedBlockNumber(checkpointedBlockNumber: number) {
+    this.checkpointedBlockNumber = checkpointedBlockNumber;
+  }
+
   /**
    * Method to fetch the rollup contract address at the base-layer.
    * @returns The rollup address.
@@ -60,11 +91,47 @@ export class MockL2BlockSource implements L2BlockSource {
    * @returns In this mock instance, returns the number of L2 blocks that we've mocked.
    */
   public getBlockNumber() {
-    return Promise.resolve(this.l2Blocks.length);
+    return Promise.resolve(BlockNumber(this.l2Blocks.length));
+  }
+
+  public getProvenBlockNumber() {
+    return Promise.resolve(BlockNumber(this.provenBlockNumber));
   }
 
-  public getProvenBlockNumber(): Promise<number> {
-    return Promise.resolve(this.provenBlockNumber);
+  public getCheckpointedBlock(number: BlockNumber): Promise<CheckpointedL2Block | undefined> {
+    if (number > this.checkpointedBlockNumber) {
+      return Promise.resolve(undefined);
+    }
+    const block = this.l2Blocks[number - 1];
+    if (!block) {
+      return Promise.resolve(undefined);
+    }
+    const checkpointedBlock = new CheckpointedL2Block(
+      CheckpointNumber(number),
+      block.toL2Block(),
+      new L1PublishedData(BigInt(number), BigInt(number), `0x${number.toString(16).padStart(64, '0')}`),
+      [],
+    );
+    return Promise.resolve(checkpointedBlock);
+  }
+
+  public async getCheckpointedBlocks(
+    from: BlockNumber,
+    limit: number,
+    _proven?: boolean,
+  ): Promise<CheckpointedL2Block[]> {
+    const result: CheckpointedL2Block[] = [];
+    for (let i = 0; i < limit; i++) {
+      const blockNum = from + i;
+      if (blockNum > this.checkpointedBlockNumber) {
+        break;
+      }
+      const block = await this.getCheckpointedBlock(BlockNumber(blockNum));
+      if (block) {
+        result.push(block);
+      }
+    }
+    return result;
   }
 
   /**
@@ -76,6 +143,16 @@ export class MockL2BlockSource implements L2BlockSource {
     return Promise.resolve(this.l2Blocks[number - 1]);
   }
 
+  /**
+   * Gets an L2 block (new format).
+   * @param number - The block number to return.
+   * @returns The requested L2 block.
+   */
+  public getL2BlockNew(number: BlockNumber): Promise<L2BlockNew | undefined> {
+    const block = this.l2Blocks[number - 1];
+    return Promise.resolve(block?.toL2Block());
+  }
+
   /**
    * Gets up to `limit` amount of L2 blocks starting from `from`.
    * @param from - Number of the first block to return (inclusive).
@@ -90,24 +167,103 @@ export class MockL2BlockSource implements L2BlockSource {
     );
   }
 
+  public async getPublishedCheckpoints(from: CheckpointNumber, limit: number) {
+    // TODO: Implement this properly. This only works when we have one block per checkpoint.
+    return (await this.getPublishedBlocks(from, limit)).map(block => block.toPublishedCheckpoint());
+  }
+
+  public async getCheckpointByArchive(archive: Fr): Promise<Checkpoint | undefined> {
+    // TODO: Implement this properly. This only works when we have one block per checkpoint.
+    return (await this.getPublishedBlockByArchive(archive))?.block.toCheckpoint();
+  }
+
+  public async getPublishedBlocks(from: number, limit: number, proven?: boolean) {
+    const blocks = await this.getBlocks(from, limit, proven);
+    return blocks.map(block =>
+      PublishedL2Block.fromFields({
+        block,
+        l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
+        attestations: [],
+      }),
+    );
+  }
+
+  async getL2BlocksNew(from: BlockNumber, limit: number, proven?: boolean): Promise<L2BlockNew[]> {
+    const blocks = await this.getBlocks(from, limit, proven);
+    return blocks.map(x => x.toL2Block());
+  }
+
+  public async getPublishedBlockByHash(blockHash: Fr): Promise<PublishedL2Block | undefined> {
+    for (const block of this.l2Blocks) {
+      const hash = await block.hash();
+      if (hash.equals(blockHash)) {
+        return PublishedL2Block.fromFields({
+          block,
+          l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
+          attestations: [],
+        });
+      }
+    }
+    return undefined;
+  }
+
+  public getPublishedBlockByArchive(archive: Fr): Promise<PublishedL2Block | undefined> {
+    const block = this.l2Blocks.find(b => b.archive.root.equals(archive));
+    if (!block) {
+      return Promise.resolve(undefined);
+    }
+    return Promise.resolve(
+      PublishedL2Block.fromFields({
+        block,
+        l1: new L1PublishedData(BigInt(block.number), BigInt(block.number), Buffer32.random().toString()),
+        attestations: [],
+      }),
+    );
+  }
+
+  public async getBlockHeaderByHash(blockHash: Fr): Promise<BlockHeader | undefined> {
+    for (const block of this.l2Blocks) {
+      const hash = await block.hash();
+      if (hash.equals(blockHash)) {
+        return block.getBlockHeader();
+      }
+    }
+    return undefined;
+  }
+
+  public getBlockHeaderByArchive(archive: Fr): Promise<BlockHeader | undefined> {
+    const block = this.l2Blocks.find(b => b.archive.root.equals(archive));
+    return Promise.resolve(block?.getBlockHeader());
+  }
+
   getBlockHeader(number: number | 'latest'): Promise<BlockHeader | undefined> {
-    return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.header);
+    return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.getBlockHeader());
   }
 
-  getBlocksForEpoch(epochNumber: bigint): Promise<L2Block[]> {
+  getCheckpointsForEpoch(epochNumber: EpochNumber): Promise<Checkpoint[]> {
+    // TODO: Implement this properly. This only works when we have one block per checkpoint.
+    return this.getBlocksForEpoch(epochNumber).then(blocks => blocks.map(b => b.toCheckpoint()));
+  }
+
+  getBlocksForEpoch(epochNumber: EpochNumber): Promise<L2Block[]> {
     const epochDuration = DefaultL1ContractsConfig.aztecEpochDuration;
     const [start, end] = getSlotRangeForEpoch(epochNumber, { epochDuration });
     const blocks = this.l2Blocks.filter(b => {
-      const slot = b.header.globalVariables.slotNumber.toBigInt();
+      const slot = b.header.globalVariables.slotNumber;
       return slot >= start && slot <= end;
     });
     return Promise.resolve(blocks);
   }
 
+  async getBlockHeadersForEpoch(epochNumber: EpochNumber): Promise<BlockHeader[]> {
+    const blocks = await this.getBlocksForEpoch(epochNumber);
+    return blocks.map(b => b.getBlockHeader());
+  }
+
   /**
    * Gets a tx effect.
-   * @param txHash - The hash of a transaction which resulted in the returned tx effect.
-   * @returns The requested tx effect.
+   * @param txHash - The hash of the tx corresponding to the tx effect.
+   * @returns The requested tx effect with block info (or undefined if not found).
    */
   public async getTxEffect(txHash: TxHash) {
     const match = this.l2Blocks
@@ -117,7 +273,12 @@ export class MockL2BlockSource implements L2BlockSource {
       return Promise.resolve(undefined);
     }
     const [txEffect, block] = match;
-    return { data: txEffect, l2BlockNumber: block.number, l2BlockHash: (await block.hash()).toString() };
+    return {
+      data: txEffect,
+      l2BlockNumber: block.number,
+      l2BlockHash: L2BlockHash.fromField(await block.hash()),
+      txIndexInBlock: block.body.txEffects.indexOf(txEffect),
+    };
   }
 
   /**
@@ -144,45 +305,69 @@ export class MockL2BlockSource implements L2BlockSource {
   }
 
   async getL2Tips(): Promise<L2Tips> {
-    const [latest, proven, finalized] = [
+    const [latest, proven, finalized, checkpointed] = [
       await this.getBlockNumber(),
       await this.getProvenBlockNumber(),
-      await this.getProvenBlockNumber(),
+      this.finalizedBlockNumber,
+      this.checkpointedBlockNumber,
     ] as const;
 
     const latestBlock = this.l2Blocks[latest - 1];
     const provenBlock = this.l2Blocks[proven - 1];
     const finalizedBlock = this.l2Blocks[finalized - 1];
+    const checkpointedBlock = this.l2Blocks[checkpointed - 1];
+
+    const latestBlockId = {
+      number: BlockNumber(latest),
+      hash: (await latestBlock?.hash())?.toString(),
+    };
+    const provenBlockId = {
+      number: BlockNumber(proven),
+      hash: (await provenBlock?.hash())?.toString(),
+    };
+    const finalizedBlockId = {
+      number: BlockNumber(finalized),
+      hash: (await finalizedBlock?.hash())?.toString(),
+    };
+    const checkpointedBlockId = {
+      number: BlockNumber(checkpointed),
+      hash: (await checkpointedBlock?.hash())?.toString(),
+    };
+
+    const makeTipId = (blockId: typeof latestBlockId) => ({
+      block: blockId,
+      checkpoint: { number: CheckpointNumber(blockId.number), hash: blockId.hash },
+    });
 
     return {
-      latest: {
-        number: latest,
-        hash: (await latestBlock?.hash())?.toString(),
-      },
-      proven: {
-        number: proven,
-        hash: (await provenBlock?.hash())?.toString(),
-      },
-      finalized: {
-        number: finalized,
-        hash: (await finalizedBlock?.hash())?.toString(),
-      },
+      proposed: latestBlockId,
+      checkpointed: makeTipId(checkpointedBlockId),
+      proven: makeTipId(provenBlockId),
+      finalized: makeTipId(finalizedBlockId),
     };
   }
 
-  getL2EpochNumber(): Promise<bigint> {
+  getL2EpochNumber(): Promise<EpochNumber> {
     throw new Error('Method not implemented.');
   }
 
-  getL2SlotNumber(): Promise<bigint> {
+  getL2SlotNumber(): Promise<SlotNumber> {
     throw new Error('Method not implemented.');
   }
 
-  isEpochComplete(_epochNumber: bigint): Promise<boolean> {
+  isEpochComplete(_epochNumber: EpochNumber): Promise<boolean> {
     throw new Error('Method not implemented.');
   }
 
   getL1Constants(): Promise<L1RollupConstants> {
+    return Promise.resolve(EmptyL1RollupConstants);
+  }
+
+  getGenesisValues(): Promise<{ genesisArchiveRoot: Fr }> {
+    return Promise.resolve({ genesisArchiveRoot: new Fr(GENESIS_ARCHIVE_ROOT) });
+  }
+
+  getL1Timestamp(): Promise<bigint> {
     throw new Error('Method not implemented.');
   }
 
@@ -191,6 +376,7 @@ export class MockL2BlockSource implements L2BlockSource {
    * @returns A promise that signals the initialization of the l2 block source on completion.
    */
   public start(): Promise<void> {
+    this.log.verbose('Starting mock L2 block source');
     return Promise.resolve();
   }
 
@@ -199,6 +385,43 @@ export class MockL2BlockSource implements L2BlockSource {
    * @returns A promise that signals the l2 block source is now stopped.
    */
   public stop(): Promise<void> {
+    this.log.verbose('Stopping mock L2 block source');
+    return Promise.resolve();
+  }
+
+  getContractClass(_id: Fr): Promise<ContractClassPublic | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  getBytecodeCommitment(_id: Fr): Promise<Fr | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  getContract(_address: AztecAddress, _timestamp?: UInt64): Promise<ContractInstanceWithAddress | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  getContractClassIds(): Promise<Fr[]> {
+    return Promise.resolve([]);
+  }
+
+  getDebugFunctionName(_address: AztecAddress, _selector: FunctionSelector): Promise<string | undefined> {
+    return Promise.resolve(undefined);
+  }
+
+  registerContractFunctionSignatures(_signatures: string[]): Promise<void> {
     return Promise.resolve();
   }
+
+  syncImmediate(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  isPendingChainInvalid(): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+
+  getPendingChainValidationStatus(): Promise<ValidateCheckpointResult> {
+    return Promise.resolve({ valid: true });
+  }
 }

package/src/test/mock_structs.ts

@@ -0,0 +1,50 @@
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
+import { randomBigInt, randomInt } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { InboxLeaf } from '@aztec/stdlib/messaging';
+
+import { type InboxMessage, updateRollingHash } from '../archiver/structs/inbox_message.js';
+
+export function makeInboxMessage(
+  previousRollingHash = Buffer16.ZERO,
+  overrides: Partial<InboxMessage> = {},
+): InboxMessage {
+  const { checkpointNumber = CheckpointNumber(randomInt(100) + 1) } = overrides;
+  const { l1BlockNumber = randomBigInt(100n) + 1n } = overrides;
+  const { l1BlockHash = Buffer32.random() } = overrides;
+  const { leaf = Fr.random() } = overrides;
+  const { rollingHash = updateRollingHash(previousRollingHash, leaf) } = overrides;
+  const { index = InboxLeaf.smallestIndexForCheckpoint(checkpointNumber) } = overrides;
+
+  return {
+    index,
+    leaf,
+    checkpointNumber,
+    l1BlockNumber,
+    l1BlockHash,
+    rollingHash,
+  };
+}
+
+export function makeInboxMessages(
+  count: number,
+  opts: {
+    initialHash?: Buffer16;
+    initialCheckpointNumber?: CheckpointNumber;
+    overrideFn?: (msg: InboxMessage, index: number) => InboxMessage;
+  } = {},
+): InboxMessage[] {
+  const { initialHash = Buffer16.ZERO, overrideFn = msg => msg, initialCheckpointNumber = 1 } = opts;
+  const messages: InboxMessage[] = [];
+  let rollingHash = initialHash;
+  for (let i = 0; i < count; i++) {
+    const leaf = Fr.random();
+    const checkpointNumber = CheckpointNumber(i + initialCheckpointNumber);
+    const message = overrideFn(makeInboxMessage(rollingHash, { leaf, checkpointNumber }), i);
+    rollingHash = message.rollingHash;
+    messages.push(message);
+  }
+
+  return messages;
+}

package/dest/archiver/data_retrieval.d.ts

@@ -1,74 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import type { BlobSinkClientInterface } from '@aztec/blob-sink/client';
-import type { ViemPublicClient } from '@aztec/ethereum';
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
-import { type Logger } from '@aztec/foundation/log';
-import { type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
-import { L2Block } from '@aztec/stdlib/block';
-import { InboxLeaf } from '@aztec/stdlib/messaging';
-import { Proof } from '@aztec/stdlib/proofs';
-import { type GetContractEventsReturnType, type GetContractReturnType, type Hex } from 'viem';
-import type { DataRetrieval } from './structs/data_retrieval.js';
-import type { L1Published } from './structs/published.js';
-/**
- * Fetches new L2 blocks.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param rollupAddress - The address of the rollup contract.
- * @param searchStartBlock - The block number to use for starting the search.
- * @param searchEndBlock - The highest block number that we should search up to.
- * @param expectedNextL2BlockNum - The next L2 block number that we expect to find.
- * @returns An array of block; as well as the next eth block to search from.
- */
-export declare function retrieveBlocksFromRollup(rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>, publicClient: ViemPublicClient, blobSinkClient: BlobSinkClientInterface, searchStartBlock: bigint, searchEndBlock: bigint, logger?: Logger): Promise<L1Published<L2Block>[]>;
-/**
- * Processes newly received L2BlockProposed logs.
- * @param rollup - The rollup contract
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param logs - L2BlockProposed logs.
- * @returns - An array blocks.
- */
-export declare function processL2BlockProposedLogs(rollup: GetContractReturnType<typeof RollupAbi, ViemPublicClient>, publicClient: ViemPublicClient, blobSinkClient: BlobSinkClientInterface, logs: GetContractEventsReturnType<typeof RollupAbi, 'L2BlockProposed'>, logger: Logger): Promise<L1Published<L2Block>[]>;
-export declare function getL1BlockTime(publicClient: ViemPublicClient, blockNumber: bigint): Promise<bigint>;
-/**
- * Fetch L1 to L2 messages.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param inboxAddress - The address of the inbox contract to fetch messages from.
- * @param blockUntilSynced - If true, blocks until the archiver has fully synced.
- * @param searchStartBlock - The block number to use for starting the search.
- * @param searchEndBlock - The highest block number that we should search up to.
- * @returns An array of InboxLeaf and next eth block to search from.
- */
-export declare function retrieveL1ToL2Messages(inbox: GetContractReturnType<typeof InboxAbi, ViemPublicClient>, searchStartBlock: bigint, searchEndBlock: bigint): Promise<DataRetrieval<InboxLeaf>>;
-/** Retrieves L2ProofVerified events from the rollup contract. */
-export declare function retrieveL2ProofVerifiedEvents(publicClient: ViemPublicClient, rollupAddress: EthAddress, searchStartBlock: bigint, searchEndBlock?: bigint): Promise<{
-    l1BlockNumber: bigint;
-    l2BlockNumber: bigint;
-    proverId: Fr;
-    txHash: Hex;
-}[]>;
-/** Retrieve submitted proofs from the rollup contract */
-export declare function retrieveL2ProofsFromRollup(publicClient: ViemPublicClient, rollupAddress: EthAddress, searchStartBlock: bigint, searchEndBlock?: bigint): Promise<DataRetrieval<{
-    proof: Proof;
-    proverId: Fr;
-    l2BlockNumber: bigint;
-    txHash: `0x${string}`;
-}>>;
-export type SubmitBlockProof = {
-    archiveRoot: Fr;
-    proverId: Fr;
-    aggregationObject: Buffer;
-    proof: Proof;
-};
-/**
- * Gets block metadata (header and archive snapshot) from the calldata of an L1 transaction.
- * Assumes that the block was published from an EOA.
- * TODO: Add retries and error management.
- * @param publicClient - The viem public client to use for transaction retrieval.
- * @param txHash - Hash of the tx that published it.
- * @param l2BlockNum - L2 block number.
- * @returns L2 block metadata (header and archive) from the calldata, deserialized
- */
-export declare function getProofFromSubmitProofTx(publicClient: ViemPublicClient, txHash: `0x${string}`, expectedProverId: Fr): Promise<SubmitBlockProof>;
-//# sourceMappingURL=data_retrieval.d.ts.map

package/dest/archiver/data_retrieval.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"data_retrieval.d.ts","sourceRoot":"","sources":["../../src/archiver/data_retrieval.ts"],"names":[],"mappings":";;AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AACvE,OAAO,KAAK,EAA6B,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEnF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAEhE,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAElE,OAAO,EAAgB,KAAK,QAAQ,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAC7E,OAAO,EAAQ,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAI7C,OAAO,EACL,KAAK,2BAA2B,EAChC,KAAK,qBAAqB,EAC1B,KAAK,GAAG,EAIT,MAAM,MAAM,CAAC;AAGd,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAmB,MAAM,wBAAwB,CAAC;AAE3E;;;;;;;;GAQG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,qBAAqB,CAAC,OAAO,SAAS,EAAE,gBAAgB,CAAC,EACjE,YAAY,EAAE,gBAAgB,EAC9B,cAAc,EAAE,uBAAuB,EACvC,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,MAAM,EACtB,MAAM,GAAE,MAAiC,GACxC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC,CAsCjC;AAED;;;;;;GAMG;AACH,wBAAsB,0BAA0B,CAC9C,MAAM,EAAE,qBAAqB,CAAC,OAAO,SAAS,EAAE,gBAAgB,CAAC,EACjE,YAAY,EAAE,gBAAgB,EAC9B,cAAc,EAAE,uBAAuB,EACvC,IAAI,EAAE,2BAA2B,CAAC,OAAO,SAAS,EAAE,iBAAiB,CAAC,EACtE,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC,CAoCjC;AAED,wBAAsB,cAAc,CAAC,YAAY,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAGzG;AAsID;;;;;;;;GAQG;AACH,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,qBAAqB,CAAC,OAAO,QAAQ,EAAE,gBAAgB,CAAC,EAC/D,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CA8BnC;AAED,iEAAiE;AACjE,wBAAsB,6BAA6B,CACjD,YAAY,EAAE,gBAAgB,EAC9B,aAAa,EAAE,UAAU,EACzB,gBAAgB,EAAE,MAAM,EACxB,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,EAAE,CAAC;IAAC,MAAM,EAAE,GAAG,CAAA;CAAE,EAAE,CAAC,CAexF;AAED,yDAAyD;AACzD,wBAAsB,0BAA0B,CAC9C,YAAY,EAAE,gBAAgB,EAC9B,aAAa,EAAE,UAAU,EACzB,gBAAgB,EAAE,MAAM,EACxB,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,aAAa,CAAC;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,EAAE,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,KAAK,MAAM,EAAE,CAAA;CAAE,CAAC,CAAC,CAatG;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,EAAE,CAAC;IAChB,QAAQ,EAAE,EAAE,CAAC;IACb,iBAAiB,EAAE,MAAM,CAAC;IAC1B,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAsB,yBAAyB,CAC7C,YAAY,EAAE,gBAAgB,EAC9B,MAAM,EAAE,KAAK,MAAM,EAAE,EACrB,gBAAgB,EAAE,EAAE,GACnB,OAAO,CAAC,gBAAgB,CAAC,CAuC3B"}