@li0ard/dstu 0.1.3 → 0.1.5

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.
@@ -0,0 +1,431 @@
1
+ import type { EdwardsOpts } from "@noble/curves/abstract/edwards.js";
2
+ import { type TArg, type TRet } from "@noble/curves/utils.js";
3
+ export declare const dstu9041Curve: (parameters: EdwardsOpts) => Readonly<{
4
+ Point: {
5
+ new (X: bigint, Y: bigint, Z: bigint): {
6
+ readonly X: bigint;
7
+ readonly Y: bigint;
8
+ readonly Z: bigint;
9
+ get x(): bigint;
10
+ get y(): bigint;
11
+ add(other: /*elided*/ any): /*elided*/ any;
12
+ multiply(scalar: bigint): /*elided*/ any;
13
+ is0(): boolean;
14
+ assertValidity(): /*elided*/ any;
15
+ toBytes(): TRet<Uint8Array>;
16
+ };
17
+ BASE: {
18
+ readonly X: bigint;
19
+ readonly Y: bigint;
20
+ readonly Z: bigint;
21
+ get x(): bigint;
22
+ get y(): bigint;
23
+ add(other: /*elided*/ any): /*elided*/ any;
24
+ multiply(scalar: bigint): /*elided*/ any;
25
+ is0(): boolean;
26
+ assertValidity(): /*elided*/ any;
27
+ toBytes(): TRet<Uint8Array>;
28
+ };
29
+ ZERO: {
30
+ readonly X: bigint;
31
+ readonly Y: bigint;
32
+ readonly Z: bigint;
33
+ get x(): bigint;
34
+ get y(): bigint;
35
+ add(other: /*elided*/ any): /*elided*/ any;
36
+ multiply(scalar: bigint): /*elided*/ any;
37
+ is0(): boolean;
38
+ assertValidity(): /*elided*/ any;
39
+ toBytes(): TRet<Uint8Array>;
40
+ };
41
+ Fp: Readonly<import("@noble/curves/abstract/modular.js").IField<bigint> & Required<Pick<import("@noble/curves/abstract/modular.js").IField<bigint>, "isOdd">>> & {
42
+ readonly ORDER: bigint;
43
+ readonly BYTES: number;
44
+ readonly BITS: number;
45
+ readonly isLE: boolean;
46
+ readonly ZERO: bigint;
47
+ readonly ONE: bigint;
48
+ readonly create: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
49
+ readonly isValid: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
50
+ readonly is0: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
51
+ readonly isValidNot0: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
52
+ readonly neg: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
53
+ readonly inv: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
54
+ readonly sqrt: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
55
+ readonly sqr: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
56
+ readonly eql: ((lhs: bigint, rhs: bigint) => boolean) & ((lhs: bigint, rhs: bigint) => boolean) & {};
57
+ readonly add: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
58
+ readonly sub: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
59
+ readonly mul: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
60
+ readonly pow: ((lhs: bigint, power: bigint) => bigint) & ((lhs: bigint, power: bigint) => bigint) & {};
61
+ readonly div: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
62
+ readonly addN: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
63
+ readonly subN: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
64
+ readonly mulN: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
65
+ readonly sqrN: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
66
+ readonly isOdd: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
67
+ readonly invertBatch: ((lst: bigint[]) => bigint[]) & ((lst: TArg<bigint[]>) => bigint[] & bigint[]) & {};
68
+ readonly toBytes: ((num: bigint) => Uint8Array) & ((num: bigint) => Uint8Array<ArrayBufferLike> & Uint8Array<ArrayBuffer>) & {};
69
+ readonly fromBytes: ((bytes: Uint8Array, skipValidation?: boolean) => bigint) & ((bytes: TArg<Uint8Array<ArrayBufferLike>>, skipValidation?: TArg<boolean | undefined>) => bigint) & {};
70
+ readonly cmov: ((a: bigint, b: bigint, c: boolean) => bigint) & ((a: bigint, b: bigint, c: TArg<boolean>) => bigint) & {};
71
+ };
72
+ Fn: Readonly<import("@noble/curves/abstract/modular.js").IField<bigint> & Required<Pick<import("@noble/curves/abstract/modular.js").IField<bigint>, "isOdd">>> & {
73
+ readonly ORDER: bigint;
74
+ readonly BYTES: number;
75
+ readonly BITS: number;
76
+ readonly isLE: boolean;
77
+ readonly ZERO: bigint;
78
+ readonly ONE: bigint;
79
+ readonly create: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
80
+ readonly isValid: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
81
+ readonly is0: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
82
+ readonly isValidNot0: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
83
+ readonly neg: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
84
+ readonly inv: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
85
+ readonly sqrt: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
86
+ readonly sqr: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
87
+ readonly eql: ((lhs: bigint, rhs: bigint) => boolean) & ((lhs: bigint, rhs: bigint) => boolean) & {};
88
+ readonly add: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
89
+ readonly sub: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
90
+ readonly mul: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
91
+ readonly pow: ((lhs: bigint, power: bigint) => bigint) & ((lhs: bigint, power: bigint) => bigint) & {};
92
+ readonly div: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
93
+ readonly addN: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
94
+ readonly subN: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
95
+ readonly mulN: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
96
+ readonly sqrN: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
97
+ readonly isOdd: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
98
+ readonly invertBatch: ((lst: bigint[]) => bigint[]) & ((lst: TArg<bigint[]>) => bigint[] & bigint[]) & {};
99
+ readonly toBytes: ((num: bigint) => Uint8Array) & ((num: bigint) => Uint8Array<ArrayBufferLike> & Uint8Array<ArrayBuffer>) & {};
100
+ readonly fromBytes: ((bytes: Uint8Array, skipValidation?: boolean) => bigint) & ((bytes: TArg<Uint8Array<ArrayBufferLike>>, skipValidation?: TArg<boolean | undefined>) => bigint) & {};
101
+ readonly cmov: ((a: bigint, b: bigint, c: boolean) => bigint) & ((a: bigint, b: bigint, c: TArg<boolean>) => bigint) & {};
102
+ };
103
+ fromBytes(bytes: TArg<Uint8Array>): {
104
+ readonly X: bigint;
105
+ readonly Y: bigint;
106
+ readonly Z: bigint;
107
+ get x(): bigint;
108
+ get y(): bigint;
109
+ add(other: /*elided*/ any): /*elided*/ any;
110
+ multiply(scalar: bigint): /*elided*/ any;
111
+ is0(): boolean;
112
+ assertValidity(): /*elided*/ any;
113
+ toBytes(): TRet<Uint8Array>;
114
+ };
115
+ fromAffine(x: bigint, y: bigint): {
116
+ readonly X: bigint;
117
+ readonly Y: bigint;
118
+ readonly Z: bigint;
119
+ get x(): bigint;
120
+ get y(): bigint;
121
+ add(other: /*elided*/ any): /*elided*/ any;
122
+ multiply(scalar: bigint): /*elided*/ any;
123
+ is0(): boolean;
124
+ assertValidity(): /*elided*/ any;
125
+ toBytes(): TRet<Uint8Array>;
126
+ };
127
+ fromX(x: bigint): {
128
+ readonly X: bigint;
129
+ readonly Y: bigint;
130
+ readonly Z: bigint;
131
+ get x(): bigint;
132
+ get y(): bigint;
133
+ add(other: /*elided*/ any): /*elided*/ any;
134
+ multiply(scalar: bigint): /*elided*/ any;
135
+ is0(): boolean;
136
+ assertValidity(): /*elided*/ any;
137
+ toBytes(): TRet<Uint8Array>;
138
+ };
139
+ };
140
+ getPublicKey: (secretKey: TArg<Uint8Array>) => TRet<Uint8Array>;
141
+ keygen: () => {
142
+ secretKey: TRet<Uint8Array>;
143
+ publicKey: TRet<Uint8Array>;
144
+ };
145
+ }>;
146
+ export declare const curve256: Readonly<{
147
+ Point: {
148
+ new (X: bigint, Y: bigint, Z: bigint): {
149
+ readonly X: bigint;
150
+ readonly Y: bigint;
151
+ readonly Z: bigint;
152
+ get x(): bigint;
153
+ get y(): bigint;
154
+ add(other: /*elided*/ any): /*elided*/ any;
155
+ multiply(scalar: bigint): /*elided*/ any;
156
+ is0(): boolean;
157
+ assertValidity(): /*elided*/ any;
158
+ toBytes(): TRet<Uint8Array>;
159
+ };
160
+ BASE: {
161
+ readonly X: bigint;
162
+ readonly Y: bigint;
163
+ readonly Z: bigint;
164
+ get x(): bigint;
165
+ get y(): bigint;
166
+ add(other: /*elided*/ any): /*elided*/ any;
167
+ multiply(scalar: bigint): /*elided*/ any;
168
+ is0(): boolean;
169
+ assertValidity(): /*elided*/ any;
170
+ toBytes(): TRet<Uint8Array>;
171
+ };
172
+ ZERO: {
173
+ readonly X: bigint;
174
+ readonly Y: bigint;
175
+ readonly Z: bigint;
176
+ get x(): bigint;
177
+ get y(): bigint;
178
+ add(other: /*elided*/ any): /*elided*/ any;
179
+ multiply(scalar: bigint): /*elided*/ any;
180
+ is0(): boolean;
181
+ assertValidity(): /*elided*/ any;
182
+ toBytes(): TRet<Uint8Array>;
183
+ };
184
+ Fp: Readonly<import("@noble/curves/abstract/modular.js").IField<bigint> & Required<Pick<import("@noble/curves/abstract/modular.js").IField<bigint>, "isOdd">>> & {
185
+ readonly ORDER: bigint;
186
+ readonly BYTES: number;
187
+ readonly BITS: number;
188
+ readonly isLE: boolean;
189
+ readonly ZERO: bigint;
190
+ readonly ONE: bigint;
191
+ readonly create: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
192
+ readonly isValid: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
193
+ readonly is0: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
194
+ readonly isValidNot0: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
195
+ readonly neg: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
196
+ readonly inv: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
197
+ readonly sqrt: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
198
+ readonly sqr: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
199
+ readonly eql: ((lhs: bigint, rhs: bigint) => boolean) & ((lhs: bigint, rhs: bigint) => boolean) & {};
200
+ readonly add: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
201
+ readonly sub: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
202
+ readonly mul: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
203
+ readonly pow: ((lhs: bigint, power: bigint) => bigint) & ((lhs: bigint, power: bigint) => bigint) & {};
204
+ readonly div: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
205
+ readonly addN: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
206
+ readonly subN: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
207
+ readonly mulN: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
208
+ readonly sqrN: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
209
+ readonly isOdd: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
210
+ readonly invertBatch: ((lst: bigint[]) => bigint[]) & ((lst: TArg<bigint[]>) => bigint[] & bigint[]) & {};
211
+ readonly toBytes: ((num: bigint) => Uint8Array) & ((num: bigint) => Uint8Array<ArrayBufferLike> & Uint8Array<ArrayBuffer>) & {};
212
+ readonly fromBytes: ((bytes: Uint8Array, skipValidation?: boolean) => bigint) & ((bytes: TArg<Uint8Array<ArrayBufferLike>>, skipValidation?: TArg<boolean | undefined>) => bigint) & {};
213
+ readonly cmov: ((a: bigint, b: bigint, c: boolean) => bigint) & ((a: bigint, b: bigint, c: TArg<boolean>) => bigint) & {};
214
+ };
215
+ Fn: Readonly<import("@noble/curves/abstract/modular.js").IField<bigint> & Required<Pick<import("@noble/curves/abstract/modular.js").IField<bigint>, "isOdd">>> & {
216
+ readonly ORDER: bigint;
217
+ readonly BYTES: number;
218
+ readonly BITS: number;
219
+ readonly isLE: boolean;
220
+ readonly ZERO: bigint;
221
+ readonly ONE: bigint;
222
+ readonly create: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
223
+ readonly isValid: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
224
+ readonly is0: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
225
+ readonly isValidNot0: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
226
+ readonly neg: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
227
+ readonly inv: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
228
+ readonly sqrt: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
229
+ readonly sqr: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
230
+ readonly eql: ((lhs: bigint, rhs: bigint) => boolean) & ((lhs: bigint, rhs: bigint) => boolean) & {};
231
+ readonly add: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
232
+ readonly sub: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
233
+ readonly mul: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
234
+ readonly pow: ((lhs: bigint, power: bigint) => bigint) & ((lhs: bigint, power: bigint) => bigint) & {};
235
+ readonly div: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
236
+ readonly addN: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
237
+ readonly subN: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
238
+ readonly mulN: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
239
+ readonly sqrN: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
240
+ readonly isOdd: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
241
+ readonly invertBatch: ((lst: bigint[]) => bigint[]) & ((lst: TArg<bigint[]>) => bigint[] & bigint[]) & {};
242
+ readonly toBytes: ((num: bigint) => Uint8Array) & ((num: bigint) => Uint8Array<ArrayBufferLike> & Uint8Array<ArrayBuffer>) & {};
243
+ readonly fromBytes: ((bytes: Uint8Array, skipValidation?: boolean) => bigint) & ((bytes: TArg<Uint8Array<ArrayBufferLike>>, skipValidation?: TArg<boolean | undefined>) => bigint) & {};
244
+ readonly cmov: ((a: bigint, b: bigint, c: boolean) => bigint) & ((a: bigint, b: bigint, c: TArg<boolean>) => bigint) & {};
245
+ };
246
+ fromBytes(bytes: TArg<Uint8Array>): {
247
+ readonly X: bigint;
248
+ readonly Y: bigint;
249
+ readonly Z: bigint;
250
+ get x(): bigint;
251
+ get y(): bigint;
252
+ add(other: /*elided*/ any): /*elided*/ any;
253
+ multiply(scalar: bigint): /*elided*/ any;
254
+ is0(): boolean;
255
+ assertValidity(): /*elided*/ any;
256
+ toBytes(): TRet<Uint8Array>;
257
+ };
258
+ fromAffine(x: bigint, y: bigint): {
259
+ readonly X: bigint;
260
+ readonly Y: bigint;
261
+ readonly Z: bigint;
262
+ get x(): bigint;
263
+ get y(): bigint;
264
+ add(other: /*elided*/ any): /*elided*/ any;
265
+ multiply(scalar: bigint): /*elided*/ any;
266
+ is0(): boolean;
267
+ assertValidity(): /*elided*/ any;
268
+ toBytes(): TRet<Uint8Array>;
269
+ };
270
+ fromX(x: bigint): {
271
+ readonly X: bigint;
272
+ readonly Y: bigint;
273
+ readonly Z: bigint;
274
+ get x(): bigint;
275
+ get y(): bigint;
276
+ add(other: /*elided*/ any): /*elided*/ any;
277
+ multiply(scalar: bigint): /*elided*/ any;
278
+ is0(): boolean;
279
+ assertValidity(): /*elided*/ any;
280
+ toBytes(): TRet<Uint8Array>;
281
+ };
282
+ };
283
+ getPublicKey: (secretKey: TArg<Uint8Array>) => TRet<Uint8Array>;
284
+ keygen: () => {
285
+ secretKey: TRet<Uint8Array>;
286
+ publicKey: TRet<Uint8Array>;
287
+ };
288
+ }>;
289
+ export declare const curve512: Readonly<{
290
+ Point: {
291
+ new (X: bigint, Y: bigint, Z: bigint): {
292
+ readonly X: bigint;
293
+ readonly Y: bigint;
294
+ readonly Z: bigint;
295
+ get x(): bigint;
296
+ get y(): bigint;
297
+ add(other: /*elided*/ any): /*elided*/ any;
298
+ multiply(scalar: bigint): /*elided*/ any;
299
+ is0(): boolean;
300
+ assertValidity(): /*elided*/ any;
301
+ toBytes(): TRet<Uint8Array>;
302
+ };
303
+ BASE: {
304
+ readonly X: bigint;
305
+ readonly Y: bigint;
306
+ readonly Z: bigint;
307
+ get x(): bigint;
308
+ get y(): bigint;
309
+ add(other: /*elided*/ any): /*elided*/ any;
310
+ multiply(scalar: bigint): /*elided*/ any;
311
+ is0(): boolean;
312
+ assertValidity(): /*elided*/ any;
313
+ toBytes(): TRet<Uint8Array>;
314
+ };
315
+ ZERO: {
316
+ readonly X: bigint;
317
+ readonly Y: bigint;
318
+ readonly Z: bigint;
319
+ get x(): bigint;
320
+ get y(): bigint;
321
+ add(other: /*elided*/ any): /*elided*/ any;
322
+ multiply(scalar: bigint): /*elided*/ any;
323
+ is0(): boolean;
324
+ assertValidity(): /*elided*/ any;
325
+ toBytes(): TRet<Uint8Array>;
326
+ };
327
+ Fp: Readonly<import("@noble/curves/abstract/modular.js").IField<bigint> & Required<Pick<import("@noble/curves/abstract/modular.js").IField<bigint>, "isOdd">>> & {
328
+ readonly ORDER: bigint;
329
+ readonly BYTES: number;
330
+ readonly BITS: number;
331
+ readonly isLE: boolean;
332
+ readonly ZERO: bigint;
333
+ readonly ONE: bigint;
334
+ readonly create: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
335
+ readonly isValid: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
336
+ readonly is0: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
337
+ readonly isValidNot0: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
338
+ readonly neg: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
339
+ readonly inv: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
340
+ readonly sqrt: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
341
+ readonly sqr: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
342
+ readonly eql: ((lhs: bigint, rhs: bigint) => boolean) & ((lhs: bigint, rhs: bigint) => boolean) & {};
343
+ readonly add: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
344
+ readonly sub: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
345
+ readonly mul: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
346
+ readonly pow: ((lhs: bigint, power: bigint) => bigint) & ((lhs: bigint, power: bigint) => bigint) & {};
347
+ readonly div: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
348
+ readonly addN: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
349
+ readonly subN: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
350
+ readonly mulN: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
351
+ readonly sqrN: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
352
+ readonly isOdd: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
353
+ readonly invertBatch: ((lst: bigint[]) => bigint[]) & ((lst: TArg<bigint[]>) => bigint[] & bigint[]) & {};
354
+ readonly toBytes: ((num: bigint) => Uint8Array) & ((num: bigint) => Uint8Array<ArrayBufferLike> & Uint8Array<ArrayBuffer>) & {};
355
+ readonly fromBytes: ((bytes: Uint8Array, skipValidation?: boolean) => bigint) & ((bytes: TArg<Uint8Array<ArrayBufferLike>>, skipValidation?: TArg<boolean | undefined>) => bigint) & {};
356
+ readonly cmov: ((a: bigint, b: bigint, c: boolean) => bigint) & ((a: bigint, b: bigint, c: TArg<boolean>) => bigint) & {};
357
+ };
358
+ Fn: Readonly<import("@noble/curves/abstract/modular.js").IField<bigint> & Required<Pick<import("@noble/curves/abstract/modular.js").IField<bigint>, "isOdd">>> & {
359
+ readonly ORDER: bigint;
360
+ readonly BYTES: number;
361
+ readonly BITS: number;
362
+ readonly isLE: boolean;
363
+ readonly ZERO: bigint;
364
+ readonly ONE: bigint;
365
+ readonly create: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
366
+ readonly isValid: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
367
+ readonly is0: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
368
+ readonly isValidNot0: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
369
+ readonly neg: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
370
+ readonly inv: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
371
+ readonly sqrt: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
372
+ readonly sqr: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
373
+ readonly eql: ((lhs: bigint, rhs: bigint) => boolean) & ((lhs: bigint, rhs: bigint) => boolean) & {};
374
+ readonly add: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
375
+ readonly sub: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
376
+ readonly mul: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
377
+ readonly pow: ((lhs: bigint, power: bigint) => bigint) & ((lhs: bigint, power: bigint) => bigint) & {};
378
+ readonly div: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
379
+ readonly addN: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
380
+ readonly subN: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
381
+ readonly mulN: ((lhs: bigint, rhs: bigint) => bigint) & ((lhs: bigint, rhs: bigint) => bigint) & {};
382
+ readonly sqrN: ((num: bigint) => bigint) & ((num: bigint) => bigint) & {};
383
+ readonly isOdd: ((num: bigint) => boolean) & ((num: bigint) => boolean) & {};
384
+ readonly invertBatch: ((lst: bigint[]) => bigint[]) & ((lst: TArg<bigint[]>) => bigint[] & bigint[]) & {};
385
+ readonly toBytes: ((num: bigint) => Uint8Array) & ((num: bigint) => Uint8Array<ArrayBufferLike> & Uint8Array<ArrayBuffer>) & {};
386
+ readonly fromBytes: ((bytes: Uint8Array, skipValidation?: boolean) => bigint) & ((bytes: TArg<Uint8Array<ArrayBufferLike>>, skipValidation?: TArg<boolean | undefined>) => bigint) & {};
387
+ readonly cmov: ((a: bigint, b: bigint, c: boolean) => bigint) & ((a: bigint, b: bigint, c: TArg<boolean>) => bigint) & {};
388
+ };
389
+ fromBytes(bytes: TArg<Uint8Array>): {
390
+ readonly X: bigint;
391
+ readonly Y: bigint;
392
+ readonly Z: bigint;
393
+ get x(): bigint;
394
+ get y(): bigint;
395
+ add(other: /*elided*/ any): /*elided*/ any;
396
+ multiply(scalar: bigint): /*elided*/ any;
397
+ is0(): boolean;
398
+ assertValidity(): /*elided*/ any;
399
+ toBytes(): TRet<Uint8Array>;
400
+ };
401
+ fromAffine(x: bigint, y: bigint): {
402
+ readonly X: bigint;
403
+ readonly Y: bigint;
404
+ readonly Z: bigint;
405
+ get x(): bigint;
406
+ get y(): bigint;
407
+ add(other: /*elided*/ any): /*elided*/ any;
408
+ multiply(scalar: bigint): /*elided*/ any;
409
+ is0(): boolean;
410
+ assertValidity(): /*elided*/ any;
411
+ toBytes(): TRet<Uint8Array>;
412
+ };
413
+ fromX(x: bigint): {
414
+ readonly X: bigint;
415
+ readonly Y: bigint;
416
+ readonly Z: bigint;
417
+ get x(): bigint;
418
+ get y(): bigint;
419
+ add(other: /*elided*/ any): /*elided*/ any;
420
+ multiply(scalar: bigint): /*elided*/ any;
421
+ is0(): boolean;
422
+ assertValidity(): /*elided*/ any;
423
+ toBytes(): TRet<Uint8Array>;
424
+ };
425
+ };
426
+ getPublicKey: (secretKey: TArg<Uint8Array>) => TRet<Uint8Array>;
427
+ keygen: () => {
428
+ secretKey: TRet<Uint8Array>;
429
+ publicKey: TRet<Uint8Array>;
430
+ };
431
+ }>;
@@ -0,0 +1,129 @@
1
+ import { Field, mod } from "@noble/curves/abstract/modular.js";
2
+ import { bitGet, bitLen, bytesToNumberBE, randomBytes } from "@noble/curves/utils.js";
3
+ import { concatBytes } from "@noble/hashes/utils.js";
4
+ export const dstu9041Curve = (parameters) => {
5
+ if (mod(parameters.p, 8n) != 5n)
6
+ throw new Error("Unsupported `p` prime");
7
+ const Fp = Field(parameters.p), Fn = Field(parameters.n);
8
+ const isValidXY = (x, y) => {
9
+ const x2 = Fp.sqr(x);
10
+ const y2 = Fp.sqr(y);
11
+ const left = Fp.add(x2, Fp.mul(parameters.a, y2));
12
+ const right = Fp.add(Fp.ONE, Fp.mul(parameters.d, Fp.mul(x2, y2)));
13
+ return Fp.eql(left, right);
14
+ };
15
+ if (!isValidXY(parameters.Gx, parameters.Gy))
16
+ throw new Error("Invalid base point");
17
+ const p_minus_1 = Fp.sub(Fp.ZERO, Fp.ONE);
18
+ const p_minus_1_over_2 = Fp.div(Fp.sub(Fp.ORDER, Fp.ONE), 2n);
19
+ const a_over_d = Fp.div(parameters.a, parameters.d);
20
+ class Point {
21
+ X;
22
+ Y;
23
+ Z;
24
+ static BASE = Point.fromAffine(parameters.Gx, parameters.Gy);
25
+ static ZERO = Point.fromAffine(1n, 0n);
26
+ static Fp = Fp;
27
+ static Fn = Fn;
28
+ constructor(X, Y, Z) {
29
+ this.X = X;
30
+ this.Y = Y;
31
+ this.Z = Z;
32
+ Object.freeze(this);
33
+ }
34
+ get x() {
35
+ return Fp.div(this.X, this.Z);
36
+ }
37
+ get y() {
38
+ return Fp.div(this.Y, this.Z);
39
+ }
40
+ add(other) {
41
+ const A = Fp.mul(this.Z, other.Z);
42
+ const B = Fp.sqr(A);
43
+ const C = Fp.mul(this.X, other.X);
44
+ const D = Fp.mul(this.Y, other.Y);
45
+ const E = Fp.mul(parameters.d, Fp.mul(C, D));
46
+ const F = Fp.sub(B, E);
47
+ const G = Fp.add(B, E);
48
+ const self_sum = Fp.add(this.X, this.Y);
49
+ const other_sum = Fp.add(other.X, other.Y);
50
+ const cross = Fp.mul(self_sum, other_sum);
51
+ const xr = Fp.mul(Fp.mul(A, G), Fp.sub(C, Fp.mul(parameters.a, D)));
52
+ const yr = Fp.mul(Fp.mul(A, F), Fp.sub(Fp.sub(cross, C), D));
53
+ const zr = Fp.mul(F, G);
54
+ return new Point(xr, yr, zr);
55
+ }
56
+ multiply(scalar) {
57
+ if (this.is0())
58
+ return Point.ZERO;
59
+ let S = new Point(this.X, this.Y, this.Z);
60
+ for (let i = bitLen(scalar) - 2; i >= 0; i--) {
61
+ S = S.add(S);
62
+ if (bitGet(scalar, i) == 1n)
63
+ S = S.add(this);
64
+ }
65
+ return S;
66
+ }
67
+ is0() {
68
+ return Fp.eql(this.x, Fp.ONE) && Fp.eql(this.y, Fp.ZERO);
69
+ }
70
+ assertValidity() {
71
+ if (!isValidXY(this.x, this.y))
72
+ throw new Error("Assertation failed: point isn't on curve");
73
+ return this;
74
+ }
75
+ toBytes() {
76
+ return concatBytes(Fp.toBytes(this.x), Fp.toBytes(this.y));
77
+ }
78
+ static fromBytes(bytes) {
79
+ if (bytes.length !== 2 * Fp.BYTES)
80
+ throw new Error(`expected ${2 * Fp.BYTES} bytes, got ${bytes.length}`);
81
+ const x = Fp.fromBytes(bytes.subarray(0, Fp.BYTES));
82
+ const y = Fp.fromBytes(bytes.subarray(Fp.BYTES, 2 * Fp.BYTES));
83
+ return Point.fromAffine(x, y);
84
+ }
85
+ static fromAffine(x, y) { return new Point(x, y, Fp.ONE).assertValidity(); }
86
+ static fromX(x) {
87
+ const x2 = Fp.sqr(x);
88
+ if (Fp.eql(x, Fp.ZERO) ||
89
+ Fp.eql(x, Fp.ONE) ||
90
+ Fp.eql(x, p_minus_1) ||
91
+ Fp.eql(x2, a_over_d))
92
+ throw new Error("Invalid x-coordinate, can't recover y");
93
+ const num = Fp.sub(Fp.ONE, x2);
94
+ const denom = Fp.sub(parameters.a, Fp.mul(parameters.d, x2));
95
+ const v = Fp.div(num, denom);
96
+ if (Fp.pow(v, p_minus_1_over_2) != Fp.ONE)
97
+ throw new Error("Invalid x-coordinate, non-complience with euler criterion");
98
+ const candidate = Point.fromAffine(x, Fp.sqrt(v));
99
+ if (!candidate.multiply(Fn.ORDER).is0())
100
+ throw new Error("Invalid x-coordinate, can't recover y");
101
+ return candidate;
102
+ }
103
+ }
104
+ const getPublicKey = (secretKey) => Point.BASE.multiply(bytesToNumberBE(secretKey)).toBytes();
105
+ const keygen = () => {
106
+ const secretKey = randomBytes(Fp.BYTES);
107
+ const publicKey = getPublicKey(secretKey);
108
+ return { secretKey, publicKey };
109
+ };
110
+ return Object.freeze({ Point, getPublicKey, keygen });
111
+ };
112
+ export const curve256 = dstu9041Curve({
113
+ p: 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe4dn,
114
+ n: 0x4000000000000000000000000000000029e26087789bc2815bdff97093543ccfn,
115
+ a: 2n,
116
+ d: 0x18n,
117
+ h: 1n,
118
+ Gx: 0x91f5d0e7e2d417e3108b13b075cdc7756045f8424479fcfe8f23d27250a0883fn,
119
+ Gy: 0x742f27a268641c9d7ddf69892be3df3d8f9cc52260b89a4953c8379c7c0a212bn
120
+ });
121
+ export const curve512 = dstu9041Curve({
122
+ p: 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc95n,
123
+ n: 0x400000000000000000000000000000000000000000000000000000000000000028a3ce52209e2bd4952882d5574165192c46c0d0311fea6bf9fece70ee63b59fn,
124
+ a: 2n,
125
+ d: 0x10dn,
126
+ h: 1n,
127
+ Gx: 0x5230a1ee747050a072bd7319741586ea520388b6b53094571c821a2fc9a9e83d56665346b5db04c43e75261dbda512728faafac48ae9260a5a184e2933e3a400n,
128
+ Gy: 0x53a0d50cc63c9219762f451978aef214dbcfcc3a5cb5ef27124991a86b42b3a1a832724a0e6b930fdd1da2e27a540d6b675e4422c444f529c508f0bae7d0a85n
129
+ });
@@ -0,0 +1,21 @@
1
+ import { type TArg, type TRet } from "@noble/curves/utils.js";
2
+ /** DSTU 9041:2020 (256 bit) */
3
+ export declare const dstu9041_256: Readonly<{
4
+ getPublicKey: (secretKey: TArg<Uint8Array>) => TRet<Uint8Array>;
5
+ keygen: () => {
6
+ secretKey: TRet<Uint8Array>;
7
+ publicKey: TRet<Uint8Array>;
8
+ };
9
+ encrypt: (message: TArg<Uint8Array>, publicKey: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
10
+ decrypt: (ciphertext: TArg<Uint8Array>, privateKey: TArg<Uint8Array>) => TRet<Uint8Array>;
11
+ }>;
12
+ /** DSTU 9041:2020 (512 bit) */
13
+ export declare const dstu9041_512: Readonly<{
14
+ getPublicKey: (secretKey: TArg<Uint8Array>) => TRet<Uint8Array>;
15
+ keygen: () => {
16
+ secretKey: TRet<Uint8Array>;
17
+ publicKey: TRet<Uint8Array>;
18
+ };
19
+ encrypt: (message: TArg<Uint8Array>, publicKey: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
20
+ decrypt: (ciphertext: TArg<Uint8Array>, privateKey: TArg<Uint8Array>) => TRet<Uint8Array>;
21
+ }>;