@sig-net/midnight 0.0.9 → 0.10.0

package/dist/managed/contract/index.js

@@ -1,53 +1,53 @@
 import * as __compactRuntime from '@midnight-ntwrk/compact-runtime';
 __compactRuntime.checkRuntimeVersion('0.18.0-rc.1');
 
-const _descriptor_0 = new __compactRuntime.CompactTypeUnsignedInteger(340282366920938463463374607431768211455n, 16);
+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 = __compactRuntime.CompactTypeSecp256k1Point;
+const _descriptor_2 = __compactRuntime.CompactTypeBoolean;
 
-const _descriptor_3 = new __compactRuntime.CompactTypeBytes(20);
+const _descriptor_3 = __compactRuntime.CompactTypeSecp256k1Point;
 
-const _descriptor_4 = new __compactRuntime.CompactTypeBytes(128);
+const _descriptor_4 = new __compactRuntime.CompactTypeBytes(20);
 
-const _descriptor_5 = new __compactRuntime.CompactTypeUnsignedInteger(255n, 1);
+const _descriptor_5 = new __compactRuntime.CompactTypeBytes(128);
+
+const _descriptor_6 = new __compactRuntime.CompactTypeUnsignedInteger(255n, 1);
 
 class _RespondBidirectionalEvent_0 {
   alignment() {
-    return _descriptor_4.alignment().concat(_descriptor_5.alignment().concat(_descriptor_1.alignment().concat(_descriptor_1.alignment().concat(_descriptor_5.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_4.fromValue(value_0),
-      outputLen: _descriptor_5.fromValue(value_0),
-      r: _descriptor_1.fromValue(value_0),
-      s: _descriptor_1.fromValue(value_0),
-      recoveryId: _descriptor_5.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_4.toValue(value_0.serializedOutput).concat(_descriptor_5.toValue(value_0.outputLen).concat(_descriptor_1.toValue(value_0.r).concat(_descriptor_1.toValue(value_0.s).concat(_descriptor_5.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_6 = new _RespondBidirectionalEvent_0();
-
-const _descriptor_7 = __compactRuntime.CompactTypeBoolean;
+const _descriptor_7 = new _RespondBidirectionalEvent_0();
 
 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);
   }
 }
 
@@ -55,16 +55,16 @@ const _descriptor_9 = new _ContractAddress_0();
 
 class _SignBidirectionalEventNotification_0 {
   alignment() {
-    return _descriptor_5.alignment().concat(_descriptor_4.alignment());
+    return _descriptor_6.alignment().concat(_descriptor_5.alignment());
   }
   fromValue(value_0) {
     return {
-      version: _descriptor_5.fromValue(value_0),
-      payload: _descriptor_4.fromValue(value_0)
+      version: _descriptor_6.fromValue(value_0),
+      payload: _descriptor_5.fromValue(value_0)
     }
   }
   toValue(value_0) {
-    return _descriptor_5.toValue(value_0.version).concat(_descriptor_4.toValue(value_0.payload));
+    return _descriptor_6.toValue(value_0.version).concat(_descriptor_5.toValue(value_0.payload));
   }
 }
 
@@ -72,7 +72,7 @@ const _descriptor_10 = new _SignBidirectionalEventNotification_0();
 
 const _descriptor_11 = __compactRuntime.CompactTypeSecp256k1Base;
 
-const _descriptor_12 = new __compactRuntime.CompactTypeVector(2, _descriptor_1);
+const _descriptor_12 = new __compactRuntime.CompactTypeVector(2, _descriptor_0);
 
 class _Secp256k1EcdsaSignature_0 {
   alignment() {
@@ -95,17 +95,17 @@ const _descriptor_14 = new __compactRuntime.CompactTypeUnsignedInteger(184467440
 
 class _Either_0 {
   alignment() {
-    return _descriptor_7.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_7.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_7.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)));
   }
 }
 
@@ -143,8 +143,14 @@ export class Contract {
       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 = {};
@@ -247,11 +253,11 @@ export class Contract {
     return result_0;
   }
   _persistentHash_1(value_0) {
-    const result_0 = __compactRuntime.persistentHash(_descriptor_4, value_0);
+    const result_0 = __compactRuntime.persistentHash(_descriptor_5, value_0);
     return result_0;
   }
   _persistentHash_2(value_0) {
-    const result_0 = __compactRuntime.persistentHash(_descriptor_2, value_0);
+    const result_0 = __compactRuntime.persistentHash(_descriptor_3, value_0);
     return result_0;
   }
   _mul_0(x_0, y_0) {
@@ -292,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,
@@ -307,13 +313,13 @@ 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); }
@@ -325,7 +331,7 @@ export class Contract {
   _numericAbiWord_0(value_0) {
     const le_0 = Array.from(__compactRuntime.convertBigintToBytes(16,
                                                                   value_0,
-                                                                  'Signet.compact line 389 char 17'),
+                                                                  'Signet.compact line 390 char 17'),
                             BigInt);
     return Uint8Array.from([...Array.from(new Uint8Array(16), BigInt),
                             le_0[15],
@@ -346,13 +352,18 @@ export class Contract {
                             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 402 char 12')
+                                                                'Signet.compact line 409 char 12')
                             ===
                             0n,
                             'ABI word exceeds Uint<128>');
@@ -361,77 +372,77 @@ export class Contract {
                                                      ((e, i) => e.slice(i, i+1))(word_0,
                                                                                  Number(16n)),
                                                      'Field',
-                                                     'Signet.compact line 403 char 17');
+                                                     '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 404 char 30'));
+                                                                               '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 405 char 30'));
+                                                                               '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 406 char 30'));
+                                                                               '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 407 char 30'));
+                                                                               '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 408 char 30'));
+                                                                               '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 409 char 30'));
+                                                                               '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 410 char 30'));
+                                                                               '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 411 char 30'));
+                                                                               '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 412 char 30'));
+                                                                               '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 413 char 30'));
+                                                                                'Signet.compact line 420 char 30'));
     const b11_0 = __compactRuntime.addField(__compactRuntime.mulField(b10_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -439,7 +450,7 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(27n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 414 char 30'));
+                                                                                'Signet.compact line 421 char 30'));
     const b12_0 = __compactRuntime.addField(__compactRuntime.mulField(b11_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -447,7 +458,7 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(28n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 415 char 30'));
+                                                                                'Signet.compact line 422 char 30'));
     const b13_0 = __compactRuntime.addField(__compactRuntime.mulField(b12_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -455,7 +466,7 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(29n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 416 char 30'));
+                                                                                'Signet.compact line 423 char 30'));
     const b14_0 = __compactRuntime.addField(__compactRuntime.mulField(b13_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -463,7 +474,7 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(30n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 417 char 30'));
+                                                                                'Signet.compact line 424 char 30'));
     const b15_0 = __compactRuntime.addField(__compactRuntime.mulField(b14_0,
                                                                       256n),
                                             __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
@@ -471,14 +482,34 @@ export class Contract {
                                                                                 ((e, i) => e.slice(i, i+1))(word_0,
                                                                                                             Number(31n)),
                                                                                 'Field',
-                                                                                'Signet.compact line 418 char 30'));
+                                                                                'Signet.compact line 425 char 30'));
     return ((t1) => {
              if (t1 > 340282366920938463463374607431768211455n) {
-               throw new __compactRuntime.CompactError('Signet.compact line 419 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 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;
@@ -510,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)
     }
@@ -534,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)
     }
@@ -566,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)
     }
