11142522588

Committed 02 Oct 2024 10:56AM UTC coverage: 70.04% (+0.007%) from 70.033%

Build # 11142522588

Build Type

push

github

Committed by

nodech

Commit Message

Merge PR #902 from 'nodech/update-types'

Run Details

7761 of 12916 branches covered (60.09%)

Branch coverage included in aggregate %.

67 of 92 new or added lines in 25 files covered. (72.83%)

8 existing lines in 5 files now uncovered.

24790 of 33559 relevant lines covered (73.87%)

34019.86 hits per line

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

77.66

/lib/coins/coinview.js

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

'use strict';

const {BufferMap} = require('buffer-map');
const Coins = require('./coins');
const UndoCoins = require('./undocoins');
const CoinEntry = require('./coinentry');
const View = require('../covenants/view');
const {BitView} = require('../covenants/bitfield');

/** @typedef {import('bufio').BufferReader} BufferReader */
/** @typedef {import('../types').Hash} Hash */
/** @typedef {import('../types').BufioWriter} BufioWriter */
/** @typedef {import('../primitives/coin')} Coin */
/** @typedef {import('../primitives/input')} Input */
/** @typedef {import('../primitives/output')} Output */
/** @typedef {import('../primitives/tx')} TX */
/** @typedef {import('../primitives/outpoint')} Outpoint */
/** @typedef {import('../wallet/path')} Path */
/** @typedef {import('../blockchain/chaindb')} ChainDB */

/**
 * Coin View
 * Represents a coin viewpoint:
 * a snapshot of {@link Coins} objects.
 * @alias module:coins.CoinView
 * @property {Object} map
 * @property {UndoCoins} undo
 */

class CoinView extends View {
  /**
   * Create a coin view.
   * @constructor
   */

  constructor() {
    super();
    this.map = new BufferMap();
    this.undo = new UndoCoins();
    this.bits = new BitView();
  }

  /**
   * Get coins.
   * @param {Hash} hash
   * @returns {Coins} coins
   */

  get(hash) {
    return this.map.get(hash);
  }

  /**
   * Test whether the view has an entry.
   * @param {Hash} hash
   * @returns {Boolean}
   */

  has(hash) {
    return this.map.has(hash);
  }

  /**
   * Add coins to the collection.
   * @param {Hash} hash
   * @param {Coins} coins
   * @returns {Coins}
   */

  add(hash, coins) {
    this.map.set(hash, coins);
    return coins;
  }

  /**
   * Ensure existence of coins object in the collection.
   * @param {Hash} hash
   * @returns {Coins}
   */

  ensure(hash) {
    const coins = this.map.get(hash);

    if (coins)
      return coins;

    return this.add(hash, new Coins());
  }

  /**
   * Remove coins from the collection.
   * @param {Hash} hash
   * @returns {Coins?}
   */

  remove(hash) {
    const coins = this.map.get(hash);

    if (!coins)
      return null;

    this.map.delete(hash);

    return coins;
  }

  /**
   * Add a tx to the collection.
   * @param {TX} tx
   * @param {Number} height
   * @returns {Coins}
   */

  addTX(tx, height) {
    const hash = tx.hash();
    const coins = Coins.fromTX(tx, height);
    return this.add(hash, coins);
  }

  /**
   * Remove a tx from the collection.
   * @param {TX} tx
   * @param {Number} height
   * @returns {Coins}
   */

  removeTX(tx, height) {
    const hash = tx.hash();
    const coins = Coins.fromTX(tx, height);

    for (const coin of coins.outputs.values())
      coin.spent = true;

    return this.add(hash, coins);
  }

  /**
   * Add an entry to the collection.
   * @param {Outpoint} prevout
   * @param {CoinEntry} coin
   * @returns {CoinEntry|null}
   */

  addEntry(prevout, coin) {
    const {hash, index} = prevout;
    const coins = this.ensure(hash);
    return coins.add(index, coin);
  }

  /**
   * Add a coin to the collection.
   * @param {Coin} coin
   * @returns {CoinEntry|null}
   */

