@waku/rln 0.1.3-f6d5deb → 0.1.4-2a94244.0

package/src/rln.ts

@@ -4,6 +4,7 @@ import type {
   IDecodedMessage,
   EncoderOptions as WakuEncoderOptions
 } from "@waku/interfaces";
+import { Logger } from "@waku/utils";
 import init from "@waku/zerokit-rln-wasm";
 import * as zerokitRLN from "@waku/zerokit-rln-wasm";
 import { ethers } from "ethers";
@@ -14,6 +15,7 @@ import {
   type RLNDecoder,
   type RLNEncoder
 } from "./codec.js";
+import { DEFAULT_RATE_LIMIT } from "./contract/constants.js";
 import { RLNContract, SEPOLIA_CONTRACT } from "./contract/index.js";
 import { IdentityCredential } from "./identity.js";
 import { Keystore } from "./keystore/index.js";
@@ -22,22 +24,55 @@ import type {
   EncryptedCredentials
 } from "./keystore/index.js";
 import { KeystoreEntity, Password } from "./keystore/types.js";
-import verificationKey from "./resources/verification_key.js";
-import * as wc from "./resources/witness_calculator.js";
-import { WitnessCalculator } from "./resources/witness_calculator.js";
+import verificationKey from "./resources/verification_key";
+import * as wc from "./resources/witness_calculator";
+import { WitnessCalculator } from "./resources/witness_calculator";
 import { extractMetaMaskSigner } from "./utils/index.js";
 import { Zerokit } from "./zerokit.js";
 
