@sig-net/midnight 0.13.0 → 0.15.0

package/dist/managed/contract/index.js

@@ -44,16 +44,15 @@ const _descriptor_4 = new _Signature_0();
 
 class _RespondBidirectionalEvent_0 {
   alignment() {
-    return _descriptor_0.alignment().concat(_descriptor_4.alignment());
+    return _descriptor_4.alignment();
   }
   fromValue(value_0) {
     return {
-      attestationDigest: _descriptor_0.fromValue(value_0),
       signature: _descriptor_4.fromValue(value_0)
     }
   }
   toValue(value_0) {
-    return _descriptor_0.toValue(value_0.attestationDigest).concat(_descriptor_4.toValue(value_0.signature));
+    return _descriptor_4.toValue(value_0.signature);
   }
 }
 
@@ -85,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() {
@@ -123,7 +124,7 @@ class _tuple_0 {
   }
 }
 
-const _descriptor_16 = new _tuple_0();
+const _descriptor_17 = new _tuple_0();
 
 class _tuple_1 {
   alignment() {
@@ -140,7 +141,7 @@ class _tuple_1 {
   }
 }
 
-const _descriptor_17 = new _tuple_1();
+const _descriptor_18 = new _tuple_1();
 
 class _tuple_2 {
   alignment() {
@@ -157,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() {
@@ -194,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;
@@ -344,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) {
@@ -380,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) {
@@ -441,23 +447,20 @@ export class Contract {
   {
     const digest_0 = this._calculateSignetAttestationDigest_2(requestId_0,
                                                               serializedOutput_0);
-    const checkpointMatches_0 = this._equal_0(digest_0,
-                                              respondBidirectionalEvent_0.attestationDigest);
-    const signatureValid_0 = this._secp256k1EcdsaVerify_0(digest_0,
-                                                          { r:
-                                                              __compactRuntime.convertBytesToField(115792089237316195423570985008687907852837564279074904382605163141518161494336n,
-                                                                                                   32,
-                                                                                                   this._reverseBytes32_0(respondBidirectionalEvent_0.signature.bigR.x),
-                                                                                                   'Secp256k1Scalar',
-                                                                                                   'Signet.compact line 356 char 12'),
-                                                            s:
-                                                              __compactRuntime.convertBytesToField(115792089237316195423570985008687907852837564279074904382605163141518161494336n,
-                                                                                                   32,
-                                                                                                   this._reverseBytes32_0(respondBidirectionalEvent_0.signature.s),
-                                                                                                   'Secp256k1Scalar',
-                                                                                                   'Signet.compact line 357 char 12') },
-                                                          mpcResponseKey_0);
-    return checkpointMatches_0 && signatureValid_0;
+    return this._secp256k1EcdsaVerify_0(digest_0,
+                                        { r:
+                                            __compactRuntime.convertBytesToField(115792089237316195423570985008687907852837564279074904382605163141518161494336n,
+                                                                                 32,
+                                                                                 this._reverseBytes32_0(respondBidirectionalEvent_0.signature.bigR.x),
+                                                                                 'Secp256k1Scalar',
+                                                                                 'Signet.compact line 389 char 12'),
+                                          s:
+                                            __compactRuntime.convertBytesToField(115792089237316195423570985008687907852837564279074904382605163141518161494336n,
+                                                                                 32,
+                                                                                 this._reverseBytes32_0(respondBidirectionalEvent_0.signature.s),
+                                                                                 'Secp256k1Scalar',
+                                                                                 'Signet.compact line 390 char 12') },
+                                        mpcResponseKey_0);
   }
   _signetKeyHash_0(pk_0) { return this._persistentHash_0(pk_0); }
   _evmAddressAbiWord_0(addr_0) {
@@ -468,7 +471,7 @@ export class Contract {
   _numericAbiWord_0(value_0) {
     const le_0 = Array.from(__compactRuntime.convertBigintToBytes(16,
                                                                   value_0,
-                                                                  'Signet.compact line 439 char 17'),
+                                                                  'Signet.compact line 471 char 17'),
                             BigInt);
     return Uint8Array.from([...Array.from(new Uint8Array(16), BigInt),
                             le_0[15],
@@ -500,7 +503,7 @@ export class Contract {
                                                                 ((e, i) => e.slice(i, i+16))(word_0,
                                                                                              Number(0n)),
                                                                 'Field',
-                                                                'Signet.compact line 458 char 12')
+                                                                'Signet.compact line 490 char 12')
                             ===
                             0n,
                             'ABI word exceeds Uint<128>');
@@ -509,77 +512,77 @@ export class Contract {
                                                      ((e, i) => e.slice(i, i+1))(word_0,
                                                                                  Number(16n)),
                                                      'Field',
-                                                     'Signet.compact line 459 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 460 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 461 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 462 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 463 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 464 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 465 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 466 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 467 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 468 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 469 char 30'));
+                                                                                'Signet.compact line 501 char 30'));
     const b11_0 = __compactRuntime.addField(__compactRuntime.mulField(b10_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -587,7 +590,7 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(27n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 470 char 30'));
+                                                                                'Signet.compact line 502 char 30'));
     const b12_0 = __compactRuntime.addField(__compactRuntime.mulField(b11_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -595,7 +598,7 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(28n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 471 char 30'));
+                                                                                'Signet.compact line 503 char 30'));
     const b13_0 = __compactRuntime.addField(__compactRuntime.mulField(b12_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -603,7 +606,7 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(29n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 472 char 30'));
+                                                                                'Signet.compact line 504 char 30'));
     const b14_0 = __compactRuntime.addField(__compactRuntime.mulField(b13_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -611,7 +614,7 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(30n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 473 char 30'));
+                                                                                'Signet.compact line 505 char 30'));
     const b15_0 = __compactRuntime.addField(__compactRuntime.mulField(b14_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -619,10 +622,10 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(31n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 474 char 30'));
+                                                                                'Signet.compact line 506 char 30'));
     return ((t1) => {
              if (t1 > 340282366920938463463374607431768211455n) {
-               throw new __compactRuntime.CompactError('Signet.compact line 475 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);
@@ -633,7 +636,7 @@ export class Contract {
                                                                 ((e, i) => e.slice(i, i+31))(word_0,
                                                                                              Number(0n)),
                                                                 'Field',
-                                                                'Signet.compact line 481 char 12')
+                                                                'Signet.compact line 513 char 12')
                             ===
                             0n,
                             'ABI word is not a canonical Boolean');
@@ -642,7 +645,7 @@ export class Contract {
                                                        ((e, i) => e.slice(i, i+1))(word_0,
                                                                                    Number(31n)),
                                                        'Field',
-                                                       'Signet.compact line 482 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;
@@ -669,10 +672,6 @@ export class Contract {
                                                    respondBidirectionalEvent_0,
                                                    mpcResponseKey_0);
   }
-  _equal_0(x0, y0) {
-    if (!x0.every((x, i) => y0[i] === x)) { return false; }
-    return true;
-  }
 }
 export function ledger(stateOrChargedState) {
   const state = stateOrChargedState instanceof __compactRuntime.StateValue ? stateOrChargedState : stateOrChargedState.state;
@@ -696,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 214 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 214 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) {
@@ -733,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 430 char 3',
+                                 'Signet.compact line 462 char 3',
                                  'Bytes<20>',
                                  addr_0)
     }
@@ -747,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 436 char 3',
+                                 'Signet.compact line 468 char 3',
                                  'Uint<0..340282366920938463463374607431768211456>',
                                  value_0)
     }
@@ -761,7 +769,7 @@ export const pureCircuits = {
     if (!(typeof(value_0) === 'boolean')) {
       __compactRuntime.typeError('boolAbiWord',
                                  'argument 1',
-                                 'Signet.compact line 449 char 3',
+                                 'Signet.compact line 481 char 3',
                                  'Boolean',
                                  value_0)
     }
@@ -775,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 457 char 3',
+                                 'Signet.compact line 489 char 3',
                                  'Bytes<32>',
                                  word_0)
     }
@@ -789,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 480 char 3',
+                                 'Signet.compact line 512 char 3',
                                  'Bytes<32>',
                                  word_0)
     }
@@ -886,11 +894,11 @@ export const pureCircuits = {
                                  'Bytes<32>',
                                  serializedOutput_0)
     }
-    if (!(typeof(respondBidirectionalEvent_0) === 'object' && respondBidirectionalEvent_0.attestationDigest.buffer instanceof ArrayBuffer && respondBidirectionalEvent_0.attestationDigest.BYTES_PER_ELEMENT === 1 && respondBidirectionalEvent_0.attestationDigest.length === 32 && typeof(respondBidirectionalEvent_0.signature) === 'object' && typeof(respondBidirectionalEvent_0.signature.bigR) === 'object' && respondBidirectionalEvent_0.signature.bigR.x.buffer instanceof ArrayBuffer && respondBidirectionalEvent_0.signature.bigR.x.BYTES_PER_ELEMENT === 1 && respondBidirectionalEvent_0.signature.bigR.x.length === 32 && respondBidirectionalEvent_0.signature.bigR.y.buffer instanceof ArrayBuffer && respondBidirectionalEvent_0.signature.bigR.y.BYTES_PER_ELEMENT === 1 && respondBidirectionalEvent_0.signature.bigR.y.length === 32 && respondBidirectionalEvent_0.signature.s.buffer instanceof ArrayBuffer && respondBidirectionalEvent_0.signature.s.BYTES_PER_ELEMENT === 1 && respondBidirectionalEvent_0.signature.s.length === 32 && typeof(respondBidirectionalEvent_0.signature.recoveryId) === 'bigint' && respondBidirectionalEvent_0.signature.recoveryId >= 0n && respondBidirectionalEvent_0.signature.recoveryId <= 255n)) {
+    if (!(typeof(respondBidirectionalEvent_0) === 'object' && typeof(respondBidirectionalEvent_0.signature) === 'object' && typeof(respondBidirectionalEvent_0.signature.bigR) === 'object' && respondBidirectionalEvent_0.signature.bigR.x.buffer instanceof ArrayBuffer && respondBidirectionalEvent_0.signature.bigR.x.BYTES_PER_ELEMENT === 1 && respondBidirectionalEvent_0.signature.bigR.x.length === 32 && respondBidirectionalEvent_0.signature.bigR.y.buffer instanceof ArrayBuffer && respondBidirectionalEvent_0.signature.bigR.y.BYTES_PER_ELEMENT === 1 && respondBidirectionalEvent_0.signature.bigR.y.length === 32 && respondBidirectionalEvent_0.signature.s.buffer instanceof ArrayBuffer && respondBidirectionalEvent_0.signature.s.BYTES_PER_ELEMENT === 1 && respondBidirectionalEvent_0.signature.s.length === 32 && typeof(respondBidirectionalEvent_0.signature.recoveryId) === 'bigint' && respondBidirectionalEvent_0.signature.recoveryId >= 0n && respondBidirectionalEvent_0.signature.recoveryId <= 255n)) {
       __compactRuntime.typeError('verifyRespondBidirectionalEvent32',
                                  'argument 3',
                                  'circuits.compact line 55 char 1',
-                                 'struct RespondBidirectionalEvent<attestationDigest: Bytes<32>, signature: struct Signature<bigR: struct AffinePoint<x: Bytes<32>, y: Bytes<32>>, s: Bytes<32>, recoveryId: Uint<0..256>>>',
+                                 'struct RespondBidirectionalEvent<signature: struct Signature<bigR: struct AffinePoint<x: Bytes<32>, y: Bytes<32>>, s: Bytes<32>, recoveryId: Uint<0..256>>>',
                                  respondBidirectionalEvent_0)
     }
     return _dummyContract._verifyRespondBidirectionalEvent32_0(requestId_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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAA;;;;;;;;;;MCqNE,MAAA,6CAWC;;OAAA;MA8ID,MAAA,aAEC;;OAAA;MA6DD,MAAA,iBAEC;;OAAA;MAID,MAAA,cASC;;OAAA;MAID,MAAA,WAEC;;OAAA;MAMD,MAAA,gBAmBC;;OAAA;MAID,MAAA,aAKC;;OAAA;MDncH,MAAA,iCAKC;;OAAA;MAED,MAAA,kCAKC;;OAAA;MAED,MAAA,mCAKC;;OAAA;MAED,MAAA,iCAYC;;OAAA;;;;GACA;EAnED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEC;EEvCD,AAAA,yBAA8B;UACtB,iBAAI;UACJ,gCACQ;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;0CACA;;;;gDACP;;;;EAqBT,AAAA,wBACiB,WACA,OACA;UAET,oCAA2C;UAC3C,2BAAS;UAAT,MAAA;UAAA,MAAA;UACA,kBAAyB;UACzB,mBAA0B,KAAG;UAC7B,mBAA0B,KAAG;UAC7B,+CAA6C;gDAAW,MAAI;;;;8GAC1C;;;;;WAA2C;;EA/FrE,AAAA,kBAAA;oEAAA;;;EAAA,AAAA,aAAA;gEAAA;;;EAAA,AAAA,aAAA;gEAAA;;;EAAA,AAAA,aAAA;gEAAA;;;EAAA,AAAA,OAAA,KAAA;yDAAA,KAAA;;;EAAA,AAAA,OAAA;yDAAA;;;EAAA,AAAA,mBAAA;sDAAA;;;EAAA,AAAA,SAAA,KAAA;mDAAA,KAAA;;;EAAA,AAAA,SAAA,KAAA;mDAAA,KAAA;;;EAAA,AAAA,kBAAA;4DAAA;;;EDqNE,AAAA,gDAWC,CARC,eAA8B;mDAC9B,oBAA2B;;;;8CAKP,eAAa;gCAAQ,oBAAkB;;;GAE5D;EAgFD,AAAA,mCAKC,CAJC,WAAoB,EACpB,kBAA+C;8BAEe,WAAS,EAAE,kBAAgB;GAC1F;EALD,AAAA,mCAKC,CAJC,WAAoB,EACpB,kBAA+C;8BAEe,WAAS,EAAE,kBAAgB;GAC1F;EALD,AAAA,mCAKC,CAJC,WAAoB,EACpB,kBAA+C;8BAEe,WAAS,EAAE,kBAAgB;GAC1F;EAKD,AAAA,iBAMC,CAN2B,GAAY;UAChC,GAA4B,cAAxB,GAAC;4BACE,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAClD,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAClD,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAClD,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;4BAAM,GAAC;;GAChE;EAmBD,AAAA,kCAsBC,CArBC,WAAoB;qCACpB,kBAA+C;qCAC/C,2BAAoD;qCACpD,gBAA8B;;UAExB,QAGL,4CAFC,WAAS;8DACT,kBAAgB;UAIZ,mBAAyE,iBAArD,QAAM;8CAAI,2BAAyB;UACvD,gBAOL,gCANC,QAAM;;;;0HAEc,2BAAyB;;;;;;0HACzB,2BAAyB;;;0DAE7C,gBAAc;WAET,mBAAiB,IAAI,gBAAc;GAC3C;EAKD,AAAA,gBAEC,CAFiC,IAAkB,kCACZ,IAAE,IACzC;EA6DD,AAAA,oBAEC,CAFqC,MAAe;;0CACZ,MAAI;;GAC5C;EAID,AAAA,iBASC,CATkC,OAAgB;UAG3C,IAAgD;kEAA1C,OAAK;;;;4BAGf,IAAE;4BAAM,IAAE;4BAAM,IAAE;4BAAM,IAAE;4BAAM,IAAE;4BAAM,IAAE;4BAAM,IAAE;4BAAK,IAAE;4BACzD,IAAE;4BAAM,IAAE;4BAAM,IAAE;4BAAM,IAAE;4BAAM,IAAE;4BAAM,IAAE;4BAAM,IAAE;4BAAK,IAAE;;GAE5D;EAID,AAAA,cAEC,CAF+B,OAAc;;4BACR,OAAK;;GAC1C;EAMD,AAAA,mBAmBC,CAnBoC,MAAe;;;6FACjC,MAAI;;;;;;;UACf,IAAiC;;iFAAlB,MAAI;;;;UACnB,IAA+C,uDAAzC,IAAE;;;2GAAoB,MAAI;;;;UAChC,IAA+C,uDAAzC,IAAE;;;2GAAoB,MAAI;;;;UAChC,IAA+C,uDAAzC,IAAE;;;2GAAoB,MAAI;;;;UAChC,IAA+C,uDAAzC,IAAE;;;2GAAoB,MAAI;;;;UAChC,IAA+C,uDAAzC,IAAE;;;2GAAoB,MAAI;;;;UAChC,IAA+C,uDAAzC,IAAE;;;2GAAoB,MAAI;;;;UAChC,IAA+C,uDAAzC,IAAE;;;2GAAoB,MAAI;;;;UAChC,IAA+C,uDAAzC,IAAE;;;2GAAoB,MAAI;;;;UAChC,IAA+C,uDAAzC,IAAE;;;2GAAoB,MAAI;;;;UAChC,KAA+C,uDAAzC,IAAE;;;4GAAoB,MAAI;;;;UAChC,KAA+C,uDAAzC,KAAG;;;;4GAAmB,MAAI;;;;UAChC,KAA+C,uDAAzC,KAAG;;;;4GAAmB,MAAI;;;;UAChC,KAA+C,uDAAzC,KAAG;;;;4GAAmB,MAAI;;;;UAChC,KAA+C,uDAAzC,KAAG;;;;4GAAmB,MAAI;;;;UAChC,KAA+C,uDAAzC,KAAG;;;;4GAAmB,MAAI;;;;;;;;;cAC/B,KAAG;GACX;EAID,AAAA,gBAKC,CALiC,MAAe;;;6FAC9B,MAAI;;;;;;;UACf,MAAkC;;mFAAlB,MAAI;;;;4BACnB,MAAI,WAAkB,MAAI;;WAC1B,MAAI;GACZ;EDncH,AAAA,oCAKC,CAJC,WAAoB,EACpB,kBAA0B;oDAEiB,WAAS;oDAAE,kBAAgB;GACvE;EAED,AAAA,qCAKC,CAJC,WAAoB,EACpB,kBAA2B;oDAEiB,WAAS;oDAAE,kBAAgB;GACxE;EAED,AAAA,sCAKC,CAJC,WAAoB,EACpB,kBAA4B;oDAEiB,WAAS;oDAAE,kBAAgB;GACzE;EAED,AAAA,oCAYC,CAXC,WAAoB;uCACpB,kBAA2B;uCAC3B,2BAAoD;uCACpD,gBAA8B;;mDAG5B,WAAS;mDACT,kBAAgB;mDAChB,2BAAyB;mDACzB,gBAAc;GAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;ECmJC,AAAA,6CAWC;;;;UARC,eAA8B;UAC9B,oBAA2B;;;;;;;;;;;;;;;2EAD3B,eAA8B;2EAC9B,oBAA2B;GAO5B;EA8ID,AAAA,aAEC;;;;UAFiC,IAAkB;2CAAlB,IAAkB;GAEnD;EA6DD,AAAA,iBAEC;;;;UAFqC,MAAe;;;;;;;;+CAAf,MAAe;GAEpD;EAID,AAAA,cASC;;;;UATkC,OAAgB;;;;;;;;4CAAhB,OAAgB;GASlD;EAID,AAAA,WAEC;;;;UAF+B,OAAc;;;;;;;;yCAAd,OAAc;GAE7C;EAMD,AAAA,gBAmBC;;;;UAnBoC,MAAe;;;;;;;;8CAAf,MAAe;GAmBnD;EAID,AAAA,aAKC;;;;UALiC,MAAe;;;;;;;;2CAAf,MAAe;GAKhD;EDncH,AAAA,iCAKC;;;;UAJC,WAAoB;UACpB,kBAA0B;;;;;;;;;;;;;;;+DAD1B,WAAoB;+DACpB,kBAA0B;GAG3B;EAED,AAAA,kCAKC;;;;UAJC,WAAoB;UACpB,kBAA2B;;;;;;;;;;;;;;;gEAD3B,WAAoB;gEACpB,kBAA2B;GAG5B;EAED,AAAA,mCAKC;;;;UAJC,WAAoB;UACpB,kBAA4B;;;;;;;;;;;;;;;iEAD5B,WAAoB;iEACpB,kBAA4B;GAG7B;EAED,AAAA,iCAYC;;;;UAXC,WAAoB;UACpB,kBAA2B;UAC3B,2BAAoD;UACpD,gBAA8B;;;;;;;;;;;;;;;;;;;;;;+DAH9B,WAAoB;+DACpB,kBAA2B;+DAC3B,2BAAoD;+DACpD,gBAA8B;GAQ/B;;;;;;"
+  "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

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,kBAAkB,EAAE,MAAM,EAC1B,UAAU,EAAE,MAAM,GACjB,oBAAoB,CAqBtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,gBAAgB,EACrB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,YAAY,GACtB,sBAAsB,GAAG,SAAS,CA2BpC"}
+{"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"}