@sig-net/midnight 0.0.6 → 0.0.7

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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAA;;;;;;;;;;MCgNE,MAAA,6CAWC;;OAAA;MA0DD,MAAA,uBAUC;;OAAA;MAQD,MAAA,+BAiBC;;OAAA;MAKD,MAAA,aAEC;;OAAA;;;;GDzRF;EAtCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCC;EEVD,AAAA,yBAA8B;UACtB,iBAAI;UACJ,gCACQ;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;;;;gDACP;;;;EAqBT,AAAA,wBACiB,WACA,OACA;UAET,oCAA2C;UAC3C,2BAAS;UAAT,MAAA;UAAA,MAAA;UACA,kBAAyB;UACzB,mBAA0B,KAAG;UAC7B,mBAA0B,KAAG;UAC7B,+CAA6C;gDAAW,MAAI;;;;8GAC1C;;;;;WAA2C;;EA/FrE,AAAA,kBAAA;qEAAA;;;EAAA,AAAA,kBAAA;oEAAA;;;EAAA,AAAA,kBAAA;oEAAA;;;EAAA,AAAA,OAAA,KAAA;yDAAA,KAAA;;;EAAA,AAAA,OAAA;yDAAA;;;EAAA,AAAA,mBAAA;sDAAA;;;EAAA,AAAA,SAAA,KAAA;mDAAA,KAAA;;;EAAA,AAAA,SAAA,KAAA;mDAAA,KAAA;;;EAAA,AAAA,kBAAA;4DAAA;;;EDgNE,AAAA,gDAWC,CARC,eAA8B;mDAC9B,oBAA2B;;;;8CAKP,eAAa;gCAAQ,oBAAkB;;;GAE5D;EA0DD,AAAA,0BAUC,CATC,WAAoB,EACpB,kBAA4B,EAC5B,WAAkB;UAEZ,SAGJ,kDAF2B,kBAAgB;;oFAC3C,WAAS;;mCAEkC,WAAS,EAAe,SAAO;GAC7E;EAQD,AAAA,kCAiBC,CAhBC,WAAoB;qCACpB,2BAAoD;qCACpD,gBAA8B;;wEAI1B,WAAS;wEACT,2BAAyB;wEACzB,2BAAyB;;;;iFAGtB,2BAAyB;;;;;;iFACzB,2BAAyB;;;wCAE9B,gBAAc;GAEjB;EAKD,AAAA,gBAEC,CAFiC,IAAkB,kCACZ,IAAE,IACzC;;;;;;;;;;;;;;;;;;;;;;;EA/GD,AAAA,6CAWC;;;;UARC,eAA8B;UAC9B,oBAA2B;;;;;;;;;;;;;;;2EAD3B,eAA8B;2EAC9B,oBAA2B;GAO5B;EA0DD,AAAA,uBAUC;;;;UATC,WAAoB;UACpB,kBAA4B;UAC5B,WAAkB;;;;;;;;;;;;;;;;;;;;;;qDAFlB,WAAoB;qDACpB,kBAA4B;qDAC5B,WAAkB;GAOnB;EAQD,AAAA,+BAiBC;;;;UAhBC,WAAoB;UACpB,2BAAoD;UACpD,gBAA8B;;;;;;;;;;;;;;;6DAF9B,WAAoB;6DACpB,2BAAoD;6DACpD,gBAA8B;GAc/B;EAKD,AAAA,aAEC;;;;UAFiC,IAAkB;2CAAlB,IAAkB;GAEnD;;;;;;"
 }

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

@@ -1,30 +1,31 @@
-import { type RequestIdHex, type SignBidirectionalRequest, type SignBidirectionalRequestIndex } from "./signet-requests.ts";
+import { type RequestIdHex, type SignBidirectionalEvent, type SignBidirectionalEventIndex } from "./signet-requests.ts";
 import { type RawContractState } from "./signature-state-reading.ts";
 /**
- * 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
+ * Aligned-value entry count of an event record EXCLUDING the capacity-scaled
+ * vectors: sender (1) + requestNonce (1) + keyVersion (1) + path (1) +
+ * algo (1) + dest (1) + params (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) + caip2Id (1) + the two schema
+ * 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).
  */
