@sig-net/midnight 0.11.0 → 0.12.0

package/dist/managed/contract/index.js.map

@@ -4,5 +4,5 @@
   "sourceRoot": "../../../",
   "sources": ["src/circuits.compact", "src/./Signet.compact", "compiler/zkir-v3-library.compact"],
   "names": [],
-  "mappings": "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"
+  "mappings": "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"
 }

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

@@ -10,16 +10,16 @@ import { type RawContractState } from "./signature-state-reading.ts";
  * fields (1 each). A stored event 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).
+ * entries (each calldata word is one Bytes<32> atom, and each access-list
+ * entry is address + storageKeyCount + its keys).
  */
 export declare const REQUEST_FIXED_VALUE_ATOMS = 22;
 /**
  * The decoded signet ledger fields of a requesting contract: its request
- * index and its contract-local request counter (Compact `Counter`, the
- * source of each request's `requestNonce` — nothing off-chain depends on it,
- * it is decoded here only because both fields travel together in tests and
- * diagnostics).
+ * index and its contract-local request counter (Compact `Counter`), the
+ * source of each request's `requestNonce`. Nothing off-chain depends on the
+ * counter: it is decoded here only because both fields travel together in
+ * tests and diagnostics.
  */
 export interface SignetRequestsLedger {
     /** The request counter (`Counter`). */
@@ -29,11 +29,11 @@ export interface SignetRequestsLedger {
 }
 /**
  * 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 caller-supplied field positions and the canonical descriptors
+ * by field position alone, with no compiled contract and no generated
+ * `ledger()`, only the caller-supplied field positions and the canonical descriptors
  * from signet-requests.ts. A contract chooses its own layout, so the caller
  * must know where the fields sit (the caller contract in this repo uses
- * index 0 / counter 1; a notification names the index position of the
+ * index 0 / counter 1, and a notification names the index position of the
  * contract it points at).
  *
  * @param raw - Raw contract state, e.g. `queryContractState(address).data`
@@ -47,20 +47,20 @@ export interface SignetRequestsLedger {
 export declare function readSignetRequestsLedgerFromState(raw: RawContractState, requestsIndexField: number, nonceField: number): SignetRequestsLedger;
 /**
  * Look up ONE request by id in a contract's request index at an arbitrary
- * ledger field — the single-record sibling of
+ * ledger field, the single-record sibling of
  * {@link readSignetRequestsLedgerFromState}, and what the discovery path
  * uses: a notification names both the requester contract AND which field
  * holds its index.
  *
  * This is the mandatory membership check of the discovery 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.
+ * 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 notification can never crash the reader.
  *
- * Only the matched record is decoded (not the whole index), and it is decoded
+ * Only the matched record is decoded, and it is decoded
  * by the same {@link decodeSignBidirectionalEvent} the full reader uses, so
  * the result is `toEqual` to `readSignetRequestsLedgerFromState(raw,
  * fieldIndex, …).requestsIndex.get(requestId)`.

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

@@ -1,13 +1,13 @@
 // 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
+// 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 ledger field POSITION.
 // A contract is free to place its request index at any field: the caller
 // supplies the position, which the discovery path learns from the
 // notification's requestsIndexField.
-// The compiled contract's generated ledger() does exactly this walk internally;
-// the record descriptors themselves are the parameterized twins in
+// The compiled contract's generated ledger() does exactly this walk internally.
+// The record descriptors themselves are the parameterised twins in
 // signet-requests.ts. The generic tree walk and shared base descriptors live
 // in signature-state-reading.ts.
 import { calculateRequestId, signBidirectionalEventDescriptor, } from "./signet-evtype2tx-requests.js";
@@ -23,26 +23,26 @@ import { requestIdType, signetFieldNode, u64, } from "./signature-state-reading.
  * fields (1 each). A stored event 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).
+ * entries (each calldata word is one Bytes<32> atom, and each access-list
+ * entry is address + storageKeyCount + its keys).
  */
 export const REQUEST_FIXED_VALUE_ATOMS = 22;
 /**
  * Recover a record's capacity instantiation (maxCalldataWords,
  * maxAccessListEntries, maxStorageKeysPerEntry) from its aligned-value atom
  * count and decode it. One atom count does not determine the capacities
- * uniquely, so candidates are enumerated — access-list-free first (today's
- * producers — the caller contract <1, 0, 0>, the erc20-vault example
- * <2, 0, 0> — all are) — 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.
+ * uniquely, so candidates are enumerated, access-list-free first (today's
+ * producers, the caller contract <1, 0, 0> and the erc20-vault example
+ * <2, 0, 0>, are all access-list-free), 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.
  *
  * The schema byte widths (`#LenOutputDeserialization`,
  * `#LenRespondSerialization`) are read from the LAST TWO atoms' actual byte
  * lengths. That works because the state layer stores atoms with trailing
  * zeros trimmed and schemas are exact-length by protocol convention (JSON
  * schema strings sized to fit, never NUL-padded, never ending in a zero
- * byte) — so stored length == declared length. A contract that padded its
+ * byte), so stored length == declared length. A contract that padded its
  * schema capacity with trailing zeros would decode to the trimmed width and
  * fail the request-id recompute, which is the authoritative check anyway.
  *
@@ -55,7 +55,7 @@ export const REQUEST_FIXED_VALUE_ATOMS = 22;
 function decodeSignBidirectionalEvent(atoms, expectedRequestId) {
     const variable = atoms.length - REQUEST_FIXED_VALUE_ATOMS;
     if (variable < 0) {
-        throw new Error(`request record has ${atoms.length} value entries — fewer than the ` +
+        throw new Error(`request record has ${atoms.length} value entries: fewer than the ` +
             `${REQUEST_FIXED_VALUE_ATOMS} its fixed fields need`);
     }
     const lenOutputDeserialization = atoms[atoms.length - 2].length;
@@ -71,9 +71,9 @@ function decodeSignBidirectionalEvent(atoms, expectedRequestId) {
             return undefined;
         }
     };
-    // Several splits can decode cleanly — an access-list entry's 20-byte address atom
-    // re-pads into a 32-byte calldata word just as well — so only the id the record is
-    // filed under separates them. This disambiguates; it does not authenticate (the MPC
+    // Several splits can decode cleanly (an access-list entry's 20-byte address atom
+    // re-pads into a 32-byte calldata word just as well), so only the id the record is
+    // filed under separates them. This disambiguates but does not authenticate (the MPC
     // recomputes against the sender-bound id before signing).
     //
     // First match wins, so the common access-list-free case stays at one decode.
@@ -106,11 +106,11 @@ function decodeSignBidirectionalEvent(atoms, expectedRequestId) {
 }
 /**
  * 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 caller-supplied field positions and the canonical descriptors
+ * by field position alone, with no compiled contract and no generated
+ * `ledger()`, only the caller-supplied field positions and the canonical descriptors
  * from signet-requests.ts. A contract chooses its own layout, so the caller
  * must know where the fields sit (the caller contract in this repo uses
- * index 0 / counter 1; a notification names the index position of the
+ * index 0 / counter 1, and a notification names the index position of the
  * contract it points at).
  *
  * @param raw - Raw contract state, e.g. `queryContractState(address).data`
@@ -144,20 +144,20 @@ export function readSignetRequestsLedgerFromState(raw, requestsIndexField, nonce
 }
 /**
  * Look up ONE request by id in a contract's request index at an arbitrary
- * ledger field — the single-record sibling of
+ * ledger field, the single-record sibling of
  * {@link readSignetRequestsLedgerFromState}, and what the discovery path
  * uses: a notification names both the requester contract AND which field
  * holds its index.
  *
  * This is the mandatory membership check of the discovery 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.
+ * 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 notification can never crash the reader.
  *
- * Only the matched record is decoded (not the whole index), and it is decoded
+ * Only the matched record is decoded, and it is decoded
  * by the same {@link decodeSignBidirectionalEvent} the full reader uses, so
  * the result is `toEqual` to `readSignetRequestsLedgerFromState(raw,
  * fieldIndex, …).requestsIndex.get(requestId)`.

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

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

@@ -14,7 +14,7 @@ import type { SignatureRespondedEvent } from "./signet-contract-state-reader.ts"
 export declare function recoverSignatureResponseSigner(request: SignBidirectionalEvent, response: SignatureRespondedEvent): string;
 /**
  * Verify a posted response against its request: does the signature recover
- * to `expectedSigner`? Never throws — a response that is malformed or signed
+ * 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.
  *

package/dist/signature-response-verification.js

@@ -2,8 +2,8 @@
 // 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
+// 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 signature record recovers to the requester's derived
 // EVM address over that transaction's signing hash.
 import { getAddress, recoverAddress } from "ethers";
@@ -24,7 +24,7 @@ export function recoverSignatureResponseSigner(request, response) {
 }
 /**
  * Verify a posted response against its request: does the signature recover
- * to `expectedSigner`? Never throws — a response that is malformed or signed
+ * 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.
  *

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

@@ -1 +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,6EAA6E;AAC7E,oDAAoD;AAEpD,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAEpD,OAAO,EACL,8CAA8C,EAC9C,kCAAkC,GACnC,MAAM,gCAAgC,CAAC;AAIxC;;;;;;;;;;GAUG;AACH,MAAM,UAAU,8BAA8B,CAC5C,OAA+B,EAC/B,QAAiC;IAEjC,OAAO,cAAc,CACnB,8CAA8C,CAAC,OAAO,CAAC,CAAC,YAAY,EACpE,kCAAkC,CAAC,QAAQ,CAAC,CAC7C,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,6BAA6B,CAC3C,OAA+B,EAC/B,QAAiC,EACjC,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"}
+{"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,yEAAyE;AACzE,wEAAwE;AACxE,6EAA6E;AAC7E,oDAAoD;AAEpD,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AAEpD,OAAO,EACL,8CAA8C,EAC9C,kCAAkC,GACnC,MAAM,gCAAgC,CAAC;AAIxC;;;;;;;;;;GAUG;AACH,MAAM,UAAU,8BAA8B,CAC5C,OAA+B,EAC/B,QAAiC;IAEjC,OAAO,cAAc,CACnB,8CAA8C,CAAC,OAAO,CAAC,CAAC,YAAY,EACpE,kCAAkC,CAAC,QAAQ,CAAC,CAC7C,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,6BAA6B,CAC3C,OAA+B,EAC/B,QAAiC,EACjC,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/signet-contract-state-reader.d.ts

@@ -15,7 +15,7 @@ export declare const RESPOND_BIDIRECTIONAL_COUNTER_MAP_FIELD = 4;
 export declare const RESPOND_BIDIRECTIONAL_MAP_FIELD = 5;
 /**
  * A curve point in affine coordinates (Compact `AffinePoint`), SEC1
- * big-endian — the same shape the sig-net EVM and Solana signer contracts
+ * big-endian, the same shape the sig-net EVM and Solana signer contracts
  * expose.
  */
 export interface AffinePoint {
@@ -30,7 +30,7 @@ export interface AffinePoint {
  * `Signature { big_r, s, recovery_id }` and the EVM/Solana signer
  * contracts): `bigR` the full nonce point so consumers never decompress,
  * `s` big-endian, `recoveryId` the parity of R.y. Stored UNVERIFIED like
- * everything else on the singleton; convert with
+ * everything else on the singleton. Convert with
  * `ecdsaSignatureToMpcSignature` / `mpcSignatureToEcdsaSignature`.
  */
 export interface MpcSignature {
@@ -43,9 +43,9 @@ export interface MpcSignature {
 }
 /**
  * The MPC's signature over the requested EVM transaction (Compact
- * `SignatureRespondedEvent`) — decode to an ethers signature with
+ * `SignatureRespondedEvent`): decode to an ethers signature with
  * `signatureRespondedEventToSignature`. The request id it answers lives in
- * the map key, not here.
+ * the map key.
  */
 export interface SignatureRespondedEvent {
     /** The requested signature over the transaction the request describes. */
@@ -57,27 +57,25 @@ export interface SignatureRespondedEvent {
  */
 export declare const signatureRespondedEventType: CompactType<SignatureRespondedEvent>;
 /**
- * The MPC's respond-bidirectional response for a request's remote EVM
- * execution (Compact `RespondBidirectionalEvent`): the serialized execution
- * output plus the ECDSA signature over the attestation digest of
- * `(requestId, serializedOutput)`. `outputLen` is carried but NOT signed over, so
- * anything relying on it must pin it separately. Stored UNVERIFIED by the signet
- * contract — clients verify it themselves (in-circuit via
- * `verifyRespondBidirectionalEvent`, or off-chain via the compiled
- * `pureCircuits.verifyRespondBidirectionalEvent`).
+ * The MPC's respond-bidirectional attestation of a request's remote EVM
+ * execution (Compact `RespondBidirectionalEvent`): the attestation digest
+ * `keccak256(requestId || serializedOutput)` plus the ECDSA signature over
+ * it. The output itself travels off chain: readers fetch it, recompute the
+ * digest (`calculateSignetAttestationDigest`) and match it against
+ * {@link attestationDigest}. Stored UNVERIFIED by the signet contract:
+ * clients verify the signature themselves against their MPC response key
+ * (in-circuit via `verifyRespondBidirectionalEvent`).
  */
 export interface RespondBidirectionalEvent {
-    /** ABI-encoded return data (canonical serialized_output), zero-padded to 128 bytes. */
-    serializedOutput: Uint8Array;
-    /** Meaningful byte count of {@link serializedOutput}. */
-    outputLen: bigint;
+    /** The signed attestation digest: `keccak256(requestId || serializedOutput)`. */
+    attestationDigest: Uint8Array;
     /** ECDSA signature over the attestation digest. */
     signature: MpcSignature;
 }
 /**
  * Composite key of one posted entry in the signet contract's maps (Compact
  * `SignetMapKey`): the request id it belongs to plus the post's 0-based
- * count. Field order — count first, then request id — mirrors the Compact
+ * count. Field order (count first, then request id) mirrors the Compact
  * struct.
  */
 export interface SignetMapKey {
@@ -87,15 +85,14 @@ export interface SignetMapKey {
     requestId: RequestId;
 }
 /**
- * Hand-composed descriptor for {@link SignetMapKey} — the map key of every
+ * Hand-composed descriptor for {@link SignetMapKey}, the map key of every
  * posted-entry map in the signet contract. Field order (count, then
  * requestId) must match the Compact struct.
  */
 export declare const signetMapKeyType: CompactType<SignetMapKey>;
 /**
  * Hand-composed descriptor for {@link RespondBidirectionalEvent}. Field
- * order (serializedOutput, outputLen, signature) must match the Compact
- * struct.
+ * order (attestationDigest, signature) must match the Compact struct.
  */
 export declare const respondBidirectionalEventType: CompactType<RespondBidirectionalEvent>;
 /**
@@ -104,7 +101,7 @@ export declare const respondBidirectionalEventType: CompactType<RespondBidirecti
  * Decode the payload with {@link decodeSignBidirectionalNotification}.
  */
 export interface SignBidirectionalNotificationRecord {
-    /** Payload layout tag (Compact `Uint<8>`); 1 = the V1 layout. */
+    /** Payload layout tag (Compact `Uint<8>`): 1 = the V1 layout. */
     version: bigint;
     /** The packed payload bytes, exactly as the registering circuit built them. */
     payload: Uint8Array;
@@ -116,20 +113,20 @@ export interface SignBidirectionalNotificationRecord {
 export declare const signBidirectionalNotificationType: CompactType<SignBidirectionalNotificationRecord>;
 /**
  * A decoded V1 notification from the signet contract's registry: the flat
- * pointer a client registered to tell the MPC a request was stored — and
+ * pointer a client registered to tell the MPC a request was stored, and
  * WHERE to read the authenticated copy. The request id is NOT in the payload:
  * it lives in the registry map key the record was stored under. Never trusted
  * on its own: the resolver authenticates by reading the request back from
  * {@link callerAddress}'s own ledger (see signet-request-resolver.ts).
  */
 export interface SignBidirectionalNotification {
-    /** Payload layout tag; this decoder only produces version 1. */
+    /** Payload layout tag: this decoder only produces version 1. */
     version: number;
     /**
      * Address of the contract whose request map holds the request, rendered
-     * as lowercase hex, no `0x` prefix — directly usable as a
+     * as lowercase hex, no `0x` prefix: directly usable as a
      * `queryContractState` argument. The MPC reads the request from THIS
-     * contract's authenticated state; the field itself confers no authority.
+     * contract's authenticated state. The field itself confers no authority.
      */
     callerAddress: string;
     /**
@@ -141,9 +138,9 @@ export interface SignBidirectionalNotification {
 }
 /**
  * Unpack a stored {@link SignBidirectionalNotificationRecord}'s payload by
- * the fixed V1 offsets — the decode twin of the compiled
+ * the fixed V1 offsets: the decode twin of the compiled
  * `constructSignBidirectionalEventNotificationV1` circuit (byte plumbing
- * only; the pack↔decode lockstep is pinned by the state-reader unit test that
+ * only: the pack↔decode lockstep is pinned by the state-reader unit test that
  * round-trips through the real circuit). V1 layout:
  * callerAddress (32) ++ requestsIndexField (1) ++ zero padding (95).
  *
@@ -158,8 +155,8 @@ export declare function decodeSignBidirectionalNotification(record: SignBidirect
 /**
  * Plain-JS notification registry parsed out of the ledger: hex request id
  * (from the `SignetMapKey` the notification was stored under) to the raw
- * stored record. Re-notifies append under higher counts; this index keeps
- * the FIRST post (count 0) per request id — the record the original submit
+ * stored record. Re-notifies append under higher counts. This index keeps
+ * the FIRST post (count 0) per request id, the record the original submit
  * registered. Decode each record with
  * {@link decodeSignBidirectionalNotification}.
  */
@@ -182,7 +179,7 @@ export type SignatureResponseIndex = Map<string, SignatureRespondedEvent>;
  */
 export type RespondBidirectionalIndex = Map<string, RespondBidirectionalEvent>;
 /**
- * Build the flattened JS map key for a `(requestId, count)` pair — the
+ * Build the flattened JS map key for a `(requestId, count)` pair: the
  * composite Compact {@link SignetMapKey} as a string so it works as a JS
  * `Map` key.
  *
@@ -194,9 +191,9 @@ export declare function signetMapEntryKey(id: RequestIdHex, count: bigint): stri
 /**
  * Read ONLY the notification registry (ledger field
  * {@link SIGN_BIDIRECTIONAL_EVENT_NOTIFICATION_MAP_FIELD}) out of raw signet
- * contract state — the poll-loop primitive of {@link SignetRequestFeed},
+ * contract state: the poll-loop primitive of {@link SignetRequestFeed},
  * which cycles frequently and has no use for the response fields. One record
- * per request id (the count-0 post; see
+ * per request id (the count-0 post, see
  * {@link SignBidirectionalNotificationIndex}).
  *
  * @param raw - Raw contract state, e.g. `queryContractState(address).data`
@@ -207,7 +204,7 @@ export declare function signetMapEntryKey(id: RequestIdHex, count: bigint): stri
 export declare function readSignBidirectionalNotificationIndexFromState(raw: RawContractState): SignBidirectionalNotificationIndex;
 /**
  * The decoded ledger fields of the signet contract: the three
- * (counter map, entry map) pairs — notifications (fields 0/1), signature
+ * (counter map, entry map) pairs, namely notifications (fields 0/1), signature
  * responses (fields 2/3), respond-bidirectional responses (fields 4/5).
  * Together they give a poller everything the contract ever records about a
  * request. All entries are UNAUTHENTICATED: verify before trusting.
@@ -231,9 +228,9 @@ export interface SignetContractLedger {
 }
 /**
  * MPC-/client-style read: parse the signet contract's ledger fields out of
- * raw contract state by field position alone — no compiled contract, no
- * generated `ledger()`, only the declaration-order layout and the canonical
- * descriptors above.
+ * raw contract state by field position alone, with no compiled contract and
+ * no generated `ledger()`, only the declaration-order layout and the
+ * canonical descriptors above.
  *
  * @param raw - Raw contract state, e.g. `queryContractState(address).data`
  *   from the indexer or `ctx.currentQueryContext.state` from the simulator.

package/dist/signet-contract-state-reader.d.ts.map

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

package/dist/signet-contract-state-reader.js

@@ -11,7 +11,7 @@
 //   field 4: respondBidirectionalCounterMap (Map<RequestId, Counter>)
 //   field 5: respondBidirectionalMap (Map<SignetMapKey, RespondBidirectionalEvent>)
 // Every store is an unauthenticated append-only log keyed by
-// (requestId, count); verification is the reader's job. The generic
+// (requestId, count): verification is the reader's job. The generic
 // state-tree walk (RawContractState, signetFieldNode) and the shared base
 // descriptors live in signature-state-reading.ts.
 import { CompactTypeBytes, CompactTypeUnsignedInteger, } from "@midnight-ntwrk/compact-runtime";
@@ -32,10 +32,8 @@ export const RESPOND_BIDIRECTIONAL_MAP_FIELD = 5;
 // ---- Type descriptors (must mirror Signet.compact field-for-field) ----
 // As in the requests reader, fromValue consumes the aligned value
 // sequentially, so field order and width here must match the Compact structs
-// exactly — a mismatch is silent data corruption, not an error.
-/** Descriptor for the response's serialized output (`Bytes<128>`). */
-const bytes128 = new CompactTypeBytes(128);
-/** Descriptor for a 32-byte scalar / coordinate (`Bytes<32>`). */
+// exactly: a mismatch is silent data corruption, not an error.
+/** Descriptor for a 32-byte scalar / coordinate / hash (`Bytes<32>`). */
 const bytes32 = new CompactTypeBytes(32);
 /** Descriptor for a Compact `Uint<8>` (1-byte unsigned integer). */
 const u8 = new CompactTypeUnsignedInteger(255n, 1);
@@ -55,7 +53,7 @@ const mpcSignatureType = {
     /**
      * Decode one signature from an aligned value, consuming it leaf by leaf.
      *
-     * @param value - Mutable aligned value cursor; pass a copy.
+     * @param value - Mutable aligned value cursor: pass a copy.
      * @returns The decoded signature.
      */
     fromValue(value) {
@@ -91,7 +89,7 @@ export const signatureRespondedEventType = {
     /**
      * Decode one signature response from an aligned value.
      *
-     * @param value - Mutable aligned value cursor; pass a copy.
+     * @param value - Mutable aligned value cursor: pass a copy.
      * @returns The decoded record.
      */
     fromValue(value) {
@@ -108,7 +106,7 @@ export const signatureRespondedEventType = {
     },
 };
 /**
- * Hand-composed descriptor for {@link SignetMapKey} — the map key of every
+ * Hand-composed descriptor for {@link SignetMapKey}, the map key of every
  * posted-entry map in the signet contract. Field order (count, then
  * requestId) must match the Compact struct.
  */
@@ -120,7 +118,7 @@ export const signetMapKeyType = {
     /**
      * Decode one key from an aligned value, consuming it field by field.
      *
-     * @param value - Mutable aligned value cursor; pass a copy.
+     * @param value - Mutable aligned value cursor: pass a copy.
      * @returns The decoded composite key.
      */
     fromValue(value) {
@@ -141,28 +139,25 @@ export const signetMapKeyType = {
 };
 /**
  * Hand-composed descriptor for {@link RespondBidirectionalEvent}. Field
- * order (serializedOutput, outputLen, signature) must match the Compact
- * struct.
+ * order (attestationDigest, signature) must match the Compact struct.
  */
 export const respondBidirectionalEventType = {
     /** @returns Compound alignment of the struct's fields in declaration order. */
     alignment() {
-        return bytes128
+        return bytes32
             .alignment()
-            .concat(u8.alignment())
             .concat(mpcSignatureType.alignment());
     },
     /**
      * Decode one response record from an aligned value, consuming it field
      * by field.
      *
-     * @param value - Mutable aligned value cursor; pass a copy.
+     * @param value - Mutable aligned value cursor: pass a copy.
      * @returns The decoded record.
      */
     fromValue(value) {
         return {
-            serializedOutput: bytes128.fromValue(value),
-            outputLen: u8.fromValue(value),
+            attestationDigest: bytes32.fromValue(value),
             signature: mpcSignatureType.fromValue(value),
         };
     },
@@ -173,9 +168,8 @@ export const respondBidirectionalEventType = {
      * @returns The aligned value, fields concatenated in declaration order.
      */
     toValue(record) {
-        return bytes128
-            .toValue(record.serializedOutput)
-            .concat(u8.toValue(record.outputLen))
+        return bytes32
+            .toValue(record.attestationDigest)
             .concat(mpcSignatureType.toValue(record.signature));
     },
 };
@@ -194,7 +188,7 @@ export const signBidirectionalNotificationType = {
      * Decode one notification record from an aligned value, consuming it
      * field by field.
      *
-     * @param value - Mutable aligned value cursor; pass a copy.
+     * @param value - Mutable aligned value cursor: pass a copy.
      * @returns The decoded record.
      */
     fromValue(value) {
@@ -223,9 +217,9 @@ const NOTIFICATION_REQUESTS_INDEX_FIELD_OFFSET = 32;
 const SUPPORTED_NOTIFICATION_VERSION = 1n;
 /**
  * Unpack a stored {@link SignBidirectionalNotificationRecord}'s payload by
- * the fixed V1 offsets — the decode twin of the compiled
+ * the fixed V1 offsets: the decode twin of the compiled
  * `constructSignBidirectionalEventNotificationV1` circuit (byte plumbing
- * only; the pack↔decode lockstep is pinned by the state-reader unit test that
+ * only: the pack↔decode lockstep is pinned by the state-reader unit test that
  * round-trips through the real circuit). V1 layout:
  * callerAddress (32) ++ requestsIndexField (1) ++ zero padding (95).
  *
@@ -243,6 +237,10 @@ export function decodeSignBidirectionalNotification(record) {
     }
     const callerAddress = bytesToHex(record.payload.slice(NOTIFICATION_CALLER_ADDRESS_OFFSET, NOTIFICATION_REQUESTS_INDEX_FIELD_OFFSET));
     const requestsIndexField = record.payload[NOTIFICATION_REQUESTS_INDEX_FIELD_OFFSET];
+    if (requestsIndexField === undefined) {
+        throw new Error(`SignBidirectionalEventNotification payload is ${record.payload.length} bytes: ` +
+            `too short for the V1 requestsIndexField at offset ${NOTIFICATION_REQUESTS_INDEX_FIELD_OFFSET}`);
+    }
     return {
         version: Number(record.version),
         callerAddress,
@@ -250,7 +248,7 @@ export function decodeSignBidirectionalNotification(record) {
     };
 }
 /**
- * Build the flattened JS map key for a `(requestId, count)` pair — the
+ * Build the flattened JS map key for a `(requestId, count)` pair: the
  * composite Compact {@link SignetMapKey} as a string so it works as a JS
  * `Map` key.
  *
@@ -298,9 +296,9 @@ function readSignetKeyedMap(raw, field, valueType) {
 /**
  * Read ONLY the notification registry (ledger field
  * {@link SIGN_BIDIRECTIONAL_EVENT_NOTIFICATION_MAP_FIELD}) out of raw signet
- * contract state — the poll-loop primitive of {@link SignetRequestFeed},
+ * contract state: the poll-loop primitive of {@link SignetRequestFeed},
  * which cycles frequently and has no use for the response fields. One record
- * per request id (the count-0 post; see
+ * per request id (the count-0 post, see
  * {@link SignBidirectionalNotificationIndex}).
  *
  * @param raw - Raw contract state, e.g. `queryContractState(address).data`
@@ -333,9 +331,9 @@ export function readSignBidirectionalNotificationIndexFromState(raw) {
 }
 /**
  * MPC-/client-style read: parse the signet contract's ledger fields out of
- * raw contract state by field position alone — no compiled contract, no
- * generated `ledger()`, only the declaration-order layout and the canonical
- * descriptors above.
+ * raw contract state by field position alone, with no compiled contract and
+ * no generated `ledger()`, only the declaration-order layout and the
+ * canonical descriptors above.
  *
  * @param raw - Raw contract state, e.g. `queryContractState(address).data`
  *   from the indexer or `ctx.currentQueryContext.state` from the simulator.