@sig-net/midnight-contract 0.0.4 → 0.0.6

package/dist/managed/contract/index.js

@@ -49,91 +49,70 @@ const _descriptor_6 = new _SignatureResponse_0();
 
 const _descriptor_7 = new __compactRuntime.CompactTypeBytes(128);
 
-const _descriptor_8 = __compactRuntime.CompactTypeJubjubPoint;
-
-const _descriptor_9 = __compactRuntime.CompactTypeField;
-
 class _RespondBidirectional_0 {
   alignment() {
-    return _descriptor_7.alignment().concat(_descriptor_5.alignment().concat(_descriptor_8.alignment().concat(_descriptor_8.alignment().concat(_descriptor_9.alignment()))));
+    return _descriptor_7.alignment().concat(_descriptor_5.alignment().concat(_descriptor_0.alignment().concat(_descriptor_0.alignment())));
   }
   fromValue(value_0) {
     return {
       serializedOutput: _descriptor_7.fromValue(value_0),
       outputLen: _descriptor_5.fromValue(value_0),
-      pk: _descriptor_8.fromValue(value_0),
-      announcement: _descriptor_8.fromValue(value_0),
-      response: _descriptor_9.fromValue(value_0)
+      sigR: _descriptor_0.fromValue(value_0),
+      sigS: _descriptor_0.fromValue(value_0)
     }
   }
   toValue(value_0) {
-    return _descriptor_7.toValue(value_0.serializedOutput).concat(_descriptor_5.toValue(value_0.outputLen).concat(_descriptor_8.toValue(value_0.pk).concat(_descriptor_8.toValue(value_0.announcement).concat(_descriptor_9.toValue(value_0.response)))));
+    return _descriptor_7.toValue(value_0.serializedOutput).concat(_descriptor_5.toValue(value_0.outputLen).concat(_descriptor_0.toValue(value_0.sigR).concat(_descriptor_0.toValue(value_0.sigS))));
   }
 }
 
-const _descriptor_10 = new _RespondBidirectional_0();
+const _descriptor_8 = new _RespondBidirectional_0();
 
-const _descriptor_11 = new __compactRuntime.CompactTypeVector(4, _descriptor_9);
+const _descriptor_9 = __compactRuntime.CompactTypeSecp256k1Point;
 
-const _descriptor_12 = new __compactRuntime.CompactTypeBytes(65);
+const _descriptor_10 = new __compactRuntime.CompactTypeBytes(65);
 
 class _SignBidirectionalNotification_0 {
   alignment() {
-    return _descriptor_5.alignment().concat(_descriptor_12.alignment());
+    return _descriptor_5.alignment().concat(_descriptor_10.alignment());
   }
   fromValue(value_0) {
     return {
       version: _descriptor_5.fromValue(value_0),
-      payload: _descriptor_12.fromValue(value_0)
+      payload: _descriptor_10.fromValue(value_0)
     }
   }
   toValue(value_0) {
-    return _descriptor_5.toValue(value_0.version).concat(_descriptor_12.toValue(value_0.payload));
+    return _descriptor_5.toValue(value_0.version).concat(_descriptor_10.toValue(value_0.payload));
   }
 }
 
-const _descriptor_13 = new _SignBidirectionalNotification_0();
+const _descriptor_11 = new _SignBidirectionalNotification_0();
 
-const _descriptor_14 = __compactRuntime.CompactTypeField;
+const _descriptor_12 = __compactRuntime.CompactTypeSecp256k1Scalar;
 
-const _descriptor_15 = new __compactRuntime.CompactTypeVector(2, _descriptor_0);
+const _descriptor_13 = __compactRuntime.CompactTypeSecp256k1Base;
 
-class _JubjubSchnorrSignature_0 {
-  alignment() {
-    return _descriptor_8.alignment().concat(_descriptor_9.alignment());
-  }
-  fromValue(value_0) {
-    return {
-      announcement: _descriptor_8.fromValue(value_0),
-      response: _descriptor_9.fromValue(value_0)
-    }
-  }
-  toValue(value_0) {
-    return _descriptor_8.toValue(value_0.announcement).concat(_descriptor_9.toValue(value_0.response));
-  }
-}
+const _descriptor_14 = new __compactRuntime.CompactTypeVector(3, _descriptor_0);
 
