@sig-net/midnight 0.0.2 → 0.0.4

package/src/signet-request-feed.ts

@@ -1,208 +0,0 @@
-// The MPC's single entry point for discovering signature requests: poll the
-// central signet contract's notification registry (ledger field 4), resolve
-// each notification to an AUTHENTICATED request read from the named caller's
-// own ledger, and yield only the ones that pass the membership check. The
-// registry is append-only with no on-ledger cursor, so the feed's in-memory
-// `yielded` set is the diff cursor: every poll enumerates the registry and
-// serves what it has not served before.
-//
-// The requester allow-list is an OPTIONAL policy filter here (drop requests
-// from contracts you choose not to serve), never a security requirement and
-// never the discovery mechanism — attribution comes from the resolver's
-// authenticated read (see signet-request-resolver.ts and
-// knowledge-base/caller-attribution.md).
-
-import {
-  decodeSignBidirectionalNotification,
-  readSignBidirectionalNotificationIndexFromState,
-} from "./signet-contract-state-reader.ts";
-import {
-  SignetRequestResolver,
-  type ResolvedSignetRequest,
-} from "./signet-request-resolver.ts";
-import type { SignetPublicStateSource } from "./signet-request-response-reader.ts";
-import { stripHexPrefix, type RequestIdHex } from "./signet-requests.ts";
-
-/** Default gap between poll cycles of {@link SignetRequestFeed.requests}. */
-export const DEFAULT_FEED_POLL_INTERVAL_MS = 3000;
-
-/** Everything a {@link SignetRequestFeed} needs. */
-export interface SignetRequestFeedConfig {
-  /** Address of the central signet contract whose notification registry to poll. */
-  readonly signetContractAddress: string;
-  /**
-   * Source of raw contract state for BOTH the signet contract's registry and
-   * the requester ledgers the resolver authenticates against — a full
-   * `indexerPublicDataProvider` is assignable.
-   */
-  readonly source: SignetPublicStateSource;
-  /**
-   * Optional policy allow-list of requester contract addresses to serve
-   * (matched case- and `0x`-prefix-insensitively). Omit to serve every
-   * requester the resolver can authenticate. NOT a security control.
-   */
-  readonly allowContracts?: Iterable<string>;
-  /** Poll cadence for {@link SignetRequestFeed.requests}; default {@link DEFAULT_FEED_POLL_INTERVAL_MS}. */
-  readonly pollIntervalMs?: number;
-}
-
-/**
- * Resolve after `ms`, or immediately once `signal` aborts. Used to space out
- * polls without wedging a shutdown.
- *
- * @param ms - Milliseconds to wait.
- * @param signal - Abort to resolve early.
- * @returns A promise that settles after the delay or the abort.
- */
-export function sleepUnlessAborted(
-  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 });
-  });
-}
-
-/** Canonical form for comparing contract addresses: no `0x`, lowercase. */
-function normalizeAddress(address: string): string {
-  return stripHexPrefix(address).toLowerCase();
-}
-
-/**
- * The registry-polling request feed. Reads the signet contract's notification
- * registry (discovery) and hands each notification to a
- * {@link SignetRequestResolver} (authentication), yielding only notifications
- * that resolve to a real, member request. Dedupes by request id across its
- * lifetime, so a re-registered notification is not re-yielded; call
- * {@link forget} to re-arm a request whose downstream processing failed.
- */
-export class SignetRequestFeed {
-  private readonly signetContractAddress: string;
-  private readonly source: SignetPublicStateSource;
-  private readonly resolver: SignetRequestResolver;
-  private readonly allowContracts?: Set<string>;
-  private readonly pollIntervalMs: number;
-
-  // Request ids already yielded. NOT the security boundary (the resolver is) —
-  // just an at-most-once gate so one request is not processed twice.
-  private readonly yielded = new Set<RequestIdHex>();
-
-  /**
-   * @param config - The signet contract, state source, and optional policy
-   *   allow-list.
-   */
-  constructor(config: SignetRequestFeedConfig) {
-    this.signetContractAddress = config.signetContractAddress;
-    this.source = config.source;
-    this.resolver = new SignetRequestResolver({ source: config.source });
-    this.allowContracts = config.allowContracts
-      ? new Set(Array.from(config.allowContracts, normalizeAddress))
-      : undefined;
-    this.pollIntervalMs =
-      config.pollIntervalMs ?? DEFAULT_FEED_POLL_INTERVAL_MS;
-  }
-
-  /** Whether the policy allow-list admits `callerAddress` (always true when unset). */
-  private allowed(callerAddress: string): boolean {
-    return (
-      this.allowContracts === undefined ||
-      this.allowContracts.has(normalizeAddress(callerAddress))
-    );
-  }
-
-  /**
-   * One-shot: every currently-registered notification that decodes, is
-   * admitted by the allow-list, not already yielded, and resolves to an
-   * authenticated member request. Registry enumeration has no meaningful
-   * on-ledger order, so entries are processed in ascending request-id-hex
-   * order — a stable, deterministic sequence. Forged / not-yet-indexed /
-   * wrong-field notifications resolve to nothing and are dropped WITHOUT
-   * being marked yielded, so a genuine request whose ledger write has not
-   * indexed yet is retried next cycle; undecodable or unsupported-version
-   * records are likewise skipped (and logged) without being marked.
-   *
-   * Dedupe and resolution key off the notification PAYLOAD's request id (the
-   * canonical one — the registry map key is caller-supplied and could
-   * disagree; the resolver's membership check authenticates the payload's).
-   *
-   * @returns The newly-authenticated requests this cycle.
-   * @throws Error if the signet contract has no readable state at the
-   *   configured address (wrong address or not yet deployed/indexed).
-   */
-  async poll(): Promise<ResolvedSignetRequest[]> {
-    const state = await this.source.queryContractState(
-      this.signetContractAddress,
-    );
-    if (!state?.data) {
-      throw new Error(
-        `No contract state at signet contract ${this.signetContractAddress} ` +
-          `— wrong address, or not yet deployed/indexed`,
-      );
-    }
-    const registry = readSignBidirectionalNotificationIndexFromState(
-      state.data,
-    );
-    const out: ResolvedSignetRequest[] = [];
-    for (const [registryKey, record] of [...registry.entries()].sort(
-      ([a], [b]) => (a < b ? -1 : a > b ? 1 : 0),
-    )) {
-      let notification;
-      try {
-        notification = decodeSignBidirectionalNotification(record);
-      } catch (error) {
-        console.warn(
-          `SignetRequestFeed: skipping undecodable notification ` +
-            `registered under ${registryKey}: ${String(error)}`,
-        );
-        continue;
-      }
-      if (this.yielded.has(notification.requestId)) continue;
-      if (!this.allowed(notification.callerAddress)) continue;
-      const resolved = await this.resolver.resolve(notification);
-      if (resolved === undefined) continue;
-      this.yielded.add(notification.requestId);
-      out.push(resolved);
-    }
-    return out;
-  }
-
-  /**
-   * Re-arm `requestId` for redelivery on the next {@link poll} / {@link requests}
-   * cycle — call when downstream processing of a yielded request failed, so it
-   * is retried (mirrors the MPC's delete-on-failure of its processed set).
-   *
-   * @param requestId - The request id to allow through again.
-   */
-  forget(requestId: RequestIdHex): void {
-    this.yielded.delete(requestId);
-  }
-
-  /**
-   * Live stream: poll + sleep, yielding each authenticated request exactly once
-   * (subject to {@link forget}), until `opts.signal` aborts. The natural
-   * sequential `for await` consumption serializes downstream processing — no
-   * two requests are handed over concurrently.
-   *
-   * @param opts.signal - Abort to stop the stream.
-   * @yields Each authenticated request, in discovery order.
-   */
-  async *requests(opts?: {
-    signal?: AbortSignal;
-  }): AsyncIterableIterator<ResolvedSignetRequest> {
-    while (!opts?.signal?.aborted) {
-      const batch = await this.poll();
-      for (const resolved of batch) yield resolved;
-      if (opts?.signal?.aborted) break;
-      await sleepUnlessAborted(this.pollIntervalMs, opts?.signal);
-    }
-  }
-}