  addCoin(coin) {
    const coins = this.ensure(coin.hash);
    return coins.addCoin(coin);
  }

  /**
   * Add an output to the collection.
   * @param {Outpoint} prevout
   * @param {Output} output
   * @returns {CoinEntry|null}
   */

  addOutput(prevout, output) {
    const {hash, index} = prevout;
    const coins = this.ensure(hash);
    return coins.addOutput(index, output);
  }

  /**
   * Add an output to the collection by output index.
   * @param {TX} tx
   * @param {Number} index
   * @param {Number} height
   * @returns {CoinEntry|null}
   */

  addIndex(tx, index, height) {
    const hash = tx.hash();
    const coins = this.ensure(hash);
    return coins.addIndex(tx, index, height);
  }

  /**
   * Spend an output.
   * @param {Outpoint} prevout
   * @returns {CoinEntry|null}
   */

  spendEntry(prevout) {
    const {hash, index} = prevout;
    const coins = this.get(hash);

    if (!coins)
      return null;

    const coin = coins.spend(index);

    if (!coin)
      return null;

    this.undo.push(coin);

    return coin;
  }

  /**
   * Remove an output.
   * @param {Outpoint} prevout
   * @returns {CoinEntry|null}
   */

  removeEntry(prevout) {
    const {hash, index} = prevout;
    const coins = this.get(hash);

    if (!coins)
      return null;

    return coins.remove(index);
  }

  /**
   * Test whether the view has an entry by prevout.
   * @param {Outpoint} prevout
   * @returns {Boolean}
   */

  hasEntry(prevout) {
    const {hash, index} = prevout;
    const coins = this.get(hash);

    if (!coins)
      return false;

    return coins.has(index);
  }

  /**
   * Get a single entry by prevout.
   * @param {Outpoint} prevout
   * @returns {CoinEntry|null}
   */

  getEntry(prevout) {
    const {hash, index} = prevout;
    const coins = this.get(hash);

    if (!coins)
      return null;

    return coins.get(index);
  }

  /**
   * Test whether an entry has been spent by prevout.
   * @param {Outpoint} prevout
   * @returns {Boolean}
   */

  isUnspent(prevout) {
    const {hash, index} = prevout;
    const coins = this.get(hash);

    if (!coins)
      return false;

    return coins.isUnspent(index);
  }

  /**
   * Get a single coin by prevout.
   * @param {Outpoint} prevout
   * @returns {Coin|null}
   */

  getCoin(prevout) {
    const coins = this.get(prevout.hash);

    if (!coins)
      return null;

    return coins.getCoin(prevout);
  }

  /**
   * Get a single output by prevout.
   * @param {Outpoint} prevout
   * @returns {Output|null}
   */

  getOutput(prevout) {
    const {hash, index} = prevout;
    const coins = this.get(hash);

    if (!coins)
      return null;

    return coins.getOutput(index);
  }

  /**
   * Get an HD path by prevout.
   * Implemented in {@link WalletCoinView}.
   * @param {Outpoint} prevout
   * @returns {null}
   */

  getPath(prevout) {
    return null;
  }

  /**
   * Get coins height by prevout.
   * @param {Outpoint} prevout
   * @returns {Number}
   */

  getHeight(prevout) {
    const coin = this.getEntry(prevout);

    if (!coin)
      return -1;

    return coin.height;
  }

  /**
   * Get coins coinbase flag by prevout.
   * @param {Outpoint} prevout
   * @returns {Boolean}
   */

  isCoinbase(prevout) {
    const coin = this.getEntry(prevout);

    if (!coin)
      return false;

    return coin.coinbase;
  }

  /**
   * Test whether the view has an entry by input.
   * @param {Input} input
   * @returns {Boolean}
   */

  hasEntryFor(input) {
    return this.hasEntry(input.prevout);
  }

  /**
   * Get a single entry by input.
   * @param {Input} input
   * @returns {CoinEntry|null}
   */

  getEntryFor(input) {
    return this.getEntry(input.prevout);
  }

