11516178903

Committed 25 Oct 2024 10:06AM UTC coverage: 71.262% (+1.2%) from 70.033%

Build # 11516178903

Build Type

Pull #888

github

Committed by

web-flow

Commit Message

Merge a3544853e 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 %.

823 of 880 new or added lines in 16 files covered. (93.52%)

2064 existing lines in 60 files now uncovered.

25716 of 34234 relevant lines covered (75.12%)

34515.35 hits per line

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

91.49

/lib/primitives/output.js

/*!
 * output.js - output 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 Amount = require('../ui/amount');
const Network = require('../protocol/network');
const Address = require('../primitives/address');
const consensus = require('../protocol/consensus');
const policy = require('../protocol/policy');
const util = require('../utils/util');
const Covenant = require('./covenant');

/** @typedef {import('../types').Amount} AmountValue */
/** @typedef {import('../types').Rate} Rate */
/** @typedef {import('../types').Hash} Hash */
/** @typedef {import('../types').BufioWriter} BufioWriter */
/** @typedef {import('./covenant').CovenantJSON} CovenantJSON */

/**
 * @typedef {Object} OutputJSON
 * @property {AmountValue} value
 * @property {String} address
 * @property {CovenantJSON} covenant
 */

/**
 * Represents a transaction output.
 * @alias module:primitives.Output
 * @property {AmountValue} value
 * @property {Address} address
 */

class Output extends bio.Struct {
  /**
   * Create an output.
   * @constructor
   * @param {Object?} [options]
   */

