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

package/dist/managed/contract/index.js

@@ -68,6 +68,8 @@ const _descriptor_9 = new __compactRuntime.CompactTypeUnsignedInteger(3402823669
 
 const _descriptor_10 = new __compactRuntime.CompactTypeBytes(20);
 
+const _descriptor_11 = __compactRuntime.CompactTypeSecp256k1Scalar;
+
 class _ContractAddress_0 {
   alignment() {
     return _descriptor_0.alignment();
@@ -82,45 +84,43 @@ class _ContractAddress_0 {
   }
 }
 
-const _descriptor_11 = new _ContractAddress_0();
+const _descriptor_12 = new _ContractAddress_0();
 
-const _descriptor_12 = new __compactRuntime.CompactTypeVector(4, _descriptor_3);
+const _descriptor_13 = new __compactRuntime.CompactTypeVector(4, _descriptor_3);
 
-const _descriptor_13 = new __compactRuntime.CompactTypeBytes(128);
+const _descriptor_14 = new __compactRuntime.CompactTypeBytes(128);
 
 class _SignBidirectionalEventNotification_0 {
   alignment() {
-    return _descriptor_3.alignment().concat(_descriptor_13.alignment());
+    return _descriptor_3.alignment().concat(_descriptor_14.alignment());
   }
   fromValue(value_0) {
     return {
       version: _descriptor_3.fromValue(value_0),
-      payload: _descriptor_13.fromValue(value_0)
+      payload: _descriptor_14.fromValue(value_0)
     }
   }
   toValue(value_0) {
-    return _descriptor_3.toValue(value_0.version).concat(_descriptor_13.toValue(value_0.payload));
+    return _descriptor_3.toValue(value_0.version).concat(_descriptor_14.toValue(value_0.payload));
   }
 }
 
-const _descriptor_14 = new _SignBidirectionalEventNotification_0();
-
-const _descriptor_15 = __compactRuntime.CompactTypeSecp256k1Scalar;
+const _descriptor_15 = new _SignBidirectionalEventNotification_0();
 
 const _descriptor_16 = __compactRuntime.CompactTypeSecp256k1Base;
 
 class _tuple_0 {
   alignment() {
-    return _descriptor_0.alignment().concat(_descriptor_1.alignment());
+    return _descriptor_0.alignment().concat(_descriptor_0.alignment());
   }
   fromValue(value_0) {
     return [
       _descriptor_0.fromValue(value_0),
-      _descriptor_1.fromValue(value_0)
+      _descriptor_0.fromValue(value_0)
     ]
   }
   toValue(value_0) {
-    return _descriptor_0.toValue(value_0[0]).concat(_descriptor_1.toValue(value_0[1]));
+    return _descriptor_0.toValue(value_0[0]).concat(_descriptor_0.toValue(value_0[1]));
   }
 }
 
@@ -128,16 +128,16 @@ const _descriptor_17 = new _tuple_0();
 
 class _tuple_1 {
   alignment() {
-    return _descriptor_0.alignment().concat(_descriptor_0.alignment());
+    return _descriptor_0.alignment().concat(_descriptor_8.alignment());
   }
   fromValue(value_0) {
     return [
       _descriptor_0.fromValue(value_0),
-      _descriptor_0.fromValue(value_0)
+      _descriptor_8.fromValue(value_0)
     ]
   }
   toValue(value_0) {
-    return _descriptor_0.toValue(value_0[0]).concat(_descriptor_0.toValue(value_0[1]));
+    return _descriptor_0.toValue(value_0[0]).concat(_descriptor_8.toValue(value_0[1]));
   }
 }
 
@@ -145,16 +145,16 @@ const _descriptor_18 = new _tuple_1();
 
 class _tuple_2 {
   alignment() {
-    return _descriptor_0.alignment().concat(_descriptor_8.alignment());
+    return _descriptor_0.alignment().concat(_descriptor_1.alignment());
   }
   fromValue(value_0) {
     return [
       _descriptor_0.fromValue(value_0),
-      _descriptor_8.fromValue(value_0)
+      _descriptor_1.fromValue(value_0)
     ]
   }
   toValue(value_0) {
-    return _descriptor_0.toValue(value_0[0]).concat(_descriptor_8.toValue(value_0[1]));
+    return _descriptor_0.toValue(value_0[0]).concat(_descriptor_1.toValue(value_0[1]));
   }
 }
 
@@ -162,16 +162,16 @@ const _descriptor_19 = new _tuple_2();
 
 class _Secp256k1EcdsaSignature_0 {
   alignment() {
-    return _descriptor_15.alignment().concat(_descriptor_15.alignment());
+    return _descriptor_11.alignment().concat(_descriptor_11.alignment());
   }
   fromValue(value_0) {
     return {
-      r: _descriptor_15.fromValue(value_0),
-      s: _descriptor_15.fromValue(value_0)
+      r: _descriptor_11.fromValue(value_0),
+      s: _descriptor_11.fromValue(value_0)
     }
   }
   toValue(value_0) {
-    return _descriptor_15.toValue(value_0.r).concat(_descriptor_15.toValue(value_0.s));
+    return _descriptor_11.toValue(value_0.r).concat(_descriptor_11.toValue(value_0.s));
   }
 }
 
@@ -214,9 +214,6 @@ export class Contract {
       async constructSignBidirectionalEventNotificationV1(context, ...args_1) {
         return { result: pureCircuits.constructSignBidirectionalEventNotificationV1(...args_1), context };
       },
-      async signetKeyHash(context, ...args_1) {
-        return { result: pureCircuits.signetKeyHash(...args_1), context };
-      },
       async evmAddressAbiWord(context, ...args_1) {
         return { result: pureCircuits.evmAddressAbiWord(...args_1), context };
       },
@@ -340,20 +337,16 @@ export class Contract {
            ===
            r_0;
   }
-  _persistentHash_0(value_0) {
-    const result_0 = __compactRuntime.persistentHash(_descriptor_6, value_0);
-    return result_0;
-  }
   _keccak256_0(value_0) {
-    const result_0 = __compactRuntime.keccak256(_descriptor_19, value_0);
+    const result_0 = __compactRuntime.keccak256(_descriptor_18, value_0);
     return result_0;
   }
   _keccak256_1(value_0) {
-    const result_0 = __compactRuntime.keccak256(_descriptor_17, value_0);
+    const result_0 = __compactRuntime.keccak256(_descriptor_19, value_0);
     return result_0;
   }
   _keccak256_2(value_0) {
-    const result_0 = __compactRuntime.keccak256(_descriptor_18, value_0);
+    const result_0 = __compactRuntime.keccak256(_descriptor_17, value_0);
     return result_0;
   }
   _mul_0(x_0, y_0) {
@@ -453,16 +446,15 @@ export class Contract {
                                                                                  32,
                                                                                  this._reverseBytes32_0(respondBidirectionalEvent_0.signature.bigR.x),
                                                                                  'Secp256k1Scalar',
-                                                                                 'Signet.compact line 398 char 12'),
+                                                                                 'Signet.compact line 341 char 12'),
                                           s:
                                             __compactRuntime.convertBytesToField(115792089237316195423570985008687907852837564279074904382605163141518161494336n,
                                                                                  32,
                                                                                  this._reverseBytes32_0(respondBidirectionalEvent_0.signature.s),
                                                                                  'Secp256k1Scalar',
-                                                                                 'Signet.compact line 399 char 12') },
+                                                                                 'Signet.compact line 342 char 12') },
                                         mpcResponseKey_0);
   }
