1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 | declare class $npm$bigi$BigInteger {
|
7 | constructor(input: string|Array<number>, base?: number): void;
|
8 | static (input: string|Array<number>, base?: number): $npm$bigi$BigInteger;
|
9 |
|
10 | toString(base?: number): string;
|
11 | toByteArray(): Array<number>;
|
12 | bitLength(): number;
|
13 | byteLength(): number;
|
14 | add(o: $npm$bigi$BigInteger): $npm$bigi$BigInteger;
|
15 | subtract(o: $npm$bigi$BigInteger): $npm$bigi$BigInteger;
|
16 | multiply(o: $npm$bigi$BigInteger): $npm$bigi$BigInteger;
|
17 | divide(o: $npm$bigi$BigInteger): $npm$bigi$BigInteger;
|
18 | mod(o: $npm$bigi$BigInteger): $npm$bigi$BigInteger;
|
19 | modInverse(o: $npm$bigi$BigInteger): $npm$bigi$BigInteger;
|
20 | shiftLeft(o: number): $npm$bigi$BigInteger;
|
21 | shiftRight(o: number): $npm$bigi$BigInteger;
|
22 | isProbablePrime(): boolean;
|
23 |
|
24 | static fromByteArrayUnsigned(array: Array<number>): $npm$bigi$BigInteger;
|
25 | static fromBuffer(buffer: Buffer): $npm$bigi$BigInteger;
|
26 | static fromDERInteger(buffer: Buffer): $npm$bigi$BigInteger;
|
27 | static fromHex(hex: string): $npm$bigi$BigInteger;
|
28 |
|
29 | toByteArrayUnsigned(): Array<number>;
|
30 | toBuffer(): Buffer;
|
31 | toDERInteger(): Buffer;
|
32 | toHex(): string;
|
33 | }
|
34 |
|
35 | declare module 'bigi' {
|
36 | declare var exports: typeof $npm$bigi$BigInteger;
|
37 | }
|
38 |
|
39 | declare class $npm$ecurve$Curve {
|
40 | p: $npm$bigi$BigInteger;
|
41 | a: $npm$bigi$BigInteger;
|
42 | b: $npm$bigi$BigInteger;
|
43 | G: $npm$ecurve$Point;
|
44 | n: $npm$bigi$BigInteger;
|
45 | h: $npm$bigi$BigInteger;
|
46 |
|
47 | constructor(
|
48 | p: $npm$bigi$BigInteger,
|
49 | a: $npm$bigi$BigInteger,
|
50 | b: $npm$bigi$BigInteger,
|
51 | Gx: $npm$bigi$BigInteger,
|
52 | Gy: $npm$bigi$BigInteger,
|
53 | n: $npm$bigi$BigInteger,
|
54 | h: $npm$bigi$BigInteger
|
55 | ): void;
|
56 |
|
57 | infinity: $npm$ecurve$Point;
|
58 | isInfinity(point: $npm$ecurve$Point): boolean;
|
59 | validate(a: $npm$ecurve$Point): boolean;
|
60 | isOnCurve(a: $npm$ecurve$Point): boolean;
|
61 | pointFromX(odd: boolean, x: $npm$ecurve$Point): $npm$ecurve$Point;
|
62 | }
|
63 |
|
64 | declare class $npm$ecurve$Point {
|
65 | constructor(
|
66 | curve: $npm$ecurve$Curve,
|
67 | x: $npm$bigi$BigInteger,
|
68 | y: $npm$bigi$BigInteger,
|
69 | z: $npm$bigi$BigInteger
|
70 | ): void;
|
71 |
|
72 | x: $npm$bigi$BigInteger;
|
73 | y: $npm$bigi$BigInteger;
|
74 | z: $npm$bigi$BigInteger;
|
75 |
|
76 | zInv: $npm$bigi$BigInteger;
|
77 | affineX: $npm$bigi$BigInteger;
|
78 | affineY: $npm$bigi$BigInteger;
|
79 |
|
80 | static fromAffine(curve: $npm$ecurve$Curve, x: $npm$bigi$BigInteger, y: $npm$bigi$BigInteger): $npm$ecurve$Point;
|
81 | equals(other: $npm$ecurve$Point): boolean;
|
82 | negate(): $npm$ecurve$Point;
|
83 | add(other: $npm$ecurve$Point): $npm$ecurve$Point;
|
84 | twice(): $npm$ecurve$Point;
|
85 | multiply(k: $npm$bigi$BigInteger): $npm$ecurve$Point;
|
86 | multiplyTwo(j: $npm$bigi$BigInteger, x: $npm$ecurve$Point, k: $npm$bigi$BigInteger): $npm$ecurve$Point;
|
87 |
|
88 | static decodeFrom(curve: $npm$ecurve$Curve, buffer: Buffer): $npm$ecurve$Point;
|
89 | getEncoded(compressed: boolean): Buffer;
|
90 |
|
91 | toString(): string;
|
92 | }
|
93 |
|
94 | declare module 'ecurve' {
|
95 |
|
96 | declare var Point: typeof $npm$ecurve$Point;
|
97 |
|
98 | declare var Curve: typeof $npm$ecurve$Curve;
|
99 |
|
100 | declare function getCurveByName(name: string): ?Curve;
|
101 | }
|
102 | // ---------- copypasta end ----
|
103 |
|
104 | declare module 'bitcoinjs-lib-zcash' {
|
105 |
|
106 | declare type Network = {
|
107 | messagePrefix: string;
|
108 | bip32: {
|
109 | public: number;
|
110 | private: number;
|
111 | };
|
112 | pubKeyHash: number;
|
113 | scriptHash: number;
|
114 | wif: number;
|
115 | dustThreshold: number;
|
116 | }
|
117 |
|
118 | declare type Output = {
|
119 | script: Buffer;
|
120 | value: number;
|
121 | };
|
122 |
|
123 | declare type Input = {
|
124 | script: Buffer;
|
125 | hash: Buffer;
|
126 | index: number;
|
127 | sequence: number;
|
128 | };
|
129 |
|
130 | declare var address: {
|
131 | fromBase58Check(address: string): {hash: Buffer, version: number};
|
132 | fromOutputScript(script: Buffer, network?: Network): string;
|
133 | toBase58Check(hash: Buffer, version: number): string;
|
134 | toOutputScipt(network?: Network): Buffer;
|
135 | };
|
136 |
|
137 | declare var script: {
|
138 | fromAddress(address: string, network?: Network): Buffer;
|
139 | scriptHashOutput(sho: Buffer): Buffer;
|
140 |
|
141 | compile(chunks: Buffer | Array<Buffer | number>): Buffer;
|
142 | decompile(buffer: Buffer | Array<Buffer | number>): Array<Buffer | number>;
|
143 | fromASM(asm: string): Buffer;
|
144 | toASM(string: Buffer): string;
|
145 | number: {
|
146 | decode: (buf: Buffer, maxLength: number, minimal: boolean) => number;
|
147 | encode: (n: number) => Buffer;
|
148 | };
|
149 | isCanonicalPubKey(buffer: Buffer): boolean;
|
150 | isCanonicalSignature(buffer: Buffer): boolean;
|
151 | isDefinedHashType(type: number): boolean;
|
152 | isPubKeyHashInput(script: Array<Buffer | number> | Buffer): boolean;
|
153 | isPubKeyHashOutput(script: Array<Buffer | number> | Buffer): boolean;
|
154 | isPubKeyInput(script: Array<Buffer | number> | Buffer): boolean;
|
155 | isPubKeyOutput(script: Array<Buffer | number> | Buffer): boolean;
|
156 | isScriptHashInput(script: Array<Buffer | number> | Buffer, allowIncomplete?: boolean): boolean;
|
157 | isScriptHashOutput(script: Array<Buffer | number> | Buffer): boolean;
|
158 | isWitnessPubKeyHashOutput(script: Array<Buffer | number> | Buffer): boolean;
|
159 | isWitnessScriptHashOutput(script: Array<Buffer | number> | Buffer): boolean;
|
160 | isMultisigInput(script: Array<Buffer | number> | Buffer, allowIncomplete?: boolean): boolean;
|
161 | isMultisigOutput(script: Array<Buffer | number> | Buffer): boolean;
|
162 | isNullDataOutput(script: Array<Buffer | number> | Buffer): boolean;
|
163 |
|
164 | classifyOutput(script: Array<Buffer | number> | Buffer): string;
|
165 | classifyInput(script: Array<Buffer | number> | Buffer): string;
|
166 | pubKeyOutput(pubKey: Buffer): Buffer;
|
167 | pubKeyHashOutput(pubKeyHash: Buffer): Buffer;
|
168 | scriptHashOutput(scriptHash: Buffer): Buffer;
|
169 | witnessPubKeyHashOutput(pubKeyHash: Buffer): Buffer;
|
170 | witnessScriptHashInput(scriptSig: Array<Buffer | number> | Buffer, scriptPubKey: Array<Buffer | number> | Buffer): Buffer;
|
171 | witnessScriptHashOutput(scriptHash: Buffer): Buffer;
|
172 |
|
173 | multisigOutput(m: number, pubKeys: Array<Buffer>): Buffer;
|
174 | pubKeyInput(signature: Buffer): Buffer;
|
175 | pubKeyHashInput(signature: Buffer, pubKey: Buffer): Buffer;
|
176 | scriptHashInput(scriptSig: Array<Buffer | number> | Buffer, scriptPubKey: Array<Buffer | number> | Buffer):Buffer;
|
177 | multisigInput(signatures: Array<Buffer>, scriptPubKey?: Array<Buffer | number> | Buffer): Buffer;
|
178 | nullDataOutput(data: Buffer): Buffer;
|
179 | };
|
180 |
|
181 | declare var crypto: {
|
182 | sha1(buffer: Buffer): Buffer;
|
183 | sha256(buffer: Buffer): Buffer;
|
184 | hash256(buffer: Buffer): Buffer;
|
185 | hash160(buffer: Buffer): Buffer;
|
186 | ripemd160(buffer: Buffer): Buffer;
|
187 | }
|
188 |
|
189 | declare class ECPair {
|
190 | d: ?$npm$bigi$BigInteger;
|
191 | Q: $npm$ecurve$Point;
|
192 | compressed: boolean;
|
193 | network: Network;
|
194 | getNetwork(): Network;
|
195 |
|
196 | constructor(d: ?$npm$bigi$BigInteger, Q: ?$npm$ecurve$Point): void;
|
197 | getAddress(): string;
|
198 | getPublicKeyBuffer(): Buffer;
|
199 | static fromPublicKeyBuffer(buffer: Buffer): ECPair;
|
200 | verify: (hash: Buffer, signature: ECSignature) => boolean;
|
201 | sign(hash: Buffer): Buffer;
|
202 | toWIF(): string;
|
203 | static fromWIF(string: string, network: Network): ECPair;
|
204 | static makeRandom(): ECPair;
|
205 | }
|
206 |
|
207 | declare class HDNode {
|
208 | depth: number;
|
209 | parentFingerprint: number;
|
210 | index: number;
|
211 | keyPair: ECPair;
|
212 | chainCode: Buffer;
|
213 | static fromBase58(
|
214 | str: string,
|
215 | networks: ?(Array<Network> | Network)
|
216 | ): HDNode;
|
217 | derive(index: number): HDNode;
|
218 | deriveHardened(index: number): HDNode;
|
219 | derivePath(path: string): HDNode;
|
220 | toBase58(): string;
|
221 | getAddress(): string;
|
222 | getFingerprint(): Buffer;
|
223 | getIdentifier(): Buffer;
|
224 | getNetwork(): Network;
|
225 | constructor(keyPair: ECPair, chainCode: Buffer): void;
|
226 |
|
227 | static fromBase58(base: string, network?: ?(Network | Array<Network>)): HDNode;
|
228 | static fromSeedHex(seed: string, network?: ?Network): HDNode;
|
229 | static fromSeedBuffer(seed: Buffer, network?: ?Network): HDNode;
|
230 | getPublicKeyBuffer(): Buffer;
|
231 |
|
232 | sign(): ECSignature;
|
233 | verify(hash: Buffer, signature: ECSignature): Buffer;
|
234 | neutered(): HDNode;
|
235 | isNeutered(): boolean;
|
236 | constructor(keyPair: ECPair, chainCode: Buffer): void;
|
237 | static HIGHEST_BIT: number;
|
238 | }
|
239 |
|
240 | declare class Transaction {
|
241 | version: number;
|
242 | locktime: number;
|
243 | ins: Array<Input>;
|
244 | outs: Array<Output>;
|
245 |
|
246 | constructor(): void;
|
247 | static fromHex(hex: string): Transaction;
|
248 | static fromBuffer(buffer: Buffer): Transaction;
|
249 | toHex(): string;
|
250 | addInput(hash: Buffer, index: number, sequence?: ?number, scriptSig?: Buffer): void;
|
251 | addOutput(scriptPubKey: Buffer, value: number): void;
|
252 | getHash(): Buffer;
|
253 | toBuffer(): Buffer;
|
254 | toHex(): string;
|
255 | getId(): string;
|
256 |
|
257 | static isCoinbaseHash(buffer: Buffer): boolean;
|
258 | isCoinbase(): boolean;
|
259 | byteLength(): number;
|
260 |
|
261 | // this is only for zcash branch
|
262 | joinsplitByteLength(): number;
|
263 | clone(): Transaction;
|
264 | hashForSignature(inIndex: number, prevOutScript: Buffer, hashType: number): Buffer;
|
265 | setInputScript(index: number, scriptSig: Buffer): void;
|
266 | }
|
267 |
|
268 | declare class TransactionBuilder {
|
269 | network: Network;
|
270 | inputs: Array<Input>;
|
271 | tx: Transaction;
|
272 |
|
273 | setLockTime(locktime: number): void;
|
274 | setVersion(version: number): void;
|
275 | addInput(txhash: string | Transaction | Buffer, vout: number, sequence?: number, prevOutScript?: Buffer): void;
|
276 | addOutput(scriptPubKey: string | Buffer, value: number): void;
|
277 | build(): Transaction;
|
278 | buildIncomplete(): Transaction;
|
279 | sign(index: number, keyPair: ECPair, redeemScript: Buffer, hashType: number): void;
|
280 |
|
281 | static fromTransaction(transaction: Transaction, network: ?Network): TransactionBuilder;
|
282 |
|
283 | }
|
284 |
|
285 | declare var networks: {[key: string]: Network}
|
286 | declare var opcodes: {[key: string]: number}
|
287 |
|
288 | declare class ECSignature {
|
289 | r: $npm$bigi$BigInteger;
|
290 | s: $npm$bigi$BigInteger;
|
291 | constructor(r: $npm$bigi$BigInteger, s: $npm$bigi$BigInteger): void;
|
292 |
|
293 | static parseCompact(buffer: Buffer): {
|
294 | compressed: boolean,
|
295 | i: number,
|
296 | signature: Buffer
|
297 | };
|
298 |
|
299 | static fromDER(buffer: Buffer): ECSignature;
|
300 | static parseScriptSignature(buffer: Buffer): {
|
301 | signature: ECSignature,
|
302 | hashType: number
|
303 | };
|
304 |
|
305 | toCompact(i: number, compressed: boolean): Buffer;
|
306 | toDER(): Buffer;
|
307 | toScriptSignature(hashType: number): Buffer;
|
308 | }
|
309 |
|
310 | declare class Block {
|
311 | version: number;
|
312 | prevHash: Buffer;
|
313 | merkleRoot: Buffer;
|
314 | timestamp: number;
|
315 | bits: number;
|
316 | nonce: number;
|
317 |
|
318 | getHash(): Buffer;
|
319 | getId(): string;
|
320 | getUTCDate(): Date;
|
321 | toBuffer(headersOnly?: boolean): Buffer;
|
322 | toHex(headersOnly?: boolean): string;
|
323 | calculateTarget(bits: number): Buffer;
|
324 | checkProofOfWork(): boolean;
|
325 |
|
326 | static fromBuffer(buffer: Buffer): Block;
|
327 | static fromHex(hex: string): Block;
|
328 | }
|
329 |
|
330 | declare var bufferutils: {
|
331 | equal(a: Buffer, b: Buffer): boolean;
|
332 | pushDataSize(i: number): number;
|
333 | readPushDataInt(buffer: Buffer, offset: number): {
|
334 | opcode: number,
|
335 | number: number,
|
336 | size: number
|
337 | };
|
338 | readUInt64LE(buffer: Buffer, offset: number): number;
|
339 | readVarInt(buffer: Buffer, offset: number): {
|
340 | number: number,
|
341 | size: number
|
342 | };
|
343 | varIntBuffer(i: number): Buffer;
|
344 | varIntSize(i: number): number;
|
345 | writePushDataInt(buffer: Buffer, number: number, offset: number): number;
|
346 | writeUInt64LE(buffer: Buffer, value: number, offset: number): void;
|
347 | writeVarInt(buffer: Buffer, number: number, offset: number): number;
|
348 | }
|
349 |
|
350 | declare var message: {
|
351 | magicHash(message: Buffer|string, network: Network): Buffer;
|
352 | sign(pair: ECPair, message: Buffer|string, network: Network): Buffer;
|
353 | verify(address: string, signature: Buffer, message: Buffer|string, network: Network): boolean;
|
354 | }
|
355 | }
|