@sig-net/midnight 0.0.1

package/dist/schnorr.d.ts

@@ -0,0 +1,100 @@
+import { type JubjubPoint } from "@midnight-ntwrk/compact-runtime";
+export type { JubjubPoint } from "@midnight-ntwrk/compact-runtime";
+/** Jubjub curve scalar field order (group order of the generator). */
+export declare const JUBJUB_ORDER = 6554484396890773809930967563523245729705921265872317281365359162392183254199n;
+/** BLS12-381 scalar field order (the Compact `Field` type modulus). */
+export declare const BLS_ORDER = 52435875175126190479447740508185965837690552500527637822603658699938581184513n;
+/**
+ * Convert little-endian bytes to a bigint. Matches Compact's
+ * `Bytes<32> as Field` interpretation (and the MPC monitor's ABI-word
+ * decoding convention).
+ *
+ * @param bytes - Little-endian byte array.
+ * @returns The decoded non-negative integer.
+ */
+export declare function bytesToBigint(bytes: Uint8Array): bigint;
+/**
+ * Convert a bigint to exactly 32 little-endian bytes. Matches Compact's
+ * `Field as Bytes<32>` encoding (the inverse of {@link bytesToBigint});
+ * negative inputs are interpreted in the BLS scalar field.
+ *
+ * @param n - The integer to encode.
+ * @returns The 32-byte little-endian encoding.
+ */
+export declare function bigintToBytes32(n: bigint): Uint8Array;
+/** A Jubjub keypair: the secret scalar and its public curve point. */
+export interface JubjubKeypair {
+    /** Secret scalar in `[1, JUBJUB_ORDER - 1]`. */
+    sk: bigint;
+    /** Public key: `sk * G` on Jubjub. */
+    pk: JubjubPoint;
+}
+/**
+ * Derive a Jubjub keypair from a seed — the same derivation the MPC server
+ * performs on its root key, so this MUST stay bit-identical to it:
+ * `sk = (persistentHash([pad32("jubjub:auth:"), seed]) mod (order - 1)) + 1`,
+ * `pk = sk * G`.
+ *
+ * @param seed - Seed bytes (e.g. the 32-byte MPC root key).
+ * @returns The derived {@link JubjubKeypair}.
+ */
+export declare function deriveJubjubKeypair(seed: Uint8Array): JubjubKeypair;
+/**
+ * A Schnorr signature (TS twin of CompactStandardLibrary's
+ * `JubjubSchnorrSignature`).
+ */
+export interface SchnorrSignature {
+    /** Nonce commitment R = k * G. */
+    announcement: JubjubPoint;
+    /** Signature scalar s = (k + c * sk) mod JUBJUB_ORDER. */
+    response: bigint;
+}
+/**
+ * Computes the Schnorr challenge (the Poseidon transientHash output reduced
+ * into Jubjub's scalar field, exactly as `jubjubSchnorrVerify` computes it).
+ * ALWAYS inject the compiled circuit — signet-midnight's own
+ * `pureCircuits.schnorrChallenge` — never a TS re-implementation; keeping it
+ * injected keeps this signer decoupled from any one compiled artifact.
+ */
+export type SchnorrChallengeFn = (annX: bigint, annY: bigint, pkX: bigint, pkY: bigint, msg: bigint[]) => bigint;
+/**
+ * Sign a message with Schnorr on Jubjub, matching CompactStandardLibrary's
+ * `jubjubSchnorrVerify`: `c = challenge` (already reduced into Jubjub's
+ * scalar field by the compiled circuit), `s = (k + c * sk) mod JUBJUB_ORDER`.
+ * For signet attestations the message is the compiled
+ * `pureCircuits.signetAttestationMessage(requestId, outputData)`.
+ *
+ * @param sk - Jubjub private key scalar.
+ * @param msg - Message field limbs.
+ * @param schnorrChallenge - The compiled `pureCircuits.schnorrChallenge`.
+ * @returns The signature (announcement R, response s).
+ * @throws Error if `sk` reduces to zero mod the Jubjub order.
+ */
+export declare function schnorrSign(sk: bigint, msg: bigint[], schnorrChallenge: SchnorrChallengeFn): SchnorrSignature;
+/**
+ * Hash a Jubjub point exactly as the circuits do (`persistentHash<JubjubPoint>`)
+ * — the form the signet contract seals as `mpcPubKeyHash`.
+ *
+ * @param point - The point to hash.
+ * @returns The 32-byte hash.
+ */
+export declare function hashJubjubPoint(point: JubjubPoint): Uint8Array;
+/**
+ * Parse a Jubjub public key from its `"x,y"` config/env form (decimal or
+ * 0x-hex field coordinates) — how deploys receive `MPC_JUBJUB_PK`.
+ *
+ * @param value - The `"x,y"` string.
+ * @returns The parsed point.
+ * @throws Error if the value is not two comma-separated field coordinates.
+ */
+export declare function parseJubjubPublicKey(value: string): JubjubPoint;
+/**
+ * Format a Jubjub public key as the `"x,y"` decimal config/env form that
+ * {@link parseJubjubPublicKey} accepts — the round-trip inverse, for handing
+ * a derived key to deploys as `MPC_JUBJUB_PK`.
+ *
+ * @param point - The point to format.
+ * @returns The `"x,y"` string with decimal coordinates.
+ */
+export declare function formatJubjubPublicKey(point: JubjubPoint): string;
+//# sourceMappingURL=schnorr.d.ts.map

