@sig-net/midnight 0.0.8 → 0.10.0

package/dist/managed/contract/index.js

@@ -1,115 +1,117 @@
 import * as __compactRuntime from '@midnight-ntwrk/compact-runtime';
 __compactRuntime.checkRuntimeVersion('0.18.0-rc.1');
 
-const _descriptor_0 = __compactRuntime.CompactTypeSecp256k1Point;
+const _descriptor_0 = new __compactRuntime.CompactTypeBytes(32);
 
-const _descriptor_1 = new __compactRuntime.CompactTypeBytes(32);
+const _descriptor_1 = new __compactRuntime.CompactTypeUnsignedInteger(340282366920938463463374607431768211455n, 16);
 
-const _descriptor_2 = new __compactRuntime.CompactTypeBytes(128);
+const _descriptor_2 = __compactRuntime.CompactTypeBoolean;
 
-const _descriptor_3 = new __compactRuntime.CompactTypeUnsignedInteger(255n, 1);
+const _descriptor_3 = __compactRuntime.CompactTypeSecp256k1Point;
+
+const _descriptor_4 = new __compactRuntime.CompactTypeBytes(20);
+
+const _descriptor_5 = new __compactRuntime.CompactTypeBytes(128);
+
+const _descriptor_6 = new __compactRuntime.CompactTypeUnsignedInteger(255n, 1);
 
 class _RespondBidirectionalEvent_0 {
   alignment() {
-    return _descriptor_2.alignment().concat(_descriptor_3.alignment().concat(_descriptor_1.alignment().concat(_descriptor_1.alignment().concat(_descriptor_3.alignment()))));
+    return _descriptor_5.alignment().concat(_descriptor_6.alignment().concat(_descriptor_0.alignment().concat(_descriptor_0.alignment().concat(_descriptor_6.alignment()))));
   }
   fromValue(value_0) {
     return {
-      serializedOutput: _descriptor_2.fromValue(value_0),
-      outputLen: _descriptor_3.fromValue(value_0),
-      r: _descriptor_1.fromValue(value_0),
-      s: _descriptor_1.fromValue(value_0),
-      recoveryId: _descriptor_3.fromValue(value_0)
+      serializedOutput: _descriptor_5.fromValue(value_0),
+      outputLen: _descriptor_6.fromValue(value_0),
+      r: _descriptor_0.fromValue(value_0),
+      s: _descriptor_0.fromValue(value_0),
+      recoveryId: _descriptor_6.fromValue(value_0)
     }
   }
   toValue(value_0) {
-    return _descriptor_2.toValue(value_0.serializedOutput).concat(_descriptor_3.toValue(value_0.outputLen).concat(_descriptor_1.toValue(value_0.r).concat(_descriptor_1.toValue(value_0.s).concat(_descriptor_3.toValue(value_0.recoveryId)))));
+    return _descriptor_5.toValue(value_0.serializedOutput).concat(_descriptor_6.toValue(value_0.outputLen).concat(_descriptor_0.toValue(value_0.r).concat(_descriptor_0.toValue(value_0.s).concat(_descriptor_6.toValue(value_0.recoveryId)))));
   }
 }
 
-const _descriptor_4 = new _RespondBidirectionalEvent_0();
+const _descriptor_7 = new _RespondBidirectionalEvent_0();
 
-const _descriptor_5 = __compactRuntime.CompactTypeBoolean;
-
-const _descriptor_6 = __compactRuntime.CompactTypeSecp256k1Scalar;
+const _descriptor_8 = __compactRuntime.CompactTypeSecp256k1Scalar;
 
 class _ContractAddress_0 {
   alignment() {
-    return _descriptor_1.alignment();
+    return _descriptor_0.alignment();
   }
   fromValue(value_0) {
     return {
-      bytes: _descriptor_1.fromValue(value_0)
+      bytes: _descriptor_0.fromValue(value_0)
     }
   }
   toValue(value_0) {
-    return _descriptor_1.toValue(value_0.bytes);
+    return _descriptor_0.toValue(value_0.bytes);
   }
 }
 
