zcash-hackworks
/
bitcore-lib-zcash
mirror of https://github.com/zcash-hackworks/bitcore-lib-zcash.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

refactor and fixes for Transaction, ScriptInterpreter, and Key

This commit is contained in:
Manuel Araoz 2014-03-20 19:41:21 -03:00 committed by MattFaus
parent b227341c12
commit ba92a6b1df
5 changed files with 1073 additions and 1128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Key.js
View File

@ -77,6 +77,10 @@ if (process.versions) {
// return it as a buffer to keep c++ compatibility
return new Buffer(signature);
};
kSpec.prototype.verifySignature = function(hash, sig, callback) {
};
kSpec.prototype.verifySignatureSync = function(hash, sig) {
var self = this;

1326
ScriptInterpreter.js
View File

File diff suppressed because it is too large Load Diff

647
Transaction.js
View File

File diff suppressed because it is too large Load Diff

80
test/test.Transaction.js
View File

@ -24,17 +24,15 @@ function parse_test_transaction(entry) {
// Ignore comments
if (entry.length !== 3) return;
var inputs = [];
var inputs = {};
entry[0].forEach(function(vin) {
var hash = vin[0];
var hash = (vin[0]);
var index = vin[1];
var scriptPubKey = Script.fromHumanReadable(vin[2]);
inputs.push({
'prev_tx_hash': hash,
'index': index,
'scriptPubKey': scriptPubKey
});
var mapKey = [hash, index];
console.log('mapkey=' + mapKey);
inputs[mapKey] = scriptPubKey;
});
@ -341,53 +339,39 @@ describe('Transaction', function() {
* Bitcoin core transaction tests
*/
// Verify that known valid transactions are intepretted correctly
var cb = function(err, results) {
should.not.exist(err);
should.exist(results);
results.should.equal(true);
};
testdata.dataTxValid.forEach(function(datum) {
var testTx = parse_test_transaction(datum);
if (!testTx) return;
if (datum.length < 3) return;
var raw = datum[1];
var verifyP2SH = datum[2];
var transactionString = buffertools.toHex(
testTx.transaction.serialize());
it('valid tx=' + transactionString, function() {
it('valid tx=' + raw, function() {
// Verify that all inputs are valid
testTx.inputs.forEach(function(input) {
var testTx = parse_test_transaction(datum);
console.log(raw);
//buffertools.toHex(testTx.transaction.serialize()).should.equal(raw);
var inputs = testTx.transaction.inputs();
for (var i = 0; i < inputs.length; i++) {
console.log(' input number #########' + i);
var input = inputs[i];
buffertools.reverse(input[0]);
input[0] = buffertools.toHex(input[0]);
var mapKey = [input];
var scriptPubKey = testTx.inputs[mapKey];
if (!scriptPubKey) throw new Error('asdasdasdasd');
testTx.transaction.verifyInput(
input.index,
input.scriptPubKey,
{ verifyP2SH: verifyP2SH, dontVerifyStrictEnc: true},
function(err, results) {
// Exceptions raised inside this function will be handled
// ...by this function, so ignore if that is the case
if (err && err.constructor.name === 'AssertionError') return;
should.not.exist(err);
should.exist(results);
results.should.equal(true);
});
});
i,
scriptPubKey, {
verifyP2SH: verifyP2SH,
dontVerifyStrictEnc: true
},
cb);
}
});
});
// Verify that known invalid transactions are interpretted correctly
testdata.dataTxInvalid.forEach(function(datum) {
var testTx = parse_test_transaction(datum);
if (!testTx) return;
var transactionString = buffertools.toHex(
testTx.transaction.serialize());
it('valid tx=' + transactionString, function() {
// Verify that all inputs are invalid
testTx.inputs.forEach(function(input) {
testTx.transaction.verifyInput(input.index, input.scriptPubKey,
function(err, results) {
// Exceptions raised inside this function will be handled
// ...by this function, so ignore if that is the case
if (err && err.constructor.name === 'AssertionError') return;
// There should either be an error, or the results should be false.
(err !== null || (!err && results === false)).should.equal(true);
});
});
});
});
});

144
util/util.js
View File

@ -1,54 +1,51 @@
var crypto = require('crypto');
var bignum = require('bignum');
var Binary = require('binary');
var Put = require('bufferput');
var buffertools = require('buffertools');
var browser;
if (!process.versions) {
// browser version
var inBrowser = !process.versions;
if (inBrowser) {
browser = require('../browser/vendor-bundle.js');
}
var sha256 = exports.sha256 = function (data) {
var sha256 = exports.sha256 = function(data) {
return new Buffer(crypto.createHash('sha256').update(data).digest('binary'), 'binary');
};
var ripe160 = exports.ripe160 = function (data) {
var ripe160 = exports.ripe160 = function(data) {
if (!Buffer.isBuffer(data)) {
throw new Error('arg should be a buffer');
}
if (!process.versions) {
var w = new browser.crypto31.lib.WordArray.init(Crypto.util.bytesToWords(data), data.length);
if (inBrowser) {
var w = new browser.crypto31.lib.WordArray.init(browser.Crypto.util.bytesToWords(data), data.length);
var wordArray = browser.crypto31.RIPEMD160(w);
var words = wordArray.words;
var answer = [];
for (var b = 0; b < words.length * 32; b += 8) {
answer.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF);
answer.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF);
}
return new Buffer(answer, 'hex');
}
return new Buffer(crypto.createHash('rmd160').update(data).digest('binary'), 'binary');
};
var sha1 = exports.sha1 = function (data) {
var sha1 = exports.sha1 = function(data) {
return new Buffer(crypto.createHash('sha1').update(data).digest('binary'), 'binary');
};
var twoSha256 = exports.twoSha256 = function (data) {
var twoSha256 = exports.twoSha256 = function(data) {
return sha256(sha256(data));
};
var sha256ripe160 = exports.sha256ripe160 = function (data) {
var sha256ripe160 = exports.sha256ripe160 = function(data) {
return ripe160(sha256(data));
};
/**
* Format a block hash like the official client does.
*/
var formatHash = exports.formatHash = function (hash) {
var formatHash = exports.formatHash = function(hash) {
var hashEnd = new Buffer(10);
hash.copy(hashEnd, 0, 22, 32);
return buffertools.reverse(hashEnd).toString('hex');
@ -57,7 +54,7 @@ var formatHash = exports.formatHash = function (hash) {
/**
* Display the whole hash, as hex, in correct endian order.
*/
var formatHashFull = exports.formatHashFull = function (hash) {
var formatHashFull = exports.formatHashFull = function(hash) {
var copy = new Buffer(hash.length);
hash.copy(copy);
var hex = buffertools.toHex(buffertools.reverse(copy));
@ -69,13 +66,13 @@ var formatHashFull = exports.formatHashFull = function (hash) {
*
* Formats a block hash by removing leading zeros and truncating to 10 characters.
*/
var formatHashAlt = exports.formatHashAlt = function (hash) {
var formatHashAlt = exports.formatHashAlt = function(hash) {
var hex = formatHashFull(hash);
hex = hex.replace(/^0*/, '');
return hex.substr(0, 10);
};
var formatBuffer = exports.formatBuffer = function (buffer, maxLen) {
var formatBuffer = exports.formatBuffer = function(buffer, maxLen) {
// Calculate amount of bytes to display
if (maxLen === null) {
maxLen = 10;
@ -96,41 +93,47 @@ var formatBuffer = exports.formatBuffer = function (buffer, maxLen) {
return output;
};
var valueToBigInt = exports.valueToBigInt = function (valueBuffer) {
var valueToBigInt = exports.valueToBigInt = function(valueBuffer) {
if (Buffer.isBuffer(valueBuffer)) {
return bignum.fromBuffer(valueBuffer, {endian: 'little', size: 8});
return bignum.fromBuffer(valueBuffer, {
endian: 'little',
size: 8
});
} else {
return valueBuffer;
}
};
var bigIntToValue = exports.bigIntToValue = function (valueBigInt) {
var bigIntToValue = exports.bigIntToValue = function(valueBigInt) {
if (Buffer.isBuffer(valueBigInt)) {
return valueBigInt;
} else {
return valueBigInt.toBuffer({endian: 'little', size: 8});
return valueBigInt.toBuffer({
endian: 'little',
size: 8
});
}
};
var fitsInNBits = function(integer, n) {
// TODO: make this efficient!!!
return integer.toString(2).replace('-','').length < n;
return integer.toString(2).replace('-', '').length < n;
};
exports.bytesNeededToStore = bytesNeededToStore = function(integer) {
if (integer === 0) return 0;
return Math.ceil(((integer).toString(2).replace('-','').length + 1)/ 8);
return Math.ceil(((integer).toString(2).replace('-', '').length + 1) / 8);
};
exports.negativeBuffer = negativeBuffer = function(b) {
// implement two-complement negative
var c = new Buffer(b.length);
// negate each byte
for (var i=0; i<b.length; i++){
for (var i = 0; i < b.length; i++) {
c[i] = ~b[i];
if (c[i] < 0) c[i] += 256;
}
// add one
for (var i=b.length - 1; i>=0; i--){
for (var i = b.length - 1; i >= 0; i--) {
c[i] += 1;
if (c[i] >= 256) c[i] -= 256;
if (c[i] !== 0) break;
@ -141,7 +144,7 @@ exports.negativeBuffer = negativeBuffer = function(b) {
/*
* Transforms an integer into a buffer using two-complement encoding
* For example, 1 is encoded as 01 and -1 is encoded as ff
* For more info see:
* For more info see:
* http://en.wikipedia.org/wiki/Signed_number_representations#Two.27s_complement
*/
exports.intToBuffer2C = function(integer) {
@ -149,9 +152,9 @@ exports.intToBuffer2C = function(integer) {
var buf = new Put();
var s = integer.toString(16);
var neg = s[0] === '-';
s = s.replace('-','');
for (var i=0; i<size; i++) {
var si = s.substring(s.length - 2*(i+1), s.length - 2*(i));
s = s.replace('-', '');
for (var i = 0; i < size; i++) {
var si = s.substring(s.length - 2 * (i + 1), s.length - 2 * (i));
if (si.lenght === 1) {
si = '0' + si;
}
@ -184,7 +187,7 @@ var padSign = function(b) {
/*
* Transforms an integer into a buffer using sign+magnitude encoding
* For example, 1 is encoded as 01 and -1 is encoded as 81
* For more info see:
* For more info see:
* http://en.wikipedia.org/wiki/Signed_number_representations#Signed_magnitude_representation
*/
exports.intToBufferSM = function(v) {
@ -234,50 +237,45 @@ exports.bufferSMToInt = function(v) {
var formatValue = exports.formatValue = function (valueBuffer) {
var formatValue = exports.formatValue = function(valueBuffer) {
var value = valueToBigInt(valueBuffer).toString();
var integerPart = value.length > 8 ? value.substr(0, value.length-8) : '0';
var decimalPart = value.length > 8 ? value.substr(value.length-8) : value;
var integerPart = value.length > 8 ? value.substr(0, value.length - 8) : '0';
var decimalPart = value.length > 8 ? value.substr(value.length - 8) : value;
while (decimalPart.length < 8) {
decimalPart = "0"+decimalPart;
decimalPart = "0" + decimalPart;
}
decimalPart = decimalPart.replace(/0*$/, '');
while (decimalPart.length < 2) {
decimalPart += "0";
}
return integerPart+"."+decimalPart;
return integerPart + "." + decimalPart;
};
var reFullVal = /^\s*(\d+)\.(\d+)/;
var reFracVal = /^\s*\.(\d+)/;
var reWholeVal = /^\s*(\d+)/;
function padFrac(frac)
{
frac=frac.substr(0,8); //truncate to 8 decimal places
function padFrac(frac) {
frac = frac.substr(0, 8); //truncate to 8 decimal places
while (frac.length < 8)
frac = frac + '0';
return frac;
}
function parseFullValue(res)
{
function parseFullValue(res) {
return bignum(res[1]).mul('100000000').add(padFrac(res[2]));
}
function parseFracValue(res)
{
function parseFracValue(res) {
return bignum(padFrac(res[1]));
}
function parseWholeValue(res)
{
function parseWholeValue(res) {
return bignum(res[1]).mul('100000000');
}
exports.parseValue = function parseValue(valueStr)
{
if (typeof valueStr !== 'string')
exports.parseValue = function parseValue(valueStr) {
if (typeof valueStr !== 'string')
valueStr = valueStr.toString();
var res = valueStr.match(reFullVal);
@ -296,11 +294,11 @@ exports.parseValue = function parseValue(valueStr)
};
// Utility that synchronizes function calls based on a key
var createSynchrotron = exports.createSynchrotron = function (fn) {
var createSynchrotron = exports.createSynchrotron = function(fn) {
var table = {};
return function (key) {
return function(key) {
var args = Array.prototype.slice.call(arguments);
var run = function () {
var run = function() {
// Function fn() will call when it finishes
args[0] = function next() {
if (table[key]) {
@ -333,21 +331,23 @@ var createSynchrotron = exports.createSynchrotron = function (fn) {
*
* @returns Buffer random nonce
*/
var generateNonce = exports.generateNonce = function () {
var b32 = 0x100000000, ff = 0xff;
var b = new Buffer(8), i = 0;
var generateNonce = exports.generateNonce = function() {
var b32 = 0x100000000,
ff = 0xff;
var b = new Buffer(8),
i = 0;
// Generate eight random bytes
r = Math.random()*b32;
r = Math.random() * b32;
b[i++] = r & ff;
b[i++] = (r=r>>>8) & ff;
b[i++] = (r=r>>>8) & ff;
b[i++] = (r=r>>>8) & ff;
r = Math.random()*b32;
b[i++] = (r = r >>> 8) & ff;
b[i++] = (r = r >>> 8) & ff;
b[i++] = (r = r >>> 8) & ff;
r = Math.random() * b32;
b[i++] = r & ff;
b[i++] = (r=r>>>8) & ff;
b[i++] = (r=r>>>8) & ff;
b[i++] = (r=r>>>8) & ff;
b[i++] = (r = r >>> 8) & ff;
b[i++] = (r = r >>> 8) & ff;
b[i++] = (r = r >>> 8) & ff;
return b;
};
@ -357,10 +357,10 @@ var generateNonce = exports.generateNonce = function () {
*
* This function calculates the difficulty target given the difficulty bits.
*/
var decodeDiffBits = exports.decodeDiffBits = function (diffBits, asBigInt) {
var decodeDiffBits = exports.decodeDiffBits = function(diffBits, asBigInt) {
diffBits = +diffBits;
var target = bignum(diffBits & 0xffffff);
target = target.shiftLeft(8*((diffBits >>> 24) - 3));
target = target.shiftLeft(8 * ((diffBits >>> 24) - 3));
if (asBigInt) {
return target;
@ -370,7 +370,7 @@ var decodeDiffBits = exports.decodeDiffBits = function (diffBits, asBigInt) {
var diffBuf = target.toBuffer();
var targetBuf = new Buffer(32);
buffertools.fill(targetBuf, 0);
diffBuf.copy(targetBuf, 32-diffBuf.length);
diffBuf.copy(targetBuf, 32 - diffBuf.length);
return targetBuf;
};
@ -393,8 +393,8 @@ var encodeDiffBits = exports.encodeDiffBits = function encodeDiffBits(target) {
var compact = size << 24;
if (size >= 1) compact |= mpiBuf[4] << 16;
if (size >= 2) compact |= mpiBuf[5] << 8;
if (size >= 3) compact |= mpiBuf[6] ;
if (size >= 2) compact |= mpiBuf[5] << 8;
if (size >= 3) compact |= mpiBuf[6];
return compact;
};
@ -405,16 +405,20 @@ var encodeDiffBits = exports.encodeDiffBits = function encodeDiffBits(target) {
* This function calculates the maximum difficulty target divided by the given
* difficulty target.
*/
var calcDifficulty = exports.calcDifficulty = function (target) {
var calcDifficulty = exports.calcDifficulty = function(target) {
if (!Buffer.isBuffer(target)) {
target = decodeDiffBits(target);
}
var targetBigint = bignum.fromBuffer(target, {order: 'forward'});
var maxBigint = bignum.fromBuffer(MAX_TARGET, {order: 'forward'});
var targetBigint = bignum.fromBuffer(target, {
order: 'forward'
});
var maxBigint = bignum.fromBuffer(MAX_TARGET, {
order: 'forward'
});
return maxBigint.div(targetBigint).toNumber();
};
var reverseBytes32 = exports.reverseBytes32 = function (data) {
var reverseBytes32 = exports.reverseBytes32 = function(data) {
if (data.length % 4) {
throw new Error("Util.reverseBytes32(): Data length must be multiple of 4");
}