package/dist/schnorr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schnorr.d.ts","sourceRoot":"","sources":["../src/schnorr.ts"],"names":[],"mappings":"AAiBA,OAAO,EAML,KAAK,WAAW,EACjB,MAAM,iCAAiC,CAAC;AAKzC,YAAY,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAEnE,sEAAsE;AACtE,eAAO,MAAM,YAAY,gFAAgF,CAAC;AAE1G,uEAAuE;AACvE,eAAO,MAAM,SAAS,iFAAiF,CAAC;AAKxG;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAMvD;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,CAQrD;AAED,sEAAsE;AACtE,MAAM,WAAW,aAAa;IAC5B,gDAAgD;IAChD,EAAE,EAAE,MAAM,CAAC;IACX,sCAAsC;IACtC,EAAE,EAAE,WAAW,CAAC;CACjB;AASD;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,aAAa,CAKnE;AAID;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,kCAAkC;IAClC,YAAY,EAAE,WAAW,CAAC;IAC1B,0DAA0D;IAC1D,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAC/B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EAAE,KACV,MAAM,CAAC;AAEZ;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CACzB,EAAE,EAAE,MAAM,EACV,GAAG,EAAE,MAAM,EAAE,EACb,gBAAgB,EAAE,kBAAkB,GACnC,gBAAgB,CAgBlB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,GAAG,UAAU,CAE9D;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAU/D;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAEhE"}

package/dist/schnorr.js

