@sig-net/midnight 0.0.1 → 0.0.2

package/dist/signet-response-feed.d.ts

@@ -1,161 +0,0 @@
-import { type SignetEventSource } from "./signet-event-observer.ts";
-import { type RespondBidirectional } from "./signet-contract-state-reader.ts";
-import { type SignatureResponseVerdict, type SignetPublicStateSource } from "./signet-request-response-reader.ts";
-import type { RequestIdHex, SignBidirectionalRequest } from "./signet-requests.ts";
-/** Default gap between poll cycles of {@link SignetResponseFeed.verdicts}. */
-export declare const DEFAULT_RESPONSE_FEED_POLL_INTERVAL_MS = 3000;
-/** Everything a {@link SignetResponseFeed} needs. */
-export interface SignetResponseFeedConfig {
-    /** Address of the central signet contract whose events and response log to watch. */
-    readonly signetContractAddress: string;
-    /** Address of the signet-compliant requester contract holding the request records (e.g. the vault). */
-    readonly requesterContractAddress: string;
-    /**
-     * Source of BOTH events and raw contract state — a full
-     * `indexerPublicDataProvider` satisfies both halves.
-     */
-    readonly source: SignetEventSource & SignetPublicStateSource;
-    /** Durable resume floor for the underlying observer (see {@link SignetEventObserverConfig.fromEventId}). */
-    readonly fromEventId?: number;
-    /** Poll cadence for {@link SignetResponseFeed.verdicts}; default {@link DEFAULT_RESPONSE_FEED_POLL_INTERVAL_MS}. */
-    readonly pollIntervalMs?: number;
-}
-/**
- * The event-driven signature response feed. Composes a
- * {@link SignetEventObserver} of {@link SignatureRespondedEvent} notifications
- * (discovery) with a {@link SignetRequestResponseReader} (verification),
- * yielding one {@link SignatureResponseVerdict} per posted response, in count
- * order, each exactly once per feed lifetime. Consumers act on the first
- * valid verdict and surface the rejected ones as they see fit — the feed,
- * like the reader, never logs.
- */
-export declare class SignetResponseFeed {
-    private readonly observer;
-    private readonly reader;
-    private readonly pollIntervalMs;
-    private readonly yielded;
-    /**
-     * @param config - The contract pair, combined event/state source, and
-     *   resume floor.
-     */
-    constructor(config: SignetResponseFeedConfig);
-    /** The yielded-count set for `requestId`, created on first use. */
-    private yieldedCounts;
-    /**
-     * One-shot: the verdicts on every response post for `requestId` not yielded
-     * before, in count order. The response log is only read when a currently-
-     * visible event announces a post this feed has not yielded yet — no new
-     * event, no state query. Ledger posts the read then surfaces beyond the
-     * announced ones are yielded too (events are the trigger, the ledger is the
-     * source of truth), and a post whose event is visible but whose write has
-     * not indexed yet is simply retried next cycle.
-     *
-     * @param requestId - The request whose response posts to judge.
-     * @param expectedSigner - The EVM address (0x hex, any case) the genuine
-     *   response must be signed by — the requester's MPC-derived address.
-     * @returns The newly-judged verdicts this cycle (possibly empty).
-     * @throws Error when either contract has no state, the request is not on
-     *   the requester's ledger, or the responses ledger is inconsistent.
-     */
-    poll(requestId: RequestIdHex, expectedSigner: string): Promise<SignatureResponseVerdict[]>;
-    /**
-     * Live stream: poll + sleep, yielding the verdict on each posted response
-     * exactly once, in count order, until `opts.signal` aborts. The natural
-     * consumption is to warn on each rejected verdict and act on the first
-     * valid one (see the cli's poll-signature-response command).
-     *
-     * @param requestId - The request whose response posts to judge.
-     * @param expectedSigner - The EVM address (0x hex, any case) the genuine
-     *   response must be signed by — the requester's MPC-derived address.
-     * @param opts.signal - Abort to stop the stream.
-     * @yields Each post's verdict, in discovery order.
-     * @throws Error when either contract has no state, the request is not on
-     *   the requester's ledger, or the responses ledger is inconsistent.
-     */
-    verdicts(requestId: RequestIdHex, expectedSigner: string, opts?: {
-        signal?: AbortSignal;
-    }): AsyncIterableIterator<SignatureResponseVerdict>;
-    /**
-     * The request record a verdict's response answers, read through the feed's
-     * own reader (cached after the first fetch — free after any {@link poll}
-     * that reached verification). What a consumer needs to assemble the signed
-     * transaction from a valid verdict via
-     * `signBidirectionalRequestToSignedEVMTransaction`.
-     *
-     * @param requestId - The request id to look up.
-     * @returns The stored request record.
-     * @throws Error when the requester contract has no state or holds no
-     *   request under `requestId`.
-     */
-    getSignatureRequest(requestId: RequestIdHex): Promise<SignBidirectionalRequest>;
-}
-/** Everything a {@link SignetRespondBidirectionalFeed} needs. */
-export interface SignetRespondBidirectionalFeedConfig {
-    /**
-     * Address of the central signet contract whose events and
-     * respond-bidirectional index to watch. Attestations live entirely on the
-     * signet contract, so — unlike {@link SignetResponseFeedConfig} — no
-     * requester contract address is needed.
-     */
-    readonly signetContractAddress: string;
-    /**
-     * Source of BOTH events and raw contract state — a full
-     * `indexerPublicDataProvider` satisfies both halves.
-     */
-    readonly source: SignetEventSource & SignetPublicStateSource;
-    /** Durable resume floor for the underlying observer (see {@link SignetEventObserverConfig.fromEventId}). */
-    readonly fromEventId?: number;
-    /** Poll cadence for {@link SignetRespondBidirectionalFeed.attestation}; default {@link DEFAULT_RESPONSE_FEED_POLL_INTERVAL_MS}. */
-    readonly pollIntervalMs?: number;
-}
-/**
- * The event-driven respond-bidirectional feed: composes a
- * {@link SignetEventObserver} of {@link RespondBidirectionalEvent}
- * notifications (discovery) with a read of the signet contract's
- * respond-bidirectional index (the source of truth), yielding the MPC's
- * attestation of a request's remote execution. No verdicts and no off-chain
- * verification — the signet contract verified the attestation IN-CIRCUIT at
- * post time (Schnorr over `(requestId, hash(serializedOutput, outputLen))`
- * against its sealed MPC key), so the stored record is authentic by
- * construction and there is exactly one per request (first valid write wins).
- */
-export declare class SignetRespondBidirectionalFeed {
-    private readonly observer;
-    private readonly signetContractAddress;
-    private readonly source;
-    private readonly pollIntervalMs;
-    private readonly attestations;
-    /**
-     * @param config - The signet contract, combined event/state source, and
-     *   resume floor.
-     */
-    constructor(config: SignetRespondBidirectionalFeedConfig);
-    /**
-     * One-shot: the attestation for `requestId`, or `undefined` while none is
-     * discoverable yet. The index is only read when a currently-visible event
-     * announces `requestId`'s attestation — no event, no state query. An event
-     * whose ledger write has not indexed yet is simply retried next cycle
-     * (events are the trigger, the ledger is the source of truth).
-     *
-     * @param requestId - The request whose attestation to look for.
-     * @returns The stored attestation record, or `undefined` when its event is
-     *   not yet visible or its write not yet indexed.
-     * @throws Error when the signet contract has no state on-chain.
-     */
-    poll(requestId: RequestIdHex): Promise<RespondBidirectional | undefined>;
-    /**
-     * Live wait: poll + sleep until `requestId`'s attestation is discoverable,
-     * and return it. Runs until `opts.signal` aborts — the caller owns the
-     * give-up policy (see the cli's poll-respond-bidirectional command).
-     *
-     * @param requestId - The request whose attestation to wait for.
-     * @param opts.signal - Abort to stop waiting.
-     * @returns The stored attestation record, or `undefined` when aborted
-     *   before one was discovered.
-     * @throws Error when the signet contract has no state on-chain.
-     */
-    attestation(requestId: RequestIdHex, opts?: {
-        signal?: AbortSignal;
-    }): Promise<RespondBidirectional | undefined>;
-}
-//# sourceMappingURL=signet-response-feed.d.ts.map