package/src/signet-request-resolver.ts

@@ -1,116 +0,0 @@
-// Turn a SignBidirectionalNotification into an AUTHENTICATED request record.
-// This is the security core of the discovery flow (see
-// knowledge-base/caller-attribution.md): the notification says only WHERE to
-// look; the request that gets signed is read from the named caller's own
-// authenticated ledger, and the notification's `requestId` must be a member
-// of that contract's request index. An attacker cannot write into a contract
-// it does not control, so a forged notification can at most re-point at a
-// legitimate request that already exists — never inject one.
-//
-// Key derivation stays f(callerAddress, path), keyed off the contract whose
-// authenticated state was actually read — the notification registry is a
-// pointer board, never an authority.
-
-import { lookupSignetRequestAt } from "./signature-requests-state-reader.ts";
-import type { RawContractState } from "./signature-state-reading.ts";
-import type { SignBidirectionalNotification } from "./signet-contract-state-reader.ts";
-import type { SignetPublicStateSource } from "./signet-request-response-reader.ts";
-import type {
-  RequestIdHex,
-  SignBidirectionalRequest,
-} from "./signet-requests.ts";
-
-/**
- * A {@link SignBidirectionalNotification} resolved to the authenticated
- * request it refers to: the request record read from `callerAddress`'s own
- * ledger, with `requestId` confirmed to be a member of that contract's index.
- */
-export interface ResolvedSignetRequest {
-  /**
-   * The contract whose authenticated state the request was read from — the
-   * epsilon-derivation predecessor. Key derivation keys off THIS, never off a
-   * field taken from the notification on faith.
-   */
-  callerAddress: string;
-  /** The request id, confirmed to be a member of `callerAddress`'s index. */
-  requestId: RequestIdHex;
-  /** The authenticated request record to sign. */
-  request: SignBidirectionalRequest;
-}
-
-/** Everything a {@link SignetRequestResolver} needs. */
-export interface SignetRequestResolverConfig {
-  /** Source of raw contract state, e.g. midnight-js's `indexerPublicDataProvider`. */
-  readonly source: SignetPublicStateSource;
-}
-
-/**
- * Resolves {@link SignBidirectionalNotification}s to authenticated
- * {@link ResolvedSignetRequest}s by reading the named caller's ledger and
- * enforcing the membership check. Construct once and reuse: resolved records
- * are immutable (their ledger key is their hash), so they are cached by request
- * id and a repeated notification for the same request costs no query.
- *
- * NB the cache is keyed by request id, NOT by contract address: a caller
- * contract's state grows as it stores new requests, so caching its state would
- * make the resolver blind to later requests from the same caller. Caching the
- * immutable resolved record instead is the same pattern
- * {@link SignetRequestResponseReader.getSignatureRequest} uses.
- */
-export class SignetRequestResolver {
-  private readonly source: SignetPublicStateSource;
-
-  // Resolved records never change; cache them so a redelivered notification for
-  // the same request id does not re-query the caller's state.
-  private readonly resolvedCache = new Map<RequestIdHex, ResolvedSignetRequest>();
-
-  /**
-   * @param config - The state source to read caller ledgers through.
-   */
-  constructor(config: SignetRequestResolverConfig) {
-    this.source = config.source;
-  }
-
-  /**
-   * Resolve a notification to its authenticated request, or `undefined` when it
-   * cannot be trusted: the caller contract has no state, or `requestId` is not
-   * a member of the index at `requestsIndexField` (forged, stale, wrong field,
-   * or not yet indexed — poll again). Never throws on an untrusted
-   * notification; a bad one is dropped, not surfaced as an error.
-   *
-   * @param notification - The decoded notification.
-   * @returns The authenticated request, or `undefined` to drop the notification.
-   */
-  async resolve(
-    notification: SignBidirectionalNotification,
-  ): Promise<ResolvedSignetRequest | undefined> {
-    const cached = this.resolvedCache.get(notification.requestId);
-    if (cached !== undefined) {
-      return cached;
-    }
-    let state: { data: RawContractState } | null;
-    try {
-      state = await this.source.queryContractState(notification.callerAddress);
-    } catch {
-      return undefined; // caller address not a contract / transient read error
-    }
-    if (!state?.data) {
-      return undefined; // no state at the named caller — cannot authenticate
-    }
-    const request = lookupSignetRequestAt(
-      state.data,
-      notification.requestsIndexField,
-      notification.requestId,
-    );
-    if (request === undefined) {
-      return undefined; // membership check failed — drop the notification
-    }
-    const resolved: ResolvedSignetRequest = {
-      callerAddress: notification.callerAddress,
-      requestId: notification.requestId,
-      request,
-    };
-    this.resolvedCache.set(notification.requestId, resolved);
-    return resolved;
-  }
-}

