@sig-net/midnight 0.19.0 → 0.21.0-rc.1

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/raw-contract-state.d.ts

@@ -0,0 +1,25 @@
+import type { StateValue } from "@midnight-ntwrk/compact-runtime";
+/**
+ * What the indexer / simulator hands us: a bare `StateValue`, or anything
+ * wrapping one under `.state` (e.g. `ChargedState`,
+ * `queryContractState(address).data`).
+ */
+export type RawContractState = StateValue | {
+    state: StateValue;
+};
+/**
+ * Follow a resolved ledger-tree path to its node in raw state: the
+ * MPC-perspective primitive, given only a contract's raw state and the path
+ * a notification carries. The path is the value compactc records for a
+ * field in the client's own `contract-info.json` (`"index"`): a
+ * single-element path (`[4]`) for a flat contract's field, a longer one
+ * (`[1, 14]`) once the compiler stores fields in a chunk tree.
+ *
+ * @param raw - Raw contract state from the indexer or simulator.
+ * @param path - Resolved chunk-tree path in declaration order.
+ * @returns The `StateValue` node at the end of the path.
+ * @throws {Error} If `path` is empty, steps into a non-array, an index is out
+ *   of range, or the runtime binding misreports a node as an array.
+ */
+export declare function signetFieldNodeByPath(raw: RawContractState, path: readonly number[]): StateValue;
+//# sourceMappingURL=raw-contract-state.d.ts.map

package/dist/raw-contract-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raw-contract-state.d.ts","sourceRoot":"","sources":["../src/raw-contract-state.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAElE;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG;IAAE,KAAK,EAAE,UAAU,CAAA;CAAE,CAAC;AAUlE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,gBAAgB,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,UAAU,CA+BhG"}

package/dist/raw-contract-state.js

@@ -0,0 +1,52 @@
+// Raw contract state and the walk over it: the state shape every signet
+// reader accepts, and the resolved ledger-tree path walk that finds a
+// contract's ledger fields in it.
+/**
+ * Unwrap a {@link RawContractState} to the underlying `StateValue`.
+ *
+ * @param raw - Bare state value or a `.state`-carrying wrapper.
+ * @returns The bare `StateValue`.
+ */
+const unwrap = (raw) => ("state" in raw ? raw.state : raw);
+/**
+ * Follow a resolved ledger-tree path to its node in raw state: the
+ * MPC-perspective primitive, given only a contract's raw state and the path
+ * a notification carries. The path is the value compactc records for a
+ * field in the client's own `contract-info.json` (`"index"`): a
+ * single-element path (`[4]`) for a flat contract's field, a longer one
+ * (`[1, 14]`) once the compiler stores fields in a chunk tree.
+ *
+ * @param raw - Raw contract state from the indexer or simulator.
+ * @param path - Resolved chunk-tree path in declaration order.
+ * @returns The `StateValue` node at the end of the path.
+ * @throws {Error} If `path` is empty, steps into a non-array, an index is out
+ *   of range, or the runtime binding misreports a node as an array.
+ */
+export function signetFieldNodeByPath(raw, path) {
+    if (path.length === 0) {
+        throw new Error("Ledger field path is empty");
+    }
+    let node = unwrap(raw);
+    for (const [level, index] of path.entries()) {
+        if (node.type() !== "array") {
+            // A one-field contract stores its field as the bare (non-array) root,
+            // addressable only as the whole state at a final [0]. The compiled
+            // accessor reads it the same way.
+            if (index === 0 && level === path.length - 1)
+                return node;
+            throw new Error(`Ledger field path ${JSON.stringify(path)} steps into a non-array at level ${String(level)}`);
+        }
+        const entries = node.asArray();
+        if (entries === undefined) {
+            throw new Error(`Ledger state node at level ${String(level)} of path ${JSON.stringify(path)} reports ` +
+                `type "array" but asArray() returned undefined: runtime binding contract violation`);
+        }
+        const next = entries[index];
+        if (next === undefined) {
+            throw new Error(`Ledger field path ${JSON.stringify(path)} index ${String(index)} out of range at level ${String(level)}`);
+        }
+        node = next;
+    }
+    return node;
+}
+//# sourceMappingURL=raw-contract-state.js.map