@@ -0,0 +1,144 @@
+// Jubjub Schnorr helpers — the TS side of the shared Schnorr.compact module:
+// key derivation, SIGNING (which needs the secret scalar, so it cannot be a
+// circuit), and key parsing/hashing. Everything provable stays in Compact:
+// the challenge is the COMPILED `pureCircuits.schnorrChallenge`, injected by
+// callers (see SchnorrChallengeFn), and the attestation message is the
+// compiled `pureCircuits.signetAttestationMessage` — this file never
+// re-implements either. Verification lives in circuits only
+// (CompactStandardLibrary's jubjubSchnorrVerify, run by the signet contract
+// at post time).
+//
+// This belongs in github.com/sig-net/signet.js as its Midnight adapter —
+// kept here until upstreamed. The math is Midnight-specific (Jubjub embedded
+// in BLS12-381 via @midnight-ntwrk/compact-runtime EC ops), which is exactly
+// why signet.js does not cover it today.
+import { randomBytes } from "node:crypto";
+import { CompactTypeBytes, CompactTypeJubjubPoint, CompactTypeVector, ecMulGenerator, persistentHash, } from "@midnight-ntwrk/compact-runtime";
+/** Jubjub curve scalar field order (group order of the generator). */
+export const JUBJUB_ORDER = 6554484396890773809930967563523245729705921265872317281365359162392183254199n;
+/** BLS12-381 scalar field order (the Compact `Field` type modulus). */
+export const BLS_ORDER = 52435875175126190479447740508185965837690552500527637822603658699938581184513n;
+const bytes32Type = new CompactTypeBytes(32);
+const vec2x32Type = new CompactTypeVector(2, bytes32Type);
+/**
+ * Convert little-endian bytes to a bigint. Matches Compact's
+ * `Bytes<32> as Field` interpretation (and the MPC monitor's ABI-word
+ * decoding convention).
+ *
+ * @param bytes - Little-endian byte array.
+ * @returns The decoded non-negative integer.
+ */
+export function bytesToBigint(bytes) {
+    let result = 0n;
+    for (let i = bytes.length - 1; i >= 0; i--) {
+        result = (result << 8n) | BigInt(bytes[i]);
+    }
+    return result;
+}
+/**
+ * Convert a bigint to exactly 32 little-endian bytes. Matches Compact's
+ * `Field as Bytes<32>` encoding (the inverse of {@link bytesToBigint});
+ * negative inputs are interpreted in the BLS scalar field.
+ *
+ * @param n - The integer to encode.
+ * @returns The 32-byte little-endian encoding.
+ */
+export function bigintToBytes32(n) {
+    const buf = new Uint8Array(32);
+    let v = n < 0n ? n + BLS_ORDER : n;
+    for (let i = 0; i < 32; i++) {
+        buf[i] = Number(v & 0xffn);
+        v >>= 8n;
+    }
+    return buf;
+}
+/** Zero-pad an ASCII domain tag to 32 bytes (Compact `pad(32, ...)`). */
+function pad32(tag) {
+    const padded = new Uint8Array(32);
+    new TextEncoder().encodeInto(tag, padded);
+    return padded;
+}
+/**
+ * Derive a Jubjub keypair from a seed — the same derivation the MPC server
+ * performs on its root key, so this MUST stay bit-identical to it:
+ * `sk = (persistentHash([pad32("jubjub:auth:"), seed]) mod (order - 1)) + 1`,
+ * `pk = sk * G`.
+ *
+ * @param seed - Seed bytes (e.g. the 32-byte MPC root key).
+ * @returns The derived {@link JubjubKeypair}.
+ */
+export function deriveJubjubKeypair(seed) {
+    const skBytes = persistentHash(vec2x32Type, [pad32("jubjub:auth:"), seed]);
+    const sk = (bytesToBigint(skBytes) % (JUBJUB_ORDER - 1n)) + 1n;
+    const pk = ecMulGenerator(sk);
+    return { sk, pk };
+}
+/**
+ * Sign a message with Schnorr on Jubjub, matching CompactStandardLibrary's
+ * `jubjubSchnorrVerify`: `c = challenge` (already reduced into Jubjub's
+ * scalar field by the compiled circuit), `s = (k + c * sk) mod JUBJUB_ORDER`.
+ * For signet attestations the message is the compiled
+ * `pureCircuits.signetAttestationMessage(requestId, outputData)`.
+ *
+ * @param sk - Jubjub private key scalar.
+ * @param msg - Message field limbs.
+ * @param schnorrChallenge - The compiled `pureCircuits.schnorrChallenge`.
+ * @returns The signature (announcement R, response s).
+ * @throws Error if `sk` reduces to zero mod the Jubjub order.
+ */
+export function schnorrSign(sk, msg, schnorrChallenge) {
+    const skReduced = ((sk % JUBJUB_ORDER) + JUBJUB_ORDER) % JUBJUB_ORDER;
+    if (skReduced === 0n) {
+        throw new Error("Private key must be non-zero mod JUBJUB_ORDER");
+    }
+    const pk = ecMulGenerator(skReduced);
+    const k = (bytesToBigint(randomBytes(32)) % JUBJUB_ORDER) || 1n;
+    const announcement = ecMulGenerator(k);
+    // schnorrChallenge returns the challenge already reduced into Jubjub's
+    // scalar field — use it as-is.
+    const c = schnorrChallenge(announcement.x, announcement.y, pk.x, pk.y, msg);
+    const response = (((k + c * skReduced) % JUBJUB_ORDER) + JUBJUB_ORDER) % JUBJUB_ORDER;
+    return { announcement, response };
+}
+/**
+ * Hash a Jubjub point exactly as the circuits do (`persistentHash<JubjubPoint>`)
+ * — the form the signet contract seals as `mpcPubKeyHash`.
+ *
+ * @param point - The point to hash.
+ * @returns The 32-byte hash.
+ */
+export function hashJubjubPoint(point) {
+    return persistentHash(CompactTypeJubjubPoint, point);
+}
+/**
+ * Parse a Jubjub public key from its `"x,y"` config/env form (decimal or
+ * 0x-hex field coordinates) — how deploys receive `MPC_JUBJUB_PK`.
+ *
+ * @param value - The `"x,y"` string.
+ * @returns The parsed point.
+ * @throws Error if the value is not two comma-separated field coordinates.
+ */
+export function parseJubjubPublicKey(value) {
+    const parts = value.split(",").map((part) => part.trim());
+    if (parts.length !== 2 || parts.some((part) => part === "")) {
+        throw new Error(`expected a Jubjub public key as "x,y"; got "${value}"`);
+    }
+    try {
+        return { x: BigInt(parts[0]), y: BigInt(parts[1]) };
+    }
+    catch {
+        throw new Error(`Jubjub public key coordinates must be decimal or 0x-hex integers; got "${value}"`);
+    }
+}
+/**
+ * Format a Jubjub public key as the `"x,y"` decimal config/env form that
+ * {@link parseJubjubPublicKey} accepts — the round-trip inverse, for handing
+ * a derived key to deploys as `MPC_JUBJUB_PK`.
+ *
+ * @param point - The point to format.
+ * @returns The `"x,y"` string with decimal coordinates.
+ */
+export function formatJubjubPublicKey(point) {
+    return `${point.x},${point.y}`;
+}
+//# sourceMappingURL=schnorr.js.map

