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

package/dist/recovery/proposalNoteImport.js

@@ -0,0 +1,411 @@
+/**
+ * Recovery primitives.
+ *
+ * After key-based recovery the local Miden store starts empty, so notes the
+ * account was in the middle of consuming are gone. v2 `consume_notes`
+ * proposals embed the serialized notes they consume, which makes
+ * pending proposals opportunistic recovery material: this module rebuilds
+ * importable notes from those embedded bytes plus a node-fetched inclusion
+ * proof, without needing the node to hold the note body — so it works for
+ * private notes too.
+ */
+import { Endpoint, InputNote, InputNoteState, Note, NoteDetails, NoteFile, NoteFilter, NoteFilterTypes, RpcClient, } from '@miden-sdk/miden-sdk';
+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 { isConsumeNotesV2 } from '../types/proposal.js';
+import { noteFromBase64, normalizeHexWord } from '../utils/encoding.js';
+/**
+ * Thrown by the recovery cancellation checkpoints; `runNoteRecovery` stops
+ * on it instead of misreporting a step failure. The message avoids
+ * 'cancelled'/'timeout' wording on purpose — the RPC retry classifier
+ * treats those fragments as transient, and cancellation must not retry.
+ */
+export class RecoveryCancelledError extends Error {
+    constructor() {
+        super('note recovery stopped before completion by its caller');
+        this.name = 'RecoveryCancelledError';
+    }
+}
+/** Throws {@link RecoveryCancelledError} when the token reports cancelled. */
+export function throwIfCancelled(cancelled) {
+    if (cancelled?.()) {
+        throw new RecoveryCancelledError();
+    }
+}
+/** Shared by the recovery primitives (proposal import and backfill). */
+export function errorDetail(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Details key: recipient digest + canonical FUNGIBLE asset list. This
+ * approximates the details commitment — which the WASM record surface does
+ * not expose — as closely as the surface allows: `fungibleAssets()` silently
+ * omits non-fungible assets and no complete accessor or commitment exists,
+ * so two notes sharing a recipient digest and fungible assets but differing
+ * only in non-fungible assets collide (the Rust SDK, keyed on the real
+ * `NoteDetailsCommitment`, does not). Latent until NFA-bearing notes reach
+ * these flows; closing it needs an upstream `NoteAssets` commitment/NFA
+ * accessor. Recipient digest alone would be worse: distinct notes can share
+ * a recipient while carrying different fungible assets. */
+export function detailsKeyOf(recipientDigestHex, assets) {
+    const fingerprint = assets
+        .fungibleAssets()
+        .map((asset) => `${normalizeHexWord(asset.faucetId().toString())}:${asset.amount()}`)
+        .sort()
+        .join(',');
+    return `${recipientDigestHex}|${fingerprint}`;
+}
+function recordKeys(record) {
+    const keys = [];
+    const recordId = record.id();
+    if (recordId) {
+        keys.push(normalizeHexWord(recordId.toString()));
+    }
+    const details = record.details();
+    keys.push(detailsKeyOf(normalizeHexWord(details.recipient().digest().toHex()), details.assets()));
+    return keys;
+}
+/**
+ * Scans the store once and keys every record by note ID *and* details key:
+ * records the store keeps without metadata (a note details import in
+ * expected state, or a note observed as consumed on chain) expose neither a
+ * note ID nor a nullifier, and an ID-only lookup would keep re-importing
+ * them forever. (The WASM NoteFilter has no details-commitment variant,
+ * unlike the Rust SDK, so the store is scanned once and keyed both ways.)
+ * Shared by the recovery primitives (proposal import and backfill).
+ */
+export async function collectExistingRecords(webClient) {
+    const existing = new Map();
+    const records = await webClient.getInputNotes(new NoteFilter(NoteFilterTypes.All));
+    for (const record of records) {
+        for (const key of recordKeys(record)) {
+            existing.set(key, record);
+        }
+    }
+    return existing;
+}
+/**
+ * Imports one note with its inclusion proof and classifies the result.
+ * Upstream note-import batches are atomic, which is why callers import
+ * individually — one bad note must not sink the rest. Returns the outcome
+ * and whether the import succeeded (input for the batched consumed-state
+ * re-check).
+ */
+export async function importNoteWithProof(webClient, source, idHex, note, proof) {
+    try {
+        const inputNote = InputNote.authenticated(note, proof);
+        await webClient.importNoteFile(NoteFile.fromInputNote(inputNote));
+        return {
+            outcome: { identifier: idHex, source, status: 'imported' },
+            wasImported: true,
+        };
+    }
+    catch (error) {
+        return {
+            outcome: {
+                identifier: idHex,
+                source,
+                status: 'failed',
+                retryable: isTransientRpcError(error),
+                reason: `failed to import note: ${errorDetail(error)}`,
+            },
+            wasImported: false,
+        };
+    }
+}
+/**
+ * Re-classifies provisionally `imported` outcomes from the records the
+ * import actually left behind. A note the chain had already nullified is
+ * stored as consumption history, not as a consumable note — reported as
+ * `already-consumed`. A note whose inclusion proof failed verification
+ * against the authenticated block header is stored in `Invalid` state by
+ * upstream while the import still resolves — reported as `failed`, because
+ * "recovered" notes that can never be consumed must not count as recovered.
+ * Records are matched by note ID when they expose one, and by the (lossy,
+ * fungible-assets-only) details key otherwise — a chain-consumed record is
+ * stored without metadata, so the approximation is the only join available;
+ * it can only misstate the status here, never skip an import. One batched
+ * store read covers every imported note. A failed check downgrades nothing;
+ * it flags the outcome's classification as unconfirmed instead.
+ */
+export async function reclassifyConsumedImports(webClient, imported, outcomes) {
+    if (imported.length === 0) {
+        return;
+    }
+    try {
+        const records = await webClient.getInputNotes(new NoteFilter(NoteFilterTypes.All));
+        const byId = new Map();
+        const byDetailsKey = new Map();
+        for (const record of records) {
+            const recordId = record.id();
+            if (recordId) {
+                byId.set(normalizeHexWord(recordId.toString()), record);
+            }
+            else {
+                const details = record.details();
+                byDetailsKey.set(detailsKeyOf(normalizeHexWord(details.recipient().digest().toHex()), details.assets()), record);
+            }
+        }
+        for (const entry of imported) {
+            const record = byId.get(entry.idHex) ?? byDetailsKey.get(entry.detailsKey);
+            if (!record) {
+                continue;
+            }
+            if (record.isConsumed()) {
+                outcomes[entry.index] = {
+                    ...outcomes[entry.index],
+                    status: 'already-consumed',
+                    reason: 'note was already consumed on chain; recorded as consumption history',
+                };
+            }
+            else if (record.state() === InputNoteState.Invalid) {
+                outcomes[entry.index] = {
+                    ...outcomes[entry.index],
+                    status: 'failed',
+                    retryable: false,
+                    reason: "the note's inclusion proof failed verification against the authenticated block header; the record is stored as invalid and the note is not consumable",
+                };
+            }
+        }
+    }
+    catch (error) {
+        // The imports themselves succeeded; stay `imported` but flag that the
+        // post-import state check is unknown.
+        for (const entry of imported) {
+            outcomes[entry.index] = {
+                ...outcomes[entry.index],
+                reason: `imported, but the post-import state check failed (${errorDetail(error)}); run sync to confirm the note's status`,
+            };
+        }
+    }
+}
+/**
+ * Imports the notes embedded in v2 `consume_notes` proposals into the local
+ * Miden store, typically after key-based recovery rebuilt the
+ * proposal list (`syncProposals`) but left the note store empty.
+ *
+ * Proposals are opportunistic recovery material, not a backup: v1 proposals
+ * carry no note bytes, and proposals disappear once canonicalized, so only
+ * notes still mid-consumption are recoverable this way.
+ *
+ * Per note: decode the embedded bytes, skip notes the store already tracks,
+ * fetch the on-chain inclusion proof, and import the note individually
+ * (upstream note-import batches are atomic, so one bad note must not sink the
+ * rest). A note the chain does not know yet is recorded as expected with its
+ * tag tracked so a later sync picks it up, and is reported as
+ * `not-committed`/retryable. A note the chain has already nullified is
+ * recorded as consumption history and reported `already-consumed`.
+ *
+ * The returned outcomes cover every unique embedded note — a note embedded by
+ * several proposals yields one outcome, not one per embedding — and this
+ * function does not throw for per-note problems.
+ *
+ * @example
+ * ```typescript
+ * const proposals = await multisig.syncProposals();
+ * const outcomes = await importNotesFromProposals(midenClient, proposals, {
+ *   midenRpcEndpoint: 'https://rpc.testnet.miden.io',
+ * });
+ * await multisig.syncState();
+ * ```
+ */
+export async function importNotesFromProposals(midenClient, proposals, options) {
+    const midenRpcEndpoint = requireMidenRpcEndpoint(options.midenRpcEndpoint);
+    const rpcConfig = resolveRpcConfig(options.rpc);
+    throwIfCancelled(options.cancelled);
+    const webClient = await getRawMidenClient(midenClient, midenRpcEndpoint);
+    const outcomes = [];
+    // Decode, validate, and deduplicate embedded notes (the same note may be
+    // embedded by several proposals). Undecodable entries, embeddings past the
+    // declared note-id list, and embeddings whose decoded ID disagrees with
+    // the declared one become isolated `invalid` outcomes with a positional
+    // identifier: recovery runs automatically over synced proposals, so the
+    // per-index ID binding is what keeps a malformed or adversarial proposal
+    // from smuggling arbitrary notes (and, for uncommitted ones, persistent
+    // expected records and tag registrations) into the local store.
+    const decoded = [];
+    const seen = new Set();
+    for (const proposal of proposals) {
+        const metadata = proposal.metadata;
+        if (metadata.proposalType !== 'consume_notes' || !isConsumeNotesV2(metadata)) {
+            continue;
+        }
+        const embedded = metadata.notes ?? [];
+        const declaredIds = metadata.noteIds ?? [];
+        for (let index = 0; index < embedded.length; index += 1) {
+            const identifier = `proposal ${proposal.id} notes[${index}]`;
+            const declaredId = declaredIds[index];
+            if (declaredId === undefined) {
+                outcomes.push({
+                    identifier,
+                    source: 'proposal',
+                    status: 'invalid',
+                    reason: "embedded note has no matching entry in the proposal's declared note ids",
+                });
+                continue;
+            }
+            // The try covers every per-note WASM accessor, so a payload that
+            // deserializes but traps on use is isolated like any other bad note.
+            let candidate;
+            try {
+                const note = noteFromBase64(embedded[index], Note);
+                candidate = {
+                    note,
+                    idHex: normalizeHexWord(note.id().toString()),
+                    detailsKey: detailsKeyOf(normalizeHexWord(note.recipient().digest().toHex()), note.assets()),
+                };
+            }
+            catch (error) {
+                outcomes.push({
+                    identifier,
+                    source: 'proposal',
+                    status: 'invalid',
+                    reason: `failed to decode embedded note: ${errorDetail(error)}`,
+                });
+                continue;
+            }
+            if (candidate.idHex !== normalizeHexWord(declaredId)) {
+                outcomes.push({
+                    identifier,
+                    source: 'proposal',
+                    status: 'invalid',
+                    reason: `embedded note decodes to ${candidate.idHex} but the proposal declares ${declaredId}`,
+                });
+                continue;
+            }
+            if (seen.has(candidate.idHex)) {
+                continue;
+            }
+            seen.add(candidate.idHex);
+            decoded.push(candidate);
+        }
+    }
+    if (decoded.length === 0) {
+        return outcomes;
+    }
+    let existing;
+    try {
+        existing = await collectExistingRecords(webClient);
+    }
+    catch (error) {
+        const reason = `failed to read local store: ${errorDetail(error)}`;
+        for (const candidate of decoded) {
+            outcomes.push({
+                identifier: candidate.idHex,
+                source: 'proposal',
+                status: 'failed',
+                reason,
+            });
+        }
+        return outcomes;
+    }
+    // Skip notes the store already tracks — but only on an exact note-ID
+    // match. A details-key match is a lossy approximation (see
+    // {@link detailsKeyOf}), so a candidate that only matches a metadata-less
+    // record proceeds to import: the upstream import dedupes exactly by the
+    // real details commitment, upgrading or no-oping in place, so importing
+    // "again" is safe while pre-skipping on the approximation could silently
+    // drop a genuinely new note.
+    const pending = [];
+    for (const candidate of decoded) {
+        const record = existing.get(candidate.idHex);
+        if (record) {
+            outcomes.push({
+                identifier: candidate.idHex,
+                source: 'proposal',
+                status: record.isConsumed() ? 'already-consumed' : 'already-present',
+            });
+            continue;
+        }
+        pending.push(candidate);
+    }
+    if (pending.length === 0) {
+        return outcomes;
+    }
+    // One round trip for all missing notes; only the import itself is per-note.
+    // The node returns proofs for private notes too, so the locally-held bytes
+    // are the only body this path ever needs.
+    const proofs = new Map();
+    throwIfCancelled(options.cancelled);
+    try {
+        const rpcClient = new RpcClient(new Endpoint(midenRpcEndpoint));
+        // Inside the retried closure, so a token flip between attempts stops
+        // the retry loop instead of letting backoff attempts outlive the
+        // deadline.
+        const fetchedNotes = await retryRpcRead(() => {
+            throwIfCancelled(options.cancelled);
+            return rpcClient.getNotesById(pending.map((candidate) => candidate.note.id()));
+        }, rpcConfig);
+        for (const fetched of fetchedNotes) {
+            proofs.set(normalizeHexWord(fetched.noteId.toString()), fetched.inclusionProof);
+        }
+    }
+    catch (error) {
+        if (error instanceof RecoveryCancelledError) {
+            throw error;
+        }
+        const retryable = isTransientRpcError(error);
+        const reason = `failed to fetch inclusion proofs: ${errorDetail(error)}`;
+        for (const candidate of pending) {
+            outcomes.push({
+                identifier: candidate.idHex,
+                source: 'proposal',
+                status: 'failed',
+                retryable,
+                reason,
+            });
+        }
+        return outcomes;
+    }
+    // Provisionally `imported` outcomes, re-classified in one batched
+    // post-import state check below.
+    const imported = [];
+    for (const candidate of pending) {
+        throwIfCancelled(options.cancelled);
+        const proof = proofs.get(candidate.idHex);
+        if (proof) {
+            const { outcome, wasImported } = await importNoteWithProof(webClient, 'proposal', candidate.idHex, candidate.note, proof);
+            if (wasImported) {
+                imported.push({
+                    index: outcomes.length,
+                    idHex: candidate.idHex,
+                    detailsKey: candidate.detailsKey,
+                });
+            }
+            outcomes.push(outcome);
+        }
+        else {
+            try {
+                // Mirror the Rust SDK's `NoteFile::ExpectedNote` + sync-hint import:
+                // the tag rides in the note file itself, so upstream registers a
+                // note-source tag that sync uses to discover the commitment and
+                // removes once the note commits. (An explicit `addTag` would instead
+                // create a permanent user-source tag that the transport backfill
+                // also re-drains, and that would outlive even a failed import.)
+                const details = new NoteDetails(candidate.note.assets(), candidate.note.recipient());
+                await webClient.importNoteFile(NoteFile.fromExpectedNote(details, candidate.note.metadata().tag(), 0));
+                outcomes.push({
+                    identifier: candidate.idHex,
+                    source: 'proposal',
+                    status: 'not-committed',
+                    retryable: true,
+                    reason: 'note not yet committed on chain; recorded as expected so a later sync picks it up',
+                });
+            }
+            catch (error) {
+                outcomes.push({
+                    identifier: candidate.idHex,
+                    source: 'proposal',
+                    status: 'failed',
+                    retryable: isTransientRpcError(error),
+                    reason: `failed to record expected note: ${errorDetail(error)}`,
+                });
+            }
+        }
+    }
+    throwIfCancelled(options.cancelled);
+    await reclassifyConsumedImports(webClient, imported, outcomes);
+    return outcomes;
+}
+//# sourceMappingURL=proposalNoteImport.js.map

package/dist/recovery/proposalNoteImport.js.map

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

package/dist/recovery/publicNoteBackfill.d.ts

@@ -0,0 +1,168 @@
+/**
+ * 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, type Note } from '@miden-sdk/miden-sdk';
+import { type NoteImportOutcome } from './proposalNoteImport.js';
+import { type RawClientSource } from '../raw-client.js';
+import { type RpcConfig } from '../rpc/config.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 declare const RPC_PAGINATION_FRAGMENT = "rpc pagination error";
+/**
+ * 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 declare class BackfillRangeError extends Error {
+}
+/** Verdict of the static relevance screen. */
+export type ScreenVerdict = 'relevant' | 'irrelevant' | 'unscreenable';
+/**
+ * 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 declare function screenNoteForAccount(note: Note, account: AccountId): ScreenVerdict;
+/** A contiguous block range, inclusive on both ends. */
+export interface BlockRange {
+    /** First block of the range. */
+    from: number;
+    /** Last block of the range. */
+    to: number;
+}
+/**
+ * Result of {@link backfillPublicNotesByTag}.
+ *
+ * Scan problems are reported here rather than thrown so a partially failing
+ * scan never aborts the rest of a recovery flow: notes discovered in the
+ * covered ranges are imported regardless.
+ */
+export interface PublicBackfillReport {
+    /** First block of the requested scan range. */
+    scannedFrom: number;
+    /** Last block of the requested scan range. */
+    scannedTo: number;
+    /** Unique tag-matching notes the scan discovered, of every visibility. */
+    discovered: number;
+    /** Unique non-public matches skipped: the chain does not hold their
+     * bodies, so they cannot be rebuilt from a scan. Private notes are covered
+     * by the transport drain and proposal-import primitives instead. */
+    skippedPrivate: number;
+    /** Unique public matches the relevance screen rejected: tags are
+     * best-effort, truncated filters, so unrelated notes can carry this
+     * account's tag. Like normal sync, only notes the account could actually
+     * consume are imported; the rest are counted here. (This SDK screens
+     * statically against the well-known P2ID/P2IDE scripts; the Rust SDK uses
+     * the execution-based screener.) */
+    skippedIrrelevant: number;
+    /** Unique public matches this SDK's static screen could not judge (custom
+     * note scripts). They are conservatively not imported, but counted apart
+     * from `skippedIrrelevant` so callers can tell "screened out" from "not
+     * screenable". Always `0` in the Rust SDK, whose execution-based screener
+     * judges every note. */
+    skippedUnscreenable: number;
+    /** One outcome per unique public note that passed the relevance screen —
+     * `outcomes.length === discovered - skippedPrivate - skippedIrrelevant -
+     * skippedUnscreenable`. Screened-out, unscreenable, and private matches
+     * get no outcome, only their counters. */
+    outcomes: NoteImportOutcome[];
+    /** Sub-ranges of `[scannedFrom, scannedTo]` the scan could not cover (RPC
+     * failures, or the scan budget ran out while splitting around the node's
+     * pagination cap). Empty when the whole range was scanned. Notes committed
+     * in these ranges may be missing from `outcomes`. */
+    uncovered: BlockRange[];
+    /** Whether rerunning the backfill can plausibly improve the result: cover
+     * `uncovered` ranges, or retry outcomes whose own `retryable` flag is set.
+     * Always `false` when the scan fully covered the range and no outcome is
+     * retryable. */
+    retryable: boolean;
+    /** Human-readable cause when the scan did not cover the whole range. */
+    reason?: string;
+}
+export interface BackfillPublicNotesOptions {
+    /** Hex ID of the account whose standard note tag should be scanned. */
+    accountId: string;
+    /** Miden node RPC endpoint used for the scan and body fetches. Must point
+     * at the same network as the injected Miden client. */
+    midenRpcEndpoint: string;
+    /** First block of the scan range (default: genesis). */
+    fromBlock?: number;
+    /** Last block of the scan range (default: the current chain tip). */
+    toBlock?: number;
+    /** Node RPC read-retry configuration (defaults match the rest of the SDK). */
+    rpc?: RpcConfig;
+}
+/**
+ * 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 declare function backfillPublicNotesByTag(midenClient: RawClientSource, options: BackfillPublicNotesOptions): Promise<PublicBackfillReport>;
+//# sourceMappingURL=publicNoteBackfill.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"publicNoteBackfill.d.ts","sourceRoot":"","sources":["../../src/recovery/publicNoteBackfill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,SAAS,EAIT,KAAK,IAAI,EAMV,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAKL,KAAK,iBAAiB,EAEvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAA8C,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACpG,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAKpE;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,yBAAyB,CAAC;AAc9D;;;;;;GAMG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;CAAG;AAUhD,8CAA8C;AAC9C,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,YAAY,GAAG,cAAc,CAAC;AAEvE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,GAAG,aAAa,CAmBlF;AAED,wDAAwD;AACxD,MAAM,WAAW,UAAU;IACzB,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,+CAA+C;IAC/C,WAAW,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,UAAU,EAAE,MAAM,CAAC;IACnB;;wEAEoE;IACpE,cAAc,EAAE,MAAM,CAAC;IACvB;;;;;wCAKoC;IACpC,iBAAiB,EAAE,MAAM,CAAC;IAC1B;;;;4BAIwB;IACxB,mBAAmB,EAAE,MAAM,CAAC;IAC5B;;;8CAG0C;IAC1C,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IAC9B;;;yDAGqD;IACrD,SAAS,EAAE,UAAU,EAAE,CAAC;IACxB;;;oBAGgB;IAChB,SAAS,EAAE,OAAO,CAAC;IACnB,wEAAwE;IACxE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,0BAA0B;IACzC,uEAAuE;IACvE,SAAS,EAAE,MAAM,CAAC;IAClB;2DACuD;IACvD,gBAAgB,EAAE,MAAM,CAAC;IACzB,wDAAwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qEAAqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,GAAG,CAAC,EAAE,SAAS,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAsB,wBAAwB,CAC5C,WAAW,EAAE,eAAe,EAC5B,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,oBAAoB,CAAC,CAsQ/B"}