187 lines
3.7 KiB
JavaScript
187 lines
3.7 KiB
JavaScript
/*!
|
|
* outpoint.js - outpoint object for bcoin
|
|
* Copyright (c) 2014-2016, Christopher Jeffrey (MIT License).
|
|
* https://github.com/bcoin-org/bcoin
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
module.exports = Outpoint;
|
|
|
|
var utils = require('../utils/utils');
|
|
var assert = require('assert');
|
|
var constants = require('../protocol/constants');
|
|
var BufferWriter = require('../utils/writer');
|
|
var BufferReader = require('../utils/reader');
|
|
|
|
/**
|
|
* Represents a COutPoint.
|
|
* @exports Outpoint
|
|
* @constructor
|
|
* @param {Hash?} hash
|
|
* @param {Number?} index
|
|
* @property {Hash} hash
|
|
* @property {Number} index
|
|
*/
|
|
|
|
function Outpoint(hash, index) {
|
|
if (!(this instanceof Outpoint))
|
|
return new Outpoint(hash, index);
|
|
|
|
this.hash = hash || constants.NULL_HASH;
|
|
this.index = index != null ? index : 0xffffffff;
|
|
}
|
|
|
|
/**
|
|
* Inject properties from options object.
|
|
* @private
|
|
* @param {Object} options
|
|
*/
|
|
|
|
Outpoint.prototype.fromOptions = function fromOptions(options) {
|
|
assert(typeof options.hash === 'string');
|
|
assert(utils.isNumber(options.index));
|
|
this.hash = options.hash;
|
|
this.index = options.index;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Instantate outpoint from options object.
|
|
* @param {Object} options
|
|
* @returns {Outpoint}
|
|
*/
|
|
|
|
Outpoint.fromOptions = function fromOptions(options) {
|
|
return new Outpoint().fromOptions(options);
|
|
};
|
|
|
|
/**
|
|
* Test whether the outpoint is null (hash of zeroes
|
|
* with max-u32 index). Used to detect coinbases.
|
|
* @returns {Boolean}
|
|
*/
|
|
|
|
Outpoint.prototype.isNull = function isNull() {
|
|
return this.index === 0xffffffff && this.hash === constants.NULL_HASH;
|
|
};
|
|
|
|
/**
|
|
* Serialize outpoint.
|
|
* @returns {Buffer}
|
|
*/
|
|
|
|
Outpoint.prototype.toRaw = function toRaw(writer) {
|
|
var p = BufferWriter(writer);
|
|
|
|
p.writeHash(this.hash);
|
|
p.writeU32(this.index);
|
|
|
|
if (!writer)
|
|
p = p.render();
|
|
|
|
return p;
|
|
};
|
|
|
|
/**
|
|
* Inject properties from serialized data.
|
|
* @private
|
|
* @param {Buffer} data
|
|
*/
|
|
|
|
Outpoint.prototype.fromRaw = function fromRaw(data) {
|
|
var p = BufferReader(data);
|
|
this.hash = p.readHash('hex');
|
|
this.index = p.readU32();
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Instantiate outpoint from serialized data.
|
|
* @param {Buffer} data
|
|
* @returns {Outpoint}
|
|
*/
|
|
|
|
Outpoint.fromRaw = function fromRaw(data) {
|
|
return new Outpoint().fromRaw(data);
|
|
};
|
|
|
|
/**
|
|
* Inject properties from json object.
|
|
* @private
|
|
* @params {Object} json
|
|
*/
|
|
|
|
Outpoint.prototype.fromJSON = function fromJSON(json) {
|
|
assert(typeof json.hash === 'string');
|
|
assert(utils.isNumber(json.index));
|
|
this.hash = utils.revHex(json.hash);
|
|
this.index = json.index;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Convert the outpoint to an object suitable
|
|
* for JSON serialization. Note that the hash
|
|
* will be reversed to abide by bitcoind's legacy
|
|
* of little-endian uint256s.
|
|
* @returns {Object}
|
|
*/
|
|
|
|
Outpoint.prototype.toJSON = function toJSON() {
|
|
return {
|
|
hash: utils.revHex(this.hash),
|
|
index: this.index
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Instantiate outpoint from json object.
|
|
* @param {Object} json
|
|
* @returns {Outpoint}
|
|
*/
|
|
|
|
Outpoint.fromJSON = function fromJSON(json) {
|
|
return new Outpoint().fromJSON(json);
|
|
};
|
|
|
|
/**
|
|
* Inject properties from tx.
|
|
* @private
|
|
* @param {TX} tx
|
|
* @param {Number} index
|
|
*/
|
|
|
|
Outpoint.prototype.fromTX = function fromTX(tx, index) {
|
|
assert(utils.isNumber(index));
|
|
this.hash = tx.hash('hex');
|
|
this.index = index;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Instantiate outpoint from tx.
|
|
* @param {TX} tx
|
|
* @param {Number} index
|
|
* @returns {Outpoint}
|
|
*/
|
|
|
|
Outpoint.fromTX = function fromTX(tx, index) {
|
|
return new Outpoint().fromTX(tx, index);
|
|
};
|
|
|
|
/**
|
|
* Convert the outpoint to a user-friendly string.
|
|
* @returns {String}
|
|
*/
|
|
|
|
Outpoint.prototype.inspect = function inspect() {
|
|
return '<Outpoint: ' + utils.revHex(this.hash) + '/' + this.index + '>';
|
|
};
|
|
|
|
/*
|
|
* Expose
|
|
*/
|
|
|
|
module.exports = Outpoint;
|