-  _signetKeyHash_0(pk_0) { return this._persistentHash_0(pk_0); }
   _evmAddressAbiWord_0(addr_0) {
     return Uint8Array.from([...Array.from(new Uint8Array(12), BigInt),
                             ...Array.from(addr_0, BigInt)],
@@ -471,7 +463,7 @@ export class Contract {
   _numericAbiWord_0(value_0) {
     const le_0 = Array.from(__compactRuntime.convertBigintToBytes(16,
                                                                   value_0,
-                                                                  'Signet.compact line 480 char 17'),
+                                                                  'Signet.compact line 420 char 17'),
                             BigInt);
     return Uint8Array.from([...Array.from(new Uint8Array(16), BigInt),
                             le_0[15],
@@ -503,7 +495,7 @@ export class Contract {
                                                                 ((e, i) => e.slice(i, i+16))(word_0,
                                                                                              Number(0n)),
                                                                 'Field',
-                                                                'Signet.compact line 499 char 12')
+                                                                'Signet.compact line 438 char 12')
                             ===
                             0n,
                             'ABI word exceeds Uint<128>');
@@ -512,77 +504,77 @@ export class Contract {
                                                      ((e, i) => e.slice(i, i+1))(word_0,
                                                                                  Number(16n)),
                                                      'Field',
-                                                     'Signet.compact line 500 char 17');
+                                                     'Signet.compact line 439 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 501 char 30'));
+                                                                               'Signet.compact line 440 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 502 char 30'));
+                                                                               'Signet.compact line 441 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 503 char 30'));
+                                                                               'Signet.compact line 442 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 504 char 30'));
+                                                                               'Signet.compact line 443 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 505 char 30'));
+                                                                               'Signet.compact line 444 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 506 char 30'));
+                                                                               'Signet.compact line 445 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 507 char 30'));
+                                                                               'Signet.compact line 446 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 508 char 30'));
+                                                                               'Signet.compact line 447 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 509 char 30'));
+                                                                               'Signet.compact line 448 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 510 char 30'));
+                                                                                'Signet.compact line 449 char 30'));
     const b11_0 = __compactRuntime.addField(__compactRuntime.mulField(b10_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -590,7 +582,7 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(27n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 511 char 30'));
+                                                                                'Signet.compact line 450 char 30'));
     const b12_0 = __compactRuntime.addField(__compactRuntime.mulField(b11_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -598,7 +590,7 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(28n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 512 char 30'));
+                                                                                'Signet.compact line 451 char 30'));
     const b13_0 = __compactRuntime.addField(__compactRuntime.mulField(b12_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -606,7 +598,7 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(29n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 513 char 30'));
+                                                                                'Signet.compact line 452 char 30'));
     const b14_0 = __compactRuntime.addField(__compactRuntime.mulField(b13_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -614,7 +606,7 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(30n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 514 char 30'));
+                                                                                'Signet.compact line 453 char 30'));
     const b15_0 = __compactRuntime.addField(__compactRuntime.mulField(b14_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -622,10 +614,10 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(31n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 515 char 30'));
+                                                                                'Signet.compact line 454 char 30'));
     return ((t1) => {
              if (t1 > 340282366920938463463374607431768211455n) {
-               throw new __compactRuntime.CompactError('Signet.compact line 516 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 455 char 12: cast from Field or Uint value to smaller Uint value failed: ' + t1 + ' is greater than 340282366920938463463374607431768211455');
              }
              return t1;
            })(b15_0);
@@ -636,7 +628,7 @@ export class Contract {
                                                                 ((e, i) => e.slice(i, i+31))(word_0,
                                                                                              Number(0n)),
                                                                 'Field',
-                                                                'Signet.compact line 522 char 12')
+                                                                'Signet.compact line 461 char 12')
                             ===
                             0n,
                             'ABI word is not a canonical Boolean');
@@ -645,7 +637,7 @@ export class Contract {
                                                        ((e, i) => e.slice(i, i+1))(word_0,
                                                                                    Number(31n)),
                                                        'Field',
-                                                       'Signet.compact line 523 char 18');
+                                                       'Signet.compact line 462 char 18');
     __compactRuntime.assert(last_0 === 0n || last_0 === 1n,
                             'ABI word is not a canonical Boolean');
     return last_0 === 1n;
@@ -704,21 +696,21 @@ export const pureCircuits = {
     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 261 char 3',
+                                 'Signet.compact line 229 char 3',
                                  'struct ContractAddress<bytes: Bytes<32>>',
                                  callerAddress_0)
     }
     if (!(typeof(requestsPathDepth_0) === 'bigint' && requestsPathDepth_0 >= 0n && requestsPathDepth_0 <= 255n)) {
       __compactRuntime.typeError('constructSignBidirectionalEventNotificationV1',
                                  'argument 2',
-                                 'Signet.compact line 261 char 3',
+                                 'Signet.compact line 229 char 3',
                                  'Uint<0..256>',
                                  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 261 char 3',
+                                 'Signet.compact line 229 char 3',
                                  'Vector<4, Uint<0..256>>',
                                  requestsPath_0)
     }
@@ -726,13 +718,6 @@ export const pureCircuits = {
                                                                            requestsPathDepth_0,
                                                                            requestsPath_0);
   },
