8452447998

Committed 27 Mar 2024 01:17PM UTC coverage: 16.226% (-52.4%) from 68.632%

Build # 8452447998

Build Type

Pull #888

github

Committed by

web-flow

Commit Message

Merge c40b9e40c into 0a4f24bdb

Pull Request Pull Request #888: Wallet TX Count and time indexing

Run Details

1001 of 12966 branches covered (7.72%)

Branch coverage included in aggregate %.

130 of 474 new or added lines in 11 files covered. (27.43%)

17522 existing lines in 124 files now uncovered.

6546 of 33547 relevant lines covered (19.51%)

37.41 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

26.07

/lib/primitives/keyring.js

/*!
 * keyring.js - keyring object for hsd
 * Copyright (c) 2017-2018, Christopher Jeffrey (MIT License).
 * https://github.com/handshake-org/hsd
 */

'use strict';

const assert = require('bsert');
const base58 = require('bcrypto/lib/encoding/base58');
const bio = require('bufio');
const blake2b = require('bcrypto/lib/blake2b');
const hash256 = require('bcrypto/lib/hash256');
const Network = require('../protocol/network');
const Script = require('../script/script');
const Address = require('./address');
const Output = require('./output');
const secp256k1 = require('bcrypto/lib/secp256k1');

/*
 * Constants
 */

const ZERO_KEY = Buffer.alloc(33, 0x00);

/**
 * Key Ring
 * Represents a key ring which amounts to an address.
 * @alias module:primitives.KeyRing
 */

class KeyRing extends bio.Struct {
  /**
   * Create a key ring.
   * @constructor
   * @param {Object} options
   */

  constructor(options) {
    super();

    this.publicKey = ZERO_KEY;
    this.privateKey = null;
    this.script = null;

    this._keyHash = null;
    this._keyAddress = null;
    this._scriptHash = null;
    this._scriptAddress = null;

    if (options)
      this.fromOptions(options);
  }

  /**
   * Inject properties from options object.
   * @private
   * @param {Object} options
   */

  fromOptions(options) {
    let key = toKey(options);

    if (Buffer.isBuffer(key))
      return this.fromKey(key);

    key = toKey(options.key);

    if (options.publicKey)
      key = toKey(options.publicKey);

    if (options.privateKey)
      key = toKey(options.privateKey);

    const script = options.script;

    if (script)
      return this.fromScript(key, script);

    return this.fromKey(key);
  }

  /**
   * Clear cached key/script hashes.
   */

  refresh() {
    this._keyHash = null;
    this._keyAddress = null;
    this._scriptHash = null;
    this._scriptAddress = null;
    return this;
  }

  /**
   * Inject data from private key.
   * @private
   * @param {Buffer} key
   */

  fromPrivate(key) {
    assert(Buffer.isBuffer(key), 'Private key must be a buffer.');
    assert(secp256k1.privateKeyVerify(key), 'Not a valid private key.');

    this.privateKey = key;
    this.publicKey = secp256k1.publicKeyCreate(key, true);

    return this;
  }

  /**
   * Instantiate keyring from a private key.
   * @param {Buffer} key
   * @returns {KeyRing}
   */

  static fromPrivate(key) {
    return new this().fromPrivate(key);
  }

  /**
   * Inject data from public key.
   * @private
   * @param {Buffer} key
   */

  fromPublic(key) {
    assert(Buffer.isBuffer(key), 'Public key must be a buffer.');
    assert(secp256k1.publicKeyVerify(key) && key.length === 33,
      'Not a valid public key.');
    this.publicKey = key;
    return this;
  }

  /**
   * Generate a keyring.
   * @private
   * @returns {KeyRing}
   */

  generate() {
    const key = secp256k1.privateKeyGenerate();
    return this.fromKey(key);
  }

  /**
   * Generate a keyring.
   * @returns {KeyRing}
   */

  static generate() {
    return new this().generate();
  }

  /**
   * Instantiate keyring from a public key.
   * @param {Buffer} publicKey
   * @returns {KeyRing}
   */

  static fromPublic(key) {
    return new this().fromPublic(key);
  }

  /**
   * Inject data from public key.
   * @private
   * @param {Buffer} privateKey
   */

  fromKey(key) {
    assert(Buffer.isBuffer(key), 'Key must be a buffer.');

    if (key.length === 32)
      return this.fromPrivate(key, true);

    return this.fromPublic(key);
  }