  constructor(options) {
    super();

    this.value = 0;
    this.address = new Address();
    this.covenant = new Covenant();

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

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

  fromOptions(options) {
    assert(options, 'Output data is required.');

    if (options.value != null) {
      assert(util.isU64(options.value), 'Value must be a uint64.');
      this.value = options.value;
    }

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

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

    return this;
  }

  /**
   * Inject properties from address/value pair.
   * @param {Address} address
   * @param {AmountValue} value
   * @returns {Output}
   */

  fromScript(address, value) {
    assert(util.isU64(value), 'Value must be a uint64.');

    this.address = Address.fromOptions(address);
    this.value = value;

    return this;
  }

  /**
   * Instantiate output from address/value pair.
   * @param {Address} address
   * @param {AmountValue} value
   * @returns {Output}
   */

  static fromScript(address, value) {
    return new this().fromScript(address, value);
  }

  /**
   * Clone the output.
   * @param {this} output
   * @returns {this}
   */

  inject(output) {
    assert(output instanceof this.constructor);
    this.value = output.value;
    this.address.inject(output.address);
    this.covenant.inject(output.covenant);
    return this;
  }

  /**
   * Test equality against another output.
   * @param {Output} output
   * @returns {Boolean}
   */

  equals(output) {
    assert(output instanceof this.constructor);
    return this.value === output.value
      && this.address.equals(output.address);
  }

  /**
   * Compare against another output (BIP69).
   * @param {Output} output
   * @returns {Number}
   */

  compare(output) {
    assert(output instanceof this.constructor);

    const cmp = this.value - output.value;

    if (cmp !== 0)
      return cmp;

    return this.address.compare(output.address);
  }

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

  getAddress() {
    return this.address;
  }

  /**
   * Get the address hash.
   * @returns {Hash}
   */

  getHash() {
    return this.address.getHash();
  }

  /**
   * Convert the input to a more user-friendly object.
   * @returns {Object}
   */

  format() {
    return {
      value: Amount.coin(this.value),
      address: this.address,
      covenant: this.covenant
    };
  }

  /**
   * Convert the output to an object suitable
   * for JSON serialization.
   * @param {Network} [network]
   * @returns {OutputJSON}
   */

  getJSON(network) {
    network = Network.get(network);

    return {
      value: this.value,
      address: this.address.toString(network),
      covenant: this.covenant.toJSON()
    };
  }

  /**
   * Calculate the dust threshold for this
   * output, based on serialize size and rate.
   * @param {Rate?} [rate]
   * @returns {AmountValue}
   */

  getDustThreshold(rate) {
    if (!this.covenant.isDustworthy())
      return 0;

    if (this.address.isUnspendable())
      return 0;

    const scale = consensus.WITNESS_SCALE_FACTOR;

    let size = this.getSize();

    size += 32 + 4 + 1 + (107 / scale | 0) + 4;

    return 3 * policy.getMinFee(size, rate);
  }

  /**
   * Calculate size of serialized output.
   * @returns {Number}
   */

  getSize() {
    return 8 + this.address.getSize() + this.covenant.getVarSize();
  }

  /**
   * Test whether the output should be considered dust.
   * @param {Rate?} [rate]
   * @returns {Boolean}
   */

  isDust(rate) {
    return this.value < this.getDustThreshold(rate);
  }

  /**
   * Test whether the output is unspendable.
   * @returns {Boolean}
   */

  isUnspendable() {
    return this.address.isUnspendable() || this.covenant.isUnspendable();
  }

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

  fromJSON(json) {
    assert(json, 'Output data is required.');
    assert(util.isU64(json.value), 'Value must be a uint64.');

    this.value = json.value;
    this.address.fromString(json.address);

    if (json.covenant != null)
      this.covenant.fromJSON(json.covenant);

    return this;
  }

  /**
   * Write the output to a buffer writer.
   * @param {BufioWriter} bw
   * @returns {BufioWriter}
   */

  write(bw) {
    bw.writeU64(this.value);
    this.address.write(bw);
    this.covenant.write(bw);
    return bw;
  }

  /**
   * Inject properties from buffer reader.
   * @param {bio.BufferReader} br
   * @returns {this}
   */

  read(br) {
    this.value = br.readU64();
    this.address.read(br);
    this.covenant.read(br);
    return this;
  }

  /**
   * Test an object to see if it is an Output.
   * @param {Object} obj
   * @returns {Boolean}
   */

  static isOutput(obj) {
    return obj instanceof Output;
  }
}

/*
 * Expose
 */

module.exports = Output;

1	/*!
2	* output.js - output 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');	68✔
10	const bio = require('bufio');	68✔
11	const Amount = require('../ui/amount');	68✔
12	const Network = require('../protocol/network');	68✔
13	const Address = require('../primitives/address');	68✔
14	const consensus = require('../protocol/consensus');	68✔
15	const policy = require('../protocol/policy');	68✔
16	const util = require('../utils/util');	68✔
17	const Covenant = require('./covenant');	68✔
18
19	/** @typedef {import('../types').Amount} AmountValue */
20	/** @typedef {import('../types').Rate} Rate */
21	/** @typedef {import('../types').Hash} Hash */
22	/** @typedef {import('../types').BufioWriter} BufioWriter */
23	/** @typedef {import('./covenant').CovenantJSON} CovenantJSON */
24
25	/**
26	* @typedef {Object} OutputJSON
27	* @property {AmountValue} value
28	* @property {String} address
29	* @property {CovenantJSON} covenant
30	*/
31
32	/**
33	* Represents a transaction output.
34	* @alias module:primitives.Output
35	* @property {AmountValue} value
36	* @property {Address} address
37	*/
38
39	class Output extends bio.Struct {
40	/**
41	* Create an output.
42	* @constructor
43	* @param {Object?} [options]
44	*/
45
46	constructor(options) {
47	super();	1,241,411✔
48
49	this.value = 0;	1,241,411✔
50	this.address = new Address();	1,241,411✔
51	this.covenant = new Covenant();	1,241,411✔
52
53	if (options)	1,241,411✔
54	this.fromOptions(options);	6,053✔
55	}
56
57	/**
58	* Inject properties from options object.
59	* @param {Object} options
60	*/
61
62	fromOptions(options) {
63	assert(options, 'Output data is required.');	6,194✔
64
65	if (options.value != null) {	6,194✔
66	assert(util.isU64(options.value), 'Value must be a uint64.');	6,193✔
67	this.value = options.value;	6,193✔
68	}
69
70	if (options.address)	6,194✔
71	this.address.fromOptions(options.address);	6,160✔
72
73	if (options.covenant)	6,194✔
74	this.covenant.fromOptions(options.covenant);	3,028✔
75
76	return this;	6,194✔
77	}
78
79	/**
80	* Inject properties from address/value pair.
81	* @param {Address} address
82	* @param {AmountValue} value
83	* @returns {Output}
84	*/
85
86	fromScript(address, value) {
87	assert(util.isU64(value), 'Value must be a uint64.');	92,726✔
88
89	this.address = Address.fromOptions(address);	92,726✔
90	this.value = value;	92,726✔
91
92	return this;	92,726✔
93	}
94
95	/**
96	* Instantiate output from address/value pair.
97	* @param {Address} address
98	* @param {AmountValue} value
99	* @returns {Output}
100	*/
101
102	static fromScript(address, value) {
103	return new this().fromScript(address, value);	92,726✔
104	}
105
106	/**
107	* Clone the output.
108	* @param {this} output
109	* @returns {this}
110	*/
111
112	inject(output) {
113	assert(output instanceof this.constructor);	163,761✔
114	this.value = output.value;	163,761✔
115	this.address.inject(output.address);	163,761✔
116	this.covenant.inject(output.covenant);	163,761✔
117	return this;	163,761✔
118	}
119
120	/**
121	* Test equality against another output.
122	* @param {Output} output
123	* @returns {Boolean}
124	*/
125
126	equals(output) {
UNCOV 127	assert(output instanceof this.constructor);	×
UNCOV 128	return this.value === output.value	×
129	&& this.address.equals(output.address);
130	}
131
132	/**
133	* Compare against another output (BIP69).
134	* @param {Output} output
135	* @returns {Number}
136	*/
137
138	compare(output) {
139	assert(output instanceof this.constructor);	22,206✔
140
141	const cmp = this.value - output.value;	22,206✔
142
143	if (cmp !== 0)	22,206✔
144	return cmp;	5,673✔
145
146	return this.address.compare(output.address);	16,533✔
147	}
148
149	/**
150	* Get the address.
151	* @returns {Address} address
152	*/
153
154	getAddress() {
155	return this.address;	218,929✔
156	}
157
158	/**
159	* Get the address hash.
160	* @returns {Hash}
161	*/
162
163	getHash() {
164	return this.address.getHash();	8,925,488✔
165	}
166
167	/**
168	* Convert the input to a more user-friendly object.
169	* @returns {Object}
170	*/
171
172	format() {
UNCOV 173	return {	×
174	value: Amount.coin(this.value),
175	address: this.address,
176	covenant: this.covenant
177	};
178	}
179
180	/**
181	* Convert the output to an object suitable
182	* for JSON serialization.
183	* @param {Network} [network]
184	* @returns {OutputJSON}
185	*/
186
187	getJSON(network) {
188	network = Network.get(network);	1,326✔
189
190	return {	1,326✔
191	value: this.value,
192	address: this.address.toString(network),
193	covenant: this.covenant.toJSON()
194	};
195	}
196
197	/**
198	* Calculate the dust threshold for this
199	* output, based on serialize size and rate.
200	* @param {Rate?} [rate]
201	* @returns {AmountValue}
202	*/
203
204	getDustThreshold(rate) {
205	if (!this.covenant.isDustworthy())	24,464✔
206	return 0;	8,759✔
207
208	if (this.address.isUnspendable())	15,705!
UNCOV 209	return 0;	×
210
211	const scale = consensus.WITNESS_SCALE_FACTOR;	15,705✔
212
213	let size = this.getSize();	15,705✔
214
215	size += 32 + 4 + 1 + (107 / scale \| 0) + 4;	15,705✔
216
217	return 3 * policy.getMinFee(size, rate);	15,705✔
218	}
219
220	/**
221	* Calculate size of serialized output.
222	* @returns {Number}
223	*/
224
225	getSize() {
226	return 8 + this.address.getSize() + this.covenant.getVarSize();	6,437,017✔
227	}
228
229	/**
230	* Test whether the output should be considered dust.
231	* @param {Rate?} [rate]
232	* @returns {Boolean}
233	*/
234
235	isDust(rate) {
236	return this.value < this.getDustThreshold(rate);	24,448✔
237	}
238
239	/**
240	* Test whether the output is unspendable.
241	* @returns {Boolean}
242	*/
243
244	isUnspendable() {
245	return this.address.isUnspendable() \|\| this.covenant.isUnspendable();	201,929✔
246	}
247
248	/**
249	* Inject properties from a JSON object.
250	* @param {OutputJSON} json
251	*/
252
253	fromJSON(json) {
254	assert(json, 'Output data is required.');	55✔
255	assert(util.isU64(json.value), 'Value must be a uint64.');	55✔
256
257	this.value = json.value;	55✔
258	this.address.fromString(json.address);	55✔
259
260	if (json.covenant != null)	55✔
261	this.covenant.fromJSON(json.covenant);	54✔
262
263	return this;	55✔
264	}
265
266	/**
267	* Write the output to a buffer writer.
268	* @param {BufioWriter} bw
269	* @returns {BufioWriter}
270	*/
271
272	write(bw) {
273	bw.writeU64(this.value);	4,880,773✔
274	this.address.write(bw);	4,880,773✔
275	this.covenant.write(bw);	4,880,773✔
276	return bw;	4,880,773✔
277	}
278
279	/**
280	* Inject properties from buffer reader.
281	* @param {bio.BufferReader} br
282	* @returns {this}
283	*/
284
285	read(br) {
286	this.value = br.readU64();	259,409✔
287	this.address.read(br);	259,409✔
288	this.covenant.read(br);	259,407✔
289	return this;	259,407✔
290	}
291
292	/**
293	* Test an object to see if it is an Output.
294	* @param {Object} obj
295	* @returns {Boolean}
296	*/
297
298	static isOutput(obj) {
UNCOV 299	return obj instanceof Output;	×
300	}
301	}
302
303	/*
304	* Expose
305	*/
306
307	module.exports = Output;	68✔

handshake-org / hsd / 11516178903

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