@sig-net/midnight 0.0.1

package/dist/signet-requests.js

@@ -0,0 +1,497 @@
+// TypeScript twins of the request-side structs in the Compact library
+// `Signet.compact` (same directory). The shapes MUST stay in lockstep with the Compact structs: the
+// compiler inlines struct types anonymously into each contract's generated
+// managed/contract/index.d.ts, and these named types match them structurally,
+// so ledger reads assign to them without casts.
+//
+// The lockstep is enforced by each consuming contract's simulator tests: the
+// "erc20-vault ledger shape" test in packages/vault-contract/tests/
+// contract.test.ts assigns the generated `ledger().signetRequestsIndex` to the
+// named SignBidirectionalRequestLedgerIndex type — the assignment itself is
+// the assertion, so any structural drift between the generated managed types
+// and these twins fails that package's `yarn build` / `yarn test`.
+//
+// Read more: https://docs.sig.network/ (signet protocol) and the module
+// header in Signet.compact (layout convention, path binding).
+import { CompactTypeBoolean, CompactTypeBytes, CompactTypeEnum, CompactTypeUnsignedInteger, CompactTypeVector, persistentHash, } from "@midnight-ntwrk/compact-runtime";
+import { getAddress, getBytes, Signature, Transaction } from "ethers";
+import { asciiPadded } from "./constants.js";
+import { bigintToBytes32, bytesToBigint } from "./schnorr.js";
+/**
+ * Which transaction-param decomposition a request carries (Compact:
+ * `enum TxParamType`), as the generated code represents enums: a `number`
+ * holding the 0-based variant index. Exported as a `const` object (not a TS
+ * `enum`) so the values stay structurally `number`.
+ */
+export const TxParamType = {
+    /** {@link EVMType2TxParams}: an EIP-1559 EVM transaction. */
+    evmType2: 0,
+    /**
+     * Never emitted — mirrors the Compact-side padding variant that keeps the
+     * enum at >= 2 variants (a 1-variant enum is a zero-byte value the proof
+     * server cannot parse inside persistentHash preimages).
+     */
+    reserved: 1,
+};
+// ---- Request id (TS twin of the Compact circuit) ---------------------------
+//
+// DEVIATION from the "pure circuits are compiled, never re-written in TS"
+// rule (see circuits.compact): `calculateRequestId` is generic over the
+// tx-params type, the Compact compiler cannot export type-parameterized
+// circuits from the top level, and a compiled copy would have to be
+// monomorphized at ONE capacity instantiation — a client contract's choice
+// that never belongs in this client-agnostic package. So the request-id
+// circuit alone gets a TS twin here.
+//
+// It is NOT a hand-port of the hash algorithm: it calls the very
+// `persistentHash` runtime builtin that compiled circuits call, over runtime
+// type descriptors mirroring the ones the compiler generates (compare
+// `_calculateRequestId_0` in any consuming contract's
+// managed/contract/index.js). What must stay in lockstep with Signet.compact
+// is exactly what this file already keeps in lockstep — the struct shapes,
+// field by field, in declaration order. Enforced by vault-contract's
+// "deposit round-trip" test, which asserts the id computed here equals the
+// ledger map key minted by the REAL compiled contract.
+// Runtime descriptors of the Compact base types the request record uses.
+// CompactTypeUnsignedInteger takes (maxValue, byte length) — same literals
+// the compiler emits for Uint<8/32/64/128>. CompactTypeEnum takes
+// (variantCount - 1, byte length); NOTE a 1-variant enum would compile to
+// `CompactTypeEnum(0, 0)` — zero bytes, which the proof server cannot parse
+// inside persistentHash preimages. TxParamType therefore carries a padding
+// `reserved` variant so it stays at (1, 1).
+const BYTES_4 = new CompactTypeBytes(4);
+const BYTES_20 = new CompactTypeBytes(20);
+const BYTES_32 = new CompactTypeBytes(32);
+const BYTES_64 = new CompactTypeBytes(64);
+const BYTES_128 = new CompactTypeBytes(128);
+const BYTES_256 = new CompactTypeBytes(256);
+const UINT_8 = new CompactTypeUnsignedInteger(2n ** 8n - 1n, 1);
+const UINT_16 = new CompactTypeUnsignedInteger(2n ** 16n - 1n, 2);
+const UINT_32 = new CompactTypeUnsignedInteger(2n ** 32n - 1n, 4);
+const UINT_64 = new CompactTypeUnsignedInteger(2n ** 64n - 1n, 8);
+const UINT_128 = new CompactTypeUnsignedInteger(2n ** 128n - 1n, 16);
+const TX_PARAM_TYPE = new CompactTypeEnum(1, 1);
+/**
+ * Build the runtime descriptor of a Compact struct from its per-field
+ * descriptors — the generic form of the struct descriptor classes the
+ * compiler generates (field-by-field concatenation of alignments and values).
+ *
+ * Field ORDER must match the Compact struct declaration order; object
+ * literals preserve insertion order for string keys, so pass fields in
+ * declaration order.
+ *
+ * @param fields - One runtime descriptor per struct field, in declaration order.
+ * @returns The composed struct descriptor.
+ */
+function compactStructDescriptor(fields) {
+    const entries = Object.entries(fields);
+    return {
+        alignment: () => entries.flatMap(([, type]) => type.alignment()),
+        toValue: (value) => entries.flatMap(([key, type]) => type.toValue(value[key])),
+        fromValue: (value) => {
+            const result = {};
+            for (const [key, type] of entries) {
+                result[key] = type.fromValue(value);
+            }
+            return result;
+        },
+    };
+}
+/**
+ * Descriptor of Compact's standard-library `Maybe<T>` — the compiler
+ * generates it as the struct `{ is_some: Boolean, value: T }`.
+ *
+ * @param inner - Descriptor of the wrapped type.
+ * @returns The Maybe struct descriptor.
+ */
+function compactMaybeDescriptor(inner) {
+    return compactStructDescriptor({
+        is_some: CompactTypeBoolean,
+        value: inner,
+    });
+}
+/**
+ * Descriptor of {@link EVMCalldata} at one word capacity — the TS analogue
+ * of instantiating Compact's `EVMCalldata<#maxWords>`.
+ *
+ * @param maxWords - The contract's calldata word capacity (the vault uses 2).
+ * @returns The calldata descriptor.
+ */
+export function evmCalldataDescriptor(maxWords) {
+    return compactStructDescriptor({
+        selector: BYTES_4,
+        noWords: UINT_16,
+        words: new CompactTypeVector(maxWords, BYTES_32),
+    });
+}
+/**
+ * Descriptor of {@link EVMAccessListEntry} at one storage-key capacity
+ * (Compact: `EVMAccessListEntry<#maxStorageKeys>`).
+ *
+ * @param maxStorageKeys - Storage-key capacity per entry.
+ * @returns The entry descriptor.
+ */
+export function evmAccessListEntryDescriptor(maxStorageKeys) {
+    return compactStructDescriptor({
+        address: BYTES_20,
+        storageKeyCount: UINT_8,
+        storageKeys: new CompactTypeVector(maxStorageKeys, BYTES_32),
+    });
+}
+/**
+ * Descriptor of {@link EVMType2TxParams} at one capacity instantiation —
+ * the TS analogue of Compact's `EVMType2TxParams<#maxCalldataWords,
+ * #maxAccessListEntries, #maxStorageKeysPerEntry>`.
+ *
+ * @param maxCalldataWords - Calldata word capacity.
+ * @param maxAccessListEntries - Access-list entry capacity.
+ * @param maxStorageKeysPerEntry - Storage-key capacity per entry.
+ * @returns The tx-params descriptor.
+ */
+export function evmType2TxParamsDescriptor(maxCalldataWords, maxAccessListEntries, maxStorageKeysPerEntry) {
+    return compactStructDescriptor({
+        to: BYTES_20,
+        chainId: UINT_64,
+        nonce: UINT_64,
+        gasLimit: UINT_64,
+        maxFeePerGas: UINT_128,
+        maxPriorityFeePerGas: UINT_128,
+        value: UINT_128,
+        accessListEntryCount: UINT_8,
+        accessList: new CompactTypeVector(maxAccessListEntries, evmAccessListEntryDescriptor(maxStorageKeysPerEntry)),
+        calldata: compactMaybeDescriptor(evmCalldataDescriptor(maxCalldataWords)),
+    });
+}
+/**
+ * Descriptor of {@link SignBidirectionalRequest} at one capacity instantiation.
+ *
+ * @param maxCalldataWords - Calldata word capacity.
+ * @param maxAccessListEntries - Access-list entry capacity.
+ * @param maxStorageKeysPerEntry - Storage-key capacity per entry.
+ * @returns The request record descriptor.
+ */
+export function signBidirectionalRequestDescriptor(maxCalldataWords, maxAccessListEntries, maxStorageKeysPerEntry) {
+    return compactStructDescriptor({
+        requestNonce: UINT_64,
+        txParamType: TX_PARAM_TYPE,
+        txParams: evmType2TxParamsDescriptor(maxCalldataWords, maxAccessListEntries, maxStorageKeysPerEntry),
+        caip2Id: BYTES_32,
+        keyVersion: UINT_32,
+        path: BYTES_256,
+        algo: BYTES_32,
+        dest: BYTES_32,
+        params: BYTES_64,
+        outputDeserializationSchema: BYTES_128,
+        respondSerializationSchema: BYTES_128,
+    });
+}
+/**
+ * Domain tag partitioning the {@link RequestId} space
+ * (Compact: `pad(32, "signet:midnight:request")`).
+ */
+const REQUEST_ID_DOMAIN_TAG = asciiPadded("signet:midnight:request", 32);
+/**
+ * Canonical id of a signet request: the domain-separated persistent hash of
+ * the entire request record. TS twin of Signet.compact's `calculateRequestId`
+ * circuit (see the deviation note atop this section), generic over the
+ * capacity instantiation via the record's own array lengths — pass the
+ * record exactly as the ledger stores it, unused slots included.
+ *
+ * @param request - The full request record (contract-shaped, all slots).
+ * @returns The 32-byte request id — the record's ledger map key.
+ */
+export function calculateRequestId(request) {
+    const { txParams } = request;
+    const maxCalldataWords = txParams.calldata.value.words.length;
+    const maxAccessListEntries = txParams.accessList.length;
+    const maxStorageKeysPerEntry = maxAccessListEntries === 0 ? 0 : txParams.accessList[0].storageKeys.length;
+    return persistentHash(new CompactTypeVector(2, BYTES_32), [
+        REQUEST_ID_DOMAIN_TAG,
+        persistentHash(signBidirectionalRequestDescriptor(maxCalldataWords, maxAccessListEntries, maxStorageKeysPerEntry), request),
+    ]);
+}
+// ---- Calldata / transaction assembly ----------------------------------------
+/**
+ * The 32-byte value of a numeric ABI word: the little-endian field embed of
+ * the number, exactly what Compact's `x as Field as Bytes<32>` cast produces
+ * in-circuit. Use when building words off-chain (UIs, expected-record
+ * builders, tests).
+ *
+ * @param value - The word's numeric value (e.g. an amount).
+ * @returns The 32-byte LE embed to store in an {@link EVMCalldata} word.
+ */
+export function numericAbiWordValue(value) {
+    return bigintToBytes32(value);
+}
+/**
+ * The 32-byte staticArg word value for an EVM address: the BIG-ENDIAN
+ * numeric reading of its 20 display-order bytes, LE-embedded. TS mirror of
+ * Signet.compact's `evmAddressAbiValue` circuit (+ `as Bytes<32>`); see the
+ * warning there — embedding the display-order bytes directly would come out
+ * byte-reversed in the assembled calldata.
+ *
+ * @param address - The 20-byte address in display order.
+ * @returns The 32-byte word value to store in an {@link EVMCalldata} word.
+ */
+export function evmAddressAbiWord(address) {
+    let value = 0n;
+    for (const byte of address) {
+        value = value * 256n + BigInt(byte);
+    }
+    return bigintToBytes32(value);
+}
+/**
+ * Re-assemble the raw calldata a request's words describe:
+ * `data = selector || BE(words[0..noWords])`. Each word is a little-endian
+ * field embed (the contract's `x as Field as Bytes<32>` cast); the leading
+ * `noWords` are re-encoded big-endian into 32-byte ABI words and any remaining
+ * capacity slots are dropped. This is THE implementation of the MPC re-assembly
+ * documented on `EVMCalldata` in Signet.compact.
+ *
+ * @param calldata - The request's calldata field.
+ * @returns Hex calldata for the transaction (`"0x"` when absent).
+ */
+export function assembleCalldata(calldata) {
+    if (!calldata.is_some) {
+        return "0x";
+    }
+    const { selector, noWords, words } = calldata.value;
+    let data = `0x${bytesToHex(selector)}`;
+    for (let i = 0; i < Number(noWords); i++) {
+        data += bytesToHex(bigintToBytes32BE(bytesToBigint(words[i])));
+    }
+    return data;
+}
+/**
+ * Decode the real (count-trimmed) access list of a request into the shape
+ * ethers' `Transaction.from` accepts.
+ *
+ * @param txParams - The request's transaction decomposition.
+ * @returns The access list, possibly empty.
+ */
+function decodeAccessList(txParams) {
+    return txParams.accessList
+        .slice(0, Number(txParams.accessListEntryCount))
+        .map((entry) => ({
+        address: getAddress(`0x${bytesToHex(entry.address)}`),
+        storageKeys: entry.storageKeys
+            .slice(0, Number(entry.storageKeyCount))
+            .map((key) => `0x${bytesToHex(key)}`),
+    }));
+}
+/**
+ * Rebuild the unsigned EIP-1559 transaction a request record describes,
+ * byte-identical to the one the MPC assembles and signs: calldata from the
+ * tagged words (see {@link assembleCalldata}), the count-trimmed access
+ * list, and the stored envelope fields. This is the canonical
+ * request→transaction transform; response-side verification
+ * (`signature-response-verification.ts`) and the signed-transaction builder
+ * below both go through it, so the transaction a client broadcasts is
+ * provably the one the MPC put its signature over.
+ *
+ * @param event - The on-ledger request record.
+ * @returns The unsigned ethers transaction (`unsignedHash` is the digest the
+ *   MPC signs).
+ * @throws Error if a calldata word carries an unknown kind.
+ */
+export function signBidirectionalRequestToUnsignedEVMTransaction(event) {
+    const { txParams } = event;
+    return Transaction.from({
+        type: 2,
+        chainId: txParams.chainId,
+        nonce: Number(txParams.nonce),
+        gasLimit: txParams.gasLimit,
+        maxFeePerGas: txParams.maxFeePerGas,
+        maxPriorityFeePerGas: txParams.maxPriorityFeePerGas,
+        to: getAddress(`0x${bytesToHex(txParams.to)}`),
+        value: txParams.value,
+        accessList: decodeAccessList(txParams),
+        data: assembleCalldata(txParams.calldata),
+    });
+}
+/**
+ * Decode a response signature record (as posted to the signet contract's
+ * signature response log — the canonical MPC `Signature { big_r, s,
+ * recovery_id }` shape) into an ethers {@link Signature}: `r` is `bigR`'s x
+ * coordinate, `v` the legacy parity derived from the recovery id.
+ *
+ * @param response - The posted signature record.
+ * @returns The ethers signature.
+ * @throws Error if the recovery id is not 0 or 1.
+ */
+export function signatureResponseToSignature(response) {
+    const recoveryId = Number(response.recoveryId);
+    if (recoveryId !== 0 && recoveryId !== 1) {
+        throw new Error(`expected a recovery id of 0 or 1, got ${recoveryId}`);
+    }
+    return Signature.from({
+        r: `0x${bytesToHex(response.bigRx)}`,
+        s: `0x${bytesToHex(response.s)}`,
+        v: recoveryId + 27,
+    });
+}
+/** secp256k1 base field prime (2^256 - 2^32 - 977). */
+const SECP256K1_P = 2n ** 256n - 2n ** 32n - 977n;
+/** Modular exponentiation by squaring. */
+function modPow(base, exponent, modulus) {
+    let result = 1n;
+    let b = base % modulus;
+    let e = exponent;
+    while (e > 0n) {
+        if (e & 1n)
+            result = (result * b) % modulus;
+        b = (b * b) % modulus;
+        e >>= 1n;
+    }
+    return result;
+}
+/** Encode a bigint as exactly 32 BIG-endian bytes (secp256k1 scalar form). */
+function bigintToBytes32BE(value) {
+    const out = new Uint8Array(32);
+    let v = value;
+    for (let i = 31; i >= 0; i--) {
+        out[i] = Number(v & 0xffn);
+        v >>= 8n;
+    }
+    return out;
+}
+/**
+ * Encode an ECDSA signature as the response record posted to the signet
+ * contract — the inverse of {@link signatureResponseToSignature},
+ * for MPC-side posters (the fakenet signer, tests). The canonical record
+ * carries `bigR` as a full affine point but an `r || s || v` signature only
+ * has R.x and the parity of R.y, so R.y is recovered by decompressing the
+ * point on the curve (y² = x³ + 7 over the secp256k1 base field).
+ *
+ * The parameter is structural (the r/s/yParity subset of an ethers
+ * {@link Signature}) so signatures from ANY ethers instance qualify — posters
+ * living in other repos resolve their own ethers install, and nominal class
+ * typing would reject it.
+ *
+ * @param signature - The signature to encode (`r`/`s` as 0x hex, `yParity` 0 or 1).
+ * @returns The response record, ready to post.
+ * @throws Error if `r` is not the x coordinate of a curve point.
+ */
+export function signatureToSignatureResponse(signature) {
+    const x = BigInt(signature.r);
+    const ySquared = (modPow(x, 3n, SECP256K1_P) + 7n) % SECP256K1_P;
+    // P ≡ 3 (mod 4), so a square root (when one exists) is c^((P+1)/4).
+    let y = modPow(ySquared, (SECP256K1_P + 1n) / 4n, SECP256K1_P);
+    if ((y * y) % SECP256K1_P !== ySquared) {
+        throw new Error("signature r is not the x coordinate of a secp256k1 point");
+    }
+    if ((y & 1n) !== BigInt(signature.yParity)) {
+        y = SECP256K1_P - y;
+    }
+    return {
+        bigRx: getBytes(signature.r),
+        bigRy: bigintToBytes32BE(y),
+        s: getBytes(signature.s),
+        recoveryId: BigInt(signature.yParity),
+    };
+}
+/**
+ * Assemble the broadcast-ready signed EIP-1559 transaction for a request from
+ * its MPC signature response: rebuild the exact unsigned transaction the MPC
+ * signed (see {@link signBidirectionalRequestToUnsignedEVMTransaction}) and
+ * attach the signature. Does NOT check that the signature recovers to the
+ * requester's derived address — the response log is unauthenticated, so
+ * verify first with `verifySignatureResponse`.
+ *
+ * @param event - The on-ledger request record.
+ * @param response - The posted signature record answering it.
+ * @returns The signed ethers transaction; `serialized` is the raw payload for
+ *   `eth_sendRawTransaction`, `hash` its on-chain hash, `from` the recovered
+ *   sender.
+ * @throws Error if the request record is malformed (see
+ *   {@link signBidirectionalRequestToUnsignedEVMTransaction}) or the response
+ *   is not a decodable signature.
+ */
+export function signBidirectionalRequestToSignedEVMTransaction(event, response) {
+    const transaction = signBidirectionalRequestToUnsignedEVMTransaction(event);
+    transaction.signature = signatureResponseToSignature(response);
+    return transaction;
+}
+/**
+ * Render bytes as a lowercase hex string, no `0x` prefix.
+ *
+ * @param bytes - The bytes to render.
+ * @returns Lowercase hex, two chars per byte.
+ */
+export function bytesToHex(bytes) {
+    return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+/**
+ * Render a request id in its canonical TS form (see
+ * {@link RequestIdHex}) — also usable as a JS `Map` key, which raw
+ * `Uint8Array` ids are not (they compare by reference).
+ *
+ * @param requestId - 32-byte request id.
+ * @returns The branded 64-char lowercase hex string, no `0x` prefix.
+ */
+export function requestIdHex(requestId) {
+    return bytesToHex(requestId);
+}
+/**
+ * Validate and normalize an untrusted string (CLI argument, config value)
+ * into a {@link RequestIdHex}: an optional `0x` prefix is stripped and
+ * the digits lowercased before validation.
+ *
+ * @param value - The candidate request id string.
+ * @returns The branded, normalized request id hex.
+ * @throws Error if the value is not 64 hex chars after normalization.
+ */
+export function parseRequestIdHex(value) {
+    const hex = value.replace(/^0x/i, "").toLowerCase();
+    if (!/^[0-9a-f]{64}$/.test(hex)) {
+        throw new Error(`not a 32-byte request id in hex: "${value}"`);
+    }
+    return hex;
+}
+/**
+ * Decode a request id back to its 32 raw bytes for the Compact boundary
+ * (compiled-circuit calls, ledger lookups).
+ *
+ * @param id - The request id in canonical hex form.
+ * @returns The 32-byte request id.
+ */
+export function requestIdBytes(id) {
+    const bytes = new Uint8Array(32);
+    for (let i = 0; i < 32; i++) {
+        bytes[i] = Number.parseInt(id.slice(2 * i, 2 * i + 2), 16);
+    }
+    return bytes;
+}
+/** Byte width of the path field (Compact `Bytes<256>`). */
+export const PATH_BYTES = 256;
+/**
+ * Build the canonical MPC derivation path for an identity commitment: the
+ * lowercase hex of the commitment as ASCII, zero-padded to {@link PATH_BYTES}
+ * — exactly what the contract's `assertPathCommitment` accepts. Use this to
+ * populate {@link SignBidirectionalRequest.path} when constructing requests.
+ *
+ * @param commitment - 32-byte identity commitment.
+ * @returns The 256-byte path field value.
+ */
+export function signetPathOfCommitment(commitment) {
+    const path = new Uint8Array(PATH_BYTES);
+    path.set(new TextEncoder().encode(bytesToHex(commitment)));
+    return path;
+}
+/**
+ * Parse the on-ledger request map into a plain-JS index keyed by hex
+ * request id.
+ *
+ * @param ledgerIndex - Iterable of `[requestId, request]` entries — e.g. a
+ *   contract's `ledger(state).signetRequestsIndex` (any
+ *   {@link SignBidirectionalRequestLedgerIndex}).
+ * @returns A new `Map` from {@link requestIdHex} key to request record.
+ */
+export function toSignBidirectionalRequestIndex(ledgerIndex) {
+    const index = new Map();
+    for (const [requestId, request] of ledgerIndex) {
+        index.set(requestIdHex(requestId), request);
+    }
+    return index;
+}
+//# sourceMappingURL=signet-requests.js.map

package/dist/signet-requests.js.map

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

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

@@ -0,0 +1,161 @@
+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