-const _descriptor_7 = new _ContractAddress_0();
+const _descriptor_9 = new _ContractAddress_0();
 
 class _SignBidirectionalEventNotification_0 {
   alignment() {
-    return _descriptor_3.alignment().concat(_descriptor_2.alignment());
+    return _descriptor_6.alignment().concat(_descriptor_5.alignment());
   }
   fromValue(value_0) {
     return {
-      version: _descriptor_3.fromValue(value_0),
-      payload: _descriptor_2.fromValue(value_0)
+      version: _descriptor_6.fromValue(value_0),
+      payload: _descriptor_5.fromValue(value_0)
     }
   }
   toValue(value_0) {
-    return _descriptor_3.toValue(value_0.version).concat(_descriptor_2.toValue(value_0.payload));
+    return _descriptor_6.toValue(value_0.version).concat(_descriptor_5.toValue(value_0.payload));
   }
 }
 
-const _descriptor_8 = new _SignBidirectionalEventNotification_0();
+const _descriptor_10 = new _SignBidirectionalEventNotification_0();
 
-const _descriptor_9 = __compactRuntime.CompactTypeSecp256k1Base;
+const _descriptor_11 = __compactRuntime.CompactTypeSecp256k1Base;
 
-const _descriptor_10 = new __compactRuntime.CompactTypeVector(2, _descriptor_1);
+const _descriptor_12 = new __compactRuntime.CompactTypeVector(2, _descriptor_0);
 
 class _Secp256k1EcdsaSignature_0 {
   alignment() {
-    return _descriptor_6.alignment().concat(_descriptor_6.alignment());
+    return _descriptor_8.alignment().concat(_descriptor_8.alignment());
   }
   fromValue(value_0) {
     return {
-      r: _descriptor_6.fromValue(value_0),
-      s: _descriptor_6.fromValue(value_0)
+      r: _descriptor_8.fromValue(value_0),
+      s: _descriptor_8.fromValue(value_0)
     }
   }
   toValue(value_0) {
-    return _descriptor_6.toValue(value_0.r).concat(_descriptor_6.toValue(value_0.s));
+    return _descriptor_8.toValue(value_0.r).concat(_descriptor_8.toValue(value_0.s));
   }
 }
 
-const _descriptor_11 = new _Secp256k1EcdsaSignature_0();
+const _descriptor_13 = new _Secp256k1EcdsaSignature_0();
 
-const _descriptor_12 = new __compactRuntime.CompactTypeUnsignedInteger(18446744073709551615n, 8);
+const _descriptor_14 = new __compactRuntime.CompactTypeUnsignedInteger(18446744073709551615n, 8);
 
 class _Either_0 {
   alignment() {
-    return _descriptor_5.alignment().concat(_descriptor_1.alignment().concat(_descriptor_1.alignment()));
+    return _descriptor_2.alignment().concat(_descriptor_0.alignment().concat(_descriptor_0.alignment()));
   }
   fromValue(value_0) {
     return {
-      is_left: _descriptor_5.fromValue(value_0),
-      left: _descriptor_1.fromValue(value_0),
-      right: _descriptor_1.fromValue(value_0)
+      is_left: _descriptor_2.fromValue(value_0),
+      left: _descriptor_0.fromValue(value_0),
+      right: _descriptor_0.fromValue(value_0)
     }
   }
   toValue(value_0) {
-    return _descriptor_5.toValue(value_0.is_left).concat(_descriptor_1.toValue(value_0.left).concat(_descriptor_1.toValue(value_0.right)));
+    return _descriptor_2.toValue(value_0.is_left).concat(_descriptor_0.toValue(value_0.left).concat(_descriptor_0.toValue(value_0.right)));
   }
 }
 
-const _descriptor_13 = new _Either_0();
-
-const _descriptor_14 = new __compactRuntime.CompactTypeUnsignedInteger(340282366920938463463374607431768211455n, 16);
+const _descriptor_15 = new _Either_0();
 