package/dist/signet-response-feed.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"signet-response-feed.d.ts","sourceRoot":"","sources":["../src/signet-response-feed.ts"],"names":[],"mappings":"AAuBA,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,4BAA4B,CAAC;AAOpC,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAEL,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC7B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,KAAK,EACV,YAAY,EACZ,wBAAwB,EACzB,MAAM,sBAAsB,CAAC;AAE9B,8EAA8E;AAC9E,eAAO,MAAM,sCAAsC,OAAO,CAAC;AAE3D,qDAAqD;AACrD,MAAM,WAAW,wBAAwB;IACvC,qFAAqF;IACrF,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACvC,uGAAuG;IACvG,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAC;IAC1C;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,iBAAiB,GAAG,uBAAuB,CAAC;IAC7D,4GAA4G;IAC5G,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,oHAAoH;IACpH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAED;;;;;;;;GAQG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA+C;IACxE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IACrD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IAIxC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwC;IAEhE;;;OAGG;gBACS,MAAM,EAAE,wBAAwB;IAiB5C,mEAAmE;IACnE,OAAO,CAAC,aAAa;IASrB;;;;;;;;;;;;;;;OAeG;IACG,IAAI,CACR,SAAS,EAAE,YAAY,EACvB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,wBAAwB,EAAE,CAAC;IAoBtC;;;;;;;;;;;;;OAaG;IACI,QAAQ,CACb,SAAS,EAAE,YAAY,EACvB,cAAc,EAAE,MAAM,EACtB,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAC9B,qBAAqB,CAAC,wBAAwB,CAAC;IASlD;;;;;;;;;;;OAWG;IACG,mBAAmB,CACvB,SAAS,EAAE,YAAY,GACtB,OAAO,CAAC,wBAAwB,CAAC;CAGrC;AAED,iEAAiE;AACjE,MAAM,WAAW,oCAAoC;IACnD;;;;;OAKG;IACH,QAAQ,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACvC;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,iBAAiB,GAAG,uBAAuB,CAAC;IAC7D,4GAA4G;IAC5G,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,mIAAmI;IACnI,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAED;;;;;;;;;;GAUG;AACH,qBAAa,8BAA8B;IACzC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiD;IAC1E,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0B;IACjD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IAIxC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAiD;IAE9E;;;OAGG;gBACS,MAAM,EAAE,oCAAoC;IAcxD;;;;;;;;;;;OAWG;IACG,IAAI,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC;IA2B9E;;;;;;;;;;OAUG;IACG,WAAW,CACf,SAAS,EAAE,YAAY,EACvB,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAC9B,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC;CAU7C"}

