12791301410

Committed 15 Jan 2025 03:12PM UTC coverage: 71.261% (+0.02%) from 71.24%

Build # 12791301410

Build Type

push

github

Committed by

nodech

Commit Message

Merge PR #918 from 'nodech/wallet-doc-updates'

Run Details

8059 of 13158 branches covered (61.25%)

Branch coverage included in aggregate %.

91 of 94 new or added lines in 6 files covered. (96.81%)

8 existing lines in 4 files now uncovered.

25735 of 34265 relevant lines covered (75.11%)

34481.61 hits per line

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

40.79

/lib/hd/hd.js

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

'use strict';

const assert = require('bsert');
const common = require('./common');
const Mnemonic = require('./mnemonic');
const HDPrivateKey = require('./private');
const HDPublicKey = require('./public');
const wordlist = require('./wordlist');

/** @typedef {import('../protocol/network')} Network */
/** @typedef {import('../types').Base58String} Base58String */
/** @typedef {import('../types').NetworkType} NetworkType */

/**
 * @exports hd
 */

const HD = exports;

/**
 * Instantiate an HD key (public or private) from an base58 string.
 * @param {Base58String} xkey
 * @param {(Network|NetworkType)?} [network]
 * @returns {HDPrivateKey|HDPublicKey}
 */

HD.fromBase58 = function fromBase58(xkey, network) {
  if (HDPrivateKey.isBase58(xkey))
    return HDPrivateKey.fromBase58(xkey, network);
  return HDPublicKey.fromBase58(xkey, network);
};

/**
 * Generate an {@link HDPrivateKey}.
 * @param {Object} options
 * @param {Buffer?} options.privateKey
 * @param {Buffer?} options.entropy
 * @returns {HDPrivateKey}
 */

HD.generate = function generate() {
  return HDPrivateKey.generate();
};

/**
 * Generate an {@link HDPrivateKey} from a seed.
 * @param {Object|Mnemonic|Buffer} options - seed,
 * mnemonic, mnemonic options.
 * @returns {HDPrivateKey}
 */

HD.fromSeed = function fromSeed(options) {
  return HDPrivateKey.fromSeed(options);
};

/**
 * Instantiate an hd private key from a mnemonic.
 * @param {Mnemonic} mnemonic
 * @param {String?} [bip39Passphrase]
 * @returns {HDPrivateKey}
 */

HD.fromMnemonic = function fromMnemonic(mnemonic, bip39Passphrase) {
  return HDPrivateKey.fromMnemonic(mnemonic, bip39Passphrase);
};

/**
 * Instantiate an HD key from a jsonified key object.
 * @param {Object} json - The jsonified transaction object.
 * @param {Network?} network
 * @returns {HDPrivateKey|HDPublicKey}
 */

HD.fromJSON = function fromJSON(json, network) {
  if (json.xprivkey)
    return HDPrivateKey.fromJSON(json, network);
  return HDPublicKey.fromJSON(json, network);
};

/**
 * Instantiate an HD key from serialized data.
 * @param {Buffer} data
 * @param {(Network|NetworkType)?} [network]
 * @returns {HDPrivateKey|HDPublicKey}
 */

HD.decode = function decode(data, network) {
  if (HDPrivateKey.isRaw(data, network))
    return HDPrivateKey.decode(data, network);
  return HDPublicKey.decode(data, network);
};

/**
 * Generate an hdkey from any number of options.
 * @param {Object|Mnemonic|Buffer} options - mnemonic, mnemonic
 * options, seed, or base58 key.
 * @param {(Network|NetworkType)?} network
 * @returns {HDPrivateKey|HDPublicKey}
 */

HD.from = function from(options, network) {
  assert(options, 'Options required.');

  if (HD.isHD(options))
    return options;

  if (HD.isBase58(options, network))
    return HD.fromBase58(options, network);

  if (HD.isRaw(options, network))
    return HD.decode(options, network);

  if (options && typeof options === 'object')
    return HD.fromMnemonic(options);

  throw new Error('Cannot create HD key from bad options.');
};

