@unlink-xyz/core 0.1.3 → 0.1.4

package/account/zkAccount.ts

@@ -1,222 +0,0 @@
-import { Mnemonic } from "../key-derivation/bip39.js";
-import { ByteUtils } from "../key-derivation/bytes.js";
-import {
-  deriveNodesFromSeed,
-  WalletNode,
-  type SpendingKeyPair,
-  type ViewingKeyPair,
-} from "../key-derivation/wallet-node.js";
-import type { Storage } from "../types.js";
-
-export type MasterSeedCrypto = {
-  encrypt(seed: Uint8Array): Promise<Uint8Array> | Uint8Array;
-  decrypt(payload: Uint8Array): Promise<Uint8Array> | Uint8Array;
-};
-
-export type GenerateMasterSeedOptions = {
-  storage: Storage;
-  rng: (n: number) => Uint8Array;
-  crypto?: MasterSeedCrypto;
-  overwrite?: boolean;
-  mnemonicPassphrase: string;
-};
-
-export const MASTER_SEED_LENGTH = 64;
-export const MASTER_SEED_KEY = "cfg:wallet:master_seed/v1";
-export const MASTER_MNEMONIC_KEY = "cfg:wallet:master_mnemonic/v1";
-
-const MNEMONIC_ENTROPY_BYTES = 32;
-
-const textEncoder = new TextEncoder();
-const textDecoder = new TextDecoder();
-
-export type ZkAccount = {
-  spendingKeyPair: SpendingKeyPair;
-  viewingKeyPair: ViewingKeyPair;
-  nullifyingKey: bigint;
-  masterPublicKey: bigint;
-};
-
-export async function deriveZkAccount(
-  masterSeed: Uint8Array,
-  accountIndex: number = 0,
-): Promise<ZkAccount> {
-  const seed = normalizeMasterSeed(masterSeed);
-  if (!Number.isInteger(accountIndex) || accountIndex < 0) {
-    throw new Error("accountIndex must be a non-negative integer");
-  }
-
-  const { spending, viewing } = deriveNodesFromSeed(seed, accountIndex);
-  const spendingKeyPair = spending.getSpendingKeyPair();
-  const viewingKeyPair = await viewing.getViewingKeyPair();
-  const nullifyingKey = WalletNode.getNullifyingKey(viewingKeyPair.privateKey);
-  const masterPublicKey = WalletNode.getMasterPublicKey(
-    spendingKeyPair.pubkey,
-    nullifyingKey,
-  );
-
-  return {
-    spendingKeyPair,
-    viewingKeyPair,
-    nullifyingKey,
-    masterPublicKey,
-  };
-}
-
-export async function deriveZkAccountFromMnemonic(
-  mnemonic: string,
-  accountIndex: number = 0,
-  password: string = "",
-): Promise<ZkAccount> {
-  const normalized = normalizeMnemonic(mnemonic);
-  const seed = mnemonicToSeed(normalized, password);
-  return deriveZkAccount(seed, accountIndex);
-}
-
-const identityMasterSeedCrypto: MasterSeedCrypto = {
-  encrypt(seed) {
-    return clone(seed);
-  },
-  decrypt(payload) {
-    return clone(payload);
-  },
-};
-
-export async function generateMasterSeed({
-  storage,
-  rng,
-  crypto = identityMasterSeedCrypto,
-  overwrite = false,
-  mnemonicPassphrase,
-}: GenerateMasterSeedOptions): Promise<Uint8Array> {
-  if (!overwrite) {
-    const existingSeed = await loadMasterSeed(storage, crypto);
-    if (existingSeed) return existingSeed;
-
-    const existingMnemonic = await loadMasterMnemonic(storage, crypto);
-    if (existingMnemonic) {
-      const seedFromMnemonic = mnemonicToSeed(
-        existingMnemonic,
-        mnemonicPassphrase,
-      );
-      await storeMasterSeed(storage, seedFromMnemonic, crypto);
-      return seedFromMnemonic;
-    }
-  }
-
-  const entropy = rng(MNEMONIC_ENTROPY_BYTES);
-  if (entropy.length !== MNEMONIC_ENTROPY_BYTES) {
-    throw new Error(`mnemonic entropy must be ${MNEMONIC_ENTROPY_BYTES} bytes`);
-  }
-
-  const mnemonic = Mnemonic.fromEntropy(ByteUtils.bytesToHex(entropy));
-  await storeMasterMnemonic(storage, mnemonic, crypto);
-  const seed = mnemonicToSeed(mnemonic, mnemonicPassphrase);
-  await storeMasterSeed(storage, seed, crypto);
-  return seed;
-}
-
-export async function loadMasterSeed(
-  storage: Storage,
-  crypto: MasterSeedCrypto = identityMasterSeedCrypto,
-): Promise<Uint8Array | null> {
-  const stored = await storage.get(MASTER_SEED_KEY);
-  if (!stored) return null;
-  const plaintext = await crypto.decrypt(stored);
-  return normalizeMasterSeed(plaintext);
-}
-
-export async function storeMasterSeed(
-  storage: Storage,
-  seed: Uint8Array,
-  crypto: MasterSeedCrypto = identityMasterSeedCrypto,
-): Promise<void> {
-  const normalized = normalizeMasterSeed(seed);
-  const encrypted = await crypto.encrypt(normalized);
-  if (!(encrypted instanceof Uint8Array)) {
-    throw new Error("master seed encryptor must return Uint8Array");
-  }
-  await storage.put(MASTER_SEED_KEY, clone(encrypted));
-}
-
-export async function loadMasterMnemonic(
-  storage: Storage,
-  crypto: MasterSeedCrypto = identityMasterSeedCrypto,
-): Promise<string | null> {
-  const stored = await storage.get(MASTER_MNEMONIC_KEY);
-  if (!stored) return null;
-  const plaintext = await crypto.decrypt(stored);
-  const mnemonic = textDecoder.decode(plaintext);
-  return normalizeMnemonic(mnemonic);
-}
-
-export type ImportMasterMnemonicOptions = {
-  storage: Storage;
-  mnemonic: string;
-  crypto?: MasterSeedCrypto;
-  overwrite?: boolean;
-  password?: string;
-};
-
-export async function importMasterMnemonic({
-  storage,
-  mnemonic,
-  crypto = identityMasterSeedCrypto,
-  overwrite = false,
-  password = "",
-}: ImportMasterMnemonicOptions): Promise<Uint8Array> {
-  if (!overwrite) {
-    const existing = await loadMasterMnemonic(storage, crypto);
-    if (existing) {
-      throw new Error(
-        "master mnemonic already exists; set overwrite to true to replace it",
-      );
-    }
-  }
-
-  const normalized = normalizeMnemonic(mnemonic);
-  const seed = mnemonicToSeed(normalized, password);
-  await storeMasterMnemonic(storage, normalized, crypto);
-  await storeMasterSeed(storage, seed, crypto);
-  return seed;
-}
-
-export async function storeMasterMnemonic(
-  storage: Storage,
-  mnemonic: string,
-  crypto: MasterSeedCrypto = identityMasterSeedCrypto,
-): Promise<void> {
-  const normalized = normalizeMnemonic(mnemonic);
-  const encrypted = await crypto.encrypt(textEncoder.encode(normalized));
-  if (!(encrypted instanceof Uint8Array)) {
-    throw new Error("master mnemonic encryptor must return Uint8Array");
-  }
-  await storage.put(MASTER_MNEMONIC_KEY, clone(encrypted));
-}
-
-function clone(bytes: Uint8Array): Uint8Array {
-  return new Uint8Array(bytes);
-}
-
-function normalizeMasterSeed(seed: Uint8Array): Uint8Array {
-  if (!(seed instanceof Uint8Array)) {
-    throw new Error("master seed must be a Uint8Array");
-  }
-  if (seed.length !== MASTER_SEED_LENGTH) {
-    throw new Error(`master seed must be ${MASTER_SEED_LENGTH} bytes`);
-  }
-  return clone(seed);
-}
-
-function normalizeMnemonic(mnemonic: string): string {
-  const formatted = mnemonic.trim().replace(/\s+/g, " ");
-  if (!Mnemonic.validate(formatted)) {
-    throw new Error("invalid BIP-39 mnemonic phrase");
-  }
-  return formatted;
-}
-
-function mnemonicToSeed(mnemonic: string, password: string = ""): Uint8Array {
-  const seedHex = Mnemonic.toSeed(mnemonic, password);
-  return ByteUtils.hexStringToBytes(seedHex);
-}

