@aztec/prover-client 0.55.0 → 0.56.0

package/src/orchestrator/tx-proving-state.ts

@@ -3,8 +3,8 @@ import {
   type AvmProvingRequest,
   type MerkleTreeId,
   type ProcessedTx,
+  ProvingRequestType,
   type PublicKernelRequest,
-  PublicKernelType,
 } from '@aztec/circuit-types';
 import {
   type AppendOnlyTreeSnapshot,
@@ -14,6 +14,7 @@ import {
   type RECURSIVE_PROOF_LENGTH,
   type RecursiveProof,
   type VerificationKeyData,
+  makeEmptyProof,
 } from '@aztec/circuits.js';
 
 export enum TX_PROVING_CODE {
@@ -25,7 +26,7 @@ export enum TX_PROVING_CODE {
 export type PublicFunction = {
   vmRequest: AvmProvingRequest | undefined;
   vmProof: Proof | undefined;
-  previousProofType: PublicKernelType;
+  previousProofType: ProvingRequestType;
   previousKernelProven: boolean;
   publicKernelRequest: PublicKernelRequest;
 };
@@ -35,6 +36,7 @@ export type PublicFunction = {
 export type TxProvingInstruction = {
   code: TX_PROVING_CODE;
   function: PublicFunction | undefined;
+  functionIndex?: number;
 };
 
 /**
@@ -50,20 +52,38 @@ export class TxProvingState {
     public readonly baseRollupInputs: BaseRollupInputs,
     public readonly treeSnapshots: Map<MerkleTreeId, AppendOnlyTreeSnapshot>,
   ) {
-    let previousProofType = PublicKernelType.NON_PUBLIC;
+    let previousProofType = ProvingRequestType.TUBE_PROOF;
     for (let i = 0; i < processedTx.publicProvingRequests.length; i++) {
       const provingRequest = processedTx.publicProvingRequests[i];
-      const kernelRequest = provingRequest.type === AVM_REQUEST ? provingRequest.kernelRequest : provingRequest;
+      const publicKernelRequest = provingRequest.type === AVM_REQUEST ? provingRequest.kernelRequest : provingRequest;
       const vmRequest = provingRequest.type === AVM_REQUEST ? provingRequest : undefined;
+      // TODO(#7124): Remove this temporary hack.
+      // There's no previous kernel for the first inner kernel in a chain of AvmProvingRequests.
+      // Setting its previousKernelProven to be true so that it will be ready once the vm proof is generated.
+      const previousKernelProven = !!vmRequest && previousProofType !== ProvingRequestType.PUBLIC_KERNEL_INNER;
+      const vmProof = provingRequest.type === ProvingRequestType.PUBLIC_KERNEL_TAIL ? makeEmptyProof() : undefined;
       const publicFunction: PublicFunction = {
         vmRequest,
-        vmProof: undefined,
+        vmProof,
         previousProofType,
-        previousKernelProven: false,
-        publicKernelRequest: kernelRequest,
+        previousKernelProven,
+        publicKernelRequest: {
+          type: publicKernelRequest.type,
+          // We take a deep copy (clone) of the inputs to be modified here and passed to the prover.
+          // bb-prover will also modify the inputs by reference.
+          inputs: publicKernelRequest.inputs.clone(),
+        } as PublicKernelRequest,
       };
       this.publicFunctions.push(publicFunction);
-      previousProofType = kernelRequest.type;
+      previousProofType = publicKernelRequest.type;
+    }
+
+    if (this.publicFunctions.length > 0) {
+      // The first merge kernel takes the tube proof.
+      const firstKernelIndex = this.publicFunctions.findIndex(
+        fn => fn.publicKernelRequest.type === ProvingRequestType.PUBLIC_KERNEL_MERGE,
+      );
+      this.publicFunctions[firstKernelIndex].previousProofType = ProvingRequestType.TUBE_PROOF;
     }
   }
 
@@ -75,29 +95,44 @@ export class TxProvingState {
     verificationKey: VerificationKeyData,
   ): TxProvingInstruction {
     const kernelRequest = this.getPublicFunctionState(provenIndex).publicKernelRequest;
-    const nextKernelIndex = provenIndex + 1;
-    if (nextKernelIndex >= this.publicFunctions.length) {
+    const provenIsInner = kernelRequest.type === ProvingRequestType.PUBLIC_KERNEL_INNER;
+    // If the proven request is not an inner kernel, its next kernel should not be an inner kernel either.
+    const nextFunctionIndex = provenIsInner
+      ? provenIndex + 1
+      : this.publicFunctions.findIndex(
+          (fn, i) => i > provenIndex && fn.publicKernelRequest.type !== ProvingRequestType.PUBLIC_KERNEL_INNER,
+        );
+    if (nextFunctionIndex >= this.publicFunctions.length || nextFunctionIndex === -1) {
       // The next kernel index is greater than our set of functions, we are done!
       return { code: TX_PROVING_CODE.COMPLETED, function: undefined };
     }
 
     // There is more work to do, are we ready?
-    const nextFunction = this.publicFunctions[nextKernelIndex];
-
-    // pass both the proof and verification key forward to the next circuit
-    nextFunction.publicKernelRequest.inputs.previousKernel.proof = proof;
-    nextFunction.publicKernelRequest.inputs.previousKernel.vk = verificationKey;
+    const nextFunction = this.publicFunctions[nextFunctionIndex];
+
+    if (provenIsInner && nextFunction.publicKernelRequest.type !== ProvingRequestType.PUBLIC_KERNEL_INNER) {
+      // TODO(#7124): Remove this temporary hack.
+      // If the proven request is inner (with vm proof) and the next one is regular kernel, set the vmProof to be
+      // not undefined.
+      // This should eventually be a real vm proof of the entire enqueued call.
+      nextFunction.vmProof = makeEmptyProof();
+    } else {
+      // pass both the proof and verification key forward to the next circuit
+      nextFunction.publicKernelRequest.inputs.previousKernel.proof = proof;
+      nextFunction.publicKernelRequest.inputs.previousKernel.vk = verificationKey;
+
+      // We need to update this so the state machine knows this proof is ready
+      nextFunction.previousKernelProven = true;
+      nextFunction.previousProofType = kernelRequest.type;
+    }
 
-    // We need to update this so the state machine knows this proof is ready
-    nextFunction.previousKernelProven = true;
-    nextFunction.previousProofType = kernelRequest.type;
-    if (nextFunction.vmProof === undefined) {
+    if (nextFunction.vmProof === undefined || !nextFunction.previousKernelProven) {
       // The VM proof for the next function is not ready
       return { code: TX_PROVING_CODE.NOT_READY, function: undefined };
     }
 
     // The VM proof is ready, we can continue
-    return { code: TX_PROVING_CODE.READY, function: nextFunction };
+    return { code: TX_PROVING_CODE.READY, function: nextFunction, functionIndex: nextFunctionIndex };
   }
 
   // Updates the transaction's proving state after completion of a tube proof
@@ -106,14 +141,16 @@ export class TxProvingState {
     proof: RecursiveProof<typeof RECURSIVE_PROOF_LENGTH>,
     verificationKey: VerificationKeyData,
   ): TxProvingInstruction {
-    const nextKernelIndex = 0;
-    if (nextKernelIndex >= this.publicFunctions.length) {
-      // The next kernel index is greater than our set of functions, we are done!
+    const nextFunctionIndex = this.publicFunctions.findIndex(
+      (fn, i) => i > 0 && fn.previousProofType === ProvingRequestType.TUBE_PROOF,
+    );
+    if (nextFunctionIndex === -1) {
+      // There are no public functions to be processed, we are done!
       return { code: TX_PROVING_CODE.COMPLETED, function: undefined };
     }
 
     // There is more work to do, are we ready?
-    const nextFunction = this.publicFunctions[nextKernelIndex];
+    const nextFunction = this.publicFunctions[nextFunctionIndex];
 
     // pass both the proof and verification key forward to the next circuit
     nextFunction.publicKernelRequest.inputs.previousKernel.proof = proof;
@@ -121,14 +158,13 @@ export class TxProvingState {
 
     // We need to update this so the state machine knows this proof is ready
     nextFunction.previousKernelProven = true;
-    nextFunction.previousProofType = PublicKernelType.NON_PUBLIC;
     if (nextFunction.vmProof === undefined) {
       // The VM proof for the next function is not ready
       return { code: TX_PROVING_CODE.NOT_READY, function: undefined };
     }
 
     // The VM proof is ready, we can continue
-    return { code: TX_PROVING_CODE.READY, function: nextFunction };
+    return { code: TX_PROVING_CODE.READY, function: nextFunction, functionIndex: nextFunctionIndex };
   }
 
   // Updates the transaction's proving state after completion of a VM proof
@@ -142,7 +178,7 @@ export class TxProvingState {
       return { code: TX_PROVING_CODE.NOT_READY, function: undefined };
     }
     // The previous kernel is ready so we can prove this kernel
-    return { code: TX_PROVING_CODE.READY, function: provenFunction };
+    return { code: TX_PROVING_CODE.READY, function: provenFunction, functionIndex: provenIndex };
   }
 
   // Returns the public function state at the given index

package/src/prover-agent/memory-proving-queue.ts

@@ -6,8 +6,6 @@ import {
   type ProvingRequestResult,
   ProvingRequestType,
   type PublicInputsAndRecursiveProof,
-  type PublicKernelNonTailRequest,
-  type PublicKernelTailRequest,
   type ServerCircuitProver,
 } from '@aztec/circuit-types';
 import type {
@@ -22,7 +20,10 @@ import type {
   MergeRollupInputs,
   NESTED_RECURSIVE_PROOF_LENGTH,
   PrivateKernelEmptyInputData,
+  PublicKernelCircuitPrivateInputs,
   PublicKernelCircuitPublicInputs,
+  PublicKernelInnerCircuitPrivateInputs,
+  PublicKernelTailCircuitPrivateInputs,
   RECURSIVE_PROOF_LENGTH,
   RecursiveProof,
   RootParityInput,
@@ -30,6 +31,7 @@ import type {
   RootRollupInputs,
   RootRollupPublicInputs,
   TubeInputs,
+  VMCircuitPublicInputs,
   VerificationKeyData,
 } from '@aztec/circuits.js';
 import { randomBytes } from '@aztec/foundation/crypto';
@@ -349,6 +351,14 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     return this.enqueue({ type: ProvingRequestType.BLOCK_ROOT_ROLLUP, inputs: input }, signal, epochNumber);
   }
 
+  getBlockRootRollupFinalProof(
+    input: BlockRootRollupInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
+    return this.enqueue({ type: ProvingRequestType.BLOCK_ROOT_ROLLUP_FINAL, inputs: input }, signal, epochNumber);
+  }
+
   /**
    * Creates a proof for the given input.
    * @param input - Input to the circuit.
@@ -374,19 +384,27 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
   }
 
   /**
-   * Create a public kernel proof.
+   * Create a public kernel inner proof.
    * @param kernelRequest - Object containing the details of the proof required
    */
-  getPublicKernelProof(
-    kernelRequest: PublicKernelNonTailRequest,
+  getPublicKernelInnerProof(
+    inputs: PublicKernelInnerCircuitPrivateInputs,
+    signal?: AbortSignal,
+    epochNumber?: number,
+  ): Promise<PublicInputsAndRecursiveProof<VMCircuitPublicInputs>> {
+    return this.enqueue({ type: ProvingRequestType.PUBLIC_KERNEL_INNER, inputs }, signal, epochNumber);
+  }
+
+  /**
+   * Create a public kernel merge proof.
+   * @param kernelRequest - Object containing the details of the proof required
+   */
+  getPublicKernelMergeProof(
+    inputs: PublicKernelCircuitPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<PublicKernelCircuitPublicInputs>> {
-    return this.enqueue(
-      { type: ProvingRequestType.PUBLIC_KERNEL_NON_TAIL, kernelType: kernelRequest.type, inputs: kernelRequest.inputs },
-      signal,
-      epochNumber,
-    );
+    return this.enqueue({ type: ProvingRequestType.PUBLIC_KERNEL_MERGE, inputs }, signal, epochNumber);
   }
 
   /**
@@ -394,15 +412,11 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
    * @param kernelRequest - Object containing the details of the proof required
    */
   getPublicTailProof(
-    kernelRequest: PublicKernelTailRequest,
+    inputs: PublicKernelTailCircuitPrivateInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
-    return this.enqueue(
-      { type: ProvingRequestType.PUBLIC_KERNEL_TAIL, kernelType: kernelRequest.type, inputs: kernelRequest.inputs },
-      signal,
-      epochNumber,
-    );
+    return this.enqueue({ type: ProvingRequestType.PUBLIC_KERNEL_TAIL, inputs }, signal, epochNumber);
   }
 
   /**

package/src/prover-agent/prover-agent.ts

@@ -161,18 +161,16 @@ export class ProverAgent {
         return this.circuitProver.getAvmProof(inputs);
       }
 
-      case ProvingRequestType.PUBLIC_KERNEL_NON_TAIL: {
-        return this.circuitProver.getPublicKernelProof({
-          type: request.kernelType,
-          inputs,
-        });
+      case ProvingRequestType.PUBLIC_KERNEL_INNER: {
+        return this.circuitProver.getPublicKernelInnerProof(inputs);
+      }
+
+      case ProvingRequestType.PUBLIC_KERNEL_MERGE: {
+        return this.circuitProver.getPublicKernelMergeProof(inputs);
       }
 
       case ProvingRequestType.PUBLIC_KERNEL_TAIL: {
-        return this.circuitProver.getPublicTailProof({
-          type: request.kernelType,
-          inputs,
-        });
+        return this.circuitProver.getPublicTailProof(inputs);
       }
 
       case ProvingRequestType.BASE_ROLLUP: {
@@ -187,6 +185,10 @@ export class ProverAgent {
         return this.circuitProver.getBlockRootRollupProof(inputs);
       }
 
+      case ProvingRequestType.BLOCK_ROOT_ROLLUP_FINAL: {
+        return this.circuitProver.getBlockRootRollupFinalProof(inputs);
+      }
+
       case ProvingRequestType.BLOCK_MERGE_ROLLUP: {
         return this.circuitProver.getBlockMergeRollupProof(inputs);
       }

package/src/prover-agent/rpc.ts

@@ -1,6 +1,7 @@
 import { type ProvingJobSource } from '@aztec/circuit-types';
 import {
   AvmCircuitInputs,
+  AvmVerificationKeyData,
   AztecAddress,
   BaseOrMergeRollupPublicInputs,
   BaseParityInputs,
@@ -18,6 +19,7 @@ import {
   Proof,
   PublicKernelCircuitPrivateInputs,
   PublicKernelCircuitPublicInputs,
+  PublicKernelInnerCircuitPrivateInputs,
   PublicKernelTailCircuitPrivateInputs,
   RecursiveProof,
   RootParityInput,
@@ -25,6 +27,7 @@ import {
   RootRollupInputs,
   RootRollupPublicInputs,
   TubeInputs,
+  VMCircuitPublicInputs,
   VerificationKeyData,
 } from '@aztec/circuits.js';
 import { createJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
@@ -37,6 +40,7 @@ export function createProvingJobSourceServer(queue: ProvingJobSource): JsonRpcSe
   return new JsonRpcServer(
     queue,
     {
+      AvmVerificationKeyData,
       AvmCircuitInputs,
       BaseOrMergeRollupPublicInputs,
       BaseParityInputs,
@@ -49,6 +53,8 @@ export function createProvingJobSourceServer(queue: ProvingJobSource): JsonRpcSe
       Proof,
       ProvingError,
       PrivateKernelEmptyInputData,
+      VMCircuitPublicInputs,
+      PublicKernelInnerCircuitPrivateInputs,
       PublicKernelCircuitPrivateInputs,
       PublicKernelCircuitPublicInputs,
       PublicKernelTailCircuitPrivateInputs,
@@ -75,6 +81,7 @@ export function createProvingJobSourceClient(
   return createJsonRpcClient(
     url,
     {
+      AvmVerificationKeyData,
       AvmCircuitInputs,
       BaseOrMergeRollupPublicInputs,
       BaseParityInputs,
@@ -87,6 +94,8 @@ export function createProvingJobSourceClient(
       Proof,
       ProvingError,
       PrivateKernelEmptyInputData,
+      VMCircuitPublicInputs,
+      PublicKernelInnerCircuitPrivateInputs,
       PublicKernelCircuitPrivateInputs,
       PublicKernelCircuitPublicInputs,
       PublicKernelTailCircuitPrivateInputs,

package/src/test/mock_prover.ts

@@ -0,0 +1,170 @@
+import {
+  type PublicInputsAndRecursiveProof,
+  type PublicInputsAndTubeProof,
+  type ServerCircuitProver,
+  makePublicInputsAndRecursiveProof,
+} from '@aztec/circuit-types';
+import {
+  AvmVerificationKeyData,
+  type BaseOrMergeRollupPublicInputs,
+  type BlockRootOrBlockMergePublicInputs,
+  type KernelCircuitPublicInputs,
+  type PublicKernelCircuitPublicInputs,
+  RECURSIVE_PROOF_LENGTH,
+  type RecursiveProof,
+  type RootRollupPublicInputs,
+  type VMCircuitPublicInputs,
+  VerificationKeyData,
+  makeEmptyProof,
+  makeRecursiveProof,
+} from '@aztec/circuits.js';
+import {
+  makeBaseOrMergeRollupPublicInputs,
+  makeBlockRootOrBlockMergeRollupPublicInputs,
+  makeKernelCircuitPublicInputs,
+  makePublicKernelCircuitPublicInputs,
+  makeRootParityInput,
+  makeRootRollupPublicInputs,
+  makeVMCircuitPublicInputs,
+} from '@aztec/circuits.js/testing';
+
+export class MockProver implements ServerCircuitProver {
+  constructor() {}
+
+  getAvmProof() {
+    return Promise.resolve(
+      Promise.resolve({
+        proof: makeEmptyProof(),
+        verificationKey: AvmVerificationKeyData.makeFake(),
+      }),
+    );
+  }
+
+  getBaseParityProof() {
+    return Promise.resolve(makeRootParityInput(RECURSIVE_PROOF_LENGTH));
+  }
+
+  getRootParityProof() {
+    return Promise.resolve(makeRootParityInput(RECURSIVE_PROOF_LENGTH));
+  }
+
+  getBaseRollupProof() {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBaseOrMergeRollupPublicInputs(),
+        makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
+        VerificationKeyData.makeFake(),
+      ),
+    );
+  }
+
+  getMergeRollupProof(): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBaseOrMergeRollupPublicInputs(),
+        makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
+        VerificationKeyData.makeFake(),
+      ),
+    );
+  }
+
+  getBlockMergeRollupProof() {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
+        VerificationKeyData.makeFake(),
+      ),
+    );
+  }
+
+  getBlockRootRollupProof(): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
+        VerificationKeyData.makeFake(),
+      ),
+    );
+  }
+
+  getBlockRootRollupFinalProof(): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeBlockRootOrBlockMergeRollupPublicInputs(),
+        makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
+        VerificationKeyData.makeFake(),
+      ),
+    );
+  }
+
+  getEmptyPrivateKernelProof(): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeKernelCircuitPublicInputs(),
+        makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
+        VerificationKeyData.makeFake(),
+      ),
+    );
+  }
+
+  getEmptyTubeProof(): Promise<PublicInputsAndTubeProof<KernelCircuitPublicInputs>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeKernelCircuitPublicInputs(),
+        makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
+        VerificationKeyData.makeFake(),
+      ),
+    );
+  }
+
+  getPublicKernelInnerProof(): Promise<PublicInputsAndRecursiveProof<VMCircuitPublicInputs>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeVMCircuitPublicInputs(),
+        makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
+        VerificationKeyData.makeFake(),
+      ),
+    );
+  }
+
+  getPublicKernelMergeProof(): Promise<PublicInputsAndRecursiveProof<PublicKernelCircuitPublicInputs>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makePublicKernelCircuitPublicInputs(),
+        makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
+        VerificationKeyData.makeFake(),
+      ),
+    );
+  }
+
+  getPublicTailProof(): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeKernelCircuitPublicInputs(),
+        makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
+        VerificationKeyData.makeFake(),
+      ),
+    );
+  }
+
+  getRootRollupProof(): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>> {
+    return Promise.resolve(
+      makePublicInputsAndRecursiveProof(
+        makeRootRollupPublicInputs(),
+        makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
+        VerificationKeyData.makeFake(),
+      ),
+    );
+  }
+
+  getTubeProof(): Promise<{
+    tubeVK: VerificationKeyData;
+    tubeProof: RecursiveProof<typeof RECURSIVE_PROOF_LENGTH>;
+  }> {
+    return Promise.resolve({
+      tubeVK: VerificationKeyData.makeFake(),
+      tubeProof: makeRecursiveProof(RECURSIVE_PROOF_LENGTH),
+    });
+  }
+}

package/dest/orchestrator/proving-state.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"proving-state.d.ts","sourceRoot":"","sources":["../../src/orchestrator/proving-state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC3F,OAAO,EACL,KAAK,sBAAsB,EAC3B,KAAK,6BAA6B,EAClC,KAAK,iCAAiC,EACtC,KAAK,EAAE,EACP,KAAK,eAAe,EACpB,KAAK,wCAAwC,EAC7C,KAAK,6BAA6B,EAClC,KAAK,mCAAmC,EACxC,KAAK,KAAK,EACV,KAAK,sBAAsB,EAC3B,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC7B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAEzD,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,CAAC,6BAA6B,GAAG,SAAS,EAAE,6BAA6B,GAAG,SAAS,CAAC,CAAC;IAC/F,MAAM,EAAE;QACN,cAAc,CAAC,OAAO,6BAA6B,CAAC,GAAG,SAAS;QAChE,cAAc,CAAC,OAAO,6BAA6B,CAAC,GAAG,SAAS;KACjE,CAAC;IACF,gBAAgB,EAAE,CAAC,uBAAuB,GAAG,SAAS,EAAE,uBAAuB,GAAG,SAAS,CAAC,CAAC;CAC9F,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,YAAY,EAAE,sBAAsB,CAAC,CAAC;AAStE;;;;GAIG;AACH,qBAAa,YAAY;aAUL,WAAW,EAAE,MAAM;IACnC,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,iBAAiB;aACT,eAAe,EAAE,eAAe;aAChC,iBAAiB,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,mCAAmC,CAAC;aAExE,mBAAmB,EAAE,sBAAsB;aAC3C,0BAA0B,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,wCAAwC,CAAC;IAhBxG,OAAO,CAAC,qBAAqB,CAAiD;IAC9E,OAAO,CAAC,iBAAiB,CAA8B;IACvD,OAAO,CAAC,gBAAgB,CAAyE;IACjG,OAAO,CAAC,qBAAqB,CAAoE;IAC1F,2BAA2B,EAAE,iCAAiC,GAAG,SAAS,CAAC;IAC3E,UAAU,EAAE,KAAK,GAAG,SAAS,CAAC;IAC9B,KAAK,EAAE,OAAO,GAAG,SAAS,CAAC;IAClC,OAAO,CAAC,GAAG,CAAwB;gBAEjB,WAAW,EAAE,MAAM,EAC3B,kBAAkB,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,EACnD,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EACnC,eAAe,EAAE,eAAe,EAChC,iBAAiB,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,mCAAmC,CAAC,EACxF,mBAAmB,EAAE,MAAM,EACX,mBAAmB,EAAE,sBAAsB,EAC3C,0BAA0B,EAAE,KAAK,CAAC,EAAE,EAAE,OAAO,wCAAwC,CAAC;IAMxG,IAAW,cAAc,WAExB;IAIM,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;IA0BzD,QAAQ,CAAC,EAAE,EAAE,cAAc;IASlC,IAAW,oBAAoB,WAE9B;IAGD,IAAW,oBAAoB,IAKQ,eAAe,CAAC,OAAO,6BAA6B,CAAC,GAAG,SAAS,CAHvG;IAGD,IAAW,oBAAoB,CAAC,KAAK,EAAE,eAAe,CAAC,OAAO,6BAA6B,CAAC,GAAG,SAAS,EAEvG;IAGD,IAAW,eAAe,yCAEzB;IAGM,WAAW;IAQX,uBAAuB;IAK9B,IAAW,MAAM,qBAEhB;IAED,yFAAyF;IACzF,IAAW,WAAW,IAAI,MAAM,CAE/B;IAED;;;;;;OAMG;IACI,gBAAgB,CACrB,WAAW,EAAE;QACX,6BAA6B;QAC7B,cAAc,CAAC,OAAO,6BAA6B,CAAC;QACpD,uBAAuB;KACxB,EACD,gBAAgB,EAAE,MAAM,EACxB,YAAY,EAAE,MAAM;IAsBf,iBAAiB,CAAC,OAAO,EAAE,MAAM;IAKjC,cAAc,CAAC,YAAY,EAAE,MAAM;IAKnC,yBAAyB;IASzB,mBAAmB,CAAC,MAAM,EAAE,eAAe,CAAC,OAAO,sBAAsB,CAAC,EAAE,KAAK,EAAE,MAAM;IAKzF,wBAAwB;IAKxB,MAAM;IAMN,MAAM,CAAC,MAAM,EAAE,MAAM;IAUrB,OAAO,CAAC,MAAM,EAAE,aAAa;CAOrC"}