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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.d.ts CHANGED
@@ -1,7 +1,7 @@
1
1
  export * from "./abi-serde.ts";
2
2
  export { bigintToBytes32, bigintToBytes32BE, BLS_ORDER, bytesToBigint, bytesToBigintBE, bytesToHex, hexToBytes, stripHexPrefix, } from "./byte-codecs.ts";
3
3
  export * from "./constants.ts";
4
- export { deriveEpsilon, deriveEvmAddress, deriveMidnightResponseKey, EPSILON_DERIVATION_PREFIX, MIDNIGHT_RESPOND_BIDIRECTIONAL_PATH, MIDNIGHT_TESTNET_CHAIN_ID, } from "./epsilon-derivation.ts";
4
+ export { deriveEpsilon, deriveEvmAddress, deriveMidnightResponseKey, EPSILON_DERIVATION_PREFIX, MIDNIGHT_CAIP2_ID, MIDNIGHT_RESPOND_BIDIRECTIONAL_PATH, } from "./epsilon-derivation.ts";
5
5
  export { type RawContractState, signetFieldNodeByPath } from "./raw-contract-state.ts";
6
6
  export * from "./signature-requests-state-reader.ts";
7
7
  export * from "./signature-response-verification.ts";
@@ -10,7 +10,7 @@ export { abiWordToBool, abiWordToUint128, assembleCalldata, boolAbiWord, type Ev
10
10
  export { calculateRequestId } from "./signet-request-id.ts";
11
11
  export * from "./signet-request-response-reader.ts";
12
12
  export { type ContractAddress, contractAddressFromHex, type Maybe, MPCDestination, MPCSignatureAlgorithm, parseRequestIdHex, PATH_BYTES, type RequestId, requestIdBytes, type RequestIdHex, requestIdHex, type SignBidirectionalEvent, type SignBidirectionalEventIndex, type SignBidirectionalEventLedgerMap, toSignBidirectionalEventIndex, TxParamType, } from "./signet-requests.ts";
13
- export { formatSecp256k1PublicKey, parseSecp256k1PublicKey, respondBidirectionalEventToCircuitInput, SECP256K1_ORDER, type Secp256k1Point, signatureRespondedEventToSignature, verifyRespondBidirectionalSignature, } from "./ecdsa-attestation.ts";
13
+ export { formatSecp256k1PublicKey, normaliseSecp256k1PublicKey, parseSecp256k1PublicKey, respondBidirectionalEventToCircuitInput, SECP256K1_ORDER, type Secp256k1Point, signatureRespondedEventToSignature, verifyRespondBidirectionalSignature, } from "./ecdsa-attestation.ts";
14
14
  /**
15
15
  * Compiled pure circuits of Signet.compact (run `yarn compile` first).
16
16
  * Off-chain code MUST use these instead of re-porting the algorithms:
@@ -1 +1 @@
1
- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,SAAS,EACT,aAAa,EACb,eAAe,EACf,UAAU,EACV,UAAU,EACV,cAAc,GACf,MAAM,kBAAkB,CAAC;AAI1B,cAAc,gBAAgB,CAAC;AAG/B,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,yBAAyB,EACzB,yBAAyB,EACzB,mCAAmC,EACnC,yBAAyB,GAC1B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,KAAK,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AACvF,cAAc,sCAAsC,CAAC;AACrD,cAAc,sCAAsC,CAAC;AACrD,cAAc,6BAA6B,CAAC;AAC5C,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,WAAW,EACX,KAAK,kBAAkB,EACvB,iBAAiB,EACjB,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACrB,cAAc,EACd,4CAA4C,EAC5C,8CAA8C,GAC/C,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,cAAc,qCAAqC,CAAC;AACpD,OAAO,EACL,KAAK,eAAe,EACpB,sBAAsB,EACtB,KAAK,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,iBAAiB,EACjB,UAAU,EACV,KAAK,SAAS,EACd,cAAc,EACd,KAAK,YAAY,EACjB,YAAY,EACZ,KAAK,sBAAsB,EAC3B,KAAK,2BAA2B,EAChC,KAAK,+BAA+B,EACpC,6BAA6B,EAC7B,WAAW,GACZ,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EACL,wBAAwB,EACxB,uBAAuB,EACvB,uCAAuC,EACvC,eAAe,EACf,KAAK,cAAc,EACnB,kCAAkC,EAClC,mCAAmC,GACpC,MAAM,wBAAwB,CAAC;AAEhC;;;;GAIG;AACH,OAAO,EAAE,KAAK,YAAY,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC"}
1
+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,SAAS,EACT,aAAa,EACb,eAAe,EACf,UAAU,EACV,UAAU,EACV,cAAc,GACf,MAAM,kBAAkB,CAAC;AAI1B,cAAc,gBAAgB,CAAC;AAG/B,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,yBAAyB,EACzB,yBAAyB,EACzB,iBAAiB,EACjB,mCAAmC,GACpC,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,KAAK,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AACvF,cAAc,sCAAsC,CAAC;AACrD,cAAc,sCAAsC,CAAC;AACrD,cAAc,6BAA6B,CAAC;AAC5C,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,WAAW,EACX,KAAK,kBAAkB,EACvB,iBAAiB,EACjB,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACrB,cAAc,EACd,4CAA4C,EAC5C,8CAA8C,GAC/C,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,cAAc,qCAAqC,CAAC;AACpD,OAAO,EACL,KAAK,eAAe,EACpB,sBAAsB,EACtB,KAAK,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,iBAAiB,EACjB,UAAU,EACV,KAAK,SAAS,EACd,cAAc,EACd,KAAK,YAAY,EACjB,YAAY,EACZ,KAAK,sBAAsB,EAC3B,KAAK,2BAA2B,EAChC,KAAK,+BAA+B,EACpC,6BAA6B,EAC7B,WAAW,GACZ,MAAM,sBAAsB,CAAC;AAK9B,OAAO,EACL,wBAAwB,EACxB,2BAA2B,EAC3B,uBAAuB,EACvB,uCAAuC,EACvC,eAAe,EACf,KAAK,cAAc,EACnB,kCAAkC,EAClC,mCAAmC,GACpC,MAAM,wBAAwB,CAAC;AAEhC;;;;GAIG;AACH,OAAO,EAAE,KAAK,YAAY,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC"}
package/dist/index.js CHANGED
@@ -9,7 +9,7 @@ export { bigintToBytes32, bigintToBytes32BE, BLS_ORDER, bytesToBigint, bytesToBi
9
9
  export * from "./constants.js";
10
10
  // Selective: deriveMidnightResponseSecretKey takes the MPC root secret, so
11
11
  // it is exported through ./testing with the other secret-taking helpers.
12
- export { deriveEpsilon, deriveEvmAddress, deriveMidnightResponseKey, EPSILON_DERIVATION_PREFIX, MIDNIGHT_RESPOND_BIDIRECTIONAL_PATH, MIDNIGHT_TESTNET_CHAIN_ID, } from "./epsilon-derivation.js";
12
+ export { deriveEpsilon, deriveEvmAddress, deriveMidnightResponseKey, EPSILON_DERIVATION_PREFIX, MIDNIGHT_CAIP2_ID, MIDNIGHT_RESPOND_BIDIRECTIONAL_PATH, } from "./epsilon-derivation.js";
13
13
  export { signetFieldNodeByPath } from "./raw-contract-state.js";
14
14
  export * from "./signature-requests-state-reader.js";
15
15
  export * from "./signature-response-verification.js";
@@ -20,8 +20,9 @@ export * from "./signet-request-response-reader.js";
20
20
  export { contractAddressFromHex, MPCDestination, MPCSignatureAlgorithm, parseRequestIdHex, PATH_BYTES, requestIdBytes, requestIdHex, toSignBidirectionalEventIndex, TxParamType, } from "./signet-requests.js";
21
21
  // Explicit list: ecdsa-attestation.ts also backs the ./testing entry point
22
22
  // (the attestation-minting helpers that take a secret key live THERE), and
23
- // its record decoder (mpcSignatureToEcdsaSignature) is package-internal.
24
- export { formatSecp256k1PublicKey, parseSecp256k1PublicKey, respondBidirectionalEventToCircuitInput, SECP256K1_ORDER, signatureRespondedEventToSignature, verifyRespondBidirectionalSignature, } from "./ecdsa-attestation.js";
23
+ // its record decoder (mpcSignatureToEcdsaSignature) and noble-point parser
24
+ // (parseSecp256k1PublicKeyToNoblePoint) are package-internal.
25
+ export { formatSecp256k1PublicKey, normaliseSecp256k1PublicKey, parseSecp256k1PublicKey, respondBidirectionalEventToCircuitInput, SECP256K1_ORDER, signatureRespondedEventToSignature, verifyRespondBidirectionalSignature, } from "./ecdsa-attestation.js";
25
26
  /**
26
27
  * Compiled pure circuits of Signet.compact (run `yarn compile` first).
27
28
  * Off-chain code MUST use these instead of re-porting the algorithms:
package/dist/index.js.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,sEAAsE;AACtE,wEAAwE;AAExE,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,SAAS,EACT,aAAa,EACb,eAAe,EACf,UAAU,EACV,UAAU,EACV,cAAc,GACf,MAAM,kBAAkB,CAAC;AAC1B,uEAAuE;AACvE,4EAA4E;AAC5E,4EAA4E;AAC5E,cAAc,gBAAgB,CAAC;AAC/B,2EAA2E;AAC3E,yEAAyE;AACzE,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,yBAAyB,EACzB,yBAAyB,EACzB,mCAAmC,EACnC,yBAAyB,GAC1B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAyB,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AACvF,cAAc,sCAAsC,CAAC;AACrD,cAAc,sCAAsC,CAAC;AACrD,cAAc,6BAA6B,CAAC;AAC5C,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,WAAW,EAEX,iBAAiB,EAGjB,cAAc,EACd,4CAA4C,EAC5C,8CAA8C,GAC/C,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,cAAc,qCAAqC,CAAC;AACpD,OAAO,EAEL,sBAAsB,EAEtB,cAAc,EACd,qBAAqB,EACrB,iBAAiB,EACjB,UAAU,EAEV,cAAc,EAEd,YAAY,EAIZ,6BAA6B,EAC7B,WAAW,GACZ,MAAM,sBAAsB,CAAC;AAC9B,2EAA2E;AAC3E,2EAA2E;AAC3E,yEAAyE;AACzE,OAAO,EACL,wBAAwB,EACxB,uBAAuB,EACvB,uCAAuC,EACvC,eAAe,EAEf,kCAAkC,EAClC,mCAAmC,GACpC,MAAM,wBAAwB,CAAC;AAEhC;;;;GAIG;AACH,OAAO,EAAqB,YAAY,EAAE,MAAM,6BAA6B,CAAC"}
1
+ {"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,sEAAsE;AACtE,wEAAwE;AAExE,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,SAAS,EACT,aAAa,EACb,eAAe,EACf,UAAU,EACV,UAAU,EACV,cAAc,GACf,MAAM,kBAAkB,CAAC;AAC1B,uEAAuE;AACvE,4EAA4E;AAC5E,4EAA4E;AAC5E,cAAc,gBAAgB,CAAC;AAC/B,2EAA2E;AAC3E,yEAAyE;AACzE,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,yBAAyB,EACzB,yBAAyB,EACzB,iBAAiB,EACjB,mCAAmC,GACpC,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAyB,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AACvF,cAAc,sCAAsC,CAAC;AACrD,cAAc,sCAAsC,CAAC;AACrD,cAAc,6BAA6B,CAAC;AAC5C,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,WAAW,EAEX,iBAAiB,EAGjB,cAAc,EACd,4CAA4C,EAC5C,8CAA8C,GAC/C,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,cAAc,qCAAqC,CAAC;AACpD,OAAO,EAEL,sBAAsB,EAEtB,cAAc,EACd,qBAAqB,EACrB,iBAAiB,EACjB,UAAU,EAEV,cAAc,EAEd,YAAY,EAIZ,6BAA6B,EAC7B,WAAW,GACZ,MAAM,sBAAsB,CAAC;AAC9B,2EAA2E;AAC3E,2EAA2E;AAC3E,2EAA2E;AAC3E,8DAA8D;AAC9D,OAAO,EACL,wBAAwB,EACxB,2BAA2B,EAC3B,uBAAuB,EACvB,uCAAuC,EACvC,eAAe,EAEf,kCAAkC,EAClC,mCAAmC,GACpC,MAAM,wBAAwB,CAAC;AAEhC;;;;GAIG;AACH,OAAO,EAAqB,YAAY,EAAE,MAAM,6BAA6B,CAAC"}
@@ -64,6 +64,17 @@
64
64
  ]
65
65
  }
66
66
  },
67
+ {
68
+ "name": "ethereumCaip2Id",
69
+ "pure": true,
70
+ "proof": false,
71
+ "arguments": [
72
+ ],
73
+ "result-type": {
74
+ "type-name": "Bytes",
75
+ "length": 32
76
+ }
77
+ },
67
78
  {
68
79
  "name": "evmAddressAbiWord",
69
80
  "pure": true,
@@ -7,26 +7,26 @@
7
7
  "type": "directory",
8
8
  "contract-info.json": {
9
9
  "type": "file",
10
- "size": 8356,
11
- "hash": "15bb6a6ac0c2c0b34888269101edc5f506a5376bf7f6272eb5130c11af77758e"
10
+ "size": 8556,
11
+ "hash": "7c47d2270aa2ea14342613bd428f575d633670cc941d12de3cdbdd69270decd7"
12
12
  }
13
13
  },
14
14
  "contract": {
15
15
  "type": "directory",
16
16
  "index.d.ts": {
17
17
  "type": "file",
18
- "size": 6686,
19
- "hash": "3f18fa6a8e53cdf89d5e207d9a4da9e8d9efafae14245345a151640fb78129b8"
18
+ "size": 6842,
19
+ "hash": "b6d45b68e32185fc3ebfcc50630dfdec409c9a6bb5ebc8b6d5c40f6480a903dd"
20
20
  },
21
21
  "index.js": {
22
22
  "type": "file",
23
- "size": 42276,
24
- "hash": "a97d1d66f4e4fa87ee50eafcd29f425e5aca03a96ada5608eff022b7bf1f1b44"
23
+ "size": 42847,
24
+ "hash": "73f5b3be89aee3b115afb2dc52ca4dfe8c862a39dcfb626b407c2894c2ba43c6"
25
25
  },
26
26
  "index.js.map": {
27
27
  "type": "file",
28
- "size": 4635,
29
- "hash": "2dca80a02be40564cf441a174d751879bc4727940ad8495989039ec6344ff4fe"
28
+ "size": 4704,
29
+ "hash": "24823832e1f686bbcc7fcc0aaef591efe9d2b082957191f8745cdd2bf80adedf"
30
30
  }
31
31
  }
32
32
  }
@@ -16,6 +16,7 @@ export type PureCircuits = {
16
16
  requestsPath_0: bigint[]): { version: bigint,
17
17
  payload: Uint8Array
18
18
  };
19
+ ethereumCaip2Id(): Uint8Array;
19
20
  evmAddressAbiWord(addr_0: Uint8Array): Uint8Array;
20
21
  numericAbiWord(value_0: bigint): Uint8Array;
21
22
  boolAbiWord(value_0: boolean): Uint8Array;
@@ -49,6 +50,7 @@ export type Circuits<PS> = {
49
50
  requestsPath_0: bigint[]): Promise<__compactRuntime.CircuitResults<PS, { version: bigint,
50
51
  payload: Uint8Array
51
52
  }>>;
53
+ ethereumCaip2Id(context: __compactRuntime.CircuitContext<PS>): Promise<__compactRuntime.CircuitResults<PS, Uint8Array>>;
52
54
  evmAddressAbiWord(context: __compactRuntime.CircuitContext<PS>,
53
55
  addr_0: Uint8Array): Promise<__compactRuntime.CircuitResults<PS, Uint8Array>>;
54
56
  numericAbiWord(context: __compactRuntime.CircuitContext<PS>, value_0: bigint): Promise<__compactRuntime.CircuitResults<PS, Uint8Array>>;
@@ -3,6 +3,8 @@ __compactRuntime.checkRuntimeVersion('0.18.0-rc.1');
3
3
 
4
4
  const _descriptor_0 = new __compactRuntime.CompactTypeBytes(32);
5
5
 
6
+ const _descriptor_1 = new __compactRuntime.CompactTypeBytes(100);
7
+
6
8
  class _AffinePoint_0 {
7
9
  alignment() {
8
10
  return _descriptor_0.alignment().concat(_descriptor_0.alignment());
@@ -18,53 +20,51 @@ class _AffinePoint_0 {
18
20
  }
19
21
  }
20
22
 
21
- const _descriptor_1 = new _AffinePoint_0();
23
+ const _descriptor_2 = new _AffinePoint_0();
22
24
 
23
- const _descriptor_2 = new __compactRuntime.CompactTypeUnsignedInteger(255n, 1);
25
+ const _descriptor_3 = new __compactRuntime.CompactTypeUnsignedInteger(255n, 1);
24
26
 
25
27
  class _Signature_0 {
26
28
  alignment() {
27
- return _descriptor_1.alignment().concat(_descriptor_0.alignment().concat(_descriptor_2.alignment()));
29
+ return _descriptor_2.alignment().concat(_descriptor_0.alignment().concat(_descriptor_3.alignment()));
28
30
  }
29
31
  fromValue(value_0) {
30
32
  return {
31
- bigR: _descriptor_1.fromValue(value_0),
33
+ bigR: _descriptor_2.fromValue(value_0),
32
34
  s: _descriptor_0.fromValue(value_0),
33
- recoveryId: _descriptor_2.fromValue(value_0)
35
+ recoveryId: _descriptor_3.fromValue(value_0)
34
36
  }
35
37
  }
36
38
  toValue(value_0) {
37
- return _descriptor_1.toValue(value_0.bigR).concat(_descriptor_0.toValue(value_0.s).concat(_descriptor_2.toValue(value_0.recoveryId)));
39
+ return _descriptor_2.toValue(value_0.bigR).concat(_descriptor_0.toValue(value_0.s).concat(_descriptor_3.toValue(value_0.recoveryId)));
38
40
  }
39
41
  }
40
42
 
41
- const _descriptor_3 = new _Signature_0();
43
+ const _descriptor_4 = new _Signature_0();
42
44
 
43
45
  class _RespondBidirectionalEvent_0 {
44
46
  alignment() {
45
- return _descriptor_3.alignment();
47
+ return _descriptor_4.alignment();
46
48
  }
47
49
  fromValue(value_0) {
48
50
  return {
49
- signature: _descriptor_3.fromValue(value_0)
51
+ signature: _descriptor_4.fromValue(value_0)
50
52
  }
51
53
  }
52
54
  toValue(value_0) {
53
- return _descriptor_3.toValue(value_0.signature);
55
+ return _descriptor_4.toValue(value_0.signature);
54
56
  }
55
57
  }
56
58
 
57
- const _descriptor_4 = new _RespondBidirectionalEvent_0();
58
-
59
- const _descriptor_5 = __compactRuntime.CompactTypeSecp256k1Point;
59
+ const _descriptor_5 = new _RespondBidirectionalEvent_0();
60
60
 
61
- const _descriptor_6 = __compactRuntime.CompactTypeBoolean;
61
+ const _descriptor_6 = __compactRuntime.CompactTypeSecp256k1Point;
62
62
 
63
- const _descriptor_7 = new __compactRuntime.CompactTypeBytes(100);
63
+ const _descriptor_7 = __compactRuntime.CompactTypeBoolean;
64
64
 
65
- const _descriptor_8 = new __compactRuntime.CompactTypeBytes(1);
65
+ const _descriptor_8 = new __compactRuntime.CompactTypeBytes(2);
66
66
 
67
- const _descriptor_9 = new __compactRuntime.CompactTypeBytes(2);
67
+ const _descriptor_9 = new __compactRuntime.CompactTypeBytes(1);
68
68
 
69
69
  const _descriptor_10 = new __compactRuntime.CompactTypeUnsignedInteger(340282366920938463463374607431768211455n, 16);
70
70
 
@@ -88,22 +88,22 @@ class _ContractAddress_0 {
88
88
 
89
89
  const _descriptor_13 = new _ContractAddress_0();
90
90
 
91
- const _descriptor_14 = new __compactRuntime.CompactTypeVector(4, _descriptor_2);
91
+ const _descriptor_14 = new __compactRuntime.CompactTypeVector(4, _descriptor_3);
92
92
 
93
93
  const _descriptor_15 = new __compactRuntime.CompactTypeBytes(128);
94
94
 
95
95
  class _SignBidirectionalEventNotification_0 {
96
96
  alignment() {
97
- return _descriptor_2.alignment().concat(_descriptor_15.alignment());
97
+ return _descriptor_3.alignment().concat(_descriptor_15.alignment());
98
98
  }
99
99
  fromValue(value_0) {
100
100
  return {
101
- version: _descriptor_2.fromValue(value_0),
101
+ version: _descriptor_3.fromValue(value_0),
102
102
  payload: _descriptor_15.fromValue(value_0)
103
103
  }
104
104
  }
105
105
  toValue(value_0) {
106
- return _descriptor_2.toValue(value_0.version).concat(_descriptor_15.toValue(value_0.payload));
106
+ return _descriptor_3.toValue(value_0.version).concat(_descriptor_15.toValue(value_0.payload));
107
107
  }
108
108
  }
109
109
 
@@ -117,17 +117,17 @@ const _descriptor_19 = new __compactRuntime.CompactTypeUnsignedInteger(184467440
117
117
 
118
118
  class _tuple_0 {
119
119
  alignment() {
120
- return _descriptor_0.alignment().concat(_descriptor_19.alignment().concat(_descriptor_7.alignment()));
120
+ return _descriptor_0.alignment().concat(_descriptor_19.alignment().concat(_descriptor_1.alignment()));
121
121
  }
122
122
  fromValue(value_0) {
123
123
  return [
124
124
  _descriptor_0.fromValue(value_0),
125
125
  _descriptor_19.fromValue(value_0),
126
- _descriptor_7.fromValue(value_0)
126
+ _descriptor_1.fromValue(value_0)
127
127
  ]
128
128
  }
129
129
  toValue(value_0) {
130
- return _descriptor_0.toValue(value_0[0]).concat(_descriptor_19.toValue(value_0[1]).concat(_descriptor_7.toValue(value_0[2])));
130
+ return _descriptor_0.toValue(value_0[0]).concat(_descriptor_19.toValue(value_0[1]).concat(_descriptor_1.toValue(value_0[2])));
131
131
  }
132
132
  }
133
133
 
@@ -153,17 +153,17 @@ const _descriptor_21 = new _tuple_1();
153
153
 
154
154
  class _tuple_2 {
155
155
  alignment() {
156
- return _descriptor_0.alignment().concat(_descriptor_19.alignment().concat(_descriptor_8.alignment()));
156
+ return _descriptor_0.alignment().concat(_descriptor_19.alignment().concat(_descriptor_9.alignment()));
157
157
  }
158
158
  fromValue(value_0) {
159
159
  return [
160
160
  _descriptor_0.fromValue(value_0),
161
161
  _descriptor_19.fromValue(value_0),
162
- _descriptor_8.fromValue(value_0)
162
+ _descriptor_9.fromValue(value_0)
163
163
  ]
164
164
  }
165
165
  toValue(value_0) {
166
- return _descriptor_0.toValue(value_0[0]).concat(_descriptor_19.toValue(value_0[1]).concat(_descriptor_8.toValue(value_0[2])));
166
+ return _descriptor_0.toValue(value_0[0]).concat(_descriptor_19.toValue(value_0[1]).concat(_descriptor_9.toValue(value_0[2])));
167
167
  }
168
168
  }
169
169
 
@@ -171,17 +171,17 @@ const _descriptor_22 = new _tuple_2();
171
171
 
172
172
  class _tuple_3 {
173
173
  alignment() {
174
- return _descriptor_0.alignment().concat(_descriptor_19.alignment().concat(_descriptor_9.alignment()));
174
+ return _descriptor_0.alignment().concat(_descriptor_19.alignment().concat(_descriptor_8.alignment()));
175
175
  }
176
176
  fromValue(value_0) {
177
177
  return [
178
178
  _descriptor_0.fromValue(value_0),
179
179
  _descriptor_19.fromValue(value_0),
180
- _descriptor_9.fromValue(value_0)
180
+ _descriptor_8.fromValue(value_0)
181
181
  ]
182
182
  }
183
183
  toValue(value_0) {
184
- return _descriptor_0.toValue(value_0[0]).concat(_descriptor_19.toValue(value_0[1]).concat(_descriptor_9.toValue(value_0[2])));
184
+ return _descriptor_0.toValue(value_0[0]).concat(_descriptor_19.toValue(value_0[1]).concat(_descriptor_8.toValue(value_0[2])));
185
185
  }
186
186
  }
187
187
 
@@ -206,17 +206,17 @@ const _descriptor_24 = new _Secp256k1EcdsaSignature_0();
206
206
 
207
207
  class _Either_0 {
208
208
  alignment() {
209
- return _descriptor_6.alignment().concat(_descriptor_0.alignment().concat(_descriptor_0.alignment()));
209
+ return _descriptor_7.alignment().concat(_descriptor_0.alignment().concat(_descriptor_0.alignment()));
210
210
  }
211
211
  fromValue(value_0) {
212
212
  return {
213
- is_left: _descriptor_6.fromValue(value_0),
213
+ is_left: _descriptor_7.fromValue(value_0),
214
214
  left: _descriptor_0.fromValue(value_0),
215
215
  right: _descriptor_0.fromValue(value_0)
216
216
  }
217
217
  }
218
218
  toValue(value_0) {
219
- return _descriptor_6.toValue(value_0.is_left).concat(_descriptor_0.toValue(value_0.left).concat(_descriptor_0.toValue(value_0.right)));
219
+ return _descriptor_7.toValue(value_0.is_left).concat(_descriptor_0.toValue(value_0.left).concat(_descriptor_0.toValue(value_0.right)));
220
220
  }
221
221
  }
222
222
 
@@ -239,6 +239,9 @@ export class Contract {
239
239
  async constructSignBidirectionalEventNotificationV1(context, ...args_1) {
240
240
  return { result: pureCircuits.constructSignBidirectionalEventNotificationV1(...args_1), context };
241
241
  },
242
+ async ethereumCaip2Id(context, ...args_1) {
243
+ return { result: pureCircuits.ethereumCaip2Id(...args_1), context };
244
+ },
242
245
  async evmAddressAbiWord(context, ...args_1) {
243
246
  return { result: pureCircuits.evmAddressAbiWord(...args_1), context };
244
247
  },
@@ -457,15 +460,18 @@ export class Contract {
457
460
  32,
458
461
  respondBidirectionalEvent_0.signature.bigR.x,
459
462
  'Secp256k1Scalar',
460
- 'Signet.compact line 345 char 12'),
463
+ 'Signet.compact line 347 char 12'),
461
464
  s:
462
465
  __compactRuntime.convertBytesToField(115792089237316195423570985008687907852837564279074904382605163141518161494336n,
463
466
  32,
464
467
  respondBidirectionalEvent_0.signature.s,
465
468
  'Secp256k1Scalar',
466
- 'Signet.compact line 346 char 12') },
469
+ 'Signet.compact line 348 char 12') },
467
470
  mpcResponseKey_0);
468
471
  }
472
+ _ethereumCaip2Id_0() {
473
+ 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]);
474
+ }
469
475
  _evmAddressAbiWord_0(addr_0) {
470
476
  return Uint8Array.from([...Array.from(new Uint8Array(12), BigInt),
471
477
  ...Array.from(addr_0, BigInt)],
@@ -474,7 +480,7 @@ export class Contract {
474
480
  _numericAbiWord_0(value_0) {
475
481
  const le_0 = Array.from(__compactRuntime.convertBigintToBytes(16,
476
482
  value_0,
477
- 'Signet.compact line 424 char 17'),
483
+ 'Signet.compact line 437 char 17'),
478
484
  BigInt);
479
485
  return Uint8Array.from([...Array.from(new Uint8Array(16), BigInt),
480
486
  le_0[15],
@@ -556,7 +562,7 @@ export class Contract {
556
562
  v_0[31]);
557
563
  return ((t1) => {
558
564
  if (t1 > 340282366920938463463374607431768211455n) {
559
- 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');
565
+ 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');
560
566
  }
561
567
  return t1;
562
568
  })(b15_0);
@@ -567,7 +573,7 @@ export class Contract {
567
573
  ((e, i) => e.slice(i, i+31))(word_0,
568
574
  Number(0n)),
569
575
  'Field',
570
- 'Signet.compact line 482 char 12')
576
+ 'Signet.compact line 495 char 12')
571
577
  ===
572
578
  0n,
573
579
  'ABI word is not a canonical Boolean');
@@ -576,7 +582,7 @@ export class Contract {
576
582
  ((e, i) => e.slice(i, i+1))(word_0,
577
583
  Number(31n)),
578
584
  'Field',
579
- 'Signet.compact line 483 char 18');
585
+ 'Signet.compact line 496 char 18');
580
586
  __compactRuntime.assert(last_0 === 0n || last_0 === 1n,
581
587
  'ABI word is not a canonical Boolean');
582
588
  return last_0 === 1n;
@@ -639,21 +645,21 @@ export const pureCircuits = {
639
645
  if (!(typeof(callerAddress_0) === 'object' && callerAddress_0.bytes.buffer instanceof ArrayBuffer && callerAddress_0.bytes.BYTES_PER_ELEMENT === 1 && callerAddress_0.bytes.length === 32)) {
640
646
  __compactRuntime.typeError('constructSignBidirectionalEventNotificationV1',
641
647
  'argument 1',
642
- 'Signet.compact line 238 char 3',
648
+ 'Signet.compact line 240 char 3',
643
649
  'struct ContractAddress<bytes: Bytes<32>>',
644
650
  callerAddress_0)
645
651
  }
646
652
  if (!(typeof(requestsPathDepth_0) === 'bigint' && requestsPathDepth_0 >= 0n && requestsPathDepth_0 <= 255n)) {
647
653
  __compactRuntime.typeError('constructSignBidirectionalEventNotificationV1',
648
654
  'argument 2',
649
- 'Signet.compact line 238 char 3',
655
+ 'Signet.compact line 240 char 3',
650
656
  'Uint<0..256>',
651
657
  requestsPathDepth_0)
652
658
  }
653
659
  if (!(Array.isArray(requestsPath_0) && requestsPath_0.length === 4 && requestsPath_0.every((t) => typeof(t) === 'bigint' && t >= 0n && t <= 255n))) {
654
660
  __compactRuntime.typeError('constructSignBidirectionalEventNotificationV1',
655
661
  'argument 3',
656
- 'Signet.compact line 238 char 3',
662
+ 'Signet.compact line 240 char 3',
657
663
  'Vector<4, Uint<0..256>>',
658
664
  requestsPath_0)
659
665
  }
@@ -661,6 +667,12 @@ export const pureCircuits = {
661
667
  requestsPathDepth_0,
662
668
  requestsPath_0);
663
669
  },
670
+ ethereumCaip2Id: (...args_0) => {
671
+ if (args_0.length !== 0) {
672
+ throw new __compactRuntime.CompactError(`ethereumCaip2Id: expected 0 arguments (as invoked from Typescript), received ${args_0.length}`);
673
+ }
674
+ return _dummyContract._ethereumCaip2Id_0();
675
+ },
664
676
  evmAddressAbiWord: (...args_0) => {
665
677
  if (args_0.length !== 1) {
666
678
  throw new __compactRuntime.CompactError(`evmAddressAbiWord: expected 1 argument (as invoked from Typescript), received ${args_0.length}`);
@@ -669,7 +681,7 @@ export const pureCircuits = {
669
681
  if (!(addr_0.buffer instanceof ArrayBuffer && addr_0.BYTES_PER_ELEMENT === 1 && addr_0.length === 20)) {
670
682
  __compactRuntime.typeError('evmAddressAbiWord',
671
683
  'argument 1',
672
- 'Signet.compact line 415 char 3',
684
+ 'Signet.compact line 428 char 3',
673
685
  'Bytes<20>',
674
686
  addr_0)
675
687
  }
@@ -683,7 +695,7 @@ export const pureCircuits = {
683
695
  if (!(typeof(value_0) === 'bigint' && value_0 >= 0n && value_0 <= 340282366920938463463374607431768211455n)) {
684
696
  __compactRuntime.typeError('numericAbiWord',
685
697
  'argument 1',
686
- 'Signet.compact line 421 char 3',
698
+ 'Signet.compact line 434 char 3',
687
699
  'Uint<0..340282366920938463463374607431768211456>',
688
700
  value_0)
689
701
  }
@@ -697,7 +709,7 @@ export const pureCircuits = {
697
709
  if (!(typeof(value_0) === 'boolean')) {
698
710
  __compactRuntime.typeError('boolAbiWord',
699
711
  'argument 1',
700
- 'Signet.compact line 434 char 3',
712
+ 'Signet.compact line 447 char 3',
701
713
  'Boolean',
702
714
  value_0)
703
715
  }
@@ -711,7 +723,7 @@ export const pureCircuits = {
711
723
  if (!(word_0.buffer instanceof ArrayBuffer && word_0.BYTES_PER_ELEMENT === 1 && word_0.length === 32)) {
712
724
  __compactRuntime.typeError('abiWordToUint128',
713
725
  'argument 1',
714
- 'Signet.compact line 442 char 3',
726
+ 'Signet.compact line 455 char 3',
715
727
  'Bytes<32>',
716
728
  word_0)
717
729
  }
@@ -725,7 +737,7 @@ export const pureCircuits = {
725
737
  if (!(word_0.buffer instanceof ArrayBuffer && word_0.BYTES_PER_ELEMENT === 1 && word_0.length === 32)) {
726
738
  __compactRuntime.typeError('abiWordToBool',
727
739
  'argument 1',
728
- 'Signet.compact line 481 char 3',
740
+ 'Signet.compact line 494 char 3',
729
741
  'Bytes<32>',
730
742
  word_0)
731
743
  }
@@ -740,14 +752,14 @@ export const pureCircuits = {
740
752
  if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
741
753
  __compactRuntime.typeError('calculateSignetAttestationDigest1',
742
754
  'argument 1',
743
- 'circuits.compact line 27 char 1',
755
+ 'circuits.compact line 28 char 1',
744
756
  'Bytes<32>',
745
757
  requestId_0)
746
758
  }
747
759
  if (!(serializedOutput_0.buffer instanceof ArrayBuffer && serializedOutput_0.BYTES_PER_ELEMENT === 1 && serializedOutput_0.length === 1)) {
748
760
  __compactRuntime.typeError('calculateSignetAttestationDigest1',
749
761
  'argument 2',
750
- 'circuits.compact line 27 char 1',
762
+ 'circuits.compact line 28 char 1',
751
763
  'Bytes<1>',
752
764
  serializedOutput_0)
753
765
  }
@@ -763,14 +775,14 @@ export const pureCircuits = {
763
775
  if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
764
776
  __compactRuntime.typeError('calculateSignetAttestationDigest2',
765
777
  'argument 1',
766
- 'circuits.compact line 34 char 1',
778
+ 'circuits.compact line 35 char 1',
767
779
  'Bytes<32>',
768
780
  requestId_0)
769
781
  }
770
782
  if (!(serializedOutput_0.buffer instanceof ArrayBuffer && serializedOutput_0.BYTES_PER_ELEMENT === 1 && serializedOutput_0.length === 2)) {
771
783
  __compactRuntime.typeError('calculateSignetAttestationDigest2',
772
784
  'argument 2',
773
- 'circuits.compact line 34 char 1',
785
+ 'circuits.compact line 35 char 1',
774
786
  'Bytes<2>',
775
787
  serializedOutput_0)
776
788
  }
@@ -786,14 +798,14 @@ export const pureCircuits = {
786
798
  if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
787
799
  __compactRuntime.typeError('calculateSignetAttestationDigest32',
788
800
  'argument 1',
789
- 'circuits.compact line 41 char 1',
801
+ 'circuits.compact line 42 char 1',
790
802
  'Bytes<32>',
791
803
  requestId_0)
792
804
  }
793
805
  if (!(serializedOutput_0.buffer instanceof ArrayBuffer && serializedOutput_0.BYTES_PER_ELEMENT === 1 && serializedOutput_0.length === 32)) {
794
806
  __compactRuntime.typeError('calculateSignetAttestationDigest32',
795
807
  'argument 2',
796
- 'circuits.compact line 41 char 1',
808
+ 'circuits.compact line 42 char 1',
797
809
  'Bytes<32>',
798
810
  serializedOutput_0)
799
811
  }
@@ -809,14 +821,14 @@ export const pureCircuits = {
809
821
  if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
810
822
  __compactRuntime.typeError('calculateSignetAttestationDigest100',
811
823
  'argument 1',
812
- 'circuits.compact line 48 char 1',
824
+ 'circuits.compact line 49 char 1',
813
825
  'Bytes<32>',
814
826
  requestId_0)
815
827
  }
816
828
  if (!(serializedOutput_0.buffer instanceof ArrayBuffer && serializedOutput_0.BYTES_PER_ELEMENT === 1 && serializedOutput_0.length === 100)) {
817
829
  __compactRuntime.typeError('calculateSignetAttestationDigest100',
818
830
  'argument 2',
819
- 'circuits.compact line 48 char 1',
831
+ 'circuits.compact line 49 char 1',
820
832
  'Bytes<100>',
821
833
  serializedOutput_0)
822
834
  }
@@ -834,21 +846,21 @@ export const pureCircuits = {
834
846
  if (!(requestId_0.buffer instanceof ArrayBuffer && requestId_0.BYTES_PER_ELEMENT === 1 && requestId_0.length === 32)) {
835
847
  __compactRuntime.typeError('verifyRespondBidirectionalEvent32',
836
848
  'argument 1',
837
- 'circuits.compact line 55 char 1',
849
+ 'circuits.compact line 56 char 1',
838
850
  'Bytes<32>',
839
851
  requestId_0)
840
852
  }
841
853
  if (!(serializedOutput_0.buffer instanceof ArrayBuffer && serializedOutput_0.BYTES_PER_ELEMENT === 1 && serializedOutput_0.length === 32)) {
842
854
  __compactRuntime.typeError('verifyRespondBidirectionalEvent32',
843
855
  'argument 2',
844
- 'circuits.compact line 55 char 1',
856
+ 'circuits.compact line 56 char 1',
845
857
  'Bytes<32>',
846
858
  serializedOutput_0)
847
859
  }
848
860
  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)) {
849
861
  __compactRuntime.typeError('verifyRespondBidirectionalEvent32',
850
862
  'argument 3',
851
- 'circuits.compact line 55 char 1',
863
+ 'circuits.compact line 56 char 1',
852
864
  'struct RespondBidirectionalEvent<signature: struct Signature<bigR: struct AffinePoint<x: Bytes<32>, y: Bytes<32>>, s: Bytes<32>, recoveryId: Uint<0..256>>>',
853
865
  respondBidirectionalEvent_0)
854
866
  }
@@ -4,5 +4,5 @@
4
4
  "sourceRoot": "../../../",
5
5
  "sources": ["src/circuits.compact", "src/./Signet.compact", "compiler/zkir-v3-library.compact"],
6
6
  "names": [],
7
- "mappings": "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"
7
+ "mappings": "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"
8
8
  }
@@ -41,7 +41,7 @@ export interface EvmAccessListEntry {
41
41
  * leading slots are real.
42
42
  */
43
43
  export interface EvmType2TxParams {
44
- /** EVM chain id (also expressed in the record's `caip2Id`). */
44
+ /** EIP-155 chain id of the network the signed transaction is valid on. */
45
45
  chainId: bigint;
46
46
  /** Account nonce of the MPC-derived sender address. */
47
47
  nonce: bigint;
@@ -1 +1 @@
1
- {"version":3,"file":"signet-evtype2tx-requests.d.ts","sourceRoot":"","sources":["../src/signet-evtype2tx-requests.ts"],"names":[],"mappings":"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"}
1
+ {"version":3,"file":"signet-evtype2tx-requests.d.ts","sourceRoot":"","sources":["../src/signet-evtype2tx-requests.ts"],"names":[],"mappings":"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"}