  /**
   * Instantiate keyring from a public key.
   * @param {Buffer} publicKey
   * @returns {KeyRing}
   */

  static fromKey(key) {
    return new this().fromKey(key);
  }

  /**
   * Inject data from script.
   * @private
   * @param {Buffer} key
   * @param {Script} script
   */

  fromScript(key, script) {
    assert(script instanceof Script, 'Non-script passed into KeyRing.');

    this.fromKey(key);
    this.script = script;

    return this;
  }

  /**
   * Instantiate keyring from script.
   * @param {Buffer} key
   * @param {Script} script
   * @returns {KeyRing}
   */

  static fromScript(key, script) {
    return new this().fromScript(key, script);
  }

  /**
   * Calculate WIF serialization size.
   * @returns {Number}
   */

  getSecretSize() {
    let size = 0;

    size += 1;
    size += this.privateKey.length;
    size += 1;
    size += 4;

    return size;
  }

  /**
   * Convert key to a secret.
   * @param {(Network|NetworkType)?} network
   * @returns {Base58String}
   */

  toSecret(network) {
    const size = this.getSecretSize();
    const bw = bio.write(size);

    assert(this.privateKey, 'Cannot serialize without private key.');

    network = Network.get(network);

    bw.writeU8(network.keyPrefix.privkey);
    bw.writeBytes(this.privateKey);
    bw.writeU8(1);

    bw.writeChecksum(hash256.digest);

    return base58.encode(bw.render());
  }

  /**
   * Inject properties from serialized secret.
   * @private
   * @param {Base58String} secret
   * @param {(Network|NetworkType)?} network
   */

  fromSecret(data, network) {
    const br = bio.read(base58.decode(data), true);

    const version = br.readU8();

    Network.fromWIF(version, network);

    const key = br.readBytes(32);

    assert(br.readU8() === 1, 'Bad compression flag.');
    br.verifyChecksum(hash256.digest);

    return this.fromPrivate(key);
  }

  /**
   * Instantiate a keyring from a serialized secret.
   * @param {Base58String} secret
   * @param {(Network|NetworkType)?} network
   * @returns {KeyRing}
   */

  static fromSecret(data, network) {
    return new this().fromSecret(data, network);
  }

  /**
   * Get private key.
   * @returns {Buffer} Private key.
   */

  getPrivateKey() {
    if (!this.privateKey)
      return null;

    return this.privateKey;
  }

  /**
   * Get public key.
   * @returns {Buffer}
   */

  getPublicKey() {
    return this.publicKey;
  }

  /**
   * Get redeem script.
   * @returns {Script}
   */

  getScript() {
    return this.script;
  }

  /**
   * Get scripthash.
   * @returns {Buffer}
   */

  getScriptHash() {
    if (!this.script)
      return null;

    if (!this._scriptHash)
      this._scriptHash = this.script.sha3();

    return this._scriptHash;
  }

  /**
   * Get scripthash address.
   * @returns {Address}
   */

  getScriptAddress() {
    if (!this.script)
      return null;

    if (!this._scriptAddress) {
      const hash = this.getScriptHash();
      const addr = Address.fromScripthash(hash);
      this._scriptAddress = addr;
    }

    return this._scriptAddress;
  }

  /**
   * Get public key hash.
   * @returns {Buffer}
   */

  getKeyHash() {
    if (!this._keyHash)
      this._keyHash = blake2b.digest(this.publicKey, 20);

    return this._keyHash;
  }

  /**
   * Get pubkeyhash address.
   * @returns {Address}
   */

  getKeyAddress() {
    if (!this._keyAddress) {
      const hash = this.getKeyHash();
      const addr = Address.fromPubkeyhash(hash);
      this._keyAddress = addr;
    }

    return this._keyAddress;
  }

  /**
   * Get hash.
   * @returns {Buffer}
   */

  getHash() {
    if (this.script)
      return this.getScriptHash();

    return this.getKeyHash();
  }

  /**
   * Get base58 address.
   * @returns {Address}
   */

  getAddress() {
    if (this.script)
      return this.getScriptAddress();

    return this.getKeyAddress();
  }

  /**
   * Test an address hash against hash and program hash.
   * @param {Buffer} hash
   * @returns {Boolean}
   */