package/dist/raw-contract-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"raw-contract-state.js","sourceRoot":"","sources":["../src/raw-contract-state.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,sEAAsE;AACtE,kCAAkC;AAWlC;;;;;GAKG;AACH,MAAM,MAAM,GAAG,CAAC,GAAqB,EAAc,EAAE,CAAC,CAAC,OAAO,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AAEzF;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,qBAAqB,CAAC,GAAqB,EAAE,IAAuB;IAClF,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;IAChD,CAAC;IACD,IAAI,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IACvB,KAAK,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;QAC5C,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,OAAO,EAAE,CAAC;YAC5B,sEAAsE;YACtE,mEAAmE;YACnE,kCAAkC;YAClC,IAAI,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,IAAI,CAAC,MAAM,GAAG,CAAC;gBAAE,OAAO,IAAI,CAAC;YAC1D,MAAM,IAAI,KAAK,CACb,qBAAqB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,oCAAoC,MAAM,CAAC,KAAK,CAAC,EAAE,CAC7F,CAAC;QACJ,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC/B,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CACb,8BAA8B,MAAM,CAAC,KAAK,CAAC,YAAY,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW;gBACpF,mFAAmF,CACtF,CAAC;QACJ,CAAC;QACD,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;QAC5B,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CACb,qBAAqB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,MAAM,CAAC,KAAK,CAAC,0BAA0B,MAAM,CAAC,KAAK,CAAC,EAAE,CAC1G,CAAC;QACJ,CAAC;QACD,IAAI,GAAG,IAAI,CAAC;IACd,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

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

@@ -1,25 +1,9 @@
+import { type RawContractState } from "./raw-contract-state.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 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
- * (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, 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 the
- * counter: it is decoded here only because both fields travel together in
- * tests and diagnostics.
+ * source of each request's `requestNonce`.
  */
 export interface SignetRequestsLedger {
     /** The request counter (`Counter`). */
@@ -29,47 +13,37 @@ export interface SignetRequestsLedger {
 }
 /**
  * MPC-style read: parse the signet ledger fields out of raw contract state
- * 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, and a notification names the index position of the
- * contract it points at).
+ * by caller-supplied field positions. A contract chooses its own layout, so
+ * the caller must know where the fields sit.
+ *
+ * Records are decoded, not verified against the ids they are filed under:
+ * {@link lookupSignetRequestAt} is the verified lookup.
  *
  * @param raw - Raw contract state, e.g. `queryContractState(address).data`
  *   from the indexer or `ctx.currentQueryContext.state` from the simulator.
  * @param requestsIndexPath - Resolved ledger-tree path of the request index.
  * @param noncePath - Resolved ledger-tree path of the request counter.
  * @returns The decoded {@link SignetRequestsLedger}.
- * @throws Error if a field is missing, has the wrong state-value shape, or a
- *   record matches no capacity split.
+ * @throws {Error} If a field is missing, has the wrong state-value shape, or a
+ *   record is not a decodable evmType2 request record.
  */
 export declare function readSignetRequestsLedgerFromState(raw: RawContractState, requestsIndexPath: readonly number[], noncePath: readonly number[]): SignetRequestsLedger;
 /**
  * Look up ONE request by id in a contract's request index at an arbitrary
- * ledger field, the single-record sibling of
- * {@link readSignetRequestsLedgerFromState}: the discovery primitive of the
- * event-based feed and what a point verification uses. A notification
- * declares the stored request's id and names both the requester contract
- * AND which field holds its index.
- *
- * `undefined` means the id is NOT a member of the index at `requestsPath`
- * (the pointer 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, 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)`.
+ * ledger field: the single-record sibling of
+ * {@link readSignetRequestsLedgerFromState} and the discovery primitive of
+ * the event-based feed. The recompute-and-drop gate: the decode never sees
+ * the id, so the final recompute is the only thing binding a record's
+ * contents to the key it was filed under, and a mismatch (a spoofed or
+ * wrongly filed record) is dropped. Every non-membership case returns
+ * `undefined` rather than throwing, and the caller MUST drop such a pointer.
  *
  * @param raw - Raw contract state, e.g. `queryContractState(address).data`.
  * @param requestsPath - Resolved ledger-tree path of the request index in
  *   `raw`, as the notification carries it.
  * @param requestId - The request id to look up.
- * @returns The stored request record, or `undefined` when it is not a member.
+ * @returns The stored, id-verified request record, or `undefined` when it is
+ *   not a member.
  */
 export declare function lookupSignetRequestAt(raw: RawContractState, requestsPath: readonly 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":"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,iBAAiB,EAAE,SAAS,MAAM,EAAE,EACpC,SAAS,EAAE,SAAS,MAAM,EAAE,GAC3B,oBAAoB,CAqBtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,gBAAgB,EACrB,YAAY,EAAE,SAAS,MAAM,EAAE,EAC/B,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":"AAcA,OAAO,EAAE,KAAK,gBAAgB,EAAyB,MAAM,yBAAyB,CAAC;AAGvF,OAAO,EAEL,KAAK,YAAY,EAGjB,KAAK,sBAAsB,EAC3B,KAAK,2BAA2B,EAEjC,MAAM,sBAAsB,CAAC;AAwC9B;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,uCAAuC;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,aAAa,EAAE,2BAA2B,CAAC;CAC5C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iCAAiC,CAC/C,GAAG,EAAE,gBAAgB,EACrB,iBAAiB,EAAE,SAAS,MAAM,EAAE,EACpC,SAAS,EAAE,SAAS,MAAM,EAAE,GAC3B,oBAAoB,CAoBtB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,gBAAgB,EACrB,YAAY,EAAE,SAAS,MAAM,EAAE,EAC/B,SAAS,EAAE,YAAY,GACtB,sBAAsB,GAAG,SAAS,CA+BpC"}

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

@@ -1,125 +1,67 @@
-// MPC-style raw state reader for the signature-REQUESTS side: decode the signet
-// request ledger fields out of a contract's raw state WITHOUT the compiled
-// contract. This is how the MPC monitor consumes signet contracts: it has only
-// a contract address, queries raw state from the indexer
-// (queryContractState(address).data), and decodes by ledger-tree PATH.
-// A contract is free to place its request index at any field: the caller
-// supplies the resolved path, which the discovery path learns from the
-// notification's requestsPath (sourced from the caller's contract-info.json).
-// The compiled contract's generated ledger() follows exactly this path 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";
-import { requestIdHex, } from "./signet-requests.js";
-import { requestIdType, signetFieldNodeByPath, u64, } from "./signature-state-reading.js";
+// MPC-style raw state reader for the signature-REQUESTS side: read the
+// signet request ledger fields out of a contract's raw state by resolved
+// ledger-tree path, as the MPC monitor and the event feed consume signet
+// contracts. The generic tree walk lives in raw-contract-state.ts and the
+// per-decomposition record decoding in signet-evtype2tx-record-decoding.ts.
+//
+// The read algorithm is the TS twin of the MPC's Rust reader
+// (chain-signatures/chain-midnight/src/reader.rs) and must stay in lockstep
+// with it: each record is decoded once, and id verification is a separate
+// recompute-and-drop gate ({@link lookupSignetRequestAt}).
+import { decodeExactly, UINT_64 } from "./compact-descriptors.js";
+import { signetFieldNodeByPath } from "./raw-contract-state.js";
+import { decodeEvmType2SignBidirectionalEvent } from "./signet-evtype2tx-record-decoding.js";
+import { calculateRequestId } from "./signet-request-id.js";
+import { requestIdBytes, requestIdHex, requestIdType, TxParamType, } from "./signet-requests.js";
+// Atom position of `txParamType` in a stored record: the chain-agnostic head
+// of SignBidirectionalEvent (sender through txParamType) occupies the first
+// 8 atoms whatever the decomposition, so the tag sits at the same index in
+// every record.
+const TX_PARAM_TYPE_ATOM = 7;
 /**
- * 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
- * (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, 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> 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.
+ * Decode a stored request record: read the `txParamType` tag and hand the
+ * cell to that decomposition's decoder, so a foreign param type fails by
+ * name rather than as capacity arithmetic. Does NOT verify the record
+ * against the id it is filed under.
  *
- * 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).
- * @param expectedRequestId - The id the record is stored under, used to pick
- *   between splits when more than one decodes cleanly.
+ * @param cell - The record cell as stored (value atoms plus alignment).
  * @returns The decoded record.
- * @throws Error if no capacity split decodes the value cleanly.
+ * @throws {Error} If the cell is not a decodable request record of a known
+ *   decomposition.
  */
-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 ` +
-            `${REQUEST_FIXED_VALUE_ATOMS} its fixed fields need`);
+function decodeSignBidirectionalEvent(cell) {
+    const what = "request record";
+    const atom = cell.value[TX_PARAM_TYPE_ATOM];
+    if (atom === undefined) {
+        throw new Error(`${what} ends before txParamType`);
     }
-    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 = signBidirectionalEventDescriptor(maxWords, maxEntries, maxKeys, lenOutputDeserialization, lenRespondSerialization).fromValue(cursor);
-            // A clean decode consumes the record exactly.
-            return cursor.length === 0 ? record : undefined;
-        }
-        catch {
-            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 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 (take(record))
-                return record;
-        }
+    if (atom.length > 1) {
+        throw new Error(`${what} txParamType atom holds ${String(atom.length)} bytes, expected at most 1`);
     }
-    if (fallback === undefined) {
-        throw new Error(`request record with ${atoms.length} value entries matches no ` +
-            `(calldata words, access-list entries, storage keys) capacity split`);
+    // The state layer trims trailing zeros, so evmType2 (0) arrives empty.
+    const paramType = atom[0] ?? 0;
+    switch (paramType) {
+        case TxParamType.evmType2:
+            return decodeEvmType2SignBidirectionalEvent(cell, what);
+        default:
+            throw new Error(`unsupported txParamType ${String(paramType)}`);
     }
-    return fallback;
 }
 /**
  * MPC-style read: parse the signet ledger fields out of raw contract state
- * 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, and a notification names the index position of the
- * contract it points at).
+ * by caller-supplied field positions. A contract chooses its own layout, so
+ * the caller must know where the fields sit.
+ *
+ * Records are decoded, not verified against the ids they are filed under:
+ * {@link lookupSignetRequestAt} is the verified lookup.
  *
  * @param raw - Raw contract state, e.g. `queryContractState(address).data`
  *   from the indexer or `ctx.currentQueryContext.state` from the simulator.
  * @param requestsIndexPath - Resolved ledger-tree path of the request index.
  * @param noncePath - Resolved ledger-tree path of the request counter.
  * @returns The decoded {@link SignetRequestsLedger}.
- * @throws Error if a field is missing, has the wrong state-value shape, or a
- *   record matches no capacity split.
+ * @throws {Error} If a field is missing, has the wrong state-value shape, or a
+ *   record is not a decodable evmType2 request record.
  */
 export function readSignetRequestsLedgerFromState(raw, requestsIndexPath, noncePath) {
     const map = signetFieldNodeByPath(raw, requestsIndexPath).asMap();
@@ -128,45 +70,35 @@ export function readSignetRequestsLedgerFromState(raw, requestsIndexPath, nonceP
     }
     const requestsIndex = new Map();
     for (const key of map.keys()) {
-        // fromValue consumes its input, so hand each descriptor a copy.
-        const requestId = requestIdHex(requestIdType.fromValue([...key.value]));
+        const requestId = requestIdHex(decodeExactly(requestIdType, key.value, "request index key"));
         const cell = map.get(key)?.asCell();
         if (cell === undefined)
             continue;
-        requestsIndex.set(requestId, decodeSignBidirectionalEvent(cell.value, requestId));
+        requestsIndex.set(requestId, decodeSignBidirectionalEvent(cell));
     }
-    const nonceCell = signetFieldNodeByPath(raw, noncePath).asCell();
-    if (nonceCell === undefined) {
+    const nonceField = signetFieldNodeByPath(raw, noncePath);
+    if (nonceField.type() !== "cell") {
         throw new Error(`Ledger field at path ${JSON.stringify(noncePath)} is not a Cell`);
     }
-    const nonce = u64.fromValue([...nonceCell.value]);
+    const nonce = decodeExactly(UINT_64, nonceField.asCell().value, "request counter");
     return { nonce, requestsIndex };
 }
 /**
  * Look up ONE request by id in a contract's request index at an arbitrary
- * ledger field, the single-record sibling of
- * {@link readSignetRequestsLedgerFromState}: the discovery primitive of the
- * event-based feed and what a point verification uses. A notification
- * declares the stored request's id and names both the requester contract
- * AND which field holds its index.
- *
- * `undefined` means the id is NOT a member of the index at `requestsPath`
- * (the pointer 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, 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)`.
+ * ledger field: the single-record sibling of
+ * {@link readSignetRequestsLedgerFromState} and the discovery primitive of
+ * the event-based feed. The recompute-and-drop gate: the decode never sees
+ * the id, so the final recompute is the only thing binding a record's
+ * contents to the key it was filed under, and a mismatch (a spoofed or
+ * wrongly filed record) is dropped. Every non-membership case returns
+ * `undefined` rather than throwing, and the caller MUST drop such a pointer.
  *
  * @param raw - Raw contract state, e.g. `queryContractState(address).data`.
  * @param requestsPath - Resolved ledger-tree path of the request index in
  *   `raw`, as the notification carries it.
  * @param requestId - The request id to look up.
- * @returns The stored request record, or `undefined` when it is not a member.
+ * @returns The stored, id-verified request record, or `undefined` when it is
+ *   not a member.
  */
 export function lookupSignetRequestAt(raw, requestsPath, requestId) {
     let node;
@@ -180,22 +112,26 @@ export function lookupSignetRequestAt(raw, requestsPath, requestId) {
     if (map === undefined) {
         return undefined; // the named field is not a request index
     }
-    for (const key of map.keys()) {
-        // fromValue consumes its input, so hand each descriptor a copy.
-        if (requestIdHex(requestIdType.fromValue([...key.value])) !== requestId) {
-            continue;
-        }
-        const cell = map.get(key)?.asCell();
-        if (cell === undefined) {
-            return undefined;
-        }
-        try {
-            return decodeSignBidirectionalEvent(cell.value, requestId);
-        }
-        catch {
-            return undefined; // a cell that is not a decodable request record
-        }
+    // The ledger's own keyed lookup on the ledger's own key type: toValue
+    // produces the canonical (zero-trimmed) key form the map stores.
+    const entry = map.get({
+        value: requestIdType.toValue(requestIdBytes(requestId)),
+        alignment: requestIdType.alignment(),
+    });
+    const cell = entry?.asCell();
+    if (cell === undefined) {
+        return undefined; // id absent, or its entry is not a cell
+    }
+    let record;
+    try {
+        record = decodeSignBidirectionalEvent(cell);
+    }
+    catch {
+        return undefined; // a cell that is not a decodable request record
+    }
+    if (requestIdHex(calculateRequestId(record)) !== requestId) {
+        return undefined; // spoofed or wrongly filed record
     }
-    return undefined; // id absent from the index
+    return record;
 }
 //# sourceMappingURL=signature-requests-state-reader.js.map

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

@@ -1,22 +1,23 @@
-import type { SignBidirectionalEvent } from "./signet-requests.ts";
 import type { SignatureRespondedEvent } from "./signet-contract-events.ts";
+import { type SignBidirectionalEvent } from "./signet-requests.ts";
 /**
- * Recover the EVM address that produced a response signature, over the
- * signing hash of the transaction the request describes.
+ * Recover the address that produced a response signature, over the signing
+ * digest of the transaction the request describes: the response-side
+ * dispatch on the request's `txParamType`.
  *
  * @param request - The on-ledger request record the response answers.
  * @param response - The posted signature record answering it.
  * @returns The checksummed recovered signer address.
- * @throws Error if the response is not a decodable signature or the request
- *   record is malformed (see
+ * @throws {Error} If the request's `txParamType` names a decomposition this
+ *   library does not sign-verify, the response is not a decodable signature,
+ *   or the request record is malformed (see
  *   {@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
- * by anyone else is simply not valid, which is the expected state of affairs
- * on an unauthenticated log.
+ * to `expectedSigner`? Never throws: a malformed or wrongly-signed response
+ * is simply not valid.
  *
  * @param request - The on-ledger request record the response answers.
  * @param response - The posted signature record answering it.

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":"AAeA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAE3E;;;;;;;;;;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"}
+{"version":3,"file":"signature-response-verification.d.ts","sourceRoot":"","sources":["../src/signature-response-verification.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAE3E,OAAO,EAAE,KAAK,sBAAsB,EAAe,MAAM,sBAAsB,CAAC;AAEhF;;;;;;;;;;;;GAYG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,sBAAsB,EAC/B,QAAQ,EAAE,uBAAuB,GAChC,MAAM,CAUR;AAED;;;;;;;;;GASG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,sBAAsB,EAC/B,QAAQ,EAAE,uBAAuB,EACjC,cAAc,EAAE,MAAM,GACrB,OAAO,CAMT"}