-  signetKeyHash: (...args_0) => {
-    if (args_0.length !== 1) {
-      throw new __compactRuntime.CompactError(`signetKeyHash: expected 1 argument (as invoked from Typescript), received ${args_0.length}`);
-    }
-    const pk_0 = args_0[0];
-    return _dummyContract._signetKeyHash_0(pk_0);
-  },
   evmAddressAbiWord: (...args_0) => {
     if (args_0.length !== 1) {
       throw new __compactRuntime.CompactError(`evmAddressAbiWord: expected 1 argument (as invoked from Typescript), received ${args_0.length}`);
@@ -741,7 +726,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 471 char 3',
+                                 'Signet.compact line 411 char 3',
                                  'Bytes<20>',
                                  addr_0)
     }
@@ -755,7 +740,7 @@ export const pureCircuits = {
     if (!(typeof(value_0) === 'bigint' && value_0 >= 0n && value_0 <= 340282366920938463463374607431768211455n)) {
       __compactRuntime.typeError('numericAbiWord',
                                  'argument 1',
-                                 'Signet.compact line 477 char 3',
+                                 'Signet.compact line 417 char 3',
                                  'Uint<0..340282366920938463463374607431768211456>',
                                  value_0)
     }
@@ -769,7 +754,7 @@ export const pureCircuits = {
     if (!(typeof(value_0) === 'boolean')) {
       __compactRuntime.typeError('boolAbiWord',
                                  'argument 1',
-                                 'Signet.compact line 490 char 3',
+                                 'Signet.compact line 430 char 3',
                                  'Boolean',
                                  value_0)
     }
@@ -783,7 +768,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 498 char 3',
+                                 'Signet.compact line 437 char 3',
                                  'Bytes<32>',
                                  word_0)
     }