package/circuits.json

@@ -1,26 +0,0 @@
-{
-  "joinsplit_3x3_16": {
-    "file": "joinsplit",
-    "template": "JoinSplit",
-    "pubs": ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-    "params": [3, 3, 16]
-  },
-  "joinsplit_2x3_16": {
-    "file": "joinsplit",
-    "template": "JoinSplit",
-    "pubs": ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-    "params": [2, 3, 16]
-  },
-  "joinsplit_1x2_16": {
-    "file": "joinsplit",
-    "template": "JoinSplit",
-    "pubs": ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-    "params": [1, 2, 16]
-  },
-  "joinsplit_1x1_16": {
-    "file": "joinsplit",
-    "template": "JoinSplit",
-    "pubs": ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-    "params": [1, 1, 16]
-  }
-}

package/clients/broadcaster.ts

@@ -1,67 +0,0 @@
-import type { FetchLike } from "./http.js";
-import { createJsonHttpClient } from "./http.js";
-
-export type BroadcasterRelayPayload = {
-  kind: "call_data";
-  to: string;
-  data: string;
-};
-
-export type SubmitRelayParams = {
-  clientTxId: string;
-  chainId: number;
-  payload: BroadcasterRelayPayload;
-};
-
-export type SubmitRelayResponse = {
-  id: string;
-  accepted: boolean;
-  message?: string | null;
-};
-
-export type RelayState =
-  | "pending"
-  | "broadcasting"
-  | "succeeded"
-  | "failed"
-  | "dead";
-
-export type RelayStatusResponse = {
-  id: string;
-  state: RelayState;
-  txHash?: string | null;
-  receipt?: unknown;
-  error?: string | null;
-};
-
-type BroadcasterClientDeps = {
-  fetch: FetchLike;
-};
-
-export function createBroadcasterClient(
-  baseUrl: string,
-  deps: BroadcasterClientDeps,
-) {
-  const http = createJsonHttpClient(baseUrl, deps);
-
-  return {
-    async submitRelay(params: SubmitRelayParams) {
-      return http.request<SubmitRelayResponse>({
-        method: "POST",
-        path: "/relays",
-        json: {
-          client_tx_id: params.clientTxId,
-          chain_id: params.chainId,
-          ...params.payload,
-        },
-      });
-    },
-
-    async getRelayStatus(relayId: string) {
-      return http.request<RelayStatusResponse>({
-        method: "GET",
-        path: `/relays/${relayId}`,
-      });
-    },
-  };
-}

