@sig-net/midnight 0.14.0 → 0.16.0

package/dist/index.d.ts

@@ -3,10 +3,9 @@ export * from "./signet-requests.ts";
 export * from "./signet-evtype2tx-requests.ts";
 export * from "./signature-state-reading.ts";
 export * from "./signature-requests-state-reader.ts";
-export * from "./signet-contract-state-reader.ts";
+export * from "./signet-contract-events.ts";
 export * from "./signature-response-verification.ts";
 export * from "./signet-request-response-reader.ts";
-export * from "./signet-request-resolver.ts";
 export * from "./signet-request-feed.ts";
 export * from "./constants.ts";
 export * from "./epsilon-derivation.ts";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,sCAAsC,CAAC;AACrD,cAAc,qCAAqC,CAAC;AACpD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AAEvC;;;;GAIG;AACH,OAAO,EAAE,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sCAAsC,CAAC;AACrD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sCAAsC,CAAC;AACrD,cAAc,qCAAqC,CAAC;AACpD,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AAEvC;;;;GAIG;AACH,OAAO,EAAE,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/index.js

@@ -1,15 +1,14 @@
 // Midnight-side sig-net integration: the client-agnostic signet protocol
-// library (wire structs, state readers, request feed/resolver, crypto) plus
-// the compiled pure circuits of the shared Compact module.
+// library (wire structs, state readers, event decoders, request feed,
+// crypto) plus the compiled pure circuits of the shared Compact module.
 export * from "./abi-serde.js";
 export * from "./signet-requests.js";
 export * from "./signet-evtype2tx-requests.js";
 export * from "./signature-state-reading.js";
 export * from "./signature-requests-state-reader.js";
-export * from "./signet-contract-state-reader.js";
+export * from "./signet-contract-events.js";
 export * from "./signature-response-verification.js";
 export * from "./signet-request-response-reader.js";
-export * from "./signet-request-resolver.js";
 export * from "./signet-request-feed.js";
 export * from "./constants.js";
 export * from "./epsilon-derivation.js";

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,4EAA4E;AAC5E,2DAA2D;AAE3D,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,sCAAsC,CAAC;AACrD,cAAc,qCAAqC,CAAC;AACpD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AAEvC;;;;GAIG;AACH,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,sEAAsE;AACtE,wEAAwE;AAExE,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sCAAsC,CAAC;AACrD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sCAAsC,CAAC;AACrD,cAAc,qCAAqC,CAAC;AACpD,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AAEvC;;;;GAIG;AACH,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC"}

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": "9110102850ba6354a9b57ac35bd10c269c73cdea5248861b7c26f3108914d932"
     },
     "index.js.map": {
       "type": "file",
-      "size": 4664,
-      "hash": "26117f20d193b8494ad25ae56f22e64233b403ff613a6a880a426604e9f55c21"
+      "size": 4763,
+      "hash": "345928fecea5933a4f62f8a6ac11b1ff8a8827c118cc1848346a70fac822d4b4"
     }
   }
 }

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 396 char 12'),
                                           s:
                                             __compactRuntime.convertBytesToField(115792089237316195423570985008687907852837564279074904382605163141518161494336n,
                                                                                  32,
                                                                                  this._reverseBytes32_0(respondBidirectionalEvent_0.signature.s),
                                                                                  'Secp256k1Scalar',
-                                                                                 'Signet.compact line 350 char 12') },
+                                                                                 'Signet.compact line 397 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 478 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 497 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 498 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 499 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 500 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 501 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 502 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 503 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 504 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 505 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 506 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 507 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 508 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 509 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 510 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 511 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 512 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 513 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 514 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 520 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 521 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 259 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 259 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 259 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 469 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 475 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 488 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 496 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 519 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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"
 }