@@ -797,7 +782,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 521 char 3',
+                                 'Signet.compact line 460 char 3',
                                  'Bytes<32>',
                                  word_0)
     }
@@ -812,14 +797,14 @@ export const pureCircuits = {
     if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
       __compactRuntime.typeError('calculateSignetAttestationDigest1',
                                  'argument 1',
-                                 'circuits.compact line 34 char 1',
+                                 'circuits.compact line 27 char 1',
                                  'Bytes<32>',
                                  requestId_0)
     }
     if (!(serializedOutput_0.buffer instanceof ArrayBuffer && serializedOutput_0.BYTES_PER_ELEMENT === 1 && serializedOutput_0.length === 1)) {
       __compactRuntime.typeError('calculateSignetAttestationDigest1',
                                  'argument 2',
-                                 'circuits.compact line 34 char 1',
+                                 'circuits.compact line 27 char 1',
                                  'Bytes<1>',
                                  serializedOutput_0)
     }
@@ -835,14 +820,14 @@ export const pureCircuits = {
     if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
       __compactRuntime.typeError('calculateSignetAttestationDigest32',
                                  'argument 1',
-                                 'circuits.compact line 41 char 1',
+                                 'circuits.compact line 34 char 1',
                                  'Bytes<32>',
                                  requestId_0)
     }
     if (!(serializedOutput_0.buffer instanceof ArrayBuffer && serializedOutput_0.BYTES_PER_ELEMENT === 1 && serializedOutput_0.length === 32)) {
       __compactRuntime.typeError('calculateSignetAttestationDigest32',
                                  'argument 2',
-                                 'circuits.compact line 41 char 1',
+                                 'circuits.compact line 34 char 1',
                                  'Bytes<32>',
                                  serializedOutput_0)
     }
