@aztec/simulator 0.0.0-test.0

package/dest/public/public_db_sources.d.ts

@@ -0,0 +1,129 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { FunctionSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type ContractClassPublic, type ContractDataSource, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import type { MerkleTreeCheckpointOperations, MerkleTreeReadOperations, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import type { Tx } from '@aztec/stdlib/tx';
+import type { PublicContractsDB, PublicStateDB } from '../common/db_interfaces.js';
+/**
+ * Implements the PublicContractsDB using a ContractDataSource.
+ * Progressively records contracts in transaction as they are processed in a block.
+ * Separates block-level contract information (from processed/included txs) from the
+ * current tx's contract information (which may be cleared on tx revert/death).
+ */
+export declare class ContractsDataSourcePublicDB implements PublicContractsDB {
+    private dataSource;
+    private currentTxNonRevertibleCache;
+    private currentTxRevertibleCache;
+    private blockCache;
+    private bytecodeCommitmentCache;
+    private log;
+    constructor(dataSource: ContractDataSource);
+    /**
+     * Add new contracts from a transaction
+     * @param tx - The transaction to add contracts from.
+     */
+    addNewContracts(tx: Tx): Promise<void>;
+    /**
+     * Add non revertible contracts from a transaction
+     * @param tx - The transaction to add non revertible contracts from.
+     */
+    addNewNonRevertibleContracts(tx: Tx): Promise<void>;
+    /**
+     * Add revertible contracts from a transaction
+     * @param tx - The transaction to add revertible contracts from.
+     */
+    addNewRevertibleContracts(tx: Tx): Promise<void>;
+    /**
+     * Add non-revertible contract classes from a transaction
+     * For private-only txs, this will be all contract classes (found in tx.data.forPublic)
+     * @param tx - The transaction to add non-revertible contract classes from.
+     */
+    private addNonRevertibleContractClasses;
+    /**
+     * Add revertible contract classes from a transaction
+     * None for private-only txs.
+     * @param tx - The transaction to add revertible contract classes from.
+     */
+    private addRevertibleContractClasses;
+    /**
+     * Add non-revertible contract instances from a transaction
+     * For private-only txs, this will be all contract instances (found in tx.data.forRollup)
+     * @param tx - The transaction to add non-revertible contract instances from.
+     */
+    private addNonRevertibleContractInstances;
+    /**
+     * Add revertible contract instances from a transaction
+     * None for private-only txs.
+     * @param tx - The transaction to add revertible contract instances from.
+     */
+    private addRevertibleContractInstances;
+    /**
+     * Given a tx's siloed contract class logs, add the contract classes to the cache
+     * @param siloedContractClassLogs - Contract class logs to process
+     * @param cache - The cache to store the contract classes in
+     * @param cacheType - Type of cache (for logging)
+     */
+    private addContractClassesFromLogs;
+    /**
+     * Given a tx's contract instance logs, add the contract instances to the cache
+     * @param contractInstanceLogs - Contract instance logs to process
+     * @param cache - The cache to store the contract instances in
+     * @param cacheType - Type of cache (for logging)
+     */
+    private addContractInstancesFromLogs;
+    /**
+     * Clear new contracts from the current tx's cache
+     */
+    clearContractsForTx(): void;
+    /**
+     * Commits the current transaction's cached contracts to the block-level cache.
+     * Then, clears the tx cache.
+     */
+    commitContractsForTx(onlyNonRevertibles?: boolean): void;
+    getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined>;
+    getContractClass(contractClassId: Fr): Promise<ContractClassPublic | undefined>;
+    getBytecodeCommitment(contractClassId: Fr): Promise<Fr | undefined>;
+    getDebugFunctionName(address: AztecAddress, selector: FunctionSelector): Promise<string | undefined>;
+}
+/**
+ * A public state DB that reads and writes to the world state.
+ */
+export declare class WorldStateDB extends ContractsDataSourcePublicDB implements PublicStateDB, MerkleTreeCheckpointOperations {
+    db: MerkleTreeWriteOperations;
+    private logger;
+    constructor(db: MerkleTreeWriteOperations, dataSource: ContractDataSource);
+    /**
+     * Checkpoints the current fork state
+     */
+    createCheckpoint(): Promise<void>;
+    /**
+     * Commits the current checkpoint
+     */
+    commitCheckpoint(): Promise<void>;
+    /**
+     * Reverts the current checkpoint
+     */
+    revertCheckpoint(): Promise<void>;
+    getMerkleInterface(): MerkleTreeWriteOperations;
+    /**
+     * Reads a value from public storage, returning zero if none.
+     * @param contract - Owner of the storage.
+     * @param slot - Slot to read in the contract storage.
+     * @returns The current value in the storage slot.
+     */
+    storageRead(contract: AztecAddress, slot: Fr): Promise<Fr>;
+    /**
+     * Records a write to public storage.
+     * @param contract - Owner of the storage.
+     * @param slot - Slot to read in the contract storage.
+     * @param newValue - The new value to store.
+     * @returns The slot of the written leaf in the public data tree.
+     */
+    storageWrite(contract: AztecAddress, slot: Fr, newValue: Fr): Promise<void>;
+    getL1ToL2LeafValue(leafIndex: bigint): Promise<Fr | undefined>;
+    getCommitmentValue(leafIndex: bigint): Promise<Fr | undefined>;
+    getNullifierIndex(nullifier: Fr): Promise<bigint | undefined>;
+}
+export declare function readPublicState(db: MerkleTreeReadOperations, contract: AztecAddress, slot: Fr): Promise<Fr>;
+//# sourceMappingURL=public_db_sources.d.ts.map

package/dest/public/public_db_sources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public_db_sources.d.ts","sourceRoot":"","sources":["../../src/public/public_db_sources.ts"],"names":[],"mappings":"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"}

package/dest/public/public_db_sources.js

@@ -0,0 +1,264 @@
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import { ContractClassRegisteredEvent } from '@aztec/protocol-contracts/class-registerer';
+import { ContractInstanceDeployedEvent } from '@aztec/protocol-contracts/instance-deployer';
+import { PublicDataWrite } from '@aztec/stdlib/avm';
+import { computePublicBytecodeCommitment } from '@aztec/stdlib/contract';
+import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { TxContractCache } from './tx_contract_cache.js';
+/**
+ * Implements the PublicContractsDB using a ContractDataSource.
+ * Progressively records contracts in transaction as they are processed in a block.
+ * Separates block-level contract information (from processed/included txs) from the
+ * current tx's contract information (which may be cleared on tx revert/death).
+ */ export class ContractsDataSourcePublicDB {
+    dataSource;
+    // Two caching layers for contract classes and instances.
+    // Tx-level cache:
+    //   - The current tx's new contract information is cached
+    //     in currentTxNonRevertibleCache and currentTxRevertibleCache.
+    // Block-level cache:
+    //   - Contract information from earlier in the block, usable by later txs.
+    // When a tx succeeds, that tx's caches are merged into the block cache and cleared.
+    currentTxNonRevertibleCache;
+    currentTxRevertibleCache;
+    blockCache;
+    // Separate flat cache for bytecode commitments.
+    bytecodeCommitmentCache;
+    log;
+    constructor(dataSource){
+        this.dataSource = dataSource;
+        this.currentTxNonRevertibleCache = new TxContractCache();
+        this.currentTxRevertibleCache = new TxContractCache();
+        this.blockCache = new TxContractCache();
+        this.bytecodeCommitmentCache = new Map();
+        this.log = createLogger('simulator:contracts-data-source');
+    }
+    /**
+   * Add new contracts from a transaction
+   * @param tx - The transaction to add contracts from.
+   */ async addNewContracts(tx) {
+        await this.addNonRevertibleContractClasses(tx);
+        await this.addRevertibleContractClasses(tx);
+        this.addNonRevertibleContractInstances(tx);
+        this.addRevertibleContractInstances(tx);
+    }
+    /**
+   * Add non revertible contracts from a transaction
+   * @param tx - The transaction to add non revertible contracts from.
+   */ async addNewNonRevertibleContracts(tx) {
+        await this.addNonRevertibleContractClasses(tx);
+        this.addNonRevertibleContractInstances(tx);
+    }
+    /**
+   * Add revertible contracts from a transaction
+   * @param tx - The transaction to add revertible contracts from.
+   */ async addNewRevertibleContracts(tx) {
+        await this.addRevertibleContractClasses(tx);
+        this.addRevertibleContractInstances(tx);
+    }
+    /**
+   * Add non-revertible contract classes from a transaction
+   * For private-only txs, this will be all contract classes (found in tx.data.forPublic)
+   * @param tx - The transaction to add non-revertible contract classes from.
+   */ async addNonRevertibleContractClasses(tx) {
+        const siloedContractClassLogs = tx.data.forPublic ? await tx.filterContractClassLogs(tx.data.forPublic.nonRevertibleAccumulatedData.contractClassLogsHashes, /*siloed=*/ true) : await tx.filterContractClassLogs(tx.data.forRollup.end.contractClassLogsHashes, /*siloed=*/ true);
+        await this.addContractClassesFromLogs(siloedContractClassLogs, this.currentTxNonRevertibleCache, 'non-revertible');
+    }
+    /**
+   * Add revertible contract classes from a transaction
+   * None for private-only txs.
+   * @param tx - The transaction to add revertible contract classes from.
+   */ async addRevertibleContractClasses(tx) {
+        const siloedContractClassLogs = tx.data.forPublic ? await tx.filterContractClassLogs(tx.data.forPublic.revertibleAccumulatedData.contractClassLogsHashes, /*siloed=*/ true) : [];
+        await this.addContractClassesFromLogs(siloedContractClassLogs, this.currentTxRevertibleCache, 'revertible');
+    }
+    /**
+   * Add non-revertible contract instances from a transaction
+   * For private-only txs, this will be all contract instances (found in tx.data.forRollup)
+   * @param tx - The transaction to add non-revertible contract instances from.
+   */ addNonRevertibleContractInstances(tx) {
+        const contractInstanceLogs = tx.data.forPublic ? tx.data.forPublic.nonRevertibleAccumulatedData.privateLogs.filter((l)=>!l.isEmpty()) : tx.data.forRollup.end.privateLogs.filter((l)=>!l.isEmpty());
+        this.addContractInstancesFromLogs(contractInstanceLogs, this.currentTxNonRevertibleCache, 'non-revertible');
+    }
+    /**
+   * Add revertible contract instances from a transaction
+   * None for private-only txs.
+   * @param tx - The transaction to add revertible contract instances from.
+   */ addRevertibleContractInstances(tx) {
+        const contractInstanceLogs = tx.data.forPublic ? tx.data.forPublic.revertibleAccumulatedData.privateLogs.filter((l)=>!l.isEmpty()) : [];
+        this.addContractInstancesFromLogs(contractInstanceLogs, this.currentTxRevertibleCache, 'revertible');
+    }
+    /**
+   * Given a tx's siloed contract class logs, add the contract classes to the cache
+   * @param siloedContractClassLogs - Contract class logs to process
+   * @param cache - The cache to store the contract classes in
+   * @param cacheType - Type of cache (for logging)
+   */ async addContractClassesFromLogs(siloedContractClassLogs, cache, cacheType) {
+        const contractClassEvents = siloedContractClassLogs.filter((log)=>ContractClassRegisteredEvent.isContractClassRegisteredEvent(log)).map((log)=>ContractClassRegisteredEvent.fromLog(log));
+        // Cache contract classes
+        await Promise.all(contractClassEvents.map(async (event)=>{
+            this.log.debug(`Adding class ${event.contractClassId.toString()} to contract's ${cacheType} tx cache`);
+            const contractClass = await event.toContractClassPublic();
+            cache.addClass(event.contractClassId, contractClass);
+        }));
+    }
+    /**
+   * Given a tx's contract instance logs, add the contract instances to the cache
+   * @param contractInstanceLogs - Contract instance logs to process
+   * @param cache - The cache to store the contract instances in
+   * @param cacheType - Type of cache (for logging)
+   */ addContractInstancesFromLogs(contractInstanceLogs, cache, cacheType) {
+        const contractInstanceEvents = contractInstanceLogs.filter((log)=>ContractInstanceDeployedEvent.isContractInstanceDeployedEvent(log)).map((log)=>ContractInstanceDeployedEvent.fromLog(log));
+        // Cache contract instances
+        contractInstanceEvents.forEach((e)=>{
+            this.log.debug(`Adding instance ${e.address.toString()} with class ${e.contractClassId.toString()} to ${cacheType} tx contract cache`);
+            cache.addInstance(e.address, e.toContractInstance());
+        });
+    }
+    /**
+   * Clear new contracts from the current tx's cache
+   */ clearContractsForTx() {
+        this.currentTxRevertibleCache.clear();
+        this.currentTxRevertibleCache.clear();
+        this.currentTxNonRevertibleCache.clear();
+    }
+    /**
+   * Commits the current transaction's cached contracts to the block-level cache.
+   * Then, clears the tx cache.
+   */ commitContractsForTx(onlyNonRevertibles = false) {
+        // Merge non-revertible tx cache into block cache
+        this.blockCache.mergeFrom(this.currentTxNonRevertibleCache);
+        if (!onlyNonRevertibles) {
+            // Merge revertible tx cache into block cache
+            this.blockCache.mergeFrom(this.currentTxRevertibleCache);
+        }
+        // Clear the tx's caches
+        this.currentTxNonRevertibleCache.clear();
+        this.currentTxRevertibleCache.clear();
+    }
+    async getContractInstance(address) {
+        // Check caches in order: tx revertible -> tx non-revertible -> block -> data source
+        return this.currentTxRevertibleCache.getInstance(address) ?? this.currentTxNonRevertibleCache.getInstance(address) ?? this.blockCache.getInstance(address) ?? await this.dataSource.getContract(address);
+    }
+    async getContractClass(contractClassId) {
+        // Check caches in order: tx revertible -> tx non-revertible -> block -> data source
+        return this.currentTxRevertibleCache.getClass(contractClassId) ?? this.currentTxNonRevertibleCache.getClass(contractClassId) ?? this.blockCache.getClass(contractClassId) ?? await this.dataSource.getContractClass(contractClassId);
+    }
+    async getBytecodeCommitment(contractClassId) {
+        // Try and retrieve from cache
+        const key = contractClassId.toString();
+        const result = this.bytecodeCommitmentCache.get(key);
+        if (result !== undefined) {
+            return result;
+        }
+        // Now try from the store
+        const fromStore = await this.dataSource.getBytecodeCommitment(contractClassId);
+        if (fromStore !== undefined) {
+            this.bytecodeCommitmentCache.set(key, fromStore);
+            return fromStore;
+        }
+        // Not in either the store or the cache, build it here and cache
+        const contractClass = await this.getContractClass(contractClassId);
+        if (contractClass === undefined) {
+            return undefined;
+        }
+        const value = await computePublicBytecodeCommitment(contractClass.packedBytecode);
+        this.bytecodeCommitmentCache.set(key, value);
+        return value;
+    }
+    async getDebugFunctionName(address, selector) {
+        return await this.dataSource.getContractFunctionName(address, selector);
+    }
+}
+/**
+ * A public state DB that reads and writes to the world state.
+ */ export class WorldStateDB extends ContractsDataSourcePublicDB {
+    db;
+    logger;
+    constructor(db, dataSource){
+        super(dataSource), this.db = db, this.logger = createLogger('simulator:world-state-db');
+    }
+    /**
+   * Checkpoints the current fork state
+   */ async createCheckpoint() {
+        await this.db.createCheckpoint();
+    }
+    /**
+   * Commits the current checkpoint
+   */ async commitCheckpoint() {
+        await this.db.commitCheckpoint();
+    }
+    /**
+   * Reverts the current checkpoint
+   */ async revertCheckpoint() {
+        await this.db.revertCheckpoint();
+    }
+    getMerkleInterface() {
+        return this.db;
+    }
+    /**
+   * Reads a value from public storage, returning zero if none.
+   * @param contract - Owner of the storage.
+   * @param slot - Slot to read in the contract storage.
+   * @returns The current value in the storage slot.
+   */ async storageRead(contract, slot) {
+        return await readPublicState(this.db, contract, slot);
+    }
+    /**
+   * Records a write to public storage.
+   * @param contract - Owner of the storage.
+   * @param slot - Slot to read in the contract storage.
+   * @param newValue - The new value to store.
+   * @returns The slot of the written leaf in the public data tree.
+   */ async storageWrite(contract, slot, newValue) {
+        const leafSlot = await computePublicDataTreeLeafSlot(contract, slot);
+        const publicDataWrite = new PublicDataWrite(leafSlot, newValue);
+        await this.db.sequentialInsert(MerkleTreeId.PUBLIC_DATA_TREE, [
+            publicDataWrite.toBuffer()
+        ]);
+    }
+    async getL1ToL2LeafValue(leafIndex) {
+        const timer = new Timer();
+        const leafValue = await this.db.getLeafValue(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, leafIndex);
+        this.logger.debug(`[DB] Fetched L1 to L2 message leaf value`, {
+            eventName: 'public-db-access',
+            duration: timer.ms(),
+            operation: 'get-l1-to-l2-message-leaf-value'
+        });
+        return leafValue;
+    }
+    async getCommitmentValue(leafIndex) {
+        const timer = new Timer();
+        const leafValue = await this.db.getLeafValue(MerkleTreeId.NOTE_HASH_TREE, leafIndex);
+        this.logger.debug(`[DB] Fetched commitment leaf value`, {
+            eventName: 'public-db-access',
+            duration: timer.ms(),
+            operation: 'get-commitment-leaf-value'
+        });
+        return leafValue;
+    }
+    async getNullifierIndex(nullifier) {
+        const timer = new Timer();
+        const index = (await this.db.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, [
+            nullifier.toBuffer()
+        ]))[0];
+        this.logger.debug(`[DB] Fetched nullifier index`, {
+            eventName: 'public-db-access',
+            duration: timer.ms(),
+            operation: 'get-nullifier-index'
+        });
+        return index;
+    }
+}
+export async function readPublicState(db, contract, slot) {
+    const leafSlot = (await computePublicDataTreeLeafSlot(contract, slot)).toBigInt();
+    const lowLeafResult = await db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+    if (!lowLeafResult || !lowLeafResult.alreadyPresent) {
+        return Fr.ZERO;
+    }
+    const preimage = await db.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
+    return preimage.value;
+}

package/dest/public/public_processor/public_processor.d.ts

@@ -0,0 +1,74 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { type DateProvider } from '@aztec/foundation/timer';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import { Gas } from '@aztec/stdlib/gas';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { type FailedTx, GlobalVariables, NestedProcessReturnValues, type ProcessedTx, Tx, type TxValidator } from '@aztec/stdlib/tx';
+import { type TelemetryClient, type Traceable, type Tracer } from '@aztec/telemetry-client';
+import { WorldStateDB } from '../public_db_sources.js';
+import { PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
+/**
+ * Creates new instances of PublicProcessor given the provided merkle tree db and contract data source.
+ */
+export declare class PublicProcessorFactory {
+    private contractDataSource;
+    private dateProvider;
+    private telemetryClient;
+    constructor(contractDataSource: ContractDataSource, dateProvider: DateProvider, telemetryClient?: TelemetryClient);
+    /**
+     * Creates a new instance of a PublicProcessor.
+     * @param historicalHeader - The header of a block previous to the one in which the tx is included.
+     * @param globalVariables - The global variables for the block being processed.
+     * @param skipFeeEnforcement - Allows disabling balance checks for fee estimations.
+     * @returns A new instance of a PublicProcessor.
+     */
+    create(merkleTree: MerkleTreeWriteOperations, globalVariables: GlobalVariables, skipFeeEnforcement: boolean): PublicProcessor;
+    protected createPublicTxSimulator(db: MerkleTreeWriteOperations, worldStateDB: WorldStateDB, globalVariables: GlobalVariables, doMerkleOperations: boolean, skipFeeEnforcement: boolean, telemetryClient: TelemetryClient): PublicTxSimulator;
+}
+/**
+ * Converts Txs lifted from the P2P module into ProcessedTx objects by executing
+ * any public function calls in them. Txs with private calls only are unaffected.
+ */
+export declare class PublicProcessor implements Traceable {
+    protected db: MerkleTreeWriteOperations;
+    protected globalVariables: GlobalVariables;
+    protected worldStateDB: WorldStateDB;
+    protected publicTxSimulator: PublicTxSimulator;
+    private dateProvider;
+    private log;
+    private metrics;
+    constructor(db: MerkleTreeWriteOperations, globalVariables: GlobalVariables, worldStateDB: WorldStateDB, publicTxSimulator: PublicTxSimulator, dateProvider: DateProvider, telemetryClient?: TelemetryClient, log?: import("@aztec/foundation/log").Logger);
+    get tracer(): Tracer;
+    /**
+     * Run each tx through the public circuit and the public kernel circuit if needed.
+     * @param txs - Txs to process.
+     * @param processedTxHandler - Handler for processed txs in the context of block building or proving.
+     * @returns The list of processed txs with their circuit simulation outputs.
+     */
+    process(txs: Iterable<Tx> | AsyncIterable<Tx>, limits?: {
+        maxTransactions?: number;
+        maxBlockSize?: number;
+        maxBlockGas?: Gas;
+        deadline?: Date;
+    }, validators?: {
+        preprocessValidator?: TxValidator<Tx>;
+        postprocessValidator?: TxValidator<ProcessedTx>;
+        nullifierCache?: {
+            addNullifiers: (nullifiers: Buffer[]) => void;
+        };
+    }): Promise<[ProcessedTx[], FailedTx[], NestedProcessReturnValues[]]>;
+    private processTx;
+    private doTreeInsertionsForPrivateOnlyTx;
+    /** Processes the given tx within deadline. Returns timeout if deadline is hit. */
+    private processTxWithinDeadline;
+    /**
+     * Creates the public data write for paying the tx fee.
+     * This is used in private only txs, since for txs with public calls
+     * the avm handles the fee payment itself.
+     */
+    private getFeePaymentPublicDataWrite;
+    private processPrivateOnlyTx;
+    private processTxWithPublicCalls;
+}
+//# sourceMappingURL=public_processor.d.ts.map

package/dest/public/public_processor/public_processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public_processor.d.ts","sourceRoot":"","sources":["../../../src/public/public_processor/public_processor.ts"],"names":[],"mappings":";;AAIA,OAAO,EAAE,KAAK,YAAY,EAAkC,MAAM,yBAAyB,CAAC;AAM5F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AACxC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAEjF,OAAO,EACL,KAAK,QAAQ,EACb,eAAe,EACf,yBAAyB,EACzB,KAAK,WAAW,EAChB,EAAE,EAEF,KAAK,WAAW,EAGjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,KAAK,MAAM,EAGZ,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,+CAA+C,CAAC;AAGlF;;GAEG;AACH,qBAAa,sBAAsB;IAE/B,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,eAAe;gBAFf,kBAAkB,EAAE,kBAAkB,EACtC,YAAY,EAAE,YAAY,EAC1B,eAAe,GAAE,eAAsC;IAGjE;;;;;;OAMG;IACI,MAAM,CACX,UAAU,EAAE,yBAAyB,EACrC,eAAe,EAAE,eAAe,EAChC,kBAAkB,EAAE,OAAO,GAC1B,eAAe;IAqBlB,SAAS,CAAC,uBAAuB,CAC/B,EAAE,EAAE,yBAAyB,EAC7B,YAAY,EAAE,YAAY,EAC1B,eAAe,EAAE,eAAe,EAChC,kBAAkB,EAAE,OAAO,EAC3B,kBAAkB,EAAE,OAAO,EAC3B,eAAe,EAAE,eAAe;CAWnC;AASD;;;GAGG;AACH,qBAAa,eAAgB,YAAW,SAAS;IAG7C,SAAS,CAAC,EAAE,EAAE,yBAAyB;IACvC,SAAS,CAAC,eAAe,EAAE,eAAe;IAC1C,SAAS,CAAC,YAAY,EAAE,YAAY;IACpC,SAAS,CAAC,iBAAiB,EAAE,iBAAiB;IAC9C,OAAO,CAAC,YAAY;IAEpB,OAAO,CAAC,GAAG;IARb,OAAO,CAAC,OAAO,CAAyB;gBAE5B,EAAE,EAAE,yBAAyB,EAC7B,eAAe,EAAE,eAAe,EAChC,YAAY,EAAE,YAAY,EAC1B,iBAAiB,EAAE,iBAAiB,EACtC,YAAY,EAAE,YAAY,EAClC,eAAe,GAAE,eAAsC,EAC/C,GAAG,yCAA6C;IAK1D,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;;OAKG;IACU,OAAO,CAClB,GAAG,EAAE,QAAQ,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,EAAE,CAAC,EACrC,MAAM,GAAE;QACN,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,WAAW,CAAC,EAAE,GAAG,CAAC;QAClB,QAAQ,CAAC,EAAE,IAAI,CAAC;KACZ,EACN,UAAU,GAAE;QACV,mBAAmB,CAAC,EAAE,WAAW,CAAC,EAAE,CAAC,CAAC;QACtC,oBAAoB,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;QAChD,cAAc,CAAC,EAAE;YAAE,aAAa,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,IAAI,CAAA;SAAE,CAAC;KAC/D,GACL,OAAO,CAAC,CAAC,WAAW,EAAE,EAAE,QAAQ,EAAE,EAAE,yBAAyB,EAAE,CAAC,CAAC;YAwKtD,SAAS;YA2BT,gCAAgC;IAyC9C,kFAAkF;YACpE,uBAAuB;IA+BrC;;;;OAIG;YACW,4BAA4B;YAwB5B,oBAAoB;YA6BpB,wBAAwB;CA8CvC"}