@sig-net/midnight 0.10.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

@@ -4,22 +4,22 @@ import { type RawContractState } from "./signature-state-reading.ts";
  * 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
+ * whatever their byte width) + the EvmType2TxParams fixed fields
+ * (chainId..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).
+ * 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.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signature-requests-state-reader.d.ts","sourceRoot":"","sources":["../src/signature-requests-state-reader.ts"],"names":[],"mappings":"AAgBA,OAAO,EAEL,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"}
+{"version":3,"file":"signature-requests-state-reader.d.ts","sourceRoot":"","sources":["../src/signature-requests-state-reader.ts"],"names":[],"mappings":"AAmBA,OAAO,EAEL,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;AA6F5C;;;;;;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,CAqBtB;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

@@ -1,59 +1,61 @@
 // 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 { signBidirectionalEventDescriptor } from "./signet-evtype2tx-requests.js";
+import { calculateRequestId, signBidirectionalEventDescriptor, } from "./signet-evtype2tx-requests.js";
 import { requestIdHex, } from "./signet-requests.js";
 import { requestIdType, signetFieldNode, u64, } from "./signature-state-reading.js";
 /**
  * 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
+ * whatever their byte width) + the EvmType2TxParams fixed fields
+ * (chainId..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).
+ * 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.
  *
  * @param atoms - The record cell's aligned value (a fresh copy per attempt).
+ * @param expectedRequestId - The id the record is stored under, used to pick
+ *   between splits when more than one decodes cleanly.
  * @returns The decoded record.
  * @throws Error if no capacity split decodes the value cleanly.
  */
-function decodeSignBidirectionalEvent(atoms) {
+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;
@@ -69,31 +71,46 @@ function decodeSignBidirectionalEvent(atoms) {
             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 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.
+    // `fallback` preserves the pre-recompute behaviour when no split matches the id.
+    let fallback;
+    const take = (record) => {
+        if (record === undefined)
+            return false;
+        fallback ??= record;
+        return requestIdHex(calculateRequestId(record)) === expectedRequestId;
+    };
     // No access list: variable atoms are calldata words alone (one atom each).
-    {
-        const record = attempt(variable, 0, 0);
-        if (record !== undefined)
-            return record;
-    }
+    const accessListFree = attempt(variable, 0, 0);
+    if (take(accessListFree))
+        return accessListFree;
     // 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)
+            if (take(record))
                 return record;
         }
     }
-    throw new Error(`request record with ${atoms.length} value entries matches no ` +
-        `(calldata words, access-list entries, storage keys) capacity split`);
+    if (fallback === undefined) {
+        throw new Error(`request record with ${atoms.length} value entries matches no ` +
+            `(calldata words, access-list entries, storage keys) capacity split`);
+    }
+    return fallback;
 }
 /**
  * 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`
@@ -112,11 +129,11 @@ export function readSignetRequestsLedgerFromState(raw, requestsIndexField, nonce
     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 requestId = requestIdHex(requestIdType.fromValue([...key.value]));
         const cell = map.get(key)?.asCell();
         if (cell === undefined)
             continue;
-        requestsIndex.set(requestIdHex(requestId), decodeSignBidirectionalEvent(cell.value));
+        requestsIndex.set(requestId, decodeSignBidirectionalEvent(cell.value, requestId));
     }
     const nonceCell = signetFieldNode(raw, nonceField).asCell();
     if (nonceCell === undefined) {
@@ -127,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)`.
@@ -172,7 +189,7 @@ export function lookupSignetRequestAt(raw, fieldIndex, requestId) {
             return undefined;
         }
         try {
-            return decodeSignBidirectionalEvent(cell.value);
+            return decodeSignBidirectionalEvent(cell.value, requestId);
         }
         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":"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"}

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

@@ -9,12 +9,12 @@ import type { SignatureRespondedEvent } 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 signBidirectionalEventToUnsignedEVMTransaction}).
+ *   {@link signBidirectionalEventToUnsignedEvmTransaction}).
  */
 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,12 +2,12 @@
 // 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.
