11252432232

Committed 09 Oct 2024 09:44AM UTC coverage: 71.252% (+1.2%) from 70.033%

Build # 11252432232

Build Type

Pull #888

github

Committed by

web-flow

Commit Message

Merge 15e964612 into 1b331eedb

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

Run Details

8048 of 13146 branches covered (61.22%)

Branch coverage included in aggregate %.

824 of 881 new or added lines in 16 files covered. (93.53%)

2068 existing lines in 60 files now uncovered.

25711 of 34234 relevant lines covered (75.1%)

34514.35 hits per line

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

63.64

/lib/primitives/txmeta.js

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

'use strict';

const assert = require('bsert');
const bio = require('bufio');
const util = require('../utils/util');
const TX = require('./tx');

/** @typedef {import('../types').Hash} Hash */
/** @typedef {import('../types').BufioWriter} BufioWriter */
/** @typedef {import('../blockchain/chainentry')} ChainEntry */
/** @typedef {import('../coins/coinview')} CoinView */
/** @typedef {import('../protocol/network')} Network */

/**
 * TXMeta
 * An extended transaction object.
 * @alias module:primitives.TXMeta
 */

class TXMeta extends bio.Struct {
  /**
   * Create an extended transaction.
   * @constructor
   * @param {Object?} [options]
   */