package/dist/schnorr.js.map

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

package/dist/signature-requests-state-reader.d.ts

@@ -0,0 +1,74 @@
+import { type RequestIdHex, type SignBidirectionalRequest, type SignBidirectionalRequestIndex } from "./signet-requests.ts";
+import { type RawContractState } from "./signature-state-reading.ts";
+/** Signet layout convention: the request index is ledger field 0. */
+export declare const SIGNET_REQUESTS_INDEX_FIELD = 0;
+/** Signet layout convention: the request counter (`SignetNonce`) is ledger field 1. */
+export declare const SIGNET_NONCE_FIELD = 1;
+/**
+ * Aligned-value entry count of a request record EXCLUDING the capacity-scaled
+ * vectors: requestNonce (1) + txParamType (1, enums are one atom whatever
+ * their byte width) + the EVMType2TxParams fixed fields (to..value = 7,
+ * accessListEntryCount = 1) + the calldata Maybe's is_some (1), selector (1)
+ * and noWords (1) + the routing fields caip2Id..respondSerializationSchema (8).
+ * A stored request cell therefore holds
+ *   `REQUEST_FIXED_VALUE_ATOMS + maxCalldataWords
+ *      + maxAccessListEntries·(2 + maxStorageKeysPerEntry)`
+ * entries (each calldata word is one Bytes<32> atom; each access-list entry is
+ * address + storageKeyCount + its keys).
+ */
+export declare const REQUEST_FIXED_VALUE_ATOMS = 21;
+/**
+ * The decoded signet ledger fields of a conforming contract — the complete
+ * view the MPC needs: the request index (field 0) and the request counter
+ * (field 1, Compact `SignetNonce`), whose value doubles as a cheap
+ * change-detection signal (unchanged nonce ⇒ no new requests).
+ */
+export interface SignetRequestsLedger {
+    /** The request counter (ledger field {@link SIGNET_NONCE_FIELD}). */
+    nonce: bigint;
+    /**
+     * The request index (ledger field {@link SIGNET_REQUESTS_INDEX_FIELD}),
+     * keyed by hex request id.
+     */
+    requestsIndex: SignBidirectionalRequestIndex;
+}
+/**
+ * MPC-style read: parse the signet ledger fields out of raw contract state
+ * by field position alone — no compiled contract, no generated `ledger()`,
+ * only the signet layout convention and the canonical descriptors from
+ * signet-requests.ts.
+ *
+ * @param raw - Raw contract state, e.g. `queryContractState(address).data`
+ *   from the indexer or `ctx.currentQueryContext.state` from the simulator.
+ * @returns The decoded {@link SignetRequestsLedger}.
+ * @throws Error if a field is missing, has the wrong state-value shape, or a
+ *   record matches no capacity split.
+ */
+export declare function readSignetRequestsLedgerFromState(raw: RawContractState): SignetRequestsLedger;
+/**
+ * Look up ONE request by id in a contract's request index at an arbitrary
+ * ledger field — the generalization of {@link readSignetRequestsLedgerFromState}
+ * the event path needs: a `SignBidirectionalEvent` names both the requester
+ * contract AND which field holds its index, so the field is no longer assumed
+ * to be {@link SIGNET_REQUESTS_INDEX_FIELD}.
+ *
+ * This is the mandatory membership check of the event flow (see
+ * signet-request-resolver.ts): `undefined` means the id is NOT a member of the
+ * index at `fieldIndex` — the notification is forged, stale, points at the
+ * wrong field, or the request is not yet indexed — and the caller MUST drop it.
+ * Every non-membership case (field out of range, field is not a Map, id absent,
+ * a cell that fails to decode) returns `undefined` rather than throwing, so a
+ * malformed or adversarial event can never crash the reader.
+ *
+ * Only the matched record is decoded (not the whole index), and it is decoded
+ * by the same {@link decodeSignBidirectionalRequest} the full reader uses, so
+ * the result is `toEqual` to `readSignetRequestsLedgerFromState(raw)
+ * .requestsIndex.get(requestId)` when `fieldIndex` is the index field.
+ *
+ * @param raw - Raw contract state, e.g. `queryContractState(address).data`.
+ * @param fieldIndex - Ledger field position of the request index in `raw`.
+ * @param requestId - The request id to look up.
+ * @returns The stored request record, or `undefined` when it is not a member.
+ */
+export declare function lookupSignetRequestAt(raw: RawContractState, fieldIndex: number, requestId: RequestIdHex): SignBidirectionalRequest | undefined;
+//# sourceMappingURL=signature-requests-state-reader.d.ts.map