package/src/signet-request-response-reader.ts

@@ -1,324 +0,0 @@
-// One-stop client-side reader for the signet request/response flow: fetch a
-// request record from the requester contract's ledger, enumerate the posts in
-// the signet contract's signature response log, and verify each candidate
-// against the request.
-// This is the helper the Signet.compact "Response Ledger Layout" comment
-// promises — the log is UNAUTHENTICATED, so a client must verify every post
-// and take the first valid one; this class packages that flow so every
-// consumer (CLI poller, integration tests, a future UI) shares one
-// implementation. Single-shot by design: each call queries state once; the
-// caller owns any poll loop.
-
-import type { PublicDataProvider } from "@midnight-ntwrk/midnight-js-types";
-import type { Transaction } from "ethers";
-
-import { readSignetRequestsLedgerFromState } from "./signature-requests-state-reader.ts";
-import {
-  readSignetContractLedgerFromState,
-  signetResponseIndexKey,
-  type SignatureResponse,
-  type RespondBidirectional,
-} from "./signet-contract-state-reader.ts";
-import { recoverSignatureResponseSigner } from "./signature-response-verification.ts";
-import type { RawContractState } from "./signature-state-reading.ts";
-import {
-  signBidirectionalRequestToSignedEVMTransaction,
-  signBidirectionalRequestToUnsignedEVMTransaction,
-  type SignBidirectionalRequest,
-  type RequestIdHex,
-} from "./signet-requests.ts";
-
-/**
- * The least of midnight-js's `PublicDataProvider` the reader needs: raw
- * contract state by address. Declared structurally (rather than a `Pick`) so
- * tests can satisfy it with a plain stub; any full `PublicDataProvider`
- * (e.g. `indexerPublicDataProvider`) is assignable to it.
- */
-export interface SignetPublicStateSource {
-  /**
-   * Retrieve the on-chain state of a contract at the latest block.
-   *
-   * @param contractAddress - The contract address to query.
-   * @returns The state (its `data` is the raw ledger tree), or `null` when
-   *   the address holds no contract.
-   */
-  queryContractState(
-    contractAddress: Parameters<PublicDataProvider["queryContractState"]>[0],
-  ): Promise<{ data: RawContractState } | null>;
-}
-
-/** Everything a {@link SignetRequestResponseReader} needs to operate. */
-export interface SignetRequestResponseReaderConfig {
-  /** Address of the signet-compliant requester contract (e.g. the vault). */
-  readonly requesterContractAddress: string;
-  /** Address of the central signet contract. */
-  readonly signetContractAddress: string;
-  /** Source of raw contract state, e.g. midnight-js's `indexerPublicDataProvider`. */
-  readonly publicDataProvider: SignetPublicStateSource;
-}
-
-/** The verdict on one posted response, in `count` order. */
-export interface SignatureResponseVerdict {
-  /** 0-based position of the post in the request's response log. */
-  count: bigint;
-  /** The posted signature record, verbatim. */
-  response: SignatureResponse;
-  /** Recovered signer address — absent when the signature did not decode. */
-  signer?: string;
-  /** Why the post was rejected; absent when the post is valid. */
-  rejectedReason?: string;
-}
-
-/** Result of {@link SignetRequestResponseReader['getVerifiedSignatureResponse']}. */
-export interface VerifiedSignatureResponseResult {
-  /**
-   * The first valid response (lowest count), or `undefined` when no valid
-   * response has been posted yet — poll again.
-   */
-  verified?: SignatureResponse;
-  /**
-   * One verdict per post, count order. Pure data: the reader never logs, so
-   * callers decide how to surface rejected posts.
-   */
-  verdicts: SignatureResponseVerdict[];
-}
-
-/**
- * Reader over one requester contract / signet contract pair.
- * Construct once per pair and reuse: fetched request records are cached (they
- * are immutable — the ledger key is their hash), so repeated verification
- * calls cost one responses-contract query each.
- */
-export class SignetRequestResponseReader {
-  private readonly config: SignetRequestResponseReaderConfig;
-
-  // Request records never change once stored; cache them across calls.
-  private readonly requestCache = new Map<
-    RequestIdHex,
-    SignBidirectionalRequest
-  >();
-
-  /**
-   * @param config - The contract pair and state source to read through.
-   */
-  constructor(config: SignetRequestResponseReaderConfig) {
-    this.config = config;
-  }
-
-  /**
-   * Query one contract's raw state, throwing a uniform error when absent.
-   *
-   * @param contractAddress - The contract to query.
-   * @param role - Human name of the contract for the error message.
-   * @returns The raw ledger state tree.
-   * @throws Error when the address holds no contract state.
-   */
-  private async queryRawState(
-    contractAddress: string,
-    role: string,
-  ): Promise<RawContractState> {
-    const state =
-      await this.config.publicDataProvider.queryContractState(contractAddress);
-    if (!state?.data) {
-      throw new Error(
-        `no state data found for ${role} contract '${contractAddress}' - is it deployed?`,
-      );
-    }
-    return state.data;
-  }
-
-  /**
-   * Fetch the request record for `requestId` from the requester contract's
-   * ledger (request index, field 0 by the signet layout convention). Cached
-   * after the first fetch.
-   *
-   * @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: RequestIdHex,
-  ): Promise<SignBidirectionalRequest> {
-    const cached = this.requestCache.get(requestId);
-    if (cached !== undefined) {
-      return cached;
-    }
-    const raw = await this.queryRawState(
-      this.config.requesterContractAddress,
-      "requester",
-    );
-    const { requestsIndex } = readSignetRequestsLedgerFromState(raw);
-    const request = requestsIndex.get(requestId);
-    if (request === undefined) {
-      throw new Error(
-        `request ${requestId} is not on the requester contract's ledger — was it submitted?`,
-      );
-    }
-    this.requestCache.set(requestId, request);
-    return request;
-  }
-
-  /**
-   * Fetch every response posted for `requestId`, in post (count) order.
-   * UNVERIFIED — any of them may be garbage; see
-   * {@link getVerifiedSignatureResponse}.
-   *
-   * @param requestId - The request id whose posts to enumerate.
-   * @returns The posted payloads, index = count; empty when none yet.
-   * @throws Error when the responses contract has no state, or its counter
-   *   disagrees with the log (inconsistent ledger).
-   */
-  async getSignatureResponses(
-    requestId: RequestIdHex,
-  ): Promise<SignatureResponse[]> {
-    const raw = await this.queryRawState(
-      this.config.signetContractAddress,
-      "signet contract",
-    );
-    const { signatureResponseCounterIndex, signatureResponseIndex } =
-      readSignetContractLedgerFromState(raw);
-    const totalPosts = signatureResponseCounterIndex.get(requestId) ?? 0n;
-    const responses: SignatureResponse[] = [];
-    for (let count = 0n; count < totalPosts; count++) {
-      const response = signatureResponseIndex.get(
-        signetResponseIndexKey(requestId, count),
-      );
-      if (response === undefined) {
-        throw new Error(
-          `response log has no entry ${count} for request ${requestId} ` +
-            `despite its counter reading ${totalPosts} — ledger state is inconsistent`,
-        );
-      }
-      responses.push(response);
-    }
-    return responses;
-  }
-
-  /**
-   * Fetch and verify the responses posted for `requestId`: each post's
-   * `{ bigR, s, recoveryId }` signature must recover to `expectedSigner`
-   * (compared case-insensitively) over the signing hash of the transaction
-   * the request record describes. The first valid post wins; every post gets
-   * a verdict so callers can report the noise.
-   *
-   * @param requestId - The request id to fetch a verified response for.
-   * @param expectedSigner - The EVM address (0x hex, any case) the genuine
-   *   response must be signed by — the requester's MPC-derived address.
-   * @returns The first valid response (if any) plus per-post verdicts.
-   * @throws Error when either contract has no state, the request is not on
-   *   the requester's ledger, or the responses ledger is inconsistent.
-   */
-  async getVerifiedSignatureResponse(
-    requestId: RequestIdHex,
-    expectedSigner: string,
-  ): Promise<VerifiedSignatureResponseResult> {
-    const request = await this.getSignatureRequest(requestId);
-    const responses = await this.getSignatureResponses(requestId);
-    const verdicts = responses.map(
-      (response, index): SignatureResponseVerdict => {
-        const count = BigInt(index);
-        let signer: string;
-        try {
-          signer = recoverSignatureResponseSigner(request, response);
-        } catch (error) {
-          return {
-            count,
-            response,
-            rejectedReason: `not a decodable signature (${String(error)})`,
-          };
-        }
-        if (signer.toLowerCase() !== expectedSigner.toLowerCase()) {
-          return {
-            count,
-            response,
-            signer,
-            rejectedReason: `signed by ${signer}, expected ${expectedSigner}`,
-          };
-        }
-        return { count, response, signer };
-      },
-    );
-    return {
-      verified: verdicts.find((v) => v.rejectedReason === undefined)?.response,
-      verdicts,
-    };
-  }
-
-  /**
-   * Rebuild the unsigned EIP-1559 transaction for `requestId` — the exact
-   * transaction the MPC signs, assembled from the request record's decomposed
-   * fields. No responses-contract query: this needs only the request record
-   * (fetched via {@link getSignatureRequest}, cached).
-   *
-   * @param requestId - The request id whose transaction to rebuild.
-   * @returns The unsigned ethers transaction (`unsignedHash` is the MPC's
-   *   signing digest).
-   * @throws Error when the requester contract has no state or holds no
-   *   request under `requestId`.
-   */
-  async getUnsignedEVMTransaction(
-    requestId: RequestIdHex,
-  ): Promise<Transaction> {
-    return signBidirectionalRequestToUnsignedEVMTransaction(
-      await this.getSignatureRequest(requestId),
-    );
-  }
-
-  /**
-   * Assemble the broadcast-ready signed EIP-1559 transaction for `requestId`:
-   * rebuild the request's transaction and attach the first VERIFIED response
-   * signed by `expectedSigner` (see {@link getVerifiedSignatureResponse} — the
-   * response log is unauthenticated, so an `expectedSigner` is required and
-   * unverified posts are never attached).
-   *
-   * @param requestId - The request id to produce a signed transaction for.
-   * @param expectedSigner - The EVM address (0x hex, any case) the genuine
-   *   response must be signed by — the requester's MPC-derived address.
-   * @returns The signed ethers transaction (`serialized` is the payload for
-   *   `eth_sendRawTransaction`), or `undefined` when no valid response has
-   *   been posted yet — poll again.
-   * @throws Error when either contract has no state, the request is not on the
-   *   requester's ledger, or the responses ledger is inconsistent.
-   */
-  async getSignedEVMTransaction(
-    requestId: RequestIdHex,
-    expectedSigner: string,
-  ): Promise<Transaction | undefined> {
-    const { verified } = await this.getVerifiedSignatureResponse(
-      requestId,
-      expectedSigner,
-    );
-    if (verified === undefined) {
-      return undefined;
-    }
-    // getSignatureRequest is cached — getVerifiedSignatureResponse already
-    // fetched it, so this is a free lookup, not a second query.
-    const request = await this.getSignatureRequest(requestId);
-    return signBidirectionalRequestToSignedEVMTransaction(request, verified);
-  }
-
-  /**
-   * Fetch the MPC's respond-bidirectional attestation for `requestId`,
-   * if posted. The signet contract verified it IN-CIRCUIT at post time
-   * (Schnorr over `(requestId, hash(serializedOutput, outputLen))` against
-   * the sealed MPC key), so it is single-slot and needs no off-chain
-   * verification or verdicts — `undefined` simply means not posted yet, poll
-   * again.
-   *
-   * @param requestId - The request id whose attestation to fetch.
-   * @returns The attestation record, or `undefined` when none is posted.
-   * @throws Error when the signet contract has no state on-chain.
-   */
-  async getRespondBidirectional(
-    requestId: RequestIdHex,
-  ): Promise<RespondBidirectional | undefined> {
-    const raw = await this.queryRawState(
-      this.config.signetContractAddress,
-      "signet contract",
-    );
-    return readSignetContractLedgerFromState(raw).respondBidirectionalIndex.get(
-      requestId,
-    );
-  }
-}