@openzeppelin/miden-multisig-client 0.17.0-rc.2 → 0.17.0

package/dist/recovery/publicNoteBackfill.js

@@ -0,0 +1,368 @@
+/**
+ * Historical public-note backfill by tag.
+ *
+ * Public notes addressed to an account are on chain, but normal forward sync
+ * starts from the store's **global** cursor: in a shared dirty store the
+ * cursor may already be past blocks containing a recovered account's notes,
+ * and a fresh store has no efficient path to them at all. This module
+ * rescans a historical block range with the account's standard note tag and
+ * imports what it finds with on-chain inclusion proofs, without ever
+ * touching the global sync height.
+ */
+import { AccountId, Endpoint, NoteScript, NoteTag, NoteType, RpcClient, } from '@miden-sdk/miden-sdk';
+import { errorMessage } from '../connectivity.js';
+import { collectExistingRecords, detailsKeyOf, errorDetail, importNoteWithProof, reclassifyConsumedImports, } from './proposalNoteImport.js';
+import { getRawMidenClient, requireMidenRpcEndpoint } from '../raw-client.js';
+import { resolveRpcConfig } from '../rpc/config.js';
+import { isTransientRpcError } from '../rpc/errors.js';
+import { retryRpcRead } from '../rpc/retry.js';
+import { normalizeHexWord } from '../utils/encoding.js';
+/**
+ * `RpcError::PaginationError`'s Display prefix in the WASM error chain: the
+ * node caps internal pagination per `syncNotes` request, and the scan splits
+ * the range client-side when it trips. Exported for the drift-guard test,
+ * which pins it against the shipped WASM binary.
+ */
+export const RPC_PAGINATION_FRAGMENT = 'rpc pagination error';
+/**
+ * Upper bound on `syncNotes` requests per backfill. Splitting around the
+ * node's pagination cap halves ranges, so the budget is only approachable
+ * when nearly every sub-range is dense enough to trip the cap; exhausting it
+ * reports the remaining ranges as uncovered instead of scanning forever.
+ */
+const MAX_SCAN_REQUESTS = 128;
+/** Block numbers are u32 on chain; out-of-range JS numbers would silently
+ * wrap modulo 2^32 at the WASM boundary and scan the wrong range. */
+const MAX_BLOCK_NUMBER = 4_294_967_295;
+/**
+ * The requested scan range is invalid (out-of-range bound, or inverted
+ * against the resolved chain tip) — a caller error that retrying cannot fix,
+ * as opposed to the transient chain-tip-lookup failures this function also
+ * throws. `Multisig.recoverNotes` keys its problem retryability on this,
+ * mirroring the Rust orchestrator's `InvalidConfig` check.
+ */
+export class BackfillRangeError extends Error {
+}
+function requireBlockNumber(name, value) {
+    if (!Number.isInteger(value) || value < 0 || value > MAX_BLOCK_NUMBER) {
+        throw new BackfillRangeError(`${name} must be an integer in [0, ${MAX_BLOCK_NUMBER}], got ${value}`);
+    }
+}
+/**
+ * Static relevance screen for a discovered public note. The Rust SDK screens
+ * with the execution-based `NoteScreener` normal sync uses; the WASM surface
+ * does not expose it, so this mirrors its verdict for the well-known note
+ * scripts: a note is `relevant` when it is a P2ID/P2IDE note whose target
+ * (or P2IDE reclaimer) is the scanned account, and `irrelevant` when it is
+ * one of those scripts addressed at someone else. Notes with other scripts
+ * are `unscreenable` — this screen cannot judge them, and they are
+ * conservatively not imported (tags are shared, truncated filters, and
+ * importing unscreened tag matches would let anyone pollute the store), but
+ * the report counts them separately so "screened out" and "not screenable"
+ * stay distinguishable. Exported for the drift-guard test, which pins the
+ * root and storage-layout assumptions against real WASM-built notes.
+ */
+export function screenNoteForAccount(note, account) {
+    const root = normalizeHexWord(note.script().root().toHex());
+    const items = note.recipient().storage().items();
+    const prefix = account.prefix().asInt();
+    const suffix = account.suffix().asInt();
+    const accountAt = (index) => items.length > index + 1 &&
+        items[index].asInt() === suffix &&
+        items[index + 1].asInt() === prefix;
+    if (root === normalizeHexWord(NoteScript.p2id().root().toHex())) {
+        // P2ID note storage: [target.suffix, target.prefix].
+        return accountAt(0) ? 'relevant' : 'irrelevant';
+    }
+    if (root === normalizeHexWord(NoteScript.p2ide().root().toHex())) {
+        // P2IDE note storage: [reclaimer.suffix, reclaimer.prefix,
+        // target.suffix, target.prefix, reclaim, timelock].
+        return accountAt(2) || accountAt(0) ? 'relevant' : 'irrelevant';
+    }
+    return 'unscreenable';
+}
+/**
+ * Scans a historical block range for public notes addressed at an account's
+ * standard note tag and imports what it finds with their on-chain inclusion
+ * proofs. Counterpart of
+ * `MultisigClient::backfill_public_notes_by_tag` in the Rust SDK.
+ *
+ * Use after account recovery: normal forward sync starts from the store's
+ * **global** cursor, so in a shared dirty store the cursor may already be
+ * past blocks containing the recovered account's notes, and a fresh store
+ * would need to replay the whole chain state to see them. The scan is
+ * tag-scoped and its cost grows with the number of matching notes, not the
+ * range length, which makes genesis an acceptable default lower
+ * bound. The global sync height is never touched — run normal sync
+ * afterwards to verify the imported notes. The store must have synced at
+ * least once (`Multisig.recoverNotes` syncs the chain before this strategy
+ * runs): importing a proof into a store that has never seen the chain
+ * fails, and such failures surface as `failed` outcomes.
+ *
+ * Notes are discovered by tag only — a best-effort filter: notes sent with
+ * unrelated custom tags are outside this scan's guarantee, and, like normal
+ * sync, every new discovery is screened for relevance before import —
+ * tag-colliding notes the account cannot consume are counted as
+ * `skippedIrrelevant` instead of polluting the store. This SDK screens
+ * statically against the well-known P2ID/P2IDE scripts (the WASM surface
+ * does not expose the execution-based screener the Rust SDK uses), so notes
+ * with custom scripts are conservatively not imported and counted as
+ * `skippedUnscreenable`. Only public notes can be
+ * rebuilt from chain data; private matches are counted as `skippedPrivate`
+ * and are covered by the transport drain and proposal-import primitives
+ * instead.
+ *
+ * A range dense enough to trip the node's internal pagination cap is split
+ * client-side and rescanned as narrower requests; ranges that still cannot
+ * be covered are reported in {@link PublicBackfillReport.uncovered} rather
+ * than failing the recovery flow. This function throws only when the scan
+ * range itself cannot be established (chain-tip lookup failed, an invalid
+ * account ID, a block bound that is not a u32 integer, or
+ * `fromBlock > toBlock`).
+ *
+ * Prefer the `Multisig.backfillPublicNotesByTag` convenience method, which
+ * reuses the client's endpoint and retry configuration.
+ *
+ * @example
+ * ```typescript
+ * const report = await multisig.backfillPublicNotesByTag();
+ * console.log(report.discovered, 'discovered,', report.outcomes.length, 'public');
+ * await multisig.syncState(); // verifies the imported notes
+ * ```
+ */
+export async function backfillPublicNotesByTag(midenClient, options) {
+    const midenRpcEndpoint = requireMidenRpcEndpoint(options.midenRpcEndpoint);
+    const rpcConfig = resolveRpcConfig(options.rpc);
+    const webClient = await getRawMidenClient(midenClient, midenRpcEndpoint);
+    const rpcClient = new RpcClient(new Endpoint(midenRpcEndpoint));
+    // Parse eagerly so a malformed account ID throws before any network work.
+    AccountId.fromHex(options.accountId);
+    const from = options.fromBlock ?? 0;
+    requireBlockNumber('fromBlock', from);
+    let to;
+    if (options.toBlock !== undefined) {
+        requireBlockNumber('toBlock', options.toBlock);
+        to = options.toBlock;
+    }
+    else {
+        try {
+            const tip = await retryRpcRead(() => rpcClient.getBlockHeaderByNumber(), rpcConfig);
+            to = tip.blockNum();
+        }
+        catch (error) {
+            throw new Error(`failed to resolve the chain tip for the backfill scan: ${errorDetail(error)}`);
+        }
+    }
+    if (from > to) {
+        throw new BackfillRangeError(`backfill range is inverted: fromBlock ${from} > toBlock ${to}`);
+    }
+    // Work queue of inclusive sub-ranges, split in half whenever the node
+    // reports its pagination cap for one of them. WASM call arguments are
+    // consumed by the bridge, so the tag is rebuilt per request.
+    const scanTag = () => NoteTag.withAccountTarget(AccountId.fromHex(options.accountId));
+    const queue = [[from, to]];
+    const discovered = new Map();
+    const uncovered = [];
+    const scanReasons = [];
+    let retryable = false;
+    let requests = 0;
+    let budgetExhausted = false;
+    while (queue.length > 0) {
+        const [lo, hi] = queue.shift();
+        if (requests >= MAX_SCAN_REQUESTS) {
+            budgetExhausted = true;
+            uncovered.push({ from: lo, to: hi });
+            continue;
+        }
+        requests += 1;
+        try {
+            const info = await retryRpcRead(() => rpcClient.syncNotes(lo, hi, [scanTag()]), rpcConfig);
+            for (const committed of info.notes()) {
+                const idHex = normalizeHexWord(committed.noteId().toString());
+                if (!discovered.has(idHex)) {
+                    // The wrapper is kept (not a one-shot accessor result) so fresh
+                    // NoteId handles can be minted per body-fetch attempt below.
+                    discovered.set(idHex, committed);
+                }
+            }
+        }
+        catch (error) {
+            // The node caps internal pagination per request rather than
+            // truncating; a single-block range cannot be split further (and
+            // cannot realistically hold that many pages), so only splittable
+            // ranges take this branch.
+            if (errorMessage(error).toLowerCase().includes(RPC_PAGINATION_FRAGMENT) && lo < hi) {
+                const mid = lo + Math.floor((hi - lo) / 2);
+                queue.unshift([lo, mid], [mid + 1, hi]);
+                continue;
+            }
+            retryable ||= isTransientRpcError(error);
+            scanReasons.push(`blocks [${lo}, ${hi}]: ${errorDetail(error)}`);
+            uncovered.push({ from: lo, to: hi });
+        }
+    }
+    if (budgetExhausted) {
+        retryable = true;
+        scanReasons.push(`scan budget of ${MAX_SCAN_REQUESTS} requests exhausted while splitting around the node's pagination cap; rerun the backfill over the uncovered ranges`);
+    }
+    const publicNotes = [];
+    for (const [idHex, committed] of discovered) {
+        if (committed.noteType() === NoteType.Public) {
+            publicNotes.push({ idHex, committed });
+        }
+    }
+    const skippedPrivate = discovered.size - publicNotes.length;
+    let skippedIrrelevant = 0;
+    let skippedUnscreenable = 0;
+    const outcomes = [];
+    const buildReport = () => {
+        let reason;
+        if (scanReasons.length > 0) {
+            reason =
+                scanReasons.length <= 3
+                    ? scanReasons.join('; ')
+                    : `${scanReasons.slice(0, 3).join('; ')}; …and ${scanReasons.length - 3} more`;
+        }
+        return {
+            scannedFrom: from,
+            scannedTo: to,
+            discovered: discovered.size,
+            skippedPrivate,
+            skippedIrrelevant,
+            skippedUnscreenable,
+            outcomes,
+            uncovered,
+            // Rerunning can help when scan ranges were left uncovered OR when any
+            // per-note outcome is itself retryable — surface both at report level
+            // so orchestration keyed on the report alone reruns when it should.
+            retryable: retryable || outcomes.some((outcome) => outcome.retryable === true),
+            ...(reason === undefined ? {} : { reason }),
+        };
+    };
+    const pending = [];
+    if (publicNotes.length > 0) {
+        try {
+            // One batched body fetch — the upstream client chunks internally by
+            // the node's negotiated note-ids limit, and the node returns full
+            // bodies for public notes, so the scan's ID + proof is all this path
+            // needs. The WASM bridge consumes call arguments, so fresh NoteId
+            // handles are minted from the kept wrappers on every retry attempt.
+            const fetchedNotes = await retryRpcRead(() => rpcClient.getNotesById(publicNotes.map((candidate) => candidate.committed.noteId())), rpcConfig);
+            const bodies = new Map();
+            for (const fetched of fetchedNotes) {
+                if (fetched.note) {
+                    bodies.set(normalizeHexWord(fetched.noteId.toString()), {
+                        note: fetched.note,
+                        proof: fetched.inclusionProof,
+                    });
+                }
+            }
+            for (const { idHex } of publicNotes) {
+                const body = bodies.get(idHex);
+                if (body) {
+                    pending.push({
+                        idHex,
+                        note: body.note,
+                        proof: body.proof,
+                        detailsKey: detailsKeyOf(normalizeHexWord(body.note.recipient().digest().toHex()), body.note.assets()),
+                    });
+                }
+                else {
+                    // Discovered as public by the scan but returned without a body —
+                    // not expected for a committed public note.
+                    outcomes.push({
+                        identifier: idHex,
+                        source: 'backfill',
+                        status: 'failed',
+                        retryable: true,
+                        reason: 'the node did not return a body for this public note',
+                    });
+                }
+            }
+        }
+        catch (error) {
+            const fetchRetryable = isTransientRpcError(error);
+            const reason = `failed to fetch note bodies: ${errorDetail(error)}`;
+            for (const { idHex } of publicNotes) {
+                outcomes.push({
+                    identifier: idHex,
+                    source: 'backfill',
+                    status: 'failed',
+                    retryable: fetchRetryable,
+                    reason,
+                });
+            }
+        }
+    }
+    if (pending.length === 0) {
+        return buildReport();
+    }
+    let existing;
+    try {
+        existing = await collectExistingRecords(webClient);
+    }
+    catch (error) {
+        const reason = `failed to read local store: ${errorDetail(error)}`;
+        for (const candidate of pending) {
+            outcomes.push({
+                identifier: candidate.idHex,
+                source: 'backfill',
+                status: 'failed',
+                reason,
+            });
+        }
+        return buildReport();
+    }
+    // Provisionally `imported` outcomes, re-classified in one batched
+    // post-import state check below.
+    const screenAccount = AccountId.fromHex(options.accountId);
+    const imported = [];
+    for (const candidate of pending) {
+        // Skip decisions key on an exact note-ID match only: a details-key
+        // match is a lossy approximation (see {@link detailsKeyOf} in the
+        // proposal-import module), and the upstream import dedupes exactly by
+        // the real details commitment, so importing "again" is safe while
+        // pre-skipping on the approximation could silently drop a genuinely
+        // new note. Unlike the proposal import, a proof-less (expected) record
+        // is NOT skipped here even on an ID match: this primitive exists
+        // because forward sync will never revisit the note's block, so the
+        // freshly fetched proof is applied to upgrade the record in place (the
+        // WASM import handles existing records).
+        const record = existing.get(candidate.idHex);
+        if (record && (record.isConsumed() || record.inclusionProof() !== undefined)) {
+            outcomes.push({
+                identifier: candidate.idHex,
+                source: 'backfill',
+                status: record.isConsumed() ? 'already-consumed' : 'already-present',
+            });
+            continue;
+        }
+        // Screen genuinely new discoveries for relevance, exactly like normal
+        // sync does before it stores a tag match. Records the store already
+        // tracks (by ID, or a metadata-less record matching on details) are
+        // material the user chose to track and skip the screen.
+        if (!record && !existing.has(candidate.detailsKey)) {
+            const verdict = screenNoteForAccount(candidate.note, screenAccount);
+            if (verdict === 'irrelevant') {
+                skippedIrrelevant += 1;
+                continue;
+            }
+            if (verdict === 'unscreenable') {
+                skippedUnscreenable += 1;
+                continue;
+            }
+        }
+        const { outcome, wasImported } = await importNoteWithProof(webClient, 'backfill', candidate.idHex, candidate.note, candidate.proof);
+        if (wasImported) {
+            imported.push({
+                index: outcomes.length,
+                idHex: candidate.idHex,
+                detailsKey: candidate.detailsKey,
+            });
+        }
+        outcomes.push(outcome);
+    }
+    await reclassifyConsumedImports(webClient, imported, outcomes);
+    return buildReport();
+}
+//# sourceMappingURL=publicNoteBackfill.js.map

