@aztec/simulator 0.76.4 → 0.77.0-testnet-ignition.21

package/dest/public/public_tx_simulator/public_tx_context.js

@@ -0,0 +1,320 @@
+import { MAX_L2_GAS_PER_TX_PUBLIC_PORTION, MAX_L2_TO_L1_MSGS_PER_TX, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, NULLIFIER_SUBTREE_HEIGHT } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { assertLength } from '@aztec/foundation/serialize';
+import { AvmCircuitInputs, PublicDataWrite, RevertCode } from '@aztec/stdlib/avm';
+import { computeTransactionFee } from '@aztec/stdlib/fees';
+import { Gas } from '@aztec/stdlib/gas';
+import { PrivateToAvmAccumulatedData, PrivateToAvmAccumulatedDataArrayLengths, PublicCallRequest, countAccumulatedItems, mergeAccumulatedData } from '@aztec/stdlib/kernel';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { TreeSnapshots, TxExecutionPhase } from '@aztec/stdlib/tx';
+import { strict as assert } from 'assert';
+import { inspect } from 'util';
+import { AvmPersistableStateManager } from '../avm/index.js';
+import { SideEffectArrayLengths, SideEffectTrace } from '../side_effect_trace.js';
+import { getCallRequestsByPhase, getExecutionRequestsByPhase } from '../utils.js';
+/**
+ * The transaction-level context for public execution.
+ */ export class PublicTxContext {
+    txHash;
+    state;
+    globalVariables;
+    startStateReference;
+    gasSettings;
+    gasUsedByPrivate;
+    gasAllocatedToPublic;
+    setupCallRequests;
+    appLogicCallRequests;
+    teardownCallRequests;
+    setupExecutionRequests;
+    appLogicExecutionRequests;
+    teardownExecutionRequests;
+    nonRevertibleAccumulatedDataFromPrivate;
+    revertibleAccumulatedDataFromPrivate;
+    feePayer;
+    trace;
+    log;
+    /* Gas used including private, teardown gas _limit_, setup and app logic */ gasUsedByPublic;
+    /* Gas actually used during teardown (different from limit) */ teardownGasUsed;
+    /* Entire transaction execution is done. */ halted;
+    /* Where did reverts happen (if at all)? */ revertCode;
+    /* What caused a revert (if one occurred)? */ revertReason;
+    avmProvingRequest;
+    constructor(txHash, state, globalVariables, startStateReference, gasSettings, gasUsedByPrivate, gasAllocatedToPublic, setupCallRequests, appLogicCallRequests, teardownCallRequests, setupExecutionRequests, appLogicExecutionRequests, teardownExecutionRequests, nonRevertibleAccumulatedDataFromPrivate, revertibleAccumulatedDataFromPrivate, feePayer, trace){
+        this.txHash = txHash;
+        this.state = state;
+        this.globalVariables = globalVariables;
+        this.startStateReference = startStateReference;
+        this.gasSettings = gasSettings;
+        this.gasUsedByPrivate = gasUsedByPrivate;
+        this.gasAllocatedToPublic = gasAllocatedToPublic;
+        this.setupCallRequests = setupCallRequests;
+        this.appLogicCallRequests = appLogicCallRequests;
+        this.teardownCallRequests = teardownCallRequests;
+        this.setupExecutionRequests = setupExecutionRequests;
+        this.appLogicExecutionRequests = appLogicExecutionRequests;
+        this.teardownExecutionRequests = teardownExecutionRequests;
+        this.nonRevertibleAccumulatedDataFromPrivate = nonRevertibleAccumulatedDataFromPrivate;
+        this.revertibleAccumulatedDataFromPrivate = revertibleAccumulatedDataFromPrivate;
+        this.feePayer = feePayer;
+        this.trace = trace;
+        this.gasUsedByPublic = Gas.empty();
+        this.teardownGasUsed = Gas.empty();
+        this.halted = false;
+        this.revertCode = RevertCode.OK;
+        this.log = createLogger(`simulator:public_tx_context`);
+    }
+    static async create(db, worldStateDB, tx, globalVariables, doMerkleOperations) {
+        const nonRevertibleAccumulatedDataFromPrivate = tx.data.forPublic.nonRevertibleAccumulatedData;
+        const previousAccumulatedDataArrayLengths = new SideEffectArrayLengths(/*publicDataWrites*/ 0, /*protocolPublicDataWrites*/ 0, /*noteHashes*/ 0, /*nullifiers=*/ 0, countAccumulatedItems(nonRevertibleAccumulatedDataFromPrivate.l2ToL1Msgs), /*publicLogs*/ 0);
+        const trace = new SideEffectTrace(/*startSideEffectCounter=*/ 0, previousAccumulatedDataArrayLengths);
+        const firstNullifier = nonRevertibleAccumulatedDataFromPrivate.nullifiers[0];
+        // Transaction level state manager that will be forked for revertible phases.
+        const txStateManager = AvmPersistableStateManager.create(worldStateDB, trace, doMerkleOperations, firstNullifier);
+        const gasSettings = tx.data.constants.txContext.gasSettings;
+        const gasUsedByPrivate = tx.data.gasUsed;
+        // Gas allocated to public is "whatever's left" after private, but with some max applied.
+        const gasAllocatedToPublic = applyMaxToAvailableGas(gasSettings.gasLimits.sub(gasUsedByPrivate));
+        return new PublicTxContext(await tx.getTxHash(), new PhaseStateManager(txStateManager), globalVariables, await db.getStateReference(), gasSettings, gasUsedByPrivate, gasAllocatedToPublic, getCallRequestsByPhase(tx, TxExecutionPhase.SETUP), getCallRequestsByPhase(tx, TxExecutionPhase.APP_LOGIC), getCallRequestsByPhase(tx, TxExecutionPhase.TEARDOWN), getExecutionRequestsByPhase(tx, TxExecutionPhase.SETUP), getExecutionRequestsByPhase(tx, TxExecutionPhase.APP_LOGIC), getExecutionRequestsByPhase(tx, TxExecutionPhase.TEARDOWN), tx.data.forPublic.nonRevertibleAccumulatedData, tx.data.forPublic.revertibleAccumulatedData, tx.data.feePayer, trace);
+    }
+    /**
+   * Signal that the entire transaction execution is done.
+   * All phases have been processed.
+   * Actual transaction fee and actual total consumed gas can now be queried.
+   */ async halt() {
+        if (this.state.isForked()) {
+            await this.state.mergeForkedState();
+        }
+        this.halted = true;
+    }
+    /**
+   * Revert execution a phase. Populate revertReason & revertCode.
+   * If in setup, throw an error (transaction will be thrown out).
+   * NOTE: this does not "halt" the entire transaction execution.
+   */ revert(phase, revertReason = undefined, culprit = '') {
+        this.log.warn(`${TxExecutionPhase[phase]} phase reverted! ${culprit} failed with reason: ${revertReason}`);
+        if (revertReason && !this.revertReason) {
+            // don't override revertReason
+            // (if app logic and teardown both revert, we want app logic's reason)
+            this.revertReason = revertReason;
+        }
+        if (phase === TxExecutionPhase.SETUP) {
+            this.log.warn(`Setup phase reverted! The transaction will be thrown out.`);
+            if (revertReason) {
+                throw revertReason;
+            } else {
+                throw new Error(`Setup phase reverted! The transaction will be thrown out. ${culprit} failed`);
+            }
+        } else if (phase === TxExecutionPhase.APP_LOGIC) {
+            this.revertCode = RevertCode.APP_LOGIC_REVERTED;
+        } else if (phase === TxExecutionPhase.TEARDOWN) {
+            if (this.revertCode.equals(RevertCode.APP_LOGIC_REVERTED)) {
+                this.revertCode = RevertCode.BOTH_REVERTED;
+            } else {
+                this.revertCode = RevertCode.TEARDOWN_REVERTED;
+            }
+        }
+    }
+    /**
+   * Get the revert code.
+   * @returns The revert code.
+   */ getFinalRevertCode() {
+        assert(this.halted, 'Cannot know the final revert code until tx execution ends');
+        return this.revertCode;
+    }
+    /**
+   * Are there any call requests for the speciiied phase?
+   */ hasPhase(phase) {
+        if (phase === TxExecutionPhase.SETUP) {
+            return this.setupCallRequests.length > 0;
+        } else if (phase === TxExecutionPhase.APP_LOGIC) {
+            return this.appLogicCallRequests.length > 0;
+        } else {
+            // phase === TxExecutionPhase.TEARDOWN
+            return this.teardownCallRequests.length > 0;
+        }
+    }
+    /**
+   * Get the call requests for the specified phase (including args hashes).
+   */ getCallRequestsForPhase(phase) {
+        switch(phase){
+            case TxExecutionPhase.SETUP:
+                return this.setupCallRequests;
+            case TxExecutionPhase.APP_LOGIC:
+                return this.appLogicCallRequests;
+            case TxExecutionPhase.TEARDOWN:
+                return this.teardownCallRequests;
+        }
+    }
+    /**
+   * Get the call requests for the specified phase (including actual args).
+   */ getExecutionRequestsForPhase(phase) {
+        switch(phase){
+            case TxExecutionPhase.SETUP:
+                return this.setupExecutionRequests;
+            case TxExecutionPhase.APP_LOGIC:
+                return this.appLogicExecutionRequests;
+            case TxExecutionPhase.TEARDOWN:
+                return this.teardownExecutionRequests;
+        }
+    }
+    /**
+   * How much gas is left as of the specified phase?
+   */ getGasLeftAtPhase(phase) {
+        if (phase === TxExecutionPhase.TEARDOWN) {
+            return applyMaxToAvailableGas(this.gasSettings.teardownGasLimits);
+        } else {
+            const gasLeftForPublic = this.gasAllocatedToPublic.sub(this.gasUsedByPublic);
+            return gasLeftForPublic;
+        }
+    }
+    /**
+   * Consume gas. Track gas for teardown phase separately.
+   */ consumeGas(phase, gas) {
+        if (phase === TxExecutionPhase.TEARDOWN) {
+            this.teardownGasUsed = this.teardownGasUsed.add(gas);
+        } else {
+            this.gasUsedByPublic = this.gasUsedByPublic.add(gas);
+        }
+    }
+    /**
+   * The gasUsed by public and private,
+   * as if the entire teardown gas limit was consumed.
+   */ getTotalGasUsed() {
+        return this.gasUsedByPrivate.add(this.gasUsedByPublic);
+    }
+    /**
+   * Compute the gas used using the actual gas used during teardown instead
+   * of the teardown gas limit.
+   * Note that this.gasUsed is initialized from private's gasUsed which includes
+   * teardown gas limit.
+   */ getActualGasUsed() {
+        assert(this.halted, 'Can only compute actual gas used after tx execution ends');
+        const requireTeardown = this.teardownCallRequests.length > 0;
+        const teardownGasLimits = requireTeardown ? this.gasSettings.teardownGasLimits : Gas.empty();
+        return this.getTotalGasUsed().sub(teardownGasLimits).add(this.teardownGasUsed);
+    }
+    /**
+   * Compute the public gas used using the actual gas used during teardown instead
+   * of the teardown gas limit.
+   */ getActualPublicGasUsed() {
+        assert(this.halted, 'Can only compute actual gas used after tx execution ends');
+        return this.gasUsedByPublic.add(this.teardownGasUsed);
+    }
+    /**
+   * Get the transaction fee as is available to the specified phase.
+   * Only teardown should have access to the actual transaction fee.
+   */ getTransactionFee(phase) {
+        if (phase === TxExecutionPhase.TEARDOWN) {
+            return this.getTransactionFeeUnsafe();
+        } else {
+            return Fr.zero();
+        }
+    }
+    /**
+   * Compute the transaction fee.
+   * Should only be called during or after teardown.
+   */ getTransactionFeeUnsafe() {
+        const gasUsed = this.getTotalGasUsed();
+        const txFee = computeTransactionFee(this.globalVariables.gasFees, this.gasSettings, gasUsed);
+        this.log.debug(`Computed tx fee`, {
+            txFee,
+            gasUsed: inspect(gasUsed),
+            gasFees: inspect(this.globalVariables.gasFees)
+        });
+        return txFee;
+    }
+    /**
+   * Generate the public inputs for the AVM circuit.
+   */ async generateAvmCircuitPublicInputs(endStateReference) {
+        assert(this.halted, 'Can only get AvmCircuitPublicInputs after tx execution ends');
+        const stateManager = this.state.getActiveStateManager();
+        const startTreeSnapshots = new TreeSnapshots(this.startStateReference.l1ToL2MessageTree, this.startStateReference.partial.noteHashTree, this.startStateReference.partial.nullifierTree, this.startStateReference.partial.publicDataTree);
+        // Will be patched/padded at the end of this fn
+        const endTreeSnapshots = new TreeSnapshots(endStateReference.l1ToL2MessageTree, endStateReference.partial.noteHashTree, endStateReference.partial.nullifierTree, endStateReference.partial.publicDataTree);
+        const avmCircuitPublicInputs = this.trace.toAvmCircuitPublicInputs(this.globalVariables, startTreeSnapshots, /*startGasUsed=*/ this.gasUsedByPrivate, this.gasSettings, this.feePayer, this.setupCallRequests, this.appLogicCallRequests, /*teardownCallRequest=*/ this.teardownCallRequests.length ? this.teardownCallRequests[0] : PublicCallRequest.empty(), endTreeSnapshots, /*endGasUsed=*/ this.getTotalGasUsed(), /*transactionFee=*/ this.getTransactionFeeUnsafe(), /*reverted=*/ !this.revertCode.isOK());
+        const getArrayLengths = (from)=>new PrivateToAvmAccumulatedDataArrayLengths(countAccumulatedItems(from.noteHashes), countAccumulatedItems(from.nullifiers), countAccumulatedItems(from.l2ToL1Msgs));
+        const convertAccumulatedData = (from)=>new PrivateToAvmAccumulatedData(from.noteHashes, from.nullifiers, from.l2ToL1Msgs);
+        // Temporary overrides as these entries aren't yet populated in trace
+        avmCircuitPublicInputs.previousNonRevertibleAccumulatedDataArrayLengths = getArrayLengths(this.nonRevertibleAccumulatedDataFromPrivate);
+        avmCircuitPublicInputs.previousRevertibleAccumulatedDataArrayLengths = getArrayLengths(this.revertibleAccumulatedDataFromPrivate);
+        avmCircuitPublicInputs.previousNonRevertibleAccumulatedData = convertAccumulatedData(this.nonRevertibleAccumulatedDataFromPrivate);
+        avmCircuitPublicInputs.previousRevertibleAccumulatedData = convertAccumulatedData(this.revertibleAccumulatedDataFromPrivate);
+        const msgsFromPrivate = this.revertCode.isOK() ? mergeAccumulatedData(avmCircuitPublicInputs.previousNonRevertibleAccumulatedData.l2ToL1Msgs, avmCircuitPublicInputs.previousRevertibleAccumulatedData.l2ToL1Msgs) : avmCircuitPublicInputs.previousNonRevertibleAccumulatedData.l2ToL1Msgs;
+        avmCircuitPublicInputs.accumulatedData.l2ToL1Msgs = assertLength(mergeAccumulatedData(msgsFromPrivate, avmCircuitPublicInputs.accumulatedData.l2ToL1Msgs), MAX_L2_TO_L1_MSGS_PER_TX);
+        // Maps slot to value. Maps in TS are iterable in insertion order, which is exactly what we want for
+        // squashing "to the left", where the first occurrence of a slot uses the value of the last write to it,
+        // and the rest occurrences are omitted
+        const squashedPublicDataWrites = new Map();
+        for (const publicDataWrite of avmCircuitPublicInputs.accumulatedData.publicDataWrites){
+            squashedPublicDataWrites.set(publicDataWrite.leafSlot.toBigInt(), publicDataWrite.value);
+        }
+        avmCircuitPublicInputs.accumulatedData.publicDataWrites = padArrayEnd(Array.from(squashedPublicDataWrites.entries()).map(([slot, value])=>new PublicDataWrite(new Fr(slot), value)), PublicDataWrite.empty(), MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX);
+        const numNoteHashesToPad = MAX_NOTE_HASHES_PER_TX - countAccumulatedItems(avmCircuitPublicInputs.accumulatedData.noteHashes);
+        await stateManager.db.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, padArrayEnd([], Fr.ZERO, numNoteHashesToPad));
+        const numNullifiersToPad = MAX_NULLIFIERS_PER_TX - countAccumulatedItems(avmCircuitPublicInputs.accumulatedData.nullifiers);
+        await stateManager.db.batchInsert(MerkleTreeId.NULLIFIER_TREE, padArrayEnd([], Fr.ZERO, numNullifiersToPad).map((nullifier)=>nullifier.toBuffer()), NULLIFIER_SUBTREE_HEIGHT);
+        const paddedState = await stateManager.db.getStateReference();
+        avmCircuitPublicInputs.endTreeSnapshots = new TreeSnapshots(paddedState.l1ToL2MessageTree, paddedState.partial.noteHashTree, paddedState.partial.nullifierTree, paddedState.partial.publicDataTree);
+        return avmCircuitPublicInputs;
+    }
+    /**
+   * Generate the proving request for the AVM circuit.
+   */ async generateProvingRequest(endStateReference) {
+        const hints = this.trace.getAvmCircuitHints();
+        return {
+            type: ProvingRequestType.PUBLIC_VM,
+            inputs: new AvmCircuitInputs('public_dispatch', [], hints, await this.generateAvmCircuitPublicInputs(endStateReference))
+        };
+    }
+}
+/**
+ * Thin wrapper around the state manager to handle forking and merging for phases.
+ *
+ * This lets us keep track of whether the state has already been forked
+ * so that we can conditionally fork at the start of a phase.
+ *
+ * There is a state manager that lives at the level of the entire transaction,
+ * but for app logic and teardown the active state manager will be a fork of the
+ * transaction level one.
+ */ class PhaseStateManager {
+    txStateManager;
+    log;
+    currentlyActiveStateManager;
+    constructor(txStateManager){
+        this.txStateManager = txStateManager;
+        this.log = createLogger(`simulator:public_phase_state_manager`);
+    }
+    async fork() {
+        assert(!this.currentlyActiveStateManager, 'Cannot fork when already forked');
+        this.log.debug(`Forking phase state manager`);
+        this.currentlyActiveStateManager = await this.txStateManager.fork();
+    }
+    getActiveStateManager() {
+        return this.currentlyActiveStateManager || this.txStateManager;
+    }
+    isForked() {
+        return !!this.currentlyActiveStateManager;
+    }
+    async mergeForkedState() {
+        assert(this.currentlyActiveStateManager, 'No forked state to merge');
+        this.log.debug(`Merging in forked state`);
+        await this.txStateManager.merge(this.currentlyActiveStateManager);
+        // Drop the forked state manager now that it is merged
+        this.currentlyActiveStateManager = undefined;
+    }
+    async discardForkedState() {
+        this.log.debug(`Discarding forked state`);
+        assert(this.currentlyActiveStateManager, 'No forked state to discard');
+        await this.txStateManager.reject(this.currentlyActiveStateManager);
+        // Drop the forked state manager. We don't want it!
+        this.currentlyActiveStateManager = undefined;
+    }
+}
+/**
+ * Apply L2 gas maximum.
+ */ function applyMaxToAvailableGas(availableGas) {
+    return new Gas(/*daGas=*/ availableGas.daGas, /*l2Gas=*/ Math.min(availableGas.l2Gas, MAX_L2_GAS_PER_TX_PUBLIC_PORTION));
+}

