@sig-net/midnight 0.14.0 → 0.15.0

package/README.md

@@ -83,7 +83,7 @@ Set up your contract for integration with the Sig Network MPC's sign bidirection
 
    Compile with the pinned toolchain (currently `compact update 0.33.0-rc.2`) and always pass `--feature-zkir-v3`: compiled output without it is not compatible with the ledger-9 matched stack (node, indexer, proof server).
 
-2. Declare the required Sig Network protocol state in your ledger (plus recommended deployer identity and initialisation state). The event map can sit at ANY ledger field: each notification your contract registers names the field position holding it (runtime step 1), and the MPC reads the authenticated request from there.
+2. Declare the required Sig Network protocol state in your ledger (plus recommended deployer identity and initialisation state). The event map can sit at ANY ledger field: each notification your contract registers carries the map's resolved ledger-tree path (see [The request map's ledger-tree path](#the-request-maps-ledger-tree-path)), and the MPC reads the authenticated request from there.
 
    ```compact
    // Required: Map of SignBidirectionalEvent signature requests, configured by transaction type.
@@ -141,6 +141,22 @@ Set up your contract for integration with the Sig Network MPC's sign bidirection
    }
    ```
 
+### The request map's ledger-tree path
+
+Each notification must tell the MPC where your `signBidirectionalEventMap` sits in your contract's compiled on-chain state, so the MPC can read the authenticated request out of raw contract state. The location is a path in the state tree, passed to `constructSignBidirectionalEventNotificationV1` as two arguments:
+
+- `requestsPathDepth`: the number of meaningful entries in the path (1 to 4).
+- `requestsPath`: the path itself, zero padded to 4 entries.
+
+The path shape comes from how compactc lays out state. The compiler packs a contract's public ledger fields into a tree whose array nodes hold at most 15 entries. With 15 or fewer fields, field N sits directly in the root array, at path `[N]` (depth 1). With more than 15 fields, the compiler groups the fields into segments of at most 15 (the remainder segment first) and the root array holds the segments. Each grouping adds one level to the tree and one entry to every field's path. A 20-field contract splits 5 + 15: field 4 sits at `[0, 4]` and field 19 sits at `[1, 14]` (depth 2).
+
+Do not derive the path by hand: the compiler records it in your compiled artifacts. Compile your contract, then look up your map's `"index"` in `managed/<contract>/compiler/contract-info.json` (a bare number `4` means path `[4]`). The generated `managed/<contract>/contract/index.js` accessors walk the same indices, for example `state.asArray()[1].asArray()[14]` for a map recorded at `[1, 14]`. That path packs as `requestsPathDepth = 2` and `requestsPath = [1, 14, 0, 0]`.
+
+The two caller contracts in the [sig-net/midnight-integration](https://github.com/sig-net/midnight-integration) repository are worked examples of each case:
+
+- [`test-caller-contract`](https://github.com/sig-net/midnight-integration/tree/main/packages/test-caller-contract): the flat case, where its 8-field ledger stores the map at field 4, so notifications carry depth `1` and path `[4, 0, 0, 0]`.
+- [`test-caller-contract-20-field`](https://github.com/sig-net/midnight-integration/tree/main/packages/test-caller-contract-20-field): the chunked case, where its 20 fields split 5 + 15, so the map at field 19 packs as depth `2` and path `[1, 14, 0, 0]`.
+
 ### Runtime
 
 Each interaction with your contract that executes a transaction on a foreign chain runs these 5 steps.
@@ -158,8 +174,8 @@ const reader = new SignetRequestResponseReader({
    // Address of YOUR deployed contract
    requesterContractAddress: myContractAddress,
 
-   // signBidirectionalEventMap's field position (Setup step 2)
-   requesterRequestsIndexField: 0,
+   // signBidirectionalEventMap's ledger-tree path (see The request map's ledger-tree path)
+   requesterRequestsPath: [0],
 
    // Address of the Signet singleton contract
    signetContractAddress,
@@ -186,10 +202,15 @@ const expectedSigner = deriveEvmAddress(mpcRootPublicKey, myContractAddress, "my
    signBidirectionalEventMap.insert(requestId, disclose(request));
 
    // Notify the MPC of the SignBidirectionalEvent and the location of your signBidirectionalEventMap.
-   // The location is 0 here based on the position of the declaration in Setup step 2.
+   // The map is at ledger field 0 (Setup step 2), so its path is [0] at depth 1
+   // (see The request map's ledger-tree path).
    signetSigner.signBidirectional(
       requestId,
-      constructSignBidirectionalEventNotificationV1(kernel.self(), 0 as Uint<8>),
+      constructSignBidirectionalEventNotificationV1(
+         kernel.self(),
+         1 as Uint<8>,                        // requestsPathDepth
+         [0, 0, 0, 0] as Vector<4, Uint<8>>,  // requestsPath, zero padded
+      ),
    );
    ```
 

package/dist/managed/compiler/contract-info.json

@@ -25,11 +25,22 @@
           }
         },
         {
-          "name": "requestsIndexField",
+          "name": "requestsPathDepth",
           "type": {
             "type-name": "Uint",
             "maxval": 255
           }
+        },
+        {
+          "name": "requestsPath",
+          "type": {
+            "type-name": "Vector",
+            "length": 4,
+            "type": {
+              "type-name": "Uint",
+              "maxval": 255
+            }
+          }
         }
       ],
       "result-type": {

package/dist/managed/compiler/contract-manifest.json

@@ -7,26 +7,26 @@
     "type": "directory",
     "contract-info.json": {
       "type": "file",
-      "size": 7955,
-      "hash": "bdc0fba992f5d93b36bfe0a807b35d05943505a5fc9dc48c46ba33a4269c65c9"
+      "size": 8200,
+      "hash": "07a63a0b166c651d4f9eb662029bacc81b0825311959ac67405d3996c064a84c"
     }
   },
   "contract": {
     "type": "directory",
     "index.d.ts": {
       "type": "file",
-      "size": 6388,
-      "hash": "c8f837fb853f415edca32eb789a5391a327ad168dd1d48e8b7eb72eadc5d7af8"
+      "size": 6518,
+      "hash": "9c63efc21d21c87c4a1989454c35158c8d783fd86131a5697edfd5e8f9db4bba"
     },
     "index.js": {
       "type": "file",
-      "size": 48928,
-      "hash": "cd4412517d099f20ca53775c282192bf5b5ea4727b2b63fd7d8e2e311bbc8a6c"
+      "size": 49867,
+      "hash": "63808b43f8f0f7674971b1fe67ed6ef933004094fe48571969839dcdbbe1c589"
     },
     "index.js.map": {
       "type": "file",
-      "size": 4664,
-      "hash": "26117f20d193b8494ad25ae56f22e64233b403ff613a6a880a426604e9f55c21"
+      "size": 4763,
+      "hash": "f4f3622ea5f12911ee4ff19ffccf1b03d35f1c07a49ce0a48c1768d7903fc2d7"
     }
   }
 }

package/dist/managed/contract/index.d.ts

@@ -12,9 +12,10 @@ export type ProvableCircuits<PS> = {
 export type PureCircuits = {
   constructSignBidirectionalEventNotificationV1(callerAddress_0: { bytes: Uint8Array
                                                                  },
-                                                requestsIndexField_0: bigint): { version: bigint,
-                                                                                 payload: Uint8Array
-                                                                               };
+                                                requestsPathDepth_0: bigint,
+                                                requestsPath_0: bigint[]): { version: bigint,
+                                                                             payload: Uint8Array
+                                                                           };
   signetKeyHash(pk_0: __compactRuntime.Secp256k1Point): Uint8Array;
   evmAddressAbiWord(addr_0: Uint8Array): Uint8Array;
   numericAbiWord(value_0: bigint): Uint8Array;
@@ -43,9 +44,10 @@ export type Circuits<PS> = {
   constructSignBidirectionalEventNotificationV1(context: __compactRuntime.CircuitContext<PS>,
                                                 callerAddress_0: { bytes: Uint8Array
                                                                  },
-                                                requestsIndexField_0: bigint): Promise<__compactRuntime.CircuitResults<PS, { version: bigint,
-                                                                                                                             payload: Uint8Array
-                                                                                                                           }>>;
+                                                requestsPathDepth_0: bigint,
+                                                requestsPath_0: bigint[]): Promise<__compactRuntime.CircuitResults<PS, { version: bigint,
+                                                                                                                         payload: Uint8Array
+                                                                                                                       }>>;
   signetKeyHash(context: __compactRuntime.CircuitContext<PS>,
                 pk_0: __compactRuntime.Secp256k1Point): Promise<__compactRuntime.CircuitResults<PS, Uint8Array>>;
   evmAddressAbiWord(context: __compactRuntime.CircuitContext<PS>,

package/dist/managed/contract/index.js

@@ -84,28 +84,30 @@ class _ContractAddress_0 {
 
 const _descriptor_11 = new _ContractAddress_0();
 
-const _descriptor_12 = new __compactRuntime.CompactTypeBytes(128);
+const _descriptor_12 = new __compactRuntime.CompactTypeVector(4, _descriptor_3);
+
+const _descriptor_13 = new __compactRuntime.CompactTypeBytes(128);
 
 class _SignBidirectionalEventNotification_0 {
   alignment() {
-    return _descriptor_3.alignment().concat(_descriptor_12.alignment());
+    return _descriptor_3.alignment().concat(_descriptor_13.alignment());
   }
   fromValue(value_0) {
     return {
       version: _descriptor_3.fromValue(value_0),
-      payload: _descriptor_12.fromValue(value_0)
+      payload: _descriptor_13.fromValue(value_0)
     }
   }
   toValue(value_0) {
-    return _descriptor_3.toValue(value_0.version).concat(_descriptor_12.toValue(value_0.payload));
+    return _descriptor_3.toValue(value_0.version).concat(_descriptor_13.toValue(value_0.payload));
   }
 }
 
-const _descriptor_13 = new _SignBidirectionalEventNotification_0();
+const _descriptor_14 = new _SignBidirectionalEventNotification_0();
 
-const _descriptor_14 = __compactRuntime.CompactTypeSecp256k1Scalar;
+const _descriptor_15 = __compactRuntime.CompactTypeSecp256k1Scalar;
 
-const _descriptor_15 = __compactRuntime.CompactTypeSecp256k1Base;
+const _descriptor_16 = __compactRuntime.CompactTypeSecp256k1Base;
 
 class _tuple_0 {
   alignment() {
@@ -122,7 +124,7 @@ class _tuple_0 {
   }
 }
 
-const _descriptor_16 = new _tuple_0();
+const _descriptor_17 = new _tuple_0();
 
 class _tuple_1 {
   alignment() {
@@ -139,7 +141,7 @@ class _tuple_1 {
   }
 }
 
-const _descriptor_17 = new _tuple_1();
+const _descriptor_18 = new _tuple_1();
 
 class _tuple_2 {
   alignment() {
@@ -156,26 +158,26 @@ class _tuple_2 {
   }
 }
 
-const _descriptor_18 = new _tuple_2();
+const _descriptor_19 = new _tuple_2();
 
 class _Secp256k1EcdsaSignature_0 {
   alignment() {
-    return _descriptor_14.alignment().concat(_descriptor_14.alignment());
+    return _descriptor_15.alignment().concat(_descriptor_15.alignment());
   }
   fromValue(value_0) {
     return {
-      r: _descriptor_14.fromValue(value_0),
-      s: _descriptor_14.fromValue(value_0)
+      r: _descriptor_15.fromValue(value_0),
+      s: _descriptor_15.fromValue(value_0)
     }
   }
   toValue(value_0) {
-    return _descriptor_14.toValue(value_0.r).concat(_descriptor_14.toValue(value_0.s));
+    return _descriptor_15.toValue(value_0.r).concat(_descriptor_15.toValue(value_0.s));
   }
 }
 
-const _descriptor_19 = new _Secp256k1EcdsaSignature_0();
+const _descriptor_20 = new _Secp256k1EcdsaSignature_0();
 
-const _descriptor_20 = new __compactRuntime.CompactTypeUnsignedInteger(18446744073709551615n, 8);
+const _descriptor_21 = new __compactRuntime.CompactTypeUnsignedInteger(18446744073709551615n, 8);
 
 class _Either_0 {
   alignment() {
@@ -193,9 +195,9 @@ class _Either_0 {
   }
 }
 
-const _descriptor_21 = new _Either_0();
+const _descriptor_22 = new _Either_0();
 
-const _descriptor_22 = new __compactRuntime.CompactTypeUnsignedInteger(4294967295n, 4);
+const _descriptor_23 = new __compactRuntime.CompactTypeUnsignedInteger(4294967295n, 4);
 
 export class Contract {
   witnesses;
@@ -343,15 +345,15 @@ export class Contract {
     return result_0;
   }
   _keccak256_0(value_0) {
-    const result_0 = __compactRuntime.keccak256(_descriptor_18, value_0);
+    const result_0 = __compactRuntime.keccak256(_descriptor_19, value_0);
     return result_0;
   }
   _keccak256_1(value_0) {
-    const result_0 = __compactRuntime.keccak256(_descriptor_16, value_0);
+    const result_0 = __compactRuntime.keccak256(_descriptor_17, value_0);
     return result_0;
   }
   _keccak256_2(value_0) {
-    const result_0 = __compactRuntime.keccak256(_descriptor_17, value_0);
+    const result_0 = __compactRuntime.keccak256(_descriptor_18, value_0);
     return result_0;
   }
   _mul_0(x_0, y_0) {
@@ -379,13 +381,18 @@ export class Contract {
     return result_0;
   }
   _constructSignBidirectionalEventNotificationV1_0(callerAddress_0,
-                                                   requestsIndexField_0)
+                                                   requestsPathDepth_0,
+                                                   requestsPath_0)
   {
     return { version: 1n,
              payload:
                Uint8Array.from([...Array.from(callerAddress_0.bytes, BigInt),
-                                requestsIndexField_0,
-                                ...Array.from(new Uint8Array(95), BigInt)],
+                                requestsPathDepth_0,
+                                requestsPath_0[0],
+                                requestsPath_0[1],
+                                requestsPath_0[2],
+                                requestsPath_0[3],
+                                ...Array.from(new Uint8Array(91), BigInt)],
                                Number) };
   }
   _calculateSignetAttestationDigest_0(requestId_0, serializedOutput_0) {
@@ -446,13 +453,13 @@ export class Contract {
                                                                                  32,
                                                                                  this._reverseBytes32_0(respondBidirectionalEvent_0.signature.bigR.x),
                                                                                  'Secp256k1Scalar',
-                                                                                 'Signet.compact line 349 char 12'),
+                                                                                 'Signet.compact line 389 char 12'),
                                           s:
                                             __compactRuntime.convertBytesToField(115792089237316195423570985008687907852837564279074904382605163141518161494336n,
                                                                                  32,
                                                                                  this._reverseBytes32_0(respondBidirectionalEvent_0.signature.s),
                                                                                  'Secp256k1Scalar',
-                                                                                 'Signet.compact line 350 char 12') },
+                                                                                 'Signet.compact line 390 char 12') },
                                         mpcResponseKey_0);
   }
   _signetKeyHash_0(pk_0) { return this._persistentHash_0(pk_0); }
@@ -464,7 +471,7 @@ export class Contract {
   _numericAbiWord_0(value_0) {
     const le_0 = Array.from(__compactRuntime.convertBigintToBytes(16,
                                                                   value_0,
-                                                                  'Signet.compact line 431 char 17'),
+                                                                  'Signet.compact line 471 char 17'),
                             BigInt);
     return Uint8Array.from([...Array.from(new Uint8Array(16), BigInt),
                             le_0[15],
@@ -496,7 +503,7 @@ export class Contract {
                                                                 ((e, i) => e.slice(i, i+16))(word_0,
                                                                                              Number(0n)),
                                                                 'Field',
-                                                                'Signet.compact line 450 char 12')
+                                                                'Signet.compact line 490 char 12')
                             ===
                             0n,
                             'ABI word exceeds Uint<128>');
@@ -505,77 +512,77 @@ export class Contract {
                                                      ((e, i) => e.slice(i, i+1))(word_0,
                                                                                  Number(16n)),
                                                      'Field',
-                                                     'Signet.compact line 451 char 17');
+                                                     'Signet.compact line 491 char 17');
     const b1_0 = __compactRuntime.addField(__compactRuntime.mulField(b0_0, 256n),
                                            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
                                                                                1,
                                                                                ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                            Number(17n)),
                                                                                'Field',
-                                                                               'Signet.compact line 452 char 30'));
+                                                                               'Signet.compact line 492 char 30'));
     const b2_0 = __compactRuntime.addField(__compactRuntime.mulField(b1_0, 256n),
                                            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
                                                                                1,
                                                                                ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                            Number(18n)),
                                                                                'Field',
-                                                                               'Signet.compact line 453 char 30'));
+                                                                               'Signet.compact line 493 char 30'));
     const b3_0 = __compactRuntime.addField(__compactRuntime.mulField(b2_0, 256n),
                                            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
                                                                                1,
                                                                                ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                            Number(19n)),
                                                                                'Field',
-                                                                               'Signet.compact line 454 char 30'));
+                                                                               'Signet.compact line 494 char 30'));
     const b4_0 = __compactRuntime.addField(__compactRuntime.mulField(b3_0, 256n),
                                            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
                                                                                1,
                                                                                ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                            Number(20n)),
                                                                                'Field',
-                                                                               'Signet.compact line 455 char 30'));
+                                                                               'Signet.compact line 495 char 30'));
     const b5_0 = __compactRuntime.addField(__compactRuntime.mulField(b4_0, 256n),
                                            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
                                                                                1,
                                                                                ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                            Number(21n)),
                                                                                'Field',
-                                                                               'Signet.compact line 456 char 30'));
+                                                                               'Signet.compact line 496 char 30'));
     const b6_0 = __compactRuntime.addField(__compactRuntime.mulField(b5_0, 256n),
                                            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
                                                                                1,
                                                                                ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                            Number(22n)),
                                                                                'Field',
-                                                                               'Signet.compact line 457 char 30'));
+                                                                               'Signet.compact line 497 char 30'));
     const b7_0 = __compactRuntime.addField(__compactRuntime.mulField(b6_0, 256n),
                                            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
                                                                                1,
                                                                                ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                            Number(23n)),
                                                                                'Field',
-                                                                               'Signet.compact line 458 char 30'));
+                                                                               'Signet.compact line 498 char 30'));
     const b8_0 = __compactRuntime.addField(__compactRuntime.mulField(b7_0, 256n),
                                            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
                                                                                1,
                                                                                ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                            Number(24n)),
                                                                                'Field',
-                                                                               'Signet.compact line 459 char 30'));
+                                                                               'Signet.compact line 499 char 30'));
     const b9_0 = __compactRuntime.addField(__compactRuntime.mulField(b8_0, 256n),
                                            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
                                                                                1,
                                                                                ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                            Number(25n)),
                                                                                'Field',
-                                                                               'Signet.compact line 460 char 30'));
+                                                                               'Signet.compact line 500 char 30'));
     const b10_0 = __compactRuntime.addField(__compactRuntime.mulField(b9_0, 256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
                                                                                 1,
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(26n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 461 char 30'));
+                                                                                'Signet.compact line 501 char 30'));
     const b11_0 = __compactRuntime.addField(__compactRuntime.mulField(b10_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -583,7 +590,7 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(27n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 462 char 30'));
+                                                                                'Signet.compact line 502 char 30'));
     const b12_0 = __compactRuntime.addField(__compactRuntime.mulField(b11_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -591,7 +598,7 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(28n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 463 char 30'));
+                                                                                'Signet.compact line 503 char 30'));
     const b13_0 = __compactRuntime.addField(__compactRuntime.mulField(b12_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -599,7 +606,7 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(29n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 464 char 30'));
+                                                                                'Signet.compact line 504 char 30'));
     const b14_0 = __compactRuntime.addField(__compactRuntime.mulField(b13_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -607,7 +614,7 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(30n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 465 char 30'));
+                                                                                'Signet.compact line 505 char 30'));
     const b15_0 = __compactRuntime.addField(__compactRuntime.mulField(b14_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -615,10 +622,10 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(31n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 466 char 30'));
+                                                                                'Signet.compact line 506 char 30'));
     return ((t1) => {
              if (t1 > 340282366920938463463374607431768211455n) {
-               throw new __compactRuntime.CompactError('Signet.compact line 467 char 12: cast from Field or Uint value to smaller Uint value failed: ' + t1 + ' is greater than 340282366920938463463374607431768211455');
+               throw new __compactRuntime.CompactError('Signet.compact line 507 char 12: cast from Field or Uint value to smaller Uint value failed: ' + t1 + ' is greater than 340282366920938463463374607431768211455');
              }
              return t1;
            })(b15_0);
@@ -629,7 +636,7 @@ export class Contract {
                                                                 ((e, i) => e.slice(i, i+31))(word_0,
                                                                                              Number(0n)),
                                                                 'Field',
-                                                                'Signet.compact line 473 char 12')
+                                                                'Signet.compact line 513 char 12')
                             ===
                             0n,
                             'ABI word is not a canonical Boolean');
@@ -638,7 +645,7 @@ export class Contract {
                                                        ((e, i) => e.slice(i, i+1))(word_0,
                                                                                    Number(31n)),
                                                        'Field',
-                                                       'Signet.compact line 474 char 18');
+                                                       'Signet.compact line 514 char 18');
     __compactRuntime.assert(last_0 === 0n || last_0 === 1n,
                             'ABI word is not a canonical Boolean');
     return last_0 === 1n;
@@ -688,27 +695,36 @@ const _emptyContext = {
 const _dummyContract = new Contract({ });
 export const pureCircuits = {
   constructSignBidirectionalEventNotificationV1: (...args_0) => {
-    if (args_0.length !== 2) {
-      throw new __compactRuntime.CompactError(`constructSignBidirectionalEventNotificationV1: expected 2 arguments (as invoked from Typescript), received ${args_0.length}`);
+    if (args_0.length !== 3) {
+      throw new __compactRuntime.CompactError(`constructSignBidirectionalEventNotificationV1: expected 3 arguments (as invoked from Typescript), received ${args_0.length}`);
     }
     const callerAddress_0 = args_0[0];
-    const requestsIndexField_0 = args_0[1];
+    const requestsPathDepth_0 = args_0[1];
+    const requestsPath_0 = args_0[2];
     if (!(typeof(callerAddress_0) === 'object' && callerAddress_0.bytes.buffer instanceof ArrayBuffer && callerAddress_0.bytes.BYTES_PER_ELEMENT === 1 && callerAddress_0.bytes.length === 32)) {
       __compactRuntime.typeError('constructSignBidirectionalEventNotificationV1',
                                  'argument 1',
-                                 'Signet.compact line 218 char 3',
+                                 'Signet.compact line 247 char 3',
                                  'struct ContractAddress<bytes: Bytes<32>>',
                                  callerAddress_0)
     }
-    if (!(typeof(requestsIndexField_0) === 'bigint' && requestsIndexField_0 >= 0n && requestsIndexField_0 <= 255n)) {
+    if (!(typeof(requestsPathDepth_0) === 'bigint' && requestsPathDepth_0 >= 0n && requestsPathDepth_0 <= 255n)) {
       __compactRuntime.typeError('constructSignBidirectionalEventNotificationV1',
                                  'argument 2',
-                                 'Signet.compact line 218 char 3',
+                                 'Signet.compact line 247 char 3',
                                  'Uint<0..256>',
-                                 requestsIndexField_0)
+                                 requestsPathDepth_0)
+    }
+    if (!(Array.isArray(requestsPath_0) && requestsPath_0.length === 4 && requestsPath_0.every((t) => typeof(t) === 'bigint' && t >= 0n && t <= 255n))) {
+      __compactRuntime.typeError('constructSignBidirectionalEventNotificationV1',
+                                 'argument 3',
+                                 'Signet.compact line 247 char 3',
+                                 'Vector<4, Uint<0..256>>',
+                                 requestsPath_0)
     }
     return _dummyContract._constructSignBidirectionalEventNotificationV1_0(callerAddress_0,
-                                                                           requestsIndexField_0);
+                                                                           requestsPathDepth_0,
+                                                                           requestsPath_0);
   },
   signetKeyHash: (...args_0) => {
     if (args_0.length !== 1) {
@@ -725,7 +741,7 @@ export const pureCircuits = {
     if (!(addr_0.buffer instanceof ArrayBuffer && addr_0.BYTES_PER_ELEMENT === 1 && addr_0.length === 20)) {
       __compactRuntime.typeError('evmAddressAbiWord',
                                  'argument 1',
-                                 'Signet.compact line 422 char 3',
+                                 'Signet.compact line 462 char 3',
                                  'Bytes<20>',
                                  addr_0)
     }
@@ -739,7 +755,7 @@ export const pureCircuits = {
     if (!(typeof(value_0) === 'bigint' && value_0 >= 0n && value_0 <= 340282366920938463463374607431768211455n)) {
       __compactRuntime.typeError('numericAbiWord',
                                  'argument 1',
-                                 'Signet.compact line 428 char 3',
+                                 'Signet.compact line 468 char 3',
                                  'Uint<0..340282366920938463463374607431768211456>',
                                  value_0)
     }
@@ -753,7 +769,7 @@ export const pureCircuits = {
     if (!(typeof(value_0) === 'boolean')) {
       __compactRuntime.typeError('boolAbiWord',
                                  'argument 1',
-                                 'Signet.compact line 441 char 3',
+                                 'Signet.compact line 481 char 3',
                                  'Boolean',
                                  value_0)
     }
@@ -767,7 +783,7 @@ export const pureCircuits = {
     if (!(word_0.buffer instanceof ArrayBuffer && word_0.BYTES_PER_ELEMENT === 1 && word_0.length === 32)) {
       __compactRuntime.typeError('abiWordToUint128',
                                  'argument 1',
-                                 'Signet.compact line 449 char 3',
+                                 'Signet.compact line 489 char 3',
                                  'Bytes<32>',
                                  word_0)
     }
@@ -781,7 +797,7 @@ export const pureCircuits = {
     if (!(word_0.buffer instanceof ArrayBuffer && word_0.BYTES_PER_ELEMENT === 1 && word_0.length === 32)) {
       __compactRuntime.typeError('abiWordToBool',
                                  'argument 1',
-                                 'Signet.compact line 472 char 3',
+                                 'Signet.compact line 512 char 3',
                                  'Bytes<32>',
                                  word_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

@@ -38,13 +38,13 @@ export interface SignetRequestsLedger {
  *
  * @param raw - Raw contract state, e.g. `queryContractState(address).data`
  *   from the indexer or `ctx.currentQueryContext.state` from the simulator.
- * @param requestsIndexField - Ledger field position of the request index.
- * @param nonceField - Ledger field position of the request counter.
+ * @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.
  */
-export declare function readSignetRequestsLedgerFromState(raw: RawContractState, requestsIndexField: number, nonceField: number): SignetRequestsLedger;
+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
@@ -66,9 +66,10 @@ export declare function readSignetRequestsLedgerFromState(raw: RawContractState,
  * fieldIndex, …).requestsIndex.get(requestId)`.
  *
  * @param raw - Raw contract state, e.g. `queryContractState(address).data`.
- * @param fieldIndex - Ledger field position of the request index in `raw`.
+ * @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.
  */
-export declare function lookupSignetRequestAt(raw: RawContractState, fieldIndex: number, requestId: RequestIdHex): SignBidirectionalEvent | undefined;
+export declare function lookupSignetRequestAt(raw: RawContractState, requestsPath: readonly number[], requestId: RequestIdHex): SignBidirectionalEvent | undefined;
 //# sourceMappingURL=signature-requests-state-reader.d.ts.map