@@ -610,12 +641,26 @@ export const pureCircuits = {
     if (!(typeof(value_0) === 'bigint' && value_0 >= 0n && value_0 <= 340282366920938463463374607431768211455n)) {
       __compactRuntime.typeError('numericAbiWord',
                                  'argument 1',
-                                 'Signet.compact line 388 char 3',
+                                 '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}`);
@@ -624,11 +669,25 @@ 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 401 char 3',
+                                 '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": "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"
+  "mappings": "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"
 }

package/dist/signet-evtype2tx-requests.d.ts

@@ -139,6 +139,15 @@ export declare function numericAbiWord(value: bigint): Uint8Array;
  * @throws Error if the address is not exactly 20 bytes.
  */
 export declare function evmAddressAbiWord(address: Uint8Array): Uint8Array;
+/**
+ * The ABI word for a Boolean: 31 zero bytes, then 0x01 (true) or 0x00
+ * (false). TS mirror of Signet.compact's `boolAbiWord` circuit
+ * (lockstep-tested against the compiled circuit).
+ *
+ * @param value - The word's Boolean value.
+ * @returns The ABI-ready 32-byte word to store in an {@link EVMCalldata} word.
+ */
+export declare function boolAbiWord(value: boolean): Uint8Array;
 /**
  * Read a numeric ABI word back into a bigint: the big-endian reading of bytes
  * 16..31. TS mirror of Signet.compact's `abiWordToUint128` circuit, including
@@ -150,6 +159,16 @@ export declare function evmAddressAbiWord(address: Uint8Array): Uint8Array;
  * @throws Error if the word is not 32 bytes or its leading half is nonzero.
  */
 export declare function abiWordToUint128(word: Uint8Array): bigint;
+/**
+ * Read a Boolean ABI word back into a boolean. TS mirror of Signet.compact's
+ * `abiWordToBool` circuit, including its canonicality check: the first 31
+ * bytes must be zero and the last byte 0 or 1.
+ *
+ * @param word - The ABI-ready 32-byte word.
+ * @returns The word's Boolean value.
+ * @throws Error if the word is not 32 bytes or is not a canonical Boolean.
+ */
+export declare function abiWordToBool(word: Uint8Array): boolean;
 /**
  * Assemble the raw calldata a request's words describe:
  * `data = selector || words[0..noWords]`, VERBATIM. Words are stored

package/dist/signet-evtype2tx-requests.d.ts.map

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

package/dist/signet-evtype2tx-requests.js

@@ -142,6 +142,19 @@ export function evmAddressAbiWord(address) {
     word.set(address, 12);
     return word;
 }
+/**
+ * The ABI word for a Boolean: 31 zero bytes, then 0x01 (true) or 0x00
+ * (false). TS mirror of Signet.compact's `boolAbiWord` circuit
+ * (lockstep-tested against the compiled circuit).
+ *
+ * @param value - The word's Boolean value.
+ * @returns The ABI-ready 32-byte word to store in an {@link EVMCalldata} word.
+ */
+export function boolAbiWord(value) {
+    const word = new Uint8Array(32);
+    word[31] = value ? 1 : 0;
+    return word;
+}
 /**
  * Read a numeric ABI word back into a bigint: the big-endian reading of bytes
  * 16..31. TS mirror of Signet.compact's `abiWordToUint128` circuit, including
@@ -165,6 +178,24 @@ export function abiWordToUint128(word) {
     }
     return value;
 }
+/**
+ * Read a Boolean ABI word back into a boolean. TS mirror of Signet.compact's
+ * `abiWordToBool` circuit, including its canonicality check: the first 31
+ * bytes must be zero and the last byte 0 or 1.
+ *
+ * @param word - The ABI-ready 32-byte word.
+ * @returns The word's Boolean value.
+ * @throws Error if the word is not 32 bytes or is not a canonical Boolean.
+ */
+export function abiWordToBool(word) {
+    if (word.length !== 32) {
+        throw new Error(`ABI word must be 32 bytes, got ${word.length}`);
+    }
+    if (word.slice(0, 31).some((byte) => byte !== 0) || word[31] > 1) {
+        throw new Error("ABI word is not a canonical Boolean");
+    }
+    return word[31] === 1;
+}
 /**
  * Assemble the raw calldata a request's words describe:
  * `data = selector || words[0..noWords]`, VERBATIM. Words are stored