/**
 * Test whether an object is in the form of a base58 hd key.
 * @param {String} data
 * @param {(Network|NetworkType)?} [network]
 * @returns {Boolean}
 */

HD.isBase58 = function isBase58(data, network) {
  return HDPrivateKey.isBase58(data, network)
    || HDPublicKey.isBase58(data, network);
};

/**
 * Test whether an object is in the form of a serialized hd key.
 * @param {Buffer} data
 * @param {(Network|NetworkType)?} [network]
 * @returns {Boolean}
 */

HD.isRaw = function isRaw(data, network) {
  return HDPrivateKey.isRaw(data, network)
    || HDPublicKey.isRaw(data, network);
};

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

HD.isHD = function isHD(obj) {
  return HDPrivateKey.isHDPrivateKey(obj)
    || HDPublicKey.isHDPublicKey(obj);
};

/**
 * Test whether an object is an HD private key.
 * @param {Object} obj
 * @returns {Boolean}
 */

HD.isPrivate = function isPrivate(obj) {
  return HDPrivateKey.isHDPrivateKey(obj);
};

/**
 * Test whether an object is an HD public key.
 * @param {Object} obj
 * @returns {Boolean}
 */

HD.isPublic = function isPublic(obj) {
  return HDPublicKey.isHDPublicKey(obj);
};

/*
 * Expose
 */

HD.common = common;
HD.HD = HD;
HD.Mnemonic = Mnemonic;
HD.PrivateKey = HDPrivateKey;
HD.PublicKey = HDPublicKey;
HD.HDPrivateKey = HDPrivateKey;
HD.HDPublicKey = HDPublicKey;
HD.wordlist = wordlist;