-const _descriptor_16 = new _JubjubSchnorrSignature_0();
+const _descriptor_15 = new __compactRuntime.CompactTypeVector(2, _descriptor_0);
 
-class _JubjubSchnorrHashInput_0 {
+class _Secp256k1EcdsaSignature_0 {
   alignment() {
-    return _descriptor_9.alignment().concat(_descriptor_9.alignment().concat(_descriptor_9.alignment().concat(_descriptor_9.alignment().concat(_descriptor_11.alignment()))));
+    return _descriptor_12.alignment().concat(_descriptor_12.alignment());
   }
   fromValue(value_0) {
     return {
-      annX: _descriptor_9.fromValue(value_0),
-      annY: _descriptor_9.fromValue(value_0),
-      pkX: _descriptor_9.fromValue(value_0),
-      pkY: _descriptor_9.fromValue(value_0),
-      msg: _descriptor_11.fromValue(value_0)
+      r: _descriptor_12.fromValue(value_0),
+      s: _descriptor_12.fromValue(value_0)
     }
   }
   toValue(value_0) {
-    return _descriptor_9.toValue(value_0.annX).concat(_descriptor_9.toValue(value_0.annY).concat(_descriptor_9.toValue(value_0.pkX).concat(_descriptor_9.toValue(value_0.pkY).concat(_descriptor_11.toValue(value_0.msg)))));
+    return _descriptor_12.toValue(value_0.r).concat(_descriptor_12.toValue(value_0.s));
   }
 }
 
-const _descriptor_17 = new _JubjubSchnorrHashInput_0();
+const _descriptor_16 = new _Secp256k1EcdsaSignature_0();
 
 class _Either_0 {
   alignment() {
@@ -151,9 +130,9 @@ class _Either_0 {
   }
 }
 
-const _descriptor_18 = new _Either_0();
+const _descriptor_17 = new _Either_0();
 
-const _descriptor_19 = new __compactRuntime.CompactTypeUnsignedInteger(340282366920938463463374607431768211455n, 16);
+const _descriptor_18 = new __compactRuntime.CompactTypeUnsignedInteger(340282366920938463463374607431768211455n, 16);
 
 class _ContractAddress_0 {
   alignment() {
@@ -169,9 +148,9 @@ class _ContractAddress_0 {
   }
 }
 
-const _descriptor_20 = new _ContractAddress_0();
+const _descriptor_19 = new _ContractAddress_0();
 
-const _descriptor_21 = new __compactRuntime.CompactTypeUnsignedInteger(4294967295n, 4);
+const _descriptor_20 = new __compactRuntime.CompactTypeUnsignedInteger(4294967295n, 4);
 
 export class Contract {
   witnesses;
@@ -216,8 +195,8 @@ export class Contract {
         const context = __compactRuntime.copyCircuitContext(contextOrig_0);
         const partialProofData = {
           input: {
-            value: _descriptor_0.toValue(requestId_0).concat(_descriptor_13.toValue(notification_0)),
-            alignment: _descriptor_0.alignment().concat(_descriptor_13.alignment())
+            value: _descriptor_0.toValue(requestId_0).concat(_descriptor_11.toValue(notification_0)),
+            alignment: _descriptor_0.alignment().concat(_descriptor_11.alignment())
           },
           output: undefined,
           publicTranscript: [],
@@ -278,38 +257,39 @@ export class Contract {
         return { result: result_0, context: context, gasCost: context.callContext.currentGasCost };
       },
       postRespondBidirectional: async (...args_1) => {
-        if (args_1.length !== 3) {
-          throw new __compactRuntime.CompactError(`postRespondBidirectional: expected 3 arguments (as invoked from Typescript), received ${args_1.length}`);
+        if (args_1.length !== 4) {
+          throw new __compactRuntime.CompactError(`postRespondBidirectional: expected 4 arguments (as invoked from Typescript), received ${args_1.length}`);
         }
         const contextOrig_0 = args_1[0];
         const requestId_0 = args_1[1];
         const respondBidirectional_0 = args_1[2];
+        const pk_0 = args_1[3];
         if (!(typeof(contextOrig_0) === 'object' && contextOrig_0.callContext.currentQueryContext != undefined)) {
           __compactRuntime.typeError('postRespondBidirectional',
                                      'argument 1 (as invoked from Typescript)',
-                                     'signet-contract.compact line 87 char 1',
+                                     'signet-contract.compact line 89 char 1',
                                      'CircuitContext',
                                      contextOrig_0)
         }
         if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
           __compactRuntime.typeError('postRespondBidirectional',
                                      'argument 1 (argument 2 as invoked from Typescript)',
-                                     'signet-contract.compact line 87 char 1',
+                                     'signet-contract.compact line 89 char 1',
                                      'Bytes<32>',
                                      requestId_0)
         }
-        if (!(typeof(respondBidirectional_0) === 'object' && respondBidirectional_0.serializedOutput.buffer instanceof ArrayBuffer && respondBidirectional_0.serializedOutput.BYTES_PER_ELEMENT === 1 && respondBidirectional_0.serializedOutput.length === 128 && typeof(respondBidirectional_0.outputLen) === 'bigint' && respondBidirectional_0.outputLen >= 0n && respondBidirectional_0.outputLen <= 255n && true && true && typeof(respondBidirectional_0.response) === 'bigint' && respondBidirectional_0.response >= 0 && respondBidirectional_0.response <= __compactRuntime.MAX_FIELD)) {
+        if (!(typeof(respondBidirectional_0) === 'object' && respondBidirectional_0.serializedOutput.buffer instanceof ArrayBuffer && respondBidirectional_0.serializedOutput.BYTES_PER_ELEMENT === 1 && respondBidirectional_0.serializedOutput.length === 128 && typeof(respondBidirectional_0.outputLen) === 'bigint' && respondBidirectional_0.outputLen >= 0n && respondBidirectional_0.outputLen <= 255n && respondBidirectional_0.sigR.buffer instanceof ArrayBuffer && respondBidirectional_0.sigR.BYTES_PER_ELEMENT === 1 && respondBidirectional_0.sigR.length === 32 && respondBidirectional_0.sigS.buffer instanceof ArrayBuffer && respondBidirectional_0.sigS.BYTES_PER_ELEMENT === 1 && respondBidirectional_0.sigS.length === 32)) {
           __compactRuntime.typeError('postRespondBidirectional',
                                      'argument 2 (argument 3 as invoked from Typescript)',
-                                     'signet-contract.compact line 87 char 1',
-                                     'struct RespondBidirectional<serializedOutput: Bytes<128>, outputLen: Uint<0..256>, pk: Opaque<"JubjubPoint">, announcement: Opaque<"JubjubPoint">, response: Field>',
+                                     'signet-contract.compact line 89 char 1',
+                                     'struct RespondBidirectional<serializedOutput: Bytes<128>, outputLen: Uint<0..256>, sigR: Bytes<32>, sigS: Bytes<32>>',
                                      respondBidirectional_0)
         }
         const context = __compactRuntime.copyCircuitContext(contextOrig_0);
         const partialProofData = {
           input: {
-            value: _descriptor_0.toValue(requestId_0).concat(_descriptor_10.toValue(respondBidirectional_0)),
-            alignment: _descriptor_0.alignment().concat(_descriptor_10.alignment())
+            value: _descriptor_0.toValue(requestId_0).concat(_descriptor_8.toValue(respondBidirectional_0).concat(_descriptor_9.toValue(pk_0))),
+            alignment: _descriptor_0.alignment().concat(_descriptor_8.alignment().concat(_descriptor_9.alignment()))
           },
           output: undefined,
           publicTranscript: [],
@@ -318,7 +298,8 @@ export class Contract {
         const result_0 = await this._postRespondBidirectional_0(context,
                                                                 partialProofData,
                                                                 requestId_0,
-                                                                respondBidirectional_0);
+                                                                respondBidirectional_0,
+                                                                pk_0);
         partialProofData.output = { value: [], alignment: [] };
         __compactRuntime.finalizeCallProofData(context, partialProofData);
         return { result: result_0, context: context, gasCost: context.callContext.currentGasCost };
@@ -440,28 +421,69 @@ export class Contract {
       currentZswapLocalState: context.callContext.currentZswapLocalState
     }
   }
-  _jubjubSchnorrVerify_0(msg_0, signature_0, pk_0) {
-    const __compact_pattern_tmp1_0 = signature_0;
-    const announcement_0 = __compact_pattern_tmp1_0.announcement;
-    const response_0 = __compact_pattern_tmp1_0.response;
-    const cNative_0 = this._transientHash_0({ annX:
-                                                this._jubjubPointX_0(announcement_0),
-                                              annY:
-                                                this._jubjubPointY_0(announcement_0),
-                                              pkX: this._jubjubPointX_0(pk_0),
-                                              pkY: this._jubjubPointY_0(pk_0),
-                                              msg: msg_0 });
-    const c_0 = cNative_0;
-    const lhs_0 = this._ecMulGenerator_0(response_0);
-    const rhs_0 = this._ecAdd_0(announcement_0, this._ecMul_0(pk_0, c_0));
-    return this._equal_0(lhs_0, rhs_0);
+  _hashToSecp256k1Scalar_0(digest_0) {
+    const v_0 = Array.from(digest_0, BigInt);
+    const beReversed_0 = Uint8Array.from([v_0[31],
+                                          v_0[30],
+                                          v_0[29],
+                                          v_0[28],
+                                          v_0[27],
+                                          v_0[26],
+                                          v_0[25],
+                                          v_0[24],
+                                          v_0[23],
+                                          v_0[22],
+                                          v_0[21],
+                                          v_0[20],
+                                          v_0[19],
+                                          v_0[18],
+                                          v_0[17],
+                                          v_0[16],
+                                          v_0[15],
+                                          v_0[14],
+                                          v_0[13],
+                                          v_0[12],
+                                          v_0[11],
+                                          v_0[10],
+                                          v_0[9],
+                                          v_0[8],
+                                          v_0[7],
+                                          v_0[6],
+                                          v_0[5],
+                                          v_0[4],
+                                          v_0[3],
+                                          v_0[2],
+                                          v_0[1],
+                                          v_0[0]],
+                                         Number);
+    return __compactRuntime.convertBytesToField(115792089237316195423570985008687907852837564279074904382605163141518161494336n,
+                                                32,
+                                                beReversed_0,
+                                                'Secp256k1Scalar',
+                                                '<standard library>');
   }
-  _transientHash_0(value_0) {
-    const result_0 = __compactRuntime.transientHash(_descriptor_17, value_0);
-    return result_0;
+  _secp256k1EcdsaVerify_0(msgHash_0, sig_0, pk_0) {
+    const z_0 = this._hashToSecp256k1Scalar_0(msgHash_0);
+    const __compact_pattern_tmp1_0 = sig_0;
+    const r_0 = __compact_pattern_tmp1_0.r;
+    const s_0 = __compact_pattern_tmp1_0.s;
+    const w_0 = this._inv_0(s_0);
+    const u1_0 = this._mul_0(z_0, w_0);
+    const u2_0 = this._mul_0(r_0, w_0);
+    const point_0 = this._ecAdd_0(this._ecMulGenerator_0(u1_0),
+                                  this._ecMul_0(pk_0, u2_0));
+    return __compactRuntime.convertBytesToField(115792089237316195423570985008687907852837564279074904382605163141518161494336n,
+                                                32,
+                                                __compactRuntime.convertBigintToBytes(32,
+                                                                                      this._secp256k1PointX_0(point_0),
+                                                                                      '<standard library>'),
+                                                'Secp256k1Scalar',
+                                                '<standard library>')
+           ===
+           r_0;
   }
   _persistentHash_0(value_0) {
-    const result_0 = __compactRuntime.persistentHash(_descriptor_8, value_0);
+    const result_0 = __compactRuntime.persistentHash(_descriptor_9, value_0);
     return result_0;
   }
   _persistentHash_1(value_0) {
@@ -472,56 +494,42 @@ export class Contract {
     const result_0 = __compactRuntime.persistentHash(_descriptor_7, value_0);
     return result_0;
   }
-  _jubjubPointX_0(pt_0) {
-    const result_0 = __compactRuntime.jubjubPointX(pt_0);
+  _persistentHash_3(value_0) {
+    const result_0 = __compactRuntime.persistentHash(_descriptor_14, value_0);
+    return result_0;
+  }
+  _mul_0(x_0, y_0) {
+    const result_0 = __compactRuntime.secp256k1ScalarMul(x_0, y_0);
     return result_0;
   }
-  _jubjubPointY_0(pt_0) {
-    const result_0 = __compactRuntime.jubjubPointY(pt_0);
+  _inv_0(s_0) {
+    const result_0 = __compactRuntime.secp256k1ScalarInv(s_0);
+    return result_0;
+  }
+  _secp256k1PointX_0(pt_0) {
+    const result_0 = __compactRuntime.secp256k1PointX(pt_0);
     return result_0;
   }
   _ecAdd_0(a_0, b_0) {
-    const result_0 = __compactRuntime.ecAdd(a_0, b_0);
+    const result_0 = __compactRuntime.secp256k1Add(a_0, b_0);
     return result_0;
   }
   _ecMul_0(a_0, b_0) {
-    const result_0 = __compactRuntime.ecMul(a_0, b_0);
+    const result_0 = __compactRuntime.secp256k1Mul(a_0, b_0);
     return result_0;
   }
   _ecMulGenerator_0(b_0) {
-    const result_0 = __compactRuntime.ecMulGenerator(b_0);
+    const result_0 = __compactRuntime.secp256k1MulGenerator(b_0);
     return result_0;
   }
   _signetAttestationMessage_0(requestId_0, serializedOutput_0, outputLen_0) {
-    const rid_0 = requestId_0;
     const outHash_0 = this._persistentHash_1([this._persistentHash_2(serializedOutput_0),
                                               __compactRuntime.convertBigintToBytes(32,
                                                                                     outputLen_0,
-                                                                                    'Signet.compact line 369 char 7')]);
-    return [__compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
-                                                16,
-                                                ((e, i) => e.slice(i, i+16))(rid_0,
-                                                                             Number(0n)),
-                                                'Field',
-                                                'Signet.compact line 372 char 7'),
-            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
-                                                16,
-                                                ((e, i) => e.slice(i, i+16))(rid_0,
-                                                                             Number(16n)),
-                                                'Field',
-                                                'Signet.compact line 373 char 7'),
-            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
-                                                16,
-                                                ((e, i) => e.slice(i, i+16))(outHash_0,
-                                                                             Number(0n)),
-                                                'Field',
-                                                'Signet.compact line 374 char 7'),
-            __compactRuntime.convertBytesToUint(52435875175126190479447740508185965837690552500527637822603658699938581184512n,
-                                                16,
-                                                ((e, i) => e.slice(i, i+16))(outHash_0,
-                                                                             Number(16n)),
-                                                'Field',
-                                                'Signet.compact line 375 char 7')];
+                                                                                    'Signet.compact line 380 char 7')]);
+    return this._persistentHash_3([new Uint8Array([115, 105, 103, 110, 101, 116, 58, 109, 105, 100, 110, 105, 103, 104, 116, 58, 97, 116, 116, 101, 115, 116, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
+                                   requestId_0,
+                                   outHash_0]);
   }
   async _notifyBidirectionalSignatureRequest_0(context,
                                                partialProofData,
@@ -541,8 +549,8 @@ export class Contract {
                                                  value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(requestId_0),
                                                                                               alignment: _descriptor_0.alignment() }).encode() } },
                                        { push: { storage: true,
-                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_13.toValue(notification_0),
-                                                                                              alignment: _descriptor_13.alignment() }).encode() } },
+                                                 value: __compactRuntime.StateValue.newCell({ value: _descriptor_11.toValue(notification_0),
+                                                                                              alignment: _descriptor_11.alignment() }).encode() } },
                                        { ins: { cached: false, n: 1 } },
                                        { ins: { cached: true, n: 1 } }]);
     return [];
@@ -645,11 +653,13 @@ export class Contract {
   async _postRespondBidirectional_0(context,
                                     partialProofData,
                                     requestId_0,
-                                    respondBidirectional_0)
+                                    respondBidirectional_0,
+                                    pk_0)
   {
     const disclosedRequestId_0 = requestId_0;
     const disclosedResponse_0 = respondBidirectional_0;
-    __compactRuntime.assert(this._equal_1(this._persistentHash_0(disclosedResponse_0.pk),
+    const disclosedPk_0 = pk_0;
+    __compactRuntime.assert(this._equal_0(this._persistentHash_0(disclosedPk_0),
                                           _descriptor_0.fromValue(__compactRuntime.queryLedgerState(context,
                                                                                                     partialProofData,
                                                                                                     [
@@ -663,14 +673,22 @@ export class Contract {
                                                                                                      { popeq: { cached: false,
                                                                                                                 result: undefined } }]).value)),
                             'unauthorized: attestation pk is not the MPC key');
-    __compactRuntime.assert(this._jubjubSchnorrVerify_0(this._signetAttestationMessage_0(disclosedRequestId_0,
-                                                                                         disclosedResponse_0.serializedOutput,
-                                                                                         disclosedResponse_0.outputLen),
-                                                        { announcement:
-                                                            disclosedResponse_0.announcement,
-                                                          response:
-                                                            disclosedResponse_0.response },
-                                                        disclosedResponse_0.pk),
+    __compactRuntime.assert(this._secp256k1EcdsaVerify_0(this._signetAttestationMessage_0(disclosedRequestId_0,
+                                                                                          disclosedResponse_0.serializedOutput,
+                                                                                          disclosedResponse_0.outputLen),
+                                                         { r:
+                                                             __compactRuntime.convertBytesToField(115792089237316195423570985008687907852837564279074904382605163141518161494336n,
+                                                                                                  32,
+                                                                                                  disclosedResponse_0.sigR,
+                                                                                                  'Secp256k1Scalar',
+                                                                                                  'signet-contract.compact line 116 char 20'),
+                                                           s:
+                                                             __compactRuntime.convertBytesToField(115792089237316195423570985008687907852837564279074904382605163141518161494336n,
+                                                                                                  32,
+                                                                                                  disclosedResponse_0.sigS,
+                                                                                                  'Secp256k1Scalar',
+                                                                                                  'signet-contract.compact line 117 char 20') },
+                                                         disclosedPk_0),
                             'Invalid attestation signature');
     if (_descriptor_2.fromValue(__compactRuntime.queryLedgerState(context,
                                                                   partialProofData,
@@ -704,20 +722,14 @@ export class Contract {
                                                    value: __compactRuntime.StateValue.newCell({ value: _descriptor_0.toValue(disclosedRequestId_0),
                                                                                                 alignment: _descriptor_0.alignment() }).encode() } },
                                          { push: { storage: true,
-                                                   value: __compactRuntime.StateValue.newCell({ value: _descriptor_10.toValue(disclosedResponse_0),
-                                                                                                alignment: _descriptor_10.alignment() }).encode() } },
+                                                   value: __compactRuntime.StateValue.newCell({ value: _descriptor_8.toValue(disclosedResponse_0),
+                                                                                                alignment: _descriptor_8.alignment() }).encode() } },
                                          { ins: { cached: false, n: 1 } },
                                          { ins: { cached: true, n: 1 } }]);
       return [];
     }
   }
   _equal_0(x0, y0) {
-    if (x0.x != y0.x || x0.y != y0.y) {
-      return false;
-    }
-    return true;
-  }
-  _equal_1(x0, y0) {
     if (!x0.every((x, i) => y0[i] === x)) { return false; }
     return true;
   }
@@ -1037,31 +1049,31 @@ export function ledger(stateOrChargedState) {
                                      'Bytes<32>',
                                      key_0)
         }
-        return _descriptor_10.fromValue(__compactRuntime.queryLedgerState(context,
-                                                                          partialProofData,
-                                                                          [
-                                                                           { dup: { n: 0 } },
-                                                                           { idx: { cached: false,
-                                                                                    pushPath: false,
-                                                                                    path: [
-                                                                                           { tag: 'value',
-                                                                                             value: { value: _descriptor_5.toValue(2n),
-                                                                                                      alignment: _descriptor_5.alignment() } }] } },
-                                                                           { idx: { cached: false,
-                                                                                    pushPath: false,
-                                                                                    path: [
-                                                                                           { tag: 'value',
-                                                                                             value: { value: _descriptor_0.toValue(key_0),
-                                                                                                      alignment: _descriptor_0.alignment() } }] } },
-                                                                           { popeq: { cached: false,
-                                                                                      result: undefined } }]).value);
+        return _descriptor_8.fromValue(__compactRuntime.queryLedgerState(context,
+                                                                         partialProofData,
+                                                                         [
+                                                                          { dup: { n: 0 } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_5.toValue(2n),
+                                                                                                     alignment: _descriptor_5.alignment() } }] } },
+                                                                          { idx: { cached: false,
+                                                                                   pushPath: false,
+                                                                                   path: [
+                                                                                          { tag: 'value',
+                                                                                            value: { value: _descriptor_0.toValue(key_0),
+                                                                                                     alignment: _descriptor_0.alignment() } }] } },
+                                                                          { popeq: { cached: false,
+                                                                                     result: undefined } }]).value);
       },
       [Symbol.iterator](...args_0) {
         if (args_0.length !== 0) {
           throw new __compactRuntime.CompactError(`iter: expected 0 arguments, received ${args_0.length}`);
         }
         const self_0 = state.asArray()[2];
-        return self_0.asMap().keys().map(  (key) => {    const value = self_0.asMap().get(key).asCell();    return [      _descriptor_0.fromValue(key.value),      _descriptor_10.fromValue(value.value)    ];  })[Symbol.iterator]();
+        return self_0.asMap().keys().map(  (key) => {    const value = self_0.asMap().get(key).asCell();    return [      _descriptor_0.fromValue(key.value),      _descriptor_8.fromValue(value.value)    ];  })[Symbol.iterator]();
       }
     },
     get mpcPubKeyHash() {
@@ -1160,7 +1172,7 @@ export function ledger(stateOrChargedState) {
                                      'Bytes<32>',
                                      key_0)
         }