package/dist/signature-requests-state-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature-requests-state-reader.d.ts","sourceRoot":"","sources":["../src/signature-requests-state-reader.ts"],"names":[],"mappings":"AAaA,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,wBAAwB,EAC7B,KAAK,6BAA6B,EACnC,MAAM,sBAAsB,CAAC;AAK9B,OAAO,EAIL,KAAK,gBAAgB,EACtB,MAAM,8BAA8B,CAAC;AAEtC,qEAAqE;AACrE,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAE7C,uFAAuF;AACvF,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAEpC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,yBAAyB,KAAK,CAAC;AA+D5C;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC,qEAAqE;IACrE,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,aAAa,EAAE,6BAA6B,CAAC;CAC9C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iCAAiC,CAAC,GAAG,EAAE,gBAAgB,GAAG,oBAAoB,CAwB7F;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,gBAAgB,EACrB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,YAAY,GACtB,wBAAwB,GAAG,SAAS,CA2BtC"}

package/dist/signature-requests-state-reader.js

@@ -0,0 +1,167 @@
+// MPC-style raw state reader for the signature-REQUESTS side: decode the signet
+// request ledger fields out of a contract's raw state WITHOUT the compiled
+// contract. This is how the MPC monitor consumes signet contracts — it has only
+// a contract address, queries raw state from the indexer
+// (queryContractState(address).data), and decodes by the signet layout
+// convention: the request index is ledger field 0, the request counter field 1.
+// The compiled contract's generated ledger() does exactly this walk internally;
+// the record descriptors themselves are the parameterized twins in
+// signet-requests.ts. The generic tree walk and shared base descriptors live
+// in signature-state-reading.ts.
+import { requestIdHex, signBidirectionalRequestDescriptor, } from "./signet-requests.js";
+import { requestIdType, signetFieldNode, u64, } from "./signature-state-reading.js";
+/** Signet layout convention: the request index is ledger field 0. */
+export const SIGNET_REQUESTS_INDEX_FIELD = 0;
+/** Signet layout convention: the request counter (`SignetNonce`) is ledger field 1. */
+export const SIGNET_NONCE_FIELD = 1;
+/**
+ * Aligned-value entry count of a request record EXCLUDING the capacity-scaled
+ * vectors: requestNonce (1) + txParamType (1, enums are one atom whatever
+ * their byte width) + the EVMType2TxParams fixed fields (to..value = 7,
+ * accessListEntryCount = 1) + the calldata Maybe's is_some (1), selector (1)
+ * and noWords (1) + the routing fields caip2Id..respondSerializationSchema (8).
+ * A stored request cell therefore holds
+ *   `REQUEST_FIXED_VALUE_ATOMS + maxCalldataWords
+ *      + maxAccessListEntries·(2 + maxStorageKeysPerEntry)`
+ * entries (each calldata word is one Bytes<32> atom; each access-list entry is
+ * address + storageKeyCount + its keys).
+ */
+export const REQUEST_FIXED_VALUE_ATOMS = 21;
+/**
+ * Recover a record's capacity instantiation (maxCalldataWords,
+ * maxAccessListEntries, maxStorageKeysPerEntry) from its aligned-value atom
+ * count and decode it. Unlike the old single-vector layout, one atom count no
+ * longer determines the capacities uniquely, so candidates are enumerated —
+ * access-list-free first (today's only producer, the vault, is <2, 0, 0>) —
+ * and validated by the decode itself: the descriptors' Bytes length checks
+ * and the enum range check reject wrong splits, and a decode that leaves
+ * atoms unconsumed is rejected here.
+ *
+ * @param atoms - The record cell's aligned value (a fresh copy per attempt).
+ * @returns The decoded record.
+ * @throws Error if no capacity split decodes the value cleanly.
+ */
+function decodeSignBidirectionalRequest(atoms) {
+    const variable = atoms.length - REQUEST_FIXED_VALUE_ATOMS;
+    if (variable < 0) {
+        throw new Error(`request record has ${atoms.length} value entries — fewer than the ` +
+            `${REQUEST_FIXED_VALUE_ATOMS} its fixed fields need`);
+    }
+    const attempt = (maxWords, maxEntries, maxKeys) => {
+        const cursor = [...atoms];
+        try {
+            const record = signBidirectionalRequestDescriptor(maxWords, maxEntries, maxKeys).fromValue(cursor);
+            // A clean decode consumes the record exactly.
+            return cursor.length === 0 ? record : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    // No access list: variable atoms are calldata words alone (one atom each).
+    {
+        const record = attempt(variable, 0, 0);
+        if (record !== undefined)
+            return record;
+    }
+    // With an access list: E entries of (2 + K) atoms, the rest words.
+    for (let entries = 1; entries * 2 <= variable; entries++) {
+        for (let keys = 0; entries * (2 + keys) <= variable; keys++) {
+            const words = variable - entries * (2 + keys);
+            const record = attempt(words, entries, keys);
+            if (record !== undefined)
+                return record;
+        }
+    }
+    throw new Error(`request record with ${atoms.length} value entries matches no ` +
+        `(calldata words, access-list entries, storage keys) capacity split`);
+}
+/**
+ * MPC-style read: parse the signet ledger fields out of raw contract state
+ * by field position alone — no compiled contract, no generated `ledger()`,
+ * only the signet layout convention and the canonical descriptors from
+ * signet-requests.ts.
+ *
+ * @param raw - Raw contract state, e.g. `queryContractState(address).data`
+ *   from the indexer or `ctx.currentQueryContext.state` from the simulator.
+ * @returns The decoded {@link SignetRequestsLedger}.
+ * @throws Error if a field is missing, has the wrong state-value shape, or a
+ *   record matches no capacity split.
+ */
+export function readSignetRequestsLedgerFromState(raw) {
+    const map = signetFieldNode(raw, SIGNET_REQUESTS_INDEX_FIELD).asMap();
+    if (map === undefined) {
+        throw new Error(`Ledger field ${SIGNET_REQUESTS_INDEX_FIELD} is not a Map`);
+    }
+    const requestsIndex = new Map();
+    for (const key of map.keys()) {
+        // fromValue consumes its input, so hand each descriptor a copy.
+        const requestId = requestIdType.fromValue([...key.value]);
+        const cell = map.get(key)?.asCell();
+        if (cell === undefined)
+            continue;
+        requestsIndex.set(requestIdHex(requestId), decodeSignBidirectionalRequest(cell.value));
+    }
+    const nonceCell = signetFieldNode(raw, SIGNET_NONCE_FIELD).asCell();
+    if (nonceCell === undefined) {
+        throw new Error(`Ledger field ${SIGNET_NONCE_FIELD} is not a Cell`);
+    }
+    const nonce = u64.fromValue([...nonceCell.value]);
+    return { nonce, requestsIndex };
+}
+/**
+ * Look up ONE request by id in a contract's request index at an arbitrary
+ * ledger field — the generalization of {@link readSignetRequestsLedgerFromState}
+ * the event path needs: a `SignBidirectionalEvent` names both the requester
+ * contract AND which field holds its index, so the field is no longer assumed
+ * to be {@link SIGNET_REQUESTS_INDEX_FIELD}.
+ *
+ * This is the mandatory membership check of the event flow (see
+ * signet-request-resolver.ts): `undefined` means the id is NOT a member of the
+ * index at `fieldIndex` — the notification is forged, stale, points at the
+ * wrong field, or the request is not yet indexed — and the caller MUST drop it.
+ * Every non-membership case (field out of range, field is not a Map, id absent,
+ * a cell that fails to decode) returns `undefined` rather than throwing, so a
+ * malformed or adversarial event can never crash the reader.
+ *
+ * Only the matched record is decoded (not the whole index), and it is decoded
+ * by the same {@link decodeSignBidirectionalRequest} the full reader uses, so
+ * the result is `toEqual` to `readSignetRequestsLedgerFromState(raw)
+ * .requestsIndex.get(requestId)` when `fieldIndex` is the index field.
+ *
+ * @param raw - Raw contract state, e.g. `queryContractState(address).data`.
+ * @param fieldIndex - Ledger field position of the request index in `raw`.
+ * @param requestId - The request id to look up.
+ * @returns The stored request record, or `undefined` when it is not a member.
+ */
+export function lookupSignetRequestAt(raw, fieldIndex, requestId) {
+    let node;
+    try {
+        node = signetFieldNode(raw, fieldIndex);
+    }
+    catch {
+        return undefined; // field position out of range for this contract
+    }
+    const map = node.asMap();
+    if (map === undefined) {
+        return undefined; // the named field is not a request index
+    }
+    for (const key of map.keys()) {
+        // fromValue consumes its input, so hand each descriptor a copy.
+        if (requestIdHex(requestIdType.fromValue([...key.value])) !== requestId) {
+            continue;
+        }
+        const cell = map.get(key)?.asCell();
+        if (cell === undefined) {
+            return undefined;
+        }
+        try {
+            return decodeSignBidirectionalRequest(cell.value);
+        }
+        catch {
+            return undefined; // a cell that is not a decodable request record
+        }
+    }
+    return undefined; // id absent from the index
+}
+//# sourceMappingURL=signature-requests-state-reader.js.map

package/dist/signature-requests-state-reader.js.map

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

package/dist/signature-response-verification.d.ts

@@ -0,0 +1,27 @@
+import { type SignBidirectionalRequest } from "./signet-requests.ts";
+import type { SignatureResponse } from "./signet-contract-state-reader.ts";
+/**
+ * Recover the EVM address that produced a response signature, over the
+ * signing hash of the transaction the request describes.
+ *
+ * @param request - The on-ledger request record the response answers.
+ * @param response - The posted signature record answering it.
+ * @returns The checksummed recovered signer address.
+ * @throws Error if the response is not a decodable signature or the request
+ *   record is malformed (see
+ *   {@link signBidirectionalRequestToUnsignedEVMTransaction}).
+ */
+export declare function recoverSignatureResponseSigner(request: SignBidirectionalRequest, response: SignatureResponse): string;
+/**
+ * Verify a posted response against its request: does the signature recover
+ * to `expectedSigner`? Never throws — a response that is malformed or signed
+ * by anyone else is simply not valid, which is the expected state of affairs
+ * on an unauthenticated log.
+ *
+ * @param request - The on-ledger request record the response answers.
+ * @param response - The posted signature record answering it.
+ * @param expectedSigner - The EVM address (any case, 0x hex) that must have signed.
+ * @returns `true` iff the response is a valid signature by `expectedSigner`.
+ */
+export declare function verifySignatureResponse(request: SignBidirectionalRequest, response: SignatureResponse, expectedSigner: string): boolean;
+//# sourceMappingURL=signature-response-verification.d.ts.map

package/dist/signature-response-verification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature-response-verification.d.ts","sourceRoot":"","sources":["../src/signature-response-verification.ts"],"names":[],"mappings":"AAWA,OAAO,EAGL,KAAK,wBAAwB,EAC9B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAE3E;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,wBAAwB,EACjC,QAAQ,EAAE,iBAAiB,GAC1B,MAAM,CAKR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,wBAAwB,EACjC,QAAQ,EAAE,iBAAiB,EAC3B,cAAc,EAAE,MAAM,GACrB,OAAO,CAST"}

package/dist/signature-response-verification.js

@@ -0,0 +1,45 @@
+// Client-side verification of MPC signature responses. Posting to the
+// signet contract's signature response log is UNAUTHENTICATED (see "Signet
+// Layout" in Signet.compact), so a poller must verify every posted response
+// before trusting it: rebuild the unsigned EVM transaction from the on-ledger
+// request record — assembled exactly as the MPC assembles it (sig-net/mpc
+// response server, managed/erc20-vault/signet/calldata-builder.ts) — and
+// check that the posted `{ bigR, s, recoveryId }` signature recovers to the
+// requester's derived EVM address over that transaction's signing hash.
+import { getAddress, recoverAddress } from "ethers";
+import { signBidirectionalRequestToUnsignedEVMTransaction, signatureResponseToSignature, } from "./signet-requests.js";
+/**
+ * Recover the EVM address that produced a response signature, over the
+ * signing hash of the transaction the request describes.
+ *
+ * @param request - The on-ledger request record the response answers.
+ * @param response - The posted signature record answering it.
+ * @returns The checksummed recovered signer address.
+ * @throws Error if the response is not a decodable signature or the request
+ *   record is malformed (see
+ *   {@link signBidirectionalRequestToUnsignedEVMTransaction}).
+ */
+export function recoverSignatureResponseSigner(request, response) {
+    return recoverAddress(signBidirectionalRequestToUnsignedEVMTransaction(request).unsignedHash, signatureResponseToSignature(response));
+}
+/**
+ * Verify a posted response against its request: does the signature recover
+ * to `expectedSigner`? Never throws — a response that is malformed or signed
+ * by anyone else is simply not valid, which is the expected state of affairs
+ * on an unauthenticated log.
+ *
+ * @param request - The on-ledger request record the response answers.
+ * @param response - The posted signature record answering it.
+ * @param expectedSigner - The EVM address (any case, 0x hex) that must have signed.
+ * @returns `true` iff the response is a valid signature by `expectedSigner`.
+ */
+export function verifySignatureResponse(request, response, expectedSigner) {
+    try {
+        return (recoverSignatureResponseSigner(request, response) ===
+            getAddress(expectedSigner));
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=signature-response-verification.js.map

package/dist/signature-response-verification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature-response-verification.js","sourceRoot":"","sources":["../src/signature-response-verification.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,2EAA2E;AAC3E,4EAA4E;AAC5E,8EAA8E;AAC9E,0EAA0E;AAC1E,yEAAyE;AACzE,4EAA4E;AAC5E,wEAAwE;AAExE,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAEpD,OAAO,EACL,gDAAgD,EAChD,4BAA4B,GAE7B,MAAM,sBAAsB,CAAC;AAG9B;;;;;;;;;;GAUG;AACH,MAAM,UAAU,8BAA8B,CAC5C,OAAiC,EACjC,QAA2B;IAE3B,OAAO,cAAc,CACnB,gDAAgD,CAAC,OAAO,CAAC,CAAC,YAAY,EACtE,4BAA4B,CAAC,QAAQ,CAAC,CACvC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,uBAAuB,CACrC,OAAiC,EACjC,QAA2B,EAC3B,cAAsB;IAEtB,IAAI,CAAC;QACH,OAAO,CACL,8BAA8B,CAAC,OAAO,EAAE,QAAQ,CAAC;YACjD,UAAU,CAAC,cAAc,CAAC,CAC3B,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC"}

package/dist/signature-state-reading.d.ts

@@ -0,0 +1,36 @@
+import { CompactTypeBytes, CompactTypeUnsignedInteger, type CompactType, type StateValue } from "@midnight-ntwrk/compact-runtime";
+import { type RequestId } from "./signet-requests.ts";
+/** Descriptor for a Compact `Uint<64>` (8-byte unsigned integer). */
+export declare const u64: CompactTypeUnsignedInteger;
+/** Descriptor for a Compact `Bytes<32>`. */
+export declare const bytes32: CompactTypeBytes;
+/**
+ * Descriptor for a request id ledger key (Compact `RequestId`, a
+ * nominal `Bytes<32>`). Use it to encode a {@link RequestId} into the
+ * aligned form the state tree stores, or decode one back.
+ */
+export declare const requestIdType: CompactType<RequestId>;
+/**
+ * What the indexer / simulator hands us: a bare `StateValue`, or anything
+ * wrapping one under `.state` (e.g. `ChargedState`,
+ * `queryContractState(address).data`).
+ */
+export type RawContractState = StateValue | {
+    state: StateValue;
+};
+/**
+ * Resolve a flat ledger field index to its node in the raw state tree.
+ *
+ * The runtime stores ledger fields as a root array and chunks them one level
+ * deep once the field count grows, so chunked roots are flattened before
+ * indexing. Chunk detection assumes signet field 0 is a `Map`, never a
+ * `List` (whose node is also array-typed) — guaranteed by the signet layout
+ * convention.
+ *
+ * @param raw - Raw contract state from the indexer or simulator.
+ * @param flatIndex - Zero-based ledger field position in declaration order.
+ * @returns The `StateValue` node holding that field.
+ * @throws Error if `flatIndex` is beyond the contract's field count.
+ */
+export declare function signetFieldNode(raw: RawContractState, flatIndex: number): StateValue;
+//# sourceMappingURL=signature-state-reading.d.ts.map

package/dist/signature-state-reading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature-state-reading.d.ts","sourceRoot":"","sources":["../src/signature-state-reading.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,gBAAgB,EAChB,0BAA0B,EAC1B,KAAK,WAAW,EAChB,KAAK,UAAU,EAChB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAOtD,qEAAqE;AACrE,eAAO,MAAM,GAAG,4BAA2D,CAAC;AAE5E,4CAA4C;AAC5C,eAAO,MAAM,OAAO,kBAA2B,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,WAAW,CAAC,SAAS,CAAW,CAAC;AAI7D;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG;IAAE,KAAK,EAAE,UAAU,CAAA;CAAE,CAAC;AAWlE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,gBAAgB,EACrB,SAAS,EAAE,MAAM,GAChB,UAAU,CAgBZ"}