  ownHash(hash) {
    if (!hash)
      return false;

    if (hash.equals(this.getKeyHash()))
      return true;

    if (this.script) {
      if (hash.equals(this.getScriptHash()))
        return true;
    }

    return false;
  }

  /**
   * Check whether transaction output belongs to this address.
   * @param {TX|Output} tx - Transaction or Output.
   * @param {Number?} index - Output index.
   * @returns {Boolean}
   */

  ownOutput(tx, index) {
    let output;

    if (tx instanceof Output) {
      output = tx;
    } else {
      output = tx.outputs[index];
      assert(output, 'Output does not exist.');
    }

    return this.ownHash(output.getHash());
  }

  /**
   * Test a hash against script hashes to
   * find the correct redeem script, if any.
   * @param {Buffer} hash
   * @returns {Script|null}
   */

  getRedeem(hash) {
    if (this.script) {
      if (hash.equals(this.getScriptHash()))
        return this.script;
    }

    return null;
  }

  /**
   * Sign a message.
   * @param {Buffer} msg
   * @returns {Buffer} Signature in DER format.
   */

  sign(msg) {
    assert(this.privateKey, 'Cannot sign without private key.');
    return secp256k1.sign(msg, this.privateKey);
  }

  /**
   * Verify a message.
   * @param {Buffer} msg
   * @param {Buffer} sig - Signature in DER format.
   * @returns {Boolean}
   */

  verify(msg, sig) {
    return secp256k1.verify(msg, sig, this.publicKey);
  }

  /**
   * Get witness program version.
   * @returns {Number}
   */

  getVersion() {
    return 0;
  }

  /**
   * Inspect keyring.
   * @returns {Object}
   */

  format() {
    return this.toJSON();
  }

  /**
   * Convert an KeyRing to a more json-friendly object.
   * @returns {Object}
   */

  getJSON(network) {
    return {
      publicKey: this.publicKey.toString('hex'),
      script: this.script ? this.script.toHex() : null,
      address: this.getAddress().toString(network)
    };
  }

  /**
   * Inject properties from json object.
   * @private
   * @param {Object} json
   */

  fromJSON(json) {
    assert(json);
    assert(typeof json.publicKey === 'string');
    assert(!json.script || typeof json.script === 'string');

    this.publicKey = Buffer.from(json.publicKey, 'hex');

    if (json.script)
      this.script = Buffer.from(json.script, 'hex');

    return this;
  }

  /**
   * Calculate serialization size.
   * @returns {Number}
   */

  getSize() {
    let size = 0;
    size += 1;

    if (this.privateKey)
      size += 32;
    else
      size += 33;

    size += this.script
      ? this.script.getVarSize()
      : 1;

    return size;
  }

  /**
   * Write the keyring to a buffer writer.
   * @param {BufferWriter} bw
   */

  write(bw) {
    if (this.privateKey) {
      bw.writeU8(0);
      bw.writeBytes(this.privateKey);
    } else {
      bw.writeU8(1);
      bw.writeBytes(this.publicKey);
    }

    if (this.script)
      bw.writeVarBytes(this.script.encode());
    else
      bw.writeVarint(0);

    return bw;
  }

  /**
   * Inject properties from buffer reader.
   * @private
   * @param {BufferReader} br
   */

  read(br) {
    const type = br.readU8();

    switch (type) {
      case 0: {
        const key = br.readBytes(32);
        this.privateKey = key;
        this.publicKey = secp256k1.publicKeyCreate(key, true);
        break;
      }
      case 1: {
        const key = br.readBytes(33);
        assert(secp256k1.publicKeyVerify(key), 'Invalid public key.');
        this.publicKey = key;
        break;
      }
      default: {
        throw new Error('Invalid key.');
      }
    }

    const script = br.readVarBytes();

    if (script.length > 0)
      this.script = Script.decode(script);

    return this;
  }

  /**
   * Test whether an object is a KeyRing.
   * @param {Object} obj
   * @returns {Boolean}
   */

  static isKeyRing(obj) {
    return obj instanceof KeyRing;
  }
}

/*
 * Helpers
 */

function toKey(opt) {
  if (!opt)
    return opt;

  if (opt.privateKey)
    return opt.privateKey;

  if (opt.publicKey)
    return opt.publicKey;

  return opt;
}

