@aztec/prover-client 0.0.1-fake-c83136db25 → 0.0.1-fake-ceab37513c

package/dest/orchestrator/epoch-proving-state.js

@@ -1,8 +1,8 @@
-import { BatchedBlobAccumulator } from '@aztec/blob-lib';
 import { UnbalancedTreeStore } from '@aztec/foundation/trees';
-import { CheckpointMergeRollupPrivateInputs, CheckpointPaddingRollupPrivateInputs, RootRollupPrivateInputs } from '@aztec/stdlib/rollup';
-import { toProofData } from './block-building-helpers.js';
-import { CheckpointProvingState } from './checkpoint-proving-state.js';
+import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { BlockMergeRollupInputs, PreviousRollupBlockData, RootRollupInputs } from '@aztec/stdlib/rollup';
+import { VkData } from '@aztec/stdlib/vks';
+import { BlockProvingState } from './block-proving-state.js';
 var PROVING_STATE_LIFECYCLE = /*#__PURE__*/ function(PROVING_STATE_LIFECYCLE) {
     PROVING_STATE_LIFECYCLE[PROVING_STATE_LIFECYCLE["PROVING_STATE_CREATED"] = 0] = "PROVING_STATE_CREATED";
     PROVING_STATE_LIFECYCLE[PROVING_STATE_LIFECYCLE["PROVING_STATE_FULL"] = 1] = "PROVING_STATE_FULL";
@@ -17,180 +17,131 @@ var PROVING_STATE_LIFECYCLE = /*#__PURE__*/ function(PROVING_STATE_LIFECYCLE) {
  * Captures resolve and reject callbacks to provide a promise base interface to the consumer of our proving.
  */ export class EpochProvingState {
     epochNumber;
-    totalNumCheckpoints;
+    firstBlockNumber;
+    totalNumBlocks;
     finalBlobBatchingChallenges;
-    onCheckpointBlobAccumulatorSet;
     completionCallback;
     rejectionCallback;
-    checkpointProofs;
-    checkpointPaddingProof;
-    rootRollupProof;
-    checkpoints;
-    startBlobAccumulator;
-    endBlobAccumulator;
+    blockRootOrMergeProvingOutputs;
+    paddingBlockRootProvingOutput;
+    rootRollupProvingOutput;
     finalBatchedBlob;
     provingStateLifecycle;
-    // Map from tx hash to chonk verifier proof promise. Used when kickstarting chonk verifier proofs before tx processing.
-    cachedChonkVerifierProofs;
-    constructor(epochNumber, totalNumCheckpoints, finalBlobBatchingChallenges, onCheckpointBlobAccumulatorSet, completionCallback, rejectionCallback){
+    // Map from tx hash to tube proof promise. Used when kickstarting tube proofs before tx processing.
+    cachedTubeProofs;
+    blocks;
+    constructor(epochNumber, firstBlockNumber, totalNumBlocks, finalBlobBatchingChallenges, completionCallback, rejectionCallback){
         this.epochNumber = epochNumber;
-        this.totalNumCheckpoints = totalNumCheckpoints;
+        this.firstBlockNumber = firstBlockNumber;
+        this.totalNumBlocks = totalNumBlocks;
         this.finalBlobBatchingChallenges = finalBlobBatchingChallenges;
-        this.onCheckpointBlobAccumulatorSet = onCheckpointBlobAccumulatorSet;
         this.completionCallback = completionCallback;
         this.rejectionCallback = rejectionCallback;
-        this.checkpoints = [];
         this.provingStateLifecycle = 0;
-        this.cachedChonkVerifierProofs = new Map();
-        this.checkpointProofs = new UnbalancedTreeStore(totalNumCheckpoints);
-        this.startBlobAccumulator = BatchedBlobAccumulator.newWithChallenges(finalBlobBatchingChallenges);
+        this.cachedTubeProofs = new Map();
+        this.blocks = [];
+        this.blockRootOrMergeProvingOutputs = new UnbalancedTreeStore(totalNumBlocks);
     }
     // Adds a block to the proving state, returns its index
     // Will update the proving life cycle if this is the last block
-    startNewCheckpoint(checkpointIndex, constants, totalNumBlocks, totalNumBlobFields, previousBlockHeader, lastArchiveSiblingPath, l1ToL2Messages, lastL1ToL2MessageTreeSnapshot, lastL1ToL2MessageSubtreeRootSiblingPath, newL1ToL2MessageTreeSnapshot, newL1ToL2MessageSubtreeRootSiblingPath) {
-        if (checkpointIndex >= this.totalNumCheckpoints) {
-            throw new Error(`Unable to start a new checkpoint at index ${checkpointIndex}. Expected at most ${this.totalNumCheckpoints} checkpoints.`);
-        }
-        const checkpoint = new CheckpointProvingState(checkpointIndex, constants, totalNumBlocks, totalNumBlobFields, this.finalBlobBatchingChallenges, previousBlockHeader, lastArchiveSiblingPath, l1ToL2Messages, lastL1ToL2MessageTreeSnapshot, lastL1ToL2MessageSubtreeRootSiblingPath, newL1ToL2MessageTreeSnapshot, newL1ToL2MessageSubtreeRootSiblingPath, this, this.onCheckpointBlobAccumulatorSet);
-        this.checkpoints[checkpointIndex] = checkpoint;
-        if (this.checkpoints.filter((c)=>!!c).length === this.totalNumCheckpoints) {
+    startNewBlock(globalVariables, l1ToL2Messages, l1ToL2MessageTreeSnapshot, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchiveSnapshot, lastArchiveSiblingPath, newArchiveSiblingPath, previousBlockHeader, proverId) {
+        const index = globalVariables.blockNumber - this.firstBlockNumber;
+        const block = new BlockProvingState(index, globalVariables, l1ToL2Messages, l1ToL2MessageTreeSnapshot, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchiveSnapshot, lastArchiveSiblingPath, newArchiveSiblingPath, previousBlockHeader, proverId, this);
+        this.blocks[index] = block;
+        if (this.blocks.filter((b)=>!!b).length === this.totalNumBlocks) {
             this.provingStateLifecycle = 1;
         }
-        return checkpoint;
-    }
-    getCheckpointProvingState(index) {
-        return this.checkpoints[index];
-    }
-    getCheckpointProvingStateByBlockNumber(blockNumber) {
-        return this.checkpoints.find((c)=>c && blockNumber >= c.firstBlockNumber && blockNumber < c.firstBlockNumber + c.totalNumBlocks);
-    }
-    getBlockProvingStateByBlockNumber(blockNumber) {
-        return this.getCheckpointProvingStateByBlockNumber(blockNumber)?.getBlockProvingStateByBlockNumber(blockNumber);
+        return block;
     }
     // Returns true if this proving state is still valid, false otherwise
     verifyState() {
         return this.provingStateLifecycle === 0 || this.provingStateLifecycle === 1;
     }
-    // Returns true if we are still able to accept checkpoints, false otherwise.
-    isAcceptingCheckpoints() {
-        return this.checkpoints.filter((c)=>!!c).length < this.totalNumCheckpoints;
+    // Returns true if we are still able to accept blocks, false otherwise
+    isAcceptingBlocks() {
+        return this.provingStateLifecycle === 0;
     }
-    setCheckpointRootRollupProof(checkpointIndex, provingOutput) {
-        return this.checkpointProofs.setLeaf(checkpointIndex, {
-            provingOutput
-        });
-    }
-    tryStartProvingCheckpointMerge(location) {
-        if (this.checkpointProofs.getNode(location)?.isProving) {
-            return false;
-        } else {
-            this.checkpointProofs.setNode(location, {
-                isProving: true
-            });
-            return true;
-        }
-    }
-    setCheckpointMergeRollupProof(location, provingOutput) {
-        this.checkpointProofs.setNode(location, {
-            provingOutput
-        });
+    setBlockRootRollupProof(blockIndex, proof) {
+        return this.blockRootOrMergeProvingOutputs.setLeaf(blockIndex, proof);
     }
-    tryStartProvingRootRollup() {
-        if (this.rootRollupProof?.isProving) {
-            return false;
-        } else {
-            this.rootRollupProof = {
-                isProving: true
-            };
-            return true;
-        }
+    setBlockMergeRollupProof(location, proof) {
+        this.blockRootOrMergeProvingOutputs.setNode(location, proof);
     }
-    setRootRollupProof(provingOutput) {
-        this.rootRollupProof = {
-            provingOutput
-        };
+    setRootRollupProof(proof) {
+        this.rootRollupProvingOutput = proof;
     }
-    tryStartProvingPaddingCheckpoint() {
-        if (this.checkpointPaddingProof?.isProving) {
-            return false;
-        } else {
-            this.checkpointPaddingProof = {
-                isProving: true
-            };
-            return true;
-        }
+    setPaddingBlockRootProof(proof) {
+        this.paddingBlockRootProvingOutput = proof;
     }
-    setCheckpointPaddingProof(provingOutput) {
-        this.checkpointPaddingProof = {
-            provingOutput
-        };
+    setFinalBatchedBlob(batchedBlob) {
+        this.finalBatchedBlob = batchedBlob;
     }
-    async setBlobAccumulators() {
-        let previousAccumulator = this.startBlobAccumulator;
+    async setBlobAccumulators(toBlock) {
+        let previousAccumulator;
+        const end = toBlock ? toBlock - this.firstBlockNumber : this.blocks.length;
         // Accumulate blobs as far as we can for this epoch.
-        for(let i = 0; i < this.totalNumCheckpoints; i++){
-            const checkpoint = this.checkpoints[i];
-            if (!checkpoint) {
+        for(let i = 0; i <= end; i++){
+            const block = this.blocks[i];
+            if (!block || !block.block) {
                 break;
             }
-            const endAccumulator = checkpoint.getEndBlobAccumulator() || await checkpoint.accumulateBlobs(previousAccumulator);
-            if (!endAccumulator) {
-                break;
+            if (!block.startBlobAccumulator) {
+                // startBlobAccumulator always exists for firstBlockNumber, so the below should never assign an undefined:
+                block.setStartBlobAccumulator(previousAccumulator);
             }
-            previousAccumulator = endAccumulator;
-            // If this is the last checkpoint, set the end blob accumulator.
-            if (i === this.totalNumCheckpoints - 1) {
-                this.endBlobAccumulator = endAccumulator;
+            if (block.startBlobAccumulator && !block.endBlobAccumulator) {
+                await block.accumulateBlobs();
             }
+            previousAccumulator = block.endBlobAccumulator;
         }
     }
-    async finalizeBatchedBlob() {
-        if (!this.endBlobAccumulator) {
-            throw new Error('End blob accumulator not ready.');
-        }
-        this.finalBatchedBlob = await this.endBlobAccumulator.finalize(true);
-    }
     getParentLocation(location) {
-        return this.checkpointProofs.getParentLocation(location);
+        return this.blockRootOrMergeProvingOutputs.getParentLocation(location);
     }
-    getCheckpointMergeRollupInputs(mergeLocation) {
-        const [left, right] = this.checkpointProofs.getChildren(mergeLocation).map((c)=>c?.provingOutput);
+    getBlockMergeRollupInputs(mergeLocation) {
+        const [left, right] = this.blockRootOrMergeProvingOutputs.getChildren(mergeLocation);
         if (!left || !right) {
-            throw new Error('At least one child is not ready for the checkpoint merge rollup.');
+            throw new Error('At lease one child is not ready.');
         }
-        return new CheckpointMergeRollupPrivateInputs([
-            toProofData(left),
-            toProofData(right)
+        return new BlockMergeRollupInputs([
+            this.#getPreviousRollupData(left),
+            this.#getPreviousRollupData(right)
         ]);
     }
     getRootRollupInputs() {
         const [left, right] = this.#getChildProofsForRoot();
         if (!left || !right) {
-            throw new Error('At least one child is not ready for the root rollup.');
+            throw new Error('At lease one child is not ready.');
         }
-        return RootRollupPrivateInputs.from({
-            previousRollups: [
-                toProofData(left),
-                toProofData(right)
+        return RootRollupInputs.from({
+            previousRollupData: [
+                this.#getPreviousRollupData(left),
+                this.#getPreviousRollupData(right)
             ]
         });
     }
-    getPaddingCheckpointInputs() {
-        return new CheckpointPaddingRollupPrivateInputs();
+    getPaddingBlockRootInputs() {
+        if (!this.blocks[0]?.isComplete()) {
+            throw new Error('Epoch needs one completed block in order to be padded.');
+        }
+        return this.blocks[0].getPaddingBlockRootInputs();
+    }
+    // Returns a specific transaction proving state
+    getBlockProvingStateByBlockNumber(blockNumber) {
+        return this.blocks.find((block)=>block?.blockNumber === blockNumber);
     }
     getEpochProofResult() {
-        const provingOutput = this.rootRollupProof?.provingOutput;
-        if (!provingOutput || !this.finalBatchedBlob) {
+        if (!this.rootRollupProvingOutput || !this.finalBatchedBlob) {
             throw new Error('Unable to get epoch proof result. Root rollup is not ready.');
         }
         return {
-            proof: provingOutput.proof.binaryProof,
-            publicInputs: provingOutput.inputs,
+            proof: this.rootRollupProvingOutput.proof.binaryProof,
+            publicInputs: this.rootRollupProvingOutput.inputs,
             batchedBlobInputs: this.finalBatchedBlob
         };
     }
-    isReadyForCheckpointMerge(location) {
-        return !!this.checkpointProofs.getSibling(location)?.provingOutput;
+    isReadyForBlockMerge(location) {
+        return this.blockRootOrMergeProvingOutputs.getSibling(location) !== undefined;
     }
     // Returns true if we have sufficient inputs to execute the block root rollup
     isReadyForRootRollup() {
@@ -225,9 +176,14 @@ var PROVING_STATE_LIFECYCLE = /*#__PURE__*/ function(PROVING_STATE_LIFECYCLE) {
             index: 0
         };
         // If there's only 1 block, its block root proof will be stored at the root.
-        return this.totalNumCheckpoints === 1 ? [
-            this.checkpointProofs.getNode(rootLocation)?.provingOutput,
-            this.checkpointPaddingProof?.provingOutput
-        ] : this.checkpointProofs.getChildren(rootLocation).map((c)=>c?.provingOutput);
+        return this.totalNumBlocks === 1 ? [
+            this.blockRootOrMergeProvingOutputs.getNode(rootLocation),
+            this.paddingBlockRootProvingOutput
+        ] : this.blockRootOrMergeProvingOutputs.getChildren(rootLocation);
+    }
+    #getPreviousRollupData({ inputs, proof, verificationKey }) {
+        const leafIndex = getVKIndex(verificationKey.keyAsFields);
+        const vkData = new VkData(verificationKey, leafIndex, getVKSiblingPath(leafIndex));
+        return new PreviousRollupBlockData(inputs, proof, vkData);
     }
 }

package/dest/orchestrator/orchestrator.d.ts

@@ -1,13 +1,10 @@
-import { BatchedBlob, FinalBlobBatchingChallenges } from '@aztec/blob-lib';
+import { FinalBlobBatchingChallenges } from '@aztec/blob-lib';
 import { Fr } from '@aztec/foundation/fields';
-import { EthAddress } from '@aztec/stdlib/block';
+import { EthAddress, L2Block } from '@aztec/stdlib/block';
 import type { EpochProver, ForkMerkleTreeOperations, ServerCircuitProver } from '@aztec/stdlib/interfaces/server';
-import type { Proof } from '@aztec/stdlib/proofs';
-import { CheckpointConstantData, RootRollupPublicInputs } from '@aztec/stdlib/rollup';
-import type { BlockHeader, ProcessedTx, Tx } from '@aztec/stdlib/tx';
-import type { UInt64 } from '@aztec/stdlib/types';
+import { type AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
+import { type BlockHeader, type GlobalVariables, type ProcessedTx, type Tx } from '@aztec/stdlib/tx';
 import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
-import type { BlockProvingState } from './block-proving-state.js';
 /**
  * Implements an event driven proving scheduler to build the recursive proof tree. The idea being:
  * 1. Transactions are provided to the scheduler post simulation.
@@ -34,33 +31,33 @@ export declare class ProvingOrchestrator implements EpochProver {
     get tracer(): Tracer;
     getProverId(): EthAddress;
     stop(): Promise<void>;
-    startNewEpoch(epochNumber: number, totalNumCheckpoints: number, finalBlobBatchingChallenges: FinalBlobBatchingChallenges): void;
-    startNewCheckpoint(checkpointIndex: number, constants: CheckpointConstantData, l1ToL2Messages: Fr[], totalNumBlocks: number, totalNumBlobFields: number, headerOfLastBlockInPreviousCheckpoint: BlockHeader): Promise<void>;
+    startNewEpoch(epochNumber: number, firstBlockNumber: number, totalNumBlocks: number, finalBlobBatchingChallenges: FinalBlobBatchingChallenges): void;
     /**
      * Starts off a new block
-     * @param blockNumber - The block number
-     * @param timestamp - The timestamp of the block. This is only required for constructing the private inputs for the
-     * block that doesn't have any txs.
-     * @param totalNumTxs - The total number of txs in the block
+     * @param globalVariables - The global variables for the block
+     * @param l1ToL2Messages - The l1 to l2 messages for the block
+     * @returns A proving ticket, containing a promise notifying of proving completion
      */
-    startNewBlock(blockNumber: number, timestamp: UInt64, totalNumTxs: number): Promise<void>;
+    startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[], previousBlockHeader: BlockHeader): Promise<void>;
     /**
      * The interface to add simulated transactions to the scheduler. This can only be called once per block.
      * @param txs - The transactions to be proven
      */
     addTxs(txs: ProcessedTx[]): Promise<void>;
     /**
-     * Kickstarts chonk verifier circuits for the specified txs. These will be used during epoch proving.
-     * Note that if the chonk verifier circuits are not started this way, they will be started nontheless after processing.
+     * Kickstarts tube circuits for the specified txs. These will be used during epoch proving.
+     * Note that if the tube circuits are not started this way, they will be started nontheless after processing.
      */
-    startChonkVerifierCircuits(txs: Tx[]): Promise<void>;
+    startTubeCircuits(txs: Tx[]): Promise<void>;
     /**
      * Marks the block as completed.
      * Computes the block header and updates the archive tree.
      */
-    setBlockCompleted(blockNumber: number, expectedHeader?: BlockHeader): Promise<BlockHeader>;
-    private buildL2BlockHeader;
-    protected verifyBuiltBlockAgainstSyncedState(provingState: BlockProvingState): Promise<void>;
+    setBlockCompleted(blockNumber: number, expectedHeader?: BlockHeader): Promise<L2Block>;
+    /** Returns the block as built for a given index. */
+    getBlock(index: number): L2Block;
+    private buildBlock;
+    protected verifyBuiltBlockAgainstSyncedState(l2Block: L2Block, newArchive: AppendOnlyTreeSnapshot): Promise<void>;
     /**
      * Cancel any further proving
      */
@@ -69,10 +66,16 @@ export declare class ProvingOrchestrator implements EpochProver {
      * Returns the proof for the current epoch.
      */
     finalizeEpoch(): Promise<{
-        publicInputs: RootRollupPublicInputs;
-        proof: Proof;
-        batchedBlobInputs: BatchedBlob;
+        proof: import("@aztec/stdlib/proofs").Proof;
+        publicInputs: import("@aztec/stdlib/rollup").RootRollupPublicInputs;
+        batchedBlobInputs: import("@aztec/blob-lib").BatchedBlob;
     }>;
+    /**
+     * Starts the proving process for the given transaction and adds it to our state
+     * @param tx - The transaction whose proving we wish to commence
+     * @param provingState - The proving state being worked on
+     */
+    private prepareTransaction;
     /**
      * Enqueue a job to be scheduled
      * @param provingState - The proving state object being operated on
@@ -80,26 +83,22 @@ export declare class ProvingOrchestrator implements EpochProver {
      * @param job - The actual job, returns a promise notifying of the job's completion
      */
     private deferredProving;
-    private updateL1ToL2MessageTree;
+    private prepareBaseParityInputs;
     private prepareBaseRollupInputs;
     private enqueueBaseRollup;
-    private getOrEnqueueChonkVerifier;
-    private doEnqueueChonkVerifier;
+    private getOrEnqueueTube;
+    private doEnqueueTube;
     private enqueueMergeRollup;
     private enqueueBlockRootRollup;
     private enqueueBaseParityCircuit;
     private checkAndEnqueueRootParityCircuit;
     private enqueueRootParityCircuit;
     private enqueueBlockMergeRollup;
-    private enqueueCheckpointRootRollup;
-    private enqueueCheckpointMergeRollup;
     private enqueueEpochPadding;
     private enqueueRootRollup;
     private checkAndEnqueueNextMergeRollup;
     private checkAndEnqueueBlockRootRollup;
     private checkAndEnqueueNextBlockMergeRollup;
-    private checkAndEnqueueCheckpointRootRollup;
-    private checkAndEnqueueNextCheckpointMergeRollup;
     private checkAndEnqueueRootRollup;
     /**
      * Executes the VM circuit for a public function, will enqueue the corresponding kernel if the
@@ -108,6 +107,6 @@ export declare class ProvingOrchestrator implements EpochProver {
      * @param txIndex - The index of the transaction being proven
      */
     private enqueueVM;
-    private checkAndEnqueueBaseRollup;
+    private checkAndEnqueueNextTxCircuit;
 }
 //# sourceMappingURL=orchestrator.d.ts.map

package/dest/orchestrator/orchestrator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../src/orchestrator/orchestrator.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../src/orchestrator/orchestrator.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AAU3F,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAS9C,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EACV,WAAW,EACX,wBAAwB,EAGxB,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AAUzC,OAAO,EAAE,KAAK,sBAAsB,EAAgB,MAAM,qBAAqB,CAAC;AAChF,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,EAAE,EAAmB,MAAM,kBAAkB,CAAC;AACtH,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,MAAM,EAIZ,MAAM,yBAAyB,CAAC;AAqBjC;;;;;;;;;GASG;AAEH;;GAEG;AACH,qBAAa,mBAAoB,YAAW,WAAW;IASnD,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAV3B,OAAO,CAAC,YAAY,CAA4C;IAChE,OAAO,CAAC,kBAAkB,CAAyB;IAEnD,OAAO,CAAC,cAAc,CAAiD;IACvE,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,GAAG,CAAqD;gBAGtD,UAAU,EAAE,wBAAwB,EACpC,MAAM,EAAE,mBAAmB,EAClB,QAAQ,EAAE,UAAU,EACrC,eAAe,GAAE,eAAsC;IAKzD,IAAI,MAAM,IAAI,MAAM,CAEnB;IAEM,WAAW,IAAI,UAAU;IAIzB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAKrB,aAAa,CAClB,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,MAAM,EACtB,2BAA2B,EAAE,2BAA2B;IAmB1D;;;;;OAKG;IAIU,aAAa,CAAC,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,EAAE,EAAE,EAAE,mBAAmB,EAAE,WAAW;IA+CnH;;;OAGG;IAIU,MAAM,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAiDtD;;;OAGG;IAEI,iBAAiB,CAAC,GAAG,EAAE,EAAE,EAAE;IAelC;;;OAGG;IAIU,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IA4BnG,oDAAoD;IAC7C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;YAQzB,UAAU;cAqCR,kCAAkC,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,sBAAsB;IAWvG;;OAEG;IACI,MAAM;IAQb;;OAEG;IACU,aAAa;;;;;IA6B1B;;;;OAIG;YACW,kBAAkB;IAShC;;;;;OAKG;IACH,OAAO,CAAC,eAAe;YAwDT,uBAAuB;YAkCvB,uBAAuB;IAyCrC,OAAO,CAAC,iBAAiB;IA8CzB,OAAO,CAAC,gBAAgB;IA0BxB,OAAO,CAAC,aAAa;IA4BrB,OAAO,CAAC,kBAAkB;YA0BZ,sBAAsB;IAgFpC,OAAO,CAAC,wBAAwB;IAuBhC,OAAO,CAAC,gCAAgC;IAUxC,OAAO,CAAC,wBAAwB;IA2BhC,OAAO,CAAC,uBAAuB;IAwB/B,OAAO,CAAC,mBAAmB;IA6B3B,OAAO,CAAC,iBAAiB;YA4BX,8BAA8B;YAa9B,8BAA8B;IA2B5C,OAAO,CAAC,mCAAmC;IAa3C,OAAO,CAAC,yBAAyB;IASjC;;;;;OAKG;IACH,OAAO,CAAC,SAAS;IAoDjB,OAAO,CAAC,4BAA4B;CAWrC"}