+// 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";
-import { signBidirectionalEventToUnsignedEVMTransaction, signatureRespondedEventToSignature, } from "./signet-evtype2tx-requests.js";
+import { signBidirectionalEventToUnsignedEvmTransaction, signatureRespondedEventToSignature, } from "./signet-evtype2tx-requests.js";
 /**
  * Recover the EVM address that produced a response signature, over the
  * signing hash of the transaction the request describes.
@@ -17,14 +17,14 @@ import { signBidirectionalEventToUnsignedEVMTransaction, signatureRespondedEvent
  * @returns The checksummed recovered signer address.
  * @throws Error if the response is not a decodable signature or the request
  *   record is malformed (see
- *   {@link signBidirectionalEventToUnsignedEVMTransaction}).
+ *   {@link signBidirectionalEventToUnsignedEvmTransaction}).
  */
 export function recoverSignatureResponseSigner(request, response) {
-    return recoverAddress(signBidirectionalEventToUnsignedEVMTransaction(request).unsignedHash, signatureRespondedEventToSignature(response));
+    return recoverAddress(signBidirectionalEventToUnsignedEvmTransaction(request).unsignedHash, signatureRespondedEventToSignature(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,4EAA4E;AAC5E,wEAAwE;AAExE,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

@@ -5,60 +5,77 @@ import { type RawContractState } from "./signature-state-reading.ts";
 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` counter map is ledger field 2. */
+export declare const RESPOND_COUNTER_MAP_FIELD = 2;
+/** Signet contract layout: the `respond` post log is ledger field 3. */
+export declare const RESPOND_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
- * `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 map key, not here.
+ * A curve point in affine coordinates (Compact `AffinePoint`), SEC1
+ * big-endian, the same shape the sig-net EVM and Solana signer contracts
+ * expose.
  */
-export interface SignatureRespondedEvent {
-    /** Signature R.x, 32 big-endian bytes. */
-    bigRx: Uint8Array;
-    /** Signature R.y, 32 big-endian bytes. */
-    bigRy: Uint8Array;
-    /** Signature s, 32 big-endian bytes. */
+export interface AffinePoint {
+    /** The x coordinate, 32 big-endian bytes. */
+    x: Uint8Array;
+    /** The y coordinate, 32 big-endian bytes. */
+    y: Uint8Array;
+}
+/**
+ * The MPC's canonical ECDSA signature as both respond events store it
+ * (Compact `Signature`, matching the MPC's own
+ * `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
+ * `ecdsaSignatureToMpcSignature` / `mpcSignatureToEcdsaSignature`.
+ */
+export interface MpcSignature {
+    /** The signature's nonce point R. */
+    bigR: AffinePoint;
+    /** Signature scalar s, 32 big-endian bytes. */
     s: Uint8Array;
-    /** Parity of R.y for public-key recovery (0 or 1). */
+    /** Recovery id (parity of R.y): 0 or 1. */
     recoveryId: bigint;
 }
 /**
- * Hand-composed descriptor for {@link SignatureRespondedEvent}. Field
- * order (bigRx, bigRy, s, recoveryId) must match the Compact struct.
+ * The MPC's signature over the requested EVM transaction (Compact
+ * `SignatureRespondedEvent`): decode to an ethers signature with
+ * `signatureRespondedEventToSignature`. The request id it answers lives in
+ * the map key.
+ */
+export interface SignatureRespondedEvent {
+    /** The requested signature over the transaction the request describes. */
+    signature: MpcSignature;
+}
+/**
+ * Hand-composed descriptor for {@link SignatureRespondedEvent}: the single
+ * {@link MpcSignature} field, matching the Compact struct.
  */
 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)`. 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;
-    /** 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;
+    /** 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 {
@@ -68,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, r, s, recoveryId) must match the
- * Compact struct.
+ * order (attestationDigest, signature) must match the Compact struct.
  */
 export declare const respondBidirectionalEventType: CompactType<RespondBidirectionalEvent>;
 /**
@@ -85,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;
@@ -97,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;
     /**
@@ -122,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).
  *
@@ -139,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}.
  */
@@ -163,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.
  *
@@ -175,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`
@@ -188,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.
@@ -201,10 +217,10 @@ export interface SignetContractLedger {
      * (count-0 post).
      */
     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` post counts per request id (ledger field 2). */
+    respondCounterMap: SignetCounterIndex;
+    /** The `respond` post log (ledger field 3), keyed by {@link signetMapEntryKey}. */
+    respondMap: SignatureResponseIndex;
     /** Respond-bidirectional post counts per request id (ledger field 4). */
     respondBidirectionalCounterMap: SignetCounterIndex;
     /** The respond-bidirectional log (ledger field 5), keyed by {@link signetMapEntryKey}. */
@@ -212,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.