-const _descriptor_15 = new __compactRuntime.CompactTypeUnsignedInteger(4294967295n, 4);
+const _descriptor_16 = new __compactRuntime.CompactTypeUnsignedInteger(4294967295n, 4);
 
 export class Contract {
   witnesses;
@@ -134,6 +136,21 @@ export class Contract {
       },
       async signetKeyHash(context, ...args_1) {
         return { result: pureCircuits.signetKeyHash(...args_1), context };
+      },
+      async evmAddressAbiWord(context, ...args_1) {
+        return { result: pureCircuits.evmAddressAbiWord(...args_1), context };
+      },
+      async numericAbiWord(context, ...args_1) {
+        return { result: pureCircuits.numericAbiWord(...args_1), context };
+      },
+      async boolAbiWord(context, ...args_1) {
+        return { result: pureCircuits.boolAbiWord(...args_1), context };
+      },
+      async abiWordToUint128(context, ...args_1) {
+        return { result: pureCircuits.abiWordToUint128(...args_1), context };
+      },
+      async abiWordToBool(context, ...args_1) {
+        return { result: pureCircuits.abiWordToBool(...args_1), context };
       }
     };
     this.impureCircuits = {};
@@ -232,15 +249,15 @@ export class Contract {
            r_0;
   }
   _persistentHash_0(value_0) {
-    const result_0 = __compactRuntime.persistentHash(_descriptor_10, value_0);
+    const result_0 = __compactRuntime.persistentHash(_descriptor_12, value_0);
     return result_0;
   }
   _persistentHash_1(value_0) {
-    const result_0 = __compactRuntime.persistentHash(_descriptor_2, value_0);
+    const result_0 = __compactRuntime.persistentHash(_descriptor_5, value_0);
     return result_0;
   }
   _persistentHash_2(value_0) {
-    const result_0 = __compactRuntime.persistentHash(_descriptor_0, value_0);
+    const result_0 = __compactRuntime.persistentHash(_descriptor_3, value_0);
     return result_0;
   }
   _mul_0(x_0, y_0) {
@@ -281,7 +298,7 @@ export class Contract {
     const outHash_0 = this._persistentHash_0([this._persistentHash_1(serializedOutput_0),
                                               __compactRuntime.convertBigintToBytes(32,
                                                                                     outputLen_0,
-                                                                                    'Signet.compact line 285 char 7')]);
+                                                                                    'Signet.compact line 287 char 7')]);
     return this._persistentHash_0([requestId_0, outHash_0]);
   }
   _verifyRespondBidirectionalEvent_0(requestId_0,
@@ -296,16 +313,203 @@ export class Contract {
                                                                                  32,
                                                                                  respondBidirectionalEvent_0.r,
                                                                                  'Secp256k1Scalar',
-                                                                                 'Signet.compact line 308 char 12'),
+                                                                                 'Signet.compact line 310 char 12'),
                                           s:
                                             __compactRuntime.convertBytesToField(115792089237316195423570985008687907852837564279074904382605163141518161494336n,
                                                                                  32,
                                                                                  respondBidirectionalEvent_0.s,
                                                                                  'Secp256k1Scalar',
-                                                                                 'Signet.compact line 309 char 12') },
+                                                                                 'Signet.compact line 311 char 12') },
                                         mpcResponseKey_0);
   }
   _signetKeyHash_0(pk_0) { return this._persistentHash_2(pk_0); }
