@sig-net/midnight 0.0.1

package/dist/managed/contract/index.js

@@ -0,0 +1,611 @@
+import * as __compactRuntime from '@midnight-ntwrk/compact-runtime';
+__compactRuntime.checkRuntimeVersion('0.18.0-rc.0');
+
+const _descriptor_0 = __compactRuntime.CompactTypeField;
+
+const _descriptor_1 = new __compactRuntime.CompactTypeVector(4, _descriptor_0);
+
+const _descriptor_2 = new __compactRuntime.CompactTypeBytes(32);
+
+const _descriptor_3 = new __compactRuntime.CompactTypeBytes(64);
+
+const _descriptor_4 = new __compactRuntime.CompactTypeBytes(256);
+
+const _descriptor_5 = new __compactRuntime.CompactTypeBytes(128);
+
+const _descriptor_6 = new __compactRuntime.CompactTypeUnsignedInteger(255n, 1);
+
+const _descriptor_7 = new __compactRuntime.CompactTypeBytes(20);
+
+class _SchnorrHashInput_0 {
+  alignment() {
+    return _descriptor_0.alignment().concat(_descriptor_0.alignment().concat(_descriptor_0.alignment().concat(_descriptor_0.alignment().concat(_descriptor_1.alignment()))));
+  }
+  fromValue(value_0) {
+    return {
+      ann_x: _descriptor_0.fromValue(value_0),
+      ann_y: _descriptor_0.fromValue(value_0),
+      pk_x: _descriptor_0.fromValue(value_0),
+      pk_y: _descriptor_0.fromValue(value_0),
+      msg: _descriptor_1.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_0.toValue(value_0.ann_x).concat(_descriptor_0.toValue(value_0.ann_y).concat(_descriptor_0.toValue(value_0.pk_x).concat(_descriptor_0.toValue(value_0.pk_y).concat(_descriptor_1.toValue(value_0.msg)))));
+  }
+}
+
+const _descriptor_8 = new _SchnorrHashInput_0();
+
+const _descriptor_9 = new __compactRuntime.CompactTypeVector(2, _descriptor_2);
+
+const _descriptor_10 = new __compactRuntime.CompactTypeUnsignedInteger(18446744073709551615n, 8);
+
+const _descriptor_11 = __compactRuntime.CompactTypeBoolean;
+
+class _Either_0 {
+  alignment() {
+    return _descriptor_11.alignment().concat(_descriptor_2.alignment().concat(_descriptor_2.alignment()));
+  }
+  fromValue(value_0) {
+    return {
+      is_left: _descriptor_11.fromValue(value_0),
+      left: _descriptor_2.fromValue(value_0),
+      right: _descriptor_2.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_11.toValue(value_0.is_left).concat(_descriptor_2.toValue(value_0.left).concat(_descriptor_2.toValue(value_0.right)));
+  }
+}
+
+const _descriptor_12 = new _Either_0();
+
+const _descriptor_13 = new __compactRuntime.CompactTypeUnsignedInteger(340282366920938463463374607431768211455n, 16);
+
+class _ContractAddress_0 {
+  alignment() {
+    return _descriptor_2.alignment();
+  }
+  fromValue(value_0) {
+    return {
+      bytes: _descriptor_2.fromValue(value_0)
+    }
+  }
+  toValue(value_0) {
+    return _descriptor_2.toValue(value_0.bytes);
+  }
+}
+
+const _descriptor_14 = new _ContractAddress_0();
+
+const _descriptor_15 = new __compactRuntime.CompactTypeUnsignedInteger(4294967295n, 4);
+
+export class Contract {
+  witnesses;
+  constructor(...args_0) {
+    if (args_0.length !== 1) {
+      throw new __compactRuntime.CompactError(`Contract constructor: expected 1 argument, received ${args_0.length}`);
+    }
+    const witnesses_0 = args_0[0];
+    if (typeof(witnesses_0) !== 'object') {
+      throw new __compactRuntime.CompactError('first (witnesses) argument to Contract constructor is not an object');
+    }
+    this.witnesses = witnesses_0;
+    this.circuits = {
+      async evmAddressAbiValue(context, ...args_1) {
+        return { result: pureCircuits.evmAddressAbiValue(...args_1), context };
+      },
+      async signetAttestationMessage(context, ...args_1) {
+        return { result: pureCircuits.signetAttestationMessage(...args_1), context };
+      },
+      async assertHexOf(context, ...args_1) {
+        return { result: pureCircuits.assertHexOf(...args_1), context };
+      },
+      async assertPathCommitment(context, ...args_1) {
+        return { result: pureCircuits.assertPathCommitment(...args_1), context };
+      },
+      async schnorrChallenge(context, ...args_1) {
+        return { result: pureCircuits.schnorrChallenge(...args_1), context };
+      }
+    };
+    this.impureCircuits = {};
+    this.provableCircuits = {};
+  }
+  async initialState(...args_0) {
+    if (args_0.length !== 1) {
+      throw new __compactRuntime.CompactError(`Contract state constructor: expected 1 argument (as invoked from Typescript), received ${args_0.length}`);
+    }
+    const constructorContext_0 = args_0[0];
+    if (typeof(constructorContext_0) !== 'object') {
+      throw new __compactRuntime.CompactError(`Contract state constructor: expected 'constructorContext' in argument 1 (as invoked from Typescript) to be an object`);
+    }
+    if (!('initialZswapLocalState' in constructorContext_0)) {
+      throw new __compactRuntime.CompactError(`Contract state constructor: expected 'initialZswapLocalState' in argument 1 (as invoked from Typescript)`);
+    }
+    if (typeof(constructorContext_0.initialZswapLocalState) !== 'object') {
+      throw new __compactRuntime.CompactError(`Contract state constructor: expected 'initialZswapLocalState' in argument 1 (as invoked from Typescript) to be an object`);
+    }
+    const state_0 = new __compactRuntime.ContractState();
+    let stateValue_0 = __compactRuntime.StateValue.newArray();
+    state_0.data = new __compactRuntime.ChargedState(stateValue_0);
+    const context = __compactRuntime.createCircuitContext('constructor', __compactRuntime.dummyContractAddress(), constructorContext_0.initialZswapLocalState.coinPublicKey, state_0.data, constructorContext_0.initialPrivateState);
+    const partialProofData = {
+      input: { value: [], alignment: [] },
+      output: undefined,
+      publicTranscript: [],
+      privateTranscriptOutputs: []
+    };
+    state_0.data = new __compactRuntime.ChargedState(context.callContext.currentQueryContext.state.state);
+    return {
+      currentContractState: state_0,
+      currentPrivateState: context.callContext.currentPrivateState,
+      currentZswapLocalState: context.callContext.currentZswapLocalState
+    }
+  }
+  _transientHash_0(value_0) {
+    const result_0 = __compactRuntime.transientHash(_descriptor_8, value_0);
+    return result_0;
+  }
+  _persistentHash_0(value_0) {
+    const result_0 = __compactRuntime.persistentHash(_descriptor_9, value_0);
+    return result_0;
+  }
+  _persistentHash_1(value_0) {
+    const result_0 = __compactRuntime.persistentHash(_descriptor_5, value_0);
+    return result_0;
+  }
+  _evmAddressAbiValue_0(addr_0) {
+    const a0_0 = __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                       1,
+                                                       ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                   Number(0n)),
+                                                       'Field',
+                                                       'Signet.compact line 272 char 17');
+    const a1_0 = __compactRuntime.addField(__compactRuntime.mulField(a0_0, 256n),
+                                           __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                 1,
+                                                                                 ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                                             Number(1n)),
+                                                                                 'Field',
+                                                                                 'Signet.compact line 273 char 30'));
+    const a2_0 = __compactRuntime.addField(__compactRuntime.mulField(a1_0, 256n),
+                                           __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                 1,
+                                                                                 ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                                             Number(2n)),
+                                                                                 'Field',
+                                                                                 'Signet.compact line 274 char 30'));
+    const a3_0 = __compactRuntime.addField(__compactRuntime.mulField(a2_0, 256n),
+                                           __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                 1,
+                                                                                 ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                                             Number(3n)),
+                                                                                 'Field',
+                                                                                 'Signet.compact line 275 char 30'));
+    const a4_0 = __compactRuntime.addField(__compactRuntime.mulField(a3_0, 256n),
+                                           __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                 1,
+                                                                                 ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                                             Number(4n)),
+                                                                                 'Field',
+                                                                                 'Signet.compact line 276 char 30'));
+    const a5_0 = __compactRuntime.addField(__compactRuntime.mulField(a4_0, 256n),
+                                           __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                 1,
+                                                                                 ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                                             Number(5n)),
+                                                                                 'Field',
+                                                                                 'Signet.compact line 277 char 30'));
+    const a6_0 = __compactRuntime.addField(__compactRuntime.mulField(a5_0, 256n),
+                                           __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                 1,
+                                                                                 ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                                             Number(6n)),
+                                                                                 'Field',
+                                                                                 'Signet.compact line 278 char 30'));
+    const a7_0 = __compactRuntime.addField(__compactRuntime.mulField(a6_0, 256n),
+                                           __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                 1,
+                                                                                 ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                                             Number(7n)),
+                                                                                 'Field',
+                                                                                 'Signet.compact line 279 char 30'));
+    const a8_0 = __compactRuntime.addField(__compactRuntime.mulField(a7_0, 256n),
+                                           __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                 1,
+                                                                                 ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                                             Number(8n)),
+                                                                                 'Field',
+                                                                                 'Signet.compact line 280 char 30'));
+    const a9_0 = __compactRuntime.addField(__compactRuntime.mulField(a8_0, 256n),
+                                           __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                 1,
+                                                                                 ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                                             Number(9n)),
+                                                                                 'Field',
+                                                                                 'Signet.compact line 281 char 30'));
+    const a10_0 = __compactRuntime.addField(__compactRuntime.mulField(a9_0, 256n),
+                                            __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                  1,
+                                                                                  ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                                              Number(10n)),
+                                                                                  'Field',
+                                                                                  'Signet.compact line 282 char 30'));
+    const a11_0 = __compactRuntime.addField(__compactRuntime.mulField(a10_0,
+                                                                      256n),
+                                            __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                  1,
+                                                                                  ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                                              Number(11n)),
+                                                                                  'Field',
+                                                                                  'Signet.compact line 283 char 30'));
+    const a12_0 = __compactRuntime.addField(__compactRuntime.mulField(a11_0,
+                                                                      256n),
+                                            __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                  1,
+                                                                                  ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                                              Number(12n)),
+                                                                                  'Field',
+                                                                                  'Signet.compact line 284 char 30'));
+    const a13_0 = __compactRuntime.addField(__compactRuntime.mulField(a12_0,
+                                                                      256n),
+                                            __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                  1,
+                                                                                  ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                                              Number(13n)),
+                                                                                  'Field',
+                                                                                  'Signet.compact line 285 char 30'));
+    const a14_0 = __compactRuntime.addField(__compactRuntime.mulField(a13_0,
+                                                                      256n),
+                                            __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                  1,
+                                                                                  ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                                              Number(14n)),
+                                                                                  'Field',
+                                                                                  'Signet.compact line 286 char 30'));
+    const a15_0 = __compactRuntime.addField(__compactRuntime.mulField(a14_0,
+                                                                      256n),
+                                            __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                  1,
+                                                                                  ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                                              Number(15n)),
+                                                                                  'Field',
+                                                                                  'Signet.compact line 287 char 30'));
+    const a16_0 = __compactRuntime.addField(__compactRuntime.mulField(a15_0,
+                                                                      256n),
+                                            __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                  1,
+                                                                                  ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                                              Number(16n)),
+                                                                                  'Field',
+                                                                                  'Signet.compact line 288 char 30'));
+    const a17_0 = __compactRuntime.addField(__compactRuntime.mulField(a16_0,
+                                                                      256n),
+                                            __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                  1,
+                                                                                  ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                                              Number(17n)),
+                                                                                  'Field',
+                                                                                  'Signet.compact line 289 char 30'));
+    const a18_0 = __compactRuntime.addField(__compactRuntime.mulField(a17_0,
+                                                                      256n),
+                                            __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                  1,
+                                                                                  ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                                              Number(18n)),
+                                                                                  'Field',
+                                                                                  'Signet.compact line 290 char 30'));
+    return __compactRuntime.addField(__compactRuntime.mulField(a18_0, 256n),
+                                     __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                           1,
+                                                                           ((e, i) => e.slice(i, i+1))(addr_0,
+                                                                                                       Number(19n)),
+                                                                           'Field',
+                                                                           'Signet.compact line 291 char 30'));
+  }
+  _signetAttestationMessage_0(requestId_0, serializedOutput_0, outputLen_0) {
+    const rid_0 = requestId_0;
+    const outHash_0 = this._persistentHash_0([this._persistentHash_1(serializedOutput_0),
+                                              __compactRuntime.convertBigintToBytes(32,
+                                                                                    outputLen_0,
+                                                                                    'Signet.compact line 393 char 7')]);
+    return [__compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                  16,
+                                                  ((e, i) => e.slice(i, i+16))(rid_0,
+                                                                               Number(0n)),
+                                                  'Field',
+                                                  'Signet.compact line 396 char 7'),
+            __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                  16,
+                                                  ((e, i) => e.slice(i, i+16))(rid_0,
+                                                                               Number(16n)),
+                                                  'Field',
+                                                  'Signet.compact line 397 char 7'),
+            __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                  16,
+                                                  ((e, i) => e.slice(i, i+16))(outHash_0,
+                                                                               Number(0n)),
+                                                  'Field',
+                                                  'Signet.compact line 398 char 7'),
+            __compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                  16,
+                                                  ((e, i) => e.slice(i, i+16))(outHash_0,
+                                                                               Number(16n)),
+                                                  'Field',
+                                                  'Signet.compact line 399 char 7')];
+  }
+  _charToNibble_0(c_0) {
+    const isDigit_0 = c_0 >= 48n && c_0 <= 57n;
+    const isLower_0 = c_0 >= 97n && c_0 <= 102n;
+    __compactRuntime.assert(isDigit_0 || isLower_0, 'non-canonical hex char');
+    const base_0 = (__compactRuntime.assert(c_0 >= 48n,
+                                            'result of subtraction would be negative'),
+                    c_0 - 48n);
+    const adjust_0 = isLower_0 ? 39n : 0n;
+    __compactRuntime.assert(base_0 >= adjust_0,
+                            'result of subtraction would be negative');
+    return base_0 - adjust_0;
+  }
+  _assertHexOf_0(commitment_0, hexStr_0) {
+    this._folder_0(((t_0, i_0) =>
+                    {
+                      const hi_0 = this._charToNibble_0(__compactRuntime.convertBytesToBigint(255n,
+                                                                                              1,
+                                                                                              ((e, i) => e.slice(i, i+1))(hexStr_0,
+                                                                                                                          Number(2n
+                                                                                                                                 *
+                                                                                                                                 i_0)),
+                                                                                              'Uint<0..256>',
+                                                                                              'Signet.compact line 426 char 31'));
+                      const lo_0 = this._charToNibble_0(__compactRuntime.convertBytesToBigint(255n,
+                                                                                              1,
+                                                                                              ((e, i) => e.slice(i, i+1))(hexStr_0,
+                                                                                                                          Number(2n
+                                                                                                                                 *
+                                                                                                                                 i_0
+                                                                                                                                 +
+                                                                                                                                 1n)),
+                                                                                              'Uint<0..256>',
+                                                                                              'Signet.compact line 427 char 31'));
+                      __compactRuntime.assert(__compactRuntime.convertBytesToBigint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
+                                                                                    1,
+                                                                                    ((e, i) => e.slice(i, i+1))(commitment_0,
+                                                                                                                Number(i_0)),
+                                                                                    'Field',
+                                                                                    'Signet.compact line 428 char 15')
+                                              ===
+                                              __compactRuntime.addField(__compactRuntime.mulField(hi_0,
+                                                                                                  16n),
+                                                                        lo_0),
+                                              'path hex does not match commitment');
+                      return t_0;
+                    }),
+                   [],
+                   [0n,
+                    1n,
+                    2n,
+                    3n,
+                    4n,
+                    5n,
+                    6n,
+                    7n,
+                    8n,
+                    9n,
+                    10n,
+                    11n,
+                    12n,
+                    13n,
+                    14n,
+                    15n,
+                    16n,
+                    17n,
+                    18n,
+                    19n,
+                    20n,
+                    21n,
+                    22n,
+                    23n,
+                    24n,
+                    25n,
+                    26n,
+                    27n,
+                    28n,
+                    29n,
+                    30n,
+                    31n]);
+    return [];
+  }
+  _assertPathCommitment_0(commitment_0, path_0) {
+    this._assertHexOf_0(commitment_0,
+                        ((e, i) => e.slice(i, i+64))(path_0, Number(0n)));
+    __compactRuntime.assert(this._equal_0(((e, i) => e.slice(i, i+192))(path_0,
+                                                                        Number(64n)),
+                                          new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])),
+                            'Path must be zero-padded after hex');
+    return [];
+  }
+  _schnorrChallenge_0(ann_x_0, ann_y_0, pk_x_0, pk_y_0, msg_0) {
+    const cFull_0 = this._transientHash_0({ ann_x: ann_x_0,
+                                            ann_y: ann_y_0,
+                                            pk_x: pk_x_0,
+                                            pk_y: pk_y_0,
+                                            msg: msg_0 });
+    return cFull_0;
+  }
+  _folder_0(f, x, a0) {
+    for (let i = 0; i < 32; i++) { x = f(x, a0[i]); }
+    return x;
+  }
+  _equal_0(x0, y0) {
+    if (!x0.every((x, i) => y0[i] === x)) { return false; }
+    return true;
+  }
+}
+export function ledger(stateOrChargedState) {
+  const state = stateOrChargedState instanceof __compactRuntime.StateValue ? stateOrChargedState : stateOrChargedState.state;
+  const chargedState = stateOrChargedState instanceof __compactRuntime.StateValue ? new __compactRuntime.ChargedState(stateOrChargedState) : stateOrChargedState;
+  const context = {
+    callContext: { currentQueryContext: new __compactRuntime.QueryContext(chargedState, __compactRuntime.dummyContractAddress()), currentGasCost: __compactRuntime.emptyRunningCost() },
+    costModel: __compactRuntime.CostModel.initialCostModel()
+  };
+  const partialProofData = {
+    input: { value: [], alignment: [] },
+    output: undefined,
+    publicTranscript: [],
+    privateTranscriptOutputs: []
+  };
+  return {
+  };
+}
+const _emptyContext = {
+  callContext: { currentQueryContext: new __compactRuntime.QueryContext(new __compactRuntime.ContractState().data, __compactRuntime.dummyContractAddress()), currentGasCost: __compactRuntime.emptyRunningCost() }
+};
+const _dummyContract = new Contract({ });
+export const pureCircuits = {
+  evmAddressAbiValue: (...args_0) => {
+    if (args_0.length !== 1) {
+      throw new __compactRuntime.CompactError(`evmAddressAbiValue: 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('evmAddressAbiValue',
+                                 'argument 1',
+                                 'Signet.compact line 271 char 3',
+                                 'Bytes<20>',
+                                 addr_0)
+    }
+    return _dummyContract._evmAddressAbiValue_0(addr_0);
+  },
+  signetAttestationMessage: (...args_0) => {
+    if (args_0.length !== 3) {
+      throw new __compactRuntime.CompactError(`signetAttestationMessage: expected 3 arguments (as invoked from Typescript), received ${args_0.length}`);
+    }
+    const requestId_0 = args_0[0];
+    const serializedOutput_0 = args_0[1];
+    const outputLen_0 = args_0[2];
+    if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
+      __compactRuntime.typeError('signetAttestationMessage',
+                                 'argument 1',
+                                 'Signet.compact line 385 char 3',
+                                 'Bytes<32>',
+                                 requestId_0)
+    }
+    if (!(serializedOutput_0.buffer instanceof ArrayBuffer && serializedOutput_0.BYTES_PER_ELEMENT === 1 && serializedOutput_0.length === 128)) {
+      __compactRuntime.typeError('signetAttestationMessage',
+                                 'argument 2',
+                                 'Signet.compact line 385 char 3',
+                                 'Bytes<128>',
+                                 serializedOutput_0)
+    }
+    if (!(typeof(outputLen_0) === 'bigint' && outputLen_0 >= 0n && outputLen_0 <= 255n)) {
+      __compactRuntime.typeError('signetAttestationMessage',
+                                 'argument 3',
+                                 'Signet.compact line 385 char 3',
+                                 'Uint<0..256>',
+                                 outputLen_0)
+    }
+    return _dummyContract._signetAttestationMessage_0(requestId_0,
+                                                      serializedOutput_0,
+                                                      outputLen_0);
+  },
+  assertHexOf: (...args_0) => {
+    if (args_0.length !== 2) {
+      throw new __compactRuntime.CompactError(`assertHexOf: expected 2 arguments (as invoked from Typescript), received ${args_0.length}`);
+    }
+    const commitment_0 = args_0[0];
+    const hexStr_0 = args_0[1];
+    if (!(commitment_0.buffer instanceof ArrayBuffer && commitment_0.BYTES_PER_ELEMENT === 1 && commitment_0.length === 32)) {
+      __compactRuntime.typeError('assertHexOf',
+                                 'argument 1',
+                                 'Signet.compact line 424 char 3',
+                                 'Bytes<32>',
+                                 commitment_0)
+    }
+    if (!(hexStr_0.buffer instanceof ArrayBuffer && hexStr_0.BYTES_PER_ELEMENT === 1 && hexStr_0.length === 64)) {
+      __compactRuntime.typeError('assertHexOf',
+                                 'argument 2',
+                                 'Signet.compact line 424 char 3',
+                                 'Bytes<64>',
+                                 hexStr_0)
+    }
+    return _dummyContract._assertHexOf_0(commitment_0, hexStr_0);
+  },
+  assertPathCommitment: (...args_0) => {
+    if (args_0.length !== 2) {
+      throw new __compactRuntime.CompactError(`assertPathCommitment: expected 2 arguments (as invoked from Typescript), received ${args_0.length}`);
+    }
+    const commitment_0 = args_0[0];
+    const path_0 = args_0[1];
+    if (!(commitment_0.buffer instanceof ArrayBuffer && commitment_0.BYTES_PER_ELEMENT === 1 && commitment_0.length === 32)) {
+      __compactRuntime.typeError('assertPathCommitment',
+                                 'argument 1',
+                                 'Signet.compact line 439 char 3',
+                                 'Bytes<32>',
+                                 commitment_0)
+    }
+    if (!(path_0.buffer instanceof ArrayBuffer && path_0.BYTES_PER_ELEMENT === 1 && path_0.length === 256)) {
+      __compactRuntime.typeError('assertPathCommitment',
+                                 'argument 2',
+                                 'Signet.compact line 439 char 3',
+                                 'Bytes<256>',
+                                 path_0)
+    }
+    return _dummyContract._assertPathCommitment_0(commitment_0, path_0);
+  },
+  schnorrChallenge: (...args_0) => {
+    if (args_0.length !== 5) {
+      throw new __compactRuntime.CompactError(`schnorrChallenge: expected 5 arguments (as invoked from Typescript), received ${args_0.length}`);
+    }
+    const ann_x_0 = args_0[0];
+    const ann_y_0 = args_0[1];
+    const pk_x_0 = args_0[2];
+    const pk_y_0 = args_0[3];
+    const msg_0 = args_0[4];
+    if (!(typeof(ann_x_0) === 'bigint' && ann_x_0 >= 0 && ann_x_0 <= __compactRuntime.MAX_FIELD)) {
+      __compactRuntime.typeError('schnorrChallenge',
+                                 'argument 1',
+                                 'Schnorr.compact line 50 char 3',
+                                 'Field',
+                                 ann_x_0)
+    }
+    if (!(typeof(ann_y_0) === 'bigint' && ann_y_0 >= 0 && ann_y_0 <= __compactRuntime.MAX_FIELD)) {
+      __compactRuntime.typeError('schnorrChallenge',
+                                 'argument 2',
+                                 'Schnorr.compact line 50 char 3',
+                                 'Field',
+                                 ann_y_0)
+    }
+    if (!(typeof(pk_x_0) === 'bigint' && pk_x_0 >= 0 && pk_x_0 <= __compactRuntime.MAX_FIELD)) {
+      __compactRuntime.typeError('schnorrChallenge',
+                                 'argument 3',
+                                 'Schnorr.compact line 50 char 3',
+                                 'Field',
+                                 pk_x_0)
+    }
+    if (!(typeof(pk_y_0) === 'bigint' && pk_y_0 >= 0 && pk_y_0 <= __compactRuntime.MAX_FIELD)) {
+      __compactRuntime.typeError('schnorrChallenge',
+                                 'argument 4',
+                                 'Schnorr.compact line 50 char 3',
+                                 'Field',
+                                 pk_y_0)
+    }
+    if (!(Array.isArray(msg_0) && msg_0.length === 4 && msg_0.every((t) => typeof(t) === 'bigint' && t >= 0 && t <= __compactRuntime.MAX_FIELD))) {
+      __compactRuntime.typeError('schnorrChallenge',
+                                 'argument 5',
+                                 'Schnorr.compact line 50 char 3',
+                                 'Vector<4, Field>',
+                                 msg_0)
+    }
+    return _dummyContract._schnorrChallenge_0(ann_x_0,
+                                              ann_y_0,
+                                              pk_x_0,
+                                              pk_y_0,
+                                              msg_0);
+  }
+};
+export const contractReferenceLocations =
+  { tag: 'publicLedgerArray', indices: { } };
+export const expectedVk = {};
+
+//# sourceMappingURL=index.js.map

package/dist/managed/contract/index.js.map

@@ -0,0 +1,8 @@
+{
+  "version": 3,
+  "file": "index.js",
+  "sourceRoot": "../../../",
+  "sources": ["src/circuits.compact", "src/./Signet.compact", "src/./Schnorr.compact", "compiler/zkir-v3-library.compact"],
+  "names": [],
+  "mappings": "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"
+}