package/clients/http.ts

@@ -1,94 +0,0 @@
-import ky, { HTTPError, TimeoutError } from "ky";
-
-export type FetchLike = (
-  input: RequestInfo | URL,
-  init?: RequestInit,
-) => Promise<Response>;
-
-export type JsonHttpDeps = { fetch: FetchLike };
-
-export type JsonRequestOptions = {
-  method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-  path: string;
-  query?: Record<string, string | number | boolean | undefined>;
-  json?: unknown;
-  body?: BodyInit;
-  headers?: HeadersInit;
-  signal?: AbortSignal;
-};
-
-export type JsonHttpClient = {
-  request<T>(opts: JsonRequestOptions): Promise<T>;
-};
-
-export class HttpError extends Error {
-  readonly status: number;
-  readonly body: unknown;
-
-  constructor(message: string, status: number, body: unknown) {
-    super(message);
-    this.status = status;
-    this.body = body;
-  }
-}
-
-async function readErrorBodySafe(res: Response) {
-  try {
-    return await res.clone().json();
-  } catch {
-    const text = await res.text();
-    return text || null;
-  }
-}
-
-export function createJsonHttpClient(
-  baseUrl: string,
-  deps: JsonHttpDeps,
-): JsonHttpClient {
-  if (!baseUrl) throw new Error("baseUrl is required");
-  if (!deps?.fetch) throw new Error("deps.fetch is required");
-
-  // Ensure `fetch` is invoked with a global `this` to avoid "Illegal invocation"
-  // errors in some browser environments when the function is extracted. // TODO: can we fix this in another way?
-  const fetchImpl: FetchLike = (...args) => deps.fetch.apply(globalThis, args);
-
-  const api = ky.create({
-    prefixUrl: baseUrl.replace(/\/+$/, ""),
-    fetch: fetchImpl,
-  });
-
-  return {
-    async request<T>(opts: JsonRequestOptions): Promise<T> {
-      try {
-        const res = api(opts.path.replace(/^\//, ""), {
-          method: opts.method,
-          searchParams: opts.query,
-          json: opts.json,
-          body: opts.body,
-          headers: opts.headers,
-          signal: opts.signal,
-        });
-        return await res.json<T>();
-      } catch (err) {
-        if (err instanceof HTTPError) {
-          const body = await readErrorBodySafe(err.response);
-          throw new HttpError(
-            `HTTP ${err.response.status} ${err.response.statusText}`.trim(),
-            err.response.status,
-            body,
-          );
-        }
-
-        if (err instanceof TimeoutError) {
-          throw new HttpError("HTTP timeout", 408, null);
-        }
-
-        throw new HttpError(
-          err instanceof Error ? err.message : "Network error",
-          0,
-          null,
-        );
-      }
-    },
-  };
-}