package/dist/signet-response-feed.js

@@ -1,234 +0,0 @@
-// The requesting client's entry point for discovering MPC signature responses
-// by event observation: watch the central signet contract's
-// SignatureRespondedEvent notifications, and when one announces a post for a
-// request the client cares about, read the response log back and verify every
-// post against the request — the response-direction mirror of
-// signet-request-feed.ts. The event is only the TRIGGER for a state read; the
-// verdicts come from the ledger via the same SignetRequestResponseReader all
-// other consumers use, so an event/state indexing skew in either direction is
-// tolerated (a post visible in state before its event is still yielded; an
-// event whose write has not indexed yet is retried next cycle).
-//
-// Trust model (see "Signet Contract Ledger Layout" in Signet.compact): the
-// response log is UNAUTHENTICATED — neither the event nor the stored record
-// confers authenticity. Only the off-chain signature verification does, which
-// is why the feed yields per-post VERDICTS rather than raw responses.
-//
-// The MPC's OTHER response kind — the respond-bidirectional attestation of a
-// request's remote execution — gets the same event-gated treatment via
-// SignetRespondBidirectionalFeed (RespondBidirectionalEvent → index read),
-// but with the opposite trust model: the signet contract verified the
-// attestation IN-CIRCUIT at post time, so the feed yields the stored record
-// itself, no verdicts.
-import { SignetEventObserver, sleepUnlessAborted, } from "./signet-event-observer.js";
-import { respondBidirectionalEventCodec, signatureRespondedEventCodec, } from "./signet-events.js";
-import { readSignetContractLedgerFromState, } from "./signet-contract-state-reader.js";
-import { SignetRequestResponseReader, } from "./signet-request-response-reader.js";
-/** Default gap between poll cycles of {@link SignetResponseFeed.verdicts}. */
-export const DEFAULT_RESPONSE_FEED_POLL_INTERVAL_MS = 3000;
-/**
- * The event-driven signature response feed. Composes a
- * {@link SignetEventObserver} of {@link SignatureRespondedEvent} notifications
- * (discovery) with a {@link SignetRequestResponseReader} (verification),
- * yielding one {@link SignatureResponseVerdict} per posted response, in count
- * order, each exactly once per feed lifetime. Consumers act on the first
- * valid verdict and surface the rejected ones as they see fit — the feed,
- * like the reader, never logs.
- */
-export class SignetResponseFeed {
-    observer;
-    reader;
-    pollIntervalMs;
-    // Post counts already yielded, per request. NOT a trust boundary (the
-    // verdicts are) — just an exactly-once gate so a post is not re-judged.
-    yielded = new Map();
-    /**
-     * @param config - The contract pair, combined event/state source, and
-     *   resume floor.
-     */
-    constructor(config) {
-        this.observer = new SignetEventObserver({
-            signetContractAddress: config.signetContractAddress,
-            source: config.source,
-            codec: signatureRespondedEventCodec,
-            fromEventId: config.fromEventId,
-            pollIntervalMs: config.pollIntervalMs,
-        });
-        this.reader = new SignetRequestResponseReader({
-            requesterContractAddress: config.requesterContractAddress,
-            signetContractAddress: config.signetContractAddress,
-            publicDataProvider: config.source,
-        });
-        this.pollIntervalMs =
-            config.pollIntervalMs ?? DEFAULT_RESPONSE_FEED_POLL_INTERVAL_MS;
-    }
-    /** The yielded-count set for `requestId`, created on first use. */
-    yieldedCounts(requestId) {
-        let counts = this.yielded.get(requestId);
-        if (counts === undefined) {
-            counts = new Set();
-            this.yielded.set(requestId, counts);
-        }
-        return counts;
-    }
-    /**
-     * One-shot: the verdicts on every response post for `requestId` not yielded
-     * before, in count order. The response log is only read when a currently-
-     * visible event announces a post this feed has not yielded yet — no new
-     * event, no state query. Ledger posts the read then surfaces beyond the
-     * announced ones are yielded too (events are the trigger, the ledger is the
-     * source of truth), and a post whose event is visible but whose write has
-     * not indexed yet is simply retried next cycle.
-     *
-     * @param requestId - The request whose response posts to judge.
-     * @param expectedSigner - The EVM address (0x hex, any case) the genuine
-     *   response must be signed by — the requester's MPC-derived address.
-     * @returns The newly-judged verdicts this cycle (possibly empty).
-     * @throws Error when either contract has no state, the request is not on
-     *   the requester's ledger, or the responses ledger is inconsistent.
-     */
-    async poll(requestId, expectedSigner) {
-        const events = await this.observer.currentEvents();
-        const counts = this.yieldedCounts(requestId);
-        const announcesNew = events.some((event) => event.requestId === requestId && !counts.has(event.count));
-        if (!announcesNew) {
-            return [];
-        }
-        const { verdicts } = await this.reader.getVerifiedSignatureResponse(requestId, expectedSigner);
-        const fresh = verdicts.filter((verdict) => !counts.has(verdict.count));
-        for (const verdict of fresh) {
-            counts.add(verdict.count);
-        }
-        return fresh;
-    }
-    /**
-     * Live stream: poll + sleep, yielding the verdict on each posted response
-     * exactly once, in count order, until `opts.signal` aborts. The natural
-     * consumption is to warn on each rejected verdict and act on the first
-     * valid one (see the cli's poll-signature-response command).
-     *
-     * @param requestId - The request whose response posts to judge.
-     * @param expectedSigner - The EVM address (0x hex, any case) the genuine
-     *   response must be signed by — the requester's MPC-derived address.
-     * @param opts.signal - Abort to stop the stream.
-     * @yields Each post's verdict, in discovery order.
-     * @throws Error when either contract has no state, the request is not on
-     *   the requester's ledger, or the responses ledger is inconsistent.
-     */
-    async *verdicts(requestId, expectedSigner, opts) {
-        while (!opts?.signal?.aborted) {
-            const batch = await this.poll(requestId, expectedSigner);
-            for (const verdict of batch)
-                yield verdict;
-            if (opts?.signal?.aborted)
-                break;
-            await sleepUnlessAborted(this.pollIntervalMs, opts?.signal);
-        }
-    }
-    /**
-     * The request record a verdict's response answers, read through the feed's
-     * own reader (cached after the first fetch — free after any {@link poll}
-     * that reached verification). What a consumer needs to assemble the signed
-     * transaction from a valid verdict via
-     * `signBidirectionalRequestToSignedEVMTransaction`.
-     *
-     * @param requestId - The request id to look up.
-     * @returns The stored request record.
-     * @throws Error when the requester contract has no state or holds no
-     *   request under `requestId`.
-     */
-    async getSignatureRequest(requestId) {
-        return this.reader.getSignatureRequest(requestId);
-    }
-}
-/**
- * The event-driven respond-bidirectional feed: composes a
- * {@link SignetEventObserver} of {@link RespondBidirectionalEvent}
- * notifications (discovery) with a read of the signet contract's
- * respond-bidirectional index (the source of truth), yielding the MPC's
- * attestation of a request's remote execution. No verdicts and no off-chain
- * verification — the signet contract verified the attestation IN-CIRCUIT at
- * post time (Schnorr over `(requestId, hash(serializedOutput, outputLen))`
- * against its sealed MPC key), so the stored record is authentic by
- * construction and there is exactly one per request (first valid write wins).
- */
-export class SignetRespondBidirectionalFeed {
-    observer;
-    signetContractAddress;
-    source;
-    pollIntervalMs;
-    // Attestation records never change once stored (one authenticated slot per
-    // request, first valid write wins), so cache them across polls.
-    attestations = new Map();
-    /**
-     * @param config - The signet contract, combined event/state source, and
-     *   resume floor.
-     */
-    constructor(config) {
-        this.observer = new SignetEventObserver({
-            signetContractAddress: config.signetContractAddress,
-            source: config.source,
-            codec: respondBidirectionalEventCodec,
-            fromEventId: config.fromEventId,
-            pollIntervalMs: config.pollIntervalMs,
-        });
-        this.signetContractAddress = config.signetContractAddress;
-        this.source = config.source;
-        this.pollIntervalMs =
-            config.pollIntervalMs ?? DEFAULT_RESPONSE_FEED_POLL_INTERVAL_MS;
-    }
-    /**
-     * One-shot: the attestation for `requestId`, or `undefined` while none is
-     * discoverable yet. The index is only read when a currently-visible event
-     * announces `requestId`'s attestation — no event, no state query. An event
-     * whose ledger write has not indexed yet is simply retried next cycle
-     * (events are the trigger, the ledger is the source of truth).
-     *
-     * @param requestId - The request whose attestation to look for.
-     * @returns The stored attestation record, or `undefined` when its event is
-     *   not yet visible or its write not yet indexed.
-     * @throws Error when the signet contract has no state on-chain.
-     */
-    async poll(requestId) {
-        const cached = this.attestations.get(requestId);
-        if (cached !== undefined) {
-            return cached;
-        }
-        const events = await this.observer.currentEvents();
-        if (!events.some((event) => event.requestId === requestId)) {
-            return undefined;
-        }
-        const state = await this.source.queryContractState(this.signetContractAddress);
-        if (!state?.data) {
-            throw new Error(`no state data found for signet contract '${this.signetContractAddress}' - is it deployed?`);
-        }
-        const record = readSignetContractLedgerFromState(state.data).respondBidirectionalIndex.get(requestId);
-        if (record === undefined) {
-            return undefined;
-        }
-        this.attestations.set(requestId, record);
-        return record;
-    }
-    /**
-     * Live wait: poll + sleep until `requestId`'s attestation is discoverable,
-     * and return it. Runs until `opts.signal` aborts — the caller owns the
-     * give-up policy (see the cli's poll-respond-bidirectional command).
-     *
-     * @param requestId - The request whose attestation to wait for.
-     * @param opts.signal - Abort to stop waiting.
-     * @returns The stored attestation record, or `undefined` when aborted
-     *   before one was discovered.
-     * @throws Error when the signet contract has no state on-chain.
-     */
-    async attestation(requestId, opts) {
-        while (!opts?.signal?.aborted) {
-            const record = await this.poll(requestId);
-            if (record !== undefined) {
-                return record;
-            }
-            await sleepUnlessAborted(this.pollIntervalMs, opts?.signal);
-        }
-        return undefined;
-    }
-}
-//# sourceMappingURL=signet-response-feed.js.map