-export declare const REQUEST_FIXED_VALUE_ATOMS = 21;
+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 `SignetNonce`, the
+ * 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).
  */
 export interface SignetRequestsLedger {
-    /** The request counter (`SignetNonce`). */
+    /** The request counter (`Counter`). */
     nonce: bigint;
     /** The request index, keyed by hex request id. */
-    requestsIndex: SignBidirectionalRequestIndex;
+    requestsIndex: SignBidirectionalEventIndex;
 }
 /**
  * MPC-style read: parse the signet ledger fields out of raw contract state
@@ -60,7 +61,7 @@ export declare function readSignetRequestsLedgerFromState(raw: RawContractState,
  * malformed or adversarial notification 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
+ * by the same {@link decodeSignBidirectionalEvent} the full reader uses, so
  * the result is `toEqual` to `readSignetRequestsLedgerFromState(raw,
  * fieldIndex, …).requestsIndex.get(requestId)`.
  *
@@ -69,5 +70,5 @@ export declare function readSignetRequestsLedgerFromState(raw: RawContractState,
  * @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;
+export declare function lookupSignetRequestAt(raw: RawContractState, fieldIndex: number, requestId: RequestIdHex): SignBidirectionalEvent | undefined;
 //# sourceMappingURL=signature-requests-state-reader.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"signature-requests-state-reader.d.ts","sourceRoot":"","sources":["../src/signature-requests-state-reader.ts"],"names":[],"mappings":"AAeA,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,wBAAwB,EAC7B,KAAK,6BAA6B,EACnC,MAAM,sBAAsB,CAAC;AAK9B,OAAO,EAIL,KAAK,gBAAgB,EACtB,MAAM,8BAA8B,CAAC;AAEtC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAgE5C;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,aAAa,EAAE,6BAA6B,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iCAAiC,CAC/C,GAAG,EAAE,gBAAgB,EACrB,kBAAkB,EAAE,MAAM,EAC1B,UAAU,EAAE,MAAM,GACjB,oBAAoB,CAwBtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,gBAAgB,EACrB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,YAAY,GACtB,wBAAwB,GAAG,SAAS,CA2BtC"}
+{"version":3,"file":"signature-requests-state-reader.d.ts","sourceRoot":"","sources":["../src/signature-requests-state-reader.ts"],"names":[],"mappings":"AAeA,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,sBAAsB,EAC3B,KAAK,2BAA2B,EACjC,MAAM,sBAAsB,CAAC;AAK9B,OAAO,EAIL,KAAK,gBAAgB,EACtB,MAAM,8BAA8B,CAAC;AAEtC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,yBAAyB,KAAK,CAAC;AA4E5C;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,uCAAuC;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,aAAa,EAAE,2BAA2B,CAAC;CAC5C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iCAAiC,CAC/C,GAAG,EAAE,gBAAgB,EACrB,kBAAkB,EAAE,MAAM,EAC1B,UAAU,EAAE,MAAM,GACjB,oBAAoB,CAwBtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,gBAAgB,EACrB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,YAAY,GACtB,sBAAsB,GAAG,SAAS,CA2BpC"}

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

@@ -10,46 +10,57 @@
 // 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 { requestIdHex, signBidirectionalEventDescriptor, } from "./signet-requests.js";
 import { requestIdType, signetFieldNode, u64, } from "./signature-state-reading.js";
 /**
- * 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
+ * Aligned-value entry count of an event record EXCLUDING the capacity-scaled
+ * vectors: sender (1) + requestNonce (1) + keyVersion (1) + path (1) +
+ * algo (1) + dest (1) + params (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) + caip2Id (1) + the two schema
+ * 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).
  */