package/dest/public/{public_tx_simulator.d.ts → public_tx_simulator/public_tx_simulator.d.ts}

@@ -1,8 +1,11 @@
-import { type AvmProvingRequest, type GasUsed, type MerkleTreeReadOperations, NestedProcessReturnValues, type SimulationError, type Tx, TxExecutionPhase } from '@aztec/circuit-types';
-import { type GlobalVariables, type RevertCode } from '@aztec/circuits.js';
+import type { AvmProvingRequest, RevertCode } from '@aztec/stdlib/avm';
+import type { SimulationError } from '@aztec/stdlib/errors';
+import type { GasUsed } from '@aztec/stdlib/gas';
+import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
+import { type GlobalVariables, NestedProcessReturnValues, Tx, TxExecutionPhase } from '@aztec/stdlib/tx';
 import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
-import { ExecutorMetrics } from './executor_metrics.js';
-import { type WorldStateDB } from './public_db_sources.js';
+import { ExecutorMetrics } from '../executor_metrics.js';
+import type { WorldStateDB } from '../public_db_sources.js';
 import { PublicTxContext } from './public_tx_context.js';
 export type ProcessedPhase = {
     phase: TxExecutionPhase;
@@ -25,10 +28,10 @@ export declare class PublicTxSimulator {
     private worldStateDB;
     private globalVariables;
     private doMerkleOperations;
-    private enforceFeePayment;
+    private skipFeeEnforcement;
     metrics: ExecutorMetrics;
     private log;
-    constructor(db: MerkleTreeReadOperations, worldStateDB: WorldStateDB, globalVariables: GlobalVariables, doMerkleOperations?: boolean, enforceFeePayment?: boolean, telemetryClient?: TelemetryClient);
+    constructor(db: MerkleTreeReadOperations, worldStateDB: WorldStateDB, globalVariables: GlobalVariables, doMerkleOperations?: boolean, skipFeeEnforcement?: boolean, telemetryClient?: TelemetryClient);
     get tracer(): Tracer;
     /**
      * Simulate a transaction's public portion including all of its phases.
@@ -72,7 +75,7 @@ export declare class PublicTxSimulator {
     private simulateEnqueuedCall;
     /**
      * Simulate an enqueued public call, without modifying the context (PublicTxContext).
-     * Resulting modifcations to the context can be applied by the caller.
+     * Resulting modifications to the context can be applied by the caller.
      *
      * This function can be mocked for testing to skip actual AVM simulation
      * while still simulating phases and generating a proving request.

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

@@ -0,0 +1 @@
+{"version":3,"file":"public_tx_simulator.d.ts","sourceRoot":"","sources":["../../../src/public/public_tx_simulator/public_tx_simulator.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAO,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAGhF,OAAO,EACL,KAAK,eAAe,EACpB,yBAAyB,EAEzB,EAAE,EACF,gBAAgB,EACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAc,KAAK,eAAe,EAAE,KAAK,MAAM,EAAiC,MAAM,yBAAyB,CAAC;AAQvH,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,EAAE,gBAAgB,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,yBAAyB,EAAE,CAAC;IAC1C,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,eAAe,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,+CAA+C;IAC/C,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,UAAU,CAAC;IACvB,4BAA4B;IAC5B,YAAY,CAAC,EAAE,eAAe,CAAC;IAC/B,eAAe,EAAE,cAAc,EAAE,CAAC;CACnC,CAAC;AAEF,qBAAa,iBAAiB;IAM1B,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,kBAAkB;IAT5B,OAAO,EAAE,eAAe,CAAC;IAEzB,OAAO,CAAC,GAAG,CAAS;gBAGV,EAAE,EAAE,wBAAwB,EAC5B,YAAY,EAAE,YAAY,EAC1B,eAAe,EAAE,eAAe,EAChC,kBAAkB,GAAE,OAAe,EACnC,kBAAkB,GAAE,OAAe,EAC3C,eAAe,GAAE,eAAsC;IAMzD,IAAI,MAAM,IAAI,MAAM,CAEnB;IACD;;;;OAIG;IACU,QAAQ,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAsFtD;;;;OAIG;YACW,kBAAkB;IAIhC;;;;OAIG;YACW,qBAAqB;IAkBnC;;;;OAIG;YACW,qBAAqB;IAoBnC;;;;;OAKG;YACW,aAAa;IA0C3B;;;;;;;OAOG;YAOW,oBAAoB;IAoClC;;;;;;;;;;;;;OAaG;YAOW,4BAA4B;IAgD1C;;OAEG;IACU,+BAA+B,CAAC,OAAO,EAAE,eAAe;IAkBrE;;;OAGG;IACU,4BAA4B,CAAC,OAAO,EAAE,eAAe;YAsBpD,MAAM;CA+BrB"}