package/clients/indexer.ts

@@ -1,150 +0,0 @@
-import type { FetchLike } from "./http.js";
-import { createJsonHttpClient } from "./http.js";
-import { isNotFoundError } from "../utils/async.js";
-
-// The HTTP API returns snake_case fields; the `Raw` helpers mirror that
-// payload exactly so we can normalize everything to camelCase in one place.
-type CommitmentRecordRaw = {
-  leaf_index: number;
-  commitment: string;
-  ciphertext: [string, string, string];
-  root: string;
-  tx_hash: string;
-  inserted_at: number;
-};
-
-export type CommitmentRecord = {
-  index: number;
-  commitment: string;
-  ciphertext: [string, string, string];
-  root: string;
-  txHash: string;
-  insertedAt: number;
-};
-
-type NullifierRecordRaw = {
-  nullifier: string;
-  tx_hash: string;
-  spent_at: number;
-  chain_id: number;
-};
-
-export type IndexerNullifierRecord = {
-  nullifier: string;
-  txHash: string;
-  spentAt: number;
-  chainId: number;
-};
-
-type CommitmentBatchResponseRaw = {
-  chain_id: number;
-  commitments: CommitmentRecordRaw[];
-  latest_root: string | null;
-};
-
-export type CommitmentBatchResponse = {
-  chainId: number;
-  commitments: CommitmentRecord[];
-  latestRoot: string | null;
-};
-
-export type FetchCommitmentsParams = {
-  chainId: number;
-  start?: number;
-  limit?: number;
-};
-
-export type GetCommitmentParams = {
-  chainId: number;
-  commitment: string;
-};
-
-export type GetNullifierParams = {
-  chainId: number;
-  nullifier: string;
-};
-
-type NullifierCountResponseRaw = {
-  chain_id: number;
-  count: number;
-};
-
-type IndexerClientDeps = {
-  fetch: FetchLike;
-};
-
-export function createIndexerClient(baseUrl: string, deps: IndexerClientDeps) {
-  const http = createJsonHttpClient(baseUrl, deps);
-
-  // Converts the snake_case record from the REST API into the camelCase shape
-  // the rest of the SDK consumes.
-  const normalizeRecord = (record: CommitmentRecordRaw): CommitmentRecord => ({
-    index: record.leaf_index,
-    commitment: record.commitment,
-    ciphertext: [...record.ciphertext] as [string, string, string],
-    root: record.root,
-    txHash: record.tx_hash,
-    insertedAt: record.inserted_at,
-  });
-
-  const normalizeNullifierRecord = (
-    record: NullifierRecordRaw,
-  ): IndexerNullifierRecord => ({
-    nullifier: record.nullifier,
-    txHash: record.tx_hash,
-    spentAt: record.spent_at,
-    chainId: record.chain_id,
-  });
-
-  return {
-    async fetchCommitmentBatch(
-      params: FetchCommitmentsParams,
-    ): Promise<CommitmentBatchResponse> {
-      const raw = await http.request<CommitmentBatchResponseRaw>({
-        method: "GET",
-        path: `/chains/${params.chainId}/commitments`,
-        query: {
-          start: params.start,
-          limit: params.limit,
-        },
-      });
-      return {
-        chainId: raw.chain_id,
-        commitments: raw.commitments.map(normalizeRecord),
-        latestRoot: raw.latest_root,
-      };
-    },
-    async getCommitment(
-      params: GetCommitmentParams,
-    ): Promise<CommitmentRecord> {
-      const raw = await http.request<CommitmentRecordRaw>({
-        method: "GET",
-        path: `/chains/${params.chainId}/commitments/${params.commitment}`,
-      });
-      return normalizeRecord(raw);
-    },
-    async getNullifier(
-      params: GetNullifierParams,
-    ): Promise<IndexerNullifierRecord | null> {
-      try {
-        const raw = await http.request<NullifierRecordRaw>({
-          method: "GET",
-          path: `/chains/${params.chainId}/nullifiers/${params.nullifier}`,
-        });
-        return normalizeNullifierRecord(raw);
-      } catch (err) {
-        if (isNotFoundError(err)) {
-          return null; // Nullifier not spent on-chain
-        }
-        throw err;
-      }
-    },
-    async getNullifierCount(chainId: number): Promise<number> {
-      const raw = await http.request<NullifierCountResponseRaw>({
-        method: "GET",
-        path: `/chains/${chainId}/nullifiers/count`,
-      });
-      return raw.count;
-    },
-  };
-}