+const log = new Logger("waku:rln");
+
 async function loadWitnessCalculator(): Promise<WitnessCalculator> {
-  const url = new URL("./resources/rln.wasm", import.meta.url);
-  const response = await fetch(url);
-  return await wc.builder(new Uint8Array(await response.arrayBuffer()), false);
+  try {
+    const url = new URL("./resources/rln.wasm", import.meta.url);
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch witness calculator: ${response.status} ${response.statusText}`
+      );
+    }
+
+    return await wc.builder(
+      new Uint8Array(await response.arrayBuffer()),
+      false
+    );
+  } catch (error) {
+    log.error("Error loading witness calculator:", error);
+    throw new Error(
+      `Failed to load witness calculator: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
 }
 
 async function loadZkey(): Promise<Uint8Array> {
-  const url = new URL("./resources/rln_final.zkey", import.meta.url);
-  const response = await fetch(url);
-  return new Uint8Array(await response.arrayBuffer());
+  try {
+    const url = new URL("./resources/rln_final.zkey", import.meta.url);
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch zkey: ${response.status} ${response.statusText}`
+      );
+    }
+
+    return new Uint8Array(await response.arrayBuffer());
+  } catch (error) {
+    log.error("Error loading zkey:", error);
+    throw new Error(
+      `Failed to load zkey: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
 }
 
 /**
@@ -45,21 +80,26 @@ async function loadZkey(): Promise<Uint8Array> {
  * @returns RLNInstance
  */
 export async function create(): Promise<RLNInstance> {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  await (init as any)?.();
-  zerokitRLN.init_panic_hook();
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    await (init as any)?.();
+    zerokitRLN.init_panic_hook();
 
-  const witnessCalculator = await loadWitnessCalculator();
-  const zkey = await loadZkey();
+    const witnessCalculator = await loadWitnessCalculator();
+    const zkey = await loadZkey();
 
-  const stringEncoder = new TextEncoder();
-  const vkey = stringEncoder.encode(JSON.stringify(verificationKey));
+    const stringEncoder = new TextEncoder();
+    const vkey = stringEncoder.encode(JSON.stringify(verificationKey));
 
-  const DEPTH = 20;
-  const zkRLN = zerokitRLN.newRLN(DEPTH, zkey, vkey);
-  const zerokit = new Zerokit(zkRLN, witnessCalculator);
+    const DEPTH = 20;
+    const zkRLN = zerokitRLN.newRLN(DEPTH, zkey, vkey);
+    const zerokit = new Zerokit(zkRLN, witnessCalculator, DEFAULT_RATE_LIMIT);
 
-  return new RLNInstance(zerokit);
+    return new RLNInstance(zerokit);
+  } catch (error) {
+    log.error("Failed to initialize RLN:", error);
+    throw error;
+  }
 }
 
 type StartRLNOptions = {
@@ -70,12 +110,16 @@ type StartRLNOptions = {
   /**
    * If not set - will use default SEPOLIA_CONTRACT address.
    */
-  registryAddress?: string;
+  address?: string;
   /**
    * Credentials to use for generating proofs and connecting to the contract and network.
    * If provided used for validating the network chainId and connecting to registry contract.
    */
   credentials?: EncryptedCredentials | DecryptedCredentials;
+  /**
+   * Rate limit for the member.
+   */
+  rateLimit?: number;
 };
 
 type RegisterMembershipOptions =
@@ -96,7 +140,7 @@ export class RLNInstance {
   private keystore = Keystore.create();
   private _credentials: undefined | DecryptedCredentials;
 
-  constructor(public zerokit: Zerokit) {}
+  public constructor(public zerokit: Zerokit) {}
 
   public get contract(): undefined | RLNContract {
     return this._contract;
@@ -116,7 +160,7 @@ export class RLNInstance {
     try {
       const { credentials, keystore } =
         await RLNInstance.decryptCredentialsIfNeeded(options.credentials);
-      const { signer, registryAddress } = await this.determineStartOptions(
+      const { signer, address } = await this.determineStartOptions(
         options,
         credentials
       );
@@ -128,8 +172,9 @@ export class RLNInstance {
       this._credentials = credentials;
       this._signer = signer!;
       this._contract = await RLNContract.init(this, {
-        registryAddress: registryAddress!,
-        signer: signer!
+        address: address!,
+        signer: signer!,
+        rateLimit: options.rateLimit ?? this.zerokit.getRateLimit
       });
       this.started = true;
     } finally {
@@ -142,12 +187,12 @@ export class RLNInstance {
     credentials: KeystoreEntity | undefined
   ): Promise<StartRLNOptions> {
     let chainId = credentials?.membership.chainId;
-    const registryAddress =
+    const address =
       credentials?.membership.address ||
-      options.registryAddress ||
+      options.address ||
       SEPOLIA_CONTRACT.address;
 
-    if (registryAddress === SEPOLIA_CONTRACT.address) {
+    if (address === SEPOLIA_CONTRACT.address) {
       chainId = SEPOLIA_CONTRACT.chainId;
     }
 
@@ -162,7 +207,7 @@ export class RLNInstance {
 
     return {
       signer,
-      registryAddress
+      address
     };
   }
 
@@ -258,7 +303,7 @@ export class RLNInstance {
     }
 
     const registryAddress = credentials.membership.address;
-    const currentRegistryAddress = this._contract.registry.address;
+    const currentRegistryAddress = this._contract.address;
     if (registryAddress !== currentRegistryAddress) {
       throw Error(
         `Failed to verify chain coordinates: credentials contract address=${registryAddress} is not equal to registryContract address=${currentRegistryAddress}`
@@ -266,7 +311,7 @@ export class RLNInstance {
     }
 
     const chainId = credentials.membership.chainId;
-    const network = await this._contract.registry.provider.getNetwork();
+    const network = await this._contract.provider.getNetwork();
     const currentChainId = network.chainId;
     if (chainId !== currentChainId) {
       throw Error(

package/src/root_tracker.ts

@@ -1,5 +1,5 @@
 class RootPerBlock {
-  constructor(
+  public constructor(
     public root: Uint8Array,
     public blockNumber: number
   ) {}
@@ -10,14 +10,15 @@ const maxBufferSize = 20;
 export class MerkleRootTracker {
   private validMerkleRoots: Array<RootPerBlock> = new Array<RootPerBlock>();
   private merkleRootBuffer: Array<RootPerBlock> = new Array<RootPerBlock>();
-  constructor(
+
+  public constructor(
     private acceptableRootWindowSize: number,
     initialRoot: Uint8Array
   ) {
     this.pushRoot(0, initialRoot);
   }
 
-  backFill(fromBlockNumber: number): void {
+  public backFill(fromBlockNumber: number): void {
     if (this.validMerkleRoots.length == 0) return;
 
     let numBlocks = 0;
@@ -66,7 +67,7 @@ export class MerkleRootTracker {
     }
   }
 
-  pushRoot(blockNumber: number, root: Uint8Array): void {
+  public pushRoot(blockNumber: number, root: Uint8Array): void {
     this.validMerkleRoots.push(new RootPerBlock(root, blockNumber));
 
     // Maintain valid merkle root window
@@ -81,11 +82,11 @@ export class MerkleRootTracker {
     }
   }
 
-  roots(): Array<Uint8Array> {
+  public roots(): Array<Uint8Array> {
     return this.validMerkleRoots.map((x) => x.root);
   }
 
-  buffer(): Array<Uint8Array> {
+  public buffer(): Array<Uint8Array> {
     return this.merkleRootBuffer.map((x) => x.root);
   }
 }

package/src/utils/bytes.ts

@@ -0,0 +1,84 @@
+/**
+ * Concatenate Uint8Arrays
+ * @param input
+ * @returns concatenation of all Uint8Array received as input
+ */
+export function concatenate(...input: Uint8Array[]): Uint8Array {
+  let totalLength = 0;
+  for (const arr of input) {
+    totalLength += arr.length;
+  }
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of input) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+
+// Adapted from https://github.com/feross/buffer
+function checkInt(
+  buf: Uint8Array,
+  value: number,
+  offset: number,
+  ext: number,
+  max: number,
+  min: number
+): void {
+  if (value > max || value < min)
+    throw new RangeError('"value" argument is out of bounds');
+  if (offset + ext > buf.length) throw new RangeError("Index out of range");
+}
+
+export function writeUIntLE(
+  buf: Uint8Array,
+  value: number,
+  offset: number,
+  byteLength: number,
+  noAssert?: boolean
+): Uint8Array {
+  value = +value;
+  offset = offset >>> 0;
+  byteLength = byteLength >>> 0;
+  if (!noAssert) {
+    const maxBytes = Math.pow(2, 8 * byteLength) - 1;
+    checkInt(buf, value, offset, byteLength, maxBytes, 0);
+  }
+
+  let mul = 1;
+  let i = 0;
+  buf[offset] = value & 0xff;
+  while (++i < byteLength && (mul *= 0x100)) {
+    buf[offset + i] = (value / mul) & 0xff;
+  }
+
+  return buf;
+}
+
+/**
+ * Transforms Uint8Array into BigInt
+ * @param array: Uint8Array
+ * @returns BigInt
+ */
+export function buildBigIntFromUint8Array(
+  array: Uint8Array,
+  byteOffset: number = 0
+): bigint {
+  const dataView = new DataView(array.buffer);
+  return dataView.getBigUint64(byteOffset, true);
+}
+
+/**
+ * Fills with zeros to set length
+ * @param array little endian Uint8Array
+ * @param length amount to pad
+ * @returns little endian Uint8Array padded with zeros to set length
+ */
+export function zeroPadLE(array: Uint8Array, length: number): Uint8Array {
+  const result = new Uint8Array(length);
+  for (let i = 0; i < length; i++) {
+    result[i] = array[i] || 0;
+  }
+  return result;
+}

package/src/utils/epoch.ts

@@ -0,0 +1,30 @@
+import { Logger } from "@waku/utils";
+
+const DefaultEpochUnitSeconds = 10; // the rln-relay epoch length in seconds
+
+const log = new Logger("waku:rln:epoch");
+
+export function dateToEpoch(
+  timestamp: Date,
+  epochUnitSeconds: number = DefaultEpochUnitSeconds
+): number {
+  const time = timestamp.getTime();
+  const epoch = Math.floor(time / 1000 / epochUnitSeconds);
+  log.info("generated epoch", epoch);
+  return epoch;
+}
+
+export function epochIntToBytes(epoch: number): Uint8Array {
+  const bytes = new Uint8Array(32);
+  const db = new DataView(bytes.buffer);
+  db.setUint32(0, epoch, true);
+  log.info("encoded epoch", epoch, bytes);
+  return bytes;
+}
+
+export function epochBytesToInt(bytes: Uint8Array): number {
+  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const epoch = dv.getUint32(0, true);
+  log.info("decoded epoch", epoch, bytes);
+  return epoch;
+}

package/src/utils/hash.ts

@@ -0,0 +1,15 @@
+import * as zerokitRLN from "@waku/zerokit-rln-wasm";
+
+import { concatenate, writeUIntLE } from "./bytes.js";
+
+export function poseidonHash(...input: Array<Uint8Array>): Uint8Array {
+  const inputLen = writeUIntLE(new Uint8Array(8), input.length, 0, 8);
+  const lenPrefixedData = concatenate(inputLen, ...input);
+  return zerokitRLN.poseidonHash(lenPrefixedData);
+}
+
+export function sha256(input: Uint8Array): Uint8Array {
+  const inputLen = writeUIntLE(new Uint8Array(8), input.length, 0, 8);
+  const lenPrefixedData = concatenate(inputLen, input);
+  return zerokitRLN.hash(lenPrefixedData);
+}

package/src/utils/index.ts

@@ -0,0 +1,9 @@
+export { extractMetaMaskSigner } from "./metamask.js";
+export {
+  concatenate,
+  writeUIntLE,
+  buildBigIntFromUint8Array,
+  zeroPadLE
+} from "./bytes.js";
+export { sha256, poseidonHash } from "./hash.js";
+export { dateToEpoch, epochIntToBytes, epochBytesToInt } from "./epoch.js";

package/src/utils/metamask.ts

@@ -0,0 +1,17 @@
+import { ethers } from "ethers";
+
+export const extractMetaMaskSigner = async (): Promise<ethers.Signer> => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const ethereum = (window as any).ethereum;
+
+  if (!ethereum) {
+    throw Error(
+      "Missing or invalid Ethereum provider. Please install a Web3 wallet such as MetaMask."
+    );
+  }
+
+  await ethereum.request({ method: "eth_requestAccounts" });
+  const provider = new ethers.providers.Web3Provider(ethereum, "any");
+
+  return provider.getSigner();
+};

package/src/zerokit.ts

@@ -1,9 +1,10 @@
 import type { IRateLimitProof } from "@waku/interfaces";
 import * as zerokitRLN from "@waku/zerokit-rln-wasm";
 
+import { DEFAULT_RATE_LIMIT, RATE_LIMIT_PARAMS } from "./contract/constants.js";
 import { IdentityCredential } from "./identity.js";
 import { Proof, proofToBytes } from "./proof.js";
-import { WitnessCalculator } from "./resources/witness_calculator.js";
+import { WitnessCalculator } from "./resources/witness_calculator";
 import {
   concatenate,
   dateToEpoch,
@@ -12,17 +13,30 @@ import {
 } from "./utils/index.js";
 
 export class Zerokit {
-  constructor(
-    private zkRLN: number,
-    private witnessCalculator: WitnessCalculator
+  public constructor(
+    private readonly zkRLN: number,
+    private readonly witnessCalculator: WitnessCalculator,
+    private readonly rateLimit: number = DEFAULT_RATE_LIMIT
   ) {}
 
-  generateIdentityCredentials(): IdentityCredential {
+  public get getZkRLN(): number {
+    return this.zkRLN;
+  }
+
+  public get getWitnessCalculator(): WitnessCalculator {
+    return this.witnessCalculator;
+  }
+
+  public get getRateLimit(): number {
+    return this.rateLimit;
+  }
+
+  public generateIdentityCredentials(): IdentityCredential {
     const memKeys = zerokitRLN.generateExtendedMembershipKey(this.zkRLN); // TODO: rename this function in zerokit rln-wasm
     return IdentityCredential.fromBytes(memKeys);
   }
 
-  generateSeededIdentityCredential(seed: string): IdentityCredential {
+  public generateSeededIdentityCredential(seed: string): IdentityCredential {
     const stringEncoder = new TextEncoder();
     const seedBytes = stringEncoder.encode(seed);
     // TODO: rename this function in zerokit rln-wasm
@@ -33,11 +47,14 @@ export class Zerokit {
     return IdentityCredential.fromBytes(memKeys);
   }
 
-  insertMember(idCommitment: Uint8Array): void {
+  public insertMember(idCommitment: Uint8Array): void {
     zerokitRLN.insertMember(this.zkRLN, idCommitment);
   }
 
-  insertMembers(index: number, ...idCommitments: Array<Uint8Array>): void {
+  public insertMembers(
+    index: number,
+    ...idCommitments: Array<Uint8Array>
+  ): void {
     // serializes a seq of IDCommitments to a byte seq
     // the order of serialization is |id_commitment_len<8>|id_commitment<var>|
     const idCommitmentLen = writeUIntLE(
@@ -50,51 +67,75 @@ export class Zerokit {
     zerokitRLN.setLeavesFrom(this.zkRLN, index, idCommitmentBytes);
   }
 
-  deleteMember(index: number): void {
+  public deleteMember(index: number): void {
     zerokitRLN.deleteLeaf(this.zkRLN, index);
   }
 
-  getMerkleRoot(): Uint8Array {
+  public getMerkleRoot(): Uint8Array {
     return zerokitRLN.getRoot(this.zkRLN);
   }
 
-  serializeMessage(
+  public serializeMessage(
     uint8Msg: Uint8Array,
     memIndex: number,
     epoch: Uint8Array,
-    idKey: Uint8Array
+    idKey: Uint8Array,
+    rateLimit?: number
   ): Uint8Array {
     // calculate message length
     const msgLen = writeUIntLE(new Uint8Array(8), uint8Msg.length, 0, 8);
-
-    // Converting index to LE bytes
     const memIndexBytes = writeUIntLE(new Uint8Array(8), memIndex, 0, 8);
+    const rateLimitBytes = writeUIntLE(
+      new Uint8Array(8),
+      rateLimit ?? this.rateLimit,
+      0,
+      8
+    );
 
-    // [ id_key<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
-    return concatenate(idKey, memIndexBytes, epoch, msgLen, uint8Msg);
+    // [ id_key<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> | rate_limit<8> ]
+    return concatenate(
+      idKey,
+      memIndexBytes,
+      epoch,
+      msgLen,
+      uint8Msg,
+      rateLimitBytes
+    );
   }
 
-  async generateRLNProof(
+  public async generateRLNProof(
     msg: Uint8Array,
     index: number,
     epoch: Uint8Array | Date | undefined,
-    idSecretHash: Uint8Array
+    idSecretHash: Uint8Array,
+    rateLimit?: number
   ): Promise<IRateLimitProof> {
-    if (epoch == undefined) {
+    if (epoch === undefined) {
       epoch = epochIntToBytes(dateToEpoch(new Date()));
     } else if (epoch instanceof Date) {
       epoch = epochIntToBytes(dateToEpoch(epoch));
     }
 
-    if (epoch.length != 32) throw "invalid epoch";
-    if (idSecretHash.length != 32) throw "invalid id secret hash";
-    if (index < 0) throw "index must be >= 0";
+    const effectiveRateLimit = rateLimit ?? this.rateLimit;
+
+    if (epoch.length !== 32) throw new Error("invalid epoch");
+    if (idSecretHash.length !== 32) throw new Error("invalid id secret hash");
+    if (index < 0) throw new Error("index must be >= 0");
+    if (
+      effectiveRateLimit < RATE_LIMIT_PARAMS.MIN_RATE ||
+      effectiveRateLimit > RATE_LIMIT_PARAMS.MAX_RATE
+    ) {
+      throw new Error(
+        `Rate limit must be between ${RATE_LIMIT_PARAMS.MIN_RATE} and ${RATE_LIMIT_PARAMS.MAX_RATE}`
+      );
+    }
 
     const serialized_msg = this.serializeMessage(
       msg,
       index,
       epoch,
-      idSecretHash
+      idSecretHash,
+      effectiveRateLimit
     );
     const rlnWitness = zerokitRLN.getSerializedRLNWitness(
       this.zkRLN,
@@ -104,7 +145,7 @@ export class Zerokit {
     const calculatedWitness = await this.witnessCalculator.calculateWitness(
       inputs,
       false
-    ); // no sanity check being used in zerokit
+    );
 
     const proofBytes = zerokitRLN.generate_rln_proof_with_witness(
       this.zkRLN,
@@ -115,9 +156,10 @@ export class Zerokit {
     return new Proof(proofBytes);
   }
 
-  verifyRLNProof(
+  public verifyRLNProof(
     proof: IRateLimitProof | Uint8Array,
-    msg: Uint8Array
+    msg: Uint8Array,
+    rateLimit?: number
   ): boolean {
     let pBytes: Uint8Array;
     if (proof instanceof Uint8Array) {
@@ -128,17 +170,24 @@ export class Zerokit {
 
     // calculate message length
     const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+    const rateLimitBytes = writeUIntLE(
+      new Uint8Array(8),
+      rateLimit ?? this.rateLimit,
+      0,
+      8
+    );
 
     return zerokitRLN.verifyRLNProof(
       this.zkRLN,
-      concatenate(pBytes, msgLen, msg)
+      concatenate(pBytes, msgLen, msg, rateLimitBytes)
     );
   }
 
-  verifyWithRoots(
+  public verifyWithRoots(
     proof: IRateLimitProof | Uint8Array,
     msg: Uint8Array,
-    ...roots: Array<Uint8Array>
+    roots: Array<Uint8Array>,
+    rateLimit?: number
   ): boolean {
     let pBytes: Uint8Array;
     if (proof instanceof Uint8Array) {
@@ -148,19 +197,26 @@ export class Zerokit {
     }
     // calculate message length
     const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+    const rateLimitBytes = writeUIntLE(
+      new Uint8Array(8),
+      rateLimit ?? this.rateLimit,
+      0,
+      8
+    );
 
     const rootsBytes = concatenate(...roots);
 
     return zerokitRLN.verifyWithRoots(
       this.zkRLN,
-      concatenate(pBytes, msgLen, msg),
+      concatenate(pBytes, msgLen, msg, rateLimitBytes),
       rootsBytes
     );
   }
 
-  verifyWithNoRoot(
+  public verifyWithNoRoot(
     proof: IRateLimitProof | Uint8Array,
-    msg: Uint8Array
+    msg: Uint8Array,
+    rateLimit?: number
   ): boolean {
     let pBytes: Uint8Array;
     if (proof instanceof Uint8Array) {
@@ -171,10 +227,16 @@ export class Zerokit {
 
     // calculate message length
     const msgLen = writeUIntLE(new Uint8Array(8), msg.length, 0, 8);
+    const rateLimitBytes = writeUIntLE(
+      new Uint8Array(8),
+      rateLimit ?? this.rateLimit,
+      0,
+      8
+    );
 
     return zerokitRLN.verifyWithRoots(
       this.zkRLN,
-      concatenate(pBytes, msgLen, msg),
+      concatenate(pBytes, msgLen, msg, rateLimitBytes),
       new Uint8Array()
     );
   }

package/dist/resources/verification_key.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"verification_key.js","sourceRoot":"","sources":["../../src/resources/verification_key.js"],"names":[],"mappings":"AAAA,MAAM,eAAe,GAAG;IACtB,QAAQ,EAAE,SAAS;IACnB,KAAK,EAAE,OAAO;IACd,OAAO,EAAE,CAAC;IACV,UAAU,EAAE;QACV,+EAA+E;QAC/E,8EAA8E;QAC9E,GAAG;KACJ;IACD,SAAS,EAAE;QACT;YACE,8EAA8E;YAC9E,+EAA+E;SAChF;QACD;YACE,+EAA+E;YAC/E,6EAA6E;SAC9E;QACD,CAAC,GAAG,EAAE,GAAG,CAAC;KACX;IACD,UAAU,EAAE;QACV;YACE,+EAA+E;YAC/E,+EAA+E;SAChF;QACD;YACE,8EAA8E;YAC9E,8EAA8E;SAC/E;QACD,CAAC,GAAG,EAAE,GAAG,CAAC;KACX;IACD,UAAU,EAAE;QACV;YACE,8EAA8E;YAC9E,8EAA8E;SAC/E;QACD;YACE,+EAA+E;YAC/E,+EAA+E;SAChF;QACD,CAAC,GAAG,EAAE,GAAG,CAAC;KACX;IACD,eAAe,EAAE;QACf;YACE;gBACE,+EAA+E;gBAC/E,8EAA8E;aAC/E;YACD;gBACE,8EAA8E;gBAC9E,8EAA8E;aAC/E;YACD;gBACE,+EAA+E;gBAC/E,8EAA8E;aAC/E;SACF;QACD;YACE;gBACE,8EAA8E;gBAC9E,+EAA+E;aAChF;YACD;gBACE,8EAA8E;gBAC9E,+EAA+E;aAChF;YACD;gBACE,+EAA+E;gBAC/E,+EAA+E;aAChF;SACF;KACF;IACD,EAAE,EAAE;QACF;YACE,+EAA+E;YAC/E,+EAA+E;YAC/E,GAAG;SACJ;QACD;YACE,+EAA+E;YAC/E,+EAA+E;YAC/E,GAAG;SACJ;QACD;YACE,+EAA+E;YAC/E,+EAA+E;YAC/E,GAAG;SACJ;QACD;YACE,+EAA+E;YAC/E,+EAA+E;YAC/E,GAAG;SACJ;QACD;YACE,+EAA+E;YAC/E,8EAA8E;YAC9E,GAAG;SACJ;QACD;YACE,6EAA6E;YAC7E,+EAA+E;YAC/E,GAAG;SACJ;QACD;YACE,+EAA+E;YAC/E,8EAA8E;YAC9E,GAAG;SACJ;KACF;CACF,CAAC;AAEF,eAAe,eAAe,CAAC"}