@@ -858,14 +843,14 @@ export const pureCircuits = {
     if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
       __compactRuntime.typeError('calculateSignetAttestationDigest100',
                                  'argument 1',
-                                 'circuits.compact line 48 char 1',
+                                 'circuits.compact line 41 char 1',
                                  'Bytes<32>',
                                  requestId_0)
     }
     if (!(serializedOutput_0.buffer instanceof ArrayBuffer && serializedOutput_0.BYTES_PER_ELEMENT === 1 && serializedOutput_0.length === 100)) {
       __compactRuntime.typeError('calculateSignetAttestationDigest100',
                                  'argument 2',
-                                 'circuits.compact line 48 char 1',
+                                 'circuits.compact line 41 char 1',
                                  'Bytes<100>',
                                  serializedOutput_0)
     }
@@ -883,21 +868,21 @@ export const pureCircuits = {
     if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
       __compactRuntime.typeError('verifyRespondBidirectionalEvent32',
                                  'argument 1',
-                                 'circuits.compact line 55 char 1',
+                                 'circuits.compact line 48 char 1',
                                  'Bytes<32>',
                                  requestId_0)
     }
     if (!(serializedOutput_0.buffer instanceof ArrayBuffer && serializedOutput_0.BYTES_PER_ELEMENT === 1 && serializedOutput_0.length === 32)) {
       __compactRuntime.typeError('verifyRespondBidirectionalEvent32',
                                  'argument 2',
-                                 'circuits.compact line 55 char 1',
+                                 'circuits.compact line 48 char 1',
                                  'Bytes<32>',
                                  serializedOutput_0)
     }
     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',
+                                 'circuits.compact line 48 char 1',
                                  'struct RespondBidirectionalEvent<signature: struct Signature<bigR: struct AffinePoint<x: Bytes<32>, y: Bytes<32>>, s: Bytes<32>, recoveryId: Uint<0..256>>>',
                                  respondBidirectionalEvent_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;;;;;;;;;;MCoQE,MAAA,6CAsBC;;OAAA;MA6HD,MAAA,aAEC;;OAAA;MA6DD,MAAA,iBAEC;;OAAA;MAID,MAAA,cASC;;OAAA;MAID,MAAA,WAEC;;OAAA;MAMD,MAAA,gBAmBC;;OAAA;MAID,MAAA,aAKC;;OAAA;MD5eH,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;;;EDoQE,AAAA,gDAsBC,CAnBC,eAA8B;mDAG9B,mBAA0B;mDAI1B,cAAgC;;;;8CAMzB,eAAa;gCAChB,mBAAiB;gCACjB,cAAY;gCAAK,cAAY;gCAAK,cAAY;gCAAK,cAAY;;;GAIpE;EAoED,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;EAiBD,AAAA,kCAmBC,CAlBC,WAAoB;qCACpB,kBAA+C;qCAC/C,2BAAoD;qCACpD,gBAA8B;;UAExB,QAGL,4CAFC,WAAS;8DACT,kBAAgB;wCAIhB,QAAM;;;;wGAEc,2BAAyB;;;;;;wGACzB,2BAAyB;;;wCAE7C,gBAAc;GAEjB;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;ED5eH,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;;;;;;;;;;;;;;;;;;;;;;;ECkMC,AAAA,6CAsBC;;;;UAnBC,eAA8B;UAG9B,mBAA0B;UAI1B,cAAgC;;;;;;;;;;;;;;;;;;;;;;2EAPhC,eAA8B;2EAG9B,mBAA0B;2EAI1B,cAAgC;GAYjC;EA6HD,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;ED5eH,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/raw-contract-state.d.ts

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

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

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

package/dist/raw-contract-state.js

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

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

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