package/config.ts

@@ -1,39 +0,0 @@
-const DEFAULT_RPC_URL = "http://localhost:3000";
-
-function readEnv(key: string): string | undefined {
-  if (typeof process !== "undefined" && process?.env) {
-    return process.env[key];
-  }
-  // Support environments where process isn't defined but a shim sets globalThis.process
-  const globalProcess = (
-    globalThis as typeof globalThis & {
-      process?: { env?: Record<string, string | undefined> };
-    }
-  ).process;
-  return globalProcess?.env?.[key];
-}
-
-function readServiceUrl(envKey: string, fallback: string): string {
-  const raw = readEnv(envKey);
-  if (!raw) return fallback;
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    throw new Error(`${envKey} must not be empty when set`);
-  }
-  return trimmed.replace(/\/+$/, "");
-}
-
-export const serviceConfig = {
-  /**
-   * Base URL for the Broadcaster HTTP API (default: http://localhost:8081).
-   */
-  broadcasterBaseUrl:
-    readServiceUrl("UNLINK_RPC_URL", DEFAULT_RPC_URL) + "/broadcaster",
-  /**
-   * Base URL for the Indexer HTTP API (default: http://localhost:8082).
-   */
-  indexerBaseUrl:
-    readServiceUrl("UNLINK_RPC_URL", DEFAULT_RPC_URL) + "/indexer",
-};
-
-export type ServiceConfig = typeof serviceConfig;

package/core.ts

@@ -1,17 +0,0 @@
-import { migrate } from "./schema.js";
-import type { Storage } from "./types.js";
-
-export type CoreDeps = {
-  storage: Storage;
-  rng: (n: number) => Uint8Array;
-};
-
-export async function initCore(deps: CoreDeps) {
-  if (!deps?.storage) throw new Error("storage dep required");
-  if (!deps?.rng) throw new Error("rng dep required");
-  await migrate(deps.storage);
-  return {
-    storage: deps.storage,
-    rng: deps.rng,
-  };
-}

package/dist/account/railgun-imports-prototype.d.ts

@@ -1,12 +0,0 @@
-/**
- * Quick smoke-test to guarantee the new dependency surface compiles and behaves as expected.
- * This is a temporary helper that will be removed once zkAccount is migrated.
- */
-export declare const railgunDependencySmokeTest: () => Promise<{
-    mnemonicRoundTrip: string;
-    packedPoint: Uint8Array<ArrayBufferLike>;
-    viewingKey: Uint8Array<ArrayBufferLike>;
-    address: `0zk1${string}`;
-    poseidonHash: bigint;
-}>;
-//# sourceMappingURL=railgun-imports-prototype.d.ts.map