package/dist/signet-response-feed.js.map

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

package/src/signet-event-observer.ts

@@ -1,186 +0,0 @@
-// Watch the CENTRAL signet contract's `Misc` events and surface ONE kind of
-// signet notification (selected by the codec) as typed events in id order —
-// the event-observation replacement for polling ledgers blind. Instantiated
-// with `signBidirectionalEventCodec` it discovers signature requests for the
-// MPC (see signet-request-feed.ts); with `signatureRespondedEventCodec` it
-// discovers posted signature responses for the requesting client (see
-// signet-response-feed.ts). The observer only DISCOVERS; authenticating /
-// verifying what an event points at is its consumer's job. The event is a
-// ping, never the source of truth — see
-// knowledge-base/caller-attribution.md.
-
-import type {
-  ContractEvent,
-  ContractEventQueryFilter,
-  PublicDataProvider,
-} from "@midnight-ntwrk/midnight-js-types";
-
-import {
-  eventNameTag,
-  hexToBytes,
-  type SignetMiscEventCodec,
-} from "./signet-events.ts";
-
-/** Default gap between polls of the indexer's event stream. */
-export const DEFAULT_EVENT_POLL_INTERVAL_MS = 3000;
-
-/**
- * The least of midnight-js's `PublicDataProvider` the event path needs: read a
- * contract's events, and (optionally) stream them live. Declared structurally
- * so tests can satisfy it with a plain stub; any full `PublicDataProvider`
- * (e.g. `indexerPublicDataProvider`) is assignable to it.
- */
-export interface SignetEventSource {
-  /**
-   * Point-in-time read of a contract's events matching `filter`.
-   *
-   * @param filter - The event filter; `contractAddress` is required, an empty
-   *   `types` array is rejected (omit for all).
-   * @returns The matching events, in ascending indexer-id order.
-   */
-  queryContractEvents(filter: ContractEventQueryFilter): Promise<ContractEvent[]>;
-  /**
-   * Optional live stream, for a future push path. Typed off
-   * `PublicDataProvider` so a full provider stays assignable; the observer's
-   * default path polls {@link queryContractEvents}.
-   */
-  contractEventsObservable?: PublicDataProvider["contractEventsObservable"];
-}
-
-/** Everything a {@link SignetEventObserver} needs. */
-export interface SignetEventObserverConfig<T> {
-  /** Address of the central signet contract whose events to watch. */
-  readonly signetContractAddress: string;
-  /** Source of contract events, e.g. midnight-js's `indexerPublicDataProvider`. */
-  readonly source: SignetEventSource;
-  /**
-   * Which signet event kind to surface: the `Misc.name` tag to filter on and
-   * the payload decoder, e.g. `signBidirectionalEventCodec` or
-   * `signatureRespondedEventCodec` (signet-events.ts).
-   */
-  readonly codec: SignetMiscEventCodec<T>;
-  /**
-   * Durable resume floor: only events with `id >= fromEventId` are considered
-   * (the in-memory cursor of a prior run, persisted across restarts so nothing
-   * is missed or replayed). Defaults to 0 — the start of the event stream.
-   */
-  readonly fromEventId?: number;
-  /** Poll cadence for {@link SignetEventObserver.watch}; default {@link DEFAULT_EVENT_POLL_INTERVAL_MS}. */
-  readonly pollIntervalMs?: number;
-}
-
-/**
- * Resolve after `ms`, or immediately once `signal` aborts. Used to space out
- * polls without wedging a shutdown.
- */
-function sleep(ms: number, signal?: AbortSignal): Promise<void> {
-  return new Promise((resolve) => {
-    if (signal?.aborted) return resolve();
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timer);
-      resolve();
-    };
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-
-/**
- * Watches one signet contract's `Misc` events and surfaces the notifications
- * of ONE kind among them (the codec's name tag), decoded and in ascending
- * indexer-id order. A single decode failure is logged and skipped — one
- * malformed event never stalls the stream.
- */
-export class SignetEventObserver<T> {
-  private readonly signetContractAddress: string;
-  private readonly source: SignetEventSource;
-  private readonly codec: SignetMiscEventCodec<T>;
-  private readonly fromEventId: number;
-  private readonly pollIntervalMs: number;
-
-  /**
-   * @param config - The signet contract, event source, codec, and resume floor.
-   */
-  constructor(config: SignetEventObserverConfig<T>) {
-    this.signetContractAddress = config.signetContractAddress;
-    this.source = config.source;
-    this.codec = config.codec;
-    this.fromEventId = config.fromEventId ?? 0;
-    this.pollIntervalMs = config.pollIntervalMs ?? DEFAULT_EVENT_POLL_INTERVAL_MS;
-  }
-
-  /** The `Misc` filter for the watched signet contract. */
-  private filter(): ContractEventQueryFilter {
-    return { contractAddress: this.signetContractAddress, types: ["Misc"] };
-  }
-
-  /**
-   * Every currently-visible notification of the codec's kind at or after the
-   * resume floor, each paired with its indexer cursor id, ascending by id.
-   * Non-`Misc` events, other name tags, and decode failures are dropped
-   * (failures logged).
-   */
-  private async scan(): Promise<Array<{ id: number; event: T }>> {
-    const events = await this.source.queryContractEvents(this.filter());
-    const out: Array<{ id: number; event: T }> = [];
-    for (const event of events) {
-      if (event.eventType !== "Misc") continue;
-      if (event.id < this.fromEventId) continue;
-      if (eventNameTag(event.name) !== this.codec.tag) continue;
-      let decoded: T;
-      try {
-        decoded = this.codec.decode(hexToBytes(event.payload));
-      } catch (error) {
-        console.warn(
-          `SignetEventObserver: dropping undecodable ${this.codec.tag} ` +
-            `event id=${event.id}: ${String(error)}`,
-        );
-        continue;
-      }
-      out.push({ id: event.id, event: decoded });
-    }
-    out.sort((a, b) => a.id - b.id);
-    return out;
-  }
-
-  /**
-   * One-shot: every notification of the codec's kind currently visible at or
-   * after the resume floor, in id order. The polling feeds
-   * ({@link SignetRequestFeed}, `SignetResponseFeed`) re-scan through this
-   * each cycle (so a not-yet-indexed write is retried); it does NOT advance a
-   * cursor — the feeds dedupe by content instead.
-   *
-   * @returns The decoded notifications, ascending by indexer id.
-   */
-  async currentEvents(): Promise<T[]> {
-    return (await this.scan()).map((entry) => entry.event);
-  }
-
-  /**
-   * Live stream: poll the event source forever, yielding each notification
-   * exactly once in id order — nothing at or below the last yielded id is
-   * re-emitted (the cursor advances as `id + 1`, matching the indexer's
-   * resume convention). Runs until `opts.signal` aborts.
-   *
-   * @param opts.signal - Abort to stop the stream (between polls or on the next yield).
-   * @yields Each decoded notification once, ascending by indexer id.
-   */
-  async *watch(opts?: { signal?: AbortSignal }): AsyncIterableIterator<T> {
-    let cursor = this.fromEventId;
-    while (!opts?.signal?.aborted) {
-      const batch = await this.scan();
-      for (const { id, event } of batch) {
-        if (id < cursor) continue;
-        yield event;
-        cursor = id + 1;
-      }
-      if (opts?.signal?.aborted) break;
-      await sleep(this.pollIntervalMs, opts?.signal);
-    }
-  }
-}
-
-export { sleep as sleepUnlessAborted };