589 lines
17 KiB
JavaScript
589 lines
17 KiB
JavaScript
var BigInteger = require('./jsbn/jsbn');
|
|
var Script = require('./script');
|
|
var util = require('./util');
|
|
var convert = require('./convert');
|
|
var Wallet = require('./wallet');
|
|
var ECKey = require('./eckey').ECKey;
|
|
var ECDSA = require('./ecdsa');
|
|
var Address = require('./address');
|
|
var Message = require('./message');
|
|
|
|
var Transaction = function (doc) {
|
|
if (!(this instanceof Transaction)) { return new Transaction(doc); }
|
|
this.version = 1;
|
|
this.lock_time = 0;
|
|
this.ins = [];
|
|
this.outs = [];
|
|
this.timestamp = null;
|
|
this.block = null;
|
|
|
|
if (doc) {
|
|
if (typeof doc == "string" || Array.isArray(doc)) {
|
|
doc = Transaction.deserialize(doc)
|
|
}
|
|
if (doc.hash) this.hash = doc.hash;
|
|
if (doc.version) this.version = doc.version;
|
|
if (doc.lock_time) this.lock_time = doc.lock_time;
|
|
if (doc.ins && doc.ins.length) {
|
|
for (var i = 0; i < doc.ins.length; i++) {
|
|
this.addInput(new TransactionIn(doc.ins[i]));
|
|
}
|
|
}
|
|
if (doc.outs && doc.outs.length) {
|
|
for (var i = 0; i < doc.outs.length; i++) {
|
|
this.addOutput(new TransactionOut(doc.outs[i]));
|
|
}
|
|
}
|
|
if (doc.timestamp) this.timestamp = doc.timestamp;
|
|
if (doc.block) this.block = doc.block;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Turn transaction data into Transaction objects.
|
|
*
|
|
* Takes an array of plain JavaScript objects containing transaction data and
|
|
* returns an array of Transaction objects.
|
|
*/
|
|
Transaction.objectify = function (txs) {
|
|
var objs = [];
|
|
for (var i = 0; i < txs.length; i++) {
|
|
objs.push(new Transaction(txs[i]));
|
|
}
|
|
return objs;
|
|
};
|
|
|
|
/**
|
|
* Create a new txin.
|
|
*
|
|
* Can be called with any of:
|
|
*
|
|
* - An existing TransactionOut object
|
|
* - A transaction and an index
|
|
* - A transaction hash and an index
|
|
* - A single string argument of the form txhash:index
|
|
*
|
|
* Note that this method does not sign the created input.
|
|
*/
|
|
Transaction.prototype.addInput = function (tx, outIndex) {
|
|
if (arguments[0] instanceof TransactionIn) {
|
|
this.ins.push(arguments[0]);
|
|
}
|
|
else if (arguments[0].length > 65) {
|
|
var args = arguments[0].split(':');
|
|
return this.addInput(args[0], args[1]);
|
|
}
|
|
else {
|
|
this.ins.push(new TransactionIn({
|
|
outpoint: {
|
|
hash: tx.hash || tx,
|
|
index: outIndex
|
|
},
|
|
script: new Script(),
|
|
sequence: 4294967295
|
|
}));
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Create a new txout.
|
|
*
|
|
* Can be called with:
|
|
*
|
|
* i) An existing TransactionOut object
|
|
* ii) An address object or an address and a value
|
|
* iii) An address:value string
|
|
*
|
|
*/
|
|
Transaction.prototype.addOutput = function (address, value) {
|
|
if (arguments[0] instanceof TransactionOut) {
|
|
this.outs.push(arguments[0]);
|
|
return;
|
|
}
|
|
if (arguments[0].indexOf(':') >= 0) {
|
|
var args = arguments[0].split(':');
|
|
address = args[0];
|
|
value = parseInt(args[1]);
|
|
}
|
|
this.outs.push(new TransactionOut({
|
|
value: value,
|
|
script: Script.createOutputScript(address)
|
|
}));
|
|
};
|
|
|
|
/**
|
|
* Serialize this transaction.
|
|
*
|
|
* Returns the transaction as a byte array in the standard Bitcoin binary
|
|
* format. This method is byte-perfect, i.e. the resulting byte array can
|
|
* be hashed to get the transaction's standard Bitcoin hash.
|
|
*/
|
|
Transaction.prototype.serialize = function () {
|
|
var buffer = [];
|
|
buffer = buffer.concat(convert.numToBytes(parseInt(this.version),4));
|
|
buffer = buffer.concat(convert.numToVarInt(this.ins.length));
|
|
for (var i = 0; i < this.ins.length; i++) {
|
|
var txin = this.ins[i];
|
|
|
|
// Why do blockchain.info, blockexplorer.com, sx and just about everybody
|
|
// else use little-endian hashes? No idea...
|
|
buffer = buffer.concat(convert.hexToBytes(txin.outpoint.hash).reverse());
|
|
|
|
buffer = buffer.concat(convert.numToBytes(parseInt(txin.outpoint.index),4));
|
|
var scriptBytes = txin.script.buffer;
|
|
buffer = buffer.concat(convert.numToVarInt(scriptBytes.length));
|
|
buffer = buffer.concat(scriptBytes);
|
|
buffer = buffer.concat(convert.numToBytes(parseInt(txin.sequence),4));
|
|
}
|
|
buffer = buffer.concat(convert.numToVarInt(this.outs.length));
|
|
for (var i = 0; i < this.outs.length; i++) {
|
|
var txout = this.outs[i];
|
|
buffer = buffer.concat(convert.numToBytes(txout.value,8));
|
|
var scriptBytes = txout.script.buffer;
|
|
buffer = buffer.concat(convert.numToVarInt(scriptBytes.length));
|
|
buffer = buffer.concat(scriptBytes);
|
|
}
|
|
buffer = buffer.concat(convert.numToBytes(parseInt(this.lock_time),4));
|
|
|
|
return buffer;
|
|
};
|
|
|
|
Transaction.prototype.serializeHex = function() {
|
|
return convert.bytesToHex(this.serialize());
|
|
}
|
|
|
|
var OP_CODESEPARATOR = 171;
|
|
|
|
var SIGHASH_ALL = 1;
|
|
var SIGHASH_NONE = 2;
|
|
var SIGHASH_SINGLE = 3;
|
|
var SIGHASH_ANYONECANPAY = 80;
|
|
|
|
/**
|
|
* Hash transaction for signing a specific input.
|
|
*
|
|
* Bitcoin uses a different hash for each signed transaction input. This
|
|
* method copies the transaction, makes the necessary changes based on the
|
|
* hashType, serializes and finally hashes the result. This hash can then be
|
|
* used to sign the transaction input in question.
|
|
*/
|
|
Transaction.prototype.hashTransactionForSignature =
|
|
function (connectedScript, inIndex, hashType)
|
|
{
|
|
var txTmp = this.clone();
|
|
|
|
// In case concatenating two scripts ends up with two codeseparators,
|
|
// or an extra one at the end, this prevents all those possible
|
|
// incompatibilities.
|
|
/*scriptCode = scriptCode.filter(function (val) {
|
|
return val !== OP_CODESEPARATOR;
|
|
});*/
|
|
|
|
// Blank out other inputs' signatures
|
|
for (var i = 0; i < txTmp.ins.length; i++) {
|
|
txTmp.ins[i].script = new Script();
|
|
}
|
|
|
|
txTmp.ins[inIndex].script = connectedScript;
|
|
|
|
// Blank out some of the outputs
|
|
if ((hashType & 0x1f) == SIGHASH_NONE) {
|
|
txTmp.outs = [];
|
|
|
|
// Let the others update at will
|
|
for (var i = 0; i < txTmp.ins.length; i++)
|
|
if (i != inIndex)
|
|
txTmp.ins[i].sequence = 0;
|
|
} else if ((hashType & 0x1f) == SIGHASH_SINGLE) {
|
|
// TODO: Implement
|
|
}
|
|
|
|
// Blank out other inputs completely, not recommended for open transactions
|
|
if (hashType & SIGHASH_ANYONECANPAY) {
|
|
txTmp.ins = [txTmp.ins[inIndex]];
|
|
}
|
|
|
|
var buffer = txTmp.serialize();
|
|
|
|
buffer = buffer.concat(convert.numToBytes(parseInt(hashType),4));
|
|
|
|
return Message.getHash(buffer)
|
|
};
|
|
|
|
/**
|
|
* Calculate and return the transaction's hash.
|
|
* Reverses hash since blockchain.info, blockexplorer.com and others
|
|
* use little-endian hashes for some stupid reason
|
|
*/
|
|
Transaction.prototype.getHash = function ()
|
|
{
|
|
var buffer = this.serialize();
|
|
return Message.getHash(buffer).reverse()
|
|
};
|
|
|
|
/**
|
|
* Create a copy of this transaction object.
|
|
*/
|
|
Transaction.prototype.clone = function ()
|
|
{
|
|
var newTx = new Transaction();
|
|
newTx.version = this.version;
|
|
newTx.lock_time = this.lock_time;
|
|
for (var i = 0; i < this.ins.length; i++) {
|
|
var txin = this.ins[i].clone();
|
|
newTx.addInput(txin);
|
|
}
|
|
for (var i = 0; i < this.outs.length; i++) {
|
|
var txout = this.outs[i].clone();
|
|
newTx.addOutput(txout);
|
|
}
|
|
return newTx;
|
|
};
|
|
|
|
/**
|
|
* Analyze how this transaction affects a wallet.
|
|
*
|
|
* Returns an object with properties 'impact', 'type' and 'addr'.
|
|
*
|
|
* 'impact' is an object, see Transaction#calcImpact.
|
|
*
|
|
* 'type' can be one of the following:
|
|
*
|
|
* recv:
|
|
* This is an incoming transaction, the wallet received money.
|
|
* 'addr' contains the first address in the wallet that receives money
|
|
* from this transaction.
|
|
*
|
|
* self:
|
|
* This is an internal transaction, money was sent within the wallet.
|
|
* 'addr' is undefined.
|
|
*
|
|
* sent:
|
|
* This is an outgoing transaction, money was sent out from the wallet.
|
|
* 'addr' contains the first external address, i.e. the recipient.
|
|
*
|
|
* other:
|
|
* This method was unable to detect what the transaction does. Either it
|
|
*/
|
|
Transaction.prototype.analyze = function (wallet) {
|
|
if (!(wallet instanceof Wallet)) return null;
|
|
|
|
var allFromMe = true,
|
|
allToMe = true,
|
|
firstRecvHash = null,
|
|
firstMeRecvHash = null,
|
|
firstSendHash = null;
|
|
|
|
for (var i = this.outs.length-1; i >= 0; i--) {
|
|
var txout = this.outs[i];
|
|
var hash = txout.script.simpleOutPubKeyHash();
|
|
if (!wallet.hasHash(hash)) {
|
|
allToMe = false;
|
|
} else {
|
|
firstMeRecvHash = hash;
|
|
}
|
|
firstRecvHash = hash;
|
|
}
|
|
for (var i = this.ins.length-1; i >= 0; i--) {
|
|
var txin = this.ins[i];
|
|
firstSendHash = txin.script.simpleInPubKeyHash();
|
|
if (!wallet.hasHash(firstSendHash)) {
|
|
allFromMe = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
var impact = this.calcImpact(wallet);
|
|
|
|
var analysis = {};
|
|
|
|
analysis.impact = impact;
|
|
|
|
if (impact.sign > 0 && impact.value > 0) {
|
|
analysis.type = 'recv';
|
|
analysis.addr = new Address(firstMeRecvHash);
|
|
} else if (allFromMe && allToMe) {
|
|
analysis.type = 'self';
|
|
} else if (allFromMe) {
|
|
analysis.type = 'sent';
|
|
// TODO: Right now, firstRecvHash is the first output, which - if the
|
|
// transaction was not generated by this library could be the
|
|
// change address.
|
|
analysis.addr = new Address(firstRecvHash);
|
|
} else {
|
|
analysis.type = "other";
|
|
}
|
|
|
|
return analysis;
|
|
};
|
|
|
|
/**
|
|
* Get a human-readable version of the data returned by Transaction#analyze.
|
|
*
|
|
* This is merely a convenience function. Clients should consider implementing
|
|
* this themselves based on their UI, I18N, etc.
|
|
*/
|
|
Transaction.prototype.getDescription = function (wallet) {
|
|
var analysis = this.analyze(wallet);
|
|
|
|
if (!analysis) return "";
|
|
|
|
switch (analysis.type) {
|
|
case 'recv':
|
|
return "Received with "+analysis.addr;
|
|
break;
|
|
|
|
case 'sent':
|
|
return "Payment to "+analysis.addr;
|
|
break;
|
|
|
|
case 'self':
|
|
return "Payment to yourself";
|
|
break;
|
|
|
|
case 'other':
|
|
default:
|
|
return "";
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Get the total amount of a transaction's outputs.
|
|
*/
|
|
Transaction.prototype.getTotalOutValue = function () {
|
|
return this.outs.reduce(function(t,o) { return t + o.value },0);
|
|
};
|
|
|
|
/**
|
|
* Old name for Transaction#getTotalOutValue.
|
|
*
|
|
* @deprecated
|
|
*/
|
|
Transaction.prototype.getTotalValue = Transaction.prototype.getTotalOutValue;
|
|
|
|
/**
|
|
* Calculates the impact a transaction has on this wallet.
|
|
*
|
|
* Based on the its public keys, the wallet will calculate the
|
|
* credit or debit of this transaction.
|
|
*
|
|
* It will return an object with two properties:
|
|
* - sign: 1 or -1 depending on sign of the calculated impact.
|
|
* - value: amount of calculated impact
|
|
*
|
|
* @returns Object Impact on wallet
|
|
*/
|
|
Transaction.prototype.calcImpact = function (wallet) {
|
|
if (!(wallet instanceof Wallet)) return 0;
|
|
|
|
// Calculate credit to us from all outputs
|
|
var valueOut = this.outs.filter(function(o) {
|
|
return wallet.hasHash(convert.bytesToHex(o.script.simpleOutPubKeyHash()));
|
|
})
|
|
.reduce(function(t,o) { return t+o.value },0);
|
|
|
|
var valueIn = this.ins.filter(function(i) {
|
|
return wallet.hasHash(convert.bytesToHex(i.script.simpleInPubKeyHash()))
|
|
&& wallet.txIndex[i.outpoint.hash];
|
|
})
|
|
.reduce(function(t,i) {
|
|
return t + wallet.txIndex[i.outpoint.hash].outs[i.outpoint.index].value
|
|
},0);
|
|
|
|
if (valueOut > valueIn) {
|
|
return {
|
|
sign: 1,
|
|
value: valueOut - valueIn
|
|
};
|
|
} else {
|
|
return {
|
|
sign: -1,
|
|
value: valueIn - valueOut
|
|
};
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Converts a serialized transaction into a transaction object
|
|
*/
|
|
|
|
Transaction.deserialize = function(buffer) {
|
|
if (typeof buffer == "string") {
|
|
buffer = convert.hexToBytes(buffer)
|
|
}
|
|
var pos = 0;
|
|
var readAsInt = function(bytes) {
|
|
if (bytes == 0) return 0;
|
|
pos++;
|
|
return buffer[pos-1] + readAsInt(bytes-1) * 256;
|
|
}
|
|
var readVarInt = function() {
|
|
pos++;
|
|
if (buffer[pos-1] < 253) {
|
|
return buffer[pos-1];
|
|
}
|
|
return readAsInt(buffer[pos-1] - 251);
|
|
}
|
|
var readBytes = function(bytes) {
|
|
pos += bytes;
|
|
return buffer.slice(pos - bytes, pos);
|
|
}
|
|
var readVarString = function() {
|
|
var size = readVarInt();
|
|
return readBytes(size);
|
|
}
|
|
var obj = {
|
|
ins: [],
|
|
outs: []
|
|
}
|
|
obj.version = readAsInt(4);
|
|
var ins = readVarInt();
|
|
for (var i = 0; i < ins; i++) {
|
|
obj.ins.push({
|
|
outpoint: {
|
|
hash: convert.bytesToHex(readBytes(32).reverse()),
|
|
index: readAsInt(4)
|
|
},
|
|
script: new Script(readVarString()),
|
|
sequence: readAsInt(4)
|
|
});
|
|
}
|
|
var outs = readVarInt();
|
|
for (var i = 0; i < outs; i++) {
|
|
obj.outs.push({
|
|
value: convert.bytesToNum(readBytes(8)),
|
|
script: new Script(readVarString())
|
|
});
|
|
}
|
|
obj.locktime = readAsInt(4);
|
|
|
|
return new Transaction(obj);
|
|
}
|
|
|
|
/**
|
|
* Signs a standard output at some index with the given key
|
|
*/
|
|
|
|
Transaction.prototype.sign = function(index, key, type) {
|
|
type = type || SIGHASH_ALL;
|
|
key = new ECKey(key);
|
|
var pub = key.getPub().export('bytes'),
|
|
hash160 = util.sha256ripe160(pub),
|
|
script = Script.createOutputScript(new Address(hash160)),
|
|
hash = this.hashTransactionForSignature( script, index, type),
|
|
sig = key.sign(hash).concat([type]);
|
|
this.ins[index].script = Script.createInputScript(sig,pub);
|
|
}
|
|
|
|
// Takes outputs of the form [{ output: 'txhash:index', address: 'address' },...]
|
|
Transaction.prototype.signWithKeys = function(keys, outputs, type) {
|
|
type = type || SIGHASH_ALL;
|
|
var addrdata = keys.map(function(key) {
|
|
key = new ECKey(key);
|
|
return {
|
|
key: key,
|
|
address: key.getBitcoinAddress().toString()
|
|
}
|
|
});
|
|
var hmap = {};
|
|
for (var o in outputs) {
|
|
hmap[outputs[o].output] = outputs[o];
|
|
}
|
|
for (var i = 0; i < this.ins.length; i++) {
|
|
var outpoint = this.ins[i].outpoint.hash+':'+this.ins[i].outpoint.index,
|
|
histItem = hmap[outpoint];
|
|
if (!histItem) continue;
|
|
var thisInputAddrdata = addrdata.filter(function(a) {
|
|
return a.address == histItem.address;
|
|
});
|
|
if (thisInputAddrdata.length == 0) continue;
|
|
this.sign(i,thisInputAddrdata[0].key);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Signs a P2SH output at some index with the given key
|
|
*/
|
|
|
|
Transaction.prototype.p2shsign = function(index, script, key, type) {
|
|
script = new Script(script);
|
|
key = new ECKey(key);
|
|
type = type || SIGHASH_ALL;
|
|
var hash = this.hashTransactionForSignature(script, index, type),
|
|
sig = key.sign(hash).concat([type]);
|
|
return sig;
|
|
}
|
|
|
|
Transaction.prototype.multisign = Transaction.prototype.p2shsign;
|
|
|
|
Transaction.prototype.applyMultisigs = function(index, script, sigs, type) {
|
|
this.ins[index].script = Script.createMultiSigInputScript(sigs, script);
|
|
}
|
|
|
|
Transaction.prototype.validateSig = function(index, script, sig, pub) {
|
|
script = new Script(script);
|
|
var hash = this.hashTransactionForSignature(script,index,1);
|
|
return ECDSA.verify(hash, convert.coerceToBytes(sig),
|
|
convert.coerceToBytes(pub));
|
|
}
|
|
|
|
|
|
var TransactionIn = function (data) {
|
|
if (typeof data == "string")
|
|
this.outpoint = { hash: data.split(':')[0], index: data.split(':')[1] }
|
|
else if (data.outpoint)
|
|
this.outpoint = data.outpoint
|
|
else
|
|
this.outpoint = { hash: data.hash, index: data.index }
|
|
|
|
if (data.scriptSig)
|
|
this.script = Script.fromScriptSig(data.scriptSig)
|
|
else if (data.script)
|
|
this.script = data.script
|
|
else
|
|
this.script = new Script(data.script)
|
|
|
|
this.sequence = data.sequence || 4294967295;
|
|
};
|
|
|
|
TransactionIn.prototype.clone = function () {
|
|
return new TransactionIn({
|
|
outpoint: {
|
|
hash: this.outpoint.hash,
|
|
index: this.outpoint.index
|
|
},
|
|
script: this.script.clone(),
|
|
sequence: this.sequence
|
|
});
|
|
};
|
|
|
|
var TransactionOut = function (data) {
|
|
this.script =
|
|
data.script instanceof Script ? data.script.clone()
|
|
: Array.isArray(data.script) ? new Script(data.script)
|
|
: typeof data.script == "string" ? new Script(convert.hexToBytes(data.script))
|
|
: data.scriptPubKey ? Script.fromScriptSig(data.scriptPubKey)
|
|
: data.address ? Script.createOutputScript(data.address)
|
|
: new Script();
|
|
|
|
if (this.script.buffer.length > 0) this.address = this.script.toAddress();
|
|
|
|
this.value =
|
|
Array.isArray(data.value) ? convert.bytesToNum(data.value)
|
|
: "string" == typeof data.value ? parseInt(data.value)
|
|
: data.value instanceof BigInteger ? parseInt(data.value.toString())
|
|
: data.value;
|
|
};
|
|
|
|
TransactionOut.prototype.clone = function ()
|
|
{
|
|
var newTxout = new TransactionOut({
|
|
script: this.script.clone(),
|
|
value: this.value
|
|
});
|
|
return newTxout;
|
|
};
|
|
|
|
module.exports.Transaction = Transaction;
|
|
module.exports.TransactionIn = TransactionIn;
|
|
module.exports.TransactionOut = TransactionOut;
|