package/dist/recovery/publicNoteBackfill.js.map

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

package/dist/recovery/recoverNotes.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Wallet-facing orchestration of the note-recovery primitives.
+ *
+ * After key-based recovery the local Miden store starts empty (or, in a
+ * shared store, its global cursors may already be past this account's
+ * notes). Each recovery primitive rescans one source normal forward sync
+ * would skip: the private-note transport backlog, the notes embedded in
+ * pending consume-notes proposals, and the chain's historical public notes
+ * for the account's tag. `Multisig.recoverNotes` runs them as a single flow
+ * and finishes with a normal sync so recovered notes are verified and ready
+ * to consume.
+ *
+ * The TS counterpart of the Rust SDK's `MultisigClient::recover_notes`,
+ * with matching semantics and report shape.
+ */
+import type { NoteImportOutcome } from './proposalNoteImport.js';
+import { type PublicBackfillReport } from './publicNoteBackfill.js';
+import type { TransportRecoveryReport } from './transportDrain.js';
+/** One step of the note-recovery flow, used to attribute problems. */
+export type RecoveryStep = 'transport-drain' | 'proposal-import' | 'public-backfill' | 'sync';
+/**
+ * A step of the recovery flow that could not run (or, for the final sync,
+ * did not finish). The flow always continues with the remaining steps; a
+ * problem here means the corresponding report field is absent (or `synced`
+ * is `false`) and rerunning the flow may recover more.
+ */
+export interface RecoveryStepProblem {
+    /** The step that failed. */
+    step: RecoveryStep;
+    /** Human-readable cause. */
+    reason: string;
+    /**
+     * Whether rerunning the flow can plausibly make this step succeed.
+     * Failures reaching this level are I/O failures against GUARDIAN, the
+     * node, or the local store; all but local-store failures are marked
+     * retryable. The flow is idempotent, so retrying is always safe.
+     */
+    retryable: boolean;
+}
+/**
+ * Result of `Multisig.recoverNotes`.
+ *
+ * Each strategy's field holds its primitive's own report and is present
+ * exactly when the strategy was enabled and ran; an enabled strategy that
+ * could not run at all is a {@link RecoveryStepProblem} instead. Step
+ * problems never abort the flow.
+ */
+export interface NoteRecoveryReport {
+    /** Report of the transport backlog drain, when that strategy ran. */
+    transport?: TransportRecoveryReport;
+    /**
+     * Per-note outcomes of the proposal-embedded import, when that strategy
+     * ran.
+     */
+    proposalImport?: NoteImportOutcome[];
+    /** Report of the historical public-note backfill, when that strategy ran. */
+    backfill?: PublicBackfillReport;
+    /** Steps that could not run or finish. Empty on a fully clean flow. */
+    problems: RecoveryStepProblem[];
+    /** Whether the final verifying sync completed. */
+    synced: boolean;
+    /**
+     * Total note records newly added to the local store by this flow: the
+     * drain's imports plus every `imported` outcome from the proposal import
+     * and the backfill.
+     */
+    imported: number;
+    /**
+     * Whether rerunning the flow can plausibly recover more: any step
+     * problem, per-note outcome, or strategy report marked retryable.
+     */
+    retryable: boolean;
+}
+/**
+ * Options for `Multisig.recoverNotes`. The default runs every strategy over
+ * the full chain history and syncs afterwards.
+ */
+export interface RecoverNotesOptions {
+    /**
+     * Rescan the private-note transport backlog (the standalone
+     * `drainPrivateNoteBacklog`). Default `true`.
+     */
+    transportDrain?: boolean;
+    /**
+     * Import the notes embedded in pending consume-notes proposals
+     * (`Multisig.importNotesFromProposals`). Default `true`.
+     */
+    proposalImport?: boolean;
+    /**
+     * Scan chain history for public notes addressed at the account's tag
+     * (`Multisig.backfillPublicNotesByTag`). Default `true`.
+     */
+    publicBackfill?: boolean;
+    /** First block of the backfill scan; defaults to genesis. */
+    fromBlock?: number;
+    /** Last block of the backfill scan; defaults to the current chain tip. */
+    toBlock?: number;
+    /**
+     * Run a normal sync after the strategies so imported notes are verified
+     * and show up as consumable. Default `true`.
+     */
+    syncAfter?: boolean;
+}
+/**
+ * The guardian-switch slice of {@link RecoverNotesOptions}: only the
+ * proposal-embedded note import runs. Internal — the public entry point is
+ * `Multisig.preservePreSwitchProposalNotes`, which adds the switch-specific
+ * safety contract (timeout, cancellation, warnings) around this slice. The
+ * `satisfies` clause forces every non-range option to be listed, so adding
+ * a recovery strategy fails to compile until the switch path decides on it.
+ */
+export declare const GUARDIAN_SWITCH_RECOVERY_OPTIONS: {
+    transportDrain: false;
+    proposalImport: true;
+    publicBackfill: false;
+    syncAfter: false;
+};
+/**
+ * The strategy implementations `runNoteRecovery` orchestrates. `Multisig`
+ * wires these to the SDK primitives; tests can substitute stubs.
+ */
+export interface NoteRecoverySteps {
+    /** Drain the private-note transport backlog. */
+    transportDrain: () => Promise<TransportRecoveryReport>;
+    /** Import notes embedded in pending consume-notes proposals. */
+    proposalImport: () => Promise<NoteImportOutcome[]>;
+    /** Backfill historical public notes by tag. */
+    publicBackfill: () => Promise<PublicBackfillReport>;
+    /** Run the final verifying sync. */
+    sync: () => Promise<void>;
+}
+/**
+ * Runs the enabled recovery strategies in order — transport drain, proposal
+ * import, public backfill, final sync — folding each strategy-level throw
+ * into a {@link RecoveryStepProblem} so no step failure aborts the flow.
+ *
+ * The optional `cancelled` token makes the run cooperatively cancellable:
+ * the orchestrator checks it before each step, and a
+ * {@link RecoveryCancelledError} from inside a step is recorded as one
+ * non-retryable problem on the interrupted step, after which no further
+ * step runs — cancellation never masquerades as a GUARDIAN or node outage.
+ *
+ * Throws only for an inverted backfill range (a caller error). See
+ * `Multisig.recoverNotes` for the wallet-facing entry point.
+ */
+export declare function runNoteRecovery(options: RecoverNotesOptions, steps: NoteRecoverySteps, cancelled?: () => boolean): Promise<NoteRecoveryReport>;
+//# sourceMappingURL=recoverNotes.d.ts.map

