@sig-net/midnight 0.21.0-rc.9 → 0.21.0

package/dist/managed/contract/index.js

@@ -64,13 +64,9 @@ const _descriptor_7 = new __compactRuntime.CompactTypeBytes(100);
 
 const _descriptor_8 = new __compactRuntime.CompactTypeBytes(1);
 
-const _descriptor_9 = new __compactRuntime.CompactTypeBytes(2);
+const _descriptor_9 = new __compactRuntime.CompactTypeUnsignedInteger(340282366920938463463374607431768211455n, 16);
 
-const _descriptor_10 = new __compactRuntime.CompactTypeUnsignedInteger(340282366920938463463374607431768211455n, 16);
-
-const _descriptor_11 = new __compactRuntime.CompactTypeBytes(20);
-
-const _descriptor_12 = __compactRuntime.CompactTypeSecp256k1Scalar;
+const _descriptor_10 = new __compactRuntime.CompactTypeBytes(20);
 
 class _ContractAddress_0 {
   alignment() {
@@ -86,123 +82,104 @@ class _ContractAddress_0 {
   }
 }
 
-const _descriptor_13 = new _ContractAddress_0();
+const _descriptor_11 = new _ContractAddress_0();
 
-const _descriptor_14 = new __compactRuntime.CompactTypeVector(4, _descriptor_2);
+const _descriptor_12 = new __compactRuntime.CompactTypeVector(4, _descriptor_2);
 
-const _descriptor_15 = new __compactRuntime.CompactTypeBytes(128);
+const _descriptor_13 = new __compactRuntime.CompactTypeBytes(128);
 
 class _SignBidirectionalEventNotification_0 {
   alignment() {
-    return _descriptor_2.alignment().concat(_descriptor_15.alignment());
+    return _descriptor_2.alignment().concat(_descriptor_13.alignment());
   }
   fromValue(value_0) {
     return {
       version: _descriptor_2.fromValue(value_0),
-      payload: _descriptor_15.fromValue(value_0)
+      payload: _descriptor_13.fromValue(value_0)
     }
   }
   toValue(value_0) {
-    return _descriptor_2.toValue(value_0.version).concat(_descriptor_15.toValue(value_0.payload));
+    return _descriptor_2.toValue(value_0.version).concat(_descriptor_13.toValue(value_0.payload));
   }
 }
 
-const _descriptor_16 = new _SignBidirectionalEventNotification_0();
+const _descriptor_14 = new _SignBidirectionalEventNotification_0();
 
-const _descriptor_17 = __compactRuntime.CompactTypeSecp256k1Base;
-
-const _descriptor_18 = __compactRuntime.CompactTypeField;
+const _descriptor_15 = __compactRuntime.CompactTypeSecp256k1Scalar;
 
-const _descriptor_19 = new __compactRuntime.CompactTypeUnsignedInteger(18446744073709551615n, 8);
+const _descriptor_16 = __compactRuntime.CompactTypeSecp256k1Base;
 
 class _tuple_0 {
   alignment() {
-    return _descriptor_0.alignment().concat(_descriptor_19.alignment().concat(_descriptor_7.alignment()));
-  }
-  fromValue(value_0) {
-    return [
-      _descriptor_0.fromValue(value_0),
-      _descriptor_19.fromValue(value_0),
-      _descriptor_7.fromValue(value_0)
-    ]
-  }
-  toValue(value_0) {
-    return _descriptor_0.toValue(value_0[0]).concat(_descriptor_19.toValue(value_0[1]).concat(_descriptor_7.toValue(value_0[2])));
-  }
-}
-
-const _descriptor_20 = new _tuple_0();
-
-class _tuple_1 {
-  alignment() {
-    return _descriptor_0.alignment().concat(_descriptor_19.alignment().concat(_descriptor_0.alignment()));
+    return _descriptor_0.alignment().concat(_descriptor_0.alignment());
   }
   fromValue(value_0) {
     return [
       _descriptor_0.fromValue(value_0),
-      _descriptor_19.fromValue(value_0),
       _descriptor_0.fromValue(value_0)
     ]
   }
   toValue(value_0) {
-    return _descriptor_0.toValue(value_0[0]).concat(_descriptor_19.toValue(value_0[1]).concat(_descriptor_0.toValue(value_0[2])));
+    return _descriptor_0.toValue(value_0[0]).concat(_descriptor_0.toValue(value_0[1]));
   }
 }
 
-const _descriptor_21 = new _tuple_1();
+const _descriptor_17 = new _tuple_0();
 
-class _tuple_2 {
+const _descriptor_18 = __compactRuntime.CompactTypeField;
+
+class _tuple_1 {
   alignment() {
-    return _descriptor_0.alignment().concat(_descriptor_19.alignment().concat(_descriptor_8.alignment()));
+    return _descriptor_0.alignment().concat(_descriptor_8.alignment());
   }
   fromValue(value_0) {
     return [
       _descriptor_0.fromValue(value_0),
-      _descriptor_19.fromValue(value_0),
       _descriptor_8.fromValue(value_0)
     ]
   }
   toValue(value_0) {
-    return _descriptor_0.toValue(value_0[0]).concat(_descriptor_19.toValue(value_0[1]).concat(_descriptor_8.toValue(value_0[2])));
+    return _descriptor_0.toValue(value_0[0]).concat(_descriptor_8.toValue(value_0[1]));
   }
 }
 
-const _descriptor_22 = new _tuple_2();
+const _descriptor_19 = new _tuple_1();
 
-class _tuple_3 {
+class _tuple_2 {
   alignment() {
-    return _descriptor_0.alignment().concat(_descriptor_19.alignment().concat(_descriptor_9.alignment()));
+    return _descriptor_0.alignment().concat(_descriptor_7.alignment());
   }
   fromValue(value_0) {
     return [
       _descriptor_0.fromValue(value_0),
-      _descriptor_19.fromValue(value_0),
-      _descriptor_9.fromValue(value_0)
+      _descriptor_7.fromValue(value_0)
     ]
   }
   toValue(value_0) {
-    return _descriptor_0.toValue(value_0[0]).concat(_descriptor_19.toValue(value_0[1]).concat(_descriptor_9.toValue(value_0[2])));
+    return _descriptor_0.toValue(value_0[0]).concat(_descriptor_7.toValue(value_0[1]));
   }
 }
 
-const _descriptor_23 = new _tuple_3();
+const _descriptor_20 = new _tuple_2();
 
 class _Secp256k1EcdsaSignature_0 {
   alignment() {
-    return _descriptor_12.alignment().concat(_descriptor_12.alignment());
+    return _descriptor_15.alignment().concat(_descriptor_15.alignment());
   }
   fromValue(value_0) {
     return {
-      r: _descriptor_12.fromValue(value_0),
-      s: _descriptor_12.fromValue(value_0)
+      r: _descriptor_15.fromValue(value_0),
+      s: _descriptor_15.fromValue(value_0)
     }
   }
   toValue(value_0) {
-    return _descriptor_12.toValue(value_0.r).concat(_descriptor_12.toValue(value_0.s));
+    return _descriptor_15.toValue(value_0.r).concat(_descriptor_15.toValue(value_0.s));
   }
 }
 
-const _descriptor_24 = new _Secp256k1EcdsaSignature_0();
+const _descriptor_21 = new _Secp256k1EcdsaSignature_0();
+
+const _descriptor_22 = new __compactRuntime.CompactTypeUnsignedInteger(18446744073709551615n, 8);
 
 class _Either_0 {
   alignment() {
@@ -220,9 +197,9 @@ class _Either_0 {
   }
 }
 
-const _descriptor_25 = new _Either_0();
+const _descriptor_23 = new _Either_0();
 
-const _descriptor_26 = new __compactRuntime.CompactTypeUnsignedInteger(4294967295n, 4);
+const _descriptor_24 = new __compactRuntime.CompactTypeUnsignedInteger(4294967295n, 4);
 
 export class Contract {
   witnesses;
@@ -239,6 +216,9 @@ export class Contract {
       async constructSignBidirectionalEventNotificationV1(context, ...args_1) {
         return { result: pureCircuits.constructSignBidirectionalEventNotificationV1(...args_1), context };
       },
+      async ethereumCaip2Id(context, ...args_1) {
+        return { result: pureCircuits.ethereumCaip2Id(...args_1), context };
+      },
       async evmAddressAbiWord(context, ...args_1) {
         return { result: pureCircuits.evmAddressAbiWord(...args_1), context };
       },
@@ -257,9 +237,6 @@ export class Contract {
       async calculateSignetAttestationDigest1(context, ...args_1) {
         return { result: pureCircuits.calculateSignetAttestationDigest1(...args_1), context };
       },
-      async calculateSignetAttestationDigest2(context, ...args_1) {
-        return { result: pureCircuits.calculateSignetAttestationDigest2(...args_1), context };
-      },
       async calculateSignetAttestationDigest32(context, ...args_1) {
         return { result: pureCircuits.calculateSignetAttestationDigest32(...args_1), context };
       },
@@ -366,19 +343,15 @@ export class Contract {
            r_0;
   }
   _transientHash_0(value_0) {
-    const result_0 = __compactRuntime.transientHash(_descriptor_22, value_0);
+    const result_0 = __compactRuntime.transientHash(_descriptor_19, value_0);
     return result_0;
   }
   _transientHash_1(value_0) {
-    const result_0 = __compactRuntime.transientHash(_descriptor_23, value_0);
-    return result_0;
-  }
-  _transientHash_2(value_0) {
     const result_0 = __compactRuntime.transientHash(_descriptor_20, value_0);
     return result_0;
   }
-  _transientHash_3(value_0) {
-    const result_0 = __compactRuntime.transientHash(_descriptor_21, value_0);
+  _transientHash_2(value_0) {
+    const result_0 = __compactRuntime.transientHash(_descriptor_17, value_0);
     return result_0;
   }
   _upgradeFromTransient_0(x_0) {
@@ -426,22 +399,14 @@ export class Contract {
   }
   _calculateSignetAttestationDigest_0(requestId_0, serializedOutput_0) {
     return this._upgradeFromTransient_0(this._transientHash_0([requestId_0,
-                                                               1n,
                                                                serializedOutput_0]));
   }
   _calculateSignetAttestationDigest_1(requestId_0, serializedOutput_0) {
     return this._upgradeFromTransient_0(this._transientHash_1([requestId_0,
-                                                               2n,
                                                                serializedOutput_0]));
   }
   _calculateSignetAttestationDigest_2(requestId_0, serializedOutput_0) {
     return this._upgradeFromTransient_0(this._transientHash_2([requestId_0,
-                                                               100n,
-                                                               serializedOutput_0]));
-  }
-  _calculateSignetAttestationDigest_3(requestId_0, serializedOutput_0) {
-    return this._upgradeFromTransient_0(this._transientHash_3([requestId_0,
-                                                               32n,
                                                                serializedOutput_0]));
   }
   _verifyRespondBidirectionalEvent_0(requestId_0,
@@ -449,7 +414,7 @@ export class Contract {
                                      respondBidirectionalEvent_0,
                                      mpcResponseKey_0)
   {
-    const digest_0 = this._calculateSignetAttestationDigest_3(requestId_0,
+    const digest_0 = this._calculateSignetAttestationDigest_2(requestId_0,
                                                               serializedOutput_0);
     return this._secp256k1EcdsaVerify_0(digest_0,
                                         { r:
@@ -457,15 +422,18 @@ export class Contract {
                                                                                  32,
                                                                                  respondBidirectionalEvent_0.signature.bigR.x,
                                                                                  'Secp256k1Scalar',
-                                                                                 'Signet.compact line 345 char 12'),
+                                                                                 'Signet.compact line 347 char 12'),
                                           s:
                                             __compactRuntime.convertBytesToField(115792089237316195423570985008687907852837564279074904382605163141518161494336n,
                                                                                  32,
                                                                                  respondBidirectionalEvent_0.signature.s,
                                                                                  'Secp256k1Scalar',
-                                                                                 'Signet.compact line 346 char 12') },
+                                                                                 'Signet.compact line 348 char 12') },
                                         mpcResponseKey_0);
   }
+  _ethereumCaip2Id_0() {
+    return new Uint8Array([101, 105, 112, 49, 53, 53, 58, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+  }
   _evmAddressAbiWord_0(addr_0) {
     return Uint8Array.from([...Array.from(new Uint8Array(12), BigInt),
                             ...Array.from(addr_0, BigInt)],
@@ -474,7 +442,7 @@ export class Contract {
   _numericAbiWord_0(value_0) {
     const le_0 = Array.from(__compactRuntime.convertBigintToBytes(16,
                                                                   value_0,
-                                                                  'Signet.compact line 424 char 17'),
+                                                                  'Signet.compact line 437 char 17'),
                             BigInt);
     return Uint8Array.from([...Array.from(new Uint8Array(16), BigInt),
                             le_0[15],
@@ -556,7 +524,7 @@ export class Contract {
                                             v_0[31]);
     return ((t1) => {
              if (t1 > 340282366920938463463374607431768211455n) {
-               throw new __compactRuntime.CompactError('Signet.compact line 476 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 489 char 12: cast from Field or Uint value to smaller Uint value failed: ' + t1 + ' is greater than 340282366920938463463374607431768211455');
              }
              return t1;
            })(b15_0);
@@ -567,7 +535,7 @@ export class Contract {
                                                                 ((e, i) => e.slice(i, i+31))(word_0,
                                                                                              Number(0n)),
                                                                 'Field',
-                                                                'Signet.compact line 482 char 12')
+                                                                'Signet.compact line 495 char 12')
                             ===
                             0n,
                             'ABI word is not a canonical Boolean');
@@ -576,7 +544,7 @@ export class Contract {
                                                        ((e, i) => e.slice(i, i+1))(word_0,
                                                                                    Number(31n)),
                                                        'Field',
-                                                       'Signet.compact line 483 char 18');
+                                                       'Signet.compact line 496 char 18');
     __compactRuntime.assert(last_0 === 0n || last_0 === 1n,
                             'ABI word is not a canonical Boolean');
     return last_0 === 1n;
@@ -585,16 +553,12 @@ export class Contract {
     return this._calculateSignetAttestationDigest_0(requestId_0,
                                                     serializedOutput_0);
   }
-  _calculateSignetAttestationDigest2_0(requestId_0, serializedOutput_0) {
-    return this._calculateSignetAttestationDigest_1(requestId_0,
-                                                    serializedOutput_0);
-  }
   _calculateSignetAttestationDigest32_0(requestId_0, serializedOutput_0) {
-    return this._calculateSignetAttestationDigest_3(requestId_0,
+    return this._calculateSignetAttestationDigest_2(requestId_0,
                                                     serializedOutput_0);
   }
   _calculateSignetAttestationDigest100_0(requestId_0, serializedOutput_0) {
-    return this._calculateSignetAttestationDigest_2(requestId_0,
+    return this._calculateSignetAttestationDigest_1(requestId_0,
                                                     serializedOutput_0);
   }
   _verifyRespondBidirectionalEvent32_0(requestId_0,
@@ -639,21 +603,21 @@ export const pureCircuits = {
     if (!(typeof(callerAddress_0) === 'object' && callerAddress_0.bytes.buffer instanceof ArrayBuffer && callerAddress_0.bytes.BYTES_PER_ELEMENT === 1 && callerAddress_0.bytes.length === 32)) {
       __compactRuntime.typeError('constructSignBidirectionalEventNotificationV1',
                                  'argument 1',
-                                 'Signet.compact line 238 char 3',
+                                 'Signet.compact line 240 char 3',
                                  'struct ContractAddress<bytes: Bytes<32>>',
                                  callerAddress_0)
     }
     if (!(typeof(requestsPathDepth_0) === 'bigint' && requestsPathDepth_0 >= 0n && requestsPathDepth_0 <= 255n)) {
       __compactRuntime.typeError('constructSignBidirectionalEventNotificationV1',
                                  'argument 2',
-                                 'Signet.compact line 238 char 3',
+                                 'Signet.compact line 240 char 3',
                                  'Uint<0..256>',
                                  requestsPathDepth_0)
     }
     if (!(Array.isArray(requestsPath_0) && requestsPath_0.length === 4 && requestsPath_0.every((t) => typeof(t) === 'bigint' && t >= 0n && t <= 255n))) {
       __compactRuntime.typeError('constructSignBidirectionalEventNotificationV1',
                                  'argument 3',
-                                 'Signet.compact line 238 char 3',
+                                 'Signet.compact line 240 char 3',
                                  'Vector<4, Uint<0..256>>',
                                  requestsPath_0)
     }
@@ -661,6 +625,12 @@ export const pureCircuits = {
                                                                            requestsPathDepth_0,
                                                                            requestsPath_0);
   },
+  ethereumCaip2Id: (...args_0) => {
+    if (args_0.length !== 0) {
+      throw new __compactRuntime.CompactError(`ethereumCaip2Id: expected 0 arguments (as invoked from Typescript), received ${args_0.length}`);
+    }
+    return _dummyContract._ethereumCaip2Id_0();
+  },
   evmAddressAbiWord: (...args_0) => {
     if (args_0.length !== 1) {
       throw new __compactRuntime.CompactError(`evmAddressAbiWord: expected 1 argument (as invoked from Typescript), received ${args_0.length}`);
@@ -669,7 +639,7 @@ export const pureCircuits = {
     if (!(addr_0.buffer instanceof ArrayBuffer && addr_0.BYTES_PER_ELEMENT === 1 && addr_0.length === 20)) {
       __compactRuntime.typeError('evmAddressAbiWord',
                                  'argument 1',
-                                 'Signet.compact line 415 char 3',
+                                 'Signet.compact line 428 char 3',
                                  'Bytes<20>',
                                  addr_0)
     }
@@ -683,7 +653,7 @@ export const pureCircuits = {
     if (!(typeof(value_0) === 'bigint' && value_0 >= 0n && value_0 <= 340282366920938463463374607431768211455n)) {
       __compactRuntime.typeError('numericAbiWord',
                                  'argument 1',
-                                 'Signet.compact line 421 char 3',
+                                 'Signet.compact line 434 char 3',
                                  'Uint<0..340282366920938463463374607431768211456>',
                                  value_0)
     }
@@ -697,7 +667,7 @@ export const pureCircuits = {
     if (!(typeof(value_0) === 'boolean')) {
       __compactRuntime.typeError('boolAbiWord',
                                  'argument 1',
-                                 'Signet.compact line 434 char 3',
+                                 'Signet.compact line 447 char 3',
                                  'Boolean',
                                  value_0)
     }
@@ -711,7 +681,7 @@ export const pureCircuits = {
     if (!(word_0.buffer instanceof ArrayBuffer && word_0.BYTES_PER_ELEMENT === 1 && word_0.length === 32)) {
       __compactRuntime.typeError('abiWordToUint128',
                                  'argument 1',
-                                 'Signet.compact line 442 char 3',
+                                 'Signet.compact line 455 char 3',
                                  'Bytes<32>',
                                  word_0)
     }
@@ -725,7 +695,7 @@ export const pureCircuits = {
     if (!(word_0.buffer instanceof ArrayBuffer && word_0.BYTES_PER_ELEMENT === 1 && word_0.length === 32)) {
       __compactRuntime.typeError('abiWordToBool',
                                  'argument 1',
-                                 'Signet.compact line 481 char 3',
+                                 'Signet.compact line 494 char 3',
                                  'Bytes<32>',
                                  word_0)
     }
@@ -740,43 +710,20 @@ export const pureCircuits = {
     if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
       __compactRuntime.typeError('calculateSignetAttestationDigest1',
                                  'argument 1',
-                                 'circuits.compact line 27 char 1',
+                                 'circuits.compact line 28 char 1',
                                  'Bytes<32>',
                                  requestId_0)
     }
     if (!(serializedOutput_0.buffer instanceof ArrayBuffer && serializedOutput_0.BYTES_PER_ELEMENT === 1 && serializedOutput_0.length === 1)) {
       __compactRuntime.typeError('calculateSignetAttestationDigest1',
                                  'argument 2',
-                                 'circuits.compact line 27 char 1',
+                                 'circuits.compact line 28 char 1',
                                  'Bytes<1>',
                                  serializedOutput_0)
     }
     return _dummyContract._calculateSignetAttestationDigest1_0(requestId_0,
                                                                serializedOutput_0);
   },
-  calculateSignetAttestationDigest2: (...args_0) => {
-    if (args_0.length !== 2) {
-      throw new __compactRuntime.CompactError(`calculateSignetAttestationDigest2: expected 2 arguments (as invoked from Typescript), received ${args_0.length}`);
-    }
-    const requestId_0 = args_0[0];
-    const serializedOutput_0 = args_0[1];
-    if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
-      __compactRuntime.typeError('calculateSignetAttestationDigest2',
-                                 'argument 1',
-                                 'circuits.compact line 34 char 1',
-                                 'Bytes<32>',
-                                 requestId_0)
-    }
-    if (!(serializedOutput_0.buffer instanceof ArrayBuffer && serializedOutput_0.BYTES_PER_ELEMENT === 1 && serializedOutput_0.length === 2)) {
-      __compactRuntime.typeError('calculateSignetAttestationDigest2',
-                                 'argument 2',
-                                 'circuits.compact line 34 char 1',
-                                 'Bytes<2>',
-                                 serializedOutput_0)
-    }
-    return _dummyContract._calculateSignetAttestationDigest2_0(requestId_0,
-                                                               serializedOutput_0);
-  },
   calculateSignetAttestationDigest32: (...args_0) => {
     if (args_0.length !== 2) {
       throw new __compactRuntime.CompactError(`calculateSignetAttestationDigest32: expected 2 arguments (as invoked from Typescript), received ${args_0.length}`);
@@ -786,14 +733,14 @@ export const pureCircuits = {
     if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
       __compactRuntime.typeError('calculateSignetAttestationDigest32',
                                  'argument 1',
-                                 'circuits.compact line 41 char 1',
+                                 'circuits.compact line 35 char 1',
                                  'Bytes<32>',
                                  requestId_0)
     }
     if (!(serializedOutput_0.buffer instanceof ArrayBuffer && serializedOutput_0.BYTES_PER_ELEMENT === 1 && serializedOutput_0.length === 32)) {
       __compactRuntime.typeError('calculateSignetAttestationDigest32',
                                  'argument 2',
-                                 'circuits.compact line 41 char 1',
+                                 'circuits.compact line 35 char 1',
                                  'Bytes<32>',
                                  serializedOutput_0)
     }
@@ -809,14 +756,14 @@ export const pureCircuits = {
     if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
       __compactRuntime.typeError('calculateSignetAttestationDigest100',
                                  'argument 1',
-                                 'circuits.compact line 48 char 1',
+                                 'circuits.compact line 42 char 1',
                                  'Bytes<32>',
                                  requestId_0)
     }
     if (!(serializedOutput_0.buffer instanceof ArrayBuffer && serializedOutput_0.BYTES_PER_ELEMENT === 1 && serializedOutput_0.length === 100)) {
       __compactRuntime.typeError('calculateSignetAttestationDigest100',
                                  'argument 2',
-                                 'circuits.compact line 48 char 1',
+                                 'circuits.compact line 42 char 1',
                                  'Bytes<100>',
                                  serializedOutput_0)
     }
@@ -834,21 +781,21 @@ export const pureCircuits = {
     if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
       __compactRuntime.typeError('verifyRespondBidirectionalEvent32',
                                  'argument 1',
-                                 'circuits.compact line 55 char 1',
+                                 'circuits.compact line 49 char 1',
                                  'Bytes<32>',
                                  requestId_0)
     }
     if (!(serializedOutput_0.buffer instanceof ArrayBuffer && serializedOutput_0.BYTES_PER_ELEMENT === 1 && serializedOutput_0.length === 32)) {
       __compactRuntime.typeError('verifyRespondBidirectionalEvent32',
                                  'argument 2',
-                                 'circuits.compact line 55 char 1',
+                                 'circuits.compact line 49 char 1',
                                  'Bytes<32>',
                                  serializedOutput_0)
     }
     if (!(typeof(respondBidirectionalEvent_0) === 'object' && typeof(respondBidirectionalEvent_0.signature) === 'object' && typeof(respondBidirectionalEvent_0.signature.bigR) === 'object' && respondBidirectionalEvent_0.signature.bigR.x.buffer instanceof ArrayBuffer && respondBidirectionalEvent_0.signature.bigR.x.BYTES_PER_ELEMENT === 1 && respondBidirectionalEvent_0.signature.bigR.x.length === 32 && respondBidirectionalEvent_0.signature.bigR.y.buffer instanceof ArrayBuffer && respondBidirectionalEvent_0.signature.bigR.y.BYTES_PER_ELEMENT === 1 && respondBidirectionalEvent_0.signature.bigR.y.length === 32 && respondBidirectionalEvent_0.signature.s.buffer instanceof ArrayBuffer && respondBidirectionalEvent_0.signature.s.BYTES_PER_ELEMENT === 1 && respondBidirectionalEvent_0.signature.s.length === 32 && typeof(respondBidirectionalEvent_0.signature.recoveryId) === 'bigint' && respondBidirectionalEvent_0.signature.recoveryId >= 0n && respondBidirectionalEvent_0.signature.recoveryId <= 255n)) {
       __compactRuntime.typeError('verifyRespondBidirectionalEvent32',
                                  'argument 3',
-                                 'circuits.compact line 55 char 1',
+                                 'circuits.compact line 49 char 1',
                                  'struct RespondBidirectionalEvent<signature: struct Signature<bigR: struct AffinePoint<x: Bytes<32>, y: Bytes<32>>, s: Bytes<32>, recoveryId: Uint<0..256>>>',
                                  respondBidirectionalEvent_0)
     }

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

@@ -4,5 +4,5 @@
   "sourceRoot": "../../../",
   "sources": ["src/circuits.compact", "src/./Signet.compact", "compiler/zkir-v3-library.compact"],
   "names": [],
-  "mappings": "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"
+  "mappings": "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"
 }

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

@@ -41,7 +41,7 @@ export interface EvmAccessListEntry {
  * leading slots are real.
  */
 export interface EvmType2TxParams {
-    /** EVM chain id (also expressed in the record's `caip2Id`). */
+    /** EIP-155 chain id of the network the signed transaction is valid on. */
     chainId: bigint;
     /** Account nonce of the MPC-derived sender address. */
     nonce: bigint;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sig-net/midnight",
-  "version": "0.21.0-rc.9",
+  "version": "0.21.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/sig-net/midnight-integration",
@@ -49,15 +49,16 @@
     "@midnight-ntwrk/compact-runtime": "0.18.0-rc.1",
     "@midnight-ntwrk/midnight-js-types": "5.0.0-beta.6",
     "@noble/curves": "^2.2.0",
-    "@sig-net/midnight-serde": "^0.21.0-rc.9",
+    "@sig-net/midnight-serde": "^0.21.0",
     "ethers": "^6.17.0"
   },
   "devDependencies": {
     "@types/node": "^26.1.0",
-    "@vitest/coverage-v8": "^4.1.10",
+    "@vitest/coverage-v8": "^5.0.0",
     "tsx": "^4.23.0",
     "typescript": "^7.0.2",
-    "vitest": "^4.1.9"
+    "vite": "^8.2.2",
+    "vitest": "^5.0.0"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts"

package/src/Signet.compact

@@ -96,8 +96,10 @@ module Signet {
     // Specific destination chain Transaction parameters.
     txParamType: TxParamType; // Off-chain tag indicating what type txParams is set to.
     txParams: TxParams; // The generic transaction-param payload
-    caip2Id: Bytes<32>;       // Target chain in CAIP-2 form, e.g. "eip155:11155111"
-                              // (https://chainagnostic.org/CAIPs/caip-2)
+    caip2Id: Bytes<32>;       // The MPC's routing key for the target chain, in CAIP-2 form
+                              // (https://chainagnostic.org/CAIPs/caip-2). An Ethereum target
+                              // (mainnet, Sepolia or a local anvil) uses ethereumCaip2Id():
+                              // the network itself is txParams' chainId.
 
     // Serialisation Schemas.
     // outputDeserializationSchema tells the MPC how to deserialise the destination chain's
@@ -312,7 +314,7 @@ module Signet {
     requestId: RequestId,
     serializedOutput: Bytes<serializedOutputLength>,
   ): Bytes<32> {
-    return upgradeFromTransient(transientHash<[RequestId, Uint<64>, Bytes<serializedOutputLength>]>([requestId, serializedOutputLength as Uint<64>, serializedOutput]));
+    return upgradeFromTransient(transientHash<[RequestId, Bytes<serializedOutputLength>]>([requestId, serializedOutput]));
   }
 
   // Verifies a RespondBidirectionalEvent against its execution output and MPC
@@ -351,6 +353,17 @@ module Signet {
 
   // ---- EVM Type2 Transaction Parameters --------------------------------------------------------------
 
+  // The caip2Id of every request targeting Ethereum, whichever Ethereum network the
+  // MPC node watches (mainnet, Sepolia or a local anvil: node configuration picks it).
+  // The MPC routes on this exact string (Chain::Ethereum in sig-net/mpc
+  // signet-primitives/src/chain.rs) and rejects the request for any other value,
+  // the network's own CAIP-2 id included. EvmType2TxParams.chainId is what binds
+  // the signed transaction to one network. Ethereum only: another EVM chain, such as
+  // BNB Smart Chain, is a separate chain to the MPC, never one of Ethereum's networks.
+  export pure circuit ethereumCaip2Id(): Bytes<32> {
+    return pad(32, "eip155:1");
+  }
+
   // The EVM transaction to be signed, decomposed into typed fields
   // (EIP-1559 / type-2: https://eips.ethereum.org/EIPS/eip-1559) so the
   // requesting contract can enforce invariants field by field. The MPC
@@ -366,7 +379,7 @@ module Signet {
   // KEY: texual order of the fields in this structure must remain fixed as is as their order
   //      is relied upon for consistent hashing and decoding from ledger state.
   export struct EvmType2TxParams<#maxCalldataWords, #maxAccessListEntries, #maxStorageKeysPerEntry> {
-    chainId: Uint<64>;               // EVM chain id (also expressed in caip2Id)
+    chainId: Uint<64>;               // EIP-155 chain id of the network the signed tx is valid on
     nonce: Uint<64>;                 // account nonce of the derived sender
     maxPriorityFeePerGas: Uint<128>; // wei
     maxFeePerGas: Uint<128>;         // wei