-        return _descriptor_13.fromValue(__compactRuntime.queryLedgerState(context,
+        return _descriptor_11.fromValue(__compactRuntime.queryLedgerState(context,
                                                                           partialProofData,
                                                                           [
                                                                            { dup: { n: 0 } },
@@ -1184,7 +1196,7 @@ export function ledger(stateOrChargedState) {
           throw new __compactRuntime.CompactError(`iter: expected 0 arguments, received ${args_0.length}`);
         }
         const self_0 = state.asArray()[4];
-        return self_0.asMap().keys().map(  (key) => {    const value = self_0.asMap().get(key).asCell();    return [      _descriptor_0.fromValue(key.value),      _descriptor_13.fromValue(value.value)    ];  })[Symbol.iterator]();
+        return self_0.asMap().keys().map(  (key) => {    const value = self_0.asMap().get(key).asCell();    return [      _descriptor_0.fromValue(key.value),      _descriptor_11.fromValue(value.value)    ];  })[Symbol.iterator]();
       }
     }
   };
@@ -1197,9 +1209,9 @@ export const pureCircuits = {};
 export const contractReferenceLocations =
   { tag: 'publicLedgerArray', indices: { } };
 export const expectedVk = {
-  'notifyBidirectionalSignatureRequest': 'd36e5392bc781c69b136080843b96458d170304502f346f0d784fa8e133a54c3',
-  'postRespondBidirectional': '0c245f8a93de6fec296de814b7b6424ebad1ac62375ab134fb4d9868b6df95d0',
-  'postSignatureResponse': 'aece39967c6c69cac6a8215b841ef62dd49ceb16a97804a0b67621ef36cdc22e',
+  'notifyBidirectionalSignatureRequest': '79a18d16c3486302eeb8ec7129d928778a408b9e5eba7d45bec6fea4594311bc',
+  'postRespondBidirectional': '02f784f3fde56567349ba646b0afb3bfdd70af5da4d822764b9d9f1c2138ab88',
+  'postSignatureResponse': '493513937e36c24eb3b921e44e26be057b6160a5c9c89fecf0a738e1bb216a80',
 };
 
 //# sourceMappingURL=index.js.map

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

@@ -2,7 +2,7 @@
   "version": 3,
   "file": "index.js",
   "sourceRoot": "../../../",
-  "sources": ["src/signet-contract.compact", "compiler/standard-library.compact", "compiler/zkir-v3-library.compact", "../../node_modules/@sig-net/midnight/src/Signet.compact"],
+  "sources": ["src/signet-contract.compact", "compiler/zkir-v3-library.compact", "../../node_modules/@sig-net/midnight/src/Signet.compact"],
   "names": [],
-  "mappings": "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"
+  "mappings": "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"
 }