package/dist/recovery/recoverNotes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recoverNotes.d.ts","sourceRoot":"","sources":["../../src/recovery/recoverNotes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAsB,KAAK,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AACxF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAEnE,sEAAsE;AACtE,MAAM,MAAM,YAAY,GACpB,iBAAiB,GACjB,iBAAiB,GACjB,iBAAiB,GACjB,MAAM,CAAC;AAEX;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,4BAA4B;IAC5B,IAAI,EAAE,YAAY,CAAC;IACnB,4BAA4B;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IACjC,qEAAqE;IACrE,SAAS,CAAC,EAAE,uBAAuB,CAAC;IACpC;;;OAGG;IACH,cAAc,CAAC,EAAE,iBAAiB,EAAE,CAAC;IACrC,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,uEAAuE;IACvE,QAAQ,EAAE,mBAAmB,EAAE,CAAC;IAChC,kDAAkD;IAClD,MAAM,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,6DAA6D;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0EAA0E;IAC1E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,gCAAgC;;;;;CAK2B,CAAC;AAEzE;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,gDAAgD;IAChD,cAAc,EAAE,MAAM,OAAO,CAAC,uBAAuB,CAAC,CAAC;IACvD,gEAAgE;IAChE,cAAc,EAAE,MAAM,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAAC;IACnD,+CAA+C;IAC/C,cAAc,EAAE,MAAM,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACpD,oCAAoC;IACpC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAMD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,mBAAmB,EAC5B,KAAK,EAAE,iBAAiB,EACxB,SAAS,CAAC,EAAE,MAAM,OAAO,GACxB,OAAO,CAAC,kBAAkB,CAAC,CAwH7B"}