  /**
   * Test whether an entry has been spent by input.
   * @param {Input} input
   * @returns {Boolean}
   */

  isUnspentFor(input) {
    return this.isUnspent(input.prevout);
  }

  /**
   * Get a single coin by input.
   * @param {Input} input
   * @returns {Coin|null}
   */

  getCoinFor(input) {
    return this.getCoin(input.prevout);
  }

  /**
   * Get a single output by input.
   * @param {Input} input
   * @returns {Output|null}
   */

  getOutputFor(input) {
    return this.getOutput(input.prevout);
  }

  /**
   * Get a single path by input.
   * Implemented in {@link WalletCoinView}.
   * @param {Input} input
   * @returns {null}
   */

  getPathFor(input) {
    return null;
  }

  /**
   * Add an HD path to the collection.
   * Implemented in {@link WalletCoinView}
   * @param {Outpoint} prevout
   * @param {Path} path
   * @returns {Path|null}
   */

  addPath(prevout, path) {
    return null;
  }

  /**
   * Get coins height by input.
   * @param {Input} input
   * @returns {Number}
   */

  getHeightFor(input) {
    return this.getHeight(input.prevout);
  }

  /**
   * Get coins coinbase flag by input.
   * @param {Input} input
   * @returns {Boolean}
   */

  isCoinbaseFor(input) {
    return this.isCoinbase(input.prevout);
  }

  /**
   * Retrieve coins from database.
   * @method
   * @param {ChainDB} db
   * @param {Outpoint} prevout
   * @returns {Promise} - Returns {@link CoinEntry}.
   */

  async readCoin(db, prevout) {
    const cache = this.getEntry(prevout);

    if (cache)
      return cache;

    const coin = await db.readCoin(prevout);

    if (!coin)
      return null;

    return this.addEntry(prevout, coin);
  }

  /**
   * Read all input coins into unspent map.
   * @method
   * @param {ChainDB} db
   * @param {TX} tx
   * @returns {Promise} - Returns {Boolean}.
   */

  async readInputs(db, tx) {
    let found = true;

    for (const {prevout} of tx.inputs) {
      if (!await this.readCoin(db, prevout))
        found = false;
    }

    return found;
  }

  /**
   * Spend coins for transaction.
   * @method
   * @param {ChainDB} db
   * @param {TX} tx
   * @returns {Promise} - Returns {Boolean}.
   */

  async spendInputs(db, tx) {
    let i = 0;

    while (i < tx.inputs.length) {
      const len = Math.min(i + 4, tx.inputs.length);
      const jobs = [];

      for (; i < len; i++) {
        const {prevout} = tx.inputs[i];
        jobs.push(this.readCoin(db, prevout));
      }

      const coins = await Promise.all(jobs);

      for (const coin of coins) {
        if (!coin || coin.spent)
          return false;

        coin.spent = true;
        this.undo.push(coin);
      }
    }

    return true;
  }

  /**
   * Calculate serialization size.
   * @param {TX} tx
   * @returns {Number}
   */

  getSize(tx) {
    let size = 0;

    size += tx.inputs.length;

    for (const {prevout} of tx.inputs) {
      const coin = this.getEntry(prevout);

      if (!coin)
        continue;

      size += coin.getSize();
    }

    return size;
  }

  /**
   * Write coin data to buffer writer
   * as it pertains to a transaction.
   * @param {BufioWriter} bw
   * @param {TX} tx
   * @returns {BufioWriter}
   */

  write(bw, tx) {
    for (const {prevout} of tx.inputs) {
      const coin = this.getEntry(prevout);

      if (!coin) {
        bw.writeU8(0);
        continue;
      }

      bw.writeU8(1);
      coin.write(bw);
    }

    return bw;
  }

  /**
   * Read serialized view data from a buffer
   * reader as it pertains to a transaction.
   * @param {BufferReader} br
   * @param {TX} tx
   */

  read(br, tx) {
    for (const {prevout} of tx.inputs) {
      if (br.readU8() === 0)
        continue;

      const coin = CoinEntry.read(br);

      this.addEntry(prevout, coin);
    }

    return this;
  }