package/dist/account/railgun-imports-prototype.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"railgun-imports-prototype.d.ts","sourceRoot":"","sources":["../../account/railgun-imports-prototype.ts"],"names":[],"mappings":"AAaA;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;;;;;EAwBtC,CAAC"}

package/dist/account/railgun-imports-prototype.js

@@ -1,30 +0,0 @@
-import { babyjub, poseidon } from '@railgun-community/circomlibjs';
-import { getPublicKey } from '@noble/ed25519';
-import { sha512 } from '@noble/hashes/sha512';
-import { bech32m } from '@scure/base';
-import { entropyToMnemonic, generateMnemonic, mnemonicToEntropy, mnemonicToSeedSync, validateMnemonic, } from '@scure/bip39';
-import { wordlist } from '@scure/bip39/wordlists/english';
-/**
- * Quick smoke-test to guarantee the new dependency surface compiles and behaves as expected.
- * This is a temporary helper that will be removed once zkAccount is migrated.
- */
-export const railgunDependencySmokeTest = async () => {
-    const mnemonic = generateMnemonic(wordlist);
-    validateMnemonic(mnemonic, wordlist);
-    const seed = mnemonicToSeedSync(mnemonic);
-    const entropy = mnemonicToEntropy(mnemonic, wordlist);
-    const mnemonicRoundTrip = entropyToMnemonic(entropy, wordlist);
-    const babyjubPoint = babyjub.Base8;
-    const packedPoint = babyjub.packPoint(babyjubPoint);
-    const viewingKey = await getPublicKey(seed.slice(0, 32));
-    const digest = sha512(seed);
-    const address = bech32m.encode('0zk', bech32m.toWords(digest.subarray(0, 32)), 127);
-    const poseidonHash = poseidon([BigInt(1), BigInt(2), BigInt(3)]);
-    return {
-        mnemonicRoundTrip,
-        packedPoint,
-        viewingKey,
-        address,
-        poseidonHash,
-    };
-};

package/dist/account/zkAccount.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"zkAccount.d.ts","sourceRoot":"","sources":["../../account/zkAccount.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,cAAc,EACpB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU,CAAC;IAC5D,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU,CAAC;CAChE,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,UAAU,CAAC;IAC/B,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,kBAAkB,KAAK,CAAC;AACrC,eAAO,MAAM,eAAe,8BAA8B,CAAC;AAC3D,eAAO,MAAM,mBAAmB,kCAAkC,CAAC;AAOnE,MAAM,MAAM,SAAS,GAAG;IACtB,eAAe,EAAE,eAAe,CAAC;IACjC,cAAc,EAAE,cAAc,CAAC;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,wBAAsB,eAAe,CACnC,UAAU,EAAE,UAAU,EACtB,YAAY,GAAE,MAAU,GACvB,OAAO,CAAC,SAAS,CAAC,CAqBpB;AAED,wBAAsB,2BAA2B,CAC/C,QAAQ,EAAE,MAAM,EAChB,YAAY,GAAE,MAAU,EACxB,QAAQ,GAAE,MAAW,GACpB,OAAO,CAAC,SAAS,CAAC,CAIpB;AAWD,wBAAsB,kBAAkB,CAAC,EACvC,OAAO,EACP,GAAG,EACH,MAAiC,EACjC,SAAiB,EACjB,kBAAkB,GACnB,EAAE,yBAAyB,GAAG,OAAO,CAAC,UAAU,CAAC,CA0BjD;AAED,wBAAsB,cAAc,CAClC,OAAO,EAAE,OAAO,EAChB,MAAM,GAAE,gBAA2C,GAClD,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAK5B;AAED,wBAAsB,eAAe,CACnC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,UAAU,EAChB,MAAM,GAAE,gBAA2C,GAClD,OAAO,CAAC,IAAI,CAAC,CAOf;AAED,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,OAAO,EAChB,MAAM,GAAE,gBAA2C,GAClD,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAMxB;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,wBAAsB,oBAAoB,CAAC,EACzC,OAAO,EACP,QAAQ,EACR,MAAiC,EACjC,SAAiB,EACjB,QAAa,GACd,EAAE,2BAA2B,GAAG,OAAO,CAAC,UAAU,CAAC,CAenD;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,gBAA2C,GAClD,OAAO,CAAC,IAAI,CAAC,CAOf"}