Merge pull request #561 from maraoz/ref/dir-structure
Refactor directory structure
This commit is contained in:
commit
f3da80b8b8
|
@ -8,7 +8,7 @@
|
|||
"eqeqeq": true, // Require triple equals i.e. `===`.
|
||||
"immed": true, // Require immediate invocations to be wrapped in parens e.g. `( function(){}() );`
|
||||
"latedef": true, // Prohibit variable use before definition.
|
||||
"newcap": true, // Require capitalization of all constructor functions e.g. `new F()`.
|
||||
"newcap": false, // Require capitalization of all constructor functions e.g. `new F()`.
|
||||
"noarg": true, // Prohibit use of `arguments.caller` and `arguments.callee`.
|
||||
"quotmark": "single", // Define quotes to string values.
|
||||
"regexp": true, // Prohibit `.` and `[^...]` in regular expressions.
|
||||
|
|
|
@ -4,7 +4,6 @@ module.exports = function(grunt) {
|
|||
|
||||
//Load NPM tasks
|
||||
grunt.loadNpmTasks('grunt-contrib-watch');
|
||||
grunt.loadNpmTasks('grunt-mocha-test');
|
||||
grunt.loadNpmTasks('grunt-markdown');
|
||||
grunt.loadNpmTasks('grunt-shell');
|
||||
|
||||
|
@ -17,7 +16,7 @@ module.exports = function(grunt) {
|
|||
stderr: true
|
||||
},
|
||||
command: grunt.option('target') === 'dev' ?
|
||||
'node ./browser/build.js -a -d; docco lib/* ' : 'node ./browser/build.js -a'
|
||||
'./browser/build; docco lib/* ' : './browser/build'
|
||||
}
|
||||
},
|
||||
watch: {
|
||||
|
@ -30,12 +29,6 @@ module.exports = function(grunt) {
|
|||
tasks: ['shell'],
|
||||
},
|
||||
},
|
||||
mochaTest: {
|
||||
options: {
|
||||
reporter: 'spec',
|
||||
},
|
||||
src: ['test/*.js'],
|
||||
},
|
||||
markdown: {
|
||||
all: {
|
||||
files: [{
|
||||
|
|
30
LICENSE.md
30
LICENSE.md
|
@ -1,30 +0,0 @@
|
|||
This software is licensed under the MIT License.
|
||||
|
||||
Copyright (c) 2014 Ryan X. Charles <ryanxcharles@gmail.com>
|
||||
|
||||
Parts of this software are based on bitcore
|
||||
Copyright (c) 2014 BitPay Inc.
|
||||
|
||||
Parts of this software are based on BitcoinJS
|
||||
Copyright (c) 2011 Stefan Thomas <justmoon@members.fsf.org>
|
||||
|
||||
Parts of this software are based on BitcoinJ
|
||||
Copyright (c) 2011 Google Inc.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
1104
examples.md
1104
examples.md
File diff suppressed because it is too large
Load Diff
|
@ -1,20 +0,0 @@
|
|||
var Identity = require('../lib/identity');
|
||||
var KeyPair = require('../lib/keypair');
|
||||
var Hash = require('../lib/hash');
|
||||
|
||||
var keypair = new KeyPair().fromRandom();
|
||||
|
||||
console.log( 'keypair:' , keypair );
|
||||
console.log( 'private key:' , keypair.privkey.toString('hex') );
|
||||
console.log( 'public key:' , keypair.pubkey.toString('hex') );
|
||||
console.log( 'public hash:' , Hash.sha256ripemd160( keypair.pubkey.toBuffer() ).toString('hex') );
|
||||
|
||||
|
||||
var identity = new Identity().fromPubkey( keypair.pubkey );
|
||||
|
||||
keypair.pubkey.compressed = false;
|
||||
var identityComp = new Identity().fromPubkey( keypair.pubkey );
|
||||
|
||||
console.log( 'identity:' , identity );
|
||||
console.log( 'identity string:' , identity.toString() );
|
||||
console.log( 'identity string, compressed:' , identityComp.toString() );
|
39
index.js
39
index.js
|
@ -1,44 +1,35 @@
|
|||
var bitcore = module.exports;
|
||||
|
||||
// protocol
|
||||
bitcore.Constants = require('./lib/protocol/constants');
|
||||
bitcore.Base58 = require('./lib/protocol/base58');
|
||||
bitcore.Base58Check = require('./lib/protocol/base58check');
|
||||
bitcore.BufferReader = require('./lib/protocol/bufferreader');
|
||||
bitcore.BufferWriter = require('./lib/protocol/bufferwriter');
|
||||
bitcore.Varint = require('./lib/protocol/varint');
|
||||
|
||||
// crypto
|
||||
bitcore.BN = require('./lib/crypto/bn');
|
||||
bitcore.ECDSA = require('./lib/crypto/ecdsa');
|
||||
bitcore.Hash = require('./lib/crypto/hash');
|
||||
bitcore.Random = require('./lib/crypto/random');
|
||||
bitcore.Point = require('./lib/crypto/point');
|
||||
|
||||
// main bitcoin library
|
||||
bitcore.Address = require('./lib/address');
|
||||
bitcore.Base58 = require('./lib/base58');
|
||||
bitcore.Base58Check = require('./lib/base58check');
|
||||
bitcore.BIP32 = require('./lib/bip32');
|
||||
bitcore.Block = require('./lib/block');
|
||||
bitcore.Blockheader = require('./lib/blockheader');
|
||||
bitcore.BN = require('./lib/bn');
|
||||
bitcore.BufferReader = require('./lib/bufferreader');
|
||||
bitcore.BufferWriter = require('./lib/bufferwriter');
|
||||
bitcore.Constants = require('./lib/constants');
|
||||
bitcore.ECDSA = require('./lib/ecdsa');
|
||||
bitcore.Hash = require('./lib/hash');
|
||||
bitcore.Identity = require('./lib/identity');
|
||||
bitcore.KDF = require('./lib/kdf');
|
||||
bitcore.Keypair = require('./lib/keypair');
|
||||
bitcore.Message = require('./lib/message');
|
||||
bitcore.Opcode = require('./lib/opcode');
|
||||
bitcore.Point = require('./lib/point');
|
||||
bitcore.Privkey = require('./lib/privkey');
|
||||
bitcore.Pubkey = require('./lib/pubkey');
|
||||
bitcore.Random = require('./lib/random');
|
||||
bitcore.Script = require('./lib/script');
|
||||
bitcore.Signature = require('./lib/signature');
|
||||
bitcore.Transaction = require('./lib/transaction');
|
||||
bitcore.Txin = require('./lib/txin');
|
||||
bitcore.Txout = require('./lib/txout');
|
||||
bitcore.Varint = require('./lib/varint');
|
||||
|
||||
//experimental, nonstandard, or unstable features
|
||||
bitcore.expmt = {};
|
||||
bitcore.expmt.AES = require('./lib/expmt/aes');
|
||||
bitcore.expmt.AESCBC = require('./lib/expmt/aescbc');
|
||||
bitcore.expmt.CBC = require('./lib/expmt/cbc');
|
||||
bitcore.expmt.ECIES = require('./lib/expmt/ecies');
|
||||
bitcore.expmt.StealthAddress = require('./lib/expmt/stealthaddress');
|
||||
bitcore.expmt.Stealthkey = require('./lib/expmt/stealthkey');
|
||||
bitcore.expmt.StealthMessage = require('./lib/expmt/stealthmessage');
|
||||
bitcore.expmt.StealthTx = require('./lib/expmt/stealthtx');
|
||||
|
||||
//dependencies, subject to change
|
||||
bitcore.deps = {};
|
||||
|
|
|
@ -1,6 +1,8 @@
|
|||
var base58check = require('./base58check');
|
||||
var constants = require('./constants');
|
||||
var Hash = require('./hash');
|
||||
'use strict';
|
||||
|
||||
var base58check = require('./protocol/base58check');
|
||||
var constants = require('./protocol/constants');
|
||||
var Hash = require('./crypto/hash');
|
||||
|
||||
function Address(buf) {
|
||||
if (!(this instanceof Address))
|
||||
|
@ -14,7 +16,7 @@ function Address(buf) {
|
|||
var obj = buf;
|
||||
this.set(obj);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
Address.prototype.set = function(obj) {
|
||||
this.hashbuf = obj.hashbuf || this.hashbuf || null;
|
||||
|
|
16
lib/bip32.js
16
lib/bip32.js
|
@ -1,12 +1,14 @@
|
|||
var Base58Check = require('./base58check');
|
||||
var Hash = require('./hash');
|
||||
'use strict';
|
||||
|
||||
var Base58Check = require('./protocol/base58check');
|
||||
var constants = require('./protocol/constants');
|
||||
var Hash = require('./crypto/hash');
|
||||
var Point = require('./crypto/point');
|
||||
var Random = require('./crypto/random');
|
||||
var BN = require('./crypto/bn');
|
||||
var Keypair = require('./keypair');
|
||||
var Pubkey = require('./pubkey');
|
||||
var Privkey = require('./privkey');
|
||||
var Point = require('./point');
|
||||
var Random = require('./random');
|
||||
var BN = require('./bn');
|
||||
var constants = require('./constants');
|
||||
|
||||
var BIP32 = function BIP32(obj) {
|
||||
if (!(this instanceof BIP32))
|
||||
|
@ -17,7 +19,7 @@ var BIP32 = function BIP32(obj) {
|
|||
} else if (obj ) {
|
||||
this.set(obj);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
BIP32.prototype.set = function(obj) {
|
||||
this.version = typeof obj.version !== 'undefined' ? obj.version : this.version;
|
||||
|
|
10
lib/block.js
10
lib/block.js
|
@ -1,9 +1,11 @@
|
|||
'use strict';
|
||||
|
||||
var Hash = require('./crypto/hash');
|
||||
var BufferReader = require('./protocol/bufferreader');
|
||||
var BufferWriter = require('./protocol/bufferwriter');
|
||||
var Varint = require('./protocol/varint');
|
||||
var Transaction = require('./transaction');
|
||||
var BufferReader = require('./bufferreader');
|
||||
var BufferWriter = require('./bufferwriter');
|
||||
var Blockheader = require('./blockheader');
|
||||
var Varint = require('./varint');
|
||||
var Hash = require('./hash');
|
||||
|
||||
var Block = function Block(magicnum, blocksize, blockheader, txsvi, txs) {
|
||||
if (!(this instanceof Block))
|
||||
|
|
|
@ -1,5 +1,7 @@
|
|||
var BufferReader = require('./bufferreader');
|
||||
var BufferWriter = require('./bufferwriter');
|
||||
'use strict';
|
||||
|
||||
var BufferReader = require('./protocol/bufferreader');
|
||||
var BufferWriter = require('./protocol/bufferwriter');
|
||||
|
||||
var Blockheader = function Blockheader(version, prevblockidbuf, merklerootbuf, time, bits, nonce) {
|
||||
if (!(this instanceof Blockheader))
|
||||
|
@ -20,7 +22,7 @@ var Blockheader = function Blockheader(version, prevblockidbuf, merklerootbuf, t
|
|||
var obj = version;
|
||||
this.set(obj);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Blockheader.prototype.set = function(obj) {
|
||||
this.version = typeof obj.version !== 'undefined' ? obj.version : this.version;
|
||||
|
|
|
@ -1,3 +1,5 @@
|
|||
'use strict';
|
||||
|
||||
var _BN = require('bn.js');
|
||||
|
||||
var BN = function BN_extended(n) {
|
|
@ -1,9 +1,11 @@
|
|||
'use strict';
|
||||
|
||||
var BN = require('./bn');
|
||||
var Point = require('./point');
|
||||
var Signature = require('./signature');
|
||||
var Keypair = require('./keypair');
|
||||
var Pubkey = require('./pubkey');
|
||||
var Random = require('./random');
|
||||
var Pubkey = require('../pubkey');
|
||||
var Keypair = require('../keypair');
|
||||
var Signature = require('../signature');
|
||||
|
||||
var ECDSA = function ECDSA(obj) {
|
||||
if (!(this instanceof ECDSA))
|
|
@ -1,3 +1,5 @@
|
|||
'use strict';
|
||||
|
||||
var hashjs = require('hash.js');
|
||||
var sha512 = require('sha512');
|
||||
|
|
@ -1,3 +1,5 @@
|
|||
'use strict';
|
||||
|
||||
var BN = require('./bn');
|
||||
var elliptic = require('elliptic');
|
||||
|
|
@ -1,5 +1,7 @@
|
|||
'use strict';
|
||||
|
||||
function Random() {
|
||||
};
|
||||
}
|
||||
|
||||
/* secure random bytes that sometimes throws an error due to lack of entropy */
|
||||
Random.getRandomBuffer = function(size) {
|
||||
|
@ -12,7 +14,7 @@ Random.getRandomBuffer = function(size) {
|
|||
Random.getRandomBufferNode = function(size) {
|
||||
var crypto = require('crypto');
|
||||
return crypto.randomBytes(size);
|
||||
}
|
||||
};
|
||||
|
||||
Random.getRandomBufferBrowser = function(size) {
|
||||
if (!window.crypto && !window.msCrypto)
|
||||
|
@ -36,11 +38,12 @@ Random.getRandomBufferBrowser = function(size) {
|
|||
Random.getPseudoRandomBuffer = function(size) {
|
||||
var b32 = 0x100000000;
|
||||
var b = new Buffer(size);
|
||||
var r;
|
||||
|
||||
for (var i = 0; i <= size; i++) {
|
||||
var j = Math.floor(i / 4);
|
||||
var k = i - j * 4;
|
||||
if (k == 0) {
|
||||
if (k === 0) {
|
||||
r = Math.random() * b32;
|
||||
b[i] = r & 0xff;
|
||||
} else {
|
|
@ -1,47 +0,0 @@
|
|||
var aes = require('aes');
|
||||
|
||||
var AES = function AES() {
|
||||
};
|
||||
|
||||
AES.encrypt = function(messagebuf, keybuf) {
|
||||
var key = AES.buf2words(keybuf);
|
||||
var message = AES.buf2words(messagebuf);
|
||||
var a = new aes(key);
|
||||
var enc = a.encrypt(message);
|
||||
var encbuf = AES.words2buf(enc);
|
||||
return encbuf;
|
||||
};
|
||||
|
||||
AES.decrypt = function(encbuf, keybuf) {
|
||||
var enc = AES.buf2words(encbuf);
|
||||
var key = AES.buf2words(keybuf);
|
||||
var a = new aes(key);
|
||||
var message = a.decrypt(enc);
|
||||
var messagebuf = AES.words2buf(message);
|
||||
return messagebuf;
|
||||
};
|
||||
|
||||
AES.buf2words = function(buf) {
|
||||
if (buf.length % 4)
|
||||
throw new Error('buf length must be a multiple of 4');
|
||||
|
||||
var words = [];
|
||||
|
||||
for (var i = 0; i < buf.length / 4; i++) {
|
||||
words.push(buf.readUInt32BE(i * 4));
|
||||
};
|
||||
|
||||
return words;
|
||||
};
|
||||
|
||||
AES.words2buf = function(words) {
|
||||
var buf = new Buffer(words.length * 4);
|
||||
|
||||
for (var i = 0; i < words.length; i++) {
|
||||
buf.writeUInt32BE(words[i], i * 4);
|
||||
};
|
||||
|
||||
return buf;
|
||||
};
|
||||
|
||||
module.exports = AES;
|
|
@ -1,34 +0,0 @@
|
|||
var AES = require('./aes');
|
||||
var CBC = require('./cbc');
|
||||
var Random = require('../random');
|
||||
var Hash = require('../hash');
|
||||
|
||||
// Symmetric encryption with AES and CBC convenience class
|
||||
var AESCBC = function AESCBC() {
|
||||
};
|
||||
|
||||
AESCBC.encrypt = function(messagebuf, passwordstr) {
|
||||
var cipherkeybuf = Hash.sha256(new Buffer(passwordstr));
|
||||
return AESCBC.encryptCipherkey(messagebuf, cipherkeybuf);
|
||||
};
|
||||
|
||||
AESCBC.decrypt = function(encbuf, passwordstr) {
|
||||
var cipherkeybuf = Hash.sha256(new Buffer(passwordstr));
|
||||
return AESCBC.decryptCipherkey(encbuf, cipherkeybuf);
|
||||
};
|
||||
|
||||
AESCBC.encryptCipherkey = function(messagebuf, cipherkeybuf, ivbuf) {
|
||||
ivbuf = ivbuf || Random.getRandomBuffer(128 / 8);
|
||||
var ctbuf = CBC.encrypt(messagebuf, ivbuf, AES, cipherkeybuf);
|
||||
var encbuf = Buffer.concat([ivbuf, ctbuf]);
|
||||
return encbuf;
|
||||
};
|
||||
|
||||
AESCBC.decryptCipherkey = function(encbuf, cipherkeybuf) {
|
||||
var ivbuf = encbuf.slice(0, 128 / 8);
|
||||
var ctbuf = encbuf.slice(128 / 8);
|
||||
var messagebuf = CBC.decrypt(ctbuf, ivbuf, AES, cipherkeybuf);
|
||||
return messagebuf;
|
||||
};
|
||||
|
||||
module.exports = AESCBC;
|
138
lib/expmt/cbc.js
138
lib/expmt/cbc.js
|
@ -1,138 +0,0 @@
|
|||
var Random = require('../random');
|
||||
|
||||
// Cipher Block Chaining
|
||||
// http://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Cipher-block_chaining_.28CBC.29
|
||||
var CBC = function CBC(blockcipher, cipherkeybuf, ivbuf) {
|
||||
if (!(this instanceof CBC))
|
||||
return new CBC(blockcipher, cipherkeybuf, ivbuf);
|
||||
|
||||
this.blockcipher = blockcipher;
|
||||
this.cipherkeybuf = cipherkeybuf;
|
||||
this.ivbuf = ivbuf;
|
||||
};
|
||||
|
||||
CBC.buf2blockbufs = function(buf, blocksize) {
|
||||
var bytesize = blocksize / 8;
|
||||
var blockbufs = [];
|
||||
|
||||
for (var i = 0; i <= buf.length / bytesize; i++) {
|
||||
var blockbuf = buf.slice(i * bytesize, i * bytesize + bytesize);
|
||||
|
||||
if (blockbuf.length < blocksize)
|
||||
blockbuf = CBC.pkcs7pad(blockbuf, blocksize);
|
||||
|
||||
blockbufs.push(blockbuf);
|
||||
}
|
||||
|
||||
return blockbufs;
|
||||
};
|
||||
|
||||
CBC.blockbufs2buf = function(blockbufs, blocksize) {
|
||||
var bytesize = blocksize / 8;
|
||||
|
||||
var last = blockbufs[blockbufs.length - 1];
|
||||
last = CBC.pkcs7unpad(last);
|
||||
blockbufs[blockbufs.length - 1] = last;
|
||||
|
||||
var buf = Buffer.concat(blockbufs);
|
||||
|
||||
return buf;
|
||||
};
|
||||
|
||||
CBC.encrypt = function(messagebuf, ivbuf, blockcipher, cipherkeybuf) {
|
||||
var blocksize = ivbuf.length * 8;
|
||||
var blockbufs = CBC.buf2blockbufs(messagebuf, blocksize);
|
||||
var encbufs = CBC.encryptblocks(blockbufs, ivbuf, blockcipher, cipherkeybuf);
|
||||
var encbuf = Buffer.concat(encbufs);
|
||||
return encbuf;
|
||||
};
|
||||
|
||||
CBC.decrypt = function(encbuf, ivbuf, blockcipher, cipherkeybuf) {
|
||||
var blocksize = ivbuf.length * 8;
|
||||
var bytesize = ivbuf.length;
|
||||
var encbufs = [];
|
||||
for (var i = 0; i < encbuf.length / bytesize; i++) {
|
||||
encbufs.push(encbuf.slice(i * bytesize, i * bytesize + bytesize));
|
||||
}
|
||||
var blockbufs = CBC.decryptblocks(encbufs, ivbuf, blockcipher, cipherkeybuf);
|
||||
var buf = CBC.blockbufs2buf(blockbufs, blocksize);
|
||||
return buf;
|
||||
};
|
||||
|
||||
CBC.encryptblock = function(blockbuf, ivbuf, blockcipher, cipherkeybuf) {
|
||||
var xorbuf = CBC.xorbufs(blockbuf, ivbuf);
|
||||
var encbuf = blockcipher.encrypt(xorbuf, cipherkeybuf);
|
||||
return encbuf;
|
||||
};
|
||||
|
||||
CBC.decryptblock = function(encbuf, ivbuf, blockcipher, cipherkeybuf) {
|
||||
var xorbuf = blockcipher.decrypt(encbuf, cipherkeybuf);
|
||||
var blockbuf = CBC.xorbufs(xorbuf, ivbuf);
|
||||
return blockbuf;
|
||||
};
|
||||
|
||||
CBC.encryptblocks = function(blockbufs, ivbuf, blockcipher, cipherkeybuf) {
|
||||
var encbufs = [];
|
||||
|
||||
for (var i = 0; i < blockbufs.length; i++) {
|
||||
var blockbuf = blockbufs[i];
|
||||
var encbuf = CBC.encryptblock(blockbuf, ivbuf, blockcipher, cipherkeybuf);
|
||||
|
||||
encbufs.push(encbuf);
|
||||
|
||||
ivbuf = encbuf;
|
||||
}
|
||||
|
||||
return encbufs;
|
||||
};
|
||||
|
||||
CBC.decryptblocks = function(encbufs, ivbuf, blockcipher, cipherkeybuf) {
|
||||
var blockbufs = [];
|
||||
|
||||
for (var i = 0; i < encbufs.length; i++) {
|
||||
var encbuf = encbufs[i];
|
||||
var blockbuf = CBC.decryptblock(encbuf, ivbuf, blockcipher, cipherkeybuf);
|
||||
|
||||
blockbufs.push(blockbuf);
|
||||
|
||||
ivbuf = encbuf;
|
||||
}
|
||||
|
||||
return blockbufs;
|
||||
};
|
||||
|
||||
CBC.pkcs7pad = function(buf, blocksize) {
|
||||
var bytesize = blocksize / 8;
|
||||
var padbytesize = bytesize - buf.length;
|
||||
var pad = new Buffer(padbytesize);
|
||||
pad.fill(padbytesize);
|
||||
var paddedbuf = Buffer.concat([buf, pad]);
|
||||
return paddedbuf;
|
||||
};
|
||||
|
||||
CBC.pkcs7unpad = function(paddedbuf, blocksize) {
|
||||
var bytesize = blocksize / 8;
|
||||
var padbytesize = bytesize - paddedbuf.length;
|
||||
var padlength = paddedbuf[paddedbuf.length - 1];
|
||||
var padbuf = paddedbuf.slice(paddedbuf.length - padlength, paddedbuf.length);
|
||||
var padbuf2 = new Buffer(padlength);
|
||||
padbuf2.fill(padlength);
|
||||
if (padbuf.toString('hex') !== padbuf2.toString('hex'))
|
||||
throw new Error('invalid padding');
|
||||
return paddedbuf.slice(0, paddedbuf.length - padlength);
|
||||
};
|
||||
|
||||
CBC.xorbufs = function(buf1, buf2) {
|
||||
if (buf1.length !== buf2.length)
|
||||
throw new Error('bufs must have the same length');
|
||||
|
||||
var buf = new Buffer(buf1.length);
|
||||
|
||||
for (var i = 0; i < buf1.length; i++) {
|
||||
buf[i] = buf1[i] ^ buf2[i];
|
||||
}
|
||||
|
||||
return buf;
|
||||
};
|
||||
|
||||
module.exports = CBC;
|
|
@ -1,55 +0,0 @@
|
|||
var AESCBC = require('./aescbc');
|
||||
var Keypair = require('../keypair');
|
||||
var Point = require('../point');
|
||||
var Hash = require('../hash');
|
||||
var Pubkey = require('../pubkey');
|
||||
var Privkey = require('../privkey');
|
||||
|
||||
// http://en.wikipedia.org/wiki/Integrated_Encryption_Scheme
|
||||
var ECIES = function ECIES() {
|
||||
if (!(this instanceof ECIES))
|
||||
return new ECIES();
|
||||
};
|
||||
|
||||
ECIES.encrypt = function(messagebuf, topubkey, fromkeypair, ivbuf) {
|
||||
if (!fromkeypair)
|
||||
fromkeypair = Keypair().fromRandom();
|
||||
var r = fromkeypair.privkey.bn;
|
||||
var R = fromkeypair.pubkey.point;
|
||||
var Rpubkey = fromkeypair.pubkey;
|
||||
var Rbuf = Rpubkey.toDER(true);
|
||||
var KB = topubkey.point;
|
||||
var P = KB.mul(r);
|
||||
var S = P.getX();
|
||||
var Sbuf = S.toBuffer({size: 32});
|
||||
var kEkM = Hash.sha512(Sbuf);
|
||||
var kE = kEkM.slice(0, 32);
|
||||
var kM = kEkM.slice(32, 64);
|
||||
var c = AESCBC.encryptCipherkey(messagebuf, kE, ivbuf);
|
||||
var d = Hash.sha256hmac(c, kM);
|
||||
var encbuf = Buffer.concat([Rbuf, c, d]);
|
||||
return encbuf;
|
||||
};
|
||||
|
||||
ECIES.decrypt = function(encbuf, toprivkey) {
|
||||
var kB = toprivkey.bn;
|
||||
var frompubkey = Pubkey().fromDER(encbuf.slice(0, 33));
|
||||
var R = frompubkey.point;
|
||||
var P = R.mul(kB);
|
||||
if (P.eq(new Point()))
|
||||
throw new Error('P equals 0');
|
||||
var S = P.getX();
|
||||
var Sbuf = S.toBuffer({size: 32});
|
||||
var kEkM = Hash.sha512(Sbuf);
|
||||
var kE = kEkM.slice(0, 32);
|
||||
var kM = kEkM.slice(32, 64);
|
||||
var c = encbuf.slice(33, encbuf.length - 32);
|
||||
var d = encbuf.slice(encbuf.length - 32, encbuf.length);
|
||||
var d2 = Hash.sha256hmac(c, kM);
|
||||
if (d.toString('hex') !== d2.toString('hex'))
|
||||
throw new Error('Invalid checksum');
|
||||
var messagebuf = AESCBC.decryptCipherkey(c, kE);
|
||||
return messagebuf;
|
||||
};
|
||||
|
||||
module.exports = ECIES;
|
|
@ -1,127 +0,0 @@
|
|||
var Stealthkey = require('./stealthkey');
|
||||
var Base58check = require('../base58check');
|
||||
var Pubkey = require('../pubkey');
|
||||
var KDF = require('../kdf');
|
||||
var BufferWriter = require('../bufferwriter');
|
||||
var BufferReader = require('../bufferreader');
|
||||
|
||||
var StealthAddress = function StealthAddress(addrstr) {
|
||||
if (!(this instanceof StealthAddress))
|
||||
return new StealthAddress(addrstr);
|
||||
|
||||
if (typeof addrstr === 'string') {
|
||||
this.fromString(addrstr)
|
||||
}
|
||||
else if (Buffer.isBuffer(addrstr)) {
|
||||
var buf = addrstr;
|
||||
this.fromBuffer(buf);
|
||||
}
|
||||
else if (addrstr) {
|
||||
var obj = addrstr;
|
||||
this.set(obj);
|
||||
}
|
||||
};
|
||||
|
||||
StealthAddress.mainver = 42;
|
||||
StealthAddress.testver = 43;
|
||||
|
||||
StealthAddress.prototype.set = function(obj) {
|
||||
this.payloadPubkey = obj.payloadPubkey || this.payloadPubkey;
|
||||
this.scanPubkey = obj.scanPubkey || this.scanPubkey;
|
||||
return this;
|
||||
};
|
||||
|
||||
StealthAddress.prototype.fromJSON = function(json) {
|
||||
this.fromString(json);
|
||||
return this;
|
||||
};
|
||||
|
||||
StealthAddress.prototype.toJSON = function() {
|
||||
return this.toString();
|
||||
};
|
||||
|
||||
StealthAddress.prototype.fromStealthkey = function(stealthkey) {
|
||||
this.set({
|
||||
payloadPubkey: stealthkey.payloadKeypair.pubkey,
|
||||
scanPubkey: stealthkey.scanKeypair.pubkey
|
||||
});
|
||||
return this;
|
||||
};
|
||||
|
||||
StealthAddress.prototype.fromBuffer = function(buf) {
|
||||
var parsed = StealthAddress.parseDWBuffer(buf);
|
||||
if ((parsed.version !== StealthAddress.mainver) && (parsed.version !== StealthAddress.testver))
|
||||
throw new Error('Invalid version');
|
||||
if (parsed.options !== 0)
|
||||
throw new Error('Invalid options');
|
||||
if (!parsed.scanPubkey)
|
||||
throw new Error('Invalid scanPubkey');
|
||||
if (parsed.payloadPubkeys.length !== 1)
|
||||
throw new Error('Must have exactly one payloadPubkey');
|
||||
if (parsed.nSigs !== 1)
|
||||
throw new Error('Must require exactly one signature');
|
||||
if (parsed.prefix.toString() !== "")
|
||||
throw new Error('Only blank prefixes supported');
|
||||
this.scanPubkey = parsed.scanPubkey;
|
||||
this.payloadPubkey = parsed.payloadPubkeys[0];
|
||||
return this;
|
||||
};
|
||||
|
||||
StealthAddress.prototype.fromString = function(str) {
|
||||
return this.fromBuffer(Base58check(str).toBuffer());
|
||||
};
|
||||
|
||||
StealthAddress.prototype.getSharedKeypair = function(senderKeypair) {
|
||||
var sharedSecretPoint = this.scanPubkey.point.mul(senderKeypair.privkey.bn);
|
||||
var sharedSecretPubkey = Pubkey(sharedSecretPoint);
|
||||
var buf = sharedSecretPubkey.toDER(true);
|
||||
var sharedKeypair = KDF.sha256hmac2keypair(buf);
|
||||
|
||||
return sharedKeypair;
|
||||
};
|
||||
|
||||
StealthAddress.prototype.getReceivePubkey = function(senderKeypair) {
|
||||
var sharedKeypair = this.getSharedKeypair(senderKeypair);
|
||||
var pubkey = Pubkey(this.payloadPubkey.point.add(sharedKeypair.pubkey.point));
|
||||
|
||||
return pubkey;
|
||||
};
|
||||
|
||||
StealthAddress.prototype.toBuffer = function(networkstr) {
|
||||
if (networkstr === 'testnet')
|
||||
var version = StealthAddress.testver;
|
||||
else
|
||||
var version = StealthAddress.mainver;
|
||||
var bw = new BufferWriter();
|
||||
bw.writeUInt8(version);
|
||||
bw.writeUInt8(0); //options
|
||||
bw.write(this.scanPubkey.toDER(true));
|
||||
bw.writeUInt8(1); //number of payload keys - we only support 1 (not multisig)
|
||||
bw.write(this.payloadPubkey.toDER(true));
|
||||
bw.writeUInt8(1); //number of signatures - we only support 1 (not multisig)
|
||||
bw.writeUInt8(0); //prefix length - we do not support prefix yet
|
||||
var buf = bw.concat();
|
||||
return buf;
|
||||
};
|
||||
|
||||
StealthAddress.prototype.toString = function(networkstr) {
|
||||
return Base58check(this.toBuffer(networkstr)).toString();
|
||||
};
|
||||
|
||||
StealthAddress.parseDWBuffer = function(buf) {
|
||||
var br = new BufferReader(buf);
|
||||
var parsed = {};
|
||||
parsed.version = br.readUInt8();
|
||||
parsed.options = br.readUInt8();
|
||||
parsed.scanPubkey = Pubkey().fromBuffer(br.read(33));
|
||||
parsed.nPayloadPubkeys = br.readUInt8();
|
||||
parsed.payloadPubkeys = [];
|
||||
for (var i = 0; i < parsed.nPayloadPubkeys; i++)
|
||||
parsed.payloadPubkeys.push(Pubkey().fromBuffer(br.read(33)));
|
||||
parsed.nSigs = br.readUInt8();
|
||||
parsed.nPrefix = br.readUInt8();
|
||||
parsed.prefix = br.read(parsed.nPrefix / 8);
|
||||
return parsed;
|
||||
};
|
||||
|
||||
module.exports = StealthAddress;
|
|
@ -1,88 +0,0 @@
|
|||
var Keypair = require('../keypair');
|
||||
var Privkey = require('../privkey');
|
||||
var Pubkey = require('../pubkey');
|
||||
var Point = require('../point');
|
||||
var Hash = require('../hash');
|
||||
var KDF = require('../kdf');
|
||||
|
||||
var Stealthkey = function Stealthkey(payloadKeypair, scanKeypair) {
|
||||
if (!(this instanceof Stealthkey))
|
||||
return new Stealthkey(payloadKeypair, scanKeypair);
|
||||
|
||||
if (payloadKeypair instanceof Keypair) {
|
||||
this.set({
|
||||
payloadKeypair: payloadKeypair,
|
||||
scanKeypair: scanKeypair
|
||||
});
|
||||
}
|
||||
else if (payloadKeypair) {
|
||||
var obj = payloadKeypair;
|
||||
this.set(obj);
|
||||
}
|
||||
};
|
||||
|
||||
Stealthkey.prototype.set = function(obj) {
|
||||
this.payloadKeypair = obj.payloadKeypair || this.payloadKeypair;
|
||||
this.scanKeypair = obj.scanKeypair || this.scanKeypair;
|
||||
return this;
|
||||
};
|
||||
|
||||
Stealthkey.prototype.fromJSON = function(json) {
|
||||
this.set({
|
||||
payloadKeypair: Keypair().fromJSON(json.payloadKeypair),
|
||||
scanKeypair: Keypair().fromJSON(json.scanKeypair)
|
||||
});
|
||||
return this;
|
||||
};
|
||||
|
||||
Stealthkey.prototype.toJSON = function() {
|
||||
return {
|
||||
payloadKeypair: this.payloadKeypair.toJSON(),
|
||||
scanKeypair: this.scanKeypair.toJSON()
|
||||
};
|
||||
};
|
||||
|
||||
Stealthkey.prototype.fromRandom = function() {
|
||||
this.payloadKeypair = Keypair().fromRandom();
|
||||
this.scanKeypair = Keypair().fromRandom();
|
||||
|
||||
return this;
|
||||
};
|
||||
|
||||
Stealthkey.prototype.getSharedKeypair = function(senderPubkey) {
|
||||
var sharedSecretPoint = senderPubkey.point.mul(this.scanKeypair.privkey.bn);
|
||||
var sharedSecretPubkey = Pubkey({point: sharedSecretPoint});
|
||||
var buf = sharedSecretPubkey.toDER(true);
|
||||
var sharedKeypair = KDF.sha256hmac2keypair(buf);
|
||||
|
||||
return sharedKeypair;
|
||||
};
|
||||
|
||||
Stealthkey.prototype.getReceivePubkey = function(senderPubkey) {
|
||||
var sharedKeypair = this.getSharedKeypair(senderPubkey);
|
||||
var pubkey = Pubkey({point: this.payloadKeypair.pubkey.point.add(sharedKeypair.pubkey.point)});
|
||||
|
||||
return pubkey;
|
||||
};
|
||||
|
||||
Stealthkey.prototype.getReceiveKeypair = function(senderPubkey) {
|
||||
var sharedKeypair = this.getSharedKeypair(senderPubkey);
|
||||
var privkey = Privkey({bn: this.payloadKeypair.privkey.bn.add(sharedKeypair.privkey.bn).mod(Point.getN())});
|
||||
var key = Keypair({privkey: privkey});
|
||||
key.privkey2pubkey();
|
||||
|
||||
return key;
|
||||
};
|
||||
|
||||
Stealthkey.prototype.isForMe = function(senderPubkey, myPossiblePubkeyhashbuf) {
|
||||
var pubkey = this.getReceivePubkey(senderPubkey);
|
||||
var pubkeybuf = pubkey.toDER(true);
|
||||
var pubkeyhash = Hash.sha256ripemd160(pubkeybuf);
|
||||
|
||||
if (pubkeyhash.toString('hex') === myPossiblePubkeyhashbuf.toString('hex'))
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
};
|
||||
|
||||
module.exports = Stealthkey;
|
|
@ -1,85 +0,0 @@
|
|||
var Stealthkey = require('./stealthkey');
|
||||
var StealthAddress = require('./stealthaddress');
|
||||
var ECIES = require('./ecies');
|
||||
var Message = require('../message');
|
||||
var Keypair = require('../keypair');
|
||||
var Address = require('../address');
|
||||
var Pubkey = require('../pubkey');
|
||||
|
||||
var StealthMessage = function StealthMessage(obj) {
|
||||
if (!(this instanceof StealthMessage))
|
||||
return new StealthMessage(obj);
|
||||
if (obj)
|
||||
this.set(obj);
|
||||
};
|
||||
|
||||
StealthMessage.prototype.set = function(obj) {
|
||||
this.messagebuf = obj.messagebuf || this.messagebuf;
|
||||
this.encbuf = obj.encbuf || this.encbuf;
|
||||
this.toStealthAddress = obj.toStealthAddress || this.toStealthAddress;
|
||||
this.toStealthkey = obj.toStealthkey || this.toStealthkey;
|
||||
this.fromKeypair = obj.fromKeypair || this.fromKeypair;
|
||||
this.receiveAddress = obj.receiveAddress || this.receiveAddress;
|
||||
return this;
|
||||
};
|
||||
|
||||
StealthMessage.encrypt = function(messagebuf, toStealthAddress, fromKeypair, ivbuf) {
|
||||
var sm = StealthMessage().set({
|
||||
messagebuf: messagebuf,
|
||||
toStealthAddress: toStealthAddress,
|
||||
fromKeypair: fromKeypair
|
||||
});
|
||||
sm.encrypt(ivbuf);
|
||||
var buf = Buffer.concat([
|
||||
sm.receiveAddress.hashbuf,
|
||||
sm.fromKeypair.pubkey.toDER(true),
|
||||
sm.encbuf
|
||||
]);
|
||||
return buf;
|
||||
};
|
||||
|
||||
StealthMessage.decrypt = function(buf, toStealthkey) {
|
||||
var sm = StealthMessage().set({
|
||||
toStealthkey: toStealthkey,
|
||||
receiveAddress: Address().set({hashbuf: buf.slice(0, 20)}),
|
||||
fromKeypair: Keypair().set({pubkey: Pubkey().fromDER(buf.slice(20, 20 + 33))}),
|
||||
encbuf: buf.slice(20 + 33)
|
||||
});
|
||||
return sm.decrypt().messagebuf;
|
||||
};
|
||||
|
||||
StealthMessage.isForMe = function(buf, toStealthkey) {
|
||||
var sm = StealthMessage().set({
|
||||
toStealthkey: toStealthkey,
|
||||
receiveAddress: Address().set({hashbuf: buf.slice(0, 20)}),
|
||||
fromKeypair: Keypair().set({pubkey: Pubkey().fromDER(buf.slice(20, 20 + 33))}),
|
||||
encbuf: buf.slice(20 + 33)
|
||||
});
|
||||
return sm.isForMe();
|
||||
};
|
||||
|
||||
StealthMessage.prototype.encrypt = function(ivbuf) {
|
||||
if (!this.fromKeypair)
|
||||
this.fromKeypair = Keypair().fromRandom();
|
||||
var receivePubkey = this.toStealthAddress.getReceivePubkey(this.fromKeypair);
|
||||
this.receiveAddress = Address().fromPubkey(receivePubkey);
|
||||
this.encbuf = ECIES.encrypt(this.messagebuf, receivePubkey, this.fromKeypair, ivbuf);
|
||||
return this;
|
||||
};
|
||||
|
||||
StealthMessage.prototype.decrypt = function() {
|
||||
var receiveKeypair = this.toStealthkey.getReceiveKeypair(this.fromKeypair.pubkey);
|
||||
this.messagebuf = ECIES.decrypt(this.encbuf, receiveKeypair.privkey);
|
||||
return this;
|
||||
};
|
||||
|
||||
StealthMessage.prototype.isForMe = function() {
|
||||
var receivePubkey = this.toStealthkey.getReceivePubkey(this.fromKeypair.pubkey);
|
||||
var receiveAddress = Address().fromPubkey(receivePubkey);
|
||||
if (receiveAddress.toString('hex') === this.receiveAddress.toString('hex'))
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
};
|
||||
|
||||
module.exports = StealthMessage;
|
|
@ -1,69 +0,0 @@
|
|||
var StealthAddress = require('./stealthaddress');
|
||||
var StealthKey = require('./stealthkey');
|
||||
var Transaction = require('../transaction');
|
||||
var Pubkey = require('../pubkey');
|
||||
|
||||
var StealthTx = function StealthTx(tx, sa, sk) {
|
||||
if (!(this instanceof StealthTx))
|
||||
return new StealthTx(tx, sa, sk);
|
||||
if (tx instanceof Transaction) {
|
||||
this.tx = tx;
|
||||
this.sa = sa;
|
||||
this.sk = sk;
|
||||
} else if (tx) {
|
||||
var obj = tx;
|
||||
this.set(obj);
|
||||
}
|
||||
};
|
||||
|
||||
StealthTx.prototype.set = function(obj) {
|
||||
this.sk = obj.sk || this.sk;
|
||||
this.sa = obj.sa || this.sa;
|
||||
this.tx = obj.tx || this.tx;
|
||||
return this;
|
||||
};
|
||||
|
||||
StealthTx.prototype.isForMe = function() {
|
||||
if (!this.notMine())
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
};
|
||||
|
||||
StealthTx.prototype.notMine = function() {
|
||||
var err;
|
||||
if (err = this.notStealth())
|
||||
return "Not stealth: " + err;
|
||||
var txopbuf = this.tx.txouts[0].script.chunks[1].buf;
|
||||
var parsed = StealthTx.parseOpReturnData(txopbuf);
|
||||
var pubkey = parsed.pubkey;
|
||||
var pubkeyhashbuf = this.tx.txouts[1].script.chunks[2].buf;
|
||||
var sk = this.sk;
|
||||
if (sk.isForMe(pubkey, pubkeyhashbuf)) {
|
||||
return false;
|
||||
} else {
|
||||
return "StealthTx not mine";
|
||||
}
|
||||
};
|
||||
|
||||
//For now, we only support a very limited variety of stealth tx
|
||||
StealthTx.prototype.notStealth = function() {
|
||||
var txouts = this.tx.txouts;
|
||||
if (!(txouts.length >= 2))
|
||||
return "Not enough txouts";
|
||||
if (!txouts[0].script.isOpReturn())
|
||||
return "First txout is not OP_RETURN";
|
||||
if (!txouts[1].script.isPubkeyhashOut())
|
||||
return "Second txout is not pubkeyhash";
|
||||
return false;
|
||||
};
|
||||
|
||||
StealthTx.parseOpReturnData = function(buf) {
|
||||
var parsed = {};
|
||||
parsed.version = buf[0];
|
||||
parsed.noncebuf = buf.slice(1, 5);
|
||||
parsed.pubkey = Pubkey().fromBuffer(buf.slice(5, 5 + 33));
|
||||
return parsed;
|
||||
};
|
||||
|
||||
module.exports = StealthTx;
|
117
lib/identity.js
117
lib/identity.js
|
@ -1,117 +0,0 @@
|
|||
var base58check = require('./base58check');
|
||||
var constants = require('./constants');
|
||||
var Hash = require('./hash');
|
||||
|
||||
function Identity(buf) {
|
||||
// TODO: instantiate identities without providing any configuration
|
||||
if (!(this instanceof Identity)) return new Identity(buf);
|
||||
|
||||
if (Buffer.isBuffer(buf)) {
|
||||
this.fromBuffer(buf);
|
||||
} else if (typeof buf === 'string') {
|
||||
var str = buf;
|
||||
this.fromString(str);
|
||||
} else if (buf) {
|
||||
var obj = buf;
|
||||
this.set(obj);
|
||||
}
|
||||
};
|
||||
|
||||
Identity.prototype.set = function(obj) {
|
||||
this.hashbuf = obj.hashbuf || this.hashbuf || null;
|
||||
this.networkstr = obj.networkstr || this.networkstr || 'ephemeral';
|
||||
this.typestr = obj.typestr || this.typestr || 'identity';
|
||||
return this;
|
||||
};
|
||||
|
||||
Identity.prototype.fromBuffer = function(buf) {
|
||||
// Identities are prefix + type + key
|
||||
if (buf.length !== 1 + 1 + 20)
|
||||
throw new Error('Identity buffers must be exactly 22 bytes (was '+buf.length+')');
|
||||
|
||||
var prefix = buf[0];
|
||||
var version = buf[1];
|
||||
|
||||
if (version === constants['ephemeral']['identity']) {
|
||||
this.networkstr = 'ephemeral';
|
||||
this.typestr = 'identity';
|
||||
} else if (version === constants['mainnet']['identity']) {
|
||||
this.networkstr = 'mainnet';
|
||||
this.typestr = 'identity';
|
||||
} else if (version === constants['testnet']['identity']) {
|
||||
this.networkstr = 'testnet';
|
||||
this.typestr = 'identity';
|
||||
} else {
|
||||
this.networkstr = 'unknown';
|
||||
this.typestr = 'unknown';
|
||||
}
|
||||
|
||||
if (prefix !== constants['ephemeral']['prefix'])
|
||||
throw new Error('Identity buffers must contain an identity prefix ('+constants['ephemeral']['prefix']+', was '+ prefix.toString() + ')');
|
||||
|
||||
this.hashbuf = buf.slice( 2 );
|
||||
|
||||
return this;
|
||||
};
|
||||
|
||||
Identity.prototype.fromHashbuf = function(hashbuf, networkstr, typestr) {
|
||||
if (hashbuf.length !== 20)
|
||||
throw new Error('hashbuf must be exactly 20 bytes');
|
||||
this.hashbuf = hashbuf;
|
||||
this.networkstr = networkstr || 'ephemeral';
|
||||
this.typestr = typestr || 'identity';
|
||||
return this;
|
||||
};
|
||||
|
||||
Identity.prototype.fromPubkey = function(pubkey, networkstr) {
|
||||
this.hashbuf = Hash.sha256ripemd160( pubkey.toBuffer() );
|
||||
this.networkstr = networkstr || 'ephemeral';
|
||||
this.typestr = 'identity';
|
||||
return this;
|
||||
};
|
||||
|
||||
Identity.prototype.fromString = function(str) {
|
||||
var buf = base58check.decode(str);
|
||||
return this.fromBuffer(buf);
|
||||
}
|
||||
|
||||
Identity.isValid = function(addrstr) {
|
||||
try {
|
||||
var address = new Identity().fromString( addrstr );
|
||||
} catch (e) {
|
||||
return false;
|
||||
}
|
||||
return address.isValid();
|
||||
};
|
||||
|
||||
Identity.prototype.isValid = function() {
|
||||
try {
|
||||
this.validate();
|
||||
return true;
|
||||
} catch (e) {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
Identity.prototype.toBuffer = function() {
|
||||
var prefix = new Buffer([ constants[ this.networkstr ][ 'prefix' ] ])
|
||||
var version = new Buffer([ constants[ this.networkstr ][ this.typestr ] ]);;
|
||||
var buf = Buffer.concat([ prefix , version, this.hashbuf ]);
|
||||
return buf;
|
||||
};
|
||||
|
||||
Identity.prototype.toString = function() {
|
||||
return base58check.encode( this.toBuffer() );
|
||||
};
|
||||
|
||||
Identity.prototype.validate = function() {
|
||||
if (!Buffer.isBuffer(this.hashbuf) || this.hashbuf.length !== 20)
|
||||
throw new Error('hash must be a buffer of 20 bytes');
|
||||
if (['ephemeral', 'mainnet', 'testnet'].indexOf( this.networkstr ))
|
||||
throw new Error('networkstr must be "ephemeral", "mainnet", or "testnet"');
|
||||
if (this.typestr !== 'identity')
|
||||
throw new Error('typestr must be "identity"');
|
||||
return this;
|
||||
};
|
||||
|
||||
module.exports = Identity;
|
31
lib/kdf.js
31
lib/kdf.js
|
@ -1,31 +0,0 @@
|
|||
var Bn = require('./bn');
|
||||
var Privkey = require('./privkey');
|
||||
var Point = require('./point');
|
||||
var Keypair = require('./keypair');
|
||||
var Hash = require('./hash');
|
||||
|
||||
function KDF() {
|
||||
};
|
||||
|
||||
KDF.buf2keypair = function(buf) {
|
||||
return KDF.sha256hmac2keypair(buf);
|
||||
};
|
||||
|
||||
KDF.sha256hmac2keypair = function(buf) {
|
||||
var privkey = KDF.sha256hmac2privkey(buf);
|
||||
var keypair = Keypair().fromPrivkey(privkey);
|
||||
return keypair;
|
||||
};
|
||||
|
||||
KDF.sha256hmac2privkey = function(buf) {
|
||||
var bn;
|
||||
var concat = new Buffer([]);
|
||||
do {
|
||||
var hash = Hash.sha256hmac(buf, concat);
|
||||
var bn = Bn.fromBuffer(hash);
|
||||
concat = Buffer.concat([concat, new Buffer(0)]);
|
||||
} while(!bn.lt(Point.getN()));
|
||||
return new Privkey({bn: bn});
|
||||
};
|
||||
|
||||
module.exports = KDF;
|
|
@ -1,3 +1,5 @@
|
|||
'use strict';
|
||||
|
||||
var Privkey = require('./privkey');
|
||||
var Pubkey = require('./pubkey');
|
||||
|
||||
|
|
|
@ -1,92 +0,0 @@
|
|||
var ECDSA = require('./ecdsa');
|
||||
var Keypair = require('./keypair');
|
||||
var BufferWriter = require('./bufferwriter');
|
||||
var Hash = require('./hash');
|
||||
var Address = require('./address');
|
||||
var Signature = require('./signature');
|
||||
|
||||
var Message = function Message(obj) {
|
||||
if (!(this instanceof Message))
|
||||
return new Message(obj);
|
||||
if (obj)
|
||||
this.set(obj);
|
||||
};
|
||||
|
||||
Message.prototype.set = function(obj) {
|
||||
this.messagebuf = obj.messagebuf || this.messagebuf;
|
||||
this.keypair = obj.keypair || this.keypair;
|
||||
this.sig = obj.sig || this.sig;
|
||||
this.address = obj.address || this.address;
|
||||
this.verified = typeof obj.verified !== 'undefined' ? obj.verified : this.verified;
|
||||
return this;
|
||||
};
|
||||
|
||||
Message.magicBytes = new Buffer('Bitcoin Signed Message:\n');
|
||||
|
||||
Message.magicHash = function(messagebuf) {
|
||||
if (!Buffer.isBuffer(messagebuf))
|
||||
throw new Error('messagebuf must be a buffer');
|
||||
var bw = new BufferWriter();
|
||||
bw.writeVarintNum(Message.magicBytes.length);
|
||||
bw.write(Message.magicBytes);
|
||||
bw.writeVarintNum(messagebuf.length);
|
||||
bw.write(messagebuf);
|
||||
var buf = bw.concat();
|
||||
|
||||
var hashbuf = Hash.sha256sha256(buf);
|
||||
|
||||
return hashbuf;
|
||||
};
|
||||
|
||||
Message.sign = function(messagebuf, keypair) {
|
||||
var m = Message({messagebuf: messagebuf, keypair: keypair});
|
||||
m.sign();
|
||||
var sigbuf = m.sig.toCompact();
|
||||
var sigstr = sigbuf.toString('base64');
|
||||
return sigstr;
|
||||
};
|
||||
|
||||
Message.verify = function(messagebuf, sigstr, address) {
|
||||
var sigbuf = new Buffer(sigstr, 'base64');
|
||||
var message = new Message();
|
||||
message.messagebuf = messagebuf;
|
||||
message.sig = Signature().fromCompact(sigbuf);
|
||||
message.address = address;
|
||||
|
||||
return message.verify().verified;
|
||||
};
|
||||
|
||||
Message.prototype.sign = function() {
|
||||
var hashbuf = Message.magicHash(this.messagebuf);
|
||||
var ecdsa = ECDSA({hashbuf: hashbuf, keypair: this.keypair});
|
||||
ecdsa.signRandomK();
|
||||
ecdsa.calci();
|
||||
this.sig = ecdsa.sig;
|
||||
return this;
|
||||
};
|
||||
|
||||
Message.prototype.verify = function() {
|
||||
var hashbuf = Message.magicHash(this.messagebuf);
|
||||
|
||||
var ecdsa = new ECDSA();
|
||||
ecdsa.hashbuf = hashbuf;
|
||||
ecdsa.sig = this.sig;
|
||||
ecdsa.keypair = new Keypair();
|
||||
ecdsa.keypair.pubkey = ecdsa.sig2pubkey();
|
||||
|
||||
if (!ecdsa.verify()) {
|
||||
this.verified = false;
|
||||
return this;
|
||||
}
|
||||
|
||||
var address = Address().fromPubkey(ecdsa.keypair.pubkey, undefined, this.sig.compressed);
|
||||
//TODO: what if livenet/testnet mismatch?
|
||||
if (address.hashbuf.toString('hex') === this.address.hashbuf.toString('hex'))
|
||||
this.verified = true;
|
||||
else
|
||||
this.verified = false;
|
||||
|
||||
return this;
|
||||
};
|
||||
|
||||
module.exports = Message;
|
|
@ -1,3 +1,5 @@
|
|||
'use strict';
|
||||
|
||||
function Opcode(num) {
|
||||
if (!(this instanceof Opcode))
|
||||
return new Opcode(num);
|
||||
|
|
|
@ -1,8 +1,10 @@
|
|||
var BN = require('./bn');
|
||||
var Point = require('./point');
|
||||
var constants = require('./constants');
|
||||
var base58check = require('./base58check');
|
||||
var Random = require('./random');
|
||||
'use strict';
|
||||
|
||||
var BN = require('./crypto/bn');
|
||||
var Point = require('./crypto/point');
|
||||
var Random = require('./crypto/random');
|
||||
var constants = require('./protocol/constants');
|
||||
var base58check = require('./protocol/base58check');
|
||||
|
||||
var Privkey = function Privkey(bn) {
|
||||
if (!(this instanceof Privkey))
|
||||
|
|
|
@ -1,3 +1,5 @@
|
|||
'use strict';
|
||||
|
||||
var bs58 = require('bs58');
|
||||
|
||||
var Base58 = function Base58(obj) {
|
|
@ -1,5 +1,7 @@
|
|||
'use strict';
|
||||
|
||||
var base58 = require('./base58');
|
||||
var sha256sha256 = require('./hash').sha256sha256;
|
||||
var sha256sha256 = require('../crypto/hash').sha256sha256;
|
||||
|
||||
var Base58Check = function Base58Check(obj) {
|
||||
if (!(this instanceof Base58Check))
|
|
@ -1,4 +1,6 @@
|
|||
var BN = require('./bn');
|
||||
'use strict';
|
||||
|
||||
var BN = require('../crypto/bn');
|
||||
|
||||
var BufferReader = function BufferReader(buf) {
|
||||
if (!(this instanceof BufferReader))
|
|
@ -1,4 +1,4 @@
|
|||
var BN = require('./bn');
|
||||
'use strict';
|
||||
|
||||
var BufferWriter = function BufferWriter(obj) {
|
||||
if (!(this instanceof BufferWriter))
|
|
@ -1,3 +1,5 @@
|
|||
'use strict';
|
||||
|
||||
exports.mainnet = {
|
||||
pubkeyhash: 0x00,
|
||||
identity: 0x0f,
|
||||
|
@ -23,4 +25,4 @@ exports.testnet = {
|
|||
exports.ephemeral = {
|
||||
prefix: 0x0f,
|
||||
identity: 0x02
|
||||
}
|
||||
};
|
|
@ -1,6 +1,8 @@
|
|||
'use strict';
|
||||
|
||||
var BufferWriter = require('./bufferwriter');
|
||||
var BufferReader = require('./bufferreader');
|
||||
var BN = require('./bn');
|
||||
var BN = require('../crypto/bn');
|
||||
|
||||
var Varint = function Varint(buf) {
|
||||
if (!(this instanceof Varint))
|
|
@ -1,6 +1,7 @@
|
|||
var Point = require('./point');
|
||||
var bn = require('./bn');
|
||||
var privkey = require('./privkey');
|
||||
'use strict';
|
||||
|
||||
var Point = require('./crypto/point');
|
||||
var bn = require('./crypto/bn');
|
||||
|
||||
var Pubkey = function Pubkey(point) {
|
||||
if (!(this instanceof Pubkey))
|
||||
|
|
|
@ -1,5 +1,7 @@
|
|||
var BufferReader = require('./bufferreader');
|
||||
var BufferWriter = require('./bufferwriter');
|
||||
'use strict';
|
||||
|
||||
var BufferReader = require('./protocol/bufferreader');
|
||||
var BufferWriter = require('./protocol/bufferwriter');
|
||||
var Opcode = require('./opcode');
|
||||
|
||||
var Script = function Script(buf) {
|
||||
|
|
|
@ -1,4 +1,6 @@
|
|||
var BN = require('./bn');
|
||||
'use strict';
|
||||
|
||||
var BN = require('./crypto/bn');
|
||||
|
||||
var Signature = function Signature(r, s) {
|
||||
if (!(this instanceof Signature))
|
||||
|
@ -25,12 +27,14 @@ Signature.prototype.set = function(obj) {
|
|||
|
||||
Signature.prototype.fromCompact = function(buf) {
|
||||
var compressed = true;
|
||||
var i = buf.slice(0, 1)[0] - 27 - 4;
|
||||
//TODO: handle uncompressed pubkeys
|
||||
/*
|
||||
if (i < 0) {
|
||||
var compressed = false;
|
||||
compressed = false;
|
||||
i = i + 4;
|
||||
}
|
||||
|
||||
var i = buf.slice(0, 1)[0] - 27 - 4; //TODO: handle uncompressed pubkeys
|
||||
*/
|
||||
|
||||
var b2 = buf.slice(1, 33);
|
||||
var b3 = buf.slice(33, 65);
|
||||
|
|
|
@ -1,9 +1,11 @@
|
|||
'use strict';
|
||||
|
||||
var BufferWriter = require('./protocol/bufferwriter');
|
||||
var BufferReader = require('./protocol/bufferreader');
|
||||
var Varint = require('./protocol/varint');
|
||||
var Hash = require('./crypto/hash');
|
||||
var Txin = require('./txin');
|
||||
var Txout = require('./txout');
|
||||
var BufferWriter = require('./bufferwriter');
|
||||
var BufferReader = require('./bufferreader');
|
||||
var Varint = require('./varint');
|
||||
var Hash = require('./hash');
|
||||
|
||||
var Transaction = function Transaction(version, txinsvi, txins, txoutsvi, txouts, nlocktime) {
|
||||
if (!(this instanceof Transaction))
|
||||
|
|
|
@ -1,6 +1,8 @@
|
|||
var BufferReader = require('./bufferreader');
|
||||
var BufferWriter = require('./bufferwriter');
|
||||
var Varint = require('./varint');
|
||||
'use strict';
|
||||
|
||||
var BufferReader = require('./protocol/bufferreader');
|
||||
var BufferWriter = require('./protocol/bufferwriter');
|
||||
var Varint = require('./protocol/varint');
|
||||
var Script = require('./script');
|
||||
|
||||
var Txin = function Txin(txidbuf, txoutnum, scriptvi, script, seqnum) {
|
||||
|
|
10
lib/txout.js
10
lib/txout.js
|
@ -1,7 +1,9 @@
|
|||
var BN = require('./bn');
|
||||
var BufferReader = require('./bufferreader');
|
||||
var BufferWriter = require('./bufferwriter');
|
||||
var Varint = require('./varint');
|
||||
'use strict';
|
||||
|
||||
var BN = require('./crypto/bn');
|
||||
var BufferReader = require('./protocol/bufferreader');
|
||||
var BufferWriter = require('./protocol/bufferwriter');
|
||||
var Varint = require('./protocol/varint');
|
||||
var Script = require('./script');
|
||||
|
||||
var Txout = function Txout(valuebn, scriptvi, script) {
|
||||
|
|
|
@ -72,9 +72,13 @@
|
|||
"sha512": "=0.0.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
"browserify": "~5.9.1",
|
||||
"chai": "~1.9.1",
|
||||
"mocha": "~1.21.0",
|
||||
"browserify": "~5.9.1"
|
||||
"grunt": "^0.4.5",
|
||||
"grunt-contrib-watch": "^0.6.1",
|
||||
"grunt-markdown": "^0.6.1",
|
||||
"grunt-shell": "^1.1.1",
|
||||
"mocha": "~1.21.0"
|
||||
},
|
||||
"license": "MIT"
|
||||
}
|
||||
|
|
|
@ -1,8 +1,11 @@
|
|||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var constants = require('../lib/constants');
|
||||
var Pubkey = require('../lib/pubkey');
|
||||
var Address = require('../lib/address');
|
||||
var Script = require('../lib/script');
|
||||
|
||||
var bitcore = require('..');
|
||||
var Pubkey = bitcore.Pubkey;
|
||||
var Address = bitcore.Address;
|
||||
var Script = bitcore.Script;
|
||||
|
||||
describe('Address', function() {
|
||||
var pubkeyhash = new Buffer('3c3fa3d4adcaf8f52d5b1843975e122548269937', 'hex');
|
||||
|
@ -12,9 +15,9 @@ describe('Address', function() {
|
|||
it('should create a new address object', function() {
|
||||
var address = new Address();
|
||||
should.exist(address);
|
||||
address = Address(buf);
|
||||
address = new Address(buf);
|
||||
should.exist(address);
|
||||
address = Address(str);
|
||||
address = new Address(str);
|
||||
should.exist(address);
|
||||
});
|
||||
|
||||
|
|
85
test/aes.js
85
test/aes.js
|
@ -1,85 +0,0 @@
|
|||
var should = require('chai').should();
|
||||
var Hash = require('../lib/hash');
|
||||
var AES = require('../lib/expmt/aes');
|
||||
|
||||
describe('AES', function() {
|
||||
var m128 = Hash.sha256(new Buffer('test1')).slice(0, 128 / 8);
|
||||
|
||||
var k128 = Hash.sha256(new Buffer('test2')).slice(0, 128 / 8);
|
||||
var k192 = Hash.sha256(new Buffer('test2')).slice(0, 192 / 8);
|
||||
var k256 = Hash.sha256(new Buffer('test2')).slice(0, 256 / 8);
|
||||
|
||||
var e128 = new Buffer('3477e13884125038f4dc24e9d2cfbbc7', 'hex');
|
||||
var e192 = new Buffer('b670954c0e2da1aaa5f9063de04eb961', 'hex');
|
||||
var e256 = new Buffer('dd2ce24581183a4a7c0b1068f8bc79f0', 'hex');
|
||||
|
||||
|
||||
describe('@encrypt', function() {
|
||||
|
||||
it('should encrypt with a 128 bit key', function() {
|
||||
var encbuf = AES.encrypt(m128, k128);
|
||||
encbuf.toString('hex').should.equal(e128.toString('hex'));
|
||||
});
|
||||
|
||||
it('should encrypt with a 192 bit key', function() {
|
||||
var encbuf = AES.encrypt(m128, k192);
|
||||
encbuf.toString('hex').should.equal(e192.toString('hex'));
|
||||
});
|
||||
|
||||
it('should encrypt with a 256 bit key', function() {
|
||||
var encbuf = AES.encrypt(m128, k256);
|
||||
encbuf.toString('hex').should.equal(e256.toString('hex'));
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@decrypt', function() {
|
||||
|
||||
it('should encrypt/decrypt with a 128 bit key', function() {
|
||||
var encbuf = AES.encrypt(m128, k128);
|
||||
var m = AES.decrypt(encbuf, k128);
|
||||
m.toString('hex').should.equal(m128.toString('hex'));
|
||||
});
|
||||
|
||||
it('should encrypt/decrypt with a 192 bit key', function() {
|
||||
var encbuf = AES.encrypt(m128, k192);
|
||||
var m = AES.decrypt(encbuf, k192);
|
||||
m.toString('hex').should.equal(m128.toString('hex'));
|
||||
});
|
||||
|
||||
it('should encrypt/decrypt with a 256 bit key', function() {
|
||||
var encbuf = AES.encrypt(m128, k256);
|
||||
var m = AES.decrypt(encbuf, k256);
|
||||
m.toString('hex').should.equal(m128.toString('hex'));
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@buf2words', function() {
|
||||
|
||||
it('should convert this 4 length buffer into an array', function() {
|
||||
var buf = new Buffer([0, 0, 0, 0]);
|
||||
var words = AES.buf2words(buf);
|
||||
words.length.should.equal(1);
|
||||
});
|
||||
|
||||
it('should throw an error on this 5 length buffer', function() {
|
||||
var buf = new Buffer([0, 0, 0, 0, 0]);
|
||||
(function() {
|
||||
var words = AES.buf2words(buf);
|
||||
}).should.throw();
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@words2buf', function() {
|
||||
|
||||
it('should convert this array into a buffer', function() {
|
||||
var a = [100, 0];
|
||||
var buf = AES.words2buf(a);
|
||||
buf.length.should.equal(8);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
});
|
|
@ -1,73 +0,0 @@
|
|||
var should = require('chai').should();
|
||||
var AESCBC = require('../lib/expmt/aescbc');
|
||||
|
||||
describe('AESCBC', function() {
|
||||
|
||||
describe('@encrypt', function() {
|
||||
|
||||
it('should return encrypt one block', function() {
|
||||
var password = "password";
|
||||
var messagebuf = new Buffer(128 / 8 - 1);
|
||||
messagebuf.fill(0);
|
||||
var encbuf = AESCBC.encrypt(messagebuf, password);
|
||||
encbuf.length.should.equal(128 / 8 + 128 / 8);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@decrypt', function() {
|
||||
|
||||
it('should decrypt that which was encrypted', function() {
|
||||
var password = "password";
|
||||
var messagebuf = new Buffer(128 / 8 - 1);
|
||||
messagebuf.fill(0);
|
||||
var encbuf = AESCBC.encrypt(messagebuf, password);
|
||||
var messagebuf2 = AESCBC.decrypt(encbuf, password);
|
||||
messagebuf2.toString('hex').should.equal(messagebuf.toString('hex'));
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@encryptCipherkey', function() {
|
||||
|
||||
it('should return encrypt one block', function() {
|
||||
var cipherkeybuf = new Buffer(256 / 8);
|
||||
cipherkeybuf.fill(0x10);
|
||||
var ivbuf = new Buffer(128 / 8);
|
||||
ivbuf.fill(0);
|
||||
var messagebuf = new Buffer(128 / 8 - 1);
|
||||
messagebuf.fill(0);
|
||||
var encbuf = AESCBC.encryptCipherkey(messagebuf, cipherkeybuf, ivbuf);
|
||||
encbuf.length.should.equal(128 / 8 + 128 / 8);
|
||||
});
|
||||
|
||||
it('should return encrypt two blocks', function() {
|
||||
var cipherkeybuf = new Buffer(256 / 8);
|
||||
cipherkeybuf.fill(0x10);
|
||||
var ivbuf = new Buffer(128 / 8);
|
||||
ivbuf.fill(0);
|
||||
var messagebuf = new Buffer(128 / 8);
|
||||
messagebuf.fill(0);
|
||||
var encbuf = AESCBC.encryptCipherkey(messagebuf, cipherkeybuf, ivbuf);
|
||||
encbuf.length.should.equal(128 / 8 + 128 / 8 + 128 / 8);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@decryptCipherkey', function() {
|
||||
|
||||
it('should decrypt that which was encrypted', function() {
|
||||
var cipherkeybuf = new Buffer(256 / 8);
|
||||
cipherkeybuf.fill(0x10);
|
||||
var ivbuf = new Buffer(128 / 8);
|
||||
ivbuf.fill(0);
|
||||
var messagebuf = new Buffer(128 / 8);
|
||||
messagebuf.fill(0);
|
||||
var encbuf = AESCBC.encryptCipherkey(messagebuf, cipherkeybuf, ivbuf);
|
||||
var messagebuf2 = AESCBC.decryptCipherkey(encbuf, cipherkeybuf);
|
||||
messagebuf2.toString('hex').should.equal(messagebuf.toString('hex'));
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
});
|
|
@ -1,12 +1,15 @@
|
|||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var constants = require('../lib/constants');
|
||||
var BIP32 = require('../lib/bip32');
|
||||
var bitcore = require('..');
|
||||
var constants = bitcore.constants;
|
||||
var BIP32 = bitcore.BIP32;
|
||||
|
||||
describe('BIP32', function() {
|
||||
|
||||
//test vectors: https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki
|
||||
var vector1_master = '000102030405060708090a0b0c0d0e0f';
|
||||
var vector1_m_public = 'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8'
|
||||
var vector1_m_public = 'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8';
|
||||
var vector1_m_private = 'xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi';
|
||||
var vector1_m0h_public = 'xpub68Gmy5EdvgibQVfPdqkBBCHxA5htiqg55crXYuXoQRKfDBFA1WEjWgP6LHhwBZeNK1VTsfTFUHCdrfp1bgwQ9xv5ski8PX9rL2dZXvgGDnw';
|
||||
var vector1_m0h_private = 'xprv9uHRZZhk6KAJC1avXpDAp4MDc3sQKNxDiPvvkX8Br5ngLNv1TxvUxt4cV1rGL5hj6KCesnDYUhd7oWgT11eZG7XnxHrnYeSvkzY7d2bhkJ7';
|
||||
|
|
|
@ -1,25 +1,25 @@
|
|||
var Blockheader = require('../lib/blockheader');
|
||||
var Block = require('../lib/block');
|
||||
var BufferWriter = require('../lib/bufferwriter');
|
||||
var BufferReader = require('../lib/bufferreader');
|
||||
var Varint = require('../lib/varint');
|
||||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var Transaction = require('../lib/transaction');
|
||||
var bitcore = require('..');
|
||||
var Blockheader = bitcore.Blockheader;
|
||||
var Block = bitcore.Block;
|
||||
var BufferReader = bitcore.BufferReader;
|
||||
var Varint = bitcore.Varint;
|
||||
var Transaction = bitcore.Transaction;
|
||||
|
||||
describe('Block', function() {
|
||||
|
||||
var txidhex = '8c9aa966d35bfeaf031409e0001b90ccdafd8d859799eb945a3c515b8260bcf2';
|
||||
var txhex = '01000000029e8d016a7b0dc49a325922d05da1f916d1e4d4f0cb840c9727f3d22ce8d1363f000000008c493046022100e9318720bee5425378b4763b0427158b1051eec8b08442ce3fbfbf7b30202a44022100d4172239ebd701dae2fbaaccd9f038e7ca166707333427e3fb2a2865b19a7f27014104510c67f46d2cbb29476d1f0b794be4cb549ea59ab9cc1e731969a7bf5be95f7ad5e7f904e5ccf50a9dc1714df00fbeb794aa27aaff33260c1032d931a75c56f2ffffffffa3195e7a1ab665473ff717814f6881485dc8759bebe97e31c301ffe7933a656f020000008b48304502201c282f35f3e02a1f32d2089265ad4b561f07ea3c288169dedcf2f785e6065efa022100e8db18aadacb382eed13ee04708f00ba0a9c40e3b21cf91da8859d0f7d99e0c50141042b409e1ebbb43875be5edde9c452c82c01e3903d38fa4fd89f3887a52cb8aea9dc8aec7e2c9d5b3609c03eb16259a2537135a1bf0f9c5fbbcbdbaf83ba402442ffffffff02206b1000000000001976a91420bb5c3bfaef0231dc05190e7f1c8e22e098991e88acf0ca0100000000001976a9149e3e2d23973a04ec1b02be97c30ab9f2f27c3b2c88ac00000000';
|
||||
var txbuf = new Buffer(txhex, 'hex');
|
||||
var tx = Transaction().fromBuffer(txbuf);
|
||||
var magicnum = 0xd9b4bef9;
|
||||
var blocksize = 50;
|
||||
bhhex = '0100000005050505050505050505050505050505050505050505050505050505050505050909090909090909090909090909090909090909090909090909090909090909020000000300000004000000';
|
||||
bhbuf = new Buffer(bhhex, 'hex');
|
||||
var bh = Blockheader().fromBuffer(bhbuf);
|
||||
var txsvi = Varint(1);
|
||||
var txs = [Transaction().fromBuffer(txbuf)];
|
||||
var block = Block().set({
|
||||
var bhhex = '0100000005050505050505050505050505050505050505050505050505050505050505050909090909090909090909090909090909090909090909090909090909090909020000000300000004000000';
|
||||
var bhbuf = new Buffer(bhhex, 'hex');
|
||||
var bh = new Blockheader().fromBuffer(bhbuf);
|
||||
var txsvi = new Varint(1);
|
||||
var txs = [new Transaction().fromBuffer(txbuf)];
|
||||
var block = new Block().set({
|
||||
magicnum: magicnum,
|
||||
blocksize: blocksize,
|
||||
blockheader: bh,
|
||||
|
|
|
@ -1,7 +1,9 @@
|
|||
var Blockheader = require('../lib/blockheader');
|
||||
var BufferWriter = require('../lib/bufferwriter');
|
||||
var BufferReader = require('../lib/bufferreader');
|
||||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var bitcore = require('..');
|
||||
var Blockheader = bitcore.Blockheader;
|
||||
var BufferReader = bitcore.BufferReader;
|
||||
|
||||
describe('Blockheader', function() {
|
||||
|
||||
|
@ -22,8 +24,8 @@ describe('Blockheader', function() {
|
|||
bits: bits,
|
||||
nonce: nonce
|
||||
});
|
||||
bhhex = '0100000005050505050505050505050505050505050505050505050505050505050505050909090909090909090909090909090909090909090909090909090909090909020000000300000004000000';
|
||||
bhbuf = new Buffer(bhhex, 'hex');
|
||||
var bhhex = '0100000005050505050505050505050505050505050505050505050505050505050505050909090909090909090909090909090909090909090909090909090909090909020000000300000004000000';
|
||||
var bhbuf = new Buffer(bhhex, 'hex');
|
||||
|
||||
it('should make a new blockheader', function() {
|
||||
var blockheader = new Blockheader();
|
||||
|
|
317
test/cbc.js
317
test/cbc.js
|
@ -1,317 +0,0 @@
|
|||
var AES = require('../lib/expmt/aes');
|
||||
var should = require('chai').should();
|
||||
var CBC = require('../lib/expmt/cbc');
|
||||
|
||||
describe('CBC', function() {
|
||||
|
||||
it('should return a new CBC', function() {
|
||||
var cbc = new CBC();
|
||||
should.exist(cbc);
|
||||
})
|
||||
|
||||
it('should return a new CBC when called without "new"', function() {
|
||||
var cbc = new CBC();
|
||||
should.exist(cbc);
|
||||
});
|
||||
|
||||
describe('@buf2blockbufs', function() {
|
||||
|
||||
it('should convert this buffer into one block', function() {
|
||||
var buf = new Buffer(16 - 1);
|
||||
buf.fill(0);
|
||||
var blockbufs = CBC.buf2blockbufs(buf, 16 * 8);
|
||||
blockbufs.length.should.equal(1);
|
||||
blockbufs[0].toString('hex').should.equal('00000000000000000000000000000001');
|
||||
});
|
||||
|
||||
it('should convert this buffer into two blocks', function() {
|
||||
var buf = new Buffer(16);
|
||||
buf.fill(0);
|
||||
var blockbufs = CBC.buf2blockbufs(buf, 16 * 8);
|
||||
blockbufs.length.should.equal(2);
|
||||
blockbufs[0].toString('hex').should.equal('00000000000000000000000000000000');
|
||||
blockbufs[1].toString('hex').should.equal('10101010101010101010101010101010');
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@buf2blockbufs', function() {
|
||||
|
||||
it('should convert this buffer into one block and back into the same buffer', function() {
|
||||
var buf = new Buffer(16 - 1);
|
||||
buf.fill(0);
|
||||
var blockbufs = CBC.buf2blockbufs(buf, 16 * 8);
|
||||
var buf2 = CBC.blockbufs2buf(blockbufs, 16 * 8);
|
||||
buf2.toString('hex').should.equal(buf.toString('hex'));
|
||||
});
|
||||
|
||||
it('should convert this buffer into two blocks and back into the same buffer', function() {
|
||||
var buf = new Buffer(16);
|
||||
buf.fill(0);
|
||||
var blockbufs = CBC.buf2blockbufs(buf, 16 * 8);
|
||||
var buf2 = CBC.blockbufs2buf(blockbufs, 16 * 8);
|
||||
buf2.toString('hex').should.equal(buf.toString('hex'));
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@encrypt', function() {
|
||||
|
||||
it('should return this known value', function() {
|
||||
var messagebuf1 = new Buffer(128 / 8);
|
||||
messagebuf1.fill(0);
|
||||
var messagebuf2 = new Buffer(128 / 8);
|
||||
messagebuf2.fill(0x10);
|
||||
var messagebuf = Buffer.concat([messagebuf1, messagebuf2]);
|
||||
var ivbuf = new Buffer(128 / 8);
|
||||
ivbuf.fill(0x10);
|
||||
var cipherkeybuf = new Buffer(128 / 8);
|
||||
cipherkeybuf.fill(0);
|
||||
var blockcipher = {};
|
||||
blockcipher.encrypt = function(messagebuf, cipherkeybuf) {
|
||||
return messagebuf;
|
||||
};
|
||||
blockcipher.decrypt = function(messagebuf, cipherkeybuf) {
|
||||
return messagebuf;
|
||||
};
|
||||
var encbuf = CBC.encrypt(messagebuf, ivbuf, blockcipher, cipherkeybuf);
|
||||
var buf2 = CBC.decrypt(encbuf, ivbuf, blockcipher, cipherkeybuf);
|
||||
});
|
||||
|
||||
it('should return this shorter known value', function() {
|
||||
var messagebuf1 = new Buffer(128 / 8);
|
||||
messagebuf1.fill(0);
|
||||
var messagebuf2 = new Buffer(120 / 8);
|
||||
messagebuf2.fill(0x10);
|
||||
var messagebuf = Buffer.concat([messagebuf1, messagebuf2]);
|
||||
var ivbuf = new Buffer(128 / 8);
|
||||
ivbuf.fill(0x10);
|
||||
var cipherkeybuf = new Buffer(128 / 8);
|
||||
cipherkeybuf.fill(0);
|
||||
var blockcipher = {};
|
||||
blockcipher.encrypt = function(messagebuf, cipherkeybuf) {
|
||||
return messagebuf;
|
||||
};
|
||||
blockcipher.decrypt = function(messagebuf, cipherkeybuf) {
|
||||
return messagebuf;
|
||||
};
|
||||
var encbuf = CBC.encrypt(messagebuf, ivbuf, blockcipher, cipherkeybuf);
|
||||
var buf2 = CBC.decrypt(encbuf, ivbuf, blockcipher, cipherkeybuf);
|
||||
});
|
||||
|
||||
it('should return this shorter known value', function() {
|
||||
var messagebuf1 = new Buffer(128 / 8);
|
||||
messagebuf1.fill(0);
|
||||
var messagebuf2 = new Buffer(136 / 8);
|
||||
messagebuf2.fill(0x10);
|
||||
var messagebuf = Buffer.concat([messagebuf1, messagebuf2]);
|
||||
var ivbuf = new Buffer(128 / 8);
|
||||
ivbuf.fill(0x10);
|
||||
var cipherkeybuf = new Buffer(128 / 8);
|
||||
cipherkeybuf.fill(0);
|
||||
var blockcipher = {};
|
||||
blockcipher.encrypt = function(messagebuf, cipherkeybuf) {
|
||||
return messagebuf;
|
||||
};
|
||||
blockcipher.decrypt = function(messagebuf, cipherkeybuf) {
|
||||
return messagebuf;
|
||||
};
|
||||
var encbuf = CBC.encrypt(messagebuf, ivbuf, blockcipher, cipherkeybuf);
|
||||
var buf2 = CBC.decrypt(encbuf, ivbuf, blockcipher, cipherkeybuf);
|
||||
});
|
||||
|
||||
it('should encrypt something with AES', function() {
|
||||
var messagebuf1 = new Buffer(128 / 8);
|
||||
messagebuf1.fill(0);
|
||||
var messagebuf2 = new Buffer(128 / 8);
|
||||
messagebuf2.fill(0x10);
|
||||
var messagebuf = Buffer.concat([messagebuf1, messagebuf2]);
|
||||
var ivbuf = new Buffer(128 / 8);
|
||||
ivbuf.fill(0x10);
|
||||
var cipherkeybuf = new Buffer(128 / 8);
|
||||
cipherkeybuf.fill(0);
|
||||
var blockcipher = AES;
|
||||
var encbuf = CBC.encrypt(messagebuf, ivbuf, blockcipher, cipherkeybuf);
|
||||
var buf2 = CBC.decrypt(encbuf, ivbuf, blockcipher, cipherkeybuf);
|
||||
buf2.toString('hex').should.equal(messagebuf.toString('hex'));
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@decrypt', function() {
|
||||
|
||||
it('should properly decrypt an encrypted message', function() {
|
||||
var messagebuf1 = new Buffer(128 / 8);
|
||||
messagebuf1.fill(0);
|
||||
var messagebuf2 = new Buffer(128 / 8);
|
||||
messagebuf2.fill(0x10);
|
||||
var messagebuf = Buffer.concat([messagebuf1, messagebuf2]);
|
||||
var ivbuf = new Buffer(128 / 8);
|
||||
ivbuf.fill(0x10);
|
||||
var cipherkeybuf = new Buffer(128 / 8);
|
||||
cipherkeybuf.fill(0);
|
||||
var blockcipher = {};
|
||||
blockcipher.encrypt = function(messagebuf, cipherkeybuf) {
|
||||
return messagebuf;
|
||||
};
|
||||
blockcipher.decrypt = function(messagebuf, cipherkeybuf) {
|
||||
return messagebuf;
|
||||
};
|
||||
var encbuf = CBC.encrypt(messagebuf, ivbuf, blockcipher, cipherkeybuf);
|
||||
var messagebuf2 = CBC.decrypt(encbuf, ivbuf, blockcipher, cipherkeybuf);
|
||||
messagebuf2.toString('hex').should.equal(messagebuf.toString('hex'));
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@encryptblock', function() {
|
||||
|
||||
it('should return this known value', function() {
|
||||
var messagebuf = new Buffer(128 / 8);
|
||||
messagebuf.fill(0);
|
||||
var ivbuf = new Buffer(128 / 8);
|
||||
ivbuf.fill(0x10);
|
||||
var cipherkeybuf = new Buffer(128 / 8);
|
||||
cipherkeybuf.fill(0);
|
||||
var blockcipher = {};
|
||||
blockcipher.encrypt = function(messagebuf, cipherkeybuf) {
|
||||
return messagebuf;
|
||||
};
|
||||
var enc = CBC.encryptblock(messagebuf, ivbuf, blockcipher, cipherkeybuf);
|
||||
enc.toString('hex').should.equal(ivbuf.toString('hex'));
|
||||
});
|
||||
|
||||
it('should return this other known value', function() {
|
||||
var messagebuf = new Buffer(128 / 8);
|
||||
messagebuf.fill(0x10);
|
||||
var ivbuf = new Buffer(128 / 8);
|
||||
ivbuf.fill(0x10);
|
||||
var cipherkeybuf = new Buffer(128 / 8);
|
||||
cipherkeybuf.fill(0);
|
||||
var blockcipher = {};
|
||||
blockcipher.encrypt = function(messagebuf, cipherkeybuf) {
|
||||
return messagebuf;
|
||||
};
|
||||
var enc = CBC.encryptblock(messagebuf, ivbuf, blockcipher, cipherkeybuf);
|
||||
enc.toString('hex').should.equal('00000000000000000000000000000000');
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@decryptblock', function() {
|
||||
|
||||
it('should decrypt an encrypted block', function() {
|
||||
var messagebuf = new Buffer(128 / 8);
|
||||
messagebuf.fill(0);
|
||||
var ivbuf = new Buffer(128 / 8);
|
||||
ivbuf.fill(0x10);
|
||||
var cipherkeybuf = new Buffer(128 / 8);
|
||||
cipherkeybuf.fill(0);
|
||||
var blockcipher = {};
|
||||
blockcipher.encrypt = function(messagebuf, cipherkeybuf) {
|
||||
return messagebuf;
|
||||
};
|
||||
blockcipher.decrypt = function(messagebuf, cipherkeybuf) {
|
||||
return messagebuf;
|
||||
};
|
||||
var encbuf = CBC.encryptblock(messagebuf, ivbuf, blockcipher, cipherkeybuf);
|
||||
var buf = CBC.decryptblock(encbuf, ivbuf, blockcipher, cipherkeybuf);
|
||||
buf.toString('hex').should.equal(messagebuf.toString('hex'));
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@encryptblocks', function() {
|
||||
|
||||
it('should return this known value', function() {
|
||||
var messagebuf1 = new Buffer(128 / 8);
|
||||
messagebuf1.fill(0);
|
||||
var messagebuf2 = new Buffer(128 / 8);
|
||||
messagebuf2.fill(0x10);
|
||||
var ivbuf = new Buffer(128 / 8);
|
||||
ivbuf.fill(0x10);
|
||||
var cipherkeybuf = new Buffer(128 / 8);
|
||||
cipherkeybuf.fill(0);
|
||||
var blockcipher = {}
|
||||
blockcipher.encrypt = function(messagebuf, cipherkeybuf) {
|
||||
return messagebuf;
|
||||
};
|
||||
var encbufs = CBC.encryptblocks([messagebuf1, messagebuf2], ivbuf, blockcipher, cipherkeybuf);
|
||||
encbufs[0].toString('hex').should.equal('10101010101010101010101010101010');
|
||||
encbufs[1].toString('hex').should.equal('00000000000000000000000000000000');
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@decryptblocks', function() {
|
||||
|
||||
it('should decrypt encrypted blocks', function() {
|
||||
var messagebuf1 = new Buffer(128 / 8);
|
||||
messagebuf1.fill(0);
|
||||
var messagebuf2 = new Buffer(128 / 8);
|
||||
messagebuf2.fill(0x10);
|
||||
var ivbuf = new Buffer(128 / 8);
|
||||
ivbuf.fill(0x10);
|
||||
var cipherkeybuf = new Buffer(128 / 8);
|
||||
cipherkeybuf.fill(0);
|
||||
var blockcipher = {}
|
||||
blockcipher.encrypt = function(messagebuf, cipherkeybuf) {
|
||||
return messagebuf;
|
||||
};
|
||||
blockcipher.decrypt = function(messagebuf, cipherkeybuf) {
|
||||
return messagebuf;
|
||||
};
|
||||
var encbufs = CBC.encryptblocks([messagebuf1, messagebuf2], ivbuf, blockcipher, cipherkeybuf);
|
||||
var bufs = CBC.decryptblocks(encbufs, ivbuf, blockcipher, cipherkeybuf);
|
||||
bufs[0].toString('hex').should.equal(messagebuf1.toString('hex'));
|
||||
bufs[1].toString('hex').should.equal(messagebuf2.toString('hex'));
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@pkcs7pad', function() {
|
||||
|
||||
it('should pad this 32 bit buffer to 128 bits with the number 128/8 - 32/8', function() {
|
||||
var buf = new Buffer(32 / 8);
|
||||
buf.fill(0);
|
||||
var padbuf = CBC.pkcs7pad(buf, 128);
|
||||
padbuf.length.should.equal(128 / 8);
|
||||
padbuf[32 / 8].should.equal(128 / 8 - 32 / 8);
|
||||
padbuf[32 / 8 + 1].should.equal(128 / 8 - 32 / 8);
|
||||
// ...
|
||||
padbuf[32 / 8 + 128 / 8 - 32 / 8 - 1].should.equal(128 / 8 - 32 / 8);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@pkcs7unpad', function() {
|
||||
|
||||
it('should unpad this padded 32 bit buffer', function() {
|
||||
var buf = new Buffer(32 / 8);
|
||||
buf.fill(0);
|
||||
var paddedbuf = CBC.pkcs7pad(buf, 128);
|
||||
var unpaddedbuf = CBC.pkcs7unpad(paddedbuf, 128);
|
||||
unpaddedbuf.toString('hex').should.equal(buf.toString('hex'));
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@xorbufs', function() {
|
||||
|
||||
it('should xor 1 and 0', function() {
|
||||
var buf1 = new Buffer([1]);
|
||||
var buf2 = new Buffer([0]);
|
||||
var buf = CBC.xorbufs(buf1, buf2);
|
||||
buf[0].should.equal(1);
|
||||
});
|
||||
|
||||
it('should xor 1 and 1', function() {
|
||||
var buf1 = new Buffer([1]);
|
||||
var buf2 = new Buffer([1]);
|
||||
var buf = CBC.xorbufs(buf1, buf2);
|
||||
buf[0].should.equal(0);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
});
|
|
@ -1,7 +1,8 @@
|
|||
var chai = chai || require('chai');
|
||||
var should = chai.should();
|
||||
var assert = chai.assert;
|
||||
var BN = require('../lib/bn');
|
||||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var bitcore = require('../..');
|
||||
var BN = bitcore.BN;
|
||||
|
||||
describe('BN', function() {
|
||||
it('should create a bn', function() {
|
||||
|
@ -18,7 +19,7 @@ describe('BN', function() {
|
|||
it('should parse numbers below and at bn.js internal word size', function() {
|
||||
var bn = new BN(Math.pow(2, 26) - 1);
|
||||
bn.toString().should.equal((Math.pow(2, 26) - 1).toString());
|
||||
var bn = new BN(Math.pow(2, 26));
|
||||
bn = new BN(Math.pow(2, 26));
|
||||
bn.toString().should.equal((Math.pow(2, 26)).toString());
|
||||
});
|
||||
|
|
@ -1,17 +1,21 @@
|
|||
var ECDSA = require('../lib/ecdsa');
|
||||
var Hash = require('../lib/hash');
|
||||
var Keypair = require('../lib/keypair');
|
||||
var Privkey = require('../lib/privkey');
|
||||
var Pubkey = require('../lib/pubkey');
|
||||
var Signature = require('../lib/signature');
|
||||
var BN = require('../lib/bn');
|
||||
var point = require('../lib/point');
|
||||
var should = require('chai').should();
|
||||
'use strict';
|
||||
|
||||
describe("ECDSA", function() {
|
||||
var should = require('chai').should();
|
||||
var bitcore = require('../..');
|
||||
var ECDSA = bitcore.ECDSA;
|
||||
var Hash = bitcore.Hash;
|
||||
var Keypair = bitcore.Keypair;
|
||||
var Privkey = bitcore.Privkey;
|
||||
var Pubkey = bitcore.Pubkey;
|
||||
var Signature = bitcore.Signature;
|
||||
var BN = bitcore.BN;
|
||||
var point = bitcore.Point;
|
||||
|
||||
describe('ECDSA', function() {
|
||||
|
||||
it('should create a blank ecdsa', function() {
|
||||
var ecdsa = new ECDSA();
|
||||
should.exist(ecdsa);
|
||||
});
|
||||
|
||||
var ecdsa = new ECDSA();
|
|
@ -1,9 +1,12 @@
|
|||
var should = require('chai').should();
|
||||
var Hash = require('../lib/hash');
|
||||
'use strict';
|
||||
|
||||
require('chai').should();
|
||||
var bitcore = require('../..');
|
||||
var Hash = bitcore.Hash;
|
||||
|
||||
describe('Hash', function() {
|
||||
var buf = new Buffer([0, 1, 2, 3, 253, 254, 255]);
|
||||
var str = "test string";
|
||||
var str = 'test string';
|
||||
|
||||
describe('#sha256', function() {
|
||||
|
|
@ -1,6 +1,9 @@
|
|||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var point = require('../lib/point');
|
||||
var BN = require('../lib/bn');
|
||||
var bitcore = require('../..');
|
||||
var point = bitcore.Point;
|
||||
var BN = bitcore.BN;
|
||||
|
||||
describe('Point', function() {
|
||||
|
|
@ -1,5 +1,8 @@
|
|||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var Random = require('../lib/random');
|
||||
var bitcore = require('../..');
|
||||
var Random = bitcore.Random;
|
||||
|
||||
describe('Random', function() {
|
||||
|
||||
|
@ -21,7 +24,7 @@ describe('Random', function() {
|
|||
var hexs = [];
|
||||
for (var i = 0; i < 100; i++)
|
||||
hexs[i] = Random.getRandomBuffer(8).toString('hex');
|
||||
for (var i = 0; i < 100; i++)
|
||||
for (i = 0; i < 100; i++)
|
||||
for (var j = i + 1; j < 100; j++)
|
||||
hexs[i].should.not.equal(hexs[j]);
|
||||
});
|
|
@ -1,52 +0,0 @@
|
|||
var ECIES = require('../lib/expmt/ecies');
|
||||
var should = require('chai').should();
|
||||
var Keypair = require('../lib/keypair');
|
||||
var Hash = require('../lib/hash');
|
||||
|
||||
describe('#ECIES', function() {
|
||||
|
||||
it('should make a new ECIES object', function() {
|
||||
var ecies = new ECIES();
|
||||
should.exist(ecies);
|
||||
});
|
||||
|
||||
it('should make a new ECIES object when called without "new"', function() {
|
||||
var ecies = ECIES();
|
||||
should.exist(ecies);
|
||||
});
|
||||
|
||||
var fromkey = Keypair().fromRandom();
|
||||
var tokey = Keypair().fromRandom();
|
||||
var messagebuf = Hash.sha256(new Buffer('my message is the hash of this string'));
|
||||
|
||||
describe('@encrypt', function() {
|
||||
|
||||
it('should return a buffer', function() {
|
||||
var encbuf = ECIES.encrypt(messagebuf, tokey.pubkey, fromkey);
|
||||
Buffer.isBuffer(encbuf).should.equal(true);
|
||||
});
|
||||
|
||||
it('should return a buffer if fromkey is not present', function() {
|
||||
var encbuf = ECIES.encrypt(messagebuf, tokey.pubkey);
|
||||
Buffer.isBuffer(encbuf).should.equal(true);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@decrypt', function() {
|
||||
|
||||
it('should decrypt that which was encrypted', function() {
|
||||
var encbuf = ECIES.encrypt(messagebuf, tokey.pubkey, fromkey);
|
||||
var messagebuf2 = ECIES.decrypt(encbuf, tokey.privkey);
|
||||
messagebuf2.toString('hex').should.equal(messagebuf.toString('hex'));
|
||||
});
|
||||
|
||||
it('should decrypt that which was encrypted if fromkeypair was randomly generated', function() {
|
||||
var encbuf = ECIES.encrypt(messagebuf, tokey.pubkey);
|
||||
var messagebuf2 = ECIES.decrypt(encbuf, tokey.privkey);
|
||||
messagebuf2.toString('hex').should.equal(messagebuf.toString('hex'));
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
});
|
|
@ -1,4 +1,6 @@
|
|||
if (process.browser)
|
||||
'use strict';
|
||||
|
||||
if (process.browser || true) // no examples yet
|
||||
return; //examples are loaded from files, which doesn't work in the browser
|
||||
|
||||
var should = require('chai').should();
|
||||
|
@ -9,11 +11,8 @@ describe('Examples', function() {
|
|||
var filenames = fs.readdirSync(__dirname + '/../examples/');
|
||||
|
||||
filenames.forEach(function(filename) {
|
||||
|
||||
if (filename.slice(filename.length - 3) === '.js') {
|
||||
|
||||
describe(filename, function() {
|
||||
|
||||
it('should not throw any errors', function() {
|
||||
(function() {
|
||||
var save = console.log;
|
||||
|
@ -22,11 +21,7 @@ describe('Examples', function() {
|
|||
console.log = save;
|
||||
}).should.not.throw();
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
}
|
||||
|
||||
});
|
||||
|
||||
});
|
||||
|
|
171
test/identity.js
171
test/identity.js
|
@ -1,171 +0,0 @@
|
|||
var should = require('chai').should();
|
||||
var constants = require('../lib/constants');
|
||||
var PubKey = require('../lib/pubkey');
|
||||
var Identity = require('../lib/identity');
|
||||
|
||||
describe('Identity', function() {
|
||||
|
||||
var knownPrivKey = 'L3e3ZneXzGw2wyyRoUxKGGrHCBhBE3uPMvQDXPaJTom4d4ogRxvC';
|
||||
var knownPubKey = '02ff0c643214634691e6f1c5044df79f7002c404407c8db1897484017e1082f182';
|
||||
var knownPubKeyHash = 'bceb8b52237d7a6c09e9aaedcf26cf387530d23e';
|
||||
var knownIdent = 'TfEmMAA5PSQRRJgiZka8y6B5x1pABHe6BVv';
|
||||
var knownIdentComp = 'TfDBCwB4ciatE4Kx3r1TK5kfCTxrrpG1H8J';
|
||||
|
||||
var pubkeyhash = new Buffer( knownPubKeyHash , 'hex');
|
||||
|
||||
//var buf = Buffer.concat([ new Buffer([0]), new Buffer([0]), pubkeyhash ]);
|
||||
// note: key is wrong string until I figure out how to duplicate the generation of short keys
|
||||
//var buf = Buffer.concat([ new Buffer( 0x0f ) , new Buffer( 0x02 ) , pubkeyhash ])
|
||||
var buf = Buffer.concat([ new Buffer([0x0f]) , new Buffer([0x02]) , pubkeyhash ])
|
||||
var str = knownIdent;
|
||||
|
||||
it('should create a new identity object', function() {
|
||||
var identity = new Identity();
|
||||
should.exist(identity);
|
||||
identity = Identity(buf);
|
||||
should.exist(identity);
|
||||
identity = Identity(str);
|
||||
should.exist(identity);
|
||||
});
|
||||
|
||||
describe('@isValid', function() {
|
||||
|
||||
it('should validate this valid identity string', function() {
|
||||
Identity.isValid( str ).should.equal( true );
|
||||
});
|
||||
|
||||
it('should invalidate this valid identity string', function() {
|
||||
Identity.isValid(str.substr(1)).should.equal(false);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#fromBuffer', function() {
|
||||
|
||||
it('should make an identity from a buffer', function() {
|
||||
Identity().fromBuffer(buf).toString().should.equal(str);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#fromHashbuf', function() {
|
||||
|
||||
it('should make an identity from a hashbuf', function() {
|
||||
Identity().fromHashbuf(pubkeyhash).toString().should.equal(str);
|
||||
var a = Identity().fromHashbuf(pubkeyhash, 'testnet', 'scripthash');
|
||||
a.networkstr.should.equal('testnet');
|
||||
a.typestr.should.equal('scripthash');
|
||||
});
|
||||
|
||||
it('should throw an error for invalid length hashbuf', function() {
|
||||
(function() {
|
||||
Identity().fromHashbuf(buf);
|
||||
}).should.throw('hashbuf must be exactly 20 bytes');
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#fromPubkey', function() {
|
||||
|
||||
it('should make this identity from a compressed pubkey', function() {
|
||||
var pubkey = new PubKey();
|
||||
pubkey.fromDER(new Buffer( knownPubKey , 'hex'));
|
||||
var identity = new Identity();
|
||||
identity.fromPubkey(pubkey);
|
||||
identity.toString().should.equal( knownIdent );
|
||||
});
|
||||
|
||||
it('should make this identity from an uncompressed pubkey', function() {
|
||||
var pubkey = new PubKey();
|
||||
pubkey.fromDER(new Buffer( knownPubKey , 'hex'));
|
||||
var identity = new Identity();
|
||||
pubkey.compressed = false;
|
||||
identity.fromPubkey(pubkey, 'ephemeral');
|
||||
identity.toString().should.equal( knownIdentComp );
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#fromString', function() {
|
||||
|
||||
it('should derive from this known ephemeral identity string', function() {
|
||||
var identity = new Identity();
|
||||
identity.fromString( str );
|
||||
identity.toBuffer().slice(2).toString('hex').should.equal(pubkeyhash.toString('hex'));
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#isValid', function() {
|
||||
|
||||
it('should describe this valid identity as valid', function() {
|
||||
var identity = new Identity();
|
||||
identity.fromString( knownIdent );
|
||||
identity.isValid().should.equal(true);
|
||||
});
|
||||
|
||||
it('should describe this identity with unknown network as invalid', function() {
|
||||
var identity = new Identity();
|
||||
identity.fromString( knownIdent );
|
||||
identity.networkstr = 'unknown';
|
||||
identity.isValid().should.equal(false);
|
||||
});
|
||||
|
||||
it('should describe this identity with unknown type as invalid', function() {
|
||||
var identity = new Identity();
|
||||
identity.fromString( knownIdent );
|
||||
identity.typestr = 'unknown';
|
||||
identity.isValid().should.equal(false);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#toBuffer', function() {
|
||||
|
||||
it('should output this known hash', function() {
|
||||
var identity = new Identity();
|
||||
identity.fromString(str);
|
||||
identity.toBuffer().slice(2).toString('hex').should.equal(pubkeyhash.toString('hex'));
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#toString', function() {
|
||||
|
||||
it('should output the same thing that was input', function() {
|
||||
var identity = new Identity();
|
||||
identity.fromString(str);
|
||||
identity.toString().should.equal(str);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#validate', function() {
|
||||
|
||||
it('should not throw an error on this valid identity', function() {
|
||||
var identity = new Identity();
|
||||
identity.fromString(str);
|
||||
should.exist(identity.validate());
|
||||
});
|
||||
|
||||
it('should throw an error on this invalid network', function() {
|
||||
var identity = new Identity();
|
||||
identity.fromString(str);
|
||||
identity.networkstr = 'unknown';
|
||||
(function() {
|
||||
identity.validate();
|
||||
}).should.throw('networkstr must be "ephemeral", "mainnet", or "testnet"');
|
||||
});
|
||||
|
||||
it('should throw an error on this invalid type', function() {
|
||||
var identity = new Identity();
|
||||
identity.fromString(str);
|
||||
identity.typestr = 'unknown';
|
||||
(function() {
|
||||
identity.validate();
|
||||
}).should.throw('typestr must be "identity"');
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
});
|
39
test/kdf.js
39
test/kdf.js
|
@ -1,39 +0,0 @@
|
|||
var should = require('chai').should();
|
||||
var KDF = require('../lib/kdf');
|
||||
var Hash = require('../lib/hash');
|
||||
|
||||
describe('KDF', function() {
|
||||
|
||||
describe('#buf2keypair', function() {
|
||||
|
||||
it('should compute these known values', function() {
|
||||
var buf = Hash.sha256(new Buffer('test'));
|
||||
var keypair = KDF.buf2keypair(buf);
|
||||
keypair.privkey.toString().should.equal('KxxVszVMFLGzmxpxR7sMSaWDmqMKLVhKebX5vZbGHyuR8spreQ7V');
|
||||
keypair.pubkey.toString().should.equal('03774f761ae89a0d2fda0d532bad62286ae8fcda9bc38c060036296085592a97c1');
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#sha256hmac2keypair', function() {
|
||||
|
||||
it('should compute these known values', function() {
|
||||
var buf = Hash.sha256(new Buffer('test'));
|
||||
var keypair = KDF.sha256hmac2keypair(buf);
|
||||
keypair.privkey.toString().should.equal('KxxVszVMFLGzmxpxR7sMSaWDmqMKLVhKebX5vZbGHyuR8spreQ7V');
|
||||
keypair.pubkey.toString().should.equal('03774f761ae89a0d2fda0d532bad62286ae8fcda9bc38c060036296085592a97c1');
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#sha256hmac2privkey', function() {
|
||||
|
||||
it('should compute this known privkey', function() {
|
||||
var buf = Hash.sha256(new Buffer('test'));
|
||||
var privkey = KDF.sha256hmac2privkey(buf);
|
||||
privkey.toString().should.equal('KxxVszVMFLGzmxpxR7sMSaWDmqMKLVhKebX5vZbGHyuR8spreQ7V');
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
});
|
|
@ -1,9 +1,11 @@
|
|||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var bn = require('../lib/bn');
|
||||
var point = require('../lib/point');
|
||||
var Privkey = require('../lib/privkey');
|
||||
var Pubkey = require('../lib/pubkey');
|
||||
var Keypair = require('../lib/keypair');
|
||||
var bitcore = require('..');
|
||||
var bn = bitcore.BN;
|
||||
var Privkey = bitcore.Privkey;
|
||||
var Pubkey = bitcore.Pubkey;
|
||||
var Keypair = bitcore.Keypair;
|
||||
|
||||
describe('Keypair', function() {
|
||||
|
||||
|
@ -15,16 +17,21 @@ describe('Keypair', function() {
|
|||
it('should make a key with a priv and pub', function() {
|
||||
var priv = new Privkey();
|
||||
var pub = new Pubkey();
|
||||
var key = new Keypair({privkey: priv, pubkey: pub});
|
||||
var key = new Keypair({
|
||||
privkey: priv,
|
||||
pubkey: pub
|
||||
});
|
||||
should.exist(key);
|
||||
should.exist(key.privkey);
|
||||
should.exist(key.pubkey);
|
||||
});
|
||||
|
||||
describe("#set", function() {
|
||||
describe('#set', function() {
|
||||
|
||||
it('should make a new priv and pub', function() {
|
||||
should.exist(Keypair().set({privkey: Privkey()}).privkey);
|
||||
should.exist(new Keypair().set({
|
||||
privkey: new Privkey()
|
||||
}).privkey);
|
||||
});
|
||||
|
||||
});
|
||||
|
@ -127,7 +134,9 @@ describe('Keypair', function() {
|
|||
var privhex = '906977a061af29276e40bf377042ffbde414e496ae2260bbf1fa9d085637bfff';
|
||||
var pubhex = '02a1633cafcc01ebfb6d78e39f687a1f0995c62fc95f51ead10a02ee0be551b5dc';
|
||||
var key = new Keypair();
|
||||
key.privkey = new Privkey({bn: bn(new Buffer(privhex, 'hex'))});
|
||||
key.privkey = new Privkey({
|
||||
bn: bn(new Buffer(privhex, 'hex'))
|
||||
});
|
||||
key.privkey2pubkey();
|
||||
key.pubkey.toString().should.equal(pubhex);
|
||||
});
|
||||
|
@ -135,7 +144,9 @@ describe('Keypair', function() {
|
|||
it('should convert this known Privkey to known Pubkey and preserve compressed=true', function() {
|
||||
var privhex = '906977a061af29276e40bf377042ffbde414e496ae2260bbf1fa9d085637bfff';
|
||||
var key = new Keypair();
|
||||
key.privkey = new Privkey({bn: bn(new Buffer(privhex, 'hex'))});
|
||||
key.privkey = new Privkey({
|
||||
bn: bn(new Buffer(privhex, 'hex'))
|
||||
});
|
||||
key.privkey.compressed = true;
|
||||
key.privkey2pubkey();
|
||||
key.pubkey.compressed.should.equal(true);
|
||||
|
@ -144,7 +155,9 @@ describe('Keypair', function() {
|
|||
it('should convert this known Privkey to known Pubkey and preserve compressed=true', function() {
|
||||
var privhex = '906977a061af29276e40bf377042ffbde414e496ae2260bbf1fa9d085637bfff';
|
||||
var key = new Keypair();
|
||||
key.privkey = new Privkey({bn: bn(new Buffer(privhex, 'hex'))});
|
||||
key.privkey = new Privkey({
|
||||
bn: bn(new Buffer(privhex, 'hex'))
|
||||
});
|
||||
key.privkey.compressed = false;
|
||||
key.privkey2pubkey();
|
||||
key.pubkey.compressed.should.equal(false);
|
||||
|
|
107
test/message.js
107
test/message.js
|
@ -1,107 +0,0 @@
|
|||
var Address = require('../lib/address');
|
||||
var Message = require('../lib/message');
|
||||
var Keypair = require('../lib/keypair');
|
||||
var should = require('chai').should();
|
||||
|
||||
describe('Message', function() {
|
||||
|
||||
it('should make a new message', function() {
|
||||
var message = new Message();
|
||||
should.exist(message);
|
||||
});
|
||||
|
||||
it('should make a new message when called without "new"', function() {
|
||||
var message = Message();
|
||||
should.exist(message);
|
||||
});
|
||||
|
||||
describe('#set', function() {
|
||||
|
||||
it('should set the messagebuf', function() {
|
||||
var messagebuf = new Buffer('message');
|
||||
should.exist(Message().set({messagebuf: messagebuf}).messagebuf);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@sign', function() {
|
||||
var messagebuf = new Buffer('this is my message');
|
||||
var keypair = Keypair().fromRandom();
|
||||
|
||||
it('should return a base64 string', function() {
|
||||
var sigstr = Message.sign(messagebuf, keypair);
|
||||
var sigbuf = new Buffer(sigstr, 'base64');
|
||||
sigbuf.length.should.equal(1 + 32 + 32);
|
||||
});
|
||||
|
||||
it('should sign with a compressed pubkey', function() {
|
||||
var keypair = Keypair().fromRandom();
|
||||
keypair.pubkey.compressed = true;
|
||||
var sigstr = Message.sign(messagebuf, keypair);
|
||||
var sigbuf = new Buffer(sigstr, 'base64');
|
||||
sigbuf[0].should.be.above(27 + 4 - 1);
|
||||
sigbuf[0].should.be.below(27 + 4 + 4 - 1);
|
||||
});
|
||||
|
||||
it('should sign with an uncompressed pubkey', function() {
|
||||
var keypair = Keypair().fromRandom();
|
||||
keypair.pubkey.compressed = false;
|
||||
var sigstr = Message.sign(messagebuf, keypair);
|
||||
var sigbuf = new Buffer(sigstr, 'base64');
|
||||
sigbuf[0].should.be.above(27 - 1);
|
||||
sigbuf[0].should.be.below(27 + 4 - 1);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@verify', function() {
|
||||
var messagebuf = new Buffer('this is my message');
|
||||
var keypair = Keypair().fromRandom();
|
||||
|
||||
it('should verify a signed message', function() {
|
||||
var sigstr = Message.sign(messagebuf, keypair);
|
||||
var addr = Address().fromPubkey(keypair.pubkey);
|
||||
Message.verify(messagebuf, sigstr, addr).should.equal(true);
|
||||
});
|
||||
|
||||
it('should verify this known good signature', function() {
|
||||
var addrstr = '1CKTmxj6DjGrGTfbZzVxnY4Besbv8oxSZb';
|
||||
var address = Address().fromString(addrstr);
|
||||
var sigstr = 'IOrTlbNBI0QO990xOw4HAjnvRl/1zR+oBMS6HOjJgfJqXp/1EnFrcJly0UcNelqJNIAH4f0abxOZiSpYmenMH4M=';
|
||||
Message.verify(messagebuf, sigstr, address);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#sign', function() {
|
||||
var messagebuf = new Buffer('this is my message');
|
||||
var keypair = Keypair().fromRandom();
|
||||
|
||||
it('should sign a message', function() {
|
||||
var message = new Message();
|
||||
message.messagebuf = messagebuf;
|
||||
message.keypair = keypair;
|
||||
message.sign();
|
||||
var sig = message.sig;
|
||||
should.exist(sig);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#verify', function() {
|
||||
var messagebuf = new Buffer('this is my message');
|
||||
var keypair = Keypair().fromRandom();
|
||||
|
||||
it('should verify a message that was just signed', function() {
|
||||
var message = new Message();
|
||||
message.messagebuf = messagebuf;
|
||||
message.keypair = keypair;
|
||||
message.address = Address().fromPubkey(keypair.pubkey);
|
||||
message.sign();
|
||||
message.verify();
|
||||
message.verified.should.equal(true);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
});
|
|
@ -1,10 +1,14 @@
|
|||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var Opcode = require('../lib/opcode');
|
||||
var bitcore = require('..');
|
||||
var Opcode = bitcore.Opcode;
|
||||
|
||||
describe('Opcode', function() {
|
||||
|
||||
it('should create a new Opcode', function() {
|
||||
var opcode = new Opcode(5);
|
||||
should.exist(opcode);
|
||||
});
|
||||
|
||||
it('should convert to a string with this handy syntax', function() {
|
||||
|
|
|
@ -1,8 +1,10 @@
|
|||
var Privkey = require('../lib/privkey');
|
||||
var base58check = require('../lib/base58check');
|
||||
var BN = require('../lib/bn');
|
||||
var Point = require('../lib/point');
|
||||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var bitcore = require('..');
|
||||
var Privkey = bitcore.Privkey;
|
||||
var BN = bitcore.BN;
|
||||
var Point = bitcore.Point;
|
||||
|
||||
describe('Privkey', function() {
|
||||
var hex = '96c132224121b509b7d0a16245e957d9192609c5637c6228311287b1be21627a';
|
||||
|
@ -24,24 +26,38 @@ describe('Privkey', function() {
|
|||
});
|
||||
|
||||
it('should create a mainnet private key', function() {
|
||||
var privkey = new Privkey({bn: BN.fromBuffer(buf), networkstr: 'mainnet', compressed: true});
|
||||
var privkey = new Privkey({
|
||||
bn: BN.fromBuffer(buf),
|
||||
networkstr: 'mainnet',
|
||||
compressed: true
|
||||
});
|
||||
privkey.toString().should.equal(encmainnet);
|
||||
});
|
||||
|
||||
it('should create an uncompressed testnet private key', function() {
|
||||
var privkey = new Privkey({bn: BN.fromBuffer(buf), networkstr: 'testnet', compressed: false});
|
||||
var privkey = new Privkey({
|
||||
bn: BN.fromBuffer(buf),
|
||||
networkstr: 'testnet',
|
||||
compressed: false
|
||||
});
|
||||
privkey.toString().should.equal(enctu);
|
||||
});
|
||||
|
||||
it('should create an uncompressed mainnet private key', function() {
|
||||
var privkey = new Privkey({bn: BN.fromBuffer(buf), networkstr: 'mainnet', compressed: false});
|
||||
var privkey = new Privkey({
|
||||
bn: BN.fromBuffer(buf),
|
||||
networkstr: 'mainnet',
|
||||
compressed: false
|
||||
});
|
||||
privkey.toString().should.equal(encmu);
|
||||
});
|
||||
|
||||
describe('#set', function() {
|
||||
|
||||
it('should set bn', function() {
|
||||
should.exist(Privkey().set({bn: BN.fromBuffer(buf)}).bn);
|
||||
should.exist(Privkey().set({
|
||||
bn: BN.fromBuffer(buf)
|
||||
}).bn);
|
||||
});
|
||||
|
||||
});
|
||||
|
|
|
@ -1,9 +1,12 @@
|
|||
var Base58 = require('../lib/base58');
|
||||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var bitcore = require('../..');
|
||||
var Base58 = bitcore.Base58;
|
||||
|
||||
describe('Base58', function() {
|
||||
var buf = new Buffer([0, 1, 2, 3, 253, 254, 255]);
|
||||
var enc = "1W7N4RuG";
|
||||
var enc = '1W7N4RuG';
|
||||
|
||||
it('should make an instance with "new"', function() {
|
||||
var b58 = new Base58();
|
||||
|
@ -17,13 +20,15 @@ describe('Base58', function() {
|
|||
|
||||
it('should allow this handy syntax', function() {
|
||||
Base58(buf).toString().should.equal(enc);
|
||||
Base58(enc).toBuffer().toString('hex').should.equal(buf.toString('hex'))
|
||||
Base58(enc).toBuffer().toString('hex').should.equal(buf.toString('hex'));
|
||||
});
|
||||
|
||||
describe('#set', function() {
|
||||
|
||||
it('should set a blank buffer', function() {
|
||||
Base58().set({buf: new Buffer([])});
|
||||
Base58().set({
|
||||
buf: new Buffer([])
|
||||
});
|
||||
});
|
||||
|
||||
});
|
||||
|
@ -80,7 +85,9 @@ describe('Base58', function() {
|
|||
describe('#toBuffer', function() {
|
||||
|
||||
it('should return the buffer', function() {
|
||||
var b58 = Base58({buf: buf});
|
||||
var b58 = Base58({
|
||||
buf: buf
|
||||
});
|
||||
b58.buf.toString('hex').should.equal(buf.toString('hex'));
|
||||
});
|
||||
|
||||
|
@ -89,7 +96,9 @@ describe('Base58', function() {
|
|||
describe('#toString', function() {
|
||||
|
||||
it('should return the buffer', function() {
|
||||
var b58 = Base58({buf: buf});
|
||||
var b58 = Base58({
|
||||
buf: buf
|
||||
});
|
||||
b58.toString().should.equal(enc);
|
||||
});
|
||||
|
|
@ -1,10 +1,13 @@
|
|||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var Base58Check = require('../lib/base58check');
|
||||
var base58 = require('../lib/base58');
|
||||
var bitcore = require('../..');
|
||||
var Base58Check = bitcore.Base58Check;
|
||||
var base58 = bitcore.Base58;
|
||||
|
||||
describe('Base58Check', function() {
|
||||
var buf = new Buffer([0, 1, 2, 3, 253, 254, 255]);
|
||||
var enc = "14HV44ipwoaqfg";
|
||||
var enc = '14HV44ipwoaqfg';
|
||||
|
||||
it('should make an instance with "new"', function() {
|
||||
var b58 = new Base58Check();
|
|
@ -1,7 +1,10 @@
|
|||
var BufferWriter = require('../lib/bufferwriter');
|
||||
var BufferReader = require('../lib/bufferreader');
|
||||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var BN = require('../lib/bn');
|
||||
var bitcore = require('../..');
|
||||
var BufferWriter = bitcore.BufferWriter;
|
||||
var BufferReader = bitcore.BufferReader;
|
||||
var BN = bitcore.BN;
|
||||
|
||||
describe('BufferReader', function() {
|
||||
|
|
@ -1,7 +1,10 @@
|
|||
var BufferWriter = require('../lib/bufferwriter');
|
||||
var BufferReader = require('../lib/bufferreader');
|
||||
var BN = require('../lib/bn');
|
||||
'use strict';
|
||||
|
||||
var bitcore = require('../..');
|
||||
var should = require('chai').should();
|
||||
var BufferWriter = bitcore.BufferWriter;
|
||||
var BufferReader = bitcore.BufferReader;
|
||||
var BN = bitcore.BN;
|
||||
|
||||
describe('BufferWriter', function() {
|
||||
|
||||
|
@ -15,7 +18,6 @@ describe('BufferWriter', function() {
|
|||
it('set bufs', function() {
|
||||
var buf1 = new Buffer([0]);
|
||||
var buf2 = new Buffer([1]);
|
||||
var bufs = [buf1, buf2];
|
||||
var bw = new BufferWriter().set({bufs: [buf1, buf2]});
|
||||
bw.concat().toString('hex').should.equal('0001');
|
||||
});
|
|
@ -0,0 +1,18 @@
|
|||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var bitcore = require('../../');
|
||||
var constants = bitcore.Constants;
|
||||
|
||||
describe('Constants', function() {
|
||||
|
||||
it('should contain all constants for livenet and testnet', function() {
|
||||
for (var key in constants.livenet) {
|
||||
if (constants.livenet.hasOwnProperty(key)) {
|
||||
constants.testnet.hasOwnProperty(key).should.equal(true);
|
||||
}
|
||||
}
|
||||
|
||||
});
|
||||
|
||||
});
|
|
@ -1,8 +1,11 @@
|
|||
var BN = require('../lib/bn');
|
||||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var BufferReader = require('../lib/bufferreader');
|
||||
var BufferWriter = require('../lib/bufferwriter');
|
||||
var Varint = require('../lib/varint');
|
||||
var bitcore = require('../..');
|
||||
var BN = bitcore.BN;
|
||||
var BufferReader = bitcore.BufferReader;
|
||||
var BufferWriter = bitcore.BufferWriter;
|
||||
var Varint = bitcore.Varint;
|
||||
|
||||
describe('Varint', function() {
|
||||
|
||||
|
@ -95,7 +98,7 @@ describe('Varint', function() {
|
|||
describe('#toBuffer', function() {
|
||||
|
||||
it('should return a buffer', function() {
|
||||
buf = BufferWriter().writeVarintNum(5).concat();
|
||||
var buf = BufferWriter().writeVarintNum(5).concat();
|
||||
var varint = Varint(buf);
|
||||
varint.toBuffer().toString('hex').should.equal(buf.toString('hex'));
|
||||
});
|
|
@ -1,8 +1,11 @@
|
|||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var Pubkey = require('../lib/pubkey');
|
||||
var Point = require('../lib/point');
|
||||
var Bn = require('../lib/bn');
|
||||
var Privkey = require('../lib/privkey');
|
||||
var bitcore = require('..');
|
||||
var Pubkey = bitcore.Pubkey;
|
||||
var Point = bitcore.Point;
|
||||
var Bn = bitcore.BN;
|
||||
var Privkey = bitcore.Privkey;
|
||||
|
||||
describe('Pubkey', function() {
|
||||
|
||||
|
@ -114,7 +117,7 @@ describe('Pubkey', function() {
|
|||
describe('#fromString', function() {
|
||||
|
||||
it('should parse this known valid public key', function() {
|
||||
pk = new Pubkey();
|
||||
var pk = new Pubkey();
|
||||
pk.fromString('041ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a7baad41d04514751e6851f5304fd243751703bed21b914f6be218c0fa354a341');
|
||||
pk.point.getX().toString(16).should.equal('1ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a');
|
||||
pk.point.getY().toString(16).should.equal('7baad41d04514751e6851f5304fd243751703bed21b914f6be218c0fa354a341');
|
||||
|
|
|
@ -1,13 +1,15 @@
|
|||
var Script = require('../lib/script');
|
||||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var Opcode = require('../lib/opcode');
|
||||
var BufferReader = require('../lib/bufferreader');
|
||||
var BufferWriter = require('../lib/bufferwriter');
|
||||
var bitcore = require('..');
|
||||
var Script = bitcore.Script;
|
||||
var Opcode = bitcore.Opcode;
|
||||
|
||||
describe('Script', function() {
|
||||
|
||||
it('should make a new script', function() {
|
||||
var script = new Script();
|
||||
should.exist(script);
|
||||
});
|
||||
|
||||
describe('#fromBuffer', function() {
|
||||
|
|
|
@ -1,6 +1,9 @@
|
|||
var BN = require('../lib/bn');
|
||||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var Signature = require('../lib/signature');
|
||||
var bitcore = require('..');
|
||||
var BN = bitcore.BN;
|
||||
var Signature = bitcore.Signature;
|
||||
|
||||
describe('Signature', function() {
|
||||
|
||||
|
@ -21,7 +24,9 @@ describe('Signature', function() {
|
|||
describe('#set', function() {
|
||||
|
||||
it('should set compressed', function() {
|
||||
should.exist(Signature().set({compressed: true}));
|
||||
should.exist(Signature().set({
|
||||
compressed: true
|
||||
}));
|
||||
});
|
||||
|
||||
});
|
||||
|
@ -51,8 +56,12 @@ describe('Signature', function() {
|
|||
it('should parse this DER format signature', function() {
|
||||
var sig = new Signature();
|
||||
sig.fromDER(buf);
|
||||
sig.r.toBuffer({size: 32}).toString('hex').should.equal('75fc517e541bd54769c080b64397e32161c850f6c1b2b67a5c433affbb3e6277');
|
||||
sig.s.toBuffer({size: 32}).toString('hex').should.equal('729e85cc46ffab881065ec07694220e71d4df9b2b8c8fd12c3122cf3a5efbcf2');
|
||||
sig.r.toBuffer({
|
||||
size: 32
|
||||
}).toString('hex').should.equal('75fc517e541bd54769c080b64397e32161c850f6c1b2b67a5c433affbb3e6277');
|
||||
sig.s.toBuffer({
|
||||
size: 32
|
||||
}).toString('hex').should.equal('729e85cc46ffab881065ec07694220e71d4df9b2b8c8fd12c3122cf3a5efbcf2');
|
||||
});
|
||||
|
||||
});
|
||||
|
@ -64,8 +73,12 @@ describe('Signature', function() {
|
|||
it('should parse this DER format signature in hex', function() {
|
||||
var sig = new Signature();
|
||||
sig.fromString(buf.toString('hex'));
|
||||
sig.r.toBuffer({size: 32}).toString('hex').should.equal('75fc517e541bd54769c080b64397e32161c850f6c1b2b67a5c433affbb3e6277');
|
||||
sig.s.toBuffer({size: 32}).toString('hex').should.equal('729e85cc46ffab881065ec07694220e71d4df9b2b8c8fd12c3122cf3a5efbcf2');
|
||||
sig.r.toBuffer({
|
||||
size: 32
|
||||
}).toString('hex').should.equal('75fc517e541bd54769c080b64397e32161c850f6c1b2b67a5c433affbb3e6277');
|
||||
sig.s.toBuffer({
|
||||
size: 32
|
||||
}).toString('hex').should.equal('729e85cc46ffab881065ec07694220e71d4df9b2b8c8fd12c3122cf3a5efbcf2');
|
||||
});
|
||||
|
||||
});
|
||||
|
@ -127,7 +140,10 @@ describe('Signature', function() {
|
|||
it('should convert these known r and s values into a known signature', function() {
|
||||
var r = BN('63173831029936981022572627018246571655303050627048489594159321588908385378810');
|
||||
var s = BN('4331694221846364448463828256391194279133231453999942381442030409253074198130');
|
||||
var sig = new Signature({r: r, s: s});
|
||||
var sig = new Signature({
|
||||
r: r,
|
||||
s: s
|
||||
});
|
||||
var der = sig.toDER(r, s);
|
||||
der.toString('hex').should.equal('30450221008bab1f0a2ff2f9cb8992173d8ad73c229d31ea8e10b0f4d4ae1a0d8ed76021fa02200993a6ec81755b9111762fc2cf8e3ede73047515622792110867d12654275e72');
|
||||
});
|
||||
|
@ -139,7 +155,10 @@ describe('Signature', function() {
|
|||
it('should convert this signature in to hex DER', function() {
|
||||
var r = BN('63173831029936981022572627018246571655303050627048489594159321588908385378810');
|
||||
var s = BN('4331694221846364448463828256391194279133231453999942381442030409253074198130');
|
||||
var sig = new Signature({r: r, s: s});
|
||||
var sig = new Signature({
|
||||
r: r,
|
||||
s: s
|
||||
});
|
||||
var hex = sig.toString();
|
||||
hex.should.equal('30450221008bab1f0a2ff2f9cb8992173d8ad73c229d31ea8e10b0f4d4ae1a0d8ed76021fa02200993a6ec81755b9111762fc2cf8e3ede73047515622792110867d12654275e72');
|
||||
});
|
||||
|
|
|
@ -1,149 +0,0 @@
|
|||
var StealthAddress = require('../lib/expmt/stealthaddress');
|
||||
var should = require('chai').should();
|
||||
var Stealthkey = require('../lib/expmt/stealthkey');
|
||||
var Keypair = require('../lib/keypair');
|
||||
var Privkey = require('../lib/privkey');
|
||||
var Pubkey = require('../lib/pubkey');
|
||||
var BN = require('../lib/bn');
|
||||
var Hash = require('../lib/hash');
|
||||
var Base58check = require('../lib/base58check');
|
||||
|
||||
describe('StealthAddress', function() {
|
||||
|
||||
var stealthkey = Stealthkey();
|
||||
stealthkey.payloadKeypair = Keypair();
|
||||
stealthkey.payloadKeypair.privkey = Privkey();
|
||||
stealthkey.payloadKeypair.privkey.bn = BN().fromBuffer(Hash.sha256(new Buffer('test 1')));
|
||||
stealthkey.payloadKeypair.privkey2pubkey();
|
||||
stealthkey.scanKeypair = Keypair();
|
||||
stealthkey.scanKeypair.privkey = Privkey();
|
||||
stealthkey.scanKeypair.privkey.bn = BN().fromBuffer(Hash.sha256(new Buffer('test 2')));
|
||||
stealthkey.scanKeypair.privkey2pubkey();
|
||||
|
||||
var senderKeypair = Keypair();
|
||||
senderKeypair.privkey = Privkey();
|
||||
senderKeypair.privkey.bn = BN().fromBuffer(Hash.sha256(new Buffer('test 3')));
|
||||
senderKeypair.privkey2pubkey();
|
||||
|
||||
var addressString = 'vJmtuUb8ysKiM1HtHQF23FGfjGAKu5sM94UyyjknqhJHNdj5CZzwtpGzeyaATQ2HvuzomNVtiwsTJSWzzCBgCTtUZbRFpzKVq9MAUr';
|
||||
var dwhex = '2a0002697763d7e9becb0c180083738c32c05b0e2fee26d6278020c06bbb04d5f66b32010362408459041e0473298af3824dbabe4d2b7f846825ed4d1c2e2c670c07cb275d0100';
|
||||
var dwbuf = new Buffer(dwhex, 'hex');
|
||||
|
||||
it('should make a new stealth address', function() {
|
||||
var sa = new StealthAddress();
|
||||
should.exist(sa);
|
||||
sa = StealthAddress();
|
||||
should.exist(sa);
|
||||
sa = StealthAddress(addressString);
|
||||
should.exist(sa);
|
||||
sa = StealthAddress(Base58check.decode(addressString));
|
||||
should.exist(sa);
|
||||
});
|
||||
|
||||
describe('#fromJSON', function() {
|
||||
|
||||
it('should give a stealthkey address with the right pubkeys', function() {
|
||||
var sa = new StealthAddress();
|
||||
sa.fromJSON(addressString);
|
||||
sa.payloadPubkey.toString().should.equal(stealthkey.payloadKeypair.pubkey.toString());
|
||||
sa.scanPubkey.toString().should.equal(stealthkey.scanKeypair.pubkey.toString());
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#toJSON', function() {
|
||||
|
||||
it('should return this known address string', function() {
|
||||
StealthAddress().fromJSON(addressString).toJSON().should.equal(addressString);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#fromBuffer', function() {
|
||||
|
||||
it('should parse this DW buffer', function() {
|
||||
StealthAddress().fromBuffer(new Buffer(dwhex, 'hex')).toBuffer().toString('hex').should.equal(dwhex);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#fromString', function() {
|
||||
|
||||
it('should parse this DW buffer', function() {
|
||||
StealthAddress().fromString(Base58check(new Buffer(dwhex, 'hex')).toString()).toBuffer().toString('hex').should.equal(dwhex);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#getSharedKeypair', function() {
|
||||
|
||||
it('should return a key', function() {
|
||||
var sa = new StealthAddress();
|
||||
sa.payloadPubkey = stealthkey.payloadKeypair.pubkey;
|
||||
sa.scanPubkey = stealthkey.scanKeypair.pubkey;
|
||||
var key = sa.getSharedKeypair(senderKeypair);
|
||||
(key instanceof Keypair).should.equal(true);
|
||||
});
|
||||
|
||||
it('should return the same key as Stealthkey.prototype.getSharedKeypair', function() {
|
||||
var sa = new StealthAddress();
|
||||
sa.payloadPubkey = stealthkey.payloadKeypair.pubkey;
|
||||
sa.scanPubkey = stealthkey.scanKeypair.pubkey;
|
||||
var key = sa.getSharedKeypair(senderKeypair);
|
||||
|
||||
var key2 = stealthkey.getSharedKeypair(senderKeypair.pubkey);
|
||||
key.toString().should.equal(key2.toString());
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#getReceivePubkey', function() {
|
||||
|
||||
it('should return a pubkey', function() {
|
||||
var pubkey = StealthAddress().fromStealthkey(stealthkey).getReceivePubkey(senderKeypair);
|
||||
(pubkey instanceof Pubkey).should.equal(true);
|
||||
});
|
||||
|
||||
it('should return the same pubkey as getReceivePubkey', function() {
|
||||
var pubkey = StealthAddress().fromStealthkey(stealthkey).getReceivePubkey(senderKeypair);
|
||||
var pubkey2 = stealthkey.getReceivePubkey(senderKeypair.pubkey);
|
||||
pubkey2.toString().should.equal(pubkey.toString());
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#toBuffer', function() {
|
||||
|
||||
it('should return this known address buffer', function() {
|
||||
var buf = Base58check.decode(addressString);
|
||||
StealthAddress().fromBuffer(dwbuf).toBuffer().toString('hex').should.equal(dwhex);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#toString', function() {
|
||||
|
||||
it('should return this known address buffer', function() {
|
||||
var buf = Base58check.decode(addressString);
|
||||
StealthAddress().fromBuffer(buf).toString().should.equal(Base58check(new Buffer(dwhex, 'hex')).toString());
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@parseDWBuffer', function() {
|
||||
|
||||
it('should parse this known DW buffer', function() {
|
||||
var buf = new Buffer(dwhex, 'hex');
|
||||
var parsed = StealthAddress.parseDWBuffer(buf);
|
||||
parsed.version.should.equal(42);
|
||||
parsed.options.should.equal(0);
|
||||
parsed.scanPubkey.toString().should.equal('02697763d7e9becb0c180083738c32c05b0e2fee26d6278020c06bbb04d5f66b32');
|
||||
parsed.nPayloadPubkeys.should.equal(1);
|
||||
parsed.payloadPubkeys[0].toString().should.equal('0362408459041e0473298af3824dbabe4d2b7f846825ed4d1c2e2c670c07cb275d');
|
||||
parsed.nSigs.should.equal(1);
|
||||
parsed.prefix.toString().should.equal('');
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
});
|
|
@ -1,138 +0,0 @@
|
|||
var should = require('chai').should();
|
||||
var Stealthkey = require('../lib/expmt/stealthkey');
|
||||
var Keypair = require('../lib/keypair');
|
||||
var Privkey = require('../lib/privkey');
|
||||
var Pubkey = require('../lib/pubkey');
|
||||
var BN = require('../lib/bn');
|
||||
var Hash = require('../lib/hash');
|
||||
|
||||
describe('Stealthkey', function() {
|
||||
|
||||
var stealthkey = Stealthkey();
|
||||
stealthkey.payloadKeypair = Keypair();
|
||||
stealthkey.payloadKeypair.privkey = Privkey();
|
||||
stealthkey.payloadKeypair.privkey.bn = BN().fromBuffer(Hash.sha256(new Buffer('test 1')));
|
||||
stealthkey.payloadKeypair.privkey2pubkey();
|
||||
stealthkey.scanKeypair = Keypair();
|
||||
stealthkey.scanKeypair.privkey = Privkey();
|
||||
stealthkey.scanKeypair.privkey.bn = BN().fromBuffer(Hash.sha256(new Buffer('test 2')));
|
||||
stealthkey.scanKeypair.privkey2pubkey();
|
||||
|
||||
var senderKeypair = Keypair();
|
||||
senderKeypair.privkey = Privkey();
|
||||
senderKeypair.privkey.bn = BN().fromBuffer(Hash.sha256(new Buffer('test 3')));
|
||||
senderKeypair.privkey2pubkey();
|
||||
|
||||
it('should create a new stealthkey', function() {
|
||||
var stealthkey = new Stealthkey();
|
||||
should.exist(stealthkey);
|
||||
});
|
||||
|
||||
it('should create a new stealthkey without using "new"', function() {
|
||||
var stealthkey = Stealthkey();
|
||||
should.exist(stealthkey);
|
||||
});
|
||||
|
||||
it('should create a new stealthkey with both keypairs in the constructor', function() {
|
||||
var keypair1 = Keypair();
|
||||
var keypair2 = Keypair();
|
||||
var stealthkey = Stealthkey(keypair1, keypair2);
|
||||
should.exist(stealthkey.payloadKeypair);
|
||||
should.exist(stealthkey.scanKeypair);
|
||||
});
|
||||
|
||||
describe('#set', function() {
|
||||
|
||||
it('should set payload key', function() {
|
||||
should.exist(Stealthkey().set({payloadKeypair: stealthkey.payloadKeypair}).payloadKeypair);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#fromJSON', function() {
|
||||
|
||||
it('should make a stealthkey from this JSON', function() {
|
||||
var sk = Stealthkey().fromJSON({
|
||||
payloadKeypair: stealthkey.payloadKeypair.toJSON(),
|
||||
scanKeypair: stealthkey.scanKeypair.toJSON()
|
||||
});
|
||||
sk.payloadKeypair.toString().should.equal(stealthkey.payloadKeypair.toString());
|
||||
sk.scanKeypair.toString().should.equal(stealthkey.scanKeypair.toString());
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#toJSON', function() {
|
||||
|
||||
it('should convert this stealthkey to json', function() {
|
||||
var json = stealthkey.toJSON()
|
||||
var json2 = Stealthkey().fromJSON(json).toJSON();
|
||||
json.payloadKeypair.privkey.should.equal(json2.payloadKeypair.privkey);
|
||||
json.scanKeypair.privkey.should.equal(json2.scanKeypair.privkey);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#fromRandom', function() {
|
||||
|
||||
it('should create a new stealthkey from random', function() {
|
||||
var stealthkey = Stealthkey().fromRandom();
|
||||
should.exist(stealthkey.payloadKeypair.privkey.bn.gt(0));
|
||||
should.exist(stealthkey.scanKeypair.privkey.bn.gt(0));
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#getSharedKeypair', function() {
|
||||
|
||||
it('should return a key', function() {
|
||||
var key = stealthkey.getSharedKeypair(senderKeypair.pubkey);
|
||||
(key instanceof Keypair).should.equal(true);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#getReceivePubkey', function() {
|
||||
|
||||
it('should return a pubkey', function() {
|
||||
var pubkey = stealthkey.getReceivePubkey(senderKeypair.pubkey);
|
||||
(pubkey instanceof Pubkey).should.equal(true);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#getReceiveKeypair', function() {
|
||||
|
||||
it('should return a key', function() {
|
||||
var key = stealthkey.getReceiveKeypair(senderKeypair.pubkey);
|
||||
(key instanceof Keypair).should.equal(true);
|
||||
});
|
||||
|
||||
it('should return a key with the same pubkey as getReceivePubkey', function() {
|
||||
var key = stealthkey.getReceiveKeypair(senderKeypair.pubkey);
|
||||
var pubkey = stealthkey.getReceivePubkey(senderKeypair.pubkey);
|
||||
key.pubkey.toString().should.equal(pubkey.toString());
|
||||
});
|
||||
|
||||
it('should return private key with length 32 or less', function() {
|
||||
var key = stealthkey.getReceiveKeypair(senderKeypair.pubkey);
|
||||
key.privkey.bn.toBuffer().length.should.be.below(33);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#isForMe', function() {
|
||||
|
||||
it('should return true if it (the transaction or message) is for me', function() {
|
||||
var pubkeyhash = new Buffer('3cb64fa6ee9b3e8754e3e2bd033bf61048604a99', 'hex');
|
||||
stealthkey.isForMe(senderKeypair.pubkey, pubkeyhash).should.equal(true);
|
||||
});
|
||||
|
||||
it('should return false if it (the transaction or message) is not for me', function() {
|
||||
var pubkeyhash = new Buffer('00b64fa6ee9b3e8754e3e2bd033bf61048604a99', 'hex');
|
||||
stealthkey.isForMe(senderKeypair.pubkey, pubkeyhash).should.equal(false);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
});
|
|
@ -1,139 +0,0 @@
|
|||
var Keypair = require('../lib/keypair');
|
||||
var StealthMessage = require('../lib/expmt/stealthmessage');
|
||||
var Stealthkey = require('../lib/expmt/stealthkey');
|
||||
var StealthAddress = require('../lib/expmt/stealthaddress');
|
||||
var KDF = require('../lib/kdf');
|
||||
var Hash = require('../lib/hash');
|
||||
var should = require('chai').should();
|
||||
var Address = require('../lib/address');
|
||||
|
||||
describe('StealthMessage', function() {
|
||||
|
||||
var payloadKeypair = KDF.buf2keypair(new Buffer('key1'));
|
||||
var scanKeypair = KDF.buf2keypair(new Buffer('key2'));
|
||||
var fromKeypair = KDF.buf2keypair(new Buffer('key3'));
|
||||
var enchex = 'f557994f16d0d628fa4fdb4ab3d7e0bc5f2754f20381c7831a20c7c9ec88dcf092ea3683261798ccda991ed65a3a54a036d8125dec0381c7831a20c7c9ec88dcf092ea3683261798ccda991ed65a3a54a036d8125dec9f86d081884c7d659a2feaa0c55ad01560ba2904d3bc8395b6c4a6f87648edb33db6a22170e5e26f340c7ba943169210234cd6a753ad13919b0ab7d678b47b5e7d63e452382de2c2590fb57ef048f7b3';
|
||||
var encbuf = new Buffer(enchex, 'hex');
|
||||
var ivbuf = Hash.sha256(new Buffer('test')).slice(0, 128 / 8);
|
||||
var sk = Stealthkey().set({payloadKeypair: payloadKeypair, scanKeypair: scanKeypair});
|
||||
var sa = StealthAddress().fromStealthkey(sk);
|
||||
var messagebuf = new Buffer('this is my message');
|
||||
|
||||
it('should make a new stealthmessage', function() {
|
||||
var sm = new StealthMessage();
|
||||
should.exist(sm);
|
||||
sm = StealthMessage()
|
||||
should.exist(sm);
|
||||
});
|
||||
|
||||
it('should allow "set" style syntax', function() {
|
||||
var encbuf = StealthMessage().set({
|
||||
messagebuf: messagebuf,
|
||||
toStealthAddress: sa
|
||||
}).encrypt().encbuf;
|
||||
should.exist(encbuf);
|
||||
encbuf.length.should.equal(113);
|
||||
});
|
||||
|
||||
describe('#set', function() {
|
||||
|
||||
it('should set the messagebuf', function() {
|
||||
var sm = StealthMessage().set({messagebuf: messagebuf});
|
||||
should.exist(sm.messagebuf);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@encrypt', function() {
|
||||
|
||||
it('should encrypt a message', function() {
|
||||
var encbuf = StealthMessage.encrypt(messagebuf, sa);
|
||||
encbuf.length.should.equal(166);
|
||||
});
|
||||
|
||||
it('should encrypt a message with this fromKeypair and ivbuf the same each time', function() {
|
||||
var encbuf = StealthMessage.encrypt(messagebuf, sa, fromKeypair, ivbuf);
|
||||
encbuf.length.should.equal(166);
|
||||
encbuf.toString('hex').should.equal(enchex);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@decrypt', function() {
|
||||
|
||||
it('should decrypt this known message correctly', function() {
|
||||
var messagebuf2 = StealthMessage.decrypt(encbuf, sk);
|
||||
messagebuf2.toString('hex').should.equal(messagebuf.toString('hex'));
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@isForMe', function() {
|
||||
|
||||
it('should know that this message is for me', function() {
|
||||
StealthMessage.isForMe(encbuf, sk).should.equal(true);
|
||||
});
|
||||
|
||||
it('should know that this message is for me even if my payloadPrivkey is not present', function() {
|
||||
var sk2 = new Stealthkey();
|
||||
sk2.scanKeypair = sk.scanKeypair;
|
||||
sk2.payloadKeypair = Keypair().set({pubkey: sk.payloadKeypair.pubkey});
|
||||
should.not.exist(sk2.payloadKeypair.privkey);
|
||||
StealthMessage.isForMe(encbuf, sk2).should.equal(true);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#encrypt', function() {
|
||||
|
||||
it('should encrypt this message', function() {
|
||||
var sm = StealthMessage().set({
|
||||
messagebuf: messagebuf,
|
||||
toStealthAddress: sa,
|
||||
fromKeypair: fromKeypair
|
||||
});
|
||||
sm.encrypt().encbuf.length.should.equal(113);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#decrypt', function() {
|
||||
|
||||
it('should decrypt that which was encrypted', function() {
|
||||
var sm = StealthMessage().set({
|
||||
messagebuf: messagebuf,
|
||||
toStealthAddress: sa
|
||||
}).encrypt();
|
||||
var messagebuf2 = StealthMessage().set({
|
||||
encbuf: sm.encbuf,
|
||||
fromKeypair: sm.fromKeypair,
|
||||
toStealthkey: sk
|
||||
}).decrypt().messagebuf;
|
||||
messagebuf2.toString('hex').should.equal(messagebuf.toString('hex'));
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#isForMe', function() {
|
||||
|
||||
it('should know that this message is for me', function() {
|
||||
StealthMessage().set({
|
||||
encbuf: encbuf,
|
||||
toStealthkey: sk,
|
||||
fromKeypair: fromKeypair,
|
||||
receiveAddress: Address().set({hashbuf: encbuf.slice(0, 20)})
|
||||
}).isForMe().should.equal(true);
|
||||
});
|
||||
|
||||
it('should know that this message is not for me', function() {
|
||||
StealthMessage().set({
|
||||
encbuf: encbuf,
|
||||
toStealthkey: sk,
|
||||
fromKeypair: fromKeypair,
|
||||
receiveAddress: Address().set({hashbuf: encbuf.slice(0, 20)})
|
||||
}).isForMe().should.equal(true);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
});
|
|
@ -1,68 +0,0 @@
|
|||
var should = require('chai').should();
|
||||
var Txout = require('../lib/txout');
|
||||
var Stealthkey = require('../lib/expmt/stealthkey');
|
||||
var StealthTx = require('../lib/expmt/stealthtx');
|
||||
var Transaction = require('../lib/transaction');
|
||||
var Varint = require('../lib/varint');
|
||||
|
||||
describe('StealthTx', function() {
|
||||
|
||||
var txhex = '0100000001c828ccce36eca04f96321ad488528af86c7598e67157c4f8e2f462a9e0e3af5f010000006a47304402204525eef6a56cc57fb184e53efdfdc1086d5265da21480d55c2184536440a64f70220349cdc6c66a8507dde0d172fe64aeb57ae56e014b50315f615086a6b85c5424e012102c0633ddb6bf2a8686e2ba4ce8026c94e1e27ef12e73f8fed6d6d2b97199f9b74ffffffff020000000000000000286a2606deadbeef0365b5a5b0ba059666e907b0b5e07b37fdb162d1399ed829315491fe1f30c87b3f905f0100000000001976a9142042d5e7ef9e82346419fbfe7df5ae52fe4bea3c88ac00000000';
|
||||
var txbuf = new Buffer(txhex, 'hex');
|
||||
var txidhex = '66da969fff214c329e27062beaf3baf20ed035801559b31f3e868c2de4cdfc5b';
|
||||
var tx = Transaction(txbuf);
|
||||
|
||||
it('should make a new StealthTx', function() {
|
||||
var stx = new StealthTx();
|
||||
should.exist(stx);
|
||||
stx = StealthTx();
|
||||
should.exist(stx);
|
||||
});
|
||||
|
||||
describe('#isForMe', function() {
|
||||
|
||||
it('should return false for this known tx and random stealthkey', function() {
|
||||
var sk = Stealthkey().fromRandom();
|
||||
var stx = StealthTx().set({sk: sk, tx: tx});
|
||||
stx.isForMe().should.equal(false);
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#notMine', function() {
|
||||
|
||||
it('should return true for this known tx and random stealthkey', function() {
|
||||
var sk = Stealthkey().fromRandom();
|
||||
var stx = StealthTx().set({sk: sk, tx: tx});
|
||||
stx.notMine().should.equal("StealthTx not mine");
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('#notStealth', function() {
|
||||
|
||||
it('should know this is a stealth tx', function() {
|
||||
var stx = StealthTx().set({tx: tx});
|
||||
stx.notStealth().should.equal(false);
|
||||
});
|
||||
|
||||
it('should know this is not a stealth tx', function() {
|
||||
var tx2 = Transaction(tx);
|
||||
tx2.txouts.pop();
|
||||
tx2.txoutsvi = Varint(1);
|
||||
var stx = StealthTx().set({tx: tx2});
|
||||
stx.notStealth().should.equal("Not enough txouts");
|
||||
});
|
||||
|
||||
});
|
||||
|
||||
describe('@parseOpReturnData', function() {
|
||||
var txout = tx.txouts[0];
|
||||
var buf = txout.script.chunks[1].buf;
|
||||
var parsed = StealthTx.parseOpReturnData(buf);
|
||||
(typeof parsed.version).should.equal('number');
|
||||
parsed.noncebuf.length.should.be.above(0);
|
||||
parsed.pubkey.toBuffer().length.should.equal(33);
|
||||
});
|
||||
|
||||
});
|
|
@ -1,10 +1,12 @@
|
|||
var Varint = require('../lib/varint');
|
||||
var Transaction = require('../lib/transaction');
|
||||
var Txin = require('../lib/txin');
|
||||
var Txout = require('../lib/txout');
|
||||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var BufferReader = require('../lib/bufferreader');
|
||||
var BufferWriter = require('../lib/bufferwriter');
|
||||
var bitcore = require('..');
|
||||
var Varint = bitcore.Varint;
|
||||
var Transaction = bitcore.Transaction;
|
||||
var Txin = bitcore.Txin;
|
||||
var Txout = bitcore.Txout;
|
||||
var BufferReader = bitcore.BufferReader;
|
||||
|
||||
describe('Transaction', function() {
|
||||
|
||||
|
|
11
test/txin.js
11
test/txin.js
|
@ -1,8 +1,11 @@
|
|||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var Script = require('../lib/script');
|
||||
var Txin = require('../lib/txin');
|
||||
var Varint = require('../lib/varint');
|
||||
var BufferReader = require('../lib/bufferreader');
|
||||
var bitcore = require('..');
|
||||
var Script = bitcore.Script;
|
||||
var Txin = bitcore.Txin;
|
||||
var Varint = bitcore.Varint;
|
||||
var BufferReader = bitcore.BufferReader;
|
||||
|
||||
describe('Txin', function() {
|
||||
|
||||
|
|
|
@ -1,21 +1,18 @@
|
|||
'use strict';
|
||||
|
||||
var should = require('chai').should();
|
||||
var BN = require('../lib/bn');
|
||||
var Txout = require('../lib/txout');
|
||||
var Script = require('../lib/script');
|
||||
var Varint = require('../lib/varint');
|
||||
var BufferReader = require('../lib/bufferreader');
|
||||
var BufferWriter = require('../lib/bufferwriter');
|
||||
var bitcore = require('..');
|
||||
var BN = bitcore.BN;
|
||||
var Txout = bitcore.Txout;
|
||||
var Script = bitcore.Script;
|
||||
var Varint = bitcore.Varint;
|
||||
var BufferReader = bitcore.BufferReader;
|
||||
|
||||
describe('Txout', function() {
|
||||
|
||||
var valuebn = BN(5);
|
||||
var script = Script().fromString("OP_CHECKMULTISIG");
|
||||
var script = Script().fromString('OP_CHECKMULTISIG');
|
||||
var scriptvi = Varint(script.toBuffer().length);
|
||||
var txout = new Txout().set({
|
||||
valuebn: valuebn,
|
||||
scriptvi: scriptvi,
|
||||
script: script
|
||||
});
|
||||
|
||||
it('should make a new txout', function() {
|
||||
var txout = new Txout();
|
||||
|
|
Loading…
Reference in New Issue