1	/*!
2	* hd.js - hd keys 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 common = require('./common');	1✔
11	const Mnemonic = require('./mnemonic');	1✔
12	const HDPrivateKey = require('./private');	1✔
13	const HDPublicKey = require('./public');	1✔
14	const wordlist = require('./wordlist');	1✔
15
16	/** @typedef {import('../protocol/network')} Network */
17	/** @typedef {import('../types').Base58String} Base58String */
18	/** @typedef {import('../types').NetworkType} NetworkType */
19
20	/**
21	* @exports hd
22	*/
23
24	const HD = exports;	1✔
25
26	/**
27	* Instantiate an HD key (public or private) from an base58 string.
28	* @param {Base58String} xkey
29	* @param {(Network\|NetworkType)?} [network]
30	* @returns {HDPrivateKey\|HDPublicKey}
31	*/
32
33	HD.fromBase58 = function fromBase58(xkey, network) {	1✔
34	if (HDPrivateKey.isBase58(xkey))	×
35	return HDPrivateKey.fromBase58(xkey, network);	×
36	return HDPublicKey.fromBase58(xkey, network);	×
37	};
38
39	/**
40	* Generate an {@link HDPrivateKey}.
41	* @param {Object} options
42	* @param {Buffer?} options.privateKey
43	* @param {Buffer?} options.entropy
44	* @returns {HDPrivateKey}
45	*/
46
47	HD.generate = function generate() {	1✔
48	return HDPrivateKey.generate();	1✔
49	};
50
51	/**
52	* Generate an {@link HDPrivateKey} from a seed.
53	* @param {Object\|Mnemonic\|Buffer} options - seed,
54	* mnemonic, mnemonic options.
55	* @returns {HDPrivateKey}
56	*/
57
58	HD.fromSeed = function fromSeed(options) {	1✔
59	return HDPrivateKey.fromSeed(options);	×
60	};
61
62	/**
63	* Instantiate an hd private key from a mnemonic.
64	* @param {Mnemonic} mnemonic
65	* @param {String?} [bip39Passphrase]
66	* @returns {HDPrivateKey}
67	*/
68
69	HD.fromMnemonic = function fromMnemonic(mnemonic, bip39Passphrase) {	1✔
UNCOV 70	return HDPrivateKey.fromMnemonic(mnemonic, bip39Passphrase);	×
71	};
72
73	/**
74	* Instantiate an HD key from a jsonified key object.
75	* @param {Object} json - The jsonified transaction object.
76	* @param {Network?} network
77	* @returns {HDPrivateKey\|HDPublicKey}
78	*/
79
80	HD.fromJSON = function fromJSON(json, network) {	1✔
81	if (json.xprivkey)	1!
82	return HDPrivateKey.fromJSON(json, network);	1✔
83	return HDPublicKey.fromJSON(json, network);	×
84	};
85
86	/**
87	* Instantiate an HD key from serialized data.
88	* @param {Buffer} data
89	* @param {(Network\|NetworkType)?} [network]
90	* @returns {HDPrivateKey\|HDPublicKey}
91	*/
92
93	HD.decode = function decode(data, network) {	1✔
94	if (HDPrivateKey.isRaw(data, network))	×
95	return HDPrivateKey.decode(data, network);	×
96	return HDPublicKey.decode(data, network);	×
97	};
98
99	/**
100	* Generate an hdkey from any number of options.
101	* @param {Object\|Mnemonic\|Buffer} options - mnemonic, mnemonic
102	* options, seed, or base58 key.
103	* @param {(Network\|NetworkType)?} network
104	* @returns {HDPrivateKey\|HDPublicKey}
105	*/
106
107	HD.from = function from(options, network) {	1✔
108	assert(options, 'Options required.');	×
109
110	if (HD.isHD(options))	×
111	return options;	×
112
113	if (HD.isBase58(options, network))	×
114	return HD.fromBase58(options, network);	×
115
116	if (HD.isRaw(options, network))	×
117	return HD.decode(options, network);	×
118
119	if (options && typeof options === 'object')	×
120	return HD.fromMnemonic(options);	×
121
122	throw new Error('Cannot create HD key from bad options.');	×
123	};
124
125	/**
126	* Test whether an object is in the form of a base58 hd key.
127	* @param {String} data
128	* @param {(Network\|NetworkType)?} [network]
129	* @returns {Boolean}
130	*/
131
132	HD.isBase58 = function isBase58(data, network) {	1✔
133	return HDPrivateKey.isBase58(data, network)	×
134	\|\| HDPublicKey.isBase58(data, network);
135	};
136
137	/**
138	* Test whether an object is in the form of a serialized hd key.
139	* @param {Buffer} data
140	* @param {(Network\|NetworkType)?} [network]
141	* @returns {Boolean}
142	*/
143
144	HD.isRaw = function isRaw(data, network) {	1✔
145	return HDPrivateKey.isRaw(data, network)	×
146	\|\| HDPublicKey.isRaw(data, network);
147	};
148
149	/**
150	* Test whether an object is an HD key.
151	* @param {Object} obj
152	* @returns {Boolean}
153	*/
154
155	HD.isHD = function isHD(obj) {	1✔
156	return HDPrivateKey.isHDPrivateKey(obj)	×
157	\|\| HDPublicKey.isHDPublicKey(obj);
158	};
159
160	/**
161	* Test whether an object is an HD private key.
162	* @param {Object} obj
163	* @returns {Boolean}
164	*/
165
166	HD.isPrivate = function isPrivate(obj) {	1✔
UNCOV 167	return HDPrivateKey.isHDPrivateKey(obj);	×
168	};
169
170	/**
171	* Test whether an object is an HD public key.
172	* @param {Object} obj
173	* @returns {Boolean}
174	*/
175
176	HD.isPublic = function isPublic(obj) {	1✔
UNCOV 177	return HDPublicKey.isHDPublicKey(obj);	×
178	};
179
180	/*
181	* Expose
182	*/
183
184	HD.common = common;	1✔
185	HD.HD = HD;	1✔
186	HD.Mnemonic = Mnemonic;	1✔
187	HD.PrivateKey = HDPrivateKey;	1✔
188	HD.PublicKey = HDPublicKey;	1✔
189	HD.HDPrivateKey = HDPrivateKey;	1✔
190	HD.HDPublicKey = HDPublicKey;	1✔
191	HD.wordlist = wordlist;	1✔

handshake-org / hsd / 12791301410

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