-export const REQUEST_FIXED_VALUE_ATOMS = 21;
+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. 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 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.
+ * 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.
+ *
+ * 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
+ * schema capacity with trailing zeros would decode to the trimmed width and
+ * fail the request-id recompute, which is the authoritative check anyway.
  *
  * @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) {
+function decodeSignBidirectionalEvent(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 lenOutputDeserialization = atoms[atoms.length - 2].length;
+    const lenRespondSerialization = atoms[atoms.length - 1].length;
     const attempt = (maxWords, maxEntries, maxKeys) => {
         const cursor = [...atoms];
         try {
-            const record = signBidirectionalRequestDescriptor(maxWords, maxEntries, maxKeys).fromValue(cursor);
+            const record = signBidirectionalEventDescriptor(maxWords, maxEntries, maxKeys, lenOutputDeserialization, lenRespondSerialization).fromValue(cursor);
             // A clean decode consumes the record exactly.
             return cursor.length === 0 ? record : undefined;
         }
@@ -104,7 +115,7 @@ export function readSignetRequestsLedgerFromState(raw, requestsIndexField, nonce
         const cell = map.get(key)?.asCell();
         if (cell === undefined)
             continue;
-        requestsIndex.set(requestIdHex(requestId), decodeSignBidirectionalRequest(cell.value));
+        requestsIndex.set(requestIdHex(requestId), decodeSignBidirectionalEvent(cell.value));
     }
     const nonceCell = signetFieldNode(raw, nonceField).asCell();
     if (nonceCell === undefined) {
@@ -129,7 +140,7 @@ export function readSignetRequestsLedgerFromState(raw, requestsIndexField, nonce
  * malformed or adversarial notification 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
+ * by the same {@link decodeSignBidirectionalEvent} the full reader uses, so
  * the result is `toEqual` to `readSignetRequestsLedgerFromState(raw,
  * fieldIndex, …).requestsIndex.get(requestId)`.
  *
@@ -160,7 +171,7 @@ export function lookupSignetRequestAt(raw, fieldIndex, requestId) {
             return undefined;
         }
         try {
-            return decodeSignBidirectionalRequest(cell.value);
+            return decodeSignBidirectionalEvent(cell.value);
         }
         catch {
             return undefined; // a cell that is not a decodable request record

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":"AAAA,gFAAgF;AAChF,2EAA2E;AAC3E,gFAAgF;AAChF,yDAAyD;AACzD,4EAA4E;AAC5E,yEAAyE;AACzE,kEAAkE;AAClE,qCAAqC;AACrC,gFAAgF;AAChF,mEAAmE;AACnE,6EAA6E;AAC7E,iCAAiC;AAIjC,OAAO,EACL,YAAY,EACZ,gCAAgC,GAIjC,MAAM,sBAAsB,CAAC;AAK9B,OAAO,EACL,aAAa,EACb,eAAe,EACf,GAAG,GAEJ,MAAM,8BAA8B,CAAC;AAEtC;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,EAAE,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,SAAS,4BAA4B,CACnC,KAAmB;IAEnB,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAM,GAAG,yBAAyB,CAAC;IAC1D,IAAI,QAAQ,GAAG,CAAC,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CACb,sBAAsB,KAAK,CAAC,MAAM,kCAAkC;YAClE,GAAG,yBAAyB,wBAAwB,CACvD,CAAC;IACJ,CAAC;IACD,MAAM,wBAAwB,GAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAgB,CAAC,MAAM,CAAC;IAChF,MAAM,uBAAuB,GAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAgB,CAAC,MAAM,CAAC;IAC/E,MAAM,OAAO,GAAG,CACd,QAAgB,EAChB,UAAkB,EAClB,OAAe,EACqB,EAAE;QACtC,MAAM,MAAM,GAAG,CAAC,GAAG,KAAK,CAAiB,CAAC;QAC1C,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,gCAAgC,CAC7C,QAAQ,EACR,UAAU,EACV,OAAO,EACP,wBAAwB,EACxB,uBAAuB,CACxB,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YACpB,8CAA8C;YAC9C,OAAO,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;QAClD,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC,CAAC;IACF,2EAA2E;IAC3E,CAAC;QACC,MAAM,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACvC,IAAI,MAAM,KAAK,SAAS;YAAE,OAAO,MAAM,CAAC;IAC1C,CAAC;IACD,mEAAmE;IACnE,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,QAAQ,EAAE,OAAO,EAAE,EAAE,CAAC;QACzD,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,QAAQ,EAAE,IAAI,EAAE,EAAE,CAAC;YAC5D,MAAM,KAAK,GAAG,QAAQ,GAAG,OAAO,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;YAC9C,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;YAC7C,IAAI,MAAM,KAAK,SAAS;gBAAE,OAAO,MAAM,CAAC;QAC1C,CAAC;IACH,CAAC;IACD,MAAM,IAAI,KAAK,CACb,uBAAuB,KAAK,CAAC,MAAM,4BAA4B;QAC7D,oEAAoE,CACvE,CAAC;AACJ,CAAC;AAgBD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,iCAAiC,CAC/C,GAAqB,EACrB,kBAA0B,EAC1B,UAAkB;IAElB,MAAM,GAAG,GAAG,eAAe,CAAC,GAAG,EAAE,kBAAkB,CAAC,CAAC,KAAK,EAAE,CAAC;IAC7D,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,gBAAgB,kBAAkB,eAAe,CAAC,CAAC;IACrE,CAAC;IACD,MAAM,aAAa,GAAgC,IAAI,GAAG,EAAE,CAAC;IAC7D,KAAK,MAAM,GAAG,IAAI,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC;QAC7B,gEAAgE;QAChE,MAAM,SAAS,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;QAC1D,MAAM,IAAI,GAAG,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;QACpC,IAAI,IAAI,KAAK,SAAS;YAAE,SAAS;QACjC,aAAa,CAAC,GAAG,CACf,YAAY,CAAC,SAAS,CAAC,EACvB,4BAA4B,CAAC,IAAI,CAAC,KAAK,CAAC,CACzC,CAAC;IACJ,CAAC;IAED,MAAM,SAAS,GAAG,eAAe,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC,MAAM,EAAE,CAAC;IAC5D,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;QAC5B,MAAM,IAAI,KAAK,CAAC,gBAAgB,UAAU,gBAAgB,CAAC,CAAC;IAC9D,CAAC;IACD,MAAM,KAAK,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;IAElD,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,CAAC;AAClC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,qBAAqB,CACnC,GAAqB,EACrB,UAAkB,EAClB,SAAuB;IAEvB,IAAI,IAAI,CAAC;IACT,IAAI,CAAC;QACH,IAAI,GAAG,eAAe,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;IAC1C,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC,CAAC,gDAAgD;IACpE,CAAC;IACD,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;IACzB,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACtB,OAAO,SAAS,CAAC,CAAC,yCAAyC;IAC7D,CAAC;IACD,KAAK,MAAM,GAAG,IAAI,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC;QAC7B,gEAAgE;QAChE,IAAI,YAAY,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;YACxE,SAAS;QACX,CAAC;QACD,MAAM,IAAI,GAAG,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;QACpC,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,IAAI,CAAC;YACH,OAAO,4BAA4B,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAClD,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,SAAS,CAAC,CAAC,gDAAgD;QACpE,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC,CAAC,2BAA2B;AAC/C,CAAC"}

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

@@ -1,5 +1,5 @@
-import { type SignBidirectionalRequest } from "./signet-requests.ts";
-import type { SignatureResponse } from "./signet-contract-state-reader.ts";
+import { type SignBidirectionalEvent } from "./signet-requests.ts";
+import type { SignatureRespondedEvent } 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.
@@ -9,9 +9,9 @@ import type { SignatureResponse } from "./signet-contract-state-reader.ts";
  * @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}).
+ *   {@link signBidirectionalEventToUnsignedEVMTransaction}).
  */
-export declare function recoverSignatureResponseSigner(request: SignBidirectionalRequest, response: SignatureResponse): string;
+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
@@ -23,5 +23,5 @@ export declare function recoverSignatureResponseSigner(request: SignBidirectiona
  * @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;
+export declare function verifySignatureRespondedEvent(request: SignBidirectionalEvent, response: SignatureRespondedEvent, expectedSigner: string): boolean;
 //# sourceMappingURL=signature-response-verification.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"signature-response-verification.d.ts","sourceRoot":"","sources":["../src/signature-response-verification.ts"],"names":[],"mappings":"AAWA,OAAO,EAGL,KAAK,sBAAsB,EAC5B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AAEjF;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,sBAAsB,EAC/B,QAAQ,EAAE,uBAAuB,GAChC,MAAM,CAKR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,sBAAsB,EAC/B,QAAQ,EAAE,uBAAuB,EACjC,cAAc,EAAE,MAAM,GACrB,OAAO,CAST"}

package/dist/signature-response-verification.js

@@ -7,7 +7,7 @@
 // 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";
+import { signBidirectionalEventToUnsignedEVMTransaction, signatureRespondedEventToSignature, } from "./signet-requests.js";
 /**
  * Recover the EVM address that produced a response signature, over the
  * signing hash of the transaction the request describes.
@@ -17,10 +17,10 @@ import { signBidirectionalRequestToUnsignedEVMTransaction, signatureResponseToSi
  * @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}).
+ *   {@link signBidirectionalEventToUnsignedEVMTransaction}).
  */
 export function recoverSignatureResponseSigner(request, response) {
-    return recoverAddress(signBidirectionalRequestToUnsignedEVMTransaction(request).unsignedHash, signatureResponseToSignature(response));
+    return recoverAddress(signBidirectionalEventToUnsignedEVMTransaction(request).unsignedHash, signatureRespondedEventToSignature(response));
 }
 /**
  * Verify a posted response against its request: does the signature recover
@@ -33,7 +33,7 @@ export function recoverSignatureResponseSigner(request, response) {
  * @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) {
+export function verifySignatureRespondedEvent(request, response, expectedSigner) {
     try {
         return (recoverSignatureResponseSigner(request, response) ===
             getAddress(expectedSigner));

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,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"}
+{"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,8CAA8C,EAC9C,kCAAkC,GAEnC,MAAM,sBAAsB,CAAC;AAG9B;;;;;;;;;;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

@@ -1,24 +1,25 @@
 import { type CompactType } from "@midnight-ntwrk/compact-runtime";
 import { type RequestId, type RequestIdHex } from "./signet-requests.ts";
 import { type RawContractState } from "./signature-state-reading.ts";
-/** Signet contract layout: the signature response counter index is ledger field 0. */
-export declare const SIGNATURE_RESPONSE_COUNTER_INDEX_FIELD = 0;
-/** Signet contract layout: the signature response log is ledger field 1. */
-export declare const SIGNATURE_RESPONSE_INDEX_FIELD = 1;
-/** Signet contract layout: the respond-bidirectional index is ledger field 2. */
-export declare const RESPOND_BIDIRECTIONAL_INDEX_FIELD = 2;
-/** Signet contract layout: the sealed MPC attestation key hash is ledger field 3. */
-export declare const MPC_PUB_KEY_HASH_FIELD = 3;
-/** Signet contract layout: the request notification registry is ledger field 4. */
-export declare const SIGN_BIDIRECTIONAL_NOTIFICATION_INDEX_FIELD = 4;
+/** Signet contract layout: the notification counter map is ledger field 0. */
+export declare const SIGN_BIDIRECTIONAL_EVENT_NOTIFICATION_COUNTER_MAP_FIELD = 0;
+/** Signet contract layout: the notification map is ledger field 1. */
+export declare const SIGN_BIDIRECTIONAL_EVENT_NOTIFICATION_MAP_FIELD = 1;
+/** Signet contract layout: the signature response counter map is ledger field 2. */
+export declare const SIGNATURE_RESPONSE_COUNTER_MAP_FIELD = 2;
+/** Signet contract layout: the signature response map is ledger field 3. */
+export declare const SIGNATURE_RESPONSE_MAP_FIELD = 3;
+/** Signet contract layout: the respond-bidirectional counter map is ledger field 4. */
+export declare const RESPOND_BIDIRECTIONAL_COUNTER_MAP_FIELD = 4;
+/** Signet contract layout: the respond-bidirectional map is ledger field 5. */
+export declare const RESPOND_BIDIRECTIONAL_MAP_FIELD = 5;
 /**
  * The MPC's secp256k1 signature over the requested EVM transaction (Compact
- * `SignatureResponse` — the canonical MPC `Signature { big_r, s,
+ * `SignatureRespondedEvent` — the canonical MPC `Signature { big_r, s,
  * recovery_id }` with `big_r` decomposed into affine coordinates, big-endian
- * scalar bytes). The request id it answers lives in the response index key,
- * not here.
+ * scalar bytes). The request id it answers lives in the map key, not here.
  */
-export interface SignatureResponse {
+export interface SignatureRespondedEvent {
     /** Signature R.x, 32 big-endian bytes. */
     bigRx: Uint8Array;
     /** Signature R.y, 32 big-endian bytes. */
@@ -29,62 +30,59 @@ export interface SignatureResponse {
     recoveryId: bigint;
 }
 /**
- * Hand-composed descriptor for {@link SignatureResponse}. Field
+ * Hand-composed descriptor for {@link SignatureRespondedEvent}. Field
  * order (bigRx, bigRy, s, recoveryId) must match the Compact struct.
  */
-export declare const signatureResponseType: CompactType<SignatureResponse>;
+export declare const signatureRespondedEventType: CompactType<SignatureRespondedEvent>;
 /**
- * The MPC's respond-bidirectional attestation of a request's remote EVM
- * execution (Compact `RespondBidirectional`): the serialized execution output
- * plus the secp256k1 ECDSA signature over the attestation digest
- * `signetAttestationMessage(requestId, serializedOutput, outputLen)`. Stored
- * records were verified IN-CIRCUIT by the signet contract at post time, so
- * readers can trust them without re-verifying. The signing public key is not
- * stored here — it is pinned by hash against the sealed MPC key.
+ * 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)`. Stored UNVERIFIED by the signet
+ * contract — clients verify it themselves (in-circuit via
+ * `verifyRespondBidirectionalEvent`, or off-chain via the compiled
+ * `pureCircuits.verifyRespondBidirectionalEvent`).
  */
-export interface RespondBidirectional {
+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;
-    /**
-     * ECDSA signature scalar r as 32 LITTLE-ENDIAN bytes (the byte order the
-     * `Secp256k1Scalar as Bytes<32>` cast produces; recover the scalar with
-     * `bytesToBigint`).
-     */
-    sigR: Uint8Array;
-    /** ECDSA signature scalar s as 32 little-endian bytes (see {@link sigR}). */
-    sigS: Uint8Array;
+    /** Signature scalar r (= R.x mod n), 32 LITTLE-endian bytes (the `Secp256k1Scalar as Bytes<32>` cast). */
+    r: Uint8Array;
+    /** Signature scalar s, 32 LITTLE-endian bytes. */
+    s: Uint8Array;
+    /** Recovery id (parity of R.y), for off-chain public-key recovery. */
+    recoveryId: bigint;
 }
 /**
- * Composite key of one posted signature response (Compact
- * `SignetResponseKey`): the request id it answers plus this post's 0-based
+ * 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
  * struct.
  */
-export interface SignetResponseKey {
-    /** 0-based position of this post among the responses for {@link requestId}. */
+export interface SignetMapKey {
+    /** 0-based position of this post among the entries for {@link requestId}. */
     count: bigint;
-    /** 32-byte id of the request this response answers. */
+    /** 32-byte id of the request this entry belongs to. */
     requestId: RequestId;
 }
 /**
- * Hand-composed descriptor for {@link SignetResponseKey} — the map key of
- * the signature response log. Field order (count, then requestId) must match
- * the Compact struct.
+ * 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 signetResponseKeyType: CompactType<SignetResponseKey>;
+export declare const signetMapKeyType: CompactType<SignetMapKey>;
 /**
- * Hand-composed descriptor for {@link RespondBidirectional}. Field
- * order (serializedOutput, outputLen, sigR, sigS) must match the Compact
- * struct — the signature scalars are stored as `Bytes<32>`, not
- * `Secp256k1Scalar`.
+ * Hand-composed descriptor for {@link RespondBidirectionalEvent}. Field
+ * order (serializedOutput, outputLen, r, s, recoveryId) must match the
+ * Compact struct.
  */
-export declare const respondBidirectionalType: CompactType<RespondBidirectional>;
+export declare const respondBidirectionalEventType: CompactType<RespondBidirectionalEvent>;
 /**
- * Raw twin of the Compact `SignBidirectionalNotification` struct as stored
- * on-ledger: the version tag plus the still-packed 65-byte payload. Decode
- * the payload with {@link decodeSignBidirectionalNotification}.
+ * Raw twin of the Compact `SignBidirectionalEventNotification` struct as
+ * stored on-ledger: the version tag plus the still-packed 128-byte payload.
+ * Decode the payload with {@link decodeSignBidirectionalNotification}.
  */
 export interface SignBidirectionalNotificationRecord {
     /** Payload layout tag (Compact `Uint<8>`); 1 = the V1 layout. */
@@ -100,35 +98,35 @@ export declare const signBidirectionalNotificationType: CompactType<SignBidirect
 /**
  * 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
- * WHERE to read the authenticated copy. Never trusted on its own: the
- * resolver authenticates by reading the request back from
+ * 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. */
     version: number;
     /**
-     * Address of the contract whose request index holds the request, rendered
+     * Address of the contract whose request map holds the request, rendered
      * 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.
      */
     callerAddress: string;
-    /** Which request in {@link callerAddress}'s index this notification is about. */
-    requestId: RequestIdHex;
     /**
-     * Ledger field position of the `Map<RequestId, SignBidirectionalRequest>`
-     * request index in {@link callerAddress} (the signet layout convention puts
-     * it at field 0, but the notification carries it so the reader never assumes).
+     * Ledger field position of the `SignBidirectionalEventMap` in
+     * {@link callerAddress} (the caller contract in this repo declares it at
+     * field 4, but the notification carries it so the reader never assumes).
      */
     requestsIndexField: number;
 }
 /**
  * Unpack a stored {@link SignBidirectionalNotificationRecord}'s payload by
  * the fixed V1 offsets — the decode twin of the compiled
- * `constructSignBidirectionalNotificationV1` circuit (byte plumbing only; the
- * pack↔decode lockstep is pinned by the state-reader unit test that round-trips
- * through the real circuit).
+ * `constructSignBidirectionalEventNotificationV1` circuit (byte plumbing
+ * 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).
  *
  * Fails closed on an unrecognised `version`: a future payload layout adds a
  * branch here rather than silently misinterpreting bytes under the V1 offsets.
@@ -140,92 +138,83 @@ export interface SignBidirectionalNotification {
 export declare function decodeSignBidirectionalNotification(record: SignBidirectionalNotificationRecord): SignBidirectionalNotification;
 /**
  * Plain-JS notification registry parsed out of the ledger: hex request id
- * (the map KEY under which the notification was registered) to the raw
- * stored record. Decode each record with
+ * (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
+ * registered. Decode each record with
  * {@link decodeSignBidirectionalNotification}.
  */
 export type SignBidirectionalNotificationIndex = Map<RequestIdHex, SignBidirectionalNotificationRecord>;
 /**
- * Plain-JS signature response counter index parsed out of the ledger: hex
- * request id (see {@link requestIdHex}) to the number of responses posted for
- * that request. Entries in the response log exist for counts `0 .. value - 1`.
+ * Plain-JS counter map parsed out of the ledger: hex request id (see
+ * {@link requestIdHex}) to the number of entries posted for that request.
+ * Entries in the corresponding map exist for counts `0 .. value - 1`.
  */
-export type SignatureResponseCounterIndex = Map<RequestIdHex, bigint>;
+export type SignetCounterIndex = Map<RequestIdHex, bigint>;
 /**
  * Plain-JS signature response log parsed out of the ledger, keyed by
- * {@link signetResponseIndexKey} (`"<hexRequestId>:<count>"`) so the
- * composite Compact key survives as a usable JS `Map` key.
+ * {@link signetMapEntryKey} (`"<hexRequestId>:<count>"`) so the composite
+ * Compact key survives as a usable JS `Map` key.
  */
-export type SignatureResponseIndex = Map<string, SignatureResponse>;
+export type SignatureResponseIndex = Map<string, SignatureRespondedEvent>;
 /**
- * Plain-JS respond-bidirectional index parsed out of the ledger: hex
- * request id to the contract-verified attestation. One slot per request.
+ * Plain-JS respond-bidirectional log parsed out of the ledger, keyed by
+ * {@link signetMapEntryKey} (`"<hexRequestId>:<count>"`).
  */
-export type RespondBidirectionalIndex = Map<RequestIdHex, RespondBidirectional>;
+export type RespondBidirectionalIndex = Map<string, RespondBidirectionalEvent>;
 /**
- * Build the {@link SignatureResponseIndex} key for a `(requestId, count)`
- * pair — the composite Compact key flattened to a string so it works as a JS
+ * 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.
  *
- * @param id - The request id the response answers, in canonical hex form.
+ * @param id - The request id the entry belongs to, in canonical hex form.
  * @param count - 0-based post count within that request.
  * @returns `"<hexRequestId>:<count>"`.
  */
-export declare function signetResponseIndexKey(id: RequestIdHex, count: bigint): string;
+export declare function signetMapEntryKey(id: RequestIdHex, count: bigint): string;
 /**
  * Read ONLY the notification registry (ledger field
- * {@link SIGN_BIDIRECTIONAL_NOTIFICATION_INDEX_FIELD}) out of raw signet
+ * {@link SIGN_BIDIRECTIONAL_EVENT_NOTIFICATION_MAP_FIELD}) out of raw signet
  * contract state — the poll-loop primitive of {@link SignetRequestFeed},
- * which cycles frequently and has no use for the response fields.
+ * which cycles frequently and has no use for the response fields. One record
+ * per request id (the count-0 post; see
+ * {@link SignBidirectionalNotificationIndex}).
  *
  * @param raw - Raw contract state, e.g. `queryContractState(address).data`
  *   from the indexer or `ctx.currentQueryContext.state` from the simulator.
- * @returns The registry, keyed by the hex request id each record was
- *   registered under.
+ * @returns The registry, keyed by the hex request id of each entry's map key.
  * @throws Error if the field is missing or is not a Map.
  */
 export declare function readSignBidirectionalNotificationIndexFromState(raw: RawContractState): SignBidirectionalNotificationIndex;
 /**
- * The decoded ledger fields of the signet contract: the signature response
- * counter (field 0) and log (field 1), the respond-bidirectional index
- * (field 2), the sealed MPC attestation key hash (field 3), and the request
- * notification registry (field 4). Together they give a poller everything
- * the contract ever records about a request.
+ * The decoded ledger fields of the signet contract: the three
+ * (counter map, entry map) pairs — 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.
  */
 export interface SignetContractLedger {
+    /** Notification post counts per request id (ledger field 0). */
+    signBidirectionalEventNotificationCounterMap: SignetCounterIndex;
     /**
-     * The signature response counter index (ledger field
-     * {@link SIGNATURE_RESPONSE_COUNTER_INDEX_FIELD}), keyed by hex request id.
-     */
-    signatureResponseCounterIndex: SignatureResponseCounterIndex;
-    /**
-     * The signature response log (ledger field
-     * {@link SIGNATURE_RESPONSE_INDEX_FIELD}), keyed by
-     * {@link signetResponseIndexKey}.
-     */
-    signatureResponseIndex: SignatureResponseIndex;
-    /**
-     * The respond-bidirectional index (ledger field
-     * {@link RESPOND_BIDIRECTIONAL_INDEX_FIELD}), keyed by hex request id.
-     */
-    respondBidirectionalIndex: RespondBidirectionalIndex;
-    /**
-     * The sealed MPC attestation key hash (ledger field
-     * {@link MPC_PUB_KEY_HASH_FIELD}) posts are verified against.
-     */
-    mpcPubKeyHash: Uint8Array;
-    /**
-     * The request notification registry (ledger field
-     * {@link SIGN_BIDIRECTIONAL_NOTIFICATION_INDEX_FIELD}), keyed by hex
-     * request id.
+     * The notification registry (ledger field 1), one record per request id
+     * (count-0 post).
      */
-    signBidirectionalNotificationIndex: SignBidirectionalNotificationIndex;
+    signBidirectionalEventNotificationMap: SignBidirectionalNotificationIndex;
+    /** Signature response post counts per request id (ledger field 2). */
+    signatureResponseCounterMap: SignetCounterIndex;
+    /** The signature response log (ledger field 3), keyed by {@link signetMapEntryKey}. */
+    signatureResponseMap: SignatureResponseIndex;
+    /** Respond-bidirectional post counts per request id (ledger field 4). */
+    respondBidirectionalCounterMap: SignetCounterIndex;
+    /** The respond-bidirectional log (ledger field 5), keyed by {@link signetMapEntryKey}. */
+    respondBidirectionalMap: RespondBidirectionalIndex;
 }
 /**
  * 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 signet contract layout convention and the
- * canonical descriptors above.
+ * 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.