  constructor(options) {
    super();

    this.tx = new TX();
    this.mtime = util.now();
    this.height = -1;
    /** @type {Hash} */
    this.block = null;
    this.time = 0;
    this.index = -1;

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

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

  fromOptions(options) {
    if (options.tx) {
      assert(options.tx instanceof TX);
      this.tx = options.tx;
    }

    if (options.mtime != null) {
      assert(util.isU64(options.mtime));
      this.mtime = options.mtime;
    }

    if (options.height != null) {
      assert(options.height === -1
        || (options.height >>> 0) === options.height);
      this.height = options.height;
    }

    if (options.block !== undefined) {
      assert(options.block === null || Buffer.isBuffer(options.block));
      this.block = options.block;
    }

    if (options.time != null) {
      assert(util.isU64(options.time));
      this.time = options.time;
    }

    if (options.index != null) {
      assert(options.index === -1 || (options.index >>> 0) === options.index);
      this.index = options.index;
    }

    return this;
  }

  /**
   * Inject properties from options object.
   * @param {TX} tx
   * @param {ChainEntry} entry
   * @param {Number} index
   */

  fromTX(tx, entry, index) {
    this.tx = tx;
    if (entry) {
      this.height = entry.height;
      this.block = entry.hash;
      this.time = entry.time;
      this.index = index;
    }
    return this;
  }

  /**
   * Instantiate TXMeta from options.
   * @param {TX} tx
   * @param {ChainEntry} entry
   * @param {Number} index
   * @returns {TXMeta}
   */

  static fromTX(tx, entry, index) {
    return new this().fromTX(tx, entry, index);
  }

  /**
   * Inspect the transaction.
   * @param {CoinView} view
   * @returns {Object}
   */

  format(view) {
    const data = this.tx.format(view, null, this.index);
    data.mtime = this.mtime;
    data.height = this.height;
    data.block = this.block ? this.block.toString('hex') : null;
    data.time = this.time;
    return data;
  }

  /**
   * Convert the transaction to an object suitable
   * for JSON serialization.
   * @param {Network} [network]
   * @param {CoinView} [view]
   * @param {Number} [chainHeight]
   * @returns {Object}
   */

  getJSON(network, view, chainHeight) {
    const json = this.tx.getJSON(network, view, null, this.index);
    json.mtime = this.mtime;
    json.height = this.height;
    json.block = this.block ? this.block.toString('hex') : null;
    json.time = this.time;
    json.confirmations = 0;

    if (chainHeight != null && this.height !== -1)
      json.confirmations = chainHeight - this.height + 1;

    return json;
  }

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

  fromJSON(json) {
    this.tx.fromJSON(json);

    assert(util.isU64(json.mtime));
    assert(json.height === -1 || (json.height >>> 0) === json.height);
    assert(!json.block || typeof json.block === 'string');
    assert(util.isU64(json.time));
    assert(json.index === -1 || (json.index >>> 0) === json.index);

    this.mtime = json.mtime;
    this.height = json.height;
    this.block = json.block ? util.parseHex(json.block, 32) : null;
    this.index = json.index;

    return this;
  }

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

  getSize() {
    let size = 0;

    size += this.tx.getSize();
    size += 4;

    if (this.block) {
      size += 1;
      size += 32;
      size += 4 * 3;
    } else {
      size += 1;
    }

    return size;
  }

  /**
   * Serialize a transaction to "extended format".
   * This is the serialization format we use internally
   * to store transactions in the database. The extended
   * serialization includes the height, block hash, index,
   * timestamp, and pending-since time.
   * @param {BufioWriter} bw
   * @returns {BufioWriter}
   */

  write(bw) {
    this.tx.write(bw);

    bw.writeU32(this.mtime);

    if (this.block) {
      bw.writeU8(1);
      bw.writeHash(this.block);
      bw.writeU32(this.height);
      bw.writeU32(this.time);
      bw.writeU32(this.index);
    } else {
      bw.writeU8(0);
    }

    return bw;
  }

  /**
   * Inject properties from "extended" serialization format.
   * @param {bio.BufferReader} br
   */

  read(br) {
    this.tx.read(br);

    this.mtime = br.readU32();

    if (br.readU8() === 1) {
      this.block = br.readHash();
      this.height = br.readU32();
      this.time = br.readU32();
      this.index = br.readU32();
      if (this.index === 0xffffffff)
        this.index = -1;
    }

    return this;
  }

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

  static isTXMeta(obj) {
    return obj instanceof TXMeta;
  }
}

/*
 * Expose
 */

module.exports = TXMeta;

1	/*!
2	* txmeta.js - extended transaction 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 bio = require('bufio');	1✔
11	const util = require('../utils/util');	1✔
12	const TX = require('./tx');	1✔
13
14	/** @typedef {import('../types').Hash} Hash */
15	/** @typedef {import('../types').BufioWriter} BufioWriter */
16	/** @typedef {import('../blockchain/chainentry')} ChainEntry */
17	/** @typedef {import('../coins/coinview')} CoinView */
18	/** @typedef {import('../protocol/network')} Network */
19
20	/**
21	* TXMeta
22	* An extended transaction object.
23	* @alias module:primitives.TXMeta
24	*/
25
26	class TXMeta extends bio.Struct {
27	/**
28	* Create an extended transaction.
29	* @constructor
30	* @param {Object?} [options]
31	*/
32
33	constructor(options) {
34	super();	31✔
35
36	this.tx = new TX();	31✔
37	this.mtime = util.now();	31✔
38	this.height = -1;	31✔
39	/** @type {Hash} */
40	this.block = null;	31✔
41	this.time = 0;	31✔
42	this.index = -1;	31✔
43
44	if (options)	31!
UNCOV 45	this.fromOptions(options);	×
46	}
47
48	/**
49	* Inject properties from options object.
50	* @param {Object} options
51	*/
52
53	fromOptions(options) {
54	if (options.tx) {	2!
55	assert(options.tx instanceof TX);	×
UNCOV 56	this.tx = options.tx;	×
57	}
58
59	if (options.mtime != null) {	2!
UNCOV 60	assert(util.isU64(options.mtime));	×
UNCOV 61	this.mtime = options.mtime;	×
62	}
63
64	if (options.height != null) {	2✔
65	assert(options.height === -1	1✔
66	\|\| (options.height >>> 0) === options.height);
67	this.height = options.height;	1✔
68	}
69
70	if (options.block !== undefined) {	2✔
71	assert(options.block === null \|\| Buffer.isBuffer(options.block));	1✔
72	this.block = options.block;	1✔
73	}
74
75	if (options.time != null) {	2!
76	assert(util.isU64(options.time));	×
UNCOV 77	this.time = options.time;	×
78	}
79
80	if (options.index != null) {	2!
UNCOV 81	assert(options.index === -1 \|\| (options.index >>> 0) === options.index);	×
UNCOV 82	this.index = options.index;	×
83	}
84
85	return this;	2✔
86	}
87
88	/**
89	* Inject properties from options object.
90	* @param {TX} tx
91	* @param {ChainEntry} entry
92	* @param {Number} index
93	*/
94
95	fromTX(tx, entry, index) {
96	this.tx = tx;	26✔
97	if (entry) {	26!
98	this.height = entry.height;	26✔
99	this.block = entry.hash;	26✔
100	this.time = entry.time;	26✔
101	this.index = index;	26✔
102	}
103	return this;	26✔
104	}
105
106	/**
107	* Instantiate TXMeta from options.
108	* @param {TX} tx
109	* @param {ChainEntry} entry
110	* @param {Number} index
111	* @returns {TXMeta}
112	*/
113
114	static fromTX(tx, entry, index) {
115	return new this().fromTX(tx, entry, index);	26✔
116	}
117
118	/**
119	* Inspect the transaction.
120	* @param {CoinView} view
121	* @returns {Object}
122	*/
123
124	format(view) {
UNCOV 125	const data = this.tx.format(view, null, this.index);	×
UNCOV 126	data.mtime = this.mtime;	×
UNCOV 127	data.height = this.height;	×
UNCOV 128	data.block = this.block ? this.block.toString('hex') : null;	×
UNCOV 129	data.time = this.time;	×
UNCOV 130	return data;	×
131	}
132
133	/**
134	* Convert the transaction to an object suitable
135	* for JSON serialization.
136	* @param {Network} [network]
137	* @param {CoinView} [view]
138	* @param {Number} [chainHeight]
139	* @returns {Object}
140	*/
141
142	getJSON(network, view, chainHeight) {
143	const json = this.tx.getJSON(network, view, null, this.index);	3✔
144	json.mtime = this.mtime;	3✔
145	json.height = this.height;	3✔
146	json.block = this.block ? this.block.toString('hex') : null;	3✔
147	json.time = this.time;	3✔
148	json.confirmations = 0;	3✔
149
150	if (chainHeight != null && this.height !== -1)	3✔
151	json.confirmations = chainHeight - this.height + 1;	1✔
152
153	return json;	3✔
154	}
155
156	/**
157	* Inject properties from a json object.
158	* @param {Object} json
159	*/
160
161	fromJSON(json) {
162	this.tx.fromJSON(json);	×
163
UNCOV 164	assert(util.isU64(json.mtime));	×
165	assert(json.height === -1 \|\| (json.height >>> 0) === json.height);	×
UNCOV 166	assert(!json.block \|\| typeof json.block === 'string');	×
UNCOV 167	assert(util.isU64(json.time));	×
UNCOV 168	assert(json.index === -1 \|\| (json.index >>> 0) === json.index);	×
169
UNCOV 170	this.mtime = json.mtime;	×
UNCOV 171	this.height = json.height;	×
UNCOV 172	this.block = json.block ? util.parseHex(json.block, 32) : null;	×
UNCOV 173	this.index = json.index;	×
174
UNCOV 175	return this;	×
176	}
177
178	/**
179	* Calculate serialization size.
180	* @returns {Number}
181	*/
182
183	getSize() {
184	let size = 0;	26✔
185
186	size += this.tx.getSize();	26✔
187	size += 4;	26✔
188
189	if (this.block) {	26!
190	size += 1;	26✔
191	size += 32;	26✔
192	size += 4 * 3;	26✔
193	} else {
UNCOV 194	size += 1;	×
195	}
196
197	return size;	26✔
198	}
199
200	/**
201	* Serialize a transaction to "extended format".
202	* This is the serialization format we use internally
203	* to store transactions in the database. The extended
204	* serialization includes the height, block hash, index,
205	* timestamp, and pending-since time.
206	* @param {BufioWriter} bw
207	* @returns {BufioWriter}
208	*/
209
210	write(bw) {
211	this.tx.write(bw);	26✔
212
213	bw.writeU32(this.mtime);	26✔
214
215	if (this.block) {	26!
216	bw.writeU8(1);	26✔
217	bw.writeHash(this.block);	26✔
218	bw.writeU32(this.height);	26✔
219	bw.writeU32(this.time);	26✔
220	bw.writeU32(this.index);	26✔
221	} else {
UNCOV 222	bw.writeU8(0);	×
223	}
224
225	return bw;	26✔
226	}
227
228	/**
229	* Inject properties from "extended" serialization format.
230	* @param {bio.BufferReader} br
231	*/
232
233	read(br) {
234	this.tx.read(br);	2✔
235
236	this.mtime = br.readU32();	2✔
237
238	if (br.readU8() === 1) {	2!
239	this.block = br.readHash();	2✔
240	this.height = br.readU32();	2✔
241	this.time = br.readU32();	2✔
242	this.index = br.readU32();	2✔
243	if (this.index === 0xffffffff)	2!
UNCOV 244	this.index = -1;	×
245	}
246
247	return this;	2✔
248	}
249
250	/**
251	* Test whether an object is an TXMeta.
252	* @param {Object} obj
253	* @returns {Boolean}
254	*/
255
256	static isTXMeta(obj) {
UNCOV 257	return obj instanceof TXMeta;	×
258	}
259	}
260
261	/*
262	* Expose
263	*/
264
265	module.exports = TXMeta;	1✔

handshake-org / hsd / 11252432232

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