+  _evmAddressAbiWord_0(addr_0) {
+    return Uint8Array.from([...Array.from(new Uint8Array(12), BigInt),
+                            ...Array.from(addr_0, BigInt)],
+                           Number);
+  }
+  _numericAbiWord_0(value_0) {
+    const le_0 = Array.from(__compactRuntime.convertBigintToBytes(16,
+                                                                  value_0,
+                                                                  'Signet.compact line 390 char 17'),
+                            BigInt);
+    return Uint8Array.from([...Array.from(new Uint8Array(16), BigInt),
+                            le_0[15],
+                            le_0[14],
+                            le_0[13],
+                            le_0[12],
+                            le_0[11],
+                            le_0[10],
+                            le_0[9],
+                            le_0[8],
+                            le_0[7],
+                            le_0[6],
+                            le_0[5],
+                            le_0[4],
+                            le_0[3],
+                            le_0[2],
+                            le_0[1],
+                            le_0[0]],
+                           Number);
+  }
+  _boolAbiWord_0(value_0) {
+    return Uint8Array.from([...Array.from(new Uint8Array(31), BigInt),
+                            value_0 ? 1n : 0n],
+                           Number);
+  }
+  _abiWordToUint128_0(word_0) {
+    __compactRuntime.assert(__compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                16,
+                                                                ((e, i) => e.slice(i, i+16))(word_0,
+                                                                                             Number(0n)),
+                                                                'Field',
+                                                                'Signet.compact line 409 char 12')
+                            ===
+                            0n,
+                            'ABI word exceeds Uint<128>');
+    const b0_0 = __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                     1,
+                                                     ((e, i) => e.slice(i, i+1))(word_0,
+                                                                                 Number(16n)),
+                                                     'Field',
+                                                     'Signet.compact line 410 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 411 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 412 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 413 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 414 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 415 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 416 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 417 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 418 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 419 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 420 char 30'));
+    const b11_0 = __compactRuntime.addField(__compactRuntime.mulField(b10_0,
+                                                                      256n),
+                                            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                1,
+                                                                                ((e, i) => e.slice(i, i+1))(word_0,
+                                                                                                            Number(27n)),
+                                                                                'Field',
+                                                                                'Signet.compact line 421 char 30'));
+    const b12_0 = __compactRuntime.addField(__compactRuntime.mulField(b11_0,
+                                                                      256n),
+                                            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                1,
+                                                                                ((e, i) => e.slice(i, i+1))(word_0,
+                                                                                                            Number(28n)),
+                                                                                'Field',
+                                                                                'Signet.compact line 422 char 30'));
+    const b13_0 = __compactRuntime.addField(__compactRuntime.mulField(b12_0,
+                                                                      256n),
+                                            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                1,
+                                                                                ((e, i) => e.slice(i, i+1))(word_0,
+                                                                                                            Number(29n)),
+                                                                                'Field',
+                                                                                'Signet.compact line 423 char 30'));
+    const b14_0 = __compactRuntime.addField(__compactRuntime.mulField(b13_0,
+                                                                      256n),
+                                            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                1,
+                                                                                ((e, i) => e.slice(i, i+1))(word_0,
+                                                                                                            Number(30n)),
+                                                                                'Field',
+                                                                                'Signet.compact line 424 char 30'));
+    const b15_0 = __compactRuntime.addField(__compactRuntime.mulField(b14_0,
+                                                                      256n),
+                                            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                1,
+                                                                                ((e, i) => e.slice(i, i+1))(word_0,
+                                                                                                            Number(31n)),
+                                                                                'Field',
+                                                                                'Signet.compact line 425 char 30'));
+    return ((t1) => {
+             if (t1 > 340282366920938463463374607431768211455n) {
+               throw new __compactRuntime.CompactError('Signet.compact line 426 char 12: cast from Field or Uint value to smaller Uint value failed: ' + t1 + ' is greater than 340282366920938463463374607431768211455');
+             }
+             return t1;
+           })(b15_0);
+  }
+  _abiWordToBool_0(word_0) {
+    __compactRuntime.assert(__compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                31,
+                                                                ((e, i) => e.slice(i, i+31))(word_0,
+                                                                                             Number(0n)),
+                                                                'Field',
+                                                                'Signet.compact line 432 char 12')
+                            ===
+                            0n,
+                            'ABI word is not a canonical Boolean');
+    const last_0 = __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                       1,
+                                                       ((e, i) => e.slice(i, i+1))(word_0,
+                                                                                   Number(31n)),
+                                                       'Field',
+                                                       'Signet.compact line 433 char 18');
+    __compactRuntime.assert(last_0 === 0n || last_0 === 1n,
+                            'ABI word is not a canonical Boolean');
+    return last_0 === 1n;
+  }
 }
 export function ledger(stateOrChargedState) {
   const state = stateOrChargedState instanceof __compactRuntime.StateValue ? stateOrChargedState : stateOrChargedState.state;
@@ -337,14 +541,14 @@ 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 209 char 3',
+                                 'Signet.compact line 211 char 3',
                                  'struct ContractAddress<bytes: Bytes<32>>',
                                  callerAddress_0)
     }
     if (!(typeof(requestsIndexField_0) === 'bigint' && requestsIndexField_0 >= 0n && requestsIndexField_0 <= 255n)) {
       __compactRuntime.typeError('constructSignBidirectionalEventNotificationV1',
                                  'argument 2',
-                                 'Signet.compact line 209 char 3',
+                                 'Signet.compact line 211 char 3',
                                  'Uint<0..256>',
                                  requestsIndexField_0)
     }
