@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/README.md +5 -3
- package/dist/constants.d.ts +5 -4
- package/dist/constants.d.ts.map +1 -1
- package/dist/constants.js +12 -7
- package/dist/constants.js.map +1 -1
- package/dist/ecdsa-attestation.d.ts +37 -8
- package/dist/ecdsa-attestation.d.ts.map +1 -1
- package/dist/ecdsa-attestation.js +88 -15
- package/dist/ecdsa-attestation.js.map +1 -1
- package/dist/epsilon-derivation.d.ts +21 -17
- package/dist/epsilon-derivation.d.ts.map +1 -1
- package/dist/epsilon-derivation.js +32 -29
- package/dist/epsilon-derivation.js.map +1 -1
- package/dist/index.d.ts +2 -2
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +4 -3
- package/dist/index.js.map +1 -1
- package/dist/managed/compiler/contract-info.json +11 -0
- package/dist/managed/compiler/contract-manifest.json +8 -8
- package/dist/managed/contract/index.d.ts +2 -0
- package/dist/managed/contract/index.js +70 -58
- package/dist/managed/contract/index.js.map +1 -1
- package/dist/signet-evtype2tx-requests.d.ts +1 -1
- package/dist/signet-evtype2tx-requests.d.ts.map +1 -1
- package/package.json +5 -4
- package/src/Signet.compact +19 -6
- package/src/circuits.compact +1 -0
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,
|
|
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:
|
package/dist/index.d.ts.map
CHANGED
|
@@ -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,
|
|
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,
|
|
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)
|
|
24
|
-
|
|
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,
|
|
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"}
|
|
@@ -7,26 +7,26 @@
|
|
|
7
7
|
"type": "directory",
|
|
8
8
|
"contract-info.json": {
|
|
9
9
|
"type": "file",
|
|
10
|
-
"size":
|
|
11
|
-
"hash": "
|
|
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":
|
|
19
|
-
"hash": "
|
|
18
|
+
"size": 6842,
|
|
19
|
+
"hash": "b6d45b68e32185fc3ebfcc50630dfdec409c9a6bb5ebc8b6d5c40f6480a903dd"
|
|
20
20
|
},
|
|
21
21
|
"index.js": {
|
|
22
22
|
"type": "file",
|
|
23
|
-
"size":
|
|
24
|
-
"hash": "
|
|
23
|
+
"size": 42847,
|
|
24
|
+
"hash": "73f5b3be89aee3b115afb2dc52ca4dfe8c862a39dcfb626b407c2894c2ba43c6"
|
|
25
25
|
},
|
|
26
26
|
"index.js.map": {
|
|
27
27
|
"type": "file",
|
|
28
|
-
"size":
|
|
29
|
-
"hash": "
|
|
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
|
|
23
|
+
const _descriptor_2 = new _AffinePoint_0();
|
|
22
24
|
|
|
23
|
-
const
|
|
25
|
+
const _descriptor_3 = new __compactRuntime.CompactTypeUnsignedInteger(255n, 1);
|
|
24
26
|
|
|
25
27
|
class _Signature_0 {
|
|
26
28
|
alignment() {
|
|
27
|
-
return
|
|
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:
|
|
33
|
+
bigR: _descriptor_2.fromValue(value_0),
|
|
32
34
|
s: _descriptor_0.fromValue(value_0),
|
|
33
|
-
recoveryId:
|
|
35
|
+
recoveryId: _descriptor_3.fromValue(value_0)
|
|
34
36
|
}
|
|
35
37
|
}
|
|
36
38
|
toValue(value_0) {
|
|
37
|
-
return
|
|
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
|
|
43
|
+
const _descriptor_4 = new _Signature_0();
|
|
42
44
|
|
|
43
45
|
class _RespondBidirectionalEvent_0 {
|
|
44
46
|
alignment() {
|
|
45
|
-
return
|
|
47
|
+
return _descriptor_4.alignment();
|
|
46
48
|
}
|
|
47
49
|
fromValue(value_0) {
|
|
48
50
|
return {
|
|
49
|
-
signature:
|
|
51
|
+
signature: _descriptor_4.fromValue(value_0)
|
|
50
52
|
}
|
|
51
53
|
}
|
|
52
54
|
toValue(value_0) {
|
|
53
|
-
return
|
|
55
|
+
return _descriptor_4.toValue(value_0.signature);
|
|
54
56
|
}
|
|
55
57
|
}
|
|
56
58
|
|
|
57
|
-
const
|
|
58
|
-
|
|
59
|
-
const _descriptor_5 = __compactRuntime.CompactTypeSecp256k1Point;
|
|
59
|
+
const _descriptor_5 = new _RespondBidirectionalEvent_0();
|
|
60
60
|
|
|
61
|
-
const _descriptor_6 = __compactRuntime.
|
|
61
|
+
const _descriptor_6 = __compactRuntime.CompactTypeSecp256k1Point;
|
|
62
62
|
|
|
63
|
-
const _descriptor_7 =
|
|
63
|
+
const _descriptor_7 = __compactRuntime.CompactTypeBoolean;
|
|
64
64
|
|
|
65
|
-
const _descriptor_8 = new __compactRuntime.CompactTypeBytes(
|
|
65
|
+
const _descriptor_8 = new __compactRuntime.CompactTypeBytes(2);
|
|
66
66
|
|
|
67
|
-
const _descriptor_9 = new __compactRuntime.CompactTypeBytes(
|
|
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,
|
|
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
|
|
97
|
+
return _descriptor_3.alignment().concat(_descriptor_15.alignment());
|
|
98
98
|
}
|
|
99
99
|
fromValue(value_0) {
|
|
100
100
|
return {
|
|
101
|
-
version:
|
|
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
|
|
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(
|
|
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
|
-
|
|
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(
|
|
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(
|
|
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
|
-
|
|
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(
|
|
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(
|
|
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
|
-
|
|
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(
|
|
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
|
|
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:
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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
|
|
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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAA;;;;;;;;;;
|
|
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
|
-
/**
|
|
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":"AAUA,OAAO,EAAE,KAAK,WAAW,EAAqB,MAAM,iCAAiC,CAAC;AACtF,OAAO,EAAc,WAAW,EAAE,MAAM,QAAQ,CAAC;AAGjD,OAAO,EAML,KAAK,KAAK,EAKX,MAAM,0BAA0B,CAAC;AAElC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAC3E,OAAO,EACL,KAAK,sBAAsB,EAE5B,MAAM,sBAAsB,CAAC;AAE9B;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,yDAAyD;IACzD,QAAQ,EAAE,UAAU,CAAC;IACrB,6EAA6E;IAC7E,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,KAAK,EAAE,UAAU,EAAE,CAAC;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,iEAAiE;IACjE,OAAO,EAAE,UAAU,CAAC;IACpB,qDAAqD;IACrD,eAAe,EAAE,MAAM,CAAC;IACxB,sEAAsE;IACtE,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B
|
|
1
|
+
{"version":3,"file":"signet-evtype2tx-requests.d.ts","sourceRoot":"","sources":["../src/signet-evtype2tx-requests.ts"],"names":[],"mappings":"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"}
|