utxo-lib 1.0.8 → 1.0.9
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/src/base_crypto.d.ts +14 -0
- package/dist/src/base_crypto.d.ts.map +1 -0
- package/dist/src/base_crypto.js +215 -0
- package/dist/src/bitgo/Musig2.js +2 -3
- package/dist/src/bitgo/UtxoPsbt.js +12 -20
- package/dist/src/bitgo/UtxoTransaction.js +2 -2
- package/dist/src/bitgo/outputScripts.js +3 -3
- package/dist/src/bitgo/parseInput.js +2 -2
- package/dist/src/bitgo/psbt/scriptTypes.js +3 -3
- package/dist/src/bitgo/wallet/chains.d.ts +1 -1
- package/dist/src/bitgo/zcash/ZcashPsbt.js +2 -3
- package/dist/src/bitgo/zcash/ZcashTransaction.js +2 -2
- package/dist/src/musig.d.ts +391 -0
- package/dist/src/musig.d.ts.map +1 -0
- package/dist/src/musig.js +461 -0
- package/dist/src/noble_ecc.d.ts +1 -1
- package/dist/src/noble_ecc.d.ts.map +1 -1
- package/dist/src/noble_ecc.js +5 -5
- package/dist/src/payments/p2tr.js +9 -13
- package/dist/src/payments/p2tr_ns.js +2 -3
- package/dist/src/taproot.js +2 -3
- package/dist/src/transaction_builder.js +2 -2
- package/package.json +1 -2
@@ -0,0 +1,391 @@
|
|
1
|
+
/*! musig-js - MIT License (c) 2022 Brandon Black */
|
2
|
+
export interface MuSig {
|
3
|
+
/**
|
4
|
+
* Gets the X-only public key associated with this context.
|
5
|
+
*
|
6
|
+
* @param ctx the key gen context or a signing session key
|
7
|
+
* @returns the X-only public key associated with this context
|
8
|
+
*/
|
9
|
+
getXOnlyPubkey(ctx: KeyGenContext | SessionKey): Uint8Array;
|
10
|
+
/**
|
11
|
+
* Gets the plain public key associated with this context.
|
12
|
+
*
|
13
|
+
* @param ctx the key gen context or a signing session key
|
14
|
+
* @returns plain public key associated with this context in compressed DER format
|
15
|
+
*/
|
16
|
+
getPlainPubkey(ctx: KeyGenContext | SessionKey): Uint8Array;
|
17
|
+
/**
|
18
|
+
* Sorts compressed DER format public keys lexicographically.
|
19
|
+
*
|
20
|
+
* @param publicKeys array of compressed DER encoded public keys to aggregate
|
21
|
+
* @returns sorted public keys (in a new array)
|
22
|
+
*/
|
23
|
+
keySort(publicKeys: Uint8Array[]): Uint8Array[];
|
24
|
+
/**
|
25
|
+
* Performs MuSig key aggregation on 1+ x-only public keys.
|
26
|
+
*
|
27
|
+
* @param publicKeys array of compressed DER encoded public keys to aggregate
|
28
|
+
* @param tweaks tweaks (0 < tweak < n) to apply to the aggregate key,
|
29
|
+
* and optionally booleans to indicate x-only tweaking
|
30
|
+
* @returns an opaque key gen context for use with other MuSig operations
|
31
|
+
*/
|
32
|
+
keyAgg(publicKeys: Uint8Array[], ...tweaks: Tweak[]): KeyGenContext;
|
33
|
+
/**
|
34
|
+
* Apply one or more x-only or ordinary tweaks to an aggregate public key.
|
35
|
+
*
|
36
|
+
* @param ctx the key generation context, as returned from `keyAgg`.
|
37
|
+
* @param tweaks tweaks (0 < tweak < n) to apply to the aggregate key,
|
38
|
+
* and optionally booleans to indicate x-only tweaking
|
39
|
+
* @returns an opaque key gen context for use with other MuSig operations
|
40
|
+
*/
|
41
|
+
addTweaks(ctx: KeyGenContext, ...tweaks: Tweak[]): KeyGenContext;
|
42
|
+
/**
|
43
|
+
* Generate a MuSig nonce pair based on the provided values.
|
44
|
+
*
|
45
|
+
* The caller must not use the same sessionId for multiple calls to nonceGen
|
46
|
+
* with other parameters held constant.
|
47
|
+
*
|
48
|
+
* The secret nonce (97 bytes) is cached internally, and will be deleted
|
49
|
+
* from the cache prior to use in a signature. The secret nonce will also be
|
50
|
+
* deleted if the returned public nonce is deleted.
|
51
|
+
*
|
52
|
+
* @param sessionId if no secret key is provided, uniformly 32-bytes of
|
53
|
+
* random data, otherwise a value guaranteed not to repeat for the secret
|
54
|
+
* key. If no sessionId is provided a reasonably high quality random one will
|
55
|
+
* be generated.
|
56
|
+
* @param secretKey the secret key which will eventually sign with this nonce
|
57
|
+
* @param publicKey the public key for which this nonce will be signed (required)
|
58
|
+
* @param xOnlyPublicKey the x-coordinate of the aggregate public key that this
|
59
|
+
* nonce will be signing a part of
|
60
|
+
* @param msg the message which will eventually be signed with this nonce
|
61
|
+
* (any possible Uint8Array length)
|
62
|
+
* @param extraInput additional input which will contribute to the generated
|
63
|
+
* nonce (0 <= extraInput.length <= 2^32-1)
|
64
|
+
* @return the generated public nonce (66 bytes)
|
65
|
+
*/
|
66
|
+
nonceGen(args: {
|
67
|
+
sessionId?: Uint8Array;
|
68
|
+
secretKey?: Uint8Array;
|
69
|
+
publicKey: Uint8Array;
|
70
|
+
xOnlyPublicKey?: Uint8Array;
|
71
|
+
msg?: Uint8Array;
|
72
|
+
extraInput?: Uint8Array;
|
73
|
+
}): Uint8Array;
|
74
|
+
/**
|
75
|
+
* Add an externally generated nonce to the cache.
|
76
|
+
*
|
77
|
+
* NOT RECOMMENDED, but useful in testing at least.
|
78
|
+
* @param publicNonce 66-byte public nonce (2 points in compressed DER)
|
79
|
+
* @param secretNonce 97-byte secret nonce (2 32-byte scalars, and the public
|
80
|
+
* key which will sign for this nonce in compressed DER)
|
81
|
+
*/
|
82
|
+
addExternalNonce(publicNonce: Uint8Array, secretNonce: Uint8Array): void;
|
83
|
+
/**
|
84
|
+
* Combine public nonces from all signers into a single aggregate public nonce.
|
85
|
+
*
|
86
|
+
* Per the spec, this function prefers to succeed with an invalid nonce at
|
87
|
+
* infinity than to fail, to enable a dishonest signer to be detected later.
|
88
|
+
*
|
89
|
+
* This can be run by an untrusted node without breaking the security of the
|
90
|
+
* protocol. An untrusted aggregator can cause the protocol to fail, but not
|
91
|
+
* forge a signature.
|
92
|
+
*
|
93
|
+
* @param nonces n-signers public nonces (66-bytes each)
|
94
|
+
* @return the aggregate public nonce (66-bytes)
|
95
|
+
*/
|
96
|
+
nonceAgg(nonces: Uint8Array[]): Uint8Array;
|
97
|
+
/**
|
98
|
+
* Creates an opaque signing session for used in partial signing, partial
|
99
|
+
* verification, or signature aggregation. This may be saved by a
|
100
|
+
* participant, but may not be provided by an untrusted party.
|
101
|
+
*
|
102
|
+
* @param aggNonce this signing session's aggregate nonce
|
103
|
+
* @param msg the 32-byte message to sign for, most commonly a transaction hash.
|
104
|
+
* @param publicKeys array of compressed DER encoded public keys to aggregate
|
105
|
+
* @param tweaks tweaks (0 < tweak < n) to apply to the aggregate key,
|
106
|
+
* and optionally booleans to indicate x-only tweaking
|
107
|
+
* @return session key for `partialSign`, `partialVerify` and `signAgg`
|
108
|
+
*/
|
109
|
+
startSigningSession(aggNonce: Uint8Array, msg: Uint8Array, publicKeys: Uint8Array[], ...tweaks: Tweak[]): SessionKey;
|
110
|
+
/**
|
111
|
+
* Creates a MuSig partial signature for the given values.
|
112
|
+
*
|
113
|
+
* Verifies the resulting partial signature by default, as recommended in the
|
114
|
+
* specification.
|
115
|
+
*
|
116
|
+
* Note: Calling `partialSign` with the same `publicNonce` more than once
|
117
|
+
* will not work, as the corresponding secret nonce is deleted. Generate a
|
118
|
+
* new public nonce and try again.
|
119
|
+
*
|
120
|
+
* @param secretKey signer's secret key
|
121
|
+
* @param publicNonce signer's public nonce
|
122
|
+
* @param sessionKey signing session key (from startSigningSession)
|
123
|
+
* @param verify if false, don't verify partial signature
|
124
|
+
* @return resulting signature
|
125
|
+
*/
|
126
|
+
partialSign(args: {
|
127
|
+
secretKey: Uint8Array;
|
128
|
+
publicNonce: Uint8Array;
|
129
|
+
sessionKey: SessionKey;
|
130
|
+
verify?: boolean;
|
131
|
+
}): Uint8Array;
|
132
|
+
/**
|
133
|
+
* Verifies a MuSig partial signature for the given values.
|
134
|
+
*
|
135
|
+
* @param sig the 32-byte MuSig partial signature to verify
|
136
|
+
* @param msg the 32-byte message to sign for, most commonly a transaction hash
|
137
|
+
* @param publicKey signer's public key
|
138
|
+
* @param publicNonce signer's public nonce
|
139
|
+
* @param aggNonce this signing session's aggregate nonce
|
140
|
+
* @param sessionKey signing session key (from startSigningSession)
|
141
|
+
* @return true if the partial signature is valid, otherwise false
|
142
|
+
*/
|
143
|
+
partialVerify(args: {
|
144
|
+
sig: Uint8Array;
|
145
|
+
publicKey: Uint8Array;
|
146
|
+
publicNonce: Uint8Array;
|
147
|
+
sessionKey: SessionKey;
|
148
|
+
}): boolean;
|
149
|
+
/**
|
150
|
+
* Aggregates MuSig partial signatures. May be run by an untrusted party.
|
151
|
+
*
|
152
|
+
* @param sigs array of 32-bytes MuSig partial signatures.
|
153
|
+
* @param sessionKey signing session key (from startSigningSession)
|
154
|
+
* @return the resulting aggregate signature.
|
155
|
+
*/
|
156
|
+
signAgg(sigs: Uint8Array[], sessionKey: SessionKey): Uint8Array;
|
157
|
+
/**
|
158
|
+
* Deterministically generate nonces and partially sign for a MuSig key.
|
159
|
+
* The security of this method depends on its being run after all other
|
160
|
+
* parties have provided their nonces.
|
161
|
+
*
|
162
|
+
* @param secretKey signer's secret key
|
163
|
+
* @param aggOtherNonce the result of calling `nonceAgg` on all other signing
|
164
|
+
* parties' nonces
|
165
|
+
* @param publicKeys array of compressed DER encoded public keys to aggregate
|
166
|
+
* @param tweaks tweaks (0 < tweak < n) to apply to the aggregate key,
|
167
|
+
* and optionally booleans to indicate x-only tweaking
|
168
|
+
* @param msg the 32-byte message to sign for, most commonly a transaction hash.
|
169
|
+
* @param rand optional additional randomness for nonce generation
|
170
|
+
* @param verify if false, don't verify partial signature
|
171
|
+
* @return resulting signature, session key (for signature aggregation), and
|
172
|
+
* public nonce (for partial verification)
|
173
|
+
*/
|
174
|
+
deterministicSign(args: {
|
175
|
+
secretKey: Uint8Array;
|
176
|
+
aggOtherNonce: Uint8Array;
|
177
|
+
publicKeys: Uint8Array[];
|
178
|
+
tweaks?: Tweak[];
|
179
|
+
msg: Uint8Array;
|
180
|
+
rand?: Uint8Array;
|
181
|
+
verify?: boolean;
|
182
|
+
}): {
|
183
|
+
sig: Uint8Array;
|
184
|
+
sessionKey: SessionKey;
|
185
|
+
publicNonce: Uint8Array;
|
186
|
+
};
|
187
|
+
/**
|
188
|
+
* Deterministically generate nonces. This is identical to deterministicSign,
|
189
|
+
* except that it aborts after nonce generation and before signing, and
|
190
|
+
* returns only the public nonce. This security of this method of nonce
|
191
|
+
* generation depends on its being run after all other parties have provided
|
192
|
+
* their nonces.
|
193
|
+
*
|
194
|
+
* A public nonce generated in this way cannot be directly used for signing
|
195
|
+
* (no secret nonce is saved), but a matching partial signature can be
|
196
|
+
* generated by subsequently calling deterministicSign with the same
|
197
|
+
* arguments as the call to deterministicNonceGen.
|
198
|
+
*
|
199
|
+
* This can be useful in a case where a stateless signer only wants to
|
200
|
+
* provide its partial signature after seeing valid partial signatures from
|
201
|
+
* other parties.
|
202
|
+
*
|
203
|
+
* @param secretKey signer's secret key
|
204
|
+
* @param aggOtherNonce the result of calling `nonceAgg` on all other signing
|
205
|
+
* parties' nonces
|
206
|
+
* @param publicKeys array of compressed DER encoded public keys to aggregate
|
207
|
+
* @param tweaks tweaks (0 < tweak < n) to apply to the aggregate key,
|
208
|
+
* and optionally booleans to indicate x-only tweaking
|
209
|
+
* @param msg the 32-byte message to sign for, most commonly a transaction hash.
|
210
|
+
* @param rand optional additional randomness for nonce generation
|
211
|
+
* @param verify if false, don't verify partial signature
|
212
|
+
* @return public nonce
|
213
|
+
*/
|
214
|
+
deterministicNonceGen(args: {
|
215
|
+
secretKey: Uint8Array;
|
216
|
+
aggOtherNonce: Uint8Array;
|
217
|
+
publicKeys: Uint8Array[];
|
218
|
+
tweaks?: Tweak[];
|
219
|
+
msg: Uint8Array;
|
220
|
+
rand?: Uint8Array;
|
221
|
+
}): {
|
222
|
+
publicNonce: Uint8Array;
|
223
|
+
};
|
224
|
+
}
|
225
|
+
export interface Crypto {
|
226
|
+
/**
|
227
|
+
* Adds a tweak to a point.
|
228
|
+
*
|
229
|
+
* @param p A point, compressed or uncompressed
|
230
|
+
* @param t A tweak, 0 < t < n
|
231
|
+
* @param compressed Whether the resulting point should be compressed.
|
232
|
+
* @returns The tweaked point, compressed or uncompressed, null if the result
|
233
|
+
* is the point at infinity.
|
234
|
+
*/
|
235
|
+
pointAddTweak(p: Uint8Array, t: Uint8Array, compressed: boolean): Uint8Array | null;
|
236
|
+
/**
|
237
|
+
* Adds two points.
|
238
|
+
*
|
239
|
+
* @param a An addend point, compressed or uncompressed
|
240
|
+
* @param b An addend point, compressed or uncompressed
|
241
|
+
* @param compressed Whether the resulting point should be compressed.
|
242
|
+
* @returns The sum point, compressed or uncompressed, null if the result is
|
243
|
+
* the point at infinity.
|
244
|
+
*/
|
245
|
+
pointAdd(a: Uint8Array, b: Uint8Array, compressed: boolean): Uint8Array | null;
|
246
|
+
/**
|
247
|
+
* Multiplies a point by a scalar.
|
248
|
+
* This function may use non-constant time operations, as no secret
|
249
|
+
* information is processed.
|
250
|
+
*
|
251
|
+
* @param p A point multiplicand, compressed or uncompressed
|
252
|
+
* @param a The multiplier, 0 < a < n
|
253
|
+
* @param compressed Whether the resulting point should be compressed.
|
254
|
+
* @returns The product point, compressed or uncompressed, null if the result
|
255
|
+
* is the point at infinity.
|
256
|
+
*/
|
257
|
+
pointMultiplyUnsafe(p: Uint8Array, a: Uint8Array, compressed: boolean): Uint8Array | null;
|
258
|
+
/**
|
259
|
+
* Multiplies point 1 by a scalar and adds it to point 2.
|
260
|
+
* This function may use non-constant time operations, as no secret
|
261
|
+
* information is processed.
|
262
|
+
*
|
263
|
+
* @param p1 point multiplicand, compressed or uncompressed
|
264
|
+
* @param a The multiplier, 0 < a < n
|
265
|
+
* @param p2 point addend, compressed or uncompressed
|
266
|
+
* @param compressed Whether the resulting point should be compressed.
|
267
|
+
* @returns The product/sum point, compressed or uncompressed, null if the
|
268
|
+
* result is the point at infinity.
|
269
|
+
*/
|
270
|
+
pointMultiplyAndAddUnsafe(p1: Uint8Array, a: Uint8Array, p2: Uint8Array, compressed: boolean): Uint8Array | null;
|
271
|
+
/**
|
272
|
+
* Negates a point, ie. returns the point with the opposite parity.
|
273
|
+
*
|
274
|
+
* @param p A point to negate, compressed or uncompressed
|
275
|
+
* @returns The negated point, with same compression as input.
|
276
|
+
*/
|
277
|
+
pointNegate(p: Uint8Array): Uint8Array;
|
278
|
+
/**
|
279
|
+
* Compresses a point.
|
280
|
+
*
|
281
|
+
* @param p A point, compressed or uncompressed
|
282
|
+
* @param compress [default=true] if false, uncompress the point
|
283
|
+
* @returns The point, compressed if compress is true, or uncompressed if false.
|
284
|
+
*/
|
285
|
+
pointCompress(p: Uint8Array, compress?: boolean): Uint8Array;
|
286
|
+
/**
|
287
|
+
* Adds one value to another, mod n.
|
288
|
+
*
|
289
|
+
* @param a An addend, 0 <= a < n
|
290
|
+
* @param b An addend, 0 <= b < n
|
291
|
+
* @returns The sum, 0 <= sum < n
|
292
|
+
*/
|
293
|
+
scalarAdd(a: Uint8Array, b: Uint8Array): Uint8Array;
|
294
|
+
/**
|
295
|
+
* Multiply one value by another, mod n.
|
296
|
+
*
|
297
|
+
* @param a The multiplicand, 0 <= a < n
|
298
|
+
* @param b The multiplier, 0 <= b < n
|
299
|
+
* @returns The product, 0 <= product < n
|
300
|
+
*/
|
301
|
+
scalarMultiply(a: Uint8Array, b: Uint8Array): Uint8Array;
|
302
|
+
/**
|
303
|
+
* Negates a value, mod n.
|
304
|
+
*
|
305
|
+
* @param a The value to negate, 0 <= a < n
|
306
|
+
* @returns The negated value, 0 <= negated < n
|
307
|
+
*/
|
308
|
+
scalarNegate(a: Uint8Array): Uint8Array;
|
309
|
+
/**
|
310
|
+
* @param a The value to reduce
|
311
|
+
* @returns a mod n
|
312
|
+
*/
|
313
|
+
scalarMod(a: Uint8Array): Uint8Array;
|
314
|
+
/**
|
315
|
+
* @param s A buffer to check against the curve order
|
316
|
+
* @returns true if s is a 32-byte array 0 <= s < n
|
317
|
+
*/
|
318
|
+
isScalar(s: Uint8Array): boolean;
|
319
|
+
/**
|
320
|
+
* @param s A buffer to check against the curve order
|
321
|
+
* @returns true if s is a 32-byte array 0 < s < n
|
322
|
+
*/
|
323
|
+
isSecret(s: Uint8Array): boolean;
|
324
|
+
/**
|
325
|
+
* @param p A buffer to check against the curve equation, compressed or
|
326
|
+
* uncompressed.
|
327
|
+
* @returns true if p is a valid point on secp256k1, false otherwise
|
328
|
+
*/
|
329
|
+
isPoint(p: Uint8Array): boolean;
|
330
|
+
/**
|
331
|
+
* @param p A buffer to check against the curve equation.
|
332
|
+
* @returns true if p is the x coordinate of a valid point on secp256k1,
|
333
|
+
* false otherwise
|
334
|
+
*/
|
335
|
+
isXOnlyPoint(p: Uint8Array): boolean;
|
336
|
+
/**
|
337
|
+
* @param p an x coordinate
|
338
|
+
* @returns the xy, uncompressed point if p is on the curve, otherwise null.
|
339
|
+
*/
|
340
|
+
liftX(p: Uint8Array): Uint8Array | null;
|
341
|
+
/**
|
342
|
+
* @param p x-only, compressed or uncompressed
|
343
|
+
* @returns the x coordinate of p
|
344
|
+
*/
|
345
|
+
pointX(p: Uint8Array): Uint8Array;
|
346
|
+
/**
|
347
|
+
* @param p a point, compressed or uncompressed
|
348
|
+
* @returns true if p has an even y coordinate, false otherwise
|
349
|
+
*/
|
350
|
+
hasEvenY(p: Uint8Array): boolean;
|
351
|
+
/**
|
352
|
+
* Gets a public key for secret key.
|
353
|
+
*
|
354
|
+
* @param s Secret key
|
355
|
+
* @param compressed Whether the resulting point should be compressed.
|
356
|
+
* @returns The public key, compressed or uncompressed
|
357
|
+
*/
|
358
|
+
getPublicKey(s: Uint8Array, compressed: boolean): Uint8Array | null;
|
359
|
+
/**
|
360
|
+
* Performs a BIP340-style tagged hash.
|
361
|
+
*
|
362
|
+
* @param tag
|
363
|
+
* @param messages Array of data to hash.
|
364
|
+
* @return The 32-byte BIP340-style tagged hash.
|
365
|
+
*/
|
366
|
+
taggedHash(tag: string, ...messages: Uint8Array[]): Uint8Array;
|
367
|
+
/**
|
368
|
+
* SHA256 hash.
|
369
|
+
*
|
370
|
+
* @param messages Array of data to hash.
|
371
|
+
* @return The 32-byte SHA256 digest.
|
372
|
+
*/
|
373
|
+
sha256(...messages: Uint8Array[]): Uint8Array;
|
374
|
+
}
|
375
|
+
export declare type Tweak = TypedTweak | Uint8Array;
|
376
|
+
export interface TypedTweak {
|
377
|
+
tweak: Uint8Array;
|
378
|
+
xOnly?: boolean;
|
379
|
+
}
|
380
|
+
export interface KeyGenContext {
|
381
|
+
aggPublicKey: Uint8Array;
|
382
|
+
gacc: Uint8Array;
|
383
|
+
tacc: Uint8Array;
|
384
|
+
}
|
385
|
+
export interface SessionKey {
|
386
|
+
publicKey: Uint8Array;
|
387
|
+
aggNonce: Uint8Array;
|
388
|
+
msg: Uint8Array;
|
389
|
+
}
|
390
|
+
export declare function MuSigFactory(ecc: Crypto): MuSig;
|
391
|
+
//# sourceMappingURL=musig.d.ts.map
|
@@ -0,0 +1 @@
|
|
1
|
+
{"version":3,"file":"musig.d.ts","sourceRoot":"","sources":["../../src/musig.ts"],"names":[],"mappings":"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"}
|