@@ -361,21 +565,21 @@ export const pureCircuits = {
     if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
       __compactRuntime.typeError('signetAttestationDigest',
                                  'argument 1',
-                                 'Signet.compact line 278 char 3',
+                                 'Signet.compact line 280 char 3',
                                  'Bytes<32>',
                                  requestId_0)
     }
     if (!(serializedOutput_0.buffer instanceof ArrayBuffer && serializedOutput_0.BYTES_PER_ELEMENT === 1 && serializedOutput_0.length === 128)) {
       __compactRuntime.typeError('signetAttestationDigest',
                                  'argument 2',
-                                 'Signet.compact line 278 char 3',
+                                 'Signet.compact line 280 char 3',
                                  'Bytes<128>',
                                  serializedOutput_0)
     }
     if (!(typeof(outputLen_0) === 'bigint' && outputLen_0 >= 0n && outputLen_0 <= 255n)) {
       __compactRuntime.typeError('signetAttestationDigest',
                                  'argument 3',
-                                 'Signet.compact line 278 char 3',
+                                 'Signet.compact line 280 char 3',
                                  'Uint<0..256>',
                                  outputLen_0)
     }
@@ -393,14 +597,14 @@ export const pureCircuits = {
     if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
       __compactRuntime.typeError('verifyRespondBidirectionalEvent',
                                  'argument 1',
-                                 'Signet.compact line 296 char 3',
+                                 'Signet.compact line 298 char 3',
                                  'Bytes<32>',
                                  requestId_0)
     }
     if (!(typeof(respondBidirectionalEvent_0) === 'object' && respondBidirectionalEvent_0.serializedOutput.buffer instanceof ArrayBuffer && respondBidirectionalEvent_0.serializedOutput.BYTES_PER_ELEMENT === 1 && respondBidirectionalEvent_0.serializedOutput.length === 128 && typeof(respondBidirectionalEvent_0.outputLen) === 'bigint' && respondBidirectionalEvent_0.outputLen >= 0n && respondBidirectionalEvent_0.outputLen <= 255n && respondBidirectionalEvent_0.r.buffer instanceof ArrayBuffer && respondBidirectionalEvent_0.r.BYTES_PER_ELEMENT === 1 && respondBidirectionalEvent_0.r.length === 32 && respondBidirectionalEvent_0.s.buffer instanceof ArrayBuffer && respondBidirectionalEvent_0.s.BYTES_PER_ELEMENT === 1 && respondBidirectionalEvent_0.s.length === 32 && typeof(respondBidirectionalEvent_0.recoveryId) === 'bigint' && respondBidirectionalEvent_0.recoveryId >= 0n && respondBidirectionalEvent_0.recoveryId <= 255n)) {
       __compactRuntime.typeError('verifyRespondBidirectionalEvent',
                                  'argument 2',
-                                 'Signet.compact line 296 char 3',
+                                 'Signet.compact line 298 char 3',
                                  'struct RespondBidirectionalEvent<serializedOutput: Bytes<128>, outputLen: Uint<0..256>, r: Bytes<32>, s: Bytes<32>, recoveryId: Uint<0..256>>',
                                  respondBidirectionalEvent_0)
     }
