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