  /**
   * Read serialized view data from a buffer
   * reader as it pertains to a transaction.
   * @param {BufferReader} br
   * @param {TX} tx
   * @returns {CoinView}
   */

  static read(br, tx) {
    return new this().read(br, tx);
  }
}

/*
 * Expose
 */

module.exports = CoinView;

1	/*!
2	* coinview.js - coin viewpoint 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 {BufferMap} = require('buffer-map');	70✔
10	const Coins = require('./coins');	70✔
11	const UndoCoins = require('./undocoins');	70✔
12	const CoinEntry = require('./coinentry');	70✔
13	const View = require('../covenants/view');	70✔
14	const {BitView} = require('../covenants/bitfield');	70✔
15
16	/** @typedef {import('bufio').BufferReader} BufferReader */
17	/** @typedef {import('../types').Hash} Hash */
18	/** @typedef {import('../types').BufioWriter} BufioWriter */
19	/** @typedef {import('../primitives/coin')} Coin */
20	/** @typedef {import('../primitives/input')} Input */
21	/** @typedef {import('../primitives/output')} Output */
22	/** @typedef {import('../primitives/tx')} TX */
23	/** @typedef {import('../primitives/outpoint')} Outpoint */
24	/** @typedef {import('../wallet/path')} Path */
25	/** @typedef {import('../blockchain/chaindb')} ChainDB */
26
27	/**
28	* Coin View
29	* Represents a coin viewpoint:
30	* a snapshot of {@link Coins} objects.
31	* @alias module:coins.CoinView
32	* @property {Object} map
33	* @property {UndoCoins} undo
34	*/
35
36	class CoinView extends View {
37	/**
38	* Create a coin view.
39	* @constructor
40	*/
41
42	constructor() {
43	super();	104,477✔
44	this.map = new BufferMap();	104,477✔
45	this.undo = new UndoCoins();	104,477✔
46	this.bits = new BitView();	104,477✔
47	}
48
49	/**
50	* Get coins.
51	* @param {Hash} hash
52	* @returns {Coins} coins
53	*/
54
55	get(hash) {
56	return this.map.get(hash);	9,464,515✔
57	}
58
59	/**
60	* Test whether the view has an entry.
61	* @param {Hash} hash
62	* @returns {Boolean}
63	*/
64
65	has(hash) {
66	return this.map.has(hash);	×
67	}
68
69	/**
70	* Add coins to the collection.
71	* @param {Hash} hash
72	* @param {Coins} coins
73	* @returns {Coins}
74	*/
75
76	add(hash, coins) {
77	this.map.set(hash, coins);	108,705✔
78	return coins;	108,705✔
79	}
80
81	/**
82	* Ensure existence of coins object in the collection.
83	* @param {Hash} hash
84	* @returns {Coins}
85	*/
86
87	ensure(hash) {
88	const coins = this.map.get(hash);	132,278✔
89
90	if (coins)	132,278✔
91	return coins;	56,631✔
92
93	return this.add(hash, new Coins());	75,647✔
94	}
95
96	/**
97	* Remove coins from the collection.
98	* @param {Hash} hash
99	* @returns {Coins?}
100	*/
101
102	remove(hash) {
103	const coins = this.map.get(hash);	×
104
105	if (!coins)	×
106	return null;	×
107
108	this.map.delete(hash);	×
109
110	return coins;	×
111	}
112
113	/**
114	* Add a tx to the collection.
115	* @param {TX} tx
116	* @param {Number} height
117	* @returns {Coins}
118	*/
119
120	addTX(tx, height) {
121	const hash = tx.hash();	28,161✔
122	const coins = Coins.fromTX(tx, height);	28,161✔
123	return this.add(hash, coins);	28,161✔
124	}
125
126	/**
127	* Remove a tx from the collection.
128	* @param {TX} tx
129	* @param {Number} height
130	* @returns {Coins}
131	*/
132
133	removeTX(tx, height) {
134	const hash = tx.hash();	4,897✔
135	const coins = Coins.fromTX(tx, height);	4,897✔
136
137	for (const coin of coins.outputs.values())	4,897✔
138	coin.spent = true;	29,217✔
139
140	return this.add(hash, coins);	4,897✔
141	}
142
143	/**
144	* Add an entry to the collection.
145	* @param {Outpoint} prevout
146	* @param {CoinEntry} coin
147	* @returns {CoinEntry\|null}
148	*/
149
150	addEntry(prevout, coin) {
151	const {hash, index} = prevout;	39,465✔
152	const coins = this.ensure(hash);	39,465✔
153	return coins.add(index, coin);	39,465✔
154	}
155
156	/**
157	* Add a coin to the collection.
158	* @param {Coin} coin
159	* @returns {CoinEntry\|null}
160	*/
161
162	addCoin(coin) {
163	const coins = this.ensure(coin.hash);	70,497✔
164	return coins.addCoin(coin);	70,497✔
165	}
166
167	/**
168	* Add an output to the collection.
169	* @param {Outpoint} prevout
170	* @param {Output} output
171	* @returns {CoinEntry\|null}
172	*/
173
174	addOutput(prevout, output) {
175	const {hash, index} = prevout;	15,217✔
176	const coins = this.ensure(hash);	15,217✔
177	return coins.addOutput(index, output);	15,217✔
178	}
179
180	/**
181	* Add an output to the collection by output index.
182	* @param {TX} tx
183	* @param {Number} index
184	* @param {Number} height
185	* @returns {CoinEntry\|null}
186	*/
187
188	addIndex(tx, index, height) {
189	const hash = tx.hash();	7,099✔
190	const coins = this.ensure(hash);	7,099✔
191	return coins.addIndex(tx, index, height);	7,099✔
192	}
193
194	/**
195	* Spend an output.
196	* @param {Outpoint} prevout
197	* @returns {CoinEntry\|null}
198	*/
199
200	spendEntry(prevout) {
201	const {hash, index} = prevout;	1✔
202	const coins = this.get(hash);	1✔
203
204	if (!coins)	1!
205	return null;	×
206
207	const coin = coins.spend(index);	1✔
208
209	if (!coin)	1!
210	return null;	×
211
212	this.undo.push(coin);	1✔
213
214	return coin;	1✔
215	}
216
217	/**
218	* Remove an output.
219	* @param {Outpoint} prevout
220	* @returns {CoinEntry\|null}
221	*/
222
223	removeEntry(prevout) {
224	const {hash, index} = prevout;	×
225	const coins = this.get(hash);	×
226
227	if (!coins)	×
228	return null;	×
229
230	return coins.remove(index);	×
231	}
232
233	/**
234	* Test whether the view has an entry by prevout.
235	* @param {Outpoint} prevout
236	* @returns {Boolean}
237	*/
238
239	hasEntry(prevout) {
240	const {hash, index} = prevout;	119,969✔
241	const coins = this.get(hash);	119,969✔
242
243	if (!coins)	119,969✔
244	return false;	33,858✔
245
246	return coins.has(index);	86,111✔
247	}
248
249	/**
250	* Get a single entry by prevout.
251	* @param {Outpoint} prevout
252	* @returns {CoinEntry\|null}
253	*/
254
255	getEntry(prevout) {
256	const {hash, index} = prevout;	153,126✔
257	const coins = this.get(hash);	153,126✔
258
259	if (!coins)	153,126✔
260	return null;	25,595✔
261
262	return coins.get(index);	127,531✔
263	}
264
265	/**
266	* Test whether an entry has been spent by prevout.
267	* @param {Outpoint} prevout
268	* @returns {Boolean}
269	*/
270
271	isUnspent(prevout) {
272	const {hash, index} = prevout;	×
273	const coins = this.get(hash);	×
274
275	if (!coins)	×
276	return false;	×
277
278	return coins.isUnspent(index);	×
279	}
280
281	/**
282	* Get a single coin by prevout.
283	* @param {Outpoint} prevout
284	* @returns {Coin\|null}
285	*/
286
287	getCoin(prevout) {
288	const coins = this.get(prevout.hash);	125✔
289
290	if (!coins)	125✔
291	return null;	1✔
292
293	return coins.getCoin(prevout);	124✔
294	}
295
296	/**
297	* Get a single output by prevout.
298	* @param {Outpoint} prevout
299	* @returns {Output\|null}
300	*/
301
302	getOutput(prevout) {
303	const {hash, index} = prevout;	9,191,290✔
304	const coins = this.get(hash);	9,191,290✔
305
306	if (!coins)	9,191,290✔
307	return null;	28,628✔
308
309	return coins.getOutput(index);	9,162,662✔
310	}
311
312	/**
313	* Get an HD path by prevout.
314	* Implemented in {@link WalletCoinView}.
315	* @param {Outpoint} prevout
316	* @returns {null}
317	*/
318
319	getPath(prevout) {
320	return null;	×
321	}
322
323	/**
324	* Get coins height by prevout.
325	* @param {Outpoint} prevout
326	* @returns {Number}
327	*/
328
329	getHeight(prevout) {
330	const coin = this.getEntry(prevout);	21,291✔
331
332	if (!coin)	21,291✔
333	return -1;	1✔
334
335	return coin.height;	21,290✔
336	}
337
338	/**
339	* Get coins coinbase flag by prevout.
340	* @param {Outpoint} prevout
341	* @returns {Boolean}
342	*/
343
344	isCoinbase(prevout) {
345	const coin = this.getEntry(prevout);	3,080✔
346
347	if (!coin)	3,080!
348	return false;	×
349
350	return coin.coinbase;	3,080✔
351	}
352
353	/**
354	* Test whether the view has an entry by input.
355	* @param {Input} input
356	* @returns {Boolean}
357	*/
358
359	hasEntryFor(input) {
360	return this.hasEntry(input.prevout);	×
361	}
362
363	/**
364	* Get a single entry by input.
365	* @param {Input} input
366	* @returns {CoinEntry\|null}
367	*/
368
369	getEntryFor(input) {
370	return this.getEntry(input.prevout);	×
371	}
372
373	/**
374	* Test whether an entry has been spent by input.
375	* @param {Input} input
376	* @returns {Boolean}
377	*/
378
379	isUnspentFor(input) {
380	return this.isUnspent(input.prevout);	×
381	}
382
383	/**
384	* Get a single coin by input.
385	* @param {Input} input
386	* @returns {Coin\|null}
387	*/
388
389	getCoinFor(input) {
390	return this.getCoin(input.prevout);	81✔
391	}
392
393	/**
394	* Get a single output by input.
395	* @param {Input} input
396	* @returns {Output\|null}
397	*/
398
399	getOutputFor(input) {
400	return this.getOutput(input.prevout);	102,199✔
401	}
402
403	/**
404	* Get a single path by input.
405	* Implemented in {@link WalletCoinView}.
406	* @param {Input} input
407	* @returns {null}
408	*/
409
410	getPathFor(input) {
411	return null;	18✔
412	}
413
414	/**
415	* Add an HD path to the collection.
416	* Implemented in {@link WalletCoinView}
417	* @param {Outpoint} prevout
418	* @param {Path} path
419	* @returns {Path\|null}
420	*/
421
422	addPath(prevout, path) {
NEW 423	return null;	×
424	}
425
426	/**
427	* Get coins height by input.
428	* @param {Input} input
429	* @returns {Number}
430	*/
431
432	getHeightFor(input) {
433	return this.getHeight(input.prevout);	×
434	}
435
436	/**
437	* Get coins coinbase flag by input.
438	* @param {Input} input
439	* @returns {Boolean}
440	*/
441
442	isCoinbaseFor(input) {
443	return this.isCoinbase(input.prevout);	×
444	}
445
446	/**
447	* Retrieve coins from database.
448	* @method
449	* @param {ChainDB} db
450	* @param {Outpoint} prevout
451	* @returns {Promise} - Returns {@link CoinEntry}.
452	*/
453
454	async readCoin(db, prevout) {
455	const cache = this.getEntry(prevout);	21,599✔
456
457	if (cache)	21,599✔
458	return cache;	19✔
459
460	const coin = await db.readCoin(prevout);	21,580✔
461
462	if (!coin)	21,580✔
463	return null;	2✔
464
465	return this.addEntry(prevout, coin);	21,578✔
466	}
467
468	/**
469	* Read all input coins into unspent map.
470	* @method
471	* @param {ChainDB} db
472	* @param {TX} tx
473	* @returns {Promise} - Returns {Boolean}.
474	*/
475
476	async readInputs(db, tx) {
477	let found = true;	×
478
479	for (const {prevout} of tx.inputs) {	×
480	if (!await this.readCoin(db, prevout))	×
481	found = false;	×
482	}
483
484	return found;	×
485	}
486
487	/**
488	* Spend coins for transaction.
489	* @method
490	* @param {ChainDB} db
491	* @param {TX} tx
492	* @returns {Promise} - Returns {Boolean}.
493	*/
494
495	async spendInputs(db, tx) {
496	let i = 0;	8,726✔
497
498	while (i < tx.inputs.length) {	8,726✔
499	const len = Math.min(i + 4, tx.inputs.length);	10,849✔
500	const jobs = [];	10,849✔
501
502	for (; i < len; i++) {	10,849✔
503	const {prevout} = tx.inputs[i];	21,599✔
504	jobs.push(this.readCoin(db, prevout));	21,599✔
505	}
506
507	const coins = await Promise.all(jobs);	10,849✔
508
509	for (const coin of coins) {	10,849✔
510	if (!coin \|\| coin.spent)	21,599✔
511	return false;	2✔
512
513	coin.spent = true;	21,597✔
514	this.undo.push(coin);	21,597✔
515	}
516	}
517
518	return true;	8,724✔
519	}
520
521	/**
522	* Calculate serialization size.
523	* @param {TX} tx
524	* @returns {Number}
525	*/
526
527	getSize(tx) {
528	let size = 0;	12,662✔
529
530	size += tx.inputs.length;	12,662✔
531
532	for (const {prevout} of tx.inputs) {	12,662✔
533	const coin = this.getEntry(prevout);	17,887✔
534
535	if (!coin)	17,887✔
536	continue;	5,883✔
537
538	size += coin.getSize();	12,004✔
539	}
540
541	return size;	12,662✔
542	}
543
544	/**
545	* Write coin data to buffer writer
546	* as it pertains to a transaction.
547	* @param {BufioWriter} bw
548	* @param {TX} tx
549	* @returns {BufioWriter}
550	*/
551
552	write(bw, tx) {
553	for (const {prevout} of tx.inputs) {	12,662✔
554	const coin = this.getEntry(prevout);	17,887✔
555
556	if (!coin) {	17,887✔
557	bw.writeU8(0);	5,883✔
558	continue;	5,883✔
559	}
560
561	bw.writeU8(1);	12,004✔
562	coin.write(bw);	12,004✔
563	}
564
565	return bw;	12,662✔
566	}
567
568	/**
569	* Read serialized view data from a buffer
570	* reader as it pertains to a transaction.
571	* @param {BufferReader} br
572	* @param {TX} tx
573	*/
574
575	read(br, tx) {
576	for (const {prevout} of tx.inputs) {	12,662✔
577	if (br.readU8() === 0)	17,887✔
578	continue;	5,883✔
579
580	const coin = CoinEntry.read(br);	12,004✔
581
582	this.addEntry(prevout, coin);	12,004✔
583	}
584
585	return this;	12,662✔
586	}
587
588	/**
589	* Read serialized view data from a buffer
590	* reader as it pertains to a transaction.
591	* @param {BufferReader} br
592	* @param {TX} tx
593	* @returns {CoinView}
594	*/
595
596	static read(br, tx) {
597	return new this().read(br, tx);	12,566✔
598	}
599	}
600
601	/*
602	* Expose
603	*/
604
605	module.exports = CoinView;	70✔

handshake-org / hsd / 11142522588

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