@@ -414,6 +618,76 @@ export const pureCircuits = {
     }
     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}`);
+    }
+    const addr_0 = args_0[0];
+    if (!(addr_0.buffer instanceof ArrayBuffer && addr_0.BYTES_PER_ELEMENT === 1 && addr_0.length === 20)) {
+      __compactRuntime.typeError('evmAddressAbiWord',
+                                 'argument 1',
+                                 'Signet.compact line 381 char 3',
+                                 'Bytes<20>',
+                                 addr_0)
+    }
+    return _dummyContract._evmAddressAbiWord_0(addr_0);
+  },
+  numericAbiWord: (...args_0) => {
+    if (args_0.length !== 1) {
+      throw new __compactRuntime.CompactError(`numericAbiWord: expected 1 argument (as invoked from Typescript), received ${args_0.length}`);
+    }
+    const value_0 = args_0[0];
+    if (!(typeof(value_0) === 'bigint' && value_0 >= 0n && value_0 <= 340282366920938463463374607431768211455n)) {
+      __compactRuntime.typeError('numericAbiWord',
+                                 'argument 1',
+                                 'Signet.compact line 387 char 3',
+                                 'Uint<0..340282366920938463463374607431768211456>',
+                                 value_0)
+    }
+    return _dummyContract._numericAbiWord_0(value_0);
+  },
+  boolAbiWord: (...args_0) => {
+    if (args_0.length !== 1) {
+      throw new __compactRuntime.CompactError(`boolAbiWord: expected 1 argument (as invoked from Typescript), received ${args_0.length}`);
+    }
+    const value_0 = args_0[0];
+    if (!(typeof(value_0) === 'boolean')) {
+      __compactRuntime.typeError('boolAbiWord',
+                                 'argument 1',
+                                 'Signet.compact line 400 char 3',
+                                 'Boolean',
+                                 value_0)
+    }
+    return _dummyContract._boolAbiWord_0(value_0);
+  },
+  abiWordToUint128: (...args_0) => {
+    if (args_0.length !== 1) {
+      throw new __compactRuntime.CompactError(`abiWordToUint128: expected 1 argument (as invoked from Typescript), received ${args_0.length}`);
+    }
+    const word_0 = args_0[0];
+    if (!(word_0.buffer instanceof ArrayBuffer && word_0.BYTES_PER_ELEMENT === 1 && word_0.length === 32)) {
+      __compactRuntime.typeError('abiWordToUint128',
+                                 'argument 1',
+                                 'Signet.compact line 408 char 3',
+                                 'Bytes<32>',
+                                 word_0)
+    }
+    return _dummyContract._abiWordToUint128_0(word_0);
+  },
+  abiWordToBool: (...args_0) => {
+    if (args_0.length !== 1) {
+      throw new __compactRuntime.CompactError(`abiWordToBool: expected 1 argument (as invoked from Typescript), received ${args_0.length}`);
+    }
+    const word_0 = args_0[0];
+    if (!(word_0.buffer instanceof ArrayBuffer && word_0.BYTES_PER_ELEMENT === 1 && word_0.length === 32)) {
+      __compactRuntime.typeError('abiWordToBool',
+                                 'argument 1',
+                                 'Signet.compact line 431 char 3',
+                                 'Bytes<32>',
+                                 word_0)
+    }
+    return _dummyContract._abiWordToBool_0(word_0);
   }
 };
 export const contractReferenceLocations =

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;;;;;;;;;;MCgNE,MAAA,6CAWC;;OAAA;MA0DD,MAAA,uBAUC;;OAAA;MAQD,MAAA,+BAiBC;;OAAA;MAKD,MAAA,aAEC;;OAAA;;;;GDzRF;EAtCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCC;EEVD,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;qEAAA;;;EAAA,AAAA,kBAAA;oEAAA;;;EAAA,AAAA,kBAAA;oEAAA;;;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;;;EDgNE,AAAA,gDAWC,CARC,eAA8B;mDAC9B,oBAA2B;;;;8CAKP,eAAa;gCAAQ,oBAAkB;;;GAE5D;EA0DD,AAAA,0BAUC,CATC,WAAoB,EACpB,kBAA4B,EAC5B,WAAkB;UAEZ,SAGJ,kDAF2B,kBAAgB;;oFAC3C,WAAS;;mCAEkC,WAAS,EAAe,SAAO;GAC7E;EAQD,AAAA,kCAiBC,CAhBC,WAAoB;qCACpB,2BAAoD;qCACpD,gBAA8B;;wEAI1B,WAAS;wEACT,2BAAyB;wEACzB,2BAAyB;;;;iFAGtB,2BAAyB;;;;;;iFACzB,2BAAyB;;;wCAE9B,gBAAc;GAEjB;EAKD,AAAA,gBAEC,CAFiC,IAAkB,kCACZ,IAAE,IACzC;;;;;;;;;;;;;;;;;;;;;;;EA/GD,AAAA,6CAWC;;;;UARC,eAA8B;UAC9B,oBAA2B;;;;;;;;;;;;;;;2EAD3B,eAA8B;2EAC9B,oBAA2B;GAO5B;EA0DD,AAAA,uBAUC;;;;UATC,WAAoB;UACpB,kBAA4B;UAC5B,WAAkB;;;;;;;;;;;;;;;;;;;;;;qDAFlB,WAAoB;qDACpB,kBAA4B;qDAC5B,WAAkB;GAOnB;EAQD,AAAA,+BAiBC;;;;UAhBC,WAAoB;UACpB,2BAAoD;UACpD,gBAA8B;;;;;;;;;;;;;;;6DAF9B,WAAoB;6DACpB,2BAAoD;6DACpD,gBAA8B;GAc/B;EAKD,AAAA,aAEC;;;;UAFiC,IAAkB;2CAAlB,IAAkB;GAEnD;;;;;;"
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAA;;;;;;;;;;MCkNE,MAAA,6CAWC;;OAAA;MA0DD,MAAA,uBAUC;;OAAA;MAQD,MAAA,+BAiBC;;OAAA;MAKD,MAAA,aAEC;;OAAA;MA2DD,MAAA,iBAEC;;OAAA;MAID,MAAA,cASC;;OAAA;MAID,MAAA,WAEC;;OAAA;MAMD,MAAA,gBAmBC;;OAAA;MAID,MAAA,aAKC;;OAAA;;;;GD3ZF;EAxBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwBC;EEID,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;qEAAA;;;EAAA,AAAA,kBAAA;oEAAA;;;EAAA,AAAA,kBAAA;oEAAA;;;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;;;EDkNE,AAAA,gDAWC,CARC,eAA8B;mDAC9B,oBAA2B;;;;8CAKP,eAAa;gCAAQ,oBAAkB;;;GAE5D;EA0DD,AAAA,0BAUC,CATC,WAAoB,EACpB,kBAA4B,EAC5B,WAAkB;UAEZ,SAGJ,kDAF2B,kBAAgB;;oFAC3C,WAAS;;mCAEkC,WAAS,EAAe,SAAO;GAC7E;EAQD,AAAA,kCAiBC,CAhBC,WAAoB;qCACpB,2BAAoD;qCACpD,gBAA8B;;wEAI1B,WAAS;wEACT,2BAAyB;wEACzB,2BAAyB;;;;iFAGtB,2BAAyB;;;;;;iFACzB,2BAAyB;;;wCAE9B,gBAAc;GAEjB;EAKD,AAAA,gBAEC,CAFiC,IAAkB,kCACZ,IAAE,IACzC;EA2DD,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;;;;;;;;;;;;;;;;;;;;;;;EAjOD,AAAA,6CAWC;;;;UARC,eAA8B;UAC9B,oBAA2B;;;;;;;;;;;;;;;2EAD3B,eAA8B;2EAC9B,oBAA2B;GAO5B;EA0DD,AAAA,uBAUC;;;;UATC,WAAoB;UACpB,kBAA4B;UAC5B,WAAkB;;;;;;;;;;;;;;;;;;;;;;qDAFlB,WAAoB;qDACpB,kBAA4B;qDAC5B,WAAkB;GAOnB;EAQD,AAAA,+BAiBC;;;;UAhBC,WAAoB;UACpB,2BAAoD;UACpD,gBAA8B;;;;;;;;;;;;;;;6DAF9B,WAAoB;6DACpB,2BAAoD;6DACpD,gBAA8B;GAc/B;EAKD,AAAA,aAEC;;;;UAFiC,IAAkB;2CAAlB,IAAkB;GAEnD;EA2DD,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;;;;;;"
 }

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":"AAeA,OAAO,EAGL,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;AA4E5C;;;;;;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,CAwBtB;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":"AAgBA,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;AA4E5C;;;;;;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,CAwBtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,gBAAgB,EACrB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,YAAY,GACtB,sBAAsB,GAAG,SAAS,CA2BpC"}

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

@@ -10,7 +10,8 @@
 // the record descriptors themselves are the parameterized twins in
 // signet-requests.ts. The generic tree walk and shared base descriptors live
 // in signature-state-reading.ts.
-import { requestIdHex, signBidirectionalEventDescriptor, } from "./signet-requests.js";
+import { signBidirectionalEventDescriptor } from "./signet-evtype2tx-requests.js";
+import { requestIdHex, } from "./signet-requests.js";
 import { requestIdType, signetFieldNode, u64, } from "./signature-state-reading.js";
 /**
  * Aligned-value entry count of an event record EXCLUDING the capacity-scaled

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

@@ -1 +1 @@
-{"version":3,"file":"signature-requests-state-reader.js","sourceRoot":"","sources":["../src/signature-requests-state-reader.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"signature-requests-state-reader.js","sourceRoot":"","sources":["../src/signature-requests-state-reader.ts"],"names":[],"mappings":"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"}

package/dist/signature-response-verification.d.ts

@@ -1,4 +1,4 @@
-import { type SignBidirectionalEvent } from "./signet-requests.ts";
+import type { SignBidirectionalEvent } from "./signet-requests.ts";
 import type { SignatureRespondedEvent } from "./signet-contract-state-reader.ts";
 /**
  * Recover the EVM address that produced a response signature, over the

package/dist/signature-response-verification.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signature-response-verification.d.ts","sourceRoot":"","sources":["../src/signature-response-verification.ts"],"names":[],"mappings":"AAWA,OAAO,EAGL,KAAK,sBAAsB,EAC5B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AAEjF;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,sBAAsB,EAC/B,QAAQ,EAAE,uBAAuB,GAChC,MAAM,CAKR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,sBAAsB,EAC/B,QAAQ,EAAE,uBAAuB,EACjC,cAAc,EAAE,MAAM,GACrB,OAAO,CAST"}
+{"version":3,"file":"signature-response-verification.d.ts","sourceRoot":"","sources":["../src/signature-response-verification.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AAEjF;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,sBAAsB,EAC/B,QAAQ,EAAE,uBAAuB,GAChC,MAAM,CAKR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,sBAAsB,EAC/B,QAAQ,EAAE,uBAAuB,EACjC,cAAc,EAAE,MAAM,GACrB,OAAO,CAST"}

package/dist/signature-response-verification.js

@@ -7,7 +7,7 @@
 // check that the posted `{ bigR, s, recoveryId }` signature recovers to the
 // requester's derived EVM address over that transaction's signing hash.
 import { getAddress, recoverAddress } from "ethers";
-import { signBidirectionalEventToUnsignedEVMTransaction, signatureRespondedEventToSignature, } from "./signet-requests.js";
+import { signBidirectionalEventToUnsignedEVMTransaction, signatureRespondedEventToSignature, } from "./signet-evtype2tx-requests.js";
 /**
  * Recover the EVM address that produced a response signature, over the
  * signing hash of the transaction the request describes.