/*
 * Expose
 */

module.exports = KeyRing;

1	/*!
2	* keyring.js - keyring object for hsd
3	* Copyright (c) 2017-2018, Christopher Jeffrey (MIT License).
4	* https://github.com/handshake-org/hsd
5	*/
6
7	'use strict';
8
9	const assert = require('bsert');	1✔
10	const base58 = require('bcrypto/lib/encoding/base58');	1✔
11	const bio = require('bufio');	1✔
12	const blake2b = require('bcrypto/lib/blake2b');	1✔
13	const hash256 = require('bcrypto/lib/hash256');	1✔
14	const Network = require('../protocol/network');	1✔
15	const Script = require('../script/script');	1✔
16	const Address = require('./address');	1✔
17	const Output = require('./output');	1✔
18	const secp256k1 = require('bcrypto/lib/secp256k1');	1✔
19
20	/*
21	* Constants
22	*/
23
24	const ZERO_KEY = Buffer.alloc(33, 0x00);	1✔
25
26	/**
27	* Key Ring
28	* Represents a key ring which amounts to an address.
29	* @alias module:primitives.KeyRing
30	*/
31
32	class KeyRing extends bio.Struct {
33	/**
34	* Create a key ring.
35	* @constructor
36	* @param {Object} options
37	*/
38
39	constructor(options) {
40	super();	3,349✔
41
42	this.publicKey = ZERO_KEY;	3,349✔
43	this.privateKey = null;	3,349✔
44	this.script = null;	3,349✔
45
46	this._keyHash = null;	3,349✔
47	this._keyAddress = null;	3,349✔
48	this._scriptHash = null;	3,349✔
49	this._scriptAddress = null;	3,349✔
50
51	if (options)	3,349✔
52	this.fromOptions(options);	61✔
53	}
54
55	/**
56	* Inject properties from options object.
57	* @private
58	* @param {Object} options
59	*/
60
61	fromOptions(options) {
62	let key = toKey(options);	61✔
63
64	if (Buffer.isBuffer(key))	61!
65	return this.fromKey(key);	61✔
66
67	key = toKey(options.key);	×
68
69	if (options.publicKey)	×
70	key = toKey(options.publicKey);	×
71
72	if (options.privateKey)	×
73	key = toKey(options.privateKey);	×
74
75	const script = options.script;	×
76
77	if (script)	×
78	return this.fromScript(key, script);	×
79
80	return this.fromKey(key);	×
81	}
82
83	/**
84	* Clear cached key/script hashes.
85	*/
86
87	refresh() {
88	this._keyHash = null;	×
89	this._keyAddress = null;	×
90	this._scriptHash = null;	×
91	this._scriptAddress = null;	×
92	return this;	×
93	}
94
95	/**
96	* Inject data from private key.
97	* @private
98	* @param {Buffer} key
99	*/
100
101	fromPrivate(key) {
102	assert(Buffer.isBuffer(key), 'Private key must be a buffer.');	65✔
103	assert(secp256k1.privateKeyVerify(key), 'Not a valid private key.');	65✔
104
105	this.privateKey = key;	65✔
106	this.publicKey = secp256k1.publicKeyCreate(key, true);	65✔
107
108	return this;	65✔
109	}
110
111	/**
112	* Instantiate keyring from a private key.
113	* @param {Buffer} key
114	* @returns {KeyRing}
115	*/
116
117	static fromPrivate(key) {
118	return new this().fromPrivate(key);	4✔
119	}
120
121	/**
122	* Inject data from public key.
123	* @private
124	* @param {Buffer} key
125	*/
126
127	fromPublic(key) {
128	assert(Buffer.isBuffer(key), 'Public key must be a buffer.');	3,284✔
129	assert(secp256k1.publicKeyVerify(key) && key.length === 33,	3,284✔
130	'Not a valid public key.');
131	this.publicKey = key;	3,284✔
132	return this;	3,284✔
133	}
134
135	/**
136	* Generate a keyring.
137	* @private
138	* @returns {KeyRing}
139	*/
140
141	generate() {
UNCOV 142	const key = secp256k1.privateKeyGenerate();	×
UNCOV 143	return this.fromKey(key);	×
144	}
145
146	/**
147	* Generate a keyring.
148	* @returns {KeyRing}
149	*/
150
151	static generate() {
UNCOV 152	return new this().generate();	×
153	}
154
155	/**
156	* Instantiate keyring from a public key.
157	* @param {Buffer} publicKey
158	* @returns {KeyRing}
159	*/
160
161	static fromPublic(key) {
162	return new this().fromPublic(key);	×
163	}
164
165	/**
166	* Inject data from public key.
167	* @private
168	* @param {Buffer} privateKey
169	*/
170
171	fromKey(key) {
172	assert(Buffer.isBuffer(key), 'Key must be a buffer.');	61✔
173
174	if (key.length === 32)	61!
175	return this.fromPrivate(key, true);	61✔
176
UNCOV 177	return this.fromPublic(key);	×
178	}
179
180	/**
181	* Instantiate keyring from a public key.
182	* @param {Buffer} publicKey
183	* @returns {KeyRing}
184	*/
185
186	static fromKey(key) {
187	return new this().fromKey(key);	×
188	}
189
190	/**
191	* Inject data from script.
192	* @private
193	* @param {Buffer} key
194	* @param {Script} script
195	*/
196
197	fromScript(key, script) {
198	assert(script instanceof Script, 'Non-script passed into KeyRing.');	×
199
200	this.fromKey(key);	×
201	this.script = script;	×
202
203	return this;	×
204	}
205
206	/**
207	* Instantiate keyring from script.
208	* @param {Buffer} key
209	* @param {Script} script
210	* @returns {KeyRing}
211	*/
212
213	static fromScript(key, script) {
214	return new this().fromScript(key, script);	×
215	}
216
217	/**
218	* Calculate WIF serialization size.
219	* @returns {Number}
220	*/
221
222	getSecretSize() {
UNCOV 223	let size = 0;	×
224
UNCOV 225	size += 1;	×
UNCOV 226	size += this.privateKey.length;	×
UNCOV 227	size += 1;	×
UNCOV 228	size += 4;	×
229
UNCOV 230	return size;	×
231	}
232
233	/**
234	* Convert key to a secret.
235	* @param {(Network\|NetworkType)?} network
236	* @returns {Base58String}
237	*/
238
239	toSecret(network) {
UNCOV 240	const size = this.getSecretSize();	×
UNCOV 241	const bw = bio.write(size);	×
242
UNCOV 243	assert(this.privateKey, 'Cannot serialize without private key.');	×
244
UNCOV 245	network = Network.get(network);	×
246
UNCOV 247	bw.writeU8(network.keyPrefix.privkey);	×
UNCOV 248	bw.writeBytes(this.privateKey);	×
UNCOV 249	bw.writeU8(1);	×
250
UNCOV 251	bw.writeChecksum(hash256.digest);	×
252
UNCOV 253	return base58.encode(bw.render());	×
254	}
255
256	/**
257	* Inject properties from serialized secret.
258	* @private
259	* @param {Base58String} secret
260	* @param {(Network\|NetworkType)?} network
261	*/
262
263	fromSecret(data, network) {
UNCOV 264	const br = bio.read(base58.decode(data), true);	×
265
UNCOV 266	const version = br.readU8();	×
267
UNCOV 268	Network.fromWIF(version, network);	×
269
UNCOV 270	const key = br.readBytes(32);	×
271
UNCOV 272	assert(br.readU8() === 1, 'Bad compression flag.');	×
UNCOV 273	br.verifyChecksum(hash256.digest);	×
274
UNCOV 275	return this.fromPrivate(key);	×
276	}
277
278	/**
279	* Instantiate a keyring from a serialized secret.
280	* @param {Base58String} secret
281	* @param {(Network\|NetworkType)?} network
282	* @returns {KeyRing}
283	*/
284
285	static fromSecret(data, network) {
UNCOV 286	return new this().fromSecret(data, network);	×
287	}
288
289	/**
290	* Get private key.
291	* @returns {Buffer} Private key.
292	*/
293
294	getPrivateKey() {
295	if (!this.privateKey)	×
296	return null;	×
297
298	return this.privateKey;	×
299	}
300
301	/**
302	* Get public key.
303	* @returns {Buffer}
304	*/
305
306	getPublicKey() {
307	return this.publicKey;	×
308	}
309
310	/**
311	* Get redeem script.
312	* @returns {Script}
313	*/
314
315	getScript() {
316	return this.script;	×
317	}
318
319	/**
320	* Get scripthash.
321	* @returns {Buffer}
322	*/
323
324	getScriptHash() {
UNCOV 325	if (!this.script)	×
326	return null;	×
327
UNCOV 328	if (!this._scriptHash)	×
UNCOV 329	this._scriptHash = this.script.sha3();	×
330
UNCOV 331	return this._scriptHash;	×
332	}
333
334	/**
335	* Get scripthash address.
336	* @returns {Address}
337	*/
338
339	getScriptAddress() {
UNCOV 340	if (!this.script)	×
341	return null;	×
342
UNCOV 343	if (!this._scriptAddress) {	×
UNCOV 344	const hash = this.getScriptHash();	×
UNCOV 345	const addr = Address.fromScripthash(hash);	×
UNCOV 346	this._scriptAddress = addr;	×
347	}
348
UNCOV 349	return this._scriptAddress;	×
350	}
351
352	/**
353	* Get public key hash.
354	* @returns {Buffer}
355	*/
356
357	getKeyHash() {
358	if (!this._keyHash)	3,351✔
359	this._keyHash = blake2b.digest(this.publicKey, 20);	3,349✔
360
361	return this._keyHash;	3,351✔
362	}
363
364	/**
365	* Get pubkeyhash address.
366	* @returns {Address}
367	*/
368
369	getKeyAddress() {
370	if (!this._keyAddress) {	41!
371	const hash = this.getKeyHash();	41✔
372	const addr = Address.fromPubkeyhash(hash);	41✔
373	this._keyAddress = addr;	41✔
374	}
375
376	return this._keyAddress;	41✔
377	}
378
379	/**
380	* Get hash.
381	* @returns {Buffer}
382	*/
383
384	getHash() {
385	if (this.script)	3,310!
UNCOV 386	return this.getScriptHash();	×
387
388	return this.getKeyHash();	3,310✔
389	}
390
391	/**
392	* Get base58 address.
393	* @returns {Address}
394	*/
395
396	getAddress() {
397	if (this.script)	41!
UNCOV 398	return this.getScriptAddress();	×
399
400	return this.getKeyAddress();	41✔
401	}
402
403	/**
404	* Test an address hash against hash and program hash.
405	* @param {Buffer} hash
406	* @returns {Boolean}
407	*/
408
409	ownHash(hash) {
UNCOV 410	if (!hash)	×
411	return false;	×
412
UNCOV 413	if (hash.equals(this.getKeyHash()))	×
UNCOV 414	return true;	×
415
UNCOV 416	if (this.script) {	×
UNCOV 417	if (hash.equals(this.getScriptHash()))	×
UNCOV 418	return true;	×
419	}
420
UNCOV 421	return false;	×
422	}
423
424	/**
425	* Check whether transaction output belongs to this address.
426	* @param {TX\|Output} tx - Transaction or Output.
427	* @param {Number?} index - Output index.
428	* @returns {Boolean}
429	*/
430
431	ownOutput(tx, index) {
432	let output;
433
UNCOV 434	if (tx instanceof Output) {	×
UNCOV 435	output = tx;	×
436	} else {
437	output = tx.outputs[index];	×
438	assert(output, 'Output does not exist.');	×
439	}
440
UNCOV 441	return this.ownHash(output.getHash());	×
442	}
443
444	/**
445	* Test a hash against script hashes to
446	* find the correct redeem script, if any.
447	* @param {Buffer} hash
448	* @returns {Script\|null}
449	*/
450
451	getRedeem(hash) {
UNCOV 452	if (this.script) {	×
UNCOV 453	if (hash.equals(this.getScriptHash()))	×
UNCOV 454	return this.script;	×
455	}
456
457	return null;	×
458	}
459
460	/**
461	* Sign a message.
462	* @param {Buffer} msg
463	* @returns {Buffer} Signature in DER format.
464	*/
465
466	sign(msg) {
UNCOV 467	assert(this.privateKey, 'Cannot sign without private key.');	×
UNCOV 468	return secp256k1.sign(msg, this.privateKey);	×
469	}
470
471	/**
472	* Verify a message.
473	* @param {Buffer} msg
474	* @param {Buffer} sig - Signature in DER format.
475	* @returns {Boolean}
476	*/
477
478	verify(msg, sig) {
479	return secp256k1.verify(msg, sig, this.publicKey);	×
480	}
481
482	/**
483	* Get witness program version.
484	* @returns {Number}
485	*/
486
487	getVersion() {
488	return 0;	3,248✔
489	}
490
491	/**
492	* Inspect keyring.
493	* @returns {Object}
494	*/
495
496	format() {
497	return this.toJSON();	×
498	}
499
500	/**
501	* Convert an KeyRing to a more json-friendly object.
502	* @returns {Object}
503	*/
504
505	getJSON(network) {
506	return {	×
507	publicKey: this.publicKey.toString('hex'),
508	script: this.script ? this.script.toHex() : null,	×
509	address: this.getAddress().toString(network)
510	};
511	}
512
513	/**
514	* Inject properties from json object.
515	* @private
516	* @param {Object} json
517	*/
518
519	fromJSON(json) {
520	assert(json);	×
521	assert(typeof json.publicKey === 'string');	×
522	assert(!json.script \|\| typeof json.script === 'string');	×
523
524	this.publicKey = Buffer.from(json.publicKey, 'hex');	×
525
526	if (json.script)	×
527	this.script = Buffer.from(json.script, 'hex');	×
528
529	return this;	×
530	}
531
532	/**
533	* Calculate serialization size.
534	* @returns {Number}
535	*/
536
537	getSize() {
UNCOV 538	let size = 0;	×
UNCOV 539	size += 1;	×
540
UNCOV 541	if (this.privateKey)	×
UNCOV 542	size += 32;	×
543	else
UNCOV 544	size += 33;	×
545
UNCOV 546	size += this.script	×
547	? this.script.getVarSize()
548	: 1;
549
UNCOV 550	return size;	×
551	}
552
553	/**
554	* Write the keyring to a buffer writer.
555	* @param {BufferWriter} bw
556	*/
557
558	write(bw) {
UNCOV 559	if (this.privateKey) {	×
UNCOV 560	bw.writeU8(0);	×
UNCOV 561	bw.writeBytes(this.privateKey);	×
562	} else {
UNCOV 563	bw.writeU8(1);	×
UNCOV 564	bw.writeBytes(this.publicKey);	×
565	}
566
UNCOV 567	if (this.script)	×
UNCOV 568	bw.writeVarBytes(this.script.encode());	×
569	else
UNCOV 570	bw.writeVarint(0);	×
571
UNCOV 572	return bw;	×
573	}
574
575	/**
576	* Inject properties from buffer reader.
577	* @private
578	* @param {BufferReader} br
579	*/
580
581	read(br) {
UNCOV 582	const type = br.readU8();	×
583
UNCOV 584	switch (type) {	×
585	case 0: {
UNCOV 586	const key = br.readBytes(32);	×
UNCOV 587	this.privateKey = key;	×
UNCOV 588	this.publicKey = secp256k1.publicKeyCreate(key, true);	×
UNCOV 589	break;	×
590	}
591	case 1: {
UNCOV 592	const key = br.readBytes(33);	×
UNCOV 593	assert(secp256k1.publicKeyVerify(key), 'Invalid public key.');	×
UNCOV 594	this.publicKey = key;	×
UNCOV 595	break;	×
596	}
597	default: {
598	throw new Error('Invalid key.');	×
599	}
600	}
601
UNCOV 602	const script = br.readVarBytes();	×
603
UNCOV 604	if (script.length > 0)	×
UNCOV 605	this.script = Script.decode(script);	×
606
UNCOV 607	return this;	×
608	}
609
610	/**
611	* Test whether an object is a KeyRing.
612	* @param {Object} obj
613	* @returns {Boolean}
614	*/
615
616	static isKeyRing(obj) {
617	return obj instanceof KeyRing;	×
618	}
619	}
620
621	/*
622	* Helpers
623	*/
624
625	function toKey(opt) {
626	if (!opt)	61!
627	return opt;	×
628
629	if (opt.privateKey)	61!
630	return opt.privateKey;	61✔
631
UNCOV 632	if (opt.publicKey)	×
UNCOV 633	return opt.publicKey;	×
634
UNCOV 635	return opt;	×
636	}
637
638	/*
639	* Expose
640	*/
641
642	module.exports = KeyRing;	1✔

handshake-org / hsd / 8452447998

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous