Eric Martindale
10 years ago
79 changed files with 8981 additions and 12 deletions
@ -1,13 +1,5 @@ |
|||
build/ |
|||
node_modules/ |
|||
*.swp |
|||
*.swo |
|||
*~ |
|||
.project |
|||
README.html |
|||
CONTRIBUTING.html |
|||
tags |
|||
coverage |
|||
.DS_Store |
|||
docs |
|||
browser/bitcore-dev.js |
|||
node_modules |
|||
browser/fullnode.js |
|||
browser/tests.js |
|||
|
|||
@ -0,0 +1,30 @@ |
|||
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. |
|||
@ -0,0 +1,4 @@ |
|||
#!/bin/bash |
|||
|
|||
browserify index.js -o browser/fullnode.js |
|||
ls test/*.js | xargs browserify -o browser/tests.js |
|||
@ -0,0 +1,25 @@ |
|||
var Block = require('../lib/block'); |
|||
var BufferReader = require('../lib/bufferreader'); |
|||
var BufferWriter = require('../lib/bufferwriter'); |
|||
|
|||
//This example will parse the blocks in a block file.
|
|||
//To use, pipe in a blk*****.dat file. e.g.:
|
|||
//cat blk00000.dat | node blockreader.js
|
|||
|
|||
var head = null; |
|||
|
|||
process.stdin.on('readable', function() { |
|||
if (!head) { |
|||
head = process.stdin.read(8); |
|||
if (!head) |
|||
return; |
|||
} |
|||
var body = process.stdin.read(head.slice(4).readUInt32LE(0)); |
|||
if (!body) |
|||
return; |
|||
var blockbuf = BufferWriter().write(head).write(body).concat(); |
|||
var block = Block().fromBuffer(blockbuf); |
|||
console.log(block.toJSON()); |
|||
head = null; |
|||
process.stdin.unshift(process.stdin.read()); |
|||
}); |
|||
@ -0,0 +1,21 @@ |
|||
var ECDSA = require('../lib/ecdsa'); |
|||
var Keypair = require('../lib/keypair'); |
|||
var Hash = require('../lib/hash'); |
|||
|
|||
//ECDSA is the signature algorithm used in bitcoin
|
|||
|
|||
//start with a keypair that you will use for signing
|
|||
var keypair = Keypair().fromRandom(); |
|||
|
|||
//a message to be signed (normally you would have the hash of a transaction)
|
|||
var messagebuf = new Buffer('This is a message I would like to sign'); |
|||
|
|||
//calculate a 32 byte hash for use in ECDSA. one way to do that is sha256.
|
|||
var hashbuf = Hash.sha256(messagebuf); |
|||
|
|||
var sig = ECDSA.sign(hashbuf, keypair); |
|||
|
|||
//Anyone with the public key can verify
|
|||
var pubkey = keypair.pubkey; |
|||
console.log('Valid signature? ' + ECDSA.verify(hashbuf, sig, pubkey)); |
|||
|
|||
@ -0,0 +1,63 @@ |
|||
var Pubkey = require('../lib/pubkey'); |
|||
var Address = require('../lib/address'); |
|||
var Stealthkey = require('../lib/expmt/stealthkey'); |
|||
var StealthAddress = require('../lib/expmt/stealthaddress'); |
|||
var StealthMessage = require('../lib/expmt/stealthmessage'); |
|||
var Keypair = require('../lib/keypair') |
|||
|
|||
//First, the person receiving must make a stealth key.
|
|||
|
|||
var sk = Stealthkey().fromRandom(); |
|||
|
|||
//It has an associated stealth address.
|
|||
|
|||
var sa = StealthAddress().fromStealthkey(sk); |
|||
|
|||
console.log('Stealth address: ' + sa); |
|||
|
|||
//Now make a message.
|
|||
|
|||
var messagebuf = new Buffer('Hello there. Only you know this message is to you, and only you know what it says.'); |
|||
|
|||
//Encrypt the message with the stealth address.
|
|||
|
|||
var encbuf = StealthMessage.encrypt(messagebuf, sa); |
|||
|
|||
console.log('Hex of the encrypted message: ' + encbuf.toString('hex')); |
|||
|
|||
//Note that the first 20 bytes are a pubkeyhash, which may be interpreted as a bitcoin address.
|
|||
//This address has never been seen before in public.
|
|||
|
|||
var address = Address().set({hashbuf: encbuf.slice(0, 20)}); |
|||
|
|||
console.log('The randomly generated address the message is to: ' + address); |
|||
|
|||
//And the next 33 bytes are a nonce public key, which the message is "from".
|
|||
//It has never been seen before in public.
|
|||
|
|||
var pubkey = Pubkey().fromDER(encbuf.slice(20, 20 + 33)); |
|||
|
|||
console.log('Nonce public key: ' + pubkey); |
|||
|
|||
//The owner of the stealth key can check to see if it is for them.
|
|||
|
|||
console.log('Is the message for me? ' + (StealthMessage.isForMe(encbuf, sk) ? "yes" : "no")); |
|||
|
|||
//The owner can decrypt it.
|
|||
|
|||
var messagebuf2 = StealthMessage.decrypt(encbuf, sk); |
|||
|
|||
console.log('Decrypted message: ' + messagebuf2.toString()); |
|||
|
|||
//If you do not have the payload privkey, you can still use isForMe.
|
|||
sk.payloadKeypair.privkey = undefined; |
|||
|
|||
console.log('Without payload privkey, is the message for me? ' + (StealthMessage.isForMe(encbuf, sk) ? "yes" : "no")); |
|||
|
|||
//...but not decrypt
|
|||
|
|||
try { |
|||
StealthMessage.decrypt(encbuf, sk); |
|||
} catch (e) { |
|||
console.log("...but without the payload privkey, I can't decrypt."); |
|||
} |
|||
@ -0,0 +1,56 @@ |
|||
var fullnode = module.exports; |
|||
|
|||
//main bitcoin library
|
|||
fullnode.Address = require('./lib/address'); |
|||
fullnode.Base58 = require('./lib/base58'); |
|||
fullnode.Base58Check = require('./lib/base58check'); |
|||
fullnode.BIP32 = require('./lib/bip32'); |
|||
fullnode.Block = require('./lib/block'); |
|||
fullnode.Blockheader = require('./lib/blockheader'); |
|||
fullnode.BN = require('./lib/bn'); |
|||
fullnode.BufferReader = require('./lib/bufferreader'); |
|||
fullnode.BufferWriter = require('./lib/bufferwriter'); |
|||
fullnode.Constants = require('./lib/constants'); |
|||
fullnode.ECDSA = require('./lib/ecdsa'); |
|||
fullnode.Hash = require('./lib/hash'); |
|||
fullnode.KDF = require('./lib/kdf'); |
|||
fullnode.Keypair = require('./lib/keypair'); |
|||
fullnode.Message = require('./lib/message'); |
|||
fullnode.Opcode = require('./lib/opcode'); |
|||
fullnode.Point = require('./lib/point'); |
|||
fullnode.Privkey = require('./lib/privkey'); |
|||
fullnode.Pubkey = require('./lib/pubkey'); |
|||
fullnode.Random = require('./lib/random'); |
|||
fullnode.Script = require('./lib/script'); |
|||
fullnode.Signature = require('./lib/signature'); |
|||
fullnode.Transaction = require('./lib/transaction'); |
|||
fullnode.Txin = require('./lib/txin'); |
|||
fullnode.Txout = require('./lib/txout'); |
|||
fullnode.Varint = require('./lib/varint'); |
|||
|
|||
//experimental, nonstandard, or unstable features
|
|||
fullnode.expmt = {}; |
|||
fullnode.expmt.AES = require('./lib/expmt/aes'); |
|||
fullnode.expmt.AESCBC = require('./lib/expmt/aescbc'); |
|||
fullnode.expmt.CBC = require('./lib/expmt/cbc'); |
|||
fullnode.expmt.ECIES = require('./lib/expmt/ecies'); |
|||
fullnode.expmt.StealthAddress = require('./lib/expmt/stealthaddress'); |
|||
fullnode.expmt.Stealthkey = require('./lib/expmt/stealthkey'); |
|||
fullnode.expmt.StealthMessage = require('./lib/expmt/stealthmessage'); |
|||
fullnode.expmt.StealthTx = require('./lib/expmt/stealthtx'); |
|||
|
|||
//dependencies, subject to change
|
|||
fullnode.deps = {}; |
|||
fullnode.deps.aes = require('aes'); |
|||
fullnode.deps.bnjs = require('bn.js'); |
|||
fullnode.deps.bs58 = require('bs58'); |
|||
fullnode.deps.Buffer = Buffer; |
|||
fullnode.deps.elliptic = require('elliptic'); |
|||
fullnode.deps.hashjs = require('hash.js'); |
|||
fullnode.deps.sha512 = require('sha512'); |
|||
|
|||
//fullnode.scriptexec = require('lib/scriptexec');
|
|||
//fullnode.tx = require('lib/tx');
|
|||
//fullnode.txpartial = require('lib/txpartial');
|
|||
|
|||
//fullnode.bip70 = require('lib/bip70');
|
|||
@ -0,0 +1,120 @@ |
|||
var base58check = require('./base58check'); |
|||
var constants = require('./constants'); |
|||
var Hash = require('./hash'); |
|||
var Pubkey = require('./pubkey'); |
|||
var Script = require('./script'); |
|||
|
|||
function Address(buf) { |
|||
if (!(this instanceof Address)) |
|||
return new Address(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); |
|||
} |
|||
}; |
|||
|
|||
Address.prototype.set = function(obj) { |
|||
this.hashbuf = obj.hashbuf || this.hashbuf || null; |
|||
this.networkstr = obj.networkstr || this.networkstr || 'mainnet'; |
|||
this.typestr = obj.typestr || this.typestr || 'pubkeyhash'; |
|||
return this; |
|||
}; |
|||
|
|||
Address.prototype.fromBuffer = function(buf) { |
|||
if (buf.length !== 1 + 20) |
|||
throw new Error('Address buffers must be exactly 21 bytes'); |
|||
var version = buf[0]; |
|||
if (version === constants['mainnet']['pubkeyhash']) { |
|||
this.networkstr = 'mainnet'; |
|||
this.typestr = 'pubkeyhash'; |
|||
} else if (version === constants['mainnet']['scripthash']) { |
|||
this.networkstr = 'mainnet'; |
|||
this.typestr = 'scripthash'; |
|||
} else if (version === constants['testnet']['pubkeyhash']) { |
|||
this.networkstr = 'testnet'; |
|||
this.typestr = 'pubkeyhash'; |
|||
} else if (version === constants['testnet']['scripthash']) { |
|||
this.networkstr = 'testnet'; |
|||
this.typestr = 'scripthash'; |
|||
} else { |
|||
this.networkstr = 'unknown'; |
|||
this.typestr = 'unknown'; |
|||
} |
|||
|
|||
this.hashbuf = buf.slice(1); |
|||
|
|||
return this; |
|||
}; |
|||
|
|||
Address.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 || 'mainnet'; |
|||
this.typestr = typestr || 'pubkeyhash'; |
|||
return this; |
|||
}; |
|||
|
|||
Address.prototype.fromPubkey = function(pubkey, networkstr) { |
|||
this.hashbuf = Hash.sha256ripemd160(pubkey.toBuffer()); |
|||
this.networkstr = networkstr || 'mainnet'; |
|||
this.typestr = 'pubkeyhash'; |
|||
return this; |
|||
}; |
|||
|
|||
Address.prototype.fromScript = function(script, networkstr) { |
|||
this.hashbuf = Hash.sha256ripemd160(script.toBuffer()); |
|||
this.networkstr = networkstr || 'mainnet'; |
|||
this.typestr = 'scripthash'; |
|||
return this; |
|||
}; |
|||
|
|||
Address.prototype.fromString = function(str) { |
|||
var buf = base58check.decode(str); |
|||
return this.fromBuffer(buf); |
|||
} |
|||
|
|||
Address.isValid = function(addrstr) { |
|||
try { |
|||
var address = new Address().fromString(addrstr); |
|||
} catch (e) { |
|||
return false; |
|||
} |
|||
return address.isValid(); |
|||
}; |
|||
|
|||
Address.prototype.isValid = function() { |
|||
try { |
|||
this.validate(); |
|||
return true; |
|||
} catch (e) { |
|||
return false; |
|||
} |
|||
}; |
|||
|
|||
Address.prototype.toBuffer = function() { |
|||
version = new Buffer([constants[this.networkstr][this.typestr]]); |
|||
var buf = Buffer.concat([version, this.hashbuf]); |
|||
return buf; |
|||
}; |
|||
|
|||
Address.prototype.toString = function() { |
|||
return base58check.encode(this.toBuffer()); |
|||
}; |
|||
|
|||
Address.prototype.validate = function() { |
|||
if (!Buffer.isBuffer(this.hashbuf) || this.hashbuf.length !== 20) |
|||
throw new Error('hash must be a buffer of 20 bytes'); |
|||
if (this.networkstr !== 'mainnet' && this.networkstr !== 'testnet') |
|||
throw new Error('networkstr must be "mainnet" or "testnet"'); |
|||
if (this.typestr !== 'pubkeyhash' && this.typestr !== 'scripthash') |
|||
throw new Error('typestr must be "pubkeyhash" or "scripthash"'); |
|||
return this; |
|||
}; |
|||
|
|||
module.exports = Address; |
|||
@ -0,0 +1,53 @@ |
|||
var bs58 = require('bs58'); |
|||
|
|||
var Base58 = function Base58(obj) { |
|||
if (!(this instanceof Base58)) |
|||
return new Base58(obj); |
|||
if (Buffer.isBuffer(obj)) { |
|||
var buf = obj; |
|||
this.fromBuffer(buf); |
|||
} else if (typeof obj === 'string') { |
|||
var str = obj; |
|||
this.fromString(str); |
|||
} else if (obj) { |
|||
this.set(obj); |
|||
} |
|||
}; |
|||
|
|||
Base58.prototype.set = function(obj) { |
|||
this.buf = obj.buf || this.buf || undefined; |
|||
return this; |
|||
}; |
|||
|
|||
Base58.encode = function(buf) { |
|||
if (!Buffer.isBuffer(buf)) |
|||
throw new Error('Input should be a buffer'); |
|||
return bs58.encode(buf); |
|||
}; |
|||
|
|||
Base58.decode = function(str) { |
|||
if (typeof str !== 'string') |
|||
throw new Error('Input should be a string'); |
|||
return bs58.decode(str); |
|||
}; |
|||
|
|||
Base58.prototype.fromBuffer = function(buf) { |
|||
this.buf = buf; |
|||
return this; |
|||
}; |
|||
|
|||
Base58.prototype.fromString = function(str) { |
|||
var buf = Base58.decode(str); |
|||
this.buf = buf; |
|||
return this; |
|||
}; |
|||
|
|||
Base58.prototype.toBuffer = function() { |
|||
return this.buf; |
|||
}; |
|||
|
|||
Base58.prototype.toString = function() { |
|||
return Base58.encode(this.buf); |
|||
}; |
|||
|
|||
module.exports = Base58; |
|||
@ -0,0 +1,73 @@ |
|||
var base58 = require('./base58'); |
|||
var sha256sha256 = require('./hash').sha256sha256; |
|||
|
|||
var Base58Check = function Base58Check(obj) { |
|||
if (!(this instanceof Base58Check)) |
|||
return new Base58Check(obj); |
|||
if (Buffer.isBuffer(obj)) { |
|||
var buf = obj; |
|||
this.fromBuffer(buf); |
|||
} else if (typeof obj === 'string') { |
|||
var str = obj; |
|||
this.fromString(str); |
|||
} else if (obj) { |
|||
this.set(obj); |
|||
} |
|||
}; |
|||
|
|||
Base58Check.prototype.set = function(obj) { |
|||
this.buf = obj.buf || this.buf || undefined; |
|||
return this; |
|||
}; |
|||
|
|||
Base58Check.decode = function(s) { |
|||
if (typeof s !== 'string') |
|||
throw new Error('Input must be a string'); |
|||
|
|||
var buf = base58.decode(s); |
|||
|
|||
if (buf.length < 4) |
|||
throw new Error("Input string too short"); |
|||
|
|||
var data = buf.slice(0, -4); |
|||
var csum = buf.slice(-4); |
|||
|
|||
var hash = sha256sha256(data); |
|||
var hash4 = hash.slice(0, 4); |
|||
|
|||
if (csum.toString('hex') !== hash4.toString('hex')) |
|||
throw new Error("Checksum mismatch"); |
|||
|
|||
return data; |
|||
}; |
|||
|
|||
Base58Check.encode = function(buf) { |
|||
if (!Buffer.isBuffer(buf)) |
|||
throw new Error('Input must be a buffer'); |
|||
var checkedBuf = new Buffer(buf.length + 4); |
|||
var hash = sha256sha256(buf); |
|||
buf.copy(checkedBuf); |
|||
hash.copy(checkedBuf, buf.length); |
|||
return base58.encode(checkedBuf); |
|||
}; |
|||
|
|||
Base58Check.prototype.fromBuffer = function(buf) { |
|||
this.buf = buf; |
|||
return this; |
|||
}; |
|||
|
|||
Base58Check.prototype.fromString = function(str) { |
|||
var buf = Base58Check.decode(str); |
|||
this.buf = buf; |
|||
return this; |
|||
}; |
|||
|
|||
Base58Check.prototype.toBuffer = function() { |
|||
return this.buf; |
|||
}; |
|||
|
|||
Base58Check.prototype.toString = function() { |
|||
return Base58Check.encode(this.buf); |
|||
}; |
|||
|
|||
module.exports = Base58Check; |
|||
@ -0,0 +1,326 @@ |
|||
var Base58Check = require('./base58check'); |
|||
var Hash = require('./hash'); |
|||
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)) |
|||
return new BIP32(obj); |
|||
if (typeof obj === 'string') { |
|||
var str = obj; |
|||
this.fromString(str); |
|||
} else if (obj ) { |
|||
this.set(obj); |
|||
} |
|||
} |
|||
|
|||
BIP32.prototype.set = function(obj) { |
|||
this.version = typeof obj.version !== 'undefined' ? obj.version : this.version; |
|||
this.depth = typeof obj.depth !== 'undefined' ? obj.depth : this.depth; |
|||
this.parentfingerprint = obj.parentfingerprint || this.parentfingerprint; |
|||
this.childindex = obj.childindex || this.childindex; |
|||
this.chaincode = obj.chaincode || this.chaincode; |
|||
this.keypair = obj.keypair || this.keypair; |
|||
this.hasprivkey = typeof obj.hasprivkey !== 'undefined' ? obj.hasprivkey : this.hasprivkey; |
|||
this.pubkeyhash = obj.pubkeyhash || this.pubkeyhash; |
|||
this.xpubkey = obj.xpubkey || this.xpubkey; |
|||
this.xprivkey = obj.xprivkey || this.xprivkey; |
|||
return this; |
|||
}; |
|||
|
|||
BIP32.prototype.fromRandom = function(networkstr) { |
|||
if (!networkstr) |
|||
networkstr = 'mainnet'; |
|||
this.version = constants[networkstr].bip32privkey; |
|||
this.depth = 0x00; |
|||
this.parentfingerprint = new Buffer([0, 0, 0, 0]); |
|||
this.childindex = new Buffer([0, 0, 0, 0]); |
|||
this.chaincode = Random.getRandomBuffer(32); |
|||
this.keypair = (new Keypair()).fromRandom(); |
|||
this.hasprivkey = true; |
|||
this.pubkeyhash = Hash.sha256ripemd160(this.keypair.pubkey.toBuffer()); |
|||
this.buildxpubkey(); |
|||
this.buildxprivkey(); |
|||
}; |
|||
|
|||
BIP32.prototype.fromString = function(str) { |
|||
var bytes = Base58Check.decode(str); |
|||
this.initFromBytes(bytes); |
|||
return this; |
|||
}; |
|||
|
|||
BIP32.prototype.fromSeed = function(bytes, networkstr) { |
|||
if (!networkstr) |
|||
networkstr = 'mainnet'; |
|||
|
|||
if (!Buffer.isBuffer(bytes)) |
|||
throw new Error('bytes must be a buffer'); |
|||
if (bytes.length < 128 / 8) |
|||
throw new Error('Need more than 128 bytes of entropy'); |
|||
if (bytes.length > 512 / 8) |
|||
throw new Error('More than 512 bytes of entropy is nonstandard'); |
|||
var hash = Hash.sha512hmac(bytes, new Buffer('Bitcoin seed')); |
|||
|
|||
this.depth = 0x00; |
|||
this.parentfingerprint = new Buffer([0, 0, 0, 0]); |
|||
this.childindex = new Buffer([0, 0, 0, 0]); |
|||
this.chaincode = hash.slice(32, 64); |
|||
this.version = constants[networkstr].bip32privkey; |
|||
this.keypair = new Keypair(); |
|||
this.keypair.privkey = new Privkey({bn: BN().fromBuffer(hash.slice(0, 32))}); |
|||
this.keypair.privkey2pubkey(); |
|||
this.hasprivkey = true; |
|||
this.pubkeyhash = Hash.sha256ripemd160(this.keypair.pubkey.toBuffer()); |
|||
|
|||
this.buildxpubkey(); |
|||
this.buildxprivkey(); |
|||
|
|||
return this; |
|||
}; |
|||
|
|||
BIP32.prototype.initFromBytes = function(bytes) { |
|||
// Both pub and private extended keys are 78 bytes
|
|||
if (bytes.length != 78) |
|||
throw new Error('not enough data'); |
|||
|
|||
this.version = bytes.slice(0, 4).readUInt32BE(0); |
|||
this.depth = bytes.slice(4, 5).readUInt8(0); |
|||
this.parentfingerprint = bytes.slice(5, 9); |
|||
this.childindex = bytes.slice(9, 13).readUInt32BE(0); |
|||
this.chaincode = bytes.slice(13, 45); |
|||
|
|||
var keyBytes = bytes.slice(45, 78); |
|||
|
|||
var isPrivate = |
|||
(this.version == constants.mainnet.bip32privkey || |
|||
this.version == constants.testnet.bip32privkey); |
|||
|
|||
var isPublic = |
|||
(this.version == constants.mainnet.bip32pubkey || |
|||
this.version == constants.testnet.bip32pubkey); |
|||
|
|||
if (isPrivate && keyBytes[0] == 0) { |
|||
this.keypair = new Keypair(); |
|||
this.keypair.privkey = new Privkey({bn: BN().fromBuffer(keyBytes.slice(1, 33))}); |
|||
this.keypair.privkey2pubkey(); |
|||
this.pubkeyhash = Hash.sha256ripemd160(this.keypair.pubkey.toBuffer()); |
|||
this.hasprivkey = true; |
|||
} else if (isPublic && (keyBytes[0] == 0x02 || keyBytes[0] == 0x03)) { |
|||
this.keypair = new Keypair(); |
|||
this.keypair.pubkey = (new Pubkey()).fromDER(keyBytes); |
|||
this.pubkeyhash = Hash.sha256ripemd160(this.keypair.pubkey.toBuffer()); |
|||
this.hasprivkey = false; |
|||
} else { |
|||
throw new Error('Invalid key'); |
|||
} |
|||
|
|||
this.buildxpubkey(); |
|||
this.buildxprivkey(); |
|||
} |
|||
|
|||
BIP32.prototype.buildxpubkey = function() { |
|||
this.xpubkey = new Buffer([]); |
|||
|
|||
var v = null; |
|||
switch (this.version) { |
|||
case constants.mainnet.bip32pubkey: |
|||
case constants.mainnet.bip32privkey: |
|||
v = constants.mainnet.bip32pubkey; |
|||
break; |
|||
case constants.testnet.bip32pubkey: |
|||
case constants.testnet.bip32privkey: |
|||
v = constants.testnet.bip32pubkey; |
|||
break; |
|||
default: |
|||
throw new Error('Unknown version'); |
|||
} |
|||
|
|||
// Version
|
|||
this.xpubkey = Buffer.concat([ |
|||
new Buffer([v >> 24]), |
|||
new Buffer([(v >> 16) & 0xff]), |
|||
new Buffer([(v >> 8) & 0xff]), |
|||
new Buffer([v & 0xff]), |
|||
new Buffer([this.depth]), |
|||
this.parentfingerprint, |
|||
new Buffer([this.childindex >>> 24]), |
|||
new Buffer([(this.childindex >>> 16) & 0xff]), |
|||
new Buffer([(this.childindex >>> 8) & 0xff]), |
|||
new Buffer([this.childindex & 0xff]), |
|||
this.chaincode, |
|||
this.keypair.pubkey.toBuffer() |
|||
]); |
|||
} |
|||
|
|||
BIP32.prototype.xpubkeyString = function(format) { |
|||
if (format === undefined || format === 'base58') { |
|||
return Base58Check.encode(this.xpubkey); |
|||
} else if (format === 'hex') { |
|||
return this.xpubkey.toString('hex'); |
|||
} else { |
|||
throw new Error('bad format'); |
|||
} |
|||
} |
|||
|
|||
BIP32.prototype.buildxprivkey = function() { |
|||
if (!this.hasprivkey) return; |
|||
this.xprivkey = new Buffer([]); |
|||
|
|||
var v = this.version; |
|||
|
|||
this.xprivkey = Buffer.concat([ |
|||
new Buffer([v >> 24]), |
|||
new Buffer([(v >> 16) & 0xff]), |
|||
new Buffer([(v >> 8) & 0xff]), |
|||
new Buffer([v & 0xff]), |
|||
new Buffer([this.depth]), |
|||
this.parentfingerprint, |
|||
new Buffer([this.childindex >>> 24]), |
|||
new Buffer([(this.childindex >>> 16) & 0xff]), |
|||
new Buffer([(this.childindex >>> 8) & 0xff]), |
|||
new Buffer([this.childindex & 0xff]), |
|||
this.chaincode, |
|||
new Buffer([0]), |
|||
this.keypair.privkey.bn.toBuffer({size: 32}) |
|||
]); |
|||
} |
|||
|
|||
BIP32.prototype.xprivkeyString = function(format) { |
|||
if (format === undefined || format === 'base58') { |
|||
return Base58Check.encode(this.xprivkey); |
|||
} else if (format === 'hex') { |
|||
return this.xprivkey.toString('hex'); |
|||
} else { |
|||
throw new Error('bad format'); |
|||
} |
|||
} |
|||
|
|||
|
|||
BIP32.prototype.derive = function(path) { |
|||
var e = path.split('/'); |
|||
|
|||
// Special cases:
|
|||
if (path == 'm' || path == 'M' || path == 'm\'' || path == 'M\'') |
|||
return this; |
|||
|
|||
var bip32 = this; |
|||
for (var i in e) { |
|||
var c = e[i]; |
|||
|
|||
if (i == 0) { |
|||
if (c != 'm') throw new Error('invalid path'); |
|||
continue; |
|||
} |
|||
|
|||
if (parseInt(c.replace("'", "")).toString() !== c.replace("'", "")) |
|||
throw new Error('invalid path'); |
|||
|
|||
var usePrivate = (c.length > 1) && (c[c.length - 1] == '\''); |
|||
var childindex = parseInt(usePrivate ? c.slice(0, c.length - 1) : c) & 0x7fffffff; |
|||
|
|||
if (usePrivate) |
|||
childindex += 0x80000000; |
|||
|
|||
bip32 = bip32.deriveChild(childindex); |
|||
} |
|||
|
|||
return bip32; |
|||
} |
|||
|
|||
BIP32.prototype.deriveChild = function(i) { |
|||
if (typeof i !== 'number') |
|||
throw new Error('i must be a number'); |
|||
|
|||
var ib = []; |
|||
ib.push((i >> 24) & 0xff); |
|||
ib.push((i >> 16) & 0xff); |
|||
ib.push((i >> 8) & 0xff); |
|||
ib.push(i & 0xff); |
|||
ib = new Buffer(ib); |
|||
|
|||
var usePrivate = (i & 0x80000000) != 0; |
|||
|
|||
var isPrivate = |
|||
(this.version == constants.mainnet.bip32privkey || |
|||
this.version == constants.testnet.bip32privkey); |
|||
|
|||
if (usePrivate && (!this.hasprivkey || !isPrivate)) |
|||
throw new Error('Cannot do private key derivation without private key'); |
|||
|
|||
var ret = null; |
|||
if (this.hasprivkey) { |
|||
var data = null; |
|||
|
|||
if (usePrivate) { |
|||
data = Buffer.concat([new Buffer([0]), this.keypair.privkey.bn.toBuffer({size: 32}), ib]); |
|||
} else { |
|||
data = Buffer.concat([this.keypair.pubkey.toBuffer({size: 32}), ib]); |
|||
} |
|||
|
|||
var hash = Hash.sha512hmac(data, this.chaincode); |
|||
var il = BN().fromBuffer(hash.slice(0, 32), {size: 32}); |
|||
var ir = hash.slice(32, 64); |
|||
|
|||
// ki = IL + kpar (mod n).
|
|||
var k = il.add(this.keypair.privkey.bn).mod(Point.getN()); |
|||
|
|||
ret = new BIP32(); |
|||
ret.chaincode = ir; |
|||
|
|||
ret.keypair = new Keypair(); |
|||
ret.keypair.privkey = new Privkey({bn: k}); |
|||
ret.keypair.privkey2pubkey(); |
|||
ret.hasprivkey = true; |
|||
|
|||
} else { |
|||
var data = Buffer.concat([this.keypair.pubkey.toBuffer(), ib]); |
|||
var hash = Hash.sha512hmac(data, this.chaincode); |
|||
var il = BN().fromBuffer(hash.slice(0, 32)); |
|||
var ir = hash.slice(32, 64); |
|||
|
|||
// Ki = (IL + kpar)*G = IL*G + Kpar
|
|||
var ilG = Point.getG().mul(il); |
|||
var Kpar = this.keypair.pubkey.point; |
|||
var Ki = ilG.add(Kpar); |
|||
var newpub = new Pubkey(); |
|||
newpub.point = Ki; |
|||
|
|||
ret = new BIP32(); |
|||
ret.chaincode = ir; |
|||
|
|||
var keypair = new Keypair(); |
|||
keypair.pubkey = newpub; |
|||
ret.keypair = keypair; |
|||
ret.hasprivkey = false; |
|||
} |
|||
|
|||
ret.childindex = i; |
|||
ret.parentfingerprint = this.pubkeyhash.slice(0, 4); |
|||
ret.version = this.version; |
|||
ret.depth = this.depth + 1; |
|||
|
|||
ret.pubkeyhash = Hash.sha256ripemd160(ret.keypair.pubkey.toBuffer()); |
|||
|
|||
ret.buildxpubkey(); |
|||
ret.buildxprivkey(); |
|||
|
|||
return ret; |
|||
} |
|||
|
|||
BIP32.prototype.toString = function() { |
|||
var isPrivate = |
|||
(this.version == constants.mainnet.bip32privkey || |
|||
this.version == constants.testnet.bip32privkey); |
|||
|
|||
if (isPrivate) |
|||
return this.xprivkeyString(); |
|||
else |
|||
return this.xpubkeyString(); |
|||
}; |
|||
|
|||
module.exports = BIP32; |
|||
@ -0,0 +1,108 @@ |
|||
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)) |
|||
return new Block(magicnum, blocksize, blockheader, txsvi, txs); |
|||
if (typeof magicnum === 'number') { |
|||
this.set({ |
|||
magicnum: magicnum, |
|||
blocksize: blocksize, |
|||
blockheader: blockheader, |
|||
txsvi: txsvi, |
|||
txs: txs |
|||
}); |
|||
} else if (Buffer.isBuffer(magicnum)) { |
|||
var blockbuf = magicnum; |
|||
this.fromBuffer(blockbuf); |
|||
} else if (magicnum) { |
|||
var obj = magicnum; |
|||
} |
|||
}; |
|||
|
|||
Block.prototype.set = function(obj) { |
|||
this.magicnum = typeof obj.magicnum !== 'undefined' ? obj.magicnum : this.magicnum; |
|||
this.blocksize = typeof obj.blocksize !== 'undefined' ? obj.blocksize : this.blocksize; |
|||
this.blockheader = obj.blockheader || this.blockheader; |
|||
this.txsvi = obj.txsvi || this.txsvi; |
|||
this.txs = obj.txs || this.txs; |
|||
return this; |
|||
}; |
|||
|
|||
Block.prototype.fromJSON = function(json) { |
|||
var txs = []; |
|||
json.txs.forEach(function(tx) { |
|||
txs.push(Transaction().fromJSON(tx)); |
|||
}); |
|||
this.set({ |
|||
magicnum: json.magicnum, |
|||
blocksize: json.blocksize, |
|||
blockheader: Blockheader().fromJSON(json.blockheader), |
|||
txsvi: Varint().fromJSON(json.txsvi), |
|||
txs: txs |
|||
}); |
|||
return this; |
|||
}; |
|||
|
|||
Block.prototype.toJSON = function() { |
|||
var txs = []; |
|||
this.txs.forEach(function(tx) { |
|||
txs.push(tx.toJSON()); |
|||
}); |
|||
return { |
|||
magicnum: this.magicnum, |
|||
blocksize: this.blocksize, |
|||
blockheader: this.blockheader.toJSON(), |
|||
txsvi: this.txsvi.toJSON(), |
|||
txs: txs |
|||
}; |
|||
}; |
|||
|
|||
Block.prototype.fromBuffer = function(buf) { |
|||
return this.fromBufferReader(BufferReader(buf)); |
|||
}; |
|||
|
|||
Block.prototype.fromBufferReader = function(br) { |
|||
this.magicnum = br.readUInt32LE(); |
|||
this.blocksize = br.readUInt32LE(); |
|||
this.blockheader = Blockheader().fromBufferReader(br); |
|||
this.txsvi = Varint(br.readVarintBuf()); |
|||
var txslen = this.txsvi.toNumber(); |
|||
this.txs = []; |
|||
for (var i = 0; i < txslen; i++) { |
|||
this.txs.push(Transaction().fromBufferReader(br)); |
|||
} |
|||
return this; |
|||
}; |
|||
|
|||
Block.prototype.toBuffer = function() { |
|||
return this.toBufferWriter().concat(); |
|||
}; |
|||
|
|||
Block.prototype.toBufferWriter = function(bw) { |
|||
if (!bw) |
|||
bw = new BufferWriter(); |
|||
bw.writeUInt32LE(this.magicnum); |
|||
bw.writeUInt32LE(this.blocksize); |
|||
bw.write(this.blockheader.toBuffer()); |
|||
bw.write(this.txsvi.buf); |
|||
var txslen = this.txsvi.toNumber(); |
|||
for (var i = 0; i < txslen; i++) { |
|||
this.txs[i].toBufferWriter(bw); |
|||
} |
|||
return bw; |
|||
}; |
|||
|
|||
Block.prototype.hash = function() { |
|||
return Hash.sha256sha256(this.blockheader.toBuffer()); |
|||
}; |
|||
|
|||
Block.prototype.id = function() { |
|||
return BufferReader(this.hash()).reverse().read(); |
|||
}; |
|||
|
|||
module.exports = Block; |
|||
@ -0,0 +1,88 @@ |
|||
var BufferReader = require('./bufferreader'); |
|||
var BufferWriter = require('./bufferwriter'); |
|||
|
|||
var Blockheader = function Blockheader(version, prevblockidbuf, merklerootbuf, time, bits, nonce) { |
|||
if (!(this instanceof Blockheader)) |
|||
return new Blockheader(version, prevblockidbuf, merklerootbuf, time, bits, nonce); |
|||
if (typeof version === 'number') { |
|||
this.set({ |
|||
version: version, |
|||
prevblockidbuf: prevblockidbuf, |
|||
merklerootbuf: merklerootbuf, |
|||
time: time, |
|||
bits: bits, |
|||
nonce: nonce |
|||
}); |
|||
} else if (Buffer.isBuffer(version)) { |
|||
var bhbuf = version; |
|||
this.fromBuffer(bhbuf); |
|||
} else if (version) { |
|||
var obj = version; |
|||
this.set(obj); |
|||
} |
|||
} |
|||
|
|||
Blockheader.prototype.set = function(obj) { |
|||
this.version = typeof obj.version !== 'undefined' ? obj.version : this.version; |
|||
this.prevblockidbuf = obj.prevblockidbuf || this.prevblockidbuf; |
|||
this.merklerootbuf = obj.merklerootbuf || this.merklerootbuf; |
|||
this.time = typeof obj.time !== 'undefined' ? obj.time : this.time; |
|||
this.bits = typeof obj.bits !== 'undefined' ? obj.bits : this.bits; |
|||
this.nonce = typeof obj.nonce !== 'undefined' ? obj.nonce : this.nonce; |
|||
return this; |
|||
}; |
|||
|
|||
Blockheader.prototype.fromJSON = function(json) { |
|||
this.set({ |
|||
version: json.version, |
|||
prevblockidbuf: new Buffer(json.prevblockidbuf, 'hex'), |
|||
merklerootbuf: new Buffer(json.merklerootbuf, 'hex'), |
|||
time: json.time, |
|||
bits: json.bits, |
|||
nonce: json.nonce |
|||
}); |
|||
return this; |
|||
}; |
|||
|
|||
Blockheader.prototype.toJSON = function() { |
|||
return { |
|||
version: this.version, |
|||
prevblockidbuf: this.prevblockidbuf.toString('hex'), |
|||
merklerootbuf: this.merklerootbuf.toString('hex'), |
|||
time: this.time, |
|||
bits: this.bits, |
|||
nonce: this.nonce |
|||
}; |
|||
}; |
|||
|
|||
Blockheader.prototype.fromBuffer = function(buf) { |
|||
return this.fromBufferReader(BufferReader(buf)); |
|||
}; |
|||
|
|||
Blockheader.prototype.fromBufferReader = function(br) { |
|||
this.version = br.readUInt32LE(); |
|||
this.prevblockidbuf = br.read(32); |
|||
this.merklerootbuf = br.read(32); |
|||
this.time = br.readUInt32LE(); |
|||
this.bits = br.readUInt32LE(); |
|||
this.nonce = br.readUInt32LE(); |
|||
return this; |
|||
}; |
|||
|
|||
Blockheader.prototype.toBuffer = function() { |
|||
return this.toBufferWriter().concat(); |
|||
}; |
|||
|
|||
Blockheader.prototype.toBufferWriter = function(bw) { |
|||
if (!bw) |
|||
bw = new BufferWriter(); |
|||
bw.writeUInt32LE(this.version); |
|||
bw.write(this.prevblockidbuf); |
|||
bw.write(this.merklerootbuf); |
|||
bw.writeUInt32LE(this.time); |
|||
bw.writeUInt32LE(this.bits); |
|||
bw.writeUInt32LE(this.nonce); |
|||
return bw; |
|||
}; |
|||
|
|||
module.exports = Blockheader; |
|||
@ -0,0 +1,132 @@ |
|||
var _BN = require('bn.js'); |
|||
|
|||
var BN = function BN_extended(n) { |
|||
if (!(this instanceof BN_extended)) { |
|||
return new BN(n); |
|||
} |
|||
arguments[0] = n; |
|||
return _BN.apply(this, arguments); |
|||
}; |
|||
|
|||
module.exports = BN; |
|||
|
|||
BN.prototype = _BN.prototype; |
|||
|
|||
var reversebuf = function(buf, nbuf) { |
|||
for (var i = 0; i < buf.length; i++) { |
|||
nbuf[i] = buf[buf.length-1-i]; |
|||
} |
|||
}; |
|||
|
|||
BN.prototype.toJSON = function() { |
|||
return this.toString(); |
|||
}; |
|||
|
|||
BN.prototype.fromJSON = function(str) { |
|||
var bn = BN(str); |
|||
bn.copy(this); |
|||
return this; |
|||
}; |
|||
|
|||
BN.prototype.fromString = function(str) { |
|||
var bn = BN(str); |
|||
bn.copy(this); |
|||
return this; |
|||
}; |
|||
|
|||
BN.fromBuffer = function(buf, opts) { |
|||
if (typeof opts !== 'undefined' && opts.endian === 'little') { |
|||
var nbuf = new Buffer(buf.length); |
|||
reversebuf(buf, nbuf); |
|||
buf = nbuf; |
|||
} |
|||
var hex = buf.toString('hex'); |
|||
if (hex.length % 2) |
|||
hex = "0" + hex; |
|||
var bn = new BN(hex, 16); |
|||
return bn; |
|||
}; |
|||
|
|||
BN.prototype.fromBuffer = function(buf, opts) { |
|||
var bn = BN.fromBuffer(buf, opts); |
|||
bn.copy(this); |
|||
|
|||
return this; |
|||
}; |
|||
|
|||
BN.prototype.toBuffer = function(opts) { |
|||
var buf; |
|||
if (opts && opts.size) { |
|||
var hex = this.toString(16); |
|||
if (hex.length % 2) |
|||
hex = "0" + hex; |
|||
var natlen = hex.length/2; |
|||
buf = new Buffer(hex, 'hex'); |
|||
|
|||
if (natlen == opts.size) |
|||
buf = buf; |
|||
|
|||
else if (natlen > opts.size) { |
|||
buf = buf.slice(natlen - buf.length, buf.length); |
|||
} |
|||
|
|||
else if (natlen < opts.size) { |
|||
var rbuf = new Buffer(opts.size); |
|||
//rbuf.fill(0);
|
|||
for (var i = 0; i < buf.length; i++) |
|||
rbuf[rbuf.length-1-i] = buf[buf.length-1-i]; |
|||
for (var i = 0; i < opts.size - natlen; i++) |
|||
rbuf[i] = 0; |
|||
buf = rbuf; |
|||
} |
|||
} |
|||
else { |
|||
var hex = this.toString(16); |
|||
if (hex.length % 2) |
|||
hex = "0" + hex; |
|||
buf = new Buffer(hex, 'hex'); |
|||
} |
|||
|
|||
if (typeof opts !== 'undefined' && opts.endian === 'little') { |
|||
var nbuf = new Buffer(buf.length); |
|||
reversebuf(buf, nbuf); |
|||
buf = nbuf; |
|||
} |
|||
|
|||
return buf; |
|||
}; |
|||
|
|||
function decorate(name) { |
|||
BN.prototype['_' + name] = _BN.prototype[name]; |
|||
var f = function(b) { |
|||
if (typeof b === 'string') |
|||
b = new _BN(b); |
|||
else if (typeof b === 'number') |
|||
b = new _BN(b.toString()); |
|||
return this['_' + name](b); |
|||
}; |
|||
BN.prototype[name] = f; |
|||
}; |
|||
|
|||
_BN.prototype.gt = function(b) { |
|||
return this.cmp(b) > 0; |
|||
}; |
|||
|
|||
_BN.prototype.lt = function(b) { |
|||
return this.cmp(b) < 0; |
|||
}; |
|||
|
|||
decorate('add'); |
|||
decorate('sub'); |
|||
decorate('mul'); |
|||
decorate('mod'); |
|||
decorate('div'); |
|||
decorate('cmp'); |
|||
decorate('gt'); |
|||
decorate('lt'); |
|||
|
|||
BN.prototype.toNumber = function() { |
|||
return parseInt(this['toString'](10), 10); |
|||
}; |
|||
|
|||
module.exports = BN; |
|||
@ -0,0 +1,133 @@ |
|||
var BN = require('./bn'); |
|||
|
|||
var BufferReader = function BufferReader(buf) { |
|||
if (!(this instanceof BufferReader)) |
|||
return new BufferReader(buf); |
|||
if (Buffer.isBuffer(buf)) { |
|||
this.set({buf: buf}); |
|||
} |
|||
else if (buf) { |
|||
var obj = buf; |
|||
this.set(obj); |
|||
} |
|||
}; |
|||
|
|||
BufferReader.prototype.set = function(obj) { |
|||
this.buf = obj.buf || this.buf || undefined; |
|||
this.pos = obj.pos || this.pos || 0; |
|||
return this; |
|||
}; |
|||
|
|||
BufferReader.prototype.eof = function() { |
|||
return this.pos >= this.buf.length; |
|||
}; |
|||
|
|||
BufferReader.prototype.read = function(len) { |
|||
if (!len) |
|||
var len = this.buf.length; |
|||
var buf = this.buf.slice(this.pos, this.pos + len); |
|||
this.pos = this.pos + len; |
|||
return buf; |
|||
}; |
|||
|
|||
BufferReader.prototype.readUInt8 = function() { |
|||
var val = this.buf.readUInt8(this.pos); |
|||
this.pos = this.pos + 1; |
|||
return val; |
|||
}; |
|||
|
|||
BufferReader.prototype.readUInt16BE = function() { |
|||
var val = this.buf.readUInt16BE(this.pos); |
|||
this.pos = this.pos + 2; |
|||
return val; |
|||
}; |
|||
|
|||
BufferReader.prototype.readUInt16LE = function() { |
|||
var val = this.buf.readUInt16LE(this.pos); |
|||
this.pos = this.pos + 2; |
|||
return val; |
|||
}; |
|||
|
|||
BufferReader.prototype.readUInt32BE = function() { |
|||
var val = this.buf.readUInt32BE(this.pos); |
|||
this.pos = this.pos + 4; |
|||
return val; |
|||
}; |
|||
|
|||
BufferReader.prototype.readUInt32LE = function() { |
|||
var val = this.buf.readUInt32LE(this.pos); |
|||
this.pos = this.pos + 4; |
|||
return val; |
|||
}; |
|||
|
|||
BufferReader.prototype.readUInt64BEBN = function() { |
|||
var buf = this.buf.slice(this.pos, this.pos + 8); |
|||
var bn = BN().fromBuffer(buf); |
|||
this.pos = this.pos + 8; |
|||
return bn; |
|||
}; |
|||
|
|||
BufferReader.prototype.readUInt64LEBN = function() { |
|||
var buf = this.buf.slice(this.pos, this.pos + 8); |
|||
var reversebuf = BufferReader({buf: buf}).reverse().read(); |
|||
var bn = BN().fromBuffer(reversebuf); |
|||
this.pos = this.pos + 8; |
|||
return bn; |
|||
}; |
|||
|
|||
BufferReader.prototype.readVarintNum = function() { |
|||
var first = this.readUInt8(); |
|||
switch (first) { |
|||
case 0xFD: |
|||
return this.readUInt16LE(); |
|||
case 0xFE: |
|||
return this.readUInt32LE(); |
|||
case 0xFF: |
|||
var bn = this.readUInt64LEBN(); |
|||
var n = bn.toNumber(); |
|||
if (n <= Math.pow(2, 53)) |
|||
return n; |
|||
else |
|||
throw new Error('number too large to retain precision - use readVarintBN'); |
|||
default: |
|||
return first; |
|||
} |
|||
}; |
|||
|
|||
BufferReader.prototype.readVarintBuf = function() { |
|||
var first = this.buf.readUInt8(this.pos); |
|||
switch (first) { |
|||
case 0xFD: |
|||
return this.read(1 + 2); |
|||
case 0xFE: |
|||
return this.read(1 + 4); |
|||
case 0xFF: |
|||
return this.read(1 + 8); |
|||
default: |
|||
return this.read(1); |
|||
} |
|||
}; |
|||
|
|||
BufferReader.prototype.readVarintBN = function() { |
|||
var first = this.readUInt8(); |
|||
switch (first) { |
|||
case 0xFD: |
|||
return BN(this.readUInt16LE()); |
|||
case 0xFE: |
|||
return BN(this.readUInt32LE()); |
|||
case 0xFF: |
|||
return this.readUInt64LEBN(); |
|||
default: |
|||
return BN(first); |
|||
} |
|||
}; |
|||
|
|||
BufferReader.prototype.reverse = function() { |
|||
var buf = new Buffer(this.buf.length); |
|||
for (var i = 0; i < buf.length; i++) |
|||
buf[i] = this.buf[this.buf.length - 1 - i]; |
|||
this.buf = buf; |
|||
return this; |
|||
}; |
|||
|
|||
module.exports = BufferReader; |
|||
@ -0,0 +1,135 @@ |
|||
var BN = require('./bn'); |
|||
|
|||
var BufferWriter = function BufferWriter(obj) { |
|||
if (!(this instanceof BufferWriter)) |
|||
return new BufferWriter(obj); |
|||
if (obj) |
|||
this.set(obj); |
|||
else |
|||
this.bufs = []; |
|||
}; |
|||
|
|||
BufferWriter.prototype.set = function(obj) { |
|||
this.bufs = obj.bufs || this.bufs || []; |
|||
return this; |
|||
}; |
|||
|
|||
BufferWriter.prototype.toBuffer = function() { |
|||
return this.concat(); |
|||
}; |
|||
|
|||
BufferWriter.prototype.concat = function() { |
|||
return Buffer.concat(this.bufs); |
|||
}; |
|||
|
|||
BufferWriter.prototype.write = function(buf) { |
|||
this.bufs.push(buf); |
|||
return this; |
|||
}; |
|||
|
|||
BufferWriter.prototype.writeUInt8 = function(n) { |
|||
var buf = new Buffer(1); |
|||
buf.writeUInt8(n, 0); |
|||
this.write(buf); |
|||
return this; |
|||
}; |
|||
|
|||
BufferWriter.prototype.writeUInt16BE = function(n) { |
|||
var buf = new Buffer(2); |
|||
buf.writeUInt16BE(n, 0); |
|||
this.write(buf); |
|||
return this; |
|||
}; |
|||
|
|||
BufferWriter.prototype.writeUInt16LE = function(n) { |
|||
var buf = new Buffer(2); |
|||
buf.writeUInt16LE(n, 0); |
|||
this.write(buf); |
|||
return this; |
|||
}; |
|||
|
|||
BufferWriter.prototype.writeUInt32BE = function(n) { |
|||
var buf = new Buffer(4); |
|||
buf.writeUInt32BE(n, 0); |
|||
this.write(buf); |
|||
return this; |
|||
}; |
|||
|
|||
BufferWriter.prototype.writeUInt32LE = function(n) { |
|||
var buf = new Buffer(4); |
|||
buf.writeUInt32LE(n, 0); |
|||
this.write(buf); |
|||
return this; |
|||
}; |
|||
|
|||
BufferWriter.prototype.writeUInt64BEBN = function(bn) { |
|||
var buf = bn.toBuffer({size: 8}); |
|||
this.write(buf); |
|||
return this; |
|||
}; |
|||
|
|||
BufferWriter.prototype.writeUInt64LEBN = function(bn) { |
|||
var buf = bn.toBuffer({size: 8}); |
|||
var reversebuf = new Buffer(Array.apply(new Array(), buf).reverse()); |
|||
this.write(reversebuf); |
|||
return this; |
|||
}; |
|||
|
|||
BufferWriter.prototype.writeVarintNum = function(n) { |
|||
var buf = BufferWriter.varintBufNum(n); |
|||
this.write(buf); |
|||
return this; |
|||
}; |
|||
|
|||
BufferWriter.prototype.writeVarintBN = function(bn) { |
|||
var buf = BufferWriter.varintBufBN(bn); |
|||
this.write(buf); |
|||
return this; |
|||
}; |
|||
|
|||
BufferWriter.varintBufNum = function(n) { |
|||
var buf = undefined; |
|||
if (n < 253) { |
|||
buf = new Buffer(1); |
|||
buf.writeUInt8(n, 0); |
|||
} else if (n < 0x10000) { |
|||
buf = new Buffer(1 + 2); |
|||
buf.writeUInt8(253, 0); |
|||
buf.writeUInt16LE(n, 1); |
|||
} else if (n < 0x100000000) { |
|||
buf = new Buffer(1 + 4); |
|||
buf.writeUInt8(254, 0); |
|||
buf.writeUInt32LE(n, 1); |
|||
} else { |
|||
buf = new Buffer(1 + 8); |
|||
buf.writeUInt8(255, 0); |
|||
buf.writeInt32LE(n & -1, 1); |
|||
buf.writeUInt32LE(Math.floor(n / 0x100000000), 5); |
|||
} |
|||
return buf; |
|||
}; |
|||
|
|||
BufferWriter.varintBufBN = function(bn) { |
|||
var buf = undefined; |
|||
var n = bn.toNumber(); |
|||
if (n < 253) { |
|||
buf = new Buffer(1); |
|||
buf.writeUInt8(n, 0); |
|||
} else if (n < 0x10000) { |
|||
buf = new Buffer(1 + 2); |
|||
buf.writeUInt8(253, 0); |
|||
buf.writeUInt16LE(n, 1); |
|||
} else if (n < 0x100000000) { |
|||
buf = new Buffer(1 + 4); |
|||
buf.writeUInt8(254, 0); |
|||
buf.writeUInt32LE(n, 1); |
|||
} else { |
|||
var bw = new BufferWriter(); |
|||
bw.writeUInt8(255); |
|||
bw.writeUInt64LEBN(bn); |
|||
var buf = bw.concat(); |
|||
} |
|||
return buf; |
|||
}; |
|||
|
|||
module.exports = BufferWriter; |
|||
@ -0,0 +1,15 @@ |
|||
exports.mainnet = { |
|||
pubkeyhash: 0x00, |
|||
privkey: 0x80, |
|||
scripthash: 0x05, |
|||
bip32pubkey: 0x0488b21e, |
|||
bip32privkey: 0x0488ade4, |
|||
}; |
|||
|
|||
exports.testnet = { |
|||
pubkeyhash: 0x6f, |
|||
privkey: 0xef, |
|||
scripthash: 0xc4, |
|||
bip32pubkey: 0x043587cf, |
|||
bip32privkey: 0x04358394, |
|||
}; |
|||
@ -0,0 +1,216 @@ |
|||
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 ECDSA = function ECDSA(obj) { |
|||
if (!(this instanceof ECDSA)) |
|||
return new ECDSA(obj); |
|||
if (obj) |
|||
this.set(obj); |
|||
}; |
|||
|
|||
ECDSA.prototype.set = function(obj) { |
|||
this.hashbuf = obj.hashbuf || this.hashbuf; |
|||
this.keypair = obj.keypair || this.keypair; |
|||
this.sig = obj.sig || this.sig; |
|||
this.k = obj.k || this.k; |
|||
this.verified = obj.verified || this.verified; |
|||
return this; |
|||
}; |
|||
|
|||
ECDSA.prototype.calci = function() { |
|||
for (var i = 0; i < 4; i++) { |
|||
this.sig.i = i; |
|||
try { |
|||
var Qprime = this.sig2pubkey(); |
|||
} catch (e) { |
|||
continue; |
|||
} |
|||
|
|||
if (Qprime.point.eq(this.keypair.pubkey.point)) { |
|||
this.sig.compressed = this.keypair.pubkey.compressed; |
|||
return this; |
|||
} |
|||
} |
|||
|
|||
this.sig.i = undefined; |
|||
throw new Error('Unable to find valid recovery factor'); |
|||
}; |
|||
|
|||
ECDSA.prototype.fromString = function(str) { |
|||
var obj = JSON.parse(str); |
|||
if (obj.hashbuf) |
|||
this.hashbuf = new Buffer(obj.hashbuf, 'hex'); |
|||
if (obj.keypair) |
|||
this.keypair = Keypair().fromString(obj.keypair); |
|||
if (obj.sig) |
|||
this.sig = Signature().fromString(obj.sig); |
|||
if (obj.k) |
|||
this.k = BN(obj.k, 10); |
|||
return this; |
|||
}; |
|||
|
|||
ECDSA.prototype.randomK = function() { |
|||
var N = Point.getN(); |
|||
var k; |
|||
do { |
|||
k = BN().fromBuffer(Random.getRandomBuffer(32)); |
|||
} while (!(k.lt(N) && k.gt(0))); |
|||
this.k = k; |
|||
return this; |
|||
}; |
|||
|
|||
// Information about public key recovery:
|
|||
// https://bitcointalk.org/index.php?topic=6430.0
|
|||
// http://stackoverflow.com/questions/19665491/how-do-i-get-an-ecdsa-public-key-from-just-a-bitcoin-signature-sec1-4-1-6-k
|
|||
ECDSA.prototype.sig2pubkey = function() { |
|||
var i = this.sig.i; |
|||
if (!(i === 0 || i === 1 || i === 2 || i === 3)) |
|||
throw new Error('i must be equal to 0, 1, 2, or 3'); |
|||
|
|||
var e = BN().fromBuffer(this.hashbuf); |
|||
var r = this.sig.r; |
|||
var s = this.sig.s; |
|||
|
|||
// A set LSB signifies that the y-coordinate is odd
|
|||
var isYOdd = i & 1; |
|||
|
|||
// The more significant bit specifies whether we should use the
|
|||
// first or second candidate key.
|
|||
var isSecondKey = i >> 1; |
|||
|
|||
var n = Point.getN(); |
|||
var G = Point.getG(); |
|||
|
|||
// 1.1 Let x = r + jn
|
|||
var x = isSecondKey ? r.add(n) : r; |
|||
var R = Point.fromX(isYOdd, x); |
|||
|
|||
// 1.4 Check that nR is at infinity
|
|||
var nR = R.mul(n); |
|||
|
|||
if (!nR.isInfinity()) |
|||
throw new Error('nR is not a valid curve point'); |
|||
|
|||
// Compute -e from e
|
|||
var eNeg = e.neg().mod(n); |
|||
|
|||
// 1.6.1 Compute Q = r^-1 (sR - eG)
|
|||
// Q = r^-1 (sR + -eG)
|
|||
var rInv = r.invm(n); |
|||
|
|||
//var Q = R.multiplyTwo(s, G, eNeg).mul(rInv);
|
|||
var Q = R.mul(s).add(G.mul(eNeg)).mul(rInv); |
|||
|
|||
var pubkey = new Pubkey({point: Q}); |
|||
pubkey.compressed = this.sig.compressed; |
|||
pubkey.validate(); |
|||
|
|||
return pubkey; |
|||
}; |
|||
|
|||
ECDSA.prototype.sigError = function() { |
|||
if (!Buffer.isBuffer(this.hashbuf) || this.hashbuf.length !== 32) |
|||
return 'hashbuf must be a 32 byte buffer'; |
|||
|
|||
try { |
|||
this.keypair.pubkey.validate(); |
|||
} catch (e) { |
|||
return 'Invalid pubkey: ' + e; |
|||
} |
|||
|
|||
var r = this.sig.r; |
|||
var s = this.sig.s; |
|||
if (!(r.gt(0) && r.lt(Point.getN())) |
|||
|| !(s.gt(0) && s.lt(Point.getN()))) |
|||
return 'r and s not in range'; |
|||
|
|||
var e = BN().fromBuffer(this.hashbuf); |
|||
var n = Point.getN(); |
|||
var sinv = s.invm(n); |
|||
var u1 = sinv.mul(e).mod(n); |
|||
var u2 = sinv.mul(r).mod(n); |
|||
|
|||
var p = Point.getG().mulAdd(u1, this.keypair.pubkey.point, u2); |
|||
if (p.isInfinity()) |
|||
return 'p is infinity'; |
|||
|
|||
if (!(p.getX().mod(n).cmp(r) === 0)) |
|||
return 'Invalid signature'; |
|||
else |
|||
return false; |
|||
}; |
|||
|
|||
ECDSA.prototype.sign = function() { |
|||
var hashbuf = this.hashbuf; |
|||
var privkey = this.keypair.privkey; |
|||
var k = this.k; |
|||
var d = privkey.bn; |
|||
|
|||
if (!k) |
|||
throw new Error('You must specify k - perhaps you should run signRandomK instead'); |
|||
|
|||
if (!hashbuf || !privkey || !d) |
|||
throw new Error('invalid parameters'); |
|||
|
|||
if (!Buffer.isBuffer(hashbuf) || hashbuf.length !== 32) |
|||
throw new Error('hashbuf must be a 32 byte buffer'); |
|||
|
|||
var N = Point.getN(); |
|||
var G = Point.getG(); |
|||
var e = BN().fromBuffer(hashbuf); |
|||
|
|||
do { |
|||
var Q = G.mul(k); |
|||
var r = Q.x.mod(N); |
|||
var s = k.invm(N).mul(e.add(d.mul(r))).mod(N); |
|||
} while (r.cmp(0) <= 0 || s.cmp(0) <= 0); |
|||
|
|||
this.sig = new Signature({r: r, s: s, compressed: this.keypair.pubkey.compressed}); |
|||
return this.sig; |
|||
}; |
|||
|
|||
ECDSA.prototype.signRandomK = function() { |
|||
var k = this.randomK(); |
|||
return this.sign(); |
|||
}; |
|||
|
|||
ECDSA.prototype.toString = function() { |
|||
var obj = {}; |
|||
if (this.hashbuf) |
|||
obj.hashbuf = this.hashbuf.toString('hex'); |
|||
if (this.keypair) |
|||
obj.keypair = this.keypair.toString(); |
|||
if (this.sig) |
|||
obj.sig = this.sig.toString(); |
|||
if (this.k) |
|||
obj.k = this.k.toString(); |
|||
return JSON.stringify(obj); |
|||
}; |
|||
|
|||
ECDSA.prototype.verify = function() { |
|||
if (!this.sigError()) |
|||
return true; |
|||
else |
|||
return false; |
|||
}; |
|||
|
|||
ECDSA.sign = function(hashbuf, keypair) { |
|||
return ECDSA().set({ |
|||
hashbuf: hashbuf, |
|||
keypair: keypair |
|||
}).signRandomK(); |
|||
}; |
|||
|
|||
ECDSA.verify = function(hashbuf, sig, pubkey) { |
|||
return ECDSA().set({ |
|||
hashbuf: hashbuf, |
|||
sig: sig, |
|||
keypair: Keypair().set({pubkey: pubkey}) |
|||
}).verify(); |
|||
}; |
|||
|
|||
module.exports = ECDSA; |
|||
@ -0,0 +1,47 @@ |
|||
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; |
|||
@ -0,0 +1,34 @@ |
|||
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; |
|||
@ -0,0 +1,138 @@ |
|||
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; |
|||
@ -0,0 +1,55 @@ |
|||
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; |
|||
@ -0,0 +1,127 @@ |
|||
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; |
|||
@ -0,0 +1,88 @@ |
|||
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; |
|||
@ -0,0 +1,85 @@ |
|||
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; |
|||
@ -0,0 +1,69 @@ |
|||
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; |
|||
@ -0,0 +1,89 @@ |
|||
var hashjs = require('hash.js'); |
|||
var sha512 = require('sha512'); |
|||
|
|||
var Hash = module.exports; |
|||
|
|||
Hash.sha256 = function(buf) { |
|||
if (!Buffer.isBuffer(buf)) |
|||
throw new Error('sha256 hash must be of a buffer'); |
|||
var hash = (new hashjs.sha256()).update(buf).digest(); |
|||
return new Buffer(hash); |
|||
}; |
|||
|
|||
Hash.sha256.blocksize = 512; |
|||
|
|||
Hash.sha256sha256 = function(buf) { |
|||
try { |
|||
return Hash.sha256(Hash.sha256(buf)); |
|||
} catch (e) { |
|||
throw new Error('sha256sha256 hash must be of a buffer'); |
|||
} |
|||
}; |
|||
|
|||
Hash.ripemd160 = function(buf) { |
|||
if (!Buffer.isBuffer(buf)) |
|||
throw new Error('ripemd160 hash must be of a buffer'); |
|||
var hash = (new hashjs.ripemd160()).update(buf).digest(); |
|||
return new Buffer(hash); |
|||
}; |
|||
|
|||
Hash.sha256ripemd160 = function(buf) { |
|||
try { |
|||
return Hash.ripemd160(Hash.sha256(buf)); |
|||
} catch (e) { |
|||
throw new Error('sha256ripemd160 hash must be of a buffer'); |
|||
} |
|||
}; |
|||
|
|||
Hash.sha512 = function(buf) { |
|||
if (!Buffer.isBuffer(buf)) |
|||
throw new Error('sha512 hash must be of a buffer'); |
|||
var hash = sha512(buf); |
|||
return new Buffer(hash); |
|||
}; |
|||
|
|||
Hash.sha512.blocksize = 1024; |
|||
|
|||
Hash.hmac = function(hashf, data, key) { |
|||
if (!Buffer.isBuffer(data) || !Buffer.isBuffer(key)) |
|||
throw new Error('data and key must be buffers'); |
|||
|
|||
//http://en.wikipedia.org/wiki/Hash-based_message_authentication_code
|
|||
//http://tools.ietf.org/html/rfc4868#section-2
|
|||
if (!hashf.blocksize) |
|||
throw new Error('Blocksize for hash function unknown'); |
|||
|
|||
var blocksize = hashf.blocksize/8; |
|||
|
|||
if (key.length > blocksize) |
|||
key = hashf(key); |
|||
else if (key < blocksize) { |
|||
var fill = new Buffer(blocksize); |
|||
fill.fill(0); |
|||
key.copy(fill); |
|||
key = fill; |
|||
} |
|||
|
|||
var o_key = new Buffer(blocksize); |
|||
o_key.fill(0x5c); |
|||
|
|||
var i_key = new Buffer(blocksize); |
|||
i_key.fill(0x36); |
|||
|
|||
var o_key_pad = new Buffer(blocksize); |
|||
var i_key_pad = new Buffer(blocksize); |
|||
for (var i = 0; i < blocksize; i++) { |
|||
o_key_pad[i] = o_key[i] ^ key[i]; |
|||
i_key_pad[i] = i_key[i] ^ key[i]; |
|||
} |
|||
|
|||
return hashf(Buffer.concat([o_key_pad, hashf(Buffer.concat([i_key_pad, data]))])); |
|||
}; |
|||
|
|||
Hash.sha256hmac = function(data, key) { |
|||
return Hash.hmac(Hash.sha256, data, key); |
|||
}; |
|||
|
|||
Hash.sha512hmac = function(data, key) { |
|||
return Hash.hmac(Hash.sha512, data, key); |
|||
}; |
|||
@ -0,0 +1,32 @@ |
|||
var Bn = require('./bn'); |
|||
var Privkey = require('./privkey'); |
|||
var Point = require('./point'); |
|||
var Pubkey = require('./pubkey'); |
|||
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; |
|||
@ -0,0 +1,73 @@ |
|||
var Privkey = require('./privkey'); |
|||
var Pubkey = require('./pubkey'); |
|||
var BN = require('./bn'); |
|||
var point = require('./point'); |
|||
|
|||
var Keypair = function Keypair(obj) { |
|||
if (!(this instanceof Keypair)) |
|||
return new Keypair(obj); |
|||
if (obj) |
|||
this.set(obj); |
|||
}; |
|||
|
|||
Keypair.prototype.set = function(obj) { |
|||
this.privkey = obj.privkey || this.privkey || undefined; |
|||
this.pubkey = obj.pubkey || this.pubkey || undefined; |
|||
return this; |
|||
}; |
|||
|
|||
Keypair.prototype.fromJSON = function(json) { |
|||
if (json.privkey) |
|||
this.set({privkey: Privkey().fromJSON(json.privkey)}); |
|||
if (json.pubkey) |
|||
this.set({pubkey: Pubkey().fromJSON(json.pubkey)}); |
|||
return this; |
|||
}; |
|||
|
|||
Keypair.prototype.toJSON = function() { |
|||
var json = {}; |
|||
if (this.privkey) |
|||
json.privkey = this.privkey.toJSON(); |
|||
if (this.pubkey) |
|||
json.pubkey = this.pubkey.toJSON(); |
|||
return json; |
|||
}; |
|||
|
|||
Keypair.prototype.fromPrivkey = function(privkey) { |
|||
this.privkey = privkey; |
|||
this.privkey2pubkey(); |
|||
return this; |
|||
}; |
|||
|
|||
Keypair.prototype.fromRandom = function() { |
|||
this.privkey = Privkey().fromRandom(); |
|||
this.privkey2pubkey(); |
|||
return this; |
|||
}; |
|||
|
|||
Keypair.prototype.fromString = function(str) { |
|||
var obj = JSON.parse(str); |
|||
if (obj.privkey) { |
|||
this.privkey = new Privkey(); |
|||
this.privkey.fromString(obj.privkey); |
|||
} |
|||
if (obj.pubkey) { |
|||
this.pubkey = new Pubkey(); |
|||
this.pubkey.fromString(obj.pubkey); |
|||
} |
|||
}; |
|||
|
|||
Keypair.prototype.privkey2pubkey = function() { |
|||
this.pubkey = Pubkey().fromPrivkey(this.privkey); |
|||
}; |
|||
|
|||
Keypair.prototype.toString = function() { |
|||
var obj = {}; |
|||
if (this.privkey) |
|||
obj.privkey = this.privkey.toString(); |
|||
if (this.pubkey) |
|||
obj.pubkey = this.pubkey.toString(); |
|||
return JSON.stringify(obj); |
|||
}; |
|||
|
|||
module.exports = Keypair; |
|||
@ -0,0 +1,94 @@ |
|||
var ECDSA = require('./ecdsa'); |
|||
var Keypair = require('./keypair'); |
|||
var Privkey = require('./privkey'); |
|||
var Pubkey = require('./pubkey'); |
|||
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; |
|||
@ -0,0 +1,192 @@ |
|||
function Opcode(num) { |
|||
if (!(this instanceof Opcode)) |
|||
return new Opcode(num); |
|||
|
|||
if (typeof num === 'number') { |
|||
this.num = num; |
|||
} else if (typeof num === 'string') { |
|||
var str = num; |
|||
this.num = Opcode.map[str]; |
|||
} else if (num) { |
|||
var obj = num; |
|||
this.set(obj); |
|||
} |
|||
} |
|||
|
|||
Opcode.prototype.set = function(obj) { |
|||
this.num = typeof obj.num !== 'undefined' ? obj.num : this.num; |
|||
return this; |
|||
}; |
|||
|
|||
Opcode.prototype.fromNumber = function(num) { |
|||
this.num = num; |
|||
return this; |
|||
}; |
|||
|
|||
Opcode.prototype.toNumber = function() { |
|||
return this.num; |
|||
}; |
|||
|
|||
Opcode.prototype.fromString = function(str) { |
|||
var num = Opcode.map[str]; |
|||
if (typeof num === 'undefined') |
|||
throw new Error('Invalid opcodestr'); |
|||
this.num = num; |
|||
return this; |
|||
}; |
|||
|
|||
Opcode.prototype.toString = function() { |
|||
var str = Opcode.reverseMap[this.num]; |
|||
if (typeof str === 'undefined') |
|||
throw new Error('Opcode does not have a string representation'); |
|||
return str; |
|||
}; |
|||
|
|||
Opcode.map = { |
|||
// push value
|
|||
OP_FALSE: 0, |
|||
OP_0: 0, |
|||
OP_PUSHDATA1: 76, |
|||
OP_PUSHDATA2: 77, |
|||
OP_PUSHDATA4: 78, |
|||
OP_1NEGATE: 79, |
|||
OP_RESERVED: 80, |
|||
OP_TRUE: 81, |
|||
OP_1: 81, |
|||
OP_2: 82, |
|||
OP_3: 83, |
|||
OP_4: 84, |
|||
OP_5: 85, |
|||
OP_6: 86, |
|||
OP_7: 87, |
|||
OP_8: 88, |
|||
OP_9: 89, |
|||
OP_10: 90, |
|||
OP_11: 91, |
|||
OP_12: 92, |
|||
OP_13: 93, |
|||
OP_14: 94, |
|||
OP_15: 95, |
|||
OP_16: 96, |
|||
|
|||
// control
|
|||
OP_NOP: 97, |
|||
OP_VER: 98, |
|||
OP_IF: 99, |
|||
OP_NOTIF: 100, |
|||
OP_VERIF: 101, |
|||
OP_VERNOTIF: 102, |
|||
OP_ELSE: 103, |
|||
OP_ENDIF: 104, |
|||
OP_VERIFY: 105, |
|||
OP_RETURN: 106, |
|||
|
|||
// stack ops
|
|||
OP_TOALTSTACK: 107, |
|||
OP_FROMALTSTACK: 108, |
|||
OP_2DROP: 109, |
|||
OP_2DUP: 110, |
|||
OP_3DUP: 111, |
|||
OP_2OVER: 112, |
|||
OP_2ROT: 113, |
|||
OP_2SWAP: 114, |
|||
OP_IFDUP: 115, |
|||
OP_DEPTH: 116, |
|||
OP_DROP: 117, |
|||
OP_DUP: 118, |
|||
OP_NIP: 119, |
|||
OP_OVER: 120, |
|||
OP_PICK: 121, |
|||
OP_ROLL: 122, |
|||
OP_ROT: 123, |
|||
OP_SWAP: 124, |
|||
OP_TUCK: 125, |
|||
|
|||
// splice ops
|
|||
OP_CAT: 126, |
|||
OP_SUBSTR: 127, |
|||
OP_LEFT: 128, |
|||
OP_RIGHT: 129, |
|||
OP_SIZE: 130, |
|||
|
|||
// bit logic
|
|||
OP_INVERT: 131, |
|||
OP_AND: 132, |
|||
OP_OR: 133, |
|||
OP_XOR: 134, |
|||
OP_EQUAL: 135, |
|||
OP_EQUALVERIFY: 136, |
|||
OP_RESERVED1: 137, |
|||
OP_RESERVED2: 138, |
|||
|
|||
// numeric
|
|||
OP_1ADD: 139, |
|||
OP_1SUB: 140, |
|||
OP_2MUL: 141, |
|||
OP_2DIV: 142, |
|||
OP_NEGATE: 143, |
|||
OP_ABS: 144, |
|||
OP_NOT: 145, |
|||
OP_0NOTEQUAL: 146, |
|||
|
|||
OP_ADD: 147, |
|||
OP_SUB: 148, |
|||
OP_MUL: 149, |
|||
OP_DIV: 150, |
|||
OP_MOD: 151, |
|||
OP_LSHIFT: 152, |
|||
OP_RSHIFT: 153, |
|||
|
|||
OP_BOOLAND: 154, |
|||
OP_BOOLOR: 155, |
|||
OP_NUMEQUAL: 156, |
|||
OP_NUMEQUALVERIFY: 157, |
|||
OP_NUMNOTEQUAL: 158, |
|||
OP_LESSTHAN: 159, |
|||
OP_GREATERTHAN: 160, |
|||
OP_LESSTHANOREQUAL: 161, |
|||
OP_GREATERTHANOREQUAL: 162, |
|||
OP_MIN: 163, |
|||
OP_MAX: 164, |
|||
|
|||
OP_WITHIN: 165, |
|||
|
|||
// crypto
|
|||
OP_RIPEMD160: 166, |
|||
OP_SHA1: 167, |
|||
OP_SHA256: 168, |
|||
OP_HASH160: 169, |
|||
OP_HASH256: 170, |
|||
OP_CODESEPARATOR: 171, |
|||
OP_CHECKSIG: 172, |
|||
OP_CHECKSIGVERIFY: 173, |
|||
OP_CHECKMULTISIG: 174, |
|||
OP_CHECKMULTISIGVERIFY: 175, |
|||
|
|||
// expansion
|
|||
OP_NOP1: 176, |
|||
OP_NOP2: 177, |
|||
OP_NOP3: 178, |
|||
OP_NOP4: 179, |
|||
OP_NOP5: 180, |
|||
OP_NOP6: 181, |
|||
OP_NOP7: 182, |
|||
OP_NOP8: 183, |
|||
OP_NOP9: 184, |
|||
OP_NOP10: 185, |
|||
|
|||
// template matching params
|
|||
OP_PUBKEYHASH: 253, |
|||
OP_PUBKEY: 254, |
|||
OP_INVALIDOPCODE: 255 |
|||
}; |
|||
|
|||
Opcode.reverseMap = []; |
|||
|
|||
for (var k in Opcode.map) { |
|||
if (Opcode.map.hasOwnProperty(k)) { |
|||
Opcode.reverseMap[Opcode.map[k]] = k; |
|||
} |
|||
} |
|||
|
|||
module.exports = Opcode; |
|||
@ -0,0 +1,50 @@ |
|||
var BN = require('./bn'); |
|||
var elliptic = require('elliptic'); |
|||
|
|||
var ec = elliptic.curves.secp256k1; |
|||
var ecpoint = ec.curve.point.bind(ec.curve) |
|||
var p = ec.curve.point(); |
|||
var Curve = Object.getPrototypeOf(ec.curve); |
|||
|
|||
var Point = function Point(x, y, isRed) { |
|||
return ecpoint(x, y, isRed); |
|||
}; |
|||
|
|||
Point.prototype = Object.getPrototypeOf(p); |
|||
|
|||
Point.fromX = ec.curve.pointFromX.bind(ec.curve); |
|||
|
|||
Point.getG = function() { |
|||
var p = Point(ec.curve.g.getX(), ec.curve.g.getY()); |
|||
return p; |
|||
}; |
|||
|
|||
Point.getN = function() { |
|||
return BN(ec.curve.n.toArray()); |
|||
}; |
|||
|
|||
Point.prototype._getX = Point.prototype.getX; |
|||
Point.prototype.getX = function() { |
|||
var n = BN(this._getX().toArray()); |
|||
return BN(this._getX().toArray()); |
|||
}; |
|||
|
|||
Point.prototype._getY = Point.prototype.getY; |
|||
Point.prototype.getY = function() { |
|||
return BN(this._getY().toArray()); |
|||
}; |
|||
|
|||
//https://www.iacr.org/archive/pkc2003/25670211/25670211.pdf
|
|||
Point.prototype.validate = function() { |
|||
var p2 = Point.fromX(this.getY().isOdd(), this.getX()); |
|||
if (!(p2.y.cmp(this.y) === 0)) |
|||
throw new Error('Invalid y value of public key'); |
|||
if (!(this.getX().gt(-1) && this.getX().lt(Point.getN())) |
|||
||!(this.getY().gt(-1) && this.getY().lt(Point.getN()))) |
|||
throw new Error('Point does not lie on the curve'); |
|||
if (!(this.mul(Point.getN()).isInfinity())) |
|||
throw new Error('Point times N must be infinity'); |
|||
return this; |
|||
}; |
|||
|
|||
module.exports = Point; |
|||
@ -0,0 +1,104 @@ |
|||
var BN = require('./bn'); |
|||
var Point = require('./point'); |
|||
var constants = require('./constants'); |
|||
var base58check = require('./base58check'); |
|||
var Random = require('./random'); |
|||
|
|||
var Privkey = function Privkey(bn) { |
|||
if (!(this instanceof Privkey)) |
|||
return new Privkey(bn); |
|||
if (bn instanceof BN) |
|||
this.bn = bn; |
|||
else if (bn) { |
|||
var obj = bn; |
|||
this.set(obj); |
|||
} |
|||
}; |
|||
|
|||
Privkey.prototype.set = function(obj) { |
|||
this.bn = obj.bn || this.bn; |
|||
this.networkstr = obj.networkstr || this.networkstr; |
|||
this.compressed = typeof obj.compressed !== 'undefined' ? obj.compressed : this.compressed; |
|||
return this; |
|||
}; |
|||
|
|||
Privkey.prototype.fromJSON = function(json) { |
|||
this.fromString(json); |
|||
return this; |
|||
}; |
|||
|
|||
Privkey.prototype.toJSON = function() { |
|||
return this.toString(); |
|||
}; |
|||
|
|||
Privkey.prototype.fromRandom = function() { |
|||
do { |
|||
var privbuf = Random.getRandomBuffer(32); |
|||
var bn = BN().fromBuffer(privbuf); |
|||
var condition = bn.lt(Point.getN()); |
|||
} while (!condition); |
|||
this.set({ |
|||
bn: bn, |
|||
networkstr: 'mainnet', |
|||
compressed: true |
|||
}); |
|||
return this; |
|||
}; |
|||
|
|||
Privkey.prototype.validate = function() { |
|||
if (!this.bn.lt(Point.getN())) |
|||
throw new Error('Number must be less than N'); |
|||
if (typeof constants[this.networkstr] === undefined) |
|||
throw new Error('Must specify the networkstr ("mainnet" or "testnet")'); |
|||
if (typeof this.compressed !== 'boolean') |
|||
throw new Error('Must specify whether the corresponding public key is compressed or not (true or false)'); |
|||
}; |
|||
|
|||
Privkey.prototype.toWIF = function() { |
|||
var networkstr = this.networkstr; |
|||
var compressed = this.compressed; |
|||
|
|||
if (typeof this.networkstr === 'undefined') |
|||
networkstr = 'mainnet'; |
|||
if (typeof this.compressed === 'undefined') |
|||
compressed = true; |
|||
|
|||
var privbuf = this.bn.toBuffer({size: 32}); |
|||
var buf; |
|||
if (compressed) |
|||
buf = Buffer.concat([new Buffer([constants[networkstr].privkey]), this.bn.toBuffer({size: 32}), new Buffer([0x01])]); |
|||
else |
|||
buf = Buffer.concat([new Buffer([constants[networkstr].privkey]), this.bn.toBuffer({size: 32})]); |
|||
|
|||
return base58check.encode(buf); |
|||
}; |
|||
|
|||
Privkey.prototype.fromWIF = function(str) { |
|||
var buf = base58check.decode(str); |
|||
|
|||
if (buf.length === 1 + 32 + 1 && buf[1 + 32 + 1 - 1] == 1) |
|||
this.compressed = true; |
|||
else if (buf.length === 1 + 32) |
|||
this.compressed = false; |
|||
else |
|||
throw new Error('Length of buffer must be 33 (uncompressed) or 34 (compressed)'); |
|||
|
|||
if (buf[0] === constants.mainnet.privkey) |
|||
this.networkstr = 'mainnet'; |
|||
else if (buf[0] === constants.testnet.privkey) |
|||
this.networkstr = 'testnet'; |
|||
else |
|||
throw new Error('Invalid networkstr'); |
|||
|
|||
this.bn = BN.fromBuffer(buf.slice(1, 32 + 1)); |
|||
}; |
|||
|
|||
Privkey.prototype.toString = function() { |
|||
return this.toWIF(); |
|||
}; |
|||
|
|||
Privkey.prototype.fromString = function(str) { |
|||
this.fromWIF(str); |
|||
}; |
|||
|
|||
module.exports = Privkey; |
|||
@ -0,0 +1,125 @@ |
|||
var Point = require('./point'); |
|||
var bn = require('./bn'); |
|||
var privkey = require('./privkey'); |
|||
|
|||
var Pubkey = function Pubkey(point) { |
|||
if (!(this instanceof Pubkey)) |
|||
return new Pubkey(point); |
|||
if (point instanceof Point) |
|||
this.point = point; |
|||
else if (point) { |
|||
var obj = point; |
|||
this.set(obj); |
|||
} |
|||
}; |
|||
|
|||
Pubkey.prototype.set = function(obj) { |
|||
if (obj.point && !obj.point.getX() && !obj.point.getY()) |
|||
throw new Error('Invalid point'); |
|||
this.point = obj.point || this.point; |
|||
this.compressed = typeof obj.compressed !== 'undefined' ? obj.compressed : this.compressed; |
|||
return this; |
|||
}; |
|||
|
|||
Pubkey.prototype.fromJSON = function(json) { |
|||
this.fromBuffer(new Buffer(json, 'hex')); |
|||
return this; |
|||
}; |
|||
|
|||
Pubkey.prototype.toJSON = function() { |
|||
return this.toBuffer().toString('hex'); |
|||
}; |
|||
|
|||
Pubkey.prototype.fromPrivkey = function(privkey) { |
|||
this.set({ |
|||
point: Point.getG().mul(privkey.bn), |
|||
compressed: privkey.compressed} |
|||
); |
|||
return this; |
|||
}; |
|||
|
|||
Pubkey.prototype.fromBuffer = function(buf) { |
|||
return this.fromDER(buf); |
|||
}; |
|||
|
|||
Pubkey.prototype.fromDER = function(buf) { |
|||
if (buf[0] == 0x04) { |
|||
var xbuf = buf.slice(1, 33); |
|||
var ybuf = buf.slice(33, 65); |
|||
if (xbuf.length !== 32 || ybuf.length !== 32 || buf.length !== 65) |
|||
throw new Error('Length of x and y must be 32 bytes'); |
|||
var x = bn(xbuf); |
|||
var y = bn(ybuf); |
|||
this.point = Point(x, y); |
|||
this.compressed = false; |
|||
} else if (buf[0] == 0x03) { |
|||
var xbuf = buf.slice(1); |
|||
var x = bn(xbuf); |
|||
this.fromX(true, x); |
|||
this.compressed = true; |
|||
} else if (buf[0] == 0x02) { |
|||
var xbuf = buf.slice(1); |
|||
var x = bn(xbuf); |
|||
this.fromX(false, x); |
|||
this.compressed = true; |
|||
} else { |
|||
throw new Error('Invalid DER format pubkey'); |
|||
} |
|||
return this; |
|||
}; |
|||
|
|||
Pubkey.prototype.fromString = function(str) { |
|||
this.fromDER(new Buffer(str, 'hex')); |
|||
}; |
|||
|
|||
Pubkey.prototype.fromX = function(odd, x) { |
|||
if (typeof odd !== 'boolean') |
|||
throw new Error('Must specify whether y is odd or not (true or false)'); |
|||
this.point = Point.fromX(odd, x); |
|||
}; |
|||
|
|||
Pubkey.prototype.toBuffer = function() { |
|||
var compressed = typeof this.compressed === 'undefined' ? true : this.compressed; |
|||
return this.toDER(compressed); |
|||
}; |
|||
|
|||
Pubkey.prototype.toDER = function(compressed) { |
|||
compressed = typeof this.compressed === 'undefined' ? compressed : this.compressed; |
|||
if (typeof compressed !== 'boolean') |
|||
throw new Error('Must specify whether the public key is compressed or not (true or false)'); |
|||
|
|||
var x = this.point.getX(); |
|||
var y = this.point.getY(); |
|||
|
|||
var xbuf = x.toBuffer({size: 32}); |
|||
var ybuf = y.toBuffer({size: 32}); |
|||
|
|||
if (!compressed) { |
|||
var prefix = new Buffer([0x04]); |
|||
return Buffer.concat([prefix, xbuf, ybuf]); |
|||
} else { |
|||
var odd = ybuf[ybuf.length - 1] % 2; |
|||
if (odd) |
|||
var prefix = new Buffer([0x03]); |
|||
else |
|||
var prefix = new Buffer([0x02]); |
|||
return Buffer.concat([prefix, xbuf]); |
|||
} |
|||
}; |
|||
|
|||
Pubkey.prototype.toString = function() { |
|||
var compressed = typeof this.compressed === 'undefined' ? true : this.compressed; |
|||
return this.toDER(compressed).toString('hex'); |
|||
}; |
|||
|
|||
//https://www.iacr.org/archive/pkc2003/25670211/25670211.pdf
|
|||
Pubkey.prototype.validate = function() { |
|||
if (this.point.isInfinity()) |
|||
throw new Error('point: Point cannot be equal to Infinity'); |
|||
if (this.point.eq(Point(bn(0), bn(0)))) |
|||
throw new Error('point: Point cannot be equal to 0, 0'); |
|||
this.point.validate(); |
|||
return this; |
|||
}; |
|||
|
|||
module.exports = Pubkey; |
|||
@ -0,0 +1,54 @@ |
|||
function Random() { |
|||
}; |
|||
|
|||
/* secure random bytes that sometimes throws an error due to lack of entropy */ |
|||
Random.getRandomBuffer = function(size) { |
|||
if (process.browser) |
|||
return Random.getRandomBufferBrowser(size); |
|||
else |
|||
return Random.getRandomBufferNode(size); |
|||
}; |
|||
|
|||
Random.getRandomBufferNode = function(size) { |
|||
var crypto = require('crypto'); |
|||
return crypto.randomBytes(size); |
|||
} |
|||
|
|||
Random.getRandomBufferBrowser = function(size) { |
|||
if (!window.crypto && !window.msCrypto) |
|||
throw new Error('window.crypto not available'); |
|||
|
|||
if (window.crypto && window.crypto.getRandomValues) |
|||
var crypto = window.crypto; |
|||
else if (window.msCrypto && window.msCrypto.getRandomValues) //internet explorer
|
|||
var crypto = window.msCrypto; |
|||
else |
|||
throw new Error('window.crypto.getRandomValues not available'); |
|||
|
|||
var bbuf = new Uint8Array(size); |
|||
crypto.getRandomValues(bbuf); |
|||
var buf = new Buffer(bbuf); |
|||
|
|||
return buf; |
|||
}; |
|||
|
|||
/* insecure random bytes, but it never fails */ |
|||
Random.getPseudoRandomBuffer = function(size) { |
|||
var b32 = 0x100000000; |
|||
var b = new Buffer(size); |
|||
|
|||
for (var i = 0; i <= size; i++) { |
|||
var j = Math.floor(i / 4); |
|||
var k = i - j * 4; |
|||
if (k == 0) { |
|||
r = Math.random() * b32; |
|||
b[i] = r & 0xff; |
|||
} else { |
|||
b[i] = (r = r >>> 8) & 0xff; |
|||
} |
|||
} |
|||
|
|||
return b; |
|||
}; |
|||
|
|||
module.exports = Random; |
|||
@ -0,0 +1,281 @@ |
|||
var BufferReader = require('./bufferreader'); |
|||
var BufferWriter = require('./bufferwriter'); |
|||
var Opcode = require('./opcode'); |
|||
|
|||
var Script = function Script(buf) { |
|||
if (!(this instanceof Script)) |
|||
return new Script(buf); |
|||
|
|||
this.chunks = []; |
|||
|
|||
if (Buffer.isBuffer(buf)) { |
|||
this.fromBuffer(buf); |
|||
} |
|||
else if (typeof buf === 'string') { |
|||
var str = buf; |
|||
this.fromString(str); |
|||
} |
|||
else if (typeof buf !== 'undefined') { |
|||
var obj = buf; |
|||
this.set(obj); |
|||
} |
|||
}; |
|||
|
|||
Script.prototype.set = function(obj) { |
|||
this.chunks = obj.chunks || this.chunks; |
|||
return this; |
|||
}; |
|||
|
|||
Script.prototype.fromJSON = function(json) { |
|||
return this.fromString(json); |
|||
}; |
|||
|
|||
Script.prototype.toJSON = function() { |
|||
return this.toString(); |
|||
}; |
|||
|
|||
Script.prototype.fromBuffer = function(buf) { |
|||
this.chunks = []; |
|||
|
|||
var br = new BufferReader(buf); |
|||
while (!br.eof()) { |
|||
var opcodenum = br.readUInt8(); |
|||
|
|||
var len, buf; |
|||
if (opcodenum > 0 && opcodenum < Opcode.map.OP_PUSHDATA1) { |
|||
len = opcodenum; |
|||
this.chunks.push({ |
|||
buf: br.read(len), |
|||
len: len, |
|||
opcodenum: opcodenum |
|||
}); |
|||
} else if (opcodenum === Opcode.map.OP_PUSHDATA1) { |
|||
len = br.readUInt8(); |
|||
var buf = br.read(len); |
|||
this.chunks.push({ |
|||
buf: buf, |
|||
len: len, |
|||
opcodenum: opcodenum |
|||
}); |
|||
} else if (opcodenum === Opcode.map.OP_PUSHDATA2) { |
|||
len = br.readUInt16LE(); |
|||
buf = br.read(len); |
|||
this.chunks.push({ |
|||
buf: buf, |
|||
len: len, |
|||
opcodenum: opcodenum |
|||
}); |
|||
} else if (opcodenum === Opcode.map.OP_PUSHDATA4) { |
|||
len = br.readUInt32LE(); |
|||
buf = br.read(len); |
|||
this.chunks.push({ |
|||
buf: buf, |
|||
len: len, |
|||
opcodenum: opcodenum |
|||
}); |
|||
} else { |
|||
this.chunks.push(opcodenum); |
|||
} |
|||
} |
|||
|
|||
return this; |
|||
}; |
|||
|
|||
Script.prototype.toBuffer = function() { |
|||
var bw = new BufferWriter(); |
|||
|
|||
for (var i = 0; i < this.chunks.length; i++) { |
|||
var chunk = this.chunks[i]; |
|||
if (typeof chunk === 'number') { |
|||
var opcodenum = chunk; |
|||
bw.writeUInt8(opcodenum); |
|||
} else { |
|||
var opcodenum = chunk.opcodenum; |
|||
bw.writeUInt8(chunk.opcodenum); |
|||
if (opcodenum < Opcode.map.OP_PUSHDATA1) { |
|||
bw.write(chunk.buf); |
|||
} |
|||
else if (opcodenum === Opcode.map.OP_PUSHDATA1) { |
|||
bw.writeUInt8(chunk.len); |
|||
bw.write(chunk.buf); |
|||
} |
|||
else if (opcodenum === Opcode.map.OP_PUSHDATA2) { |
|||
bw.writeUInt16LE(chunk.len); |
|||
bw.write(chunk.buf); |
|||
} |
|||
else if (opcodenum === Opcode.map.OP_PUSHDATA4) { |
|||
bw.writeUInt32LE(chunk.len); |
|||
bw.write(chunk.buf); |
|||
} |
|||
} |
|||
} |
|||
|
|||
return bw.concat(); |
|||
}; |
|||
|
|||
Script.prototype.fromString = function(str) { |
|||
this.chunks = []; |
|||
|
|||
var tokens = str.split(' '); |
|||
var i = 0; |
|||
while (i < tokens.length) { |
|||
var token = tokens[i]; |
|||
var opcode = Opcode(token); |
|||
var opcodenum = opcode.toNumber(); |
|||
|
|||
if (typeof opcodenum === 'undefined') { |
|||
opcodenum = parseInt(token); |
|||
if (opcodenum > 0 && opcodenum < Opcode.map.OP_PUSHDATA1) { |
|||
this.chunks.push({ |
|||
buf: new Buffer(tokens[i + 1].slice(2), 'hex'), |
|||
len: opcodenum, |
|||
opcodenum: opcodenum |
|||
}); |
|||
i = i + 2; |
|||
} |
|||
else { |
|||
throw new Error('Invalid script'); |
|||
} |
|||
} else if (opcodenum === Opcode.map.OP_PUSHDATA1 || opcodenum === Opcode.map.OP_PUSHDATA2 || opcodenum === Opcode.map.OP_PUSHDATA4) { |
|||
if (tokens[i + 2].slice(0, 2) != '0x') |
|||
throw new Error('Pushdata data must start with 0x'); |
|||
this.chunks.push({ |
|||
buf: new Buffer(tokens[i + 2].slice(2), 'hex'), |
|||
len: parseInt(tokens[i + 1]), |
|||
opcodenum: opcodenum |
|||
}); |
|||
i = i + 3; |
|||
} else { |
|||
this.chunks.push(opcodenum); |
|||
i = i + 1; |
|||
} |
|||
} |
|||
return this; |
|||
}; |
|||
|
|||
Script.prototype.toString = function() { |
|||
var str = ""; |
|||
|
|||
for (var i = 0; i < this.chunks.length; i++) { |
|||
var chunk = this.chunks[i]; |
|||
if (typeof chunk === 'number') { |
|||
var opcodenum = chunk; |
|||
str = str + Opcode(opcodenum).toString() + " "; |
|||
} else { |
|||
var opcodenum = chunk.opcodenum; |
|||
if (opcodenum === Opcode.map.OP_PUSHDATA1 || opcodenum === Opcode.map.OP_PUSHDATA2 || opcodenum === Opcode.map.OP_PUSHDATA4) |
|||
str = str + Opcode(opcodenum).toString() + " " ; |
|||
str = str + chunk.len + " " ; |
|||
str = str + "0x" + chunk.buf.toString('hex') + " "; |
|||
} |
|||
} |
|||
|
|||
return str.substr(0, str.length - 1); |
|||
}; |
|||
|
|||
Script.prototype.isOpReturn = function() { |
|||
if (this.chunks[0] === Opcode('OP_RETURN').toNumber() |
|||
&& |
|||
(this.chunks.length === 1 |
|||
|| |
|||
(this.chunks.length === 2 |
|||
&& this.chunks[1].buf |
|||
&& this.chunks[1].buf.length <= 40 |
|||
&& this.chunks[1].length === this.chunks.len))) { |
|||
return true; |
|||
} else { |
|||
return false; |
|||
} |
|||
}; |
|||
|
|||
Script.prototype.isPubkeyhashOut = function() { |
|||
if (this.chunks[0] === Opcode('OP_DUP').toNumber() |
|||
&& this.chunks[1] === Opcode('OP_HASH160').toNumber() |
|||
&& this.chunks[2].buf |
|||
&& this.chunks[3] === Opcode('OP_EQUALVERIFY').toNumber() |
|||
&& this.chunks[4] === Opcode('OP_CHECKSIG').toNumber()) { |
|||
return true; |
|||
} else { |
|||
return false; |
|||
} |
|||
}; |
|||
|
|||
Script.prototype.isPubkeyhashIn = function() { |
|||
if (this.chunks.length === 2 |
|||
&& this.chunks[0].buf |
|||
&& this.chunks[1].buf) { |
|||
return true; |
|||
} else { |
|||
return false; |
|||
} |
|||
}; |
|||
|
|||
Script.prototype.isScripthashOut = function() { |
|||
if (this.chunks.length === 3 |
|||
&& this.chunks[0] === Opcode('OP_HASH160').toNumber() |
|||
&& this.chunks[1].buf |
|||
&& this.chunks[1].buf.length === 20 |
|||
&& this.chunks[2] === Opcode('OP_EQUAL').toNumber()) { |
|||
return true; |
|||
} else { |
|||
return false; |
|||
} |
|||
}; |
|||
|
|||
//note that these are frequently indistinguishable from pubkeyhashin
|
|||
Script.prototype.isScripthashIn = function() { |
|||
var allpush = this.chunks.every(function(chunk) { |
|||
return Buffer.isBuffer(chunk.buf); |
|||
}); |
|||
if (allpush) { |
|||
return true; |
|||
} else { |
|||
return false; |
|||
} |
|||
}; |
|||
|
|||
Script.prototype.write = function(obj) { |
|||
if (typeof obj === 'string') |
|||
this.writeOp(obj); |
|||
else if (typeof obj === 'number') |
|||
this.writeOp(obj); |
|||
else if (Buffer.isBuffer(obj)) |
|||
this.writeBuffer(obj); |
|||
else if (typeof obj === 'object') |
|||
this.chunks.push(obj); |
|||
else |
|||
throw new Error('Invalid script chunk'); |
|||
return this; |
|||
}; |
|||
|
|||
Script.prototype.writeOp = function(str) { |
|||
if (typeof str === 'number') |
|||
this.chunks.push(str); |
|||
else |
|||
this.chunks.push(Opcode(str).toNumber()); |
|||
return this; |
|||
}; |
|||
|
|||
Script.prototype.writeBuffer = function(buf) { |
|||
var opcodenum; |
|||
var len = buf.length; |
|||
if (buf.length > 0 && buf.length < Opcode.map.OP_PUSHDATA1) { |
|||
opcodenum = buf.length; |
|||
} else if (buf.length < Math.pow(2, 8)) { |
|||
opcodenum = Opcode.map.OP_PUSHDATA1; |
|||
} else if (buf.length < Math.pow(2, 16)) { |
|||
opcodenum = Opcode.map.OP_PUSHDATA2; |
|||
} else if (buf.length < Math.pow(2, 32)) { |
|||
opcodenum = Opcode.map.OP_PUSHDATA4; |
|||
} else { |
|||
throw new Error("You can't push that much data"); |
|||
} |
|||
this.chunks.push({ |
|||
buf: buf, |
|||
len: len, |
|||
opcodenum: opcodenum |
|||
}); |
|||
return this; |
|||
}; |
|||
|
|||
module.exports = Script; |
|||
@ -0,0 +1,169 @@ |
|||
var BN = require('./bn'); |
|||
var Point = require('./point'); |
|||
var Pubkey = require('./pubkey'); |
|||
|
|||
var Signature = function Signature(r, s) { |
|||
if (!(this instanceof Signature)) |
|||
return new Signature(r, s); |
|||
if (r instanceof BN) { |
|||
this.set({ |
|||
r: r, |
|||
s: s |
|||
}); |
|||
} |
|||
else if (r) { |
|||
var obj = r; |
|||
this.set(obj); |
|||
} |
|||
}; |
|||
|
|||
Signature.prototype.set = function(obj) { |
|||
this.r = obj.r || this.r || undefined; |
|||
this.s = obj.s || this.s || undefined; |
|||
this.i = typeof obj.i !== 'undefined' ? obj.i : this.i; //public key recovery parameter in range [0, 3]
|
|||
this.compressed = typeof obj.compressed !== 'undefined' ? obj.compressed : this.compressed; //whether the recovered pubkey is compressed
|
|||
return this; |
|||
}; |
|||
|
|||
Signature.prototype.fromCompact = function(buf) { |
|||
var compressed = true; |
|||
if (i < 0) { |
|||
var 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); |
|||
|
|||
if (!(i === 0 || i === 1 || i === 2 || i === 3)) |
|||
throw new Error('i must be 0, 1, 2, or 3'); |
|||
if (b2.length !== 32) |
|||
throw new Error('r must be 32 bytes'); |
|||
if (b3.length !== 32) |
|||
throw new Error('s must be 32 bytes'); |
|||
|
|||
this.compressed = compressed; |
|||
this.i = i; |
|||
this.r = BN().fromBuffer(b2); |
|||
this.s = BN().fromBuffer(b3); |
|||
|
|||
return this; |
|||
}; |
|||
|
|||
Signature.prototype.fromDER = function(buf) { |
|||
var obj = Signature.parseDER(buf); |
|||
this.r = obj.r; |
|||
this.s = obj.s; |
|||
|
|||
return this; |
|||
}; |
|||
|
|||
Signature.prototype.fromString = function(str) { |
|||
var buf = new Buffer(str, 'hex'); |
|||
this.fromDER(buf); |
|||
|
|||
return this; |
|||
}; |
|||
|
|||
Signature.parseDER = function(buf) { |
|||
if (!Buffer.isBuffer(buf)) |
|||
throw new Error('DER formatted signature should be a buffer'); |
|||
|
|||
var header = buf[0]; |
|||
|
|||
if (header !== 0x30) |
|||
throw new Error('Header byte should be 0x30'); |
|||
|
|||
var length = buf[1]; |
|||
if (length !== buf.slice(2).length) |
|||
throw new Error('Length byte should length of what follows'); |
|||
|
|||
var rheader = buf[2 + 0]; |
|||
if (rheader !== 0x02) |
|||
throw new Error('Integer byte for r should be 0x02'); |
|||
|
|||
var rlength = buf[2 + 1]; |
|||
var rbuf = buf.slice(2 + 2, 2 + 2 + rlength); |
|||
var r = BN().fromBuffer(rbuf); |
|||
var rneg = buf[2 + 1 + 1] === 0x00 ? true : false; |
|||
if (rlength !== rbuf.length) |
|||
throw new Error('Length of r incorrect'); |
|||
|
|||
var sheader = buf[2 + 2 + rlength + 0]; |
|||
if (sheader !== 0x02) |
|||
throw new Error('Integer byte for s should be 0x02'); |
|||
|
|||
var slength = buf[2 + 2 + rlength + 1]; |
|||
var sbuf = buf.slice(2 + 2 + rlength + 2, 2 + 2 + rlength + 2 + slength); |
|||
var s = BN().fromBuffer(sbuf); |
|||
var sneg = buf[2 + 2 + rlength + 2 + 2] === 0x00 ? true : false; |
|||
if (slength !== sbuf.length) |
|||
throw new Error('Length of s incorrect'); |
|||
|
|||
var sumlength = 2 + 2 + rlength + 2 + slength; |
|||
if (length !== sumlength - 2) |
|||
throw new Error('Length of signature incorrect'); |
|||
|
|||
var obj = { |
|||
header: header, |
|||
length: length, |
|||
rheader: rheader, |
|||
rlength: rlength, |
|||
rneg: rneg, |
|||
rbuf: rbuf, |
|||
r: r, |
|||
sheader: sheader, |
|||
slength: slength, |
|||
sneg: sneg, |
|||
sbuf: sbuf, |
|||
s: s |
|||
}; |
|||
|
|||
return obj; |
|||
}; |
|||
|
|||
Signature.prototype.toCompact = function(i, compressed) { |
|||
i = typeof i === 'number' ? i : this.i; |
|||
compressed = typeof compressed === 'boolean' ? compressed : this.compressed; |
|||
|
|||
if (!(i === 0 || i === 1 || i === 2 || i === 3)) |
|||
throw new Error('i must be equal to 0, 1, 2, or 3'); |
|||
|
|||
var val = i + 27 + 4; |
|||
if (compressed === false) |
|||
val = val - 4; |
|||
var b1 = new Buffer([val]); |
|||
var b2 = this.r.toBuffer({size: 32}); |
|||
var b3 = this.s.toBuffer({size: 32}); |
|||
return Buffer.concat([b1, b2, b3]); |
|||
}; |
|||
|
|||
Signature.prototype.toDER = function() { |
|||
var rnbuf = this.r.toBuffer(); |
|||
var snbuf = this.s.toBuffer(); |
|||
|
|||
var rneg = rnbuf[0] & 0x80 ? true : false; |
|||
var sneg = snbuf[0] & 0x80 ? true : false; |
|||
|
|||
var rbuf = rneg ? Buffer.concat([new Buffer([0x00]), rnbuf]) : rnbuf; |
|||
var sbuf = sneg ? Buffer.concat([new Buffer([0x00]), snbuf]) : snbuf; |
|||
|
|||
var length = 2 + rbuf.length + 2 + sbuf.length; |
|||
var rlength = rbuf.length; |
|||
var slength = sbuf.length; |
|||
var rheader = 0x02; |
|||
var sheader = 0x02; |
|||
var header = 0x30; |
|||
|
|||
var der = Buffer.concat([new Buffer([header, length, rheader, rlength]), rbuf, new Buffer([sheader, slength]), sbuf]); |
|||
return der; |
|||
}; |
|||
|
|||
Signature.prototype.toString = function() { |
|||
var buf = this.toDER(); |
|||
return buf.toString('hex'); |
|||
}; |
|||
|
|||
module.exports = Signature; |
|||
@ -0,0 +1,155 @@ |
|||
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)) |
|||
return new Transaction(version, txinsvi, txins, txoutsvi, txouts, nlocktime); |
|||
if (typeof version === 'number') { |
|||
this.initialize(); |
|||
this.set({ |
|||
version: version, |
|||
txinsvi: txinsvi, |
|||
txins: txins, |
|||
txoutsvi: txoutsvi, |
|||
txouts: txouts, |
|||
nlocktime: nlocktime |
|||
}); |
|||
} else if (Buffer.isBuffer(version)) { |
|||
//not necessary to initialize, since everything should be overwritten
|
|||
var txbuf = version; |
|||
this.fromBuffer(txbuf); |
|||
} else if (version) { |
|||
this.initialize(); |
|||
var obj = version; |
|||
this.set(obj); |
|||
} else { |
|||
this.initialize(); |
|||
} |
|||
}; |
|||
|
|||
Transaction.prototype.initialize = function() { |
|||
this.version = 1; |
|||
this.txinsvi = Varint(0); |
|||
this.txins = []; |
|||
this.txoutsvi = Varint(0); |
|||
this.txouts = []; |
|||
this.nlocktime = 0xffffffff; |
|||
return this; |
|||
}; |
|||
|
|||
Transaction.prototype.set = function(obj) { |
|||
this.version = typeof obj.version !== 'undefined' ? obj.version : this.version; |
|||
this.txinsvi = obj.txinsvi || this.txinsvi; |
|||
this.txins = obj.txins || this.txins; |
|||
this.txoutsvi = obj.txoutsvi || this.txoutsvi; |
|||
this.txouts = obj.txouts || this.txouts; |
|||
this.nlocktime = typeof obj.nlocktime !== 'undefined' ? obj.nlocktime : this.nlocktime; |
|||
return this; |
|||
}; |
|||
|
|||
Transaction.prototype.fromJSON = function(json) { |
|||
var txins = []; |
|||
json.txins.forEach(function(txin) { |
|||
txins.push(Txin().fromJSON(txin)); |
|||
}); |
|||
var txouts = []; |
|||
json.txouts.forEach(function(txout) { |
|||
txouts.push(Txout().fromJSON(txout)); |
|||
}); |
|||
this.set({ |
|||
version: json.version, |
|||
txinsvi: Varint().fromJSON(json.txinsvi), |
|||
txins: txins, |
|||
txoutsvi: Varint().fromJSON(json.txoutsvi), |
|||
txouts: txouts, |
|||
nlocktime: json.nlocktime |
|||
}); |
|||
return this; |
|||
}; |
|||
|
|||
Transaction.prototype.toJSON = function() { |
|||
var txins = []; |
|||
this.txins.forEach(function(txin) { |
|||
txins.push(txin.toJSON()); |
|||
}); |
|||
var txouts = []; |
|||
this.txouts.forEach(function(txout) { |
|||
txouts.push(txout.toJSON()); |
|||
}); |
|||
return { |
|||
version: this.version, |
|||
txinsvi: this.txinsvi.toJSON(), |
|||
txins: txins, |
|||
txoutsvi: this.txoutsvi.toJSON(), |
|||
txouts: txouts, |
|||
nlocktime: this.nlocktime |
|||
}; |
|||
}; |
|||
|
|||
Transaction.prototype.fromBuffer = function(buf) { |
|||
return this.fromBufferReader(BufferReader(buf)); |
|||
}; |
|||
|
|||
Transaction.prototype.fromBufferReader = function(br) { |
|||
this.version = br.readUInt32LE(); |
|||
this.txinsvi = Varint(br.readVarintBuf()); |
|||
var txinsnum = this.txinsvi.toNumber(); |
|||
this.txins = []; |
|||
for (var i = 0; i < txinsnum; i++) { |
|||
this.txins.push(Txin().fromBufferReader(br)); |
|||
} |
|||
this.txoutsvi = Varint(br.readVarintBuf()); |
|||
var txoutsnum = this.txoutsvi.toNumber(); |
|||
this.txouts = []; |
|||
for (var i = 0; i < txoutsnum; i++) { |
|||
this.txouts.push(Txout().fromBufferReader(br)); |
|||
} |
|||
this.nlocktime = br.readUInt32LE(); |
|||
return this; |
|||
}; |
|||
|
|||
Transaction.prototype.toBuffer = function() { |
|||
return this.toBufferWriter().concat(); |
|||
}; |
|||
|
|||
Transaction.prototype.toBufferWriter = function(bw) { |
|||
if (!bw) |
|||
bw = new BufferWriter(); |
|||
bw.writeUInt32LE(this.version); |
|||
bw.write(this.txinsvi.buf); |
|||
for (var i = 0; i < this.txins.length; i++) { |
|||
this.txins[i].toBufferWriter(bw); |
|||
} |
|||
bw.write(this.txoutsvi.buf) |
|||
for (var i = 0; i < this.txouts.length; i++) { |
|||
this.txouts[i].toBufferWriter(bw); |
|||
} |
|||
bw.writeUInt32LE(this.nlocktime); |
|||
return bw; |
|||
}; |
|||
|
|||
Transaction.prototype.hash = function() { |
|||
return Hash.sha256sha256(this.toBuffer()); |
|||
}; |
|||
|
|||
Transaction.prototype.id = function() { |
|||
return BufferReader(this.hash()).reverse().read(); |
|||
}; |
|||
|
|||
Transaction.prototype.pushin = function(txin) { |
|||
this.txins.push(txin); |
|||
this.txinsvi = Varint(this.txinsvi.toNumber() + 1); |
|||
return this; |
|||
}; |
|||
|
|||
Transaction.prototype.pushout = function(txout) { |
|||
this.txouts.push(txout); |
|||
this.txoutsvi = Varint(this.txoutsvi.toNumber() + 1); |
|||
return this; |
|||
}; |
|||
|
|||
module.exports = Transaction; |
|||
@ -0,0 +1,81 @@ |
|||
var BufferReader = require('./bufferreader'); |
|||
var BufferWriter = require('./bufferwriter'); |
|||
var Varint = require('./varint'); |
|||
var Script = require('./script'); |
|||
|
|||
var Txin = function Txin(txidbuf, txoutnum, scriptvi, script, seqnum) { |
|||
if (!(this instanceof Txin)) |
|||
return new Txin(txidbuf, txoutnum, scriptvi, script, seqnum); |
|||
if (Buffer.isBuffer(txidbuf)) { |
|||
if (txidbuf.length !== 32) |
|||
throw new Error('txidbuf must be 32 bytes'); |
|||
this.txidbuf = txidbuf; |
|||
this.txoutnum = txoutnum; |
|||
this.scriptvi = scriptvi; |
|||
this.script = script; |
|||
this.seqnum = seqnum; |
|||
} else if (txidbuf) { |
|||
var obj = txidbuf; |
|||
this.set(obj); |
|||
} |
|||
}; |
|||
|
|||
Txin.prototype.set = function(obj) { |
|||
this.txidbuf = obj.txidbuf || this.txidbuf; |
|||
this.txoutnum = typeof obj.txoutnum !== 'undefined' ? obj.txoutnum : this.txoutnum; |
|||
this.scriptvi = typeof obj.scriptvi !== 'undefined' ? obj.scriptvi : this.scriptvi; |
|||
this.script = obj.script || this.script; |
|||
this.seqnum = typeof obj.seqnum !== 'undefined' ? obj.seqnum : this.seqnum; |
|||
return this; |
|||
}; |
|||
|
|||
Txin.prototype.fromJSON = function(json) { |
|||
this.set({ |
|||
txidbuf: new Buffer(json.txidbuf, 'hex'), |
|||
txoutnum: json.txoutnum, |
|||
scriptvi: Varint().fromJSON(json.scriptvi), |
|||
script: Script().fromJSON(json.script), |
|||
seqnum: json.seqnum |
|||
}); |
|||
return this; |
|||
}; |
|||
|
|||
Txin.prototype.toJSON = function() { |
|||
return { |
|||
txidbuf: this.txidbuf.toString('hex'), |
|||
txoutnum: this.txoutnum, |
|||
scriptvi: this.scriptvi.toJSON(), |
|||
script: this.script.toJSON(), |
|||
seqnum: this.seqnum |
|||
}; |
|||
}; |
|||
|
|||
Txin.prototype.fromBuffer = function(buf) { |
|||
return this.fromBufferReader(BufferReader(buf)); |
|||
}; |
|||
|
|||
Txin.prototype.fromBufferReader = function(br) { |
|||
this.txidbuf = br.read(32); |
|||
this.txoutnum = br.readUInt32LE(); |
|||
this.scriptvi = Varint(br.readVarintBuf()); |
|||
this.script = Script().fromBuffer(br.read(this.scriptvi.toNumber())); |
|||
this.seqnum = br.readUInt32LE(); |
|||
return this; |
|||
}; |
|||
|
|||
Txin.prototype.toBuffer = function() { |
|||
return this.toBufferWriter().concat(); |
|||
}; |
|||
|
|||
Txin.prototype.toBufferWriter = function(bw) { |
|||
if (!bw) |
|||
bw = new BufferWriter(); |
|||
bw.write(this.txidbuf); |
|||
bw.writeUInt32LE(this.txoutnum); |
|||
bw.write(this.scriptvi.buf); |
|||
bw.write(this.script.toBuffer()); |
|||
bw.writeUInt32LE(this.seqnum); |
|||
return bw; |
|||
}; |
|||
|
|||
module.exports = Txin; |
|||
@ -0,0 +1,71 @@ |
|||
var BN = require('./bn'); |
|||
var BufferReader = require('./bufferreader'); |
|||
var BufferWriter = require('./bufferwriter'); |
|||
var Varint = require('./varint'); |
|||
var Script = require('./script'); |
|||
|
|||
var Txout = function Txout(valuebn, scriptvi, script) { |
|||
if (!(this instanceof Txout)) |
|||
return new Txout(valuebn, scriptvi, script); |
|||
if (valuebn instanceof BN) { |
|||
this.set({ |
|||
valuebn: valuebn, |
|||
scriptvi: scriptvi, |
|||
script: script |
|||
}); |
|||
} else if (valuebn) { |
|||
var obj = valuebn; |
|||
this.set(obj); |
|||
} |
|||
}; |
|||
|
|||
Txout.prototype.set = function(obj) { |
|||
this.valuebn = obj.valuebn || this.valuebn; |
|||
this.scriptvi = obj.scriptvi || this.scriptvi; |
|||
this.script = obj.script || this.script; |
|||
return this; |
|||
}; |
|||
|
|||
Txout.prototype.fromJSON = function(json) { |
|||
this.set({ |
|||
valuebn: BN().fromJSON(json.valuebn), |
|||
scriptvi: Varint().fromJSON(json.scriptvi), |
|||
script: Script().fromJSON(json.script) |
|||
}); |
|||
return this; |
|||
}; |
|||
|
|||
Txout.prototype.toJSON = function() { |
|||
return { |
|||
valuebn: this.valuebn.toJSON(), |
|||
scriptvi: this.scriptvi.toJSON(), |
|||
script: this.script.toJSON() |
|||
}; |
|||
}; |
|||
|
|||
Txout.prototype.fromBuffer = function(buf) { |
|||
return this.fromBufferReader(BufferReader(buf)); |
|||
}; |
|||
|
|||
Txout.prototype.fromBufferReader = function(br) { |
|||
this.valuebn = br.readUInt64LEBN(); |
|||
this.scriptvi = Varint(br.readVarintNum()); |
|||
this.script = Script().fromBuffer(br.read(this.scriptvi.toNumber())); |
|||
return this; |
|||
}; |
|||
|
|||
Txout.prototype.toBuffer = function() { |
|||
var bw = new BufferWriter(); |
|||
return this.toBufferWriter(bw).concat(); |
|||
}; |
|||
|
|||
Txout.prototype.toBufferWriter = function(bw) { |
|||
if (!bw) |
|||
bw = new BufferWriter(); |
|||
bw.writeUInt64LEBN(this.valuebn); |
|||
bw.write(this.scriptvi.buf); |
|||
bw.write(this.script.toBuffer()); |
|||
return bw; |
|||
}; |
|||
|
|||
module.exports = Txout; |
|||
@ -0,0 +1,70 @@ |
|||
var BufferWriter = require('./bufferwriter'); |
|||
var BufferReader = require('./bufferreader'); |
|||
var BN = require('./bn'); |
|||
|
|||
var Varint = function Varint(buf) { |
|||
if (!(this instanceof Varint)) |
|||
return new Varint(buf); |
|||
if (Buffer.isBuffer(buf)) { |
|||
this.buf = buf; |
|||
} else if (typeof buf === 'number') { |
|||
var num = buf; |
|||
this.fromNumber(num); |
|||
} else if (buf instanceof BN) { |
|||
var bn = buf; |
|||
this.fromBN(bn); |
|||
} else if (buf) { |
|||
var obj = buf; |
|||
this.set(obj); |
|||
} |
|||
}; |
|||
|
|||
Varint.prototype.set = function(obj) { |
|||
this.buf = obj.buf || this.buf; |
|||
return this; |
|||
}; |
|||
|
|||
Varint.prototype.fromJSON = function(json) { |
|||
this.set({ |
|||
buf: new Buffer(json, 'hex') |
|||
}); |
|||
return this; |
|||
}; |
|||
|
|||
Varint.prototype.toJSON = function() { |
|||
return this.buf.toString('hex'); |
|||
}; |
|||
|
|||
Varint.prototype.fromBuffer = function(buf) { |
|||
this.buf = buf; |
|||
return this; |
|||
}; |
|||
|
|||
Varint.prototype.fromBufferReader = function(br) { |
|||
this.buf = br.readVarintBuf(); |
|||
return this; |
|||
}; |
|||
|
|||
Varint.prototype.fromBN = function(bn) { |
|||
this.buf = BufferWriter().writeVarintBN(bn).concat(); |
|||
return this; |
|||
}; |
|||
|
|||
Varint.prototype.fromNumber = function(num) { |
|||
this.buf = BufferWriter().writeVarintNum(num).concat(); |
|||
return this; |
|||
}; |
|||
|
|||
Varint.prototype.toBuffer = function() { |
|||
return this.buf; |
|||
}; |
|||
|
|||
Varint.prototype.toBN = function() { |
|||
return BufferReader(this.buf).readVarintBN(); |
|||
}; |
|||
|
|||
Varint.prototype.toNumber = function() { |
|||
return BufferReader(this.buf).readVarintNum(); |
|||
}; |
|||
|
|||
module.exports = Varint; |
|||
@ -0,0 +1,58 @@ |
|||
{ |
|||
"name": "bitcore2", |
|||
"version": "0.0.0", |
|||
"dependencies": { |
|||
"aes": { |
|||
"version": "0.1.0", |
|||
"from": "aes@=0.1.0", |
|||
"resolved": "https://registry.npmjs.org/aes/-/aes-0.1.0.tgz" |
|||
}, |
|||
"bn.js": { |
|||
"version": "0.14.0", |
|||
"from": "bn.js@0.14.0", |
|||
"resolved": "https://registry.npmjs.org/bn.js/-/bn.js-0.14.0.tgz" |
|||
}, |
|||
"bs58": { |
|||
"version": "1.2.1", |
|||
"from": "bs58@=1.2.1", |
|||
"resolved": "https://registry.npmjs.org/bs58/-/bs58-1.2.1.tgz" |
|||
}, |
|||
"elliptic": { |
|||
"version": "0.15.10", |
|||
"from": "elliptic@0.15.10", |
|||
"resolved": "https://registry.npmjs.org/elliptic/-/elliptic-0.15.10.tgz", |
|||
"dependencies": { |
|||
"bn.js": { |
|||
"version": "0.11.7", |
|||
"from": "bn.js@0.11.7", |
|||
"resolved": "https://registry.npmjs.org/bn.js/-/bn.js-0.11.7.tgz" |
|||
}, |
|||
"hash.js": { |
|||
"version": "0.2.1", |
|||
"from": "hash.js@0.2.1", |
|||
"resolved": "https://registry.npmjs.org/hash.js/-/hash.js-0.2.1.tgz" |
|||
}, |
|||
"inherits": { |
|||
"version": "2.0.1", |
|||
"from": "inherits@^2.0.1" |
|||
} |
|||
} |
|||
}, |
|||
"hash.js": { |
|||
"version": "0.3.1", |
|||
"from": "hash.js@0.3.1", |
|||
"resolved": "https://registry.npmjs.org/hash.js/-/hash.js-0.3.1.tgz", |
|||
"dependencies": { |
|||
"inherits": { |
|||
"version": "2.0.1", |
|||
"from": "inherits@^2.0.1" |
|||
} |
|||
} |
|||
}, |
|||
"sha512": { |
|||
"version": "0.0.1", |
|||
"from": "sha512@=0.0.1", |
|||
"resolved": "https://registry.npmjs.org/sha512/-/sha512-0.0.1.tgz" |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,79 @@ |
|||
{ |
|||
"name": "fullnode", |
|||
"version": "0.0.0", |
|||
"description": "Bitcoin library, CLI and API.", |
|||
"author": "Ryan X. Charles <ryanxcharles@gmail.com>", |
|||
"main": "index.js", |
|||
"scripts": { |
|||
"test": "mocha" |
|||
}, |
|||
"contributors": [ |
|||
{ |
|||
"name": "Daniel Cousens", |
|||
"email": "bitcoin@dcousens.com" |
|||
}, |
|||
{ |
|||
"name": "Gordon Hall", |
|||
"email": "gordon@bitpay.com" |
|||
}, |
|||
{ |
|||
"name": "Jeff Garzik", |
|||
"email": "jgarzik@bitpay.com" |
|||
}, |
|||
{ |
|||
"name": "Kyle Drake", |
|||
"email": "kyle@kyledrake.net" |
|||
}, |
|||
{ |
|||
"name": "Manuel Araoz", |
|||
"email": "manuelaraoz@gmail.com" |
|||
}, |
|||
{ |
|||
"name": "Matias Alejo Garcia", |
|||
"email": "ematiu@gmail.com" |
|||
}, |
|||
{ |
|||
"name": "Ryan X. Charles", |
|||
"email": "ryanxcharles@gmail.com" |
|||
}, |
|||
{ |
|||
"name": "Stefan Thomas", |
|||
"email": "moon@justmoon.net" |
|||
}, |
|||
{ |
|||
"name": "Stephen Pair", |
|||
"email": "stephen@bitpay.com" |
|||
}, |
|||
{ |
|||
"name": "Wei Lu", |
|||
"email": "luwei.here@gmail.com" |
|||
} |
|||
], |
|||
"keywords": [ |
|||
"bitcoin", |
|||
"bip32", |
|||
"bip37", |
|||
"bip70", |
|||
"stealth", |
|||
"merge", |
|||
"multisig" |
|||
], |
|||
"repository": { |
|||
"type": "git", |
|||
"url": "https://github.com/ryanxcharles/fullnode.git" |
|||
}, |
|||
"dependencies": { |
|||
"aes": "=0.1.0", |
|||
"bn.js": "=0.14.0", |
|||
"bs58": "=1.2.1", |
|||
"elliptic": "=0.15.10", |
|||
"hash.js": "=0.3.1", |
|||
"sha512": "=0.0.1" |
|||
}, |
|||
"devDependencies": { |
|||
"chai": "~1.9.1", |
|||
"mocha": "~1.21.0", |
|||
"browserify": "~5.9.1" |
|||
}, |
|||
"license": "MIT" |
|||
} |
|||
@ -0,0 +1,203 @@ |
|||
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'); |
|||
|
|||
describe('Address', function() { |
|||
var pubkeyhash = new Buffer('3c3fa3d4adcaf8f52d5b1843975e122548269937', 'hex'); |
|||
var buf = Buffer.concat([new Buffer([0]), pubkeyhash]); |
|||
var str = '16VZnHwRhwrExfeHFHGjwrgEMq8VcYPs9r'; |
|||
|
|||
it('should create a new address object', function() { |
|||
var address = new Address(); |
|||
should.exist(address); |
|||
address = Address(buf); |
|||
should.exist(address); |
|||
address = Address(str); |
|||
should.exist(address); |
|||
}); |
|||
|
|||
describe('@isValid', function() { |
|||
|
|||
it('should validate this valid address string', function() { |
|||
Address.isValid(str).should.equal(true); |
|||
}); |
|||
|
|||
it('should invalidate this valid address string', function() { |
|||
Address.isValid(str.substr(1)).should.equal(false); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromBuffer', function() { |
|||
|
|||
it('should make an address from a buffer', function() { |
|||
Address().fromBuffer(buf).toString().should.equal(str); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromHashbuf', function() { |
|||
|
|||
it('should make an address from a hashbuf', function() { |
|||
Address().fromHashbuf(pubkeyhash).toString().should.equal(str); |
|||
var a = Address().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() { |
|||
Address().fromHashbuf(buf); |
|||
}).should.throw('hashbuf must be exactly 20 bytes'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromPubkey', function() { |
|||
|
|||
it('should make this address from a compressed pubkey', function() { |
|||
var pubkey = new Pubkey(); |
|||
pubkey.fromDER(new Buffer('0285e9737a74c30a873f74df05124f2aa6f53042c2fc0a130d6cbd7d16b944b004', 'hex')); |
|||
var address = new Address(); |
|||
address.fromPubkey(pubkey); |
|||
address.toString().should.equal('19gH5uhqY6DKrtkU66PsZPUZdzTd11Y7ke'); |
|||
}); |
|||
|
|||
it('should make this address from an uncompressed pubkey', function() { |
|||
var pubkey = new Pubkey(); |
|||
pubkey.fromDER(new Buffer('0285e9737a74c30a873f74df05124f2aa6f53042c2fc0a130d6cbd7d16b944b004', 'hex')); |
|||
var address = new Address(); |
|||
pubkey.compressed = false; |
|||
address.fromPubkey(pubkey, 'mainnet'); |
|||
address.toString().should.equal('16JXnhxjJUhxfyx4y6H4sFcxrgt8kQ8ewX'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromScript', function() { |
|||
|
|||
it('should make this address from a script', function() { |
|||
var script = Script().fromString("OP_CHECKMULTISIG"); |
|||
var address = Address().fromScript(script); |
|||
address.toString().should.equal('3BYmEwgV2vANrmfRymr1mFnHXgLjD6gAWm'); |
|||
}); |
|||
|
|||
it('should make this address from other script', function() { |
|||
var script = Script().fromString("OP_CHECKSIG OP_HASH160"); |
|||
var address = Address().fromScript(script); |
|||
address.toString().should.equal('347iRqVwks5r493N1rsLN4k9J7Ljg488W7'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromString', function() { |
|||
|
|||
it('should derive from this known address string mainnet', function() { |
|||
var address = new Address(); |
|||
address.fromString(str); |
|||
address.toBuffer().slice(1).toString('hex').should.equal(pubkeyhash.toString('hex')); |
|||
}); |
|||
|
|||
it('should derive from this known address string testnet', function() { |
|||
var address = new Address(); |
|||
address.fromString(str); |
|||
address.networkstr = 'testnet'; |
|||
address.fromString(address.toString()); |
|||
address.toString().should.equal('mm1X5M2QWyHVjn7txrF7mmtZDpjCXzoa98'); |
|||
}); |
|||
|
|||
it('should derive from this known address string mainnet scripthash', function() { |
|||
var address = new Address(); |
|||
address.fromString(str); |
|||
address.networkstr = 'mainnet'; |
|||
address.typestr = 'scripthash'; |
|||
address.fromString(address.toString()); |
|||
address.toString().should.equal('37BahqRsFrAd3qLiNNwLNV3AWMRD7itxTo'); |
|||
}); |
|||
|
|||
it('should derive from this known address string testnet scripthash', function() { |
|||
var address = new Address(); |
|||
address.fromString(str); |
|||
address.networkstr = 'testnet'; |
|||
address.typestr = 'scripthash'; |
|||
address.fromString(address.toString()); |
|||
address.toString().should.equal('2MxjnmaMtsJfyFcyG3WZCzS2RihdNuWqeX4'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#isValid', function() { |
|||
|
|||
it('should describe this valid address as valid', function() { |
|||
var address = new Address(); |
|||
address.fromString('37BahqRsFrAd3qLiNNwLNV3AWMRD7itxTo'); |
|||
address.isValid().should.equal(true); |
|||
}); |
|||
|
|||
it('should describe this address with unknown network as invalid', function() { |
|||
var address = new Address(); |
|||
address.fromString('37BahqRsFrAd3qLiNNwLNV3AWMRD7itxTo'); |
|||
address.networkstr = 'unknown'; |
|||
address.isValid().should.equal(false); |
|||
}); |
|||
|
|||
it('should describe this address with unknown type as invalid', function() { |
|||
var address = new Address(); |
|||
address.fromString('37BahqRsFrAd3qLiNNwLNV3AWMRD7itxTo'); |
|||
address.typestr = 'unknown'; |
|||
address.isValid().should.equal(false); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toBuffer', function() { |
|||
|
|||
it('should output this known hash', function() { |
|||
var address = new Address(); |
|||
address.fromString(str); |
|||
address.toBuffer().slice(1).toString('hex').should.equal(pubkeyhash.toString('hex')); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toString', function() { |
|||
|
|||
it('should output the same thing that was input', function() { |
|||
var address = new Address(); |
|||
address.fromString(str); |
|||
address.toString().should.equal(str); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#validate', function() { |
|||
|
|||
it('should not throw an error on this valid address', function() { |
|||
var address = new Address(); |
|||
address.fromString(str); |
|||
should.exist(address.validate()); |
|||
}); |
|||
|
|||
it('should throw an error on this invalid network', function() { |
|||
var address = new Address(); |
|||
address.fromString(str); |
|||
address.networkstr = 'unknown'; |
|||
(function() { |
|||
address.validate(); |
|||
}).should.throw('networkstr must be "mainnet" or "testnet"'); |
|||
}); |
|||
|
|||
it('should throw an error on this invalid type', function() { |
|||
var address = new Address(); |
|||
address.fromString(str); |
|||
address.typestr = 'unknown'; |
|||
(function() { |
|||
address.validate(); |
|||
}).should.throw('typestr must be "pubkeyhash" or "scripthash"'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,85 @@ |
|||
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); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,73 @@ |
|||
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')); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,98 @@ |
|||
var Base58 = require('../lib/base58'); |
|||
var should = require('chai').should(); |
|||
|
|||
describe('Base58', function() { |
|||
var buf = new Buffer([0, 1, 2, 3, 253, 254, 255]); |
|||
var enc = "1W7N4RuG"; |
|||
|
|||
it('should make an instance with "new"', function() { |
|||
var b58 = new Base58(); |
|||
should.exist(b58); |
|||
}); |
|||
|
|||
it('should make an instance without "new"', function() { |
|||
var b58 = Base58(); |
|||
should.exist(b58); |
|||
}); |
|||
|
|||
it('should allow this handy syntax', function() { |
|||
Base58(buf).toString().should.equal(enc); |
|||
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([])}); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('@encode', function() { |
|||
|
|||
it('should encode the buffer accurately', function() { |
|||
Base58.encode(buf).should.equal(enc); |
|||
}); |
|||
|
|||
it('should throw an error when the Input is not a buffer', function() { |
|||
(function() { |
|||
Base58.encode("string") |
|||
}).should.throw('Input should be a buffer'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('@decode', function() { |
|||
|
|||
it('should decode this encoded value correctly', function() { |
|||
Base58.decode(enc).toString('hex').should.equal(buf.toString('hex')); |
|||
}); |
|||
|
|||
it('should throw an error when Input is not a string', function() { |
|||
(function() { |
|||
Base58.decode(5); |
|||
}).should.throw('Input should be a string'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromBuffer', function() { |
|||
|
|||
it('should not fail', function() { |
|||
should.exist(Base58().fromBuffer(buf)); |
|||
}); |
|||
|
|||
it('should set buffer', function() { |
|||
var b58 = Base58().fromBuffer(buf); |
|||
b58.buf.toString('hex').should.equal(buf.toString('hex')); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromString', function() { |
|||
|
|||
it('should convert this known string to a buffer', function() { |
|||
Base58().fromString(enc).toBuffer().toString('hex').should.equal(buf.toString('hex')); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toBuffer', function() { |
|||
|
|||
it('should return the buffer', function() { |
|||
var b58 = Base58({buf: buf}); |
|||
b58.buf.toString('hex').should.equal(buf.toString('hex')); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toString', function() { |
|||
|
|||
it('should return the buffer', function() { |
|||
var b58 = Base58({buf: buf}); |
|||
b58.toString().should.equal(enc); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,114 @@ |
|||
var should = require('chai').should(); |
|||
var Base58Check = require('../lib/base58check'); |
|||
var base58 = require('../lib/base58'); |
|||
|
|||
describe('Base58Check', function() { |
|||
var buf = new Buffer([0, 1, 2, 3, 253, 254, 255]); |
|||
var enc = "14HV44ipwoaqfg"; |
|||
|
|||
it('should make an instance with "new"', function() { |
|||
var b58 = new Base58Check(); |
|||
should.exist(b58); |
|||
}); |
|||
|
|||
it('should make an instance without "new"', function() { |
|||
var b58 = Base58Check(); |
|||
should.exist(b58); |
|||
}); |
|||
|
|||
it('should allow this handy syntax', function() { |
|||
Base58Check(buf).toString().should.equal(enc); |
|||
Base58Check(enc).toBuffer().toString('hex').should.equal(buf.toString('hex')); |
|||
}); |
|||
|
|||
describe('#set', function() { |
|||
|
|||
it('should set a buf', function() { |
|||
should.exist(Base58Check().set({buf: buf}).buf); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('@encode', function() { |
|||
|
|||
it('should encode the buffer accurately', function() { |
|||
Base58Check.encode(buf).should.equal(enc); |
|||
}); |
|||
|
|||
it('should throw an error when the input is not a buffer', function() { |
|||
(function() { |
|||
Base58Check.encode("string") |
|||
}).should.throw('Input must be a buffer'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('@decode', function() { |
|||
|
|||
it('should decode this encoded value correctly', function() { |
|||
Base58Check.decode(enc).toString('hex').should.equal(buf.toString('hex')); |
|||
}); |
|||
|
|||
it('should throw an error when input is not a string', function() { |
|||
(function() { |
|||
Base58Check.decode(5); |
|||
}).should.throw('Input must be a string'); |
|||
}); |
|||
|
|||
it('should throw an error when input is too short', function() { |
|||
(function() { |
|||
Base58Check.decode(enc.slice(0, 1)); |
|||
}).should.throw('Input string too short'); |
|||
}); |
|||
|
|||
it('should throw an error when there is a checksum mismatch', function() { |
|||
var buf2 = base58.decode(enc); |
|||
buf2[0] = buf2[0] + 1; |
|||
var enc2 = base58.encode(buf2); |
|||
(function() { |
|||
Base58Check.decode(enc2); |
|||
}).should.throw('Checksum mismatch'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromBuffer', function() { |
|||
|
|||
it('should not fail', function() { |
|||
should.exist(Base58Check().fromBuffer(buf)); |
|||
}); |
|||
|
|||
it('should set buffer', function() { |
|||
var b58 = Base58Check().fromBuffer(buf); |
|||
b58.buf.toString('hex').should.equal(buf.toString('hex')); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromString', function() { |
|||
|
|||
it('should convert this known string to a buffer', function() { |
|||
Base58Check().fromString(enc).toBuffer().toString('hex').should.equal(buf.toString('hex')); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toBuffer', function() { |
|||
|
|||
it('should return the buffer', function() { |
|||
var b58 = Base58Check({buf: buf}); |
|||
b58.buf.toString('hex').should.equal(buf.toString('hex')); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toString', function() { |
|||
|
|||
it('should return the buffer', function() { |
|||
var b58 = Base58Check({buf: buf}); |
|||
b58.toString().should.equal(enc); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,359 @@ |
|||
var should = require('chai').should(); |
|||
var constants = require('../lib/constants'); |
|||
var BIP32 = require('../lib/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_private = 'xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi'; |
|||
var vector1_m0h_public = 'xpub68Gmy5EdvgibQVfPdqkBBCHxA5htiqg55crXYuXoQRKfDBFA1WEjWgP6LHhwBZeNK1VTsfTFUHCdrfp1bgwQ9xv5ski8PX9rL2dZXvgGDnw'; |
|||
var vector1_m0h_private = 'xprv9uHRZZhk6KAJC1avXpDAp4MDc3sQKNxDiPvvkX8Br5ngLNv1TxvUxt4cV1rGL5hj6KCesnDYUhd7oWgT11eZG7XnxHrnYeSvkzY7d2bhkJ7'; |
|||
var vector1_m0h1_public = 'xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFHKkNAWbWMiGj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ'; |
|||
var vector1_m0h1_private = 'xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSxqu53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs'; |
|||
var vector1_m0h12h_public = 'xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5'; |
|||
var vector1_m0h12h_private = 'xprv9z4pot5VBttmtdRTWfWQmoH1taj2axGVzFqSb8C9xaxKymcFzXBDptWmT7FwuEzG3ryjH4ktypQSAewRiNMjANTtpgP4mLTj34bhnZX7UiM'; |
|||
var vector1_m0h12h2_public = 'xpub6FHa3pjLCk84BayeJxFW2SP4XRrFd1JYnxeLeU8EqN3vDfZmbqBqaGJAyiLjTAwm6ZLRQUMv1ZACTj37sR62cfN7fe5JnJ7dh8zL4fiyLHV'; |
|||
var vector1_m0h12h2_private = 'xprvA2JDeKCSNNZky6uBCviVfJSKyQ1mDYahRjijr5idH2WwLsEd4Hsb2Tyh8RfQMuPh7f7RtyzTtdrbdqqsunu5Mm3wDvUAKRHSC34sJ7in334'; |
|||
var vector1_m0h12h21000000000_public = 'xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNTEcYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy'; |
|||
var vector1_m0h12h21000000000_private = 'xprvA41z7zogVVwxVSgdKUHDy1SKmdb533PjDz7J6N6mV6uS3ze1ai8FHa8kmHScGpWmj4WggLyQjgPie1rFSruoUihUZREPSL39UNdE3BBDu76'; |
|||
var vector2_master = 'fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542'; |
|||
var vector2_m_public = 'xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB'; |
|||
var vector2_m_private = 'xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGdso3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U'; |
|||
var vector2_m0_public = 'xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH'; |
|||
var vector2_m0_private = 'xprv9vHkqa6EV4sPZHYqZznhT2NPtPCjKuDKGY38FBWLvgaDx45zo9WQRUT3dKYnjwih2yJD9mkrocEZXo1ex8G81dwSM1fwqWpWkeS3v86pgKt'; |
|||
var vector2_m02147483647h_public = 'xpub6ASAVgeehLbnwdqV6UKMHVzgqAG8Gr6riv3Fxxpj8ksbH9ebxaEyBLZ85ySDhKiLDBrQSARLq1uNRts8RuJiHjaDMBU4Zn9h8LZNnBC5y4a'; |
|||
var vector2_m02147483647h_private = 'xprv9wSp6B7kry3Vj9m1zSnLvN3xH8RdsPP1Mh7fAaR7aRLcQMKTR2vidYEeEg2mUCTAwCd6vnxVrcjfy2kRgVsFawNzmjuHc2YmYRmagcEPdU9'; |
|||
var vector2_m02147483647h1_public = 'xpub6DF8uhdarytz3FWdA8TvFSvvAh8dP3283MY7p2V4SeE2wyWmG5mg5EwVvmdMVCQcoNJxGoWaU9DCWh89LojfZ537wTfunKau47EL2dhHKon'; |
|||
var vector2_m02147483647h1_private = 'xprv9zFnWC6h2cLgpmSA46vutJzBcfJ8yaJGg8cX1e5StJh45BBciYTRXSd25UEPVuesF9yog62tGAQtHjXajPPdbRCHuWS6T8XA2ECKADdw4Ef'; |
|||
var vector2_m02147483647h12147483646h_public = 'xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL'; |
|||
var vector2_m02147483647h12147483646h_private = 'xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc'; |
|||
var vector2_m02147483647h12147483646h2_public = 'xpub6FnCn6nSzZAw5Tw7cgR9bi15UV96gLZhjDstkXXxvCLsUXBGXPdSnLFbdpq8p9HmGsApME5hQTZ3emM2rnY5agb9rXpVGyy3bdW6EEgAtqt'; |
|||
var vector2_m02147483647h12147483646h2_private = 'xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw7nadnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j'; |
|||
|
|||
it('should make a new a bip32', function() { |
|||
var bip32; |
|||
bip32 = new BIP32(); |
|||
should.exist(bip32); |
|||
bip32 = BIP32(); |
|||
should.exist(bip32); |
|||
new BIP32(vector1_m_private).toString().should.equal(vector1_m_private); |
|||
BIP32(vector1_m_private).toString().should.equal(vector1_m_private); |
|||
BIP32(BIP32(vector1_m_private)).toString().should.equal(vector1_m_private); |
|||
}); |
|||
|
|||
it('should initialize test vector 1 from the extended public key', function() { |
|||
var bip32 = new BIP32().fromString(vector1_m_public); |
|||
should.exist(bip32); |
|||
}); |
|||
|
|||
it('should initialize test vector 1 from the extended private key', function() { |
|||
var bip32 = new BIP32().fromString(vector1_m_private); |
|||
should.exist(bip32); |
|||
}); |
|||
|
|||
it('should get the extended public key from the extended private key for test vector 1', function() { |
|||
var bip32 = new BIP32().fromString(vector1_m_private); |
|||
bip32.xpubkeyString().should.equal(vector1_m_public); |
|||
}); |
|||
|
|||
it("should get m/0' ext. private key from test vector 1", function() { |
|||
var bip32 = new BIP32().fromString(vector1_m_private); |
|||
var child = bip32.derive("m/0'"); |
|||
should.exist(child); |
|||
child.xprivkeyString().should.equal(vector1_m0h_private); |
|||
}); |
|||
|
|||
it("should get m/0' ext. public key from test vector 1", function() { |
|||
var bip32 = new BIP32().fromString(vector1_m_private); |
|||
var child = bip32.derive("m/0'"); |
|||
should.exist(child); |
|||
child.xpubkeyString().should.equal(vector1_m0h_public); |
|||
}); |
|||
|
|||
it("should get m/0'/1 ext. private key from test vector 1", function() { |
|||
var bip32 = new BIP32().fromString(vector1_m_private); |
|||
var child = bip32.derive("m/0'/1"); |
|||
should.exist(child); |
|||
child.xprivkeyString().should.equal(vector1_m0h1_private); |
|||
}); |
|||
|
|||
it("should get m/0'/1 ext. public key from test vector 1", function() { |
|||
var bip32 = new BIP32().fromString(vector1_m_private); |
|||
var child = bip32.derive("m/0'/1"); |
|||
should.exist(child); |
|||
child.xpubkeyString().should.equal(vector1_m0h1_public); |
|||
}); |
|||
|
|||
it("should get m/0'/1 ext. public key from m/0' public key from test vector 1", function() { |
|||
var bip32 = new BIP32().fromString(vector1_m_private); |
|||
var child = bip32.derive("m/0'"); |
|||
var child_pub = new BIP32().fromString(child.xpubkeyString()); |
|||
var child2 = child_pub.derive("m/1"); |
|||
should.exist(child2); |
|||
child2.xpubkeyString().should.equal(vector1_m0h1_public); |
|||
}); |
|||
|
|||
it("should get m/0'/1/2h ext. private key from test vector 1", function() { |
|||
var bip32 = new BIP32().fromString(vector1_m_private); |
|||
var child = bip32.derive("m/0'/1/2'"); |
|||
should.exist(child); |
|||
child.xprivkeyString().should.equal(vector1_m0h12h_private); |
|||
}); |
|||
|
|||
it("should get m/0'/1/2h ext. public key from test vector 1", function() { |
|||
var bip32 = new BIP32().fromString(vector1_m_private); |
|||
var child = bip32.derive("m/0'/1/2'"); |
|||
should.exist(child); |
|||
child.xpubkeyString().should.equal(vector1_m0h12h_public); |
|||
}); |
|||
|
|||
it("should get m/0'/1/2h/2 ext. private key from test vector 1", function() { |
|||
var bip32 = new BIP32().fromString(vector1_m_private); |
|||
var child = bip32.derive("m/0'/1/2'/2"); |
|||
should.exist(child); |
|||
child.xprivkeyString().should.equal(vector1_m0h12h2_private); |
|||
}); |
|||
|
|||
it("should get m/0'/1/2'/2 ext. public key from m/0'/1/2' public key from test vector 1", function() { |
|||
var bip32 = new BIP32().fromString(vector1_m_private); |
|||
var child = bip32.derive("m/0'/1/2'"); |
|||
var child_pub = new BIP32().fromString(child.xpubkeyString()); |
|||
var child2 = child_pub.derive("m/2"); |
|||
should.exist(child2); |
|||
child2.xpubkeyString().should.equal(vector1_m0h12h2_public); |
|||
}); |
|||
|
|||
it("should get m/0'/1/2h/2 ext. public key from test vector 1", function() { |
|||
var bip32 = new BIP32().fromString(vector1_m_private); |
|||
var child = bip32.derive("m/0'/1/2'/2"); |
|||
should.exist(child); |
|||
child.xpubkeyString().should.equal(vector1_m0h12h2_public); |
|||
}); |
|||
|
|||
it("should get m/0'/1/2h/2/1000000000 ext. private key from test vector 1", function() { |
|||
var bip32 = new BIP32().fromString(vector1_m_private); |
|||
var child = bip32.derive("m/0'/1/2'/2/1000000000"); |
|||
should.exist(child); |
|||
child.xprivkeyString().should.equal(vector1_m0h12h21000000000_private); |
|||
}); |
|||
|
|||
it("should get m/0'/1/2h/2/1000000000 ext. public key from test vector 1", function() { |
|||
var bip32 = new BIP32().fromString(vector1_m_private); |
|||
var child = bip32.derive("m/0'/1/2'/2/1000000000"); |
|||
should.exist(child); |
|||
child.xpubkeyString().should.equal(vector1_m0h12h21000000000_public); |
|||
}); |
|||
|
|||
it("should get m/0'/1/2'/2/1000000000 ext. public key from m/0'/1/2'/2 public key from test vector 1", function() { |
|||
var bip32 = new BIP32().fromString(vector1_m_private); |
|||
var child = bip32.derive("m/0'/1/2'/2"); |
|||
var child_pub = new BIP32().fromString(child.xpubkeyString()); |
|||
var child2 = child_pub.derive("m/1000000000"); |
|||
should.exist(child2); |
|||
child2.xpubkeyString().should.equal(vector1_m0h12h21000000000_public); |
|||
}); |
|||
|
|||
it('should initialize test vector 2 from the extended public key', function() { |
|||
var bip32 = new BIP32().fromString(vector2_m_public); |
|||
should.exist(bip32); |
|||
}); |
|||
|
|||
it('should initialize test vector 2 from the extended private key', function() { |
|||
var bip32 = new BIP32().fromString(vector2_m_private); |
|||
should.exist(bip32); |
|||
}); |
|||
|
|||
it('should get the extended public key from the extended private key for test vector 2', function() { |
|||
var bip32 = new BIP32().fromString(vector2_m_private); |
|||
bip32.xpubkeyString().should.equal(vector2_m_public); |
|||
}); |
|||
|
|||
it("should get m/0 ext. private key from test vector 2", function() { |
|||
var bip32 = new BIP32().fromString(vector2_m_private); |
|||
var child = bip32.derive("m/0"); |
|||
should.exist(child); |
|||
child.xprivkeyString().should.equal(vector2_m0_private); |
|||
}); |
|||
|
|||
it("should get m/0 ext. public key from test vector 2", function() { |
|||
var bip32 = new BIP32().fromString(vector2_m_private); |
|||
var child = bip32.derive("m/0"); |
|||
should.exist(child); |
|||
child.xpubkeyString().should.equal(vector2_m0_public); |
|||
}); |
|||
|
|||
it("should get m/0 ext. public key from m public key from test vector 2", function() { |
|||
var bip32 = new BIP32().fromString(vector2_m_private); |
|||
var child = bip32.derive("m"); |
|||
var child_pub = new BIP32().fromString(child.xpubkeyString()); |
|||
var child2 = child_pub.derive("m/0"); |
|||
should.exist(child2); |
|||
child2.xpubkeyString().should.equal(vector2_m0_public); |
|||
}); |
|||
|
|||
it("should get m/0/2147483647h ext. private key from test vector 2", function() { |
|||
var bip32 = new BIP32().fromString(vector2_m_private); |
|||
var child = bip32.derive("m/0/2147483647'"); |
|||
should.exist(child); |
|||
child.xprivkeyString().should.equal(vector2_m02147483647h_private); |
|||
}); |
|||
|
|||
it("should get m/0/2147483647h ext. public key from test vector 2", function() { |
|||
var bip32 = new BIP32().fromString(vector2_m_private); |
|||
var child = bip32.derive("m/0/2147483647'"); |
|||
should.exist(child); |
|||
child.xpubkeyString().should.equal(vector2_m02147483647h_public); |
|||
}); |
|||
|
|||
it("should get m/0/2147483647h/1 ext. private key from test vector 2", function() { |
|||
var bip32 = new BIP32().fromString(vector2_m_private); |
|||
var child = bip32.derive("m/0/2147483647'/1"); |
|||
should.exist(child); |
|||
child.xprivkeyString().should.equal(vector2_m02147483647h1_private); |
|||
}); |
|||
|
|||
it("should get m/0/2147483647h/1 ext. public key from test vector 2", function() { |
|||
var bip32 = new BIP32().fromString(vector2_m_private); |
|||
var child = bip32.derive("m/0/2147483647'/1"); |
|||
should.exist(child); |
|||
child.xpubkeyString().should.equal(vector2_m02147483647h1_public); |
|||
}); |
|||
|
|||
it("should get m/0/2147483647h/1 ext. public key from m/0/2147483647h public key from test vector 2", function() { |
|||
var bip32 = new BIP32().fromString(vector2_m_private); |
|||
var child = bip32.derive("m/0/2147483647'"); |
|||
var child_pub = new BIP32().fromString(child.xpubkeyString()); |
|||
var child2 = child_pub.derive("m/1"); |
|||
should.exist(child2); |
|||
child2.xpubkeyString().should.equal(vector2_m02147483647h1_public); |
|||
}); |
|||
|
|||
it("should get m/0/2147483647h/1/2147483646h ext. private key from test vector 2", function() { |
|||
var bip32 = new BIP32().fromString(vector2_m_private); |
|||
var child = bip32.derive("m/0/2147483647'/1/2147483646'"); |
|||
should.exist(child); |
|||
child.xprivkeyString().should.equal(vector2_m02147483647h12147483646h_private); |
|||
}); |
|||
|
|||
it("should get m/0/2147483647h/1/2147483646h ext. public key from test vector 2", function() { |
|||
var bip32 = new BIP32().fromString(vector2_m_private); |
|||
var child = bip32.derive("m/0/2147483647'/1/2147483646'"); |
|||
should.exist(child); |
|||
child.xpubkeyString().should.equal(vector2_m02147483647h12147483646h_public); |
|||
}); |
|||
|
|||
it("should get m/0/2147483647h/1/2147483646h/2 ext. private key from test vector 2", function() { |
|||
var bip32 = new BIP32().fromString(vector2_m_private); |
|||
var child = bip32.derive("m/0/2147483647'/1/2147483646'/2"); |
|||
should.exist(child); |
|||
child.xprivkeyString().should.equal(vector2_m02147483647h12147483646h2_private); |
|||
}); |
|||
|
|||
it("should get m/0/2147483647h/1/2147483646h/2 ext. public key from test vector 2", function() { |
|||
var bip32 = new BIP32().fromString(vector2_m_private); |
|||
var child = bip32.derive("m/0/2147483647'/1/2147483646'/2"); |
|||
should.exist(child); |
|||
child.xpubkeyString().should.equal(vector2_m02147483647h12147483646h2_public); |
|||
}); |
|||
|
|||
it("should get m/0/2147483647h/1/2147483646h/2 ext. public key from m/0/2147483647h/2147483646h public key from test vector 2", function() { |
|||
var bip32 = new BIP32().fromString(vector2_m_private); |
|||
var child = bip32.derive("m/0/2147483647'/1/2147483646'"); |
|||
var child_pub = new BIP32().fromString(child.xpubkeyString()); |
|||
var child2 = child_pub.derive("m/2"); |
|||
should.exist(child2); |
|||
child2.xpubkeyString().should.equal(vector2_m02147483647h12147483646h2_public); |
|||
}); |
|||
|
|||
describe('testnet', function() { |
|||
it('should initialize a new BIP32 correctly from a random BIP32', function() { |
|||
var b1 = new BIP32(); |
|||
b1.fromRandom('testnet'); |
|||
var b2 = new BIP32().fromString(b1.xpubkeyString()); |
|||
b2.xpubkeyString().should.equal(b1.xpubkeyString()); |
|||
}); |
|||
|
|||
it('should generate valid ext pub key for testnet', function() { |
|||
var b = new BIP32(); |
|||
b.fromRandom('testnet'); |
|||
b.xpubkeyString().substring(0,4).should.equal('tpub'); |
|||
}); |
|||
}); |
|||
|
|||
describe('#set', function() { |
|||
var bip32 = BIP32(vector1_m_private); |
|||
var bip322 = BIP32().set({ |
|||
version: bip32.version, |
|||
depth: bip32.depth, |
|||
parentfingerprint: bip32.parentfingerprint, |
|||
childindex: bip32.childindex, |
|||
chaincode: bip32.chaincode, |
|||
key: bip32.key, |
|||
hasprivkey: bip32.hasprivkey, |
|||
pubkeyhash: bip32.pubKeyhash, |
|||
xpubkey: bip32.xpubkey, |
|||
xprivkey: bip32.xprivkey |
|||
}); |
|||
bip322.toString().should.equal(bip32.toString()); |
|||
bip322.set({}).toString().should.equal(bip32.toString()); |
|||
}); |
|||
|
|||
describe('#seed', function() { |
|||
|
|||
it('should initialize a new BIP32 correctly from test vector 1 seed', function() { |
|||
var hex = vector1_master; |
|||
var bip32 = (new BIP32()).fromSeed(new Buffer(hex, 'hex'), 'mainnet'); |
|||
should.exist(bip32); |
|||
bip32.xprivkeyString().should.equal(vector1_m_private); |
|||
bip32.xpubkeyString().should.equal(vector1_m_public); |
|||
}); |
|||
|
|||
it('should initialize a new BIP32 correctly from test vector 2 seed', function() { |
|||
var hex = vector2_master; |
|||
var bip32 = (new BIP32()).fromSeed(new Buffer(hex, 'hex'), 'mainnet'); |
|||
should.exist(bip32); |
|||
bip32.xprivkeyString().should.equal(vector2_m_private); |
|||
bip32.xpubkeyString().should.equal(vector2_m_public); |
|||
}); |
|||
}); |
|||
|
|||
describe('#fromString', function() { |
|||
|
|||
it('should make a bip32 from a string', function() { |
|||
var str = 'xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi'; |
|||
var bip32 = new BIP32().fromString(str); |
|||
should.exist(bip32); |
|||
bip32.toString().should.equal(str); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toString', function() { |
|||
var bip32 = new BIP32(); |
|||
bip32.fromRandom('mainnet'); |
|||
var tip32 = new BIP32(); |
|||
tip32.fromRandom('testnet'); |
|||
|
|||
it('should return an xprv string', function() { |
|||
bip32.toString().slice(0, 4).should.equal('xprv'); |
|||
}); |
|||
|
|||
it('should return an xpub string', function() { |
|||
var bip32b = new BIP32().fromString(bip32.xpubkeyString()); |
|||
bip32b.toString().slice(0, 4).should.equal('xpub'); |
|||
}); |
|||
|
|||
it('should return a tprv string', function() { |
|||
tip32.toString().slice(0, 4).should.equal('tprv'); |
|||
}); |
|||
|
|||
it('should return a tpub string', function() { |
|||
var tip32b = new BIP32().fromString(tip32.xpubkeyString()); |
|||
tip32b.toString().slice(0, 4).should.equal('tpub'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,151 @@ |
|||
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'); |
|||
var should = require('chai').should(); |
|||
var Transaction = require('../lib/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({ |
|||
magicnum: magicnum, |
|||
blocksize: blocksize, |
|||
blockheader: bh, |
|||
txsvi: txsvi, |
|||
txs: txs |
|||
}); |
|||
var blockhex = 'f9beb4d93200000001000000050505050505050505050505050505050505050505050505050505050505050509090909090909090909090909090909090909090909090909090909090909090200000003000000040000000101000000029e8d016a7b0dc49a325922d05da1f916d1e4d4f0cb840c9727f3d22ce8d1363f000000008c493046022100e9318720bee5425378b4763b0427158b1051eec8b08442ce3fbfbf7b30202a44022100d4172239ebd701dae2fbaaccd9f038e7ca166707333427e3fb2a2865b19a7f27014104510c67f46d2cbb29476d1f0b794be4cb549ea59ab9cc1e731969a7bf5be95f7ad5e7f904e5ccf50a9dc1714df00fbeb794aa27aaff33260c1032d931a75c56f2ffffffffa3195e7a1ab665473ff717814f6881485dc8759bebe97e31c301ffe7933a656f020000008b48304502201c282f35f3e02a1f32d2089265ad4b561f07ea3c288169dedcf2f785e6065efa022100e8db18aadacb382eed13ee04708f00ba0a9c40e3b21cf91da8859d0f7d99e0c50141042b409e1ebbb43875be5edde9c452c82c01e3903d38fa4fd89f3887a52cb8aea9dc8aec7e2c9d5b3609c03eb16259a2537135a1bf0f9c5fbbcbdbaf83ba402442ffffffff02206b1000000000001976a91420bb5c3bfaef0231dc05190e7f1c8e22e098991e88acf0ca0100000000001976a9149e3e2d23973a04ec1b02be97c30ab9f2f27c3b2c88ac00000000'; |
|||
var blockbuf = new Buffer(blockhex, 'hex'); |
|||
|
|||
var genesishex = 'f9beb4d91d0100000100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a29ab5f49ffff001d1dac2b7c0101000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000'; |
|||
var genesisbuf = new Buffer(genesishex, 'hex'); |
|||
var genesisidhex = '000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f'; |
|||
|
|||
it('should make a new block', function() { |
|||
var block = new Block(); |
|||
should.exist(block); |
|||
block = Block(); |
|||
should.exist(block); |
|||
block = Block(blockbuf); |
|||
block.toBuffer().toString('hex').should.equal(blockhex); |
|||
}); |
|||
|
|||
describe('#set', function() { |
|||
|
|||
it('should set these known values', function() { |
|||
var block = Block().set({ |
|||
magicnum: magicnum, |
|||
blocksize: blocksize, |
|||
blockheader: bh, |
|||
txsvi: txsvi, |
|||
txs: txs |
|||
}); |
|||
should.exist(block.magicnum); |
|||
should.exist(block.blocksize); |
|||
should.exist(block.blockheader); |
|||
should.exist(block.txsvi); |
|||
should.exist(block.txs); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromJSON', function() { |
|||
|
|||
it('should set these known values', function() { |
|||
var block = Block().set({ |
|||
magicnum: magicnum, |
|||
blocksize: blocksize, |
|||
blockheader: bh.toJSON(), |
|||
txsvi: txsvi.toJSON(), |
|||
txs: [txs[0].toJSON()] |
|||
}); |
|||
should.exist(block.magicnum); |
|||
should.exist(block.blocksize); |
|||
should.exist(block.blockheader); |
|||
should.exist(block.txsvi); |
|||
should.exist(block.txs); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toJSON', function() { |
|||
|
|||
it('should recover these known values', function() { |
|||
var json = block.toJSON(); |
|||
should.exist(json.magicnum); |
|||
should.exist(json.blocksize); |
|||
should.exist(json.blockheader); |
|||
should.exist(json.txsvi); |
|||
should.exist(json.txs); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromBuffer', function() { |
|||
|
|||
it('should make a block from this known buffer', function() { |
|||
var block = Block().fromBuffer(blockbuf); |
|||
block.toBuffer().toString('hex').should.equal(blockhex); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromBufferReader', function() { |
|||
|
|||
it('should make a block from this known buffer', function() { |
|||
var block = Block().fromBufferReader(BufferReader(blockbuf)); |
|||
block.toBuffer().toString('hex').should.equal(blockhex); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toBuffer', function() { |
|||
|
|||
it('should recover a block from this known buffer', function() { |
|||
var block = Block().fromBuffer(blockbuf); |
|||
block.toBuffer().toString('hex').should.equal(blockhex); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toBufferWriter', function() { |
|||
|
|||
it('should recover a block from this known buffer', function() { |
|||
var block = Block().fromBuffer(blockbuf); |
|||
block.toBufferWriter().concat().toString('hex').should.equal(blockhex); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#hash', function() { |
|||
|
|||
it('should return the correct hash of the genesis block', function() { |
|||
var block = Block().fromBuffer(genesisbuf); |
|||
var blockhash = new Buffer(Array.apply([], new Buffer(genesisidhex, 'hex')).reverse()); |
|||
block.hash().toString('hex').should.equal(blockhash.toString('hex')); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#id', function() { |
|||
|
|||
it('should return the correct id of the genesis block', function() { |
|||
var block = Block().fromBuffer(genesisbuf); |
|||
block.id().toString('hex').should.equal(genesisidhex); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,124 @@ |
|||
var Blockheader = require('../lib/blockheader'); |
|||
var BufferWriter = require('../lib/bufferwriter'); |
|||
var BufferReader = require('../lib/bufferreader'); |
|||
var should = require('chai').should(); |
|||
|
|||
describe('Blockheader', function() { |
|||
|
|||
var bh = new Blockheader(); |
|||
var version = 1; |
|||
var prevblockidbuf = new Buffer(32); |
|||
prevblockidbuf.fill(5); |
|||
var merklerootbuf = new Buffer(32); |
|||
merklerootbuf.fill(9); |
|||
var time = 2; |
|||
var bits = 3; |
|||
var nonce = 4; |
|||
bh.set({ |
|||
version: version, |
|||
prevblockidbuf: prevblockidbuf, |
|||
merklerootbuf: merklerootbuf, |
|||
time: time, |
|||
bits: bits, |
|||
nonce: nonce |
|||
}); |
|||
bhhex = '0100000005050505050505050505050505050505050505050505050505050505050505050909090909090909090909090909090909090909090909090909090909090909020000000300000004000000'; |
|||
bhbuf = new Buffer(bhhex, 'hex'); |
|||
|
|||
it('should make a new blockheader', function() { |
|||
var blockheader = new Blockheader(); |
|||
should.exist(blockheader); |
|||
blockheader = Blockheader(); |
|||
should.exist(blockheader); |
|||
Blockheader(bhbuf).toBuffer().toString('hex').should.equal(bhhex); |
|||
}); |
|||
|
|||
describe('#set', function() { |
|||
|
|||
it('should set all the variables', function() { |
|||
bh.set({ |
|||
version: version, |
|||
prevblockidbuf: prevblockidbuf, |
|||
merklerootbuf: merklerootbuf, |
|||
time: time, |
|||
bits: bits, |
|||
nonce: nonce |
|||
}); |
|||
should.exist(bh.version); |
|||
should.exist(bh.prevblockidbuf); |
|||
should.exist(bh.merklerootbuf); |
|||
should.exist(bh.time); |
|||
should.exist(bh.bits); |
|||
should.exist(bh.nonce); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromJSON', function() { |
|||
|
|||
it('should set all the variables', function() { |
|||
var bh = Blockheader().fromJSON({ |
|||
version: version, |
|||
prevblockidbuf: prevblockidbuf.toString('hex'), |
|||
merklerootbuf: merklerootbuf.toString('hex'), |
|||
time: time, |
|||
bits: bits, |
|||
nonce: nonce |
|||
}); |
|||
should.exist(bh.version); |
|||
should.exist(bh.prevblockidbuf); |
|||
should.exist(bh.merklerootbuf); |
|||
should.exist(bh.time); |
|||
should.exist(bh.bits); |
|||
should.exist(bh.nonce); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toJSON', function() { |
|||
|
|||
it('should set all the variables', function() { |
|||
var json = bh.toJSON(); |
|||
should.exist(json.version); |
|||
should.exist(json.prevblockidbuf); |
|||
should.exist(json.merklerootbuf); |
|||
should.exist(json.time); |
|||
should.exist(json.bits); |
|||
should.exist(json.nonce); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromBuffer', function() { |
|||
|
|||
it('should parse this known buffer', function() { |
|||
Blockheader().fromBuffer(bhbuf).toBuffer().toString('hex').should.equal(bhhex); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromBufferReader', function() { |
|||
|
|||
it('should parse this known buffer', function() { |
|||
Blockheader().fromBufferReader(BufferReader(bhbuf)).toBuffer().toString('hex').should.equal(bhhex); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toBuffer', function() { |
|||
|
|||
it('should output this known buffer', function() { |
|||
Blockheader().fromBuffer(bhbuf).toBuffer().toString('hex').should.equal(bhhex); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toBufferWriter', function() { |
|||
|
|||
it('should output this known buffer', function() { |
|||
Blockheader().fromBuffer(bhbuf).toBufferWriter().concat().toString('hex').should.equal(bhhex); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,154 @@ |
|||
var chai = chai || require('chai'); |
|||
var should = chai.should(); |
|||
var assert = chai.assert; |
|||
var BN = require('../lib/bn'); |
|||
|
|||
describe('BN', function() { |
|||
it('should create a bn', function() { |
|||
var bn = new BN(50); |
|||
should.exist(bn); |
|||
bn.toString().should.equal('50'); |
|||
}); |
|||
|
|||
it('should parse this number', function() { |
|||
var bn = new BN(999970000); |
|||
bn.toString().should.equal('999970000'); |
|||
}); |
|||
|
|||
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.toString().should.equal((Math.pow(2, 26)).toString()); |
|||
}); |
|||
|
|||
describe('#add', function() { |
|||
|
|||
it('should add two small numbers together', function() { |
|||
var bn1 = new BN(50); |
|||
var bn2 = new BN(75); |
|||
var bn3 = bn1.add(bn2); |
|||
bn3.toString().should.equal('125'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#sub', function() { |
|||
|
|||
it('should subtract a small number', function() { |
|||
var bn1 = new BN(50); |
|||
var bn2 = new BN(25); |
|||
var bn3 = bn1.sub(bn2); |
|||
bn3.toString().should.equal('25'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#gt', function() { |
|||
|
|||
it('should say 1 is greater than 0', function() { |
|||
var bn1 = new BN(1); |
|||
var bn0 = new BN(0); |
|||
bn1.gt(bn0).should.equal(true); |
|||
}); |
|||
|
|||
it('should say a big number is greater than a small big number', function() { |
|||
var bn1 = new BN('24023452345398529485723980457'); |
|||
var bn0 = new BN('34098234283412341234049357'); |
|||
bn1.gt(bn0).should.equal(true); |
|||
}); |
|||
|
|||
it('should say a big number is great than a standard number', function() { |
|||
var bn1 = new BN('24023452345398529485723980457'); |
|||
var bn0 = new BN(5); |
|||
bn1.gt(bn0).should.equal(true); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromJSON', function() { |
|||
|
|||
it('should make BN from a string', function() { |
|||
BN().fromJSON('5').toString().should.equal('5'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toJSON', function() { |
|||
|
|||
it('should make string from a BN', function() { |
|||
BN(5).toJSON().should.equal('5'); |
|||
BN().fromJSON('5').toJSON().should.equal('5'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromString', function() { |
|||
|
|||
it('should make BN from a string', function() { |
|||
BN().fromString('5').toString().should.equal('5'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toString', function() { |
|||
|
|||
it('should make a string', function() { |
|||
BN(5).toString().should.equal('5'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('@fromBuffer', function() { |
|||
|
|||
it('should work with big endian', function() { |
|||
var bn = BN.fromBuffer(new Buffer('0001', 'hex'), {endian: 'big'}); |
|||
bn.toString().should.equal('1'); |
|||
}); |
|||
|
|||
it('should work with big endian 256', function() { |
|||
var bn = BN.fromBuffer(new Buffer('0100', 'hex'), {endian: 'big'}); |
|||
bn.toString().should.equal('256'); |
|||
}); |
|||
|
|||
it('should work with little endian if we specify the size', function() { |
|||
var bn = BN.fromBuffer(new Buffer('0100', 'hex'), {size: 2, endian: 'little'}); |
|||
bn.toString().should.equal('1'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromBuffer', function() { |
|||
|
|||
it('should work as a prototype method', function() { |
|||
var bn = BN().fromBuffer(new Buffer('0100', 'hex'), {size: 2, endian: 'little'}); |
|||
bn.toString().should.equal('1'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toBuffer', function() { |
|||
|
|||
it('should create a 4 byte buffer', function() { |
|||
var bn = new BN(1); |
|||
bn.toBuffer({size: 4}).toString('hex').should.equal('00000001'); |
|||
}); |
|||
|
|||
it('should create a 4 byte buffer in little endian', function() { |
|||
var bn = new BN(1); |
|||
bn.toBuffer({size: 4, endian: 'little'}).toString('hex').should.equal('01000000'); |
|||
}); |
|||
|
|||
it('should create a 2 byte buffer even if you ask for a 1 byte', function() { |
|||
var bn = new BN('ff00', 16); |
|||
bn.toBuffer({size: 1}).toString('hex').should.equal('ff00'); |
|||
}); |
|||
|
|||
it('should create a 4 byte buffer even if you ask for a 1 byte', function() { |
|||
var bn = new BN('ffffff00', 16); |
|||
bn.toBuffer({size: 4}).toString('hex').should.equal('ffffff00'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,274 @@ |
|||
var BufferWriter = require('../lib/bufferwriter'); |
|||
var BufferReader = require('../lib/bufferreader'); |
|||
var should = require('chai').should(); |
|||
var BN = require('../lib/bn'); |
|||
|
|||
describe('BufferReader', function() { |
|||
|
|||
it('should make a new BufferReader', function() { |
|||
var br = new BufferReader(); |
|||
should.exist(br); |
|||
br = BufferReader(); |
|||
should.exist(br); |
|||
}); |
|||
|
|||
it('should create a new bufferreader with a buffer', function() { |
|||
var buf = new Buffer(0); |
|||
var br = new BufferReader(buf); |
|||
should.exist(br); |
|||
Buffer.isBuffer(br.buf).should.equal(true); |
|||
}); |
|||
|
|||
describe('#set', function() { |
|||
|
|||
it('should set pos', function() { |
|||
should.exist(BufferReader().set({pos: 1}).pos); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#eof', function() { |
|||
|
|||
it('should return true for a blank br', function() { |
|||
var br = new BufferReader({buf: new Buffer([])}); |
|||
br.eof().should.equal(true); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('read', function() { |
|||
|
|||
it('should return the same buffer', function() { |
|||
var buf = new Buffer([0]); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.read().toString('hex').should.equal(buf.toString('hex')); |
|||
}); |
|||
|
|||
it('should return a buffer of this length', function() { |
|||
var buf = new Buffer(10); |
|||
buf.fill(0); |
|||
var br = new BufferReader(buf); |
|||
var buf2 = br.read(2); |
|||
buf2.length.should.equal(2); |
|||
br.eof().should.equal(false); |
|||
br.pos.should.equal(2); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#readUInt8', function() { |
|||
|
|||
it('should return 1', function() { |
|||
var buf = new Buffer(1); |
|||
buf.writeUInt8(1, 0); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readUInt8().should.equal(1); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#readUInt16BE', function() { |
|||
|
|||
it('should return 1', function() { |
|||
var buf = new Buffer(2); |
|||
buf.writeUInt16BE(1, 0); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readUInt16BE().should.equal(1); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#readUInt16LE', function() { |
|||
|
|||
it('should return 1', function() { |
|||
var buf = new Buffer(2); |
|||
buf.writeUInt16LE(1, 0); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readUInt16LE().should.equal(1); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#readUInt32BE', function() { |
|||
|
|||
it('should return 1', function() { |
|||
var buf = new Buffer(4); |
|||
buf.writeUInt32BE(1, 0); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readUInt32BE().should.equal(1); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#readUInt32LE', function() { |
|||
|
|||
it('should return 1', function() { |
|||
var buf = new Buffer(4); |
|||
buf.writeUInt32LE(1, 0); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readUInt32LE().should.equal(1); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#readUInt64BEBN', function() { |
|||
|
|||
it('should return 1', function() { |
|||
var buf = new Buffer(8); |
|||
buf.fill(0); |
|||
buf.writeUInt32BE(1, 4); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readUInt64BEBN().toNumber().should.equal(1); |
|||
}); |
|||
|
|||
it('should return 2^64', function() { |
|||
var buf = new Buffer(8); |
|||
buf.fill(0xff); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readUInt64BEBN().toNumber().should.equal(Math.pow(2, 64)); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#readUInt64LEBN', function() { |
|||
|
|||
it('should return 1', function() { |
|||
var buf = new Buffer(8); |
|||
buf.fill(0); |
|||
buf.writeUInt32LE(1, 0); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readUInt64LEBN().toNumber().should.equal(1); |
|||
}); |
|||
|
|||
it('should return 2^30', function() { |
|||
var buf = new Buffer(8); |
|||
buf.fill(0); |
|||
buf.writeUInt32LE(Math.pow(2, 30), 0); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readUInt64LEBN().toNumber().should.equal(Math.pow(2, 30)); |
|||
}); |
|||
|
|||
it('should return 0', function() { |
|||
var buf = new Buffer(8); |
|||
buf.fill(0); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readUInt64LEBN().toNumber().should.equal(0); |
|||
}); |
|||
|
|||
it('should return 2^64', function() { |
|||
var buf = new Buffer(8); |
|||
buf.fill(0xff); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readUInt64LEBN().toNumber().should.equal(Math.pow(2, 64)); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#readVarintBuf', function() { |
|||
|
|||
it('should read a 1 byte varint', function() { |
|||
var buf = new Buffer([50]); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readVarintBuf().length.should.equal(1); |
|||
}); |
|||
|
|||
it('should read a 3 byte varint', function() { |
|||
var buf = new Buffer([253, 253, 0]); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readVarintBuf().length.should.equal(3); |
|||
}); |
|||
|
|||
it('should read a 5 byte varint', function() { |
|||
var buf = new Buffer([254, 0, 0, 0, 0]); |
|||
buf.writeUInt32LE(50000, 1); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readVarintBuf().length.should.equal(5); |
|||
}); |
|||
|
|||
it('should read a 9 byte varint', function() { |
|||
var buf = BufferWriter().writeVarintBN(BN(Math.pow(2, 54).toString())).concat(); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readVarintBuf().length.should.equal(9); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#readVarintNum', function() { |
|||
|
|||
it('should read a 1 byte varint', function() { |
|||
var buf = new Buffer([50]); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readVarintNum().should.equal(50); |
|||
}); |
|||
|
|||
it('should read a 3 byte varint', function() { |
|||
var buf = new Buffer([253, 253, 0]); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readVarintNum().should.equal(253); |
|||
}); |
|||
|
|||
it('should read a 5 byte varint', function() { |
|||
var buf = new Buffer([254, 0, 0, 0, 0]); |
|||
buf.writeUInt32LE(50000, 1); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readVarintNum().should.equal(50000); |
|||
}); |
|||
|
|||
it('should throw an error on a 9 byte varint over the javascript uint precision limit', function() { |
|||
var buf = BufferWriter().writeVarintBN(BN(Math.pow(2, 54).toString())).concat(); |
|||
var br = new BufferReader({buf: buf}); |
|||
(function() { |
|||
br.readVarintNum(); |
|||
}).should.throw('number too large to retain precision - use readVarintBN'); |
|||
}); |
|||
|
|||
it('should not throw an error on a 9 byte varint not over the javascript uint precision limit', function() { |
|||
var buf = BufferWriter().writeVarintBN(BN(Math.pow(2, 53).toString())).concat(); |
|||
var br = new BufferReader({buf: buf}); |
|||
(function() { |
|||
br.readVarintNum(); |
|||
}).should.not.throw('number too large to retain precision - use readVarintBN'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#readVarintBN', function() { |
|||
|
|||
it('should read a 1 byte varint', function() { |
|||
var buf = new Buffer([50]); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readVarintBN().toNumber().should.equal(50); |
|||
}); |
|||
|
|||
it('should read a 3 byte varint', function() { |
|||
var buf = new Buffer([253, 253, 0]); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readVarintBN().toNumber().should.equal(253); |
|||
}); |
|||
|
|||
it('should read a 5 byte varint', function() { |
|||
var buf = new Buffer([254, 0, 0, 0, 0]); |
|||
buf.writeUInt32LE(50000, 1); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readVarintBN().toNumber().should.equal(50000); |
|||
}); |
|||
|
|||
it('should read a 9 byte varint', function() { |
|||
var buf = Buffer.concat([new Buffer([255]), new Buffer('ffffffffffffffff', 'hex')]); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.readVarintBN().toNumber().should.equal(Math.pow(2, 64)); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#reverse', function() { |
|||
|
|||
it('should reverse this [0, 1]', function() { |
|||
var buf = new Buffer([0, 1]); |
|||
var br = new BufferReader({buf: buf}); |
|||
br.reverse().read().toString('hex').should.equal('0100'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,186 @@ |
|||
var BufferWriter = require('../lib/bufferwriter'); |
|||
var BufferReader = require('../lib/bufferreader'); |
|||
var BN = require('../lib/bn'); |
|||
var should = require('chai').should(); |
|||
|
|||
describe('BufferWriter', function() { |
|||
|
|||
it('should create a new buffer writer', function() { |
|||
var bw = new BufferWriter(); |
|||
should.exist(bw); |
|||
}); |
|||
|
|||
describe('#set', 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'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toBuffer', function() { |
|||
|
|||
it('should concat these two bufs', function() { |
|||
var buf1 = new Buffer([0]); |
|||
var buf2 = new Buffer([1]); |
|||
var bw = new BufferWriter({bufs: [buf1, buf2]}); |
|||
bw.toBuffer().toString('hex').should.equal('0001'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#concat', function() { |
|||
|
|||
it('should concat these two bufs', function() { |
|||
var buf1 = new Buffer([0]); |
|||
var buf2 = new Buffer([1]); |
|||
var bw = new BufferWriter({bufs: [buf1, buf2]}); |
|||
bw.concat().toString('hex').should.equal('0001'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#write', function() { |
|||
|
|||
it('should write a buffer', function() { |
|||
var buf = new Buffer([0]); |
|||
var bw = new BufferWriter(); |
|||
bw.write(buf); |
|||
bw.concat().toString('hex').should.equal('00'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#writeUInt8', function() { |
|||
|
|||
it('should write 1', function() { |
|||
var bw = new BufferWriter(); |
|||
bw.writeUInt8(1).concat().toString('hex').should.equal('01'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#writeUInt16BE', function() { |
|||
|
|||
it('should write 1', function() { |
|||
var bw = new BufferWriter(); |
|||
bw.writeUInt16BE(1).concat().toString('hex').should.equal('0001'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#writeUInt16LE', function() { |
|||
|
|||
it('should write 1', function() { |
|||
var bw = new BufferWriter(); |
|||
bw.writeUInt16LE(1).concat().toString('hex').should.equal('0100'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#writeUInt32BE', function() { |
|||
|
|||
it('should write 1', function() { |
|||
var bw = new BufferWriter(); |
|||
bw.writeUInt32BE(1).concat().toString('hex').should.equal('00000001'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#writeUInt32LE', function() { |
|||
|
|||
it('should write 1', function() { |
|||
var bw = new BufferWriter(); |
|||
bw.writeUInt32LE(1).concat().toString('hex').should.equal('01000000'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#writeUInt64BEBN', function() { |
|||
|
|||
it('should write 1', function() { |
|||
var bw = new BufferWriter(); |
|||
bw.writeUInt64BEBN(BN(1)).concat().toString('hex').should.equal('0000000000000001'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#writeUInt64LEBN', function() { |
|||
|
|||
it('should write 1', function() { |
|||
var bw = new BufferWriter(); |
|||
bw.writeUInt64LEBN(BN(1)).concat().toString('hex').should.equal('0100000000000000'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#writeVarint', function() { |
|||
|
|||
it('should write a 1 byte varint', function() { |
|||
var bw = new BufferWriter(); |
|||
bw.writeVarintNum(1); |
|||
bw.concat().length.should.equal(1); |
|||
}); |
|||
|
|||
it('should write a 3 byte varint', function() { |
|||
var bw = new BufferWriter(); |
|||
bw.writeVarintNum(1000); |
|||
bw.concat().length.should.equal(3); |
|||
}); |
|||
|
|||
it('should write a 5 byte varint', function() { |
|||
var bw = new BufferWriter(); |
|||
bw.writeVarintNum(Math.pow(2, 16 + 1)); |
|||
bw.concat().length.should.equal(5); |
|||
}); |
|||
|
|||
it('should write a 9 byte varint', function() { |
|||
var bw = new BufferWriter(); |
|||
bw.writeVarintNum(Math.pow(2, 32 + 1)); |
|||
bw.concat().length.should.equal(9); |
|||
}); |
|||
|
|||
it('should read back the same value it wrote for a 9 byte varint', function() { |
|||
var bw = new BufferWriter(); |
|||
var n = Math.pow(2, 53); |
|||
n.should.equal(n + 1); //javascript number precision limit
|
|||
bw.writeVarintNum(n); |
|||
var br = new BufferReader({buf: bw.concat()}); |
|||
br.readVarintBN().toNumber().should.equal(n); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#writeVarintBN', function() { |
|||
|
|||
it('should write a 1 byte varint', function() { |
|||
var bw = new BufferWriter(); |
|||
bw.writeVarintBN(BN(1)); |
|||
bw.concat().length.should.equal(1); |
|||
}); |
|||
|
|||
it('should write a 3 byte varint', function() { |
|||
var bw = new BufferWriter(); |
|||
bw.writeVarintBN(BN(1000)); |
|||
bw.concat().length.should.equal(3); |
|||
}); |
|||
|
|||
it('should write a 5 byte varint', function() { |
|||
var bw = new BufferWriter(); |
|||
bw.writeVarintBN(BN(Math.pow(2, 16 + 1))); |
|||
bw.concat().length.should.equal(5); |
|||
}); |
|||
|
|||
it('should write a 9 byte varint', function() { |
|||
var bw = new BufferWriter(); |
|||
bw.writeVarintBN(BN(Math.pow(2, 32 + 1))); |
|||
bw.concat().length.should.equal(9); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,317 @@ |
|||
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); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,213 @@ |
|||
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(); |
|||
|
|||
describe("ECDSA", function() { |
|||
|
|||
it('should create a blank ecdsa', function() { |
|||
var ecdsa = new ECDSA(); |
|||
}); |
|||
|
|||
var ecdsa = new ECDSA(); |
|||
ecdsa.hashbuf = Hash.sha256(new Buffer('test data')); |
|||
ecdsa.keypair = new Keypair(); |
|||
ecdsa.keypair.privkey = new Privkey({bn: BN().fromBuffer(new Buffer('fee0a1f7afebf9d2a5a80c0c98a31c709681cce195cbcd06342b517970c0be1e', 'hex'))}); |
|||
ecdsa.keypair.pubkey = new Pubkey({ |
|||
point: point(BN().fromBuffer(new Buffer('ac242d242d23be966085a2b2b893d989f824e06c9ad0395a8a52f055ba39abb2', 'hex')), |
|||
BN().fromBuffer(new Buffer('4836ab292c105a711ed10fcfd30999c31ff7c02456147747e03e739ad527c380', 'hex'))) |
|||
}); |
|||
|
|||
describe('#set', function() { |
|||
|
|||
it('should set hashbuf', function() { |
|||
should.exist(ECDSA().set({hashbuf: ecdsa.hashbuf}).hashbuf); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#calci', function() { |
|||
|
|||
it('should calculate i', function() { |
|||
ecdsa.randomK(); |
|||
ecdsa.sign(); |
|||
ecdsa.calci(); |
|||
should.exist(ecdsa.sig.i); |
|||
}); |
|||
|
|||
it('should calulate this known i', function() { |
|||
var hashbuf = Hash.sha256(new Buffer('some data')); |
|||
var r = BN('71706645040721865894779025947914615666559616020894583599959600180037551395766', 10); |
|||
var s = BN('109412465507152403114191008482955798903072313614214706891149785278625167723646', 10); |
|||
var ecdsa = new ECDSA(); |
|||
ecdsa.keypair = new Keypair(); |
|||
ecdsa.keypair.privkey = Privkey(); |
|||
ecdsa.keypair.privkey.bn = BN().fromBuffer(Hash.sha256(new Buffer('test'))); |
|||
ecdsa.keypair.privkey2pubkey(); |
|||
ecdsa.hashbuf = hashbuf; |
|||
ecdsa.sig = new Signature({r: r, s: s}); |
|||
|
|||
ecdsa.calci(); |
|||
ecdsa.sig.i.should.equal(1); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromString', function() { |
|||
|
|||
it('should to a round trip with to string', function() { |
|||
var str = ecdsa.toString(); |
|||
var ecdsa2 = new ECDSA(); |
|||
ecdsa2.fromString(str); |
|||
should.exist(ecdsa.hashbuf); |
|||
should.exist(ecdsa.keypair); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#randomK', function() { |
|||
|
|||
it('should generate a new random k when called twice in a row', function() { |
|||
ecdsa.randomK(); |
|||
var k1 = ecdsa.k; |
|||
ecdsa.randomK(); |
|||
var k2 = ecdsa.k; |
|||
(k1.cmp(k2) === 0).should.equal(false); |
|||
}); |
|||
|
|||
it('should generate a random k that is (almost always) greater than this relatively small number', function() { |
|||
ecdsa.randomK(); |
|||
var k1 = ecdsa.k; |
|||
var k2 = BN(Math.pow(2, 32)).mul(BN(Math.pow(2, 32))).mul(BN(Math.pow(2, 32))); |
|||
k2.gt(k1).should.equal(false); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#sig2pubkey', function() { |
|||
|
|||
it('should calculate the correct public key', function() { |
|||
ecdsa.k = BN('114860389168127852803919605627759231199925249596762615988727970217268189974335', 10); |
|||
ecdsa.sign(); |
|||
ecdsa.sig.i = 1; |
|||
var pubkey = ecdsa.sig2pubkey(); |
|||
pubkey.point.eq(ecdsa.keypair.pubkey.point).should.equal(true); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#sigError', function() { |
|||
|
|||
it('should return an error if the hash is invalid', function() { |
|||
var ecdsa = new ECDSA(); |
|||
ecdsa.sigError().should.equal('hashbuf must be a 32 byte buffer'); |
|||
}); |
|||
|
|||
it('should return an error if the pubkey is invalid', function() { |
|||
var ecdsa = new ECDSA(); |
|||
ecdsa.hashbuf = Hash.sha256(new Buffer('test')); |
|||
ecdsa.sigError().indexOf("Invalid pubkey").should.equal(0); |
|||
}); |
|||
|
|||
it('should return an error if r, s are invalid', function() { |
|||
var ecdsa = new ECDSA(); |
|||
ecdsa.hashbuf = Hash.sha256(new Buffer('test')); |
|||
var pk = new Pubkey(); |
|||
pk.fromDER(new Buffer('041ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a7baad41d04514751e6851f5304fd243751703bed21b914f6be218c0fa354a341', 'hex')); |
|||
ecdsa.keypair = new Keypair(); |
|||
ecdsa.keypair.pubkey = pk; |
|||
ecdsa.sig = new Signature(); |
|||
ecdsa.sig.r = BN(0); |
|||
ecdsa.sig.s = BN(0); |
|||
ecdsa.sigError().should.equal("r and s not in range"); |
|||
}); |
|||
|
|||
it('should return an error if the signature is incorrect', function() { |
|||
ecdsa.sig = new Signature(); |
|||
ecdsa.sig.fromString('3046022100e9915e6236695f093a4128ac2a956c40ed971531de2f4f41ba05fac7e2bd019c02210094e6a4a769cc7f2a8ab3db696c7cd8d56bcdbfff860a8c81de4bc6a798b90827'); |
|||
ecdsa.sig.r = ecdsa.sig.r.add(BN(1)); |
|||
ecdsa.sigError().should.equal("Invalid signature"); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#sign', function() { |
|||
|
|||
it('should create a valid signature', function() { |
|||
ecdsa.randomK(); |
|||
ecdsa.sign(); |
|||
ecdsa.verify().should.equal(true); |
|||
}); |
|||
|
|||
it('should should throw an error if hashbuf is not 32 bytes', function() { |
|||
var ecdsa2 = ECDSA().set({ |
|||
hashbuf: ecdsa.hashbuf.slice(0, 31), |
|||
keypair: ecdsa.keypair |
|||
}); |
|||
ecdsa2.randomK(); |
|||
(function() { |
|||
ecdsa2.sign(); |
|||
}).should.throw('hashbuf must be a 32 byte buffer'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#signRandomK', function() { |
|||
|
|||
it('should produce a signature', function() { |
|||
ecdsa.signRandomK(); |
|||
should.exist(ecdsa.sig); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toString', function() { |
|||
|
|||
it('should convert this to a string', function() { |
|||
var str = ecdsa.toString(); |
|||
(typeof str === 'string').should.equal(true); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#verify', function() { |
|||
|
|||
it('should verify a signature that was just signed', function() { |
|||
ecdsa.sig = new Signature(); |
|||
ecdsa.sig.fromString('3046022100e9915e6236695f093a4128ac2a956c40ed971531de2f4f41ba05fac7e2bd019c02210094e6a4a769cc7f2a8ab3db696c7cd8d56bcdbfff860a8c81de4bc6a798b90827'); |
|||
ecdsa.verify().should.equal(true); |
|||
}); |
|||
|
|||
it('should verify this known good signature', function() { |
|||
ecdsa.signRandomK(); |
|||
ecdsa.verify().should.equal(true); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('@sign', function() { |
|||
|
|||
it('should produce a signature', function() { |
|||
var sig = ECDSA.sign(ecdsa.hashbuf, ecdsa.keypair); |
|||
(sig instanceof Signature).should.equal(true); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('@verify', function() { |
|||
|
|||
it('should verify a valid signature, and unverify an invalid signature', function() { |
|||
var sig = ECDSA.sign(ecdsa.hashbuf, ecdsa.keypair); |
|||
ECDSA.verify(ecdsa.hashbuf, sig, ecdsa.keypair.pubkey).should.equal(true); |
|||
var fakesig = Signature(sig.r.add(1), sig.s); |
|||
ECDSA.verify(ecdsa.hashbuf, fakesig, ecdsa.keypair.pubkey).should.equal(false); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,52 @@ |
|||
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')); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,32 @@ |
|||
if (process.browser) |
|||
return; //examples are loaded from files, which doesn't work in the browser
|
|||
|
|||
var should = require('chai').should(); |
|||
var fs = require('fs'); |
|||
|
|||
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; |
|||
console.log = function() {}; |
|||
require('../examples/' + filename); |
|||
console.log = save; |
|||
}).should.not.throw(); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
} |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,115 @@ |
|||
var should = require('chai').should(); |
|||
var Hash = require('../lib/hash'); |
|||
|
|||
describe('Hash', function() { |
|||
var buf = new Buffer([0, 1, 2, 3, 253, 254, 255]); |
|||
var str = "test string"; |
|||
|
|||
describe('#sha256', function() { |
|||
|
|||
it('should calculate the hash of this buffer correctly', function() { |
|||
var hash = Hash.sha256(buf); |
|||
hash.toString('hex').should.equal('6f2c7b22fd1626998287b3636089087961091de80311b9279c4033ec678a83e8'); |
|||
}); |
|||
|
|||
it('should throw an error when the input is not a buffer', function() { |
|||
(function() { |
|||
Hash.sha256(str); |
|||
}).should.throw('sha256 hash must be of a buffer'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#sha256hmac', function() { |
|||
|
|||
it('should compute this known empty test vector correctly', function() { |
|||
var key = new Buffer(''); |
|||
var data = new Buffer(''); |
|||
Hash.sha256hmac(data, key).toString('hex').should.equal('b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad'); |
|||
}); |
|||
|
|||
it('should compute this known non-empty test vector correctly', function() { |
|||
var key = new Buffer('key'); |
|||
var data = new Buffer('The quick brown fox jumps over the lazy dog'); |
|||
Hash.sha256hmac(data, key).toString('hex').should.equal('f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#sha256sha256', function() { |
|||
|
|||
it('should calculate the hash of this buffer correctly', function() { |
|||
var hash = Hash.sha256sha256(buf); |
|||
hash.toString('hex').should.equal('be586c8b20dee549bdd66018c7a79e2b67bb88b7c7d428fa4c970976d2bec5ba'); |
|||
}); |
|||
|
|||
it('should throw an error when the input is not a buffer', function() { |
|||
(function() { |
|||
Hash.sha256sha256(str); |
|||
}).should.throw('sha256sha256 hash must be of a buffer'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#sha256ripemd160', function() { |
|||
|
|||
it('should calculate the hash of this buffer correctly', function() { |
|||
var hash = Hash.sha256ripemd160(buf); |
|||
hash.toString('hex').should.equal('7322e2bd8535e476c092934e16a6169ca9b707ec'); |
|||
}); |
|||
|
|||
it('should throw an error when the input is not a buffer', function() { |
|||
(function() { |
|||
Hash.sha256ripemd160(str); |
|||
}).should.throw('sha256ripemd160 hash must be of a buffer'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#ripemd160', function() { |
|||
|
|||
it('should calculate the hash of this buffer correctly', function() { |
|||
var hash = Hash.ripemd160(buf); |
|||
hash.toString('hex').should.equal('fa0f4565ff776fee0034c713cbf48b5ec06b7f5c'); |
|||
}); |
|||
|
|||
it('should throw an error when the input is not a buffer', function() { |
|||
(function() { |
|||
Hash.ripemd160(str); |
|||
}).should.throw('ripemd160 hash must be of a buffer'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#sha512', function() { |
|||
|
|||
it('should calculate the hash of this buffer correctly', function() { |
|||
var hash = Hash.sha512(buf); |
|||
hash.toString('hex').should.equal('c0530aa32048f4904ae162bc14b9eb535eab6c465e960130005feddb71613e7d62aea75f7d3333ba06e805fc8e45681454524e3f8050969fe5a5f7f2392e31d0'); |
|||
}); |
|||
|
|||
it('should throw an error when the input is not a buffer', function() { |
|||
(function() { |
|||
Hash.sha512(str); |
|||
}).should.throw('sha512 hash must be of a buffer'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe("#sha512hmac", function() { |
|||
|
|||
it('should calculate this known empty test vector correctly', function() { |
|||
var hex = 'b936cee86c9f87aa5d3c6f2e84cb5a4239a5fe50480a6ec66b70ab5b1f4ac6730c6c515421b327ec1d69402e53dfb49ad7381eb067b338fd7b0cb22247225d47'; |
|||
Hash.sha512hmac(new Buffer([]), new Buffer([])).toString('hex').should.equal(hex); |
|||
}); |
|||
|
|||
it('should calculate this known non-empty test vector correctly', function() { |
|||
var hex = 'c40bd7c15aa493b309c940e08a73ffbd28b2e4cb729eb94480d727e4df577b13cc403a78e6150d83595f3b17c4cc331f12ca5952691de3735a63c1d4c69a2bac'; |
|||
var data = new Buffer("test1"); |
|||
var key = new Buffer("test2"); |
|||
Hash.sha512hmac(data, key).toString('hex').should.equal(hex); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,18 @@ |
|||
<!DOCTYPE html> |
|||
<html> |
|||
<head> |
|||
<title>Mocha</title> |
|||
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> |
|||
<meta name="viewport" content="width=device-width, initial-scale=1.0"> |
|||
<link rel="stylesheet" href="../node_modules/mocha/mocha.css" /> |
|||
</head> |
|||
<body> |
|||
<div id="mocha"></div> |
|||
<script src="../node_modules/mocha/mocha.js"></script> |
|||
<script>mocha.setup('bdd')</script> |
|||
<script src="../browser/tests.js"></script> |
|||
<script> |
|||
mocha.run(); |
|||
</script> |
|||
</body> |
|||
</html> |
|||
@ -0,0 +1,39 @@ |
|||
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'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,165 @@ |
|||
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'); |
|||
|
|||
describe('Keypair', function() { |
|||
|
|||
it('should make a blank key', function() { |
|||
var key = new Keypair(); |
|||
should.exist(key); |
|||
}); |
|||
|
|||
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}); |
|||
should.exist(key); |
|||
should.exist(key.privkey); |
|||
should.exist(key.pubkey); |
|||
}); |
|||
|
|||
describe("#set", function() { |
|||
|
|||
it('should make a new priv and pub', function() { |
|||
should.exist(Keypair().set({privkey: Privkey()}).privkey); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromJSON', function() { |
|||
|
|||
it('should make a keypair from this json', function() { |
|||
var privkey = Privkey().fromRandom(); |
|||
var pubkey = Pubkey().fromPrivkey(privkey); |
|||
var keypair = Keypair().fromJSON({ |
|||
privkey: privkey.toJSON(), |
|||
pubkey: pubkey.toJSON() |
|||
}) |
|||
keypair.privkey.toString().should.equal(privkey.toString()); |
|||
keypair.pubkey.toString().should.equal(pubkey.toString()); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toJSON', function() { |
|||
|
|||
it('should make json from this keypair', function() { |
|||
var json = Keypair().fromRandom().toJSON(); |
|||
should.exist(json.privkey); |
|||
should.exist(json.pubkey); |
|||
var keypair = Keypair().fromJSON(json); |
|||
keypair.toJSON().privkey.toString().should.equal(json.privkey.toString()); |
|||
keypair.toJSON().pubkey.toString().should.equal(json.pubkey.toString()); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe("#fromPrivkey", function() { |
|||
|
|||
it('should make a new key from a privkey', function() { |
|||
should.exist(Keypair().fromPrivkey(Privkey().fromRandom()).pubkey); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe("#fromRandom", function() { |
|||
|
|||
it('should make a new priv and pub, should be compressed, mainnet', function() { |
|||
var key = new Keypair(); |
|||
key.fromRandom(); |
|||
should.exist(key.privkey); |
|||
should.exist(key.pubkey); |
|||
key.privkey.bn.gt(bn(0)).should.equal(true); |
|||
key.pubkey.point.getX().gt(bn(0)).should.equal(true); |
|||
key.pubkey.point.getY().gt(bn(0)).should.equal(true); |
|||
key.privkey.compressed.should.equal(true); |
|||
key.privkey.networkstr.should.equal('mainnet'); |
|||
key.pubkey.compressed.should.equal(true); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe("#fromString()", function() { |
|||
|
|||
it('should recover a key creating with toString', function() { |
|||
var key = new Keypair(); |
|||
key.fromRandom(); |
|||
var priv = key.privkey; |
|||
var pub = key.pubkey; |
|||
var str = key.toString(); |
|||
key.fromString(str); |
|||
should.exist(key.privkey); |
|||
should.exist(key.pubkey); |
|||
key.privkey.toString().should.equal(priv.toString()); |
|||
key.pubkey.toString().should.equal(pub.toString()); |
|||
}); |
|||
|
|||
it('should work with only Privkey set', function() { |
|||
var key = new Keypair(); |
|||
key.fromRandom(); |
|||
key.pubkey = undefined; |
|||
var priv = key.privkey; |
|||
var str = key.toString(); |
|||
key.fromString(str); |
|||
should.exist(key.privkey); |
|||
key.privkey.toString().should.equal(priv.toString()); |
|||
}); |
|||
|
|||
it('should work with only Pubkey set', function() { |
|||
var key = new Keypair(); |
|||
key.fromRandom(); |
|||
key.privkey = undefined; |
|||
var pub = key.pubkey; |
|||
var str = key.toString(); |
|||
key.fromString(str); |
|||
should.exist(key.pubkey); |
|||
key.pubkey.toString().should.equal(pub.toString()); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe("#privkey2pubkey", function() { |
|||
|
|||
it('should convert this known Privkey to known Pubkey', function() { |
|||
var privhex = '906977a061af29276e40bf377042ffbde414e496ae2260bbf1fa9d085637bfff'; |
|||
var pubhex = '02a1633cafcc01ebfb6d78e39f687a1f0995c62fc95f51ead10a02ee0be551b5dc'; |
|||
var key = new Keypair(); |
|||
key.privkey = new Privkey({bn: bn(new Buffer(privhex, 'hex'))}); |
|||
key.privkey2pubkey(); |
|||
key.pubkey.toString().should.equal(pubhex); |
|||
}); |
|||
|
|||
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.compressed = true; |
|||
key.privkey2pubkey(); |
|||
key.pubkey.compressed.should.equal(true); |
|||
}); |
|||
|
|||
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.compressed = false; |
|||
key.privkey2pubkey(); |
|||
key.pubkey.compressed.should.equal(false); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe("#toString()", function() { |
|||
|
|||
it('should exist', function() { |
|||
var key = new Keypair(); |
|||
key.fromRandom(); |
|||
should.exist(key.toString()); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,107 @@ |
|||
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); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,75 @@ |
|||
var should = require('chai').should(); |
|||
var Opcode = require('../lib/opcode'); |
|||
|
|||
describe('Opcode', function() { |
|||
|
|||
it('should create a new Opcode', function() { |
|||
var opcode = new Opcode(5); |
|||
}); |
|||
|
|||
it('should convert to a string with this handy syntax', function() { |
|||
Opcode(0).toString().should.equal('OP_0'); |
|||
Opcode(96).toString().should.equal('OP_16'); |
|||
Opcode(97).toString().should.equal('OP_NOP'); |
|||
}); |
|||
|
|||
it('should convert to a number with this handy syntax', function() { |
|||
Opcode('OP_0').toNumber().should.equal(0); |
|||
Opcode('OP_16').toNumber().should.equal(96); |
|||
Opcode('OP_NOP').toNumber().should.equal(97); |
|||
}); |
|||
|
|||
describe('#fromNumber', function() { |
|||
|
|||
it('should work for 0', function() { |
|||
Opcode().fromNumber(0).num.should.equal(0); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toNumber', function() { |
|||
|
|||
it('should work for 0', function() { |
|||
Opcode().fromNumber(0).toNumber().should.equal(0); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromString', function() { |
|||
|
|||
it('should work for OP_0', function() { |
|||
Opcode().fromString('OP_0').num.should.equal(0); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toString', function() { |
|||
|
|||
it('should work for OP_0', function() { |
|||
Opcode().fromString('OP_0').toString().should.equal('OP_0'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('@map', function() { |
|||
|
|||
it('should have a map containing 116 elements', function() { |
|||
var i = 0; |
|||
for (var key in Opcode.map) { |
|||
i++; |
|||
} |
|||
i.should.equal(116); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('@reverseMap', function() { |
|||
|
|||
it('should exist and have op 185', function() { |
|||
should.exist(Opcode.reverseMap); |
|||
Opcode.reverseMap[185].should.equal('OP_NOP10'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,117 @@ |
|||
var should = require('chai').should(); |
|||
var point = require('../lib/point'); |
|||
var BN = require('../lib/bn'); |
|||
|
|||
describe('Point', function() { |
|||
|
|||
it('should create a point', function() { |
|||
var p = point(); |
|||
should.exist(p); |
|||
}); |
|||
|
|||
it('should create a point when called with "new"', function() { |
|||
var p = new point(); |
|||
should.exist(p); |
|||
}); |
|||
|
|||
describe('#getX', function() { |
|||
|
|||
it('should return 0', function() { |
|||
var p = point(); |
|||
p.getX().toString().should.equal('0'); |
|||
}); |
|||
|
|||
it('should be convertable to a buffer', function() { |
|||
var p = point(); |
|||
p.getX().toBuffer({size: 32}).length.should.equal(32); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#getY', function() { |
|||
|
|||
it('should return 0', function() { |
|||
var p = point(); |
|||
p.getY().toString().should.equal('0'); |
|||
}); |
|||
|
|||
it('should be convertable to a buffer', function() { |
|||
var p = point(); |
|||
p.getY().toBuffer({size: 32}).length.should.equal(32); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#add', function() { |
|||
|
|||
it('should accurately add g to itself', function() { |
|||
var p1 = point.getG(); |
|||
var p2 = point.getG(); |
|||
var p3 = p1.add(p2); |
|||
p3.getX().toString().should.equal('89565891926547004231252920425935692360644145829622209833684329913297188986597'); |
|||
p3.getY().toString().should.equal('12158399299693830322967808612713398636155367887041628176798871954788371653930'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#mul', function() { |
|||
|
|||
it('should accurately multiply g by 2', function() { |
|||
var g = point.getG(); |
|||
var b = g.mul(BN(2)); |
|||
b.getX().toString().should.equal('89565891926547004231252920425935692360644145829622209833684329913297188986597'); |
|||
b.getY().toString().should.equal('12158399299693830322967808612713398636155367887041628176798871954788371653930'); |
|||
}); |
|||
|
|||
it('should accurately multiply g by n-1', function() { |
|||
var g = point.getG(); |
|||
var n = point.getN(); |
|||
var b = g.mul(n.sub(1)); |
|||
b.getX().toString().should.equal('55066263022277343669578718895168534326250603453777594175500187360389116729240'); |
|||
b.getY().toString().should.equal('83121579216557378445487899878180864668798711284981320763518679672151497189239'); |
|||
}); |
|||
|
|||
//not sure if this is technically accurate or not...
|
|||
//normally, you should always multiply g by something less than n
|
|||
//but it is the same result in OpenSSL
|
|||
it('should accurately multiply g by n+1', function() { |
|||
var g = point.getG(); |
|||
var n = point.getN(); |
|||
var b = g.mul(n.add(1)); |
|||
b.getX().toString().should.equal('55066263022277343669578718895168534326250603453777594175500187360389116729240'); |
|||
b.getY().toString().should.equal('32670510020758816978083085130507043184471273380659243275938904335757337482424'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('@fromX', function() { |
|||
|
|||
it('should return g', function() { |
|||
var g = point.getG(); |
|||
var p = point.fromX(false, g.getX()); |
|||
g.eq(p).should.equal(true); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#validate', function() { |
|||
|
|||
it('should validate this valid point', function() { |
|||
var x = BN().fromBuffer(new Buffer('ac242d242d23be966085a2b2b893d989f824e06c9ad0395a8a52f055ba39abb2', 'hex')); |
|||
var y = BN().fromBuffer(new Buffer('4836ab292c105a711ed10fcfd30999c31ff7c02456147747e03e739ad527c380', 'hex')); |
|||
var p = point(x, y); |
|||
should.exist(p.validate()); |
|||
}); |
|||
|
|||
it('should invalidate this invalid point', function() { |
|||
var x = BN().fromBuffer(new Buffer('ac242d242d23be966085a2b2b893d989f824e06c9ad0395a8a52f055ba39abb2', 'hex')); |
|||
var y = BN().fromBuffer(new Buffer('0000000000000000000000000000000000000000000000000000000000000000', 'hex')); |
|||
var p = point(x, y); |
|||
(function() { |
|||
p.validate(); |
|||
}).should.throw('Invalid y value of public key'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,120 @@ |
|||
var Privkey = require('../lib/privkey'); |
|||
var base58check = require('../lib/base58check'); |
|||
var BN = require('../lib/bn'); |
|||
var Point = require('../lib/point'); |
|||
var should = require('chai').should(); |
|||
|
|||
describe('Privkey', function() { |
|||
var hex = '96c132224121b509b7d0a16245e957d9192609c5637c6228311287b1be21627a'; |
|||
var buf = new Buffer(hex, 'hex'); |
|||
var enctestnet = 'cSdkPxkAjA4HDr5VHgsebAPDEh9Gyub4HK8UJr2DFGGqKKy4K5sG'; |
|||
var enctu = '92jJzK4tbURm1C7udQXxeCBvXHoHJstDXRxAMouPG1k1XUaXdsu'; |
|||
var encmainnet = 'L2Gkw3kKJ6N24QcDuH4XDqt9cTqsKTVNDGz1CRZhk9cq4auDUbJy'; |
|||
var encmu = '5JxgQaFM1FMd38cd14e3mbdxsdSa9iM2BV6DHBYsvGzxkTNQ7Un'; |
|||
|
|||
it('should create an empty private key', function() { |
|||
var privkey = new Privkey(); |
|||
should.exist(privkey); |
|||
}); |
|||
|
|||
it('should create a 0 private key with this convenience method', function() { |
|||
var bn = BN(0); |
|||
var privkey = new Privkey(bn); |
|||
privkey.bn.toString().should.equal(bn.toString()); |
|||
}); |
|||
|
|||
it('should create a mainnet private key', function() { |
|||
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}); |
|||
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}); |
|||
privkey.toString().should.equal(encmu); |
|||
}); |
|||
|
|||
describe('#set', function() { |
|||
|
|||
it('should set bn', function() { |
|||
should.exist(Privkey().set({bn: BN.fromBuffer(buf)}).bn); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromJSON', function() { |
|||
|
|||
it('should input this address correctly', function() { |
|||
var privkey = new Privkey(); |
|||
privkey.fromJSON(encmu); |
|||
privkey.toWIF().should.equal(encmu); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toString', function() { |
|||
|
|||
it('should output this address correctly', function() { |
|||
var privkey = new Privkey(); |
|||
privkey.fromJSON(encmu); |
|||
privkey.toJSON().should.equal(encmu); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromRandom', function() { |
|||
|
|||
it('should set bn gt 0 and lt n, and should be compressed', function() { |
|||
var privkey = Privkey().fromRandom(); |
|||
privkey.bn.gt(BN(0)).should.equal(true); |
|||
privkey.bn.lt(Point.getN()).should.equal(true); |
|||
privkey.compressed.should.equal(true); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromWIF', function() { |
|||
|
|||
it('should parse this compressed testnet address correctly', function() { |
|||
var privkey = new Privkey(); |
|||
privkey.fromWIF(encmainnet); |
|||
privkey.toWIF().should.equal(encmainnet); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toWIF', function() { |
|||
|
|||
it('should parse this compressed testnet address correctly', function() { |
|||
var privkey = new Privkey(); |
|||
privkey.fromWIF(enctestnet); |
|||
privkey.toWIF().should.equal(enctestnet); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromString', function() { |
|||
|
|||
it('should parse this uncompressed testnet address correctly', function() { |
|||
var privkey = new Privkey(); |
|||
privkey.fromString(enctu); |
|||
privkey.toWIF().should.equal(enctu); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toString', function() { |
|||
|
|||
it('should parse this uncompressed mainnet address correctly', function() { |
|||
var privkey = new Privkey(); |
|||
privkey.fromString(encmu); |
|||
privkey.toString().should.equal(encmu); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,205 @@ |
|||
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'); |
|||
|
|||
describe('Pubkey', function() { |
|||
|
|||
it('should create a blank public key', function() { |
|||
var pk = new Pubkey(); |
|||
should.exist(pk); |
|||
}); |
|||
|
|||
it('should create a public key with a point', function() { |
|||
var p = Point(); |
|||
var pk = new Pubkey({point: p}); |
|||
should.exist(pk.point); |
|||
}); |
|||
|
|||
it('should create a public key with a point with this convenient method', function() { |
|||
var p = Point(); |
|||
var pk = new Pubkey(p); |
|||
should.exist(pk.point); |
|||
pk.point.toString().should.equal(p.toString()); |
|||
}); |
|||
|
|||
describe('#set', function() { |
|||
|
|||
it('should make a public key from a point', function() { |
|||
should.exist(Pubkey().set({point: Point.getG()}).point); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromJSON', function() { |
|||
|
|||
it('should input this public key', function() { |
|||
var pk = new Pubkey(); |
|||
pk.fromJSON('041ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a7baad41d04514751e6851f5304fd243751703bed21b914f6be218c0fa354a341'); |
|||
pk.point.getX().toString(16).should.equal('1ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a'); |
|||
pk.point.getY().toString(16).should.equal('7baad41d04514751e6851f5304fd243751703bed21b914f6be218c0fa354a341'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toJSON', function() { |
|||
|
|||
it('should output this pubkey', function() { |
|||
var pk = new Pubkey(); |
|||
var hex = '041ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a7baad41d04514751e6851f5304fd243751703bed21b914f6be218c0fa354a341'; |
|||
pk.fromJSON(hex).toJSON().should.equal(hex); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromPrivkey', function() { |
|||
|
|||
it('should make a public key from a privkey', function() { |
|||
should.exist(Pubkey().fromPrivkey(Privkey().fromRandom())); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromBuffer', function() { |
|||
|
|||
it('should parse this uncompressed public key', function() { |
|||
var pk = new Pubkey(); |
|||
pk.fromBuffer(new Buffer('041ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a7baad41d04514751e6851f5304fd243751703bed21b914f6be218c0fa354a341', 'hex')); |
|||
pk.point.getX().toString(16).should.equal('1ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a'); |
|||
pk.point.getY().toString(16).should.equal('7baad41d04514751e6851f5304fd243751703bed21b914f6be218c0fa354a341'); |
|||
}); |
|||
|
|||
it('should parse this compressed public key', function() { |
|||
var pk = new Pubkey(); |
|||
pk.fromBuffer(new Buffer('031ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a', 'hex')); |
|||
pk.point.getX().toString(16).should.equal('1ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a'); |
|||
pk.point.getY().toString(16).should.equal('7baad41d04514751e6851f5304fd243751703bed21b914f6be218c0fa354a341'); |
|||
}); |
|||
|
|||
it('should throw an error on this invalid public key', function() { |
|||
var pk = new Pubkey(); |
|||
(function() { |
|||
pk.fromBuffer(new Buffer('091ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a', 'hex')); |
|||
}).should.throw(); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromDER', function() { |
|||
|
|||
it('should parse this uncompressed public key', function() { |
|||
var pk = new Pubkey(); |
|||
pk.fromDER(new Buffer('041ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a7baad41d04514751e6851f5304fd243751703bed21b914f6be218c0fa354a341', 'hex')); |
|||
pk.point.getX().toString(16).should.equal('1ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a'); |
|||
pk.point.getY().toString(16).should.equal('7baad41d04514751e6851f5304fd243751703bed21b914f6be218c0fa354a341'); |
|||
}); |
|||
|
|||
it('should parse this compressed public key', function() { |
|||
var pk = new Pubkey(); |
|||
pk.fromDER(new Buffer('031ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a', 'hex')); |
|||
pk.point.getX().toString(16).should.equal('1ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a'); |
|||
pk.point.getY().toString(16).should.equal('7baad41d04514751e6851f5304fd243751703bed21b914f6be218c0fa354a341'); |
|||
}); |
|||
|
|||
it('should throw an error on this invalid public key', function() { |
|||
var pk = new Pubkey(); |
|||
(function() { |
|||
pk.fromDER(new Buffer('091ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a', 'hex')); |
|||
}).should.throw(); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromString', function() { |
|||
|
|||
it('should parse this known valid public key', function() { |
|||
pk = new Pubkey(); |
|||
pk.fromString('041ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a7baad41d04514751e6851f5304fd243751703bed21b914f6be218c0fa354a341'); |
|||
pk.point.getX().toString(16).should.equal('1ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a'); |
|||
pk.point.getY().toString(16).should.equal('7baad41d04514751e6851f5304fd243751703bed21b914f6be218c0fa354a341'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromX', function() { |
|||
|
|||
it('should create this known public key', function() { |
|||
var x = Bn.fromBuffer(new Buffer('1ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a', 'hex')); |
|||
var pk = new Pubkey(); |
|||
pk.fromX(true, x); |
|||
pk.point.getX().toString(16).should.equal('1ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a'); |
|||
pk.point.getY().toString(16).should.equal('7baad41d04514751e6851f5304fd243751703bed21b914f6be218c0fa354a341'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toBuffer', function() { |
|||
|
|||
it('should return this compressed DER format', function() { |
|||
var x = Bn.fromBuffer(new Buffer('1ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a', 'hex')); |
|||
var pk = new Pubkey(); |
|||
pk.fromX(true, x); |
|||
pk.toBuffer().toString('hex').should.equal('031ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toDER', function() { |
|||
|
|||
it('should return this compressed DER format', function() { |
|||
var x = Bn.fromBuffer(new Buffer('1ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a', 'hex')); |
|||
var pk = new Pubkey(); |
|||
pk.fromX(true, x); |
|||
pk.toDER(true).toString('hex').should.equal('031ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a'); |
|||
}); |
|||
|
|||
it('should return this uncompressed DER format', function() { |
|||
var x = Bn.fromBuffer(new Buffer('1ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a', 'hex')); |
|||
var pk = new Pubkey(); |
|||
pk.fromX(true, x); |
|||
pk.toDER(false).toString('hex').should.equal('041ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a7baad41d04514751e6851f5304fd243751703bed21b914f6be218c0fa354a341'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toString', function() { |
|||
|
|||
it('should print this known public key', function() { |
|||
var hex = '031ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a'; |
|||
var pk = new Pubkey(); |
|||
pk.fromString(hex); |
|||
pk.toString().should.equal(hex); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#validate', function() { |
|||
|
|||
it('should not throw an error if pubkey is valid', function() { |
|||
var hex = '031ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a'; |
|||
var pk = new Pubkey(); |
|||
pk.fromString(hex); |
|||
should.exist(pk.validate()); |
|||
}); |
|||
|
|||
it('should not throw an error if pubkey is invalid', function() { |
|||
var hex = '041ff0fe0f7b15ffaa85ff9f4744d539139c252a49710fb053bb9f2b933173ff9a0000000000000000000000000000000000000000000000000000000000000000'; |
|||
var pk = new Pubkey(); |
|||
pk.fromString(hex); |
|||
(function() { |
|||
pk.validate(); |
|||
}).should.throw('Invalid y value of public key'); |
|||
}); |
|||
|
|||
it('should not throw an error if pubkey is infinity', function() { |
|||
var pk = new Pubkey(); |
|||
pk.point = Point.getG().mul(Point.getN()); |
|||
(function() { |
|||
pk.validate(); |
|||
}).should.throw('Point cannot be equal to Infinity'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,61 @@ |
|||
var should = require('chai').should(); |
|||
var Random = require('../lib/random'); |
|||
|
|||
describe('Random', function() { |
|||
|
|||
describe('@getRandomBuffer', function() { |
|||
|
|||
it('should return a buffer', function() { |
|||
var bytes = Random.getRandomBuffer(8); |
|||
bytes.length.should.equal(8); |
|||
Buffer.isBuffer(bytes).should.equal(true); |
|||
}); |
|||
|
|||
it('should not equate two 256 bit random buffers', function() { |
|||
var bytes1 = Random.getRandomBuffer(32); |
|||
var bytes2 = Random.getRandomBuffer(32); |
|||
bytes1.toString('hex').should.not.equal(bytes2.toString('hex')); |
|||
}); |
|||
|
|||
it('should generate 100 8 byte buffers in a row that are not equal', 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 (var j = i + 1; j < 100; j++) |
|||
hexs[i].should.not.equal(hexs[j]); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('@getPseudoRandomBuffer', function() { |
|||
|
|||
it('should generate 7 random bytes', function() { |
|||
var buf = Random.getPseudoRandomBuffer(7); |
|||
buf.length.should.equal(7); |
|||
}); |
|||
|
|||
it('should generate 8 random bytes', function() { |
|||
var buf = Random.getPseudoRandomBuffer(8); |
|||
buf.length.should.equal(8); |
|||
}); |
|||
|
|||
it('should generate 9 random bytes', function() { |
|||
var buf = Random.getPseudoRandomBuffer(9); |
|||
buf.length.should.equal(9); |
|||
}); |
|||
|
|||
it('should generate 90 random bytes', function() { |
|||
var buf = Random.getPseudoRandomBuffer(90); |
|||
buf.length.should.equal(90); |
|||
}); |
|||
|
|||
it('should generate two 8 byte buffers that are not equal', function() { |
|||
var buf1 = Random.getPseudoRandomBuffer(8); |
|||
var buf2 = Random.getPseudoRandomBuffer(8); |
|||
buf1.toString('hex').should.not.equal(buf2.toString('hex')); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,308 @@ |
|||
var Script = require('../lib/script'); |
|||
var should = require('chai').should(); |
|||
var Opcode = require('../lib/opcode'); |
|||
var BufferReader = require('../lib/bufferreader'); |
|||
var BufferWriter = require('../lib/bufferwriter'); |
|||
|
|||
describe('Script', function() { |
|||
|
|||
it('should make a new script', function() { |
|||
var script = new Script(); |
|||
}); |
|||
|
|||
describe('#fromBuffer', function() { |
|||
|
|||
it('should parse this buffer containing an OP code', function() { |
|||
var buf = new Buffer(1); |
|||
buf[0] = Opcode('OP_0').toNumber(); |
|||
var script = Script().fromBuffer(buf); |
|||
script.chunks.length.should.equal(1); |
|||
script.chunks[0].should.equal(buf[0]); |
|||
}); |
|||
|
|||
it('should parse this buffer containing another OP code', function() { |
|||
var buf = new Buffer(1); |
|||
buf[0] = Opcode('OP_CHECKMULTISIG').toNumber(); |
|||
var script = Script().fromBuffer(buf); |
|||
script.chunks.length.should.equal(1); |
|||
script.chunks[0].should.equal(buf[0]); |
|||
}); |
|||
|
|||
it('should parse this buffer containing three bytes of data', function() { |
|||
var buf = new Buffer([3, 1, 2, 3]); |
|||
var script = Script().fromBuffer(buf); |
|||
script.chunks.length.should.equal(1); |
|||
script.chunks[0].buf.toString('hex').should.equal('010203'); |
|||
}); |
|||
|
|||
it('should parse this buffer containing OP_PUSHDATA1 and three bytes of data', function() { |
|||
var buf = new Buffer([0, 0, 1, 2, 3]); |
|||
buf[0] = Opcode('OP_PUSHDATA1').toNumber(); |
|||
buf.writeUInt8(3, 1); |
|||
var script = Script().fromBuffer(buf); |
|||
script.chunks.length.should.equal(1); |
|||
script.chunks[0].buf.toString('hex').should.equal('010203'); |
|||
}); |
|||
|
|||
it('should parse this buffer containing OP_PUSHDATA2 and three bytes of data', function() { |
|||
var buf = new Buffer([0, 0, 0, 1, 2, 3]); |
|||
buf[0] = Opcode('OP_PUSHDATA2').toNumber(); |
|||
buf.writeUInt16LE(3, 1); |
|||
var script = Script().fromBuffer(buf); |
|||
script.chunks.length.should.equal(1); |
|||
script.chunks[0].buf.toString('hex').should.equal('010203'); |
|||
}); |
|||
|
|||
it('should parse this buffer containing OP_PUSHDATA4 and three bytes of data', function() { |
|||
var buf = new Buffer([0, 0, 0, 0, 0, 1, 2, 3]); |
|||
buf[0] = Opcode('OP_PUSHDATA4').toNumber(); |
|||
buf.writeUInt16LE(3, 1); |
|||
var script = Script().fromBuffer(buf); |
|||
script.chunks.length.should.equal(1); |
|||
script.chunks[0].buf.toString('hex').should.equal('010203'); |
|||
}); |
|||
|
|||
it('should parse this buffer an OP code, data, and another OP code', function() { |
|||
var buf = new Buffer([0, 0, 0, 0, 0, 0, 1, 2, 3, 0]); |
|||
buf[0] = Opcode('OP_0').toNumber(); |
|||
buf[1] = Opcode('OP_PUSHDATA4').toNumber(); |
|||
buf.writeUInt16LE(3, 2); |
|||
buf[buf.length - 1] = Opcode('OP_0').toNumber(); |
|||
var script = Script().fromBuffer(buf); |
|||
script.chunks.length.should.equal(3); |
|||
script.chunks[0].should.equal(buf[0]); |
|||
script.chunks[1].buf.toString('hex').should.equal('010203'); |
|||
script.chunks[2].should.equal(buf[buf.length - 1]); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toBuffer', function() { |
|||
|
|||
it('should output this buffer containing an OP code', function() { |
|||
var buf = new Buffer(1); |
|||
buf[0] = Opcode('OP_0').toNumber(); |
|||
var script = Script().fromBuffer(buf); |
|||
script.chunks.length.should.equal(1); |
|||
script.chunks[0].should.equal(buf[0]); |
|||
script.toBuffer().toString('hex').should.equal(buf.toString('hex')); |
|||
}); |
|||
|
|||
it('should output this buffer containing another OP code', function() { |
|||
var buf = new Buffer(1); |
|||
buf[0] = Opcode('OP_CHECKMULTISIG').toNumber(); |
|||
var script = Script().fromBuffer(buf); |
|||
script.chunks.length.should.equal(1); |
|||
script.chunks[0].should.equal(buf[0]); |
|||
script.toBuffer().toString('hex').should.equal(buf.toString('hex')); |
|||
}); |
|||
|
|||
it('should output this buffer containing three bytes of data', function() { |
|||
var buf = new Buffer([3, 1, 2, 3]); |
|||
var script = Script().fromBuffer(buf); |
|||
script.chunks.length.should.equal(1); |
|||
script.chunks[0].buf.toString('hex').should.equal('010203'); |
|||
script.toBuffer().toString('hex').should.equal(buf.toString('hex')); |
|||
}); |
|||
|
|||
it('should output this buffer containing OP_PUSHDATA1 and three bytes of data', function() { |
|||
var buf = new Buffer([0, 0, 1, 2, 3]); |
|||
buf[0] = Opcode('OP_PUSHDATA1').toNumber(); |
|||
buf.writeUInt8(3, 1); |
|||
var script = Script().fromBuffer(buf); |
|||
script.chunks.length.should.equal(1); |
|||
script.chunks[0].buf.toString('hex').should.equal('010203'); |
|||
script.toBuffer().toString('hex').should.equal(buf.toString('hex')); |
|||
}); |
|||
|
|||
it('should output this buffer containing OP_PUSHDATA2 and three bytes of data', function() { |
|||
var buf = new Buffer([0, 0, 0, 1, 2, 3]); |
|||
buf[0] = Opcode('OP_PUSHDATA2').toNumber(); |
|||
buf.writeUInt16LE(3, 1); |
|||
var script = Script().fromBuffer(buf); |
|||
script.chunks.length.should.equal(1); |
|||
script.chunks[0].buf.toString('hex').should.equal('010203'); |
|||
script.toBuffer().toString('hex').should.equal(buf.toString('hex')); |
|||
}); |
|||
|
|||
it('should output this buffer containing OP_PUSHDATA4 and three bytes of data', function() { |
|||
var buf = new Buffer([0, 0, 0, 0, 0, 1, 2, 3]); |
|||
buf[0] = Opcode('OP_PUSHDATA4').toNumber(); |
|||
buf.writeUInt16LE(3, 1); |
|||
var script = Script().fromBuffer(buf); |
|||
script.chunks.length.should.equal(1); |
|||
script.chunks[0].buf.toString('hex').should.equal('010203'); |
|||
script.toBuffer().toString('hex').should.equal(buf.toString('hex')); |
|||
}); |
|||
|
|||
it('should output this buffer an OP code, data, and another OP code', function() { |
|||
var buf = new Buffer([0, 0, 0, 0, 0, 0, 1, 2, 3, 0]); |
|||
buf[0] = Opcode('OP_0').toNumber(); |
|||
buf[1] = Opcode('OP_PUSHDATA4').toNumber(); |
|||
buf.writeUInt16LE(3, 2); |
|||
buf[buf.length - 1] = Opcode('OP_0').toNumber(); |
|||
var script = Script().fromBuffer(buf); |
|||
script.chunks.length.should.equal(3); |
|||
script.chunks[0].should.equal(buf[0]); |
|||
script.chunks[1].buf.toString('hex').should.equal('010203'); |
|||
script.chunks[2].should.equal(buf[buf.length - 1]); |
|||
script.toBuffer().toString('hex').should.equal(buf.toString('hex')); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromString', function() { |
|||
|
|||
it('should parse these known scripts', function() { |
|||
Script().fromString('OP_0 OP_PUSHDATA4 3 0x010203 OP_0').toString().should.equal('OP_0 OP_PUSHDATA4 3 0x010203 OP_0'); |
|||
Script().fromString('OP_0 OP_PUSHDATA2 3 0x010203 OP_0').toString().should.equal('OP_0 OP_PUSHDATA2 3 0x010203 OP_0'); |
|||
Script().fromString('OP_0 OP_PUSHDATA1 3 0x010203 OP_0').toString().should.equal('OP_0 OP_PUSHDATA1 3 0x010203 OP_0'); |
|||
Script().fromString('OP_0 3 0x010203 OP_0').toString().should.equal('OP_0 3 0x010203 OP_0'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toString', function() { |
|||
|
|||
it('should output this buffer an OP code, data, and another OP code', function() { |
|||
var buf = new Buffer([0, 0, 0, 0, 0, 0, 1, 2, 3, 0]); |
|||
buf[0] = Opcode('OP_0').toNumber(); |
|||
buf[1] = Opcode('OP_PUSHDATA4').toNumber(); |
|||
buf.writeUInt16LE(3, 2); |
|||
buf[buf.length - 1] = Opcode('OP_0').toNumber(); |
|||
var script = Script().fromBuffer(buf); |
|||
script.chunks.length.should.equal(3); |
|||
script.chunks[0].should.equal(buf[0]); |
|||
script.chunks[1].buf.toString('hex').should.equal('010203'); |
|||
script.chunks[2].should.equal(buf[buf.length - 1]); |
|||
script.toString().toString('hex').should.equal('OP_0 OP_PUSHDATA4 3 0x010203 OP_0'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromJSON', function() { |
|||
|
|||
it('should parse this known script', function() { |
|||
Script().fromJSON('OP_0 OP_PUSHDATA4 3 0x010203 OP_0').toString().should.equal('OP_0 OP_PUSHDATA4 3 0x010203 OP_0'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toJSON', function() { |
|||
|
|||
it('should output this known script', function() { |
|||
Script().fromString('OP_0 OP_PUSHDATA4 3 0x010203 OP_0').toJSON().should.equal('OP_0 OP_PUSHDATA4 3 0x010203 OP_0'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#isOpReturn', function() { |
|||
|
|||
it('should know this is a (blank) OP_RETURN script', function() { |
|||
Script('OP_RETURN').isOpReturn().should.equal(true); |
|||
}); |
|||
|
|||
it('should know this is an OP_RETURN script', function() { |
|||
var buf = new Buffer(40); |
|||
buf.fill(0); |
|||
Script('OP_RETURN 40 0x' + buf.toString('hex')).isOpReturn().should.equal(true); |
|||
}); |
|||
|
|||
it('should know this is not an OP_RETURN script', function() { |
|||
var buf = new Buffer(40); |
|||
buf.fill(0); |
|||
Script('OP_CHECKMULTISIG 40 0x' + buf.toString('hex')).isOpReturn().should.equal(false); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#isPubkeyhashIn', function() { |
|||
|
|||
it('should classify this known pubkeyhashin', function() { |
|||
Script('73 0x3046022100bb3c194a30e460d81d34be0a230179c043a656f67e3c5c8bf47eceae7c4042ee0221008bf54ca11b2985285be0fd7a212873d243e6e73f5fad57e8eb14c4f39728b8c601 65 0x04e365859b3c78a8b7c202412b949ebca58e147dba297be29eee53cd3e1d300a6419bc780cc9aec0dc94ed194e91c8f6433f1b781ee00eac0ead2aae1e8e0712c6').isPubkeyhashIn().should.equal(true); |
|||
}); |
|||
|
|||
it('should classify this known non-pubkeyhashin', function() { |
|||
Script('73 0x3046022100bb3c194a30e460d81d34be0a230179c043a656f67e3c5c8bf47eceae7c4042ee0221008bf54ca11b2985285be0fd7a212873d243e6e73f5fad57e8eb14c4f39728b8c601 65 0x04e365859b3c78a8b7c202412b949ebca58e147dba297be29eee53cd3e1d300a6419bc780cc9aec0dc94ed194e91c8f6433f1b781ee00eac0ead2aae1e8e0712c6 OP_CHECKSIG').isPubkeyhashIn().should.equal(false); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#isPubkeyhashOut', function() { |
|||
|
|||
it('should classify this known pubkeyhashout as pubkeyhashout', function() { |
|||
Script('OP_DUP OP_HASH160 20 0000000000000000000000000000000000000000 OP_EQUALVERIFY OP_CHECKSIG').isPubkeyhashOut().should.equal(true); |
|||
}); |
|||
|
|||
it('should classify this known non-pubkeyhashout as not pubkeyhashout', function() { |
|||
Script('OP_DUP OP_HASH160 20 0000000000000000000000000000000000000000').isPubkeyhashOut().should.equal(false) |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#isScripthashIn', function() { |
|||
|
|||
it('should classify this known scripthashin', function() { |
|||
Script('20 0000000000000000000000000000000000000000').isScripthashIn().should.equal(true); |
|||
}); |
|||
|
|||
it('should classify this known non-scripthashin', function() { |
|||
Script('20 0000000000000000000000000000000000000000 OP_CHECKSIG').isScripthashIn().should.equal(false); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#isScripthashOut', function() { |
|||
|
|||
it('should classify this known pubkeyhashout as pubkeyhashout', function() { |
|||
Script('OP_HASH160 20 0x0000000000000000000000000000000000000000 OP_EQUAL').isScripthashOut().should.equal(true); |
|||
}); |
|||
|
|||
it('should classify these known non-pubkeyhashout as not pubkeyhashout', function() { |
|||
Script('OP_HASH160 20 0x0000000000000000000000000000000000000000 OP_EQUAL OP_EQUAL').isScripthashOut().should.equal(false); |
|||
Script('OP_HASH160 21 0x000000000000000000000000000000000000000000 OP_EQUAL').isScripthashOut().should.equal(false); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#writeOp', function() { |
|||
|
|||
it('should write these ops', function() { |
|||
Script().writeOp('OP_CHECKMULTISIG').toString().should.equal('OP_CHECKMULTISIG'); |
|||
Script().writeOp(Opcode.map.OP_CHECKMULTISIG).toString().should.equal('OP_CHECKMULTISIG'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#writeBuffer', function() { |
|||
|
|||
it('should write these push data', function() { |
|||
var buf = new Buffer(1); |
|||
buf.fill(0); |
|||
Script().writeBuffer(buf).toString().should.equal('1 0x00'); |
|||
buf = new Buffer(255); |
|||
buf.fill(0); |
|||
Script().writeBuffer(buf).toString().should.equal('OP_PUSHDATA1 255 0x' + buf.toString('hex')); |
|||
buf = new Buffer(256); |
|||
buf.fill(0); |
|||
Script().writeBuffer(buf).toString().should.equal('OP_PUSHDATA2 256 0x' + buf.toString('hex')); |
|||
buf = new Buffer(Math.pow(2, 16)); |
|||
buf.fill(0); |
|||
Script().writeBuffer(buf).toString().should.equal('OP_PUSHDATA4 ' + Math.pow(2, 16) + ' 0x' + buf.toString('hex')); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#write', function() { |
|||
|
|||
it('should write both pushdata and non-pushdata chunks', function() { |
|||
Script().write('OP_CHECKMULTISIG').toString().should.equal('OP_CHECKMULTISIG'); |
|||
Script().write(Opcode.map.OP_CHECKMULTISIG).toString().should.equal('OP_CHECKMULTISIG'); |
|||
var buf = new Buffer(1); |
|||
buf.fill(0); |
|||
Script().write(buf).toString().should.equal('1 0x00'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,149 @@ |
|||
var BN = require('../lib/bn'); |
|||
var should = require('chai').should(); |
|||
var Signature = require('../lib/signature'); |
|||
|
|||
describe('Signature', function() { |
|||
|
|||
it('should make a blank signature', function() { |
|||
var sig = new Signature(); |
|||
should.exist(sig); |
|||
}); |
|||
|
|||
it('should work with conveniently setting r, s', function() { |
|||
var r = BN(); |
|||
var s = BN(); |
|||
var sig = new Signature(r, s); |
|||
should.exist(sig); |
|||
sig.r.toString().should.equal(r.toString()); |
|||
sig.s.toString().should.equal(s.toString()); |
|||
}); |
|||
|
|||
describe('#set', function() { |
|||
|
|||
it('should set compressed', function() { |
|||
should.exist(Signature().set({compressed: true})); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromCompact', function() { |
|||
|
|||
it('should create a signature from a compressed signature', function() { |
|||
var blank = new Buffer(32); |
|||
blank.fill(0); |
|||
var compressed = Buffer.concat([ |
|||
new Buffer([0 + 27 + 4]), |
|||
blank, |
|||
blank |
|||
]); |
|||
var sig = new Signature(); |
|||
sig.fromCompact(compressed); |
|||
sig.r.cmp(0).should.equal(0); |
|||
sig.s.cmp(0).should.equal(0); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromDER', function() { |
|||
|
|||
var buf = new Buffer('3044022075fc517e541bd54769c080b64397e32161c850f6c1b2b67a5c433affbb3e62770220729e85cc46ffab881065ec07694220e71d4df9b2b8c8fd12c3122cf3a5efbcf2', 'hex'); |
|||
|
|||
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'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromString', function() { |
|||
|
|||
var buf = new Buffer('3044022075fc517e541bd54769c080b64397e32161c850f6c1b2b67a5c433affbb3e62770220729e85cc46ffab881065ec07694220e71d4df9b2b8c8fd12c3122cf3a5efbcf2', 'hex'); |
|||
|
|||
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'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#parseDER', function() { |
|||
|
|||
it('should parse this signature generated in node', function() { |
|||
var sighex = '30450221008bab1f0a2ff2f9cb8992173d8ad73c229d31ea8e10b0f4d4ae1a0d8ed76021fa02200993a6ec81755b9111762fc2cf8e3ede73047515622792110867d12654275e72'; |
|||
var sig = new Buffer(sighex, 'hex'); |
|||
var parsed = Signature.parseDER(sig); |
|||
parsed.header.should.equal(0x30) |
|||
parsed.length.should.equal(69) |
|||
parsed.rlength.should.equal(33); |
|||
parsed.rneg.should.equal(true); |
|||
parsed.rbuf.toString('hex').should.equal('008bab1f0a2ff2f9cb8992173d8ad73c229d31ea8e10b0f4d4ae1a0d8ed76021fa'); |
|||
parsed.r.toString().should.equal('63173831029936981022572627018246571655303050627048489594159321588908385378810'); |
|||
parsed.slength.should.equal(32); |
|||
parsed.sneg.should.equal(false); |
|||
parsed.sbuf.toString('hex').should.equal('0993a6ec81755b9111762fc2cf8e3ede73047515622792110867d12654275e72'); |
|||
parsed.s.toString().should.equal('4331694221846364448463828256391194279133231453999942381442030409253074198130'); |
|||
}); |
|||
|
|||
it('should parse this 69 byte signature', function() { |
|||
var sighex = '3043021f59e4705959cc78acbfcf8bd0114e9cc1b389a4287fb33152b73a38c319b50302202f7428a27284c757e409bf41506183e9e49dfb54d5063796dfa0d403a4deccfa'; |
|||
var sig = new Buffer(sighex, 'hex'); |
|||
var parsed = Signature.parseDER(sig); |
|||
parsed.header.should.equal(0x30) |
|||
parsed.length.should.equal(67) |
|||
parsed.rlength.should.equal(31); |
|||
parsed.rneg.should.equal(false); |
|||
parsed.rbuf.toString('hex').should.equal('59e4705959cc78acbfcf8bd0114e9cc1b389a4287fb33152b73a38c319b503'); |
|||
parsed.r.toString().should.equal('158826015856106182499128681792325160381907915189052224498209222621383996675'); |
|||
parsed.slength.should.equal(32); |
|||
parsed.sneg.should.equal(false); |
|||
parsed.sbuf.toString('hex').should.equal('2f7428a27284c757e409bf41506183e9e49dfb54d5063796dfa0d403a4deccfa'); |
|||
parsed.s.toString().should.equal('21463938592353267769710297084836796652964571266930856168996063301532842380538'); |
|||
}); |
|||
|
|||
it('should parse this 68 byte signature', function() { |
|||
var sighex = '3042021e17cfe77536c3fb0526bd1a72d7a8e0973f463add210be14063c8a9c37632022061bfa677f825ded82ba0863fb0c46ca1388dd3e647f6a93c038168b59d131a51'; |
|||
var sig = new Buffer(sighex, 'hex'); |
|||
var parsed = Signature.parseDER(sig); |
|||
parsed.header.should.equal(0x30) |
|||
parsed.length.should.equal(66) |
|||
parsed.rlength.should.equal(30); |
|||
parsed.rneg.should.equal(false); |
|||
parsed.rbuf.toString('hex').should.equal('17cfe77536c3fb0526bd1a72d7a8e0973f463add210be14063c8a9c37632'); |
|||
parsed.r.toString().should.equal('164345250294671732127776123343329699648286106708464198588053542748255794'); |
|||
parsed.slength.should.equal(32); |
|||
parsed.sneg.should.equal(false); |
|||
parsed.sbuf.toString('hex').should.equal('61bfa677f825ded82ba0863fb0c46ca1388dd3e647f6a93c038168b59d131a51'); |
|||
parsed.s.toString().should.equal('44212963026209759051804639008236126356702363229859210154760104982946304432721'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toDER', 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 der = sig.toDER(r, s); |
|||
der.toString('hex').should.equal('30450221008bab1f0a2ff2f9cb8992173d8ad73c229d31ea8e10b0f4d4ae1a0d8ed76021fa02200993a6ec81755b9111762fc2cf8e3ede73047515622792110867d12654275e72'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toString', 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 hex = sig.toString(); |
|||
hex.should.equal('30450221008bab1f0a2ff2f9cb8992173d8ad73c229d31ea8e10b0f4d4ae1a0d8ed76021fa02200993a6ec81755b9111762fc2cf8e3ede73047515622792110867d12654275e72'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,149 @@ |
|||
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(''); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,138 @@ |
|||
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); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,139 @@ |
|||
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); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,68 @@ |
|||
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); |
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,195 @@ |
|||
var Varint = require('../lib/varint'); |
|||
var Transaction = require('../lib/transaction'); |
|||
var Txin = require('../lib/txin'); |
|||
var Txout = require('../lib/txout'); |
|||
var should = require('chai').should(); |
|||
var BufferReader = require('../lib/bufferreader'); |
|||
var BufferWriter = require('../lib/bufferwriter'); |
|||
|
|||
describe('Transaction', function() { |
|||
|
|||
var txin = Txin().fromBuffer(new Buffer('00000000000000000000000000000000000000000000000000000000000000000000000001ae00000000', 'hex')); |
|||
var txout = Txout().fromBuffer(new Buffer('050000000000000001ae', 'hex')); |
|||
var tx = Transaction().set({ |
|||
version: 0, |
|||
txinsvi: Varint(1), |
|||
txins: [txin], |
|||
txoutsvi: Varint(1), |
|||
txouts: [txout], |
|||
nlocktime: 0 |
|||
}); |
|||
var txhex = '000000000100000000000000000000000000000000000000000000000000000000000000000000000001ae0000000001050000000000000001ae00000000'; |
|||
var txbuf = new Buffer(txhex, 'hex'); |
|||
|
|||
var tx2idhex = '8c9aa966d35bfeaf031409e0001b90ccdafd8d859799eb945a3c515b8260bcf2'; |
|||
var tx2hex = '01000000029e8d016a7b0dc49a325922d05da1f916d1e4d4f0cb840c9727f3d22ce8d1363f000000008c493046022100e9318720bee5425378b4763b0427158b1051eec8b08442ce3fbfbf7b30202a44022100d4172239ebd701dae2fbaaccd9f038e7ca166707333427e3fb2a2865b19a7f27014104510c67f46d2cbb29476d1f0b794be4cb549ea59ab9cc1e731969a7bf5be95f7ad5e7f904e5ccf50a9dc1714df00fbeb794aa27aaff33260c1032d931a75c56f2ffffffffa3195e7a1ab665473ff717814f6881485dc8759bebe97e31c301ffe7933a656f020000008b48304502201c282f35f3e02a1f32d2089265ad4b561f07ea3c288169dedcf2f785e6065efa022100e8db18aadacb382eed13ee04708f00ba0a9c40e3b21cf91da8859d0f7d99e0c50141042b409e1ebbb43875be5edde9c452c82c01e3903d38fa4fd89f3887a52cb8aea9dc8aec7e2c9d5b3609c03eb16259a2537135a1bf0f9c5fbbcbdbaf83ba402442ffffffff02206b1000000000001976a91420bb5c3bfaef0231dc05190e7f1c8e22e098991e88acf0ca0100000000001976a9149e3e2d23973a04ec1b02be97c30ab9f2f27c3b2c88ac00000000'; |
|||
var tx2buf = new Buffer(tx2hex, 'hex'); |
|||
|
|||
it('should make a new transaction', function() { |
|||
var tx = new Transaction(); |
|||
should.exist(tx); |
|||
tx = Transaction(); |
|||
should.exist(tx); |
|||
|
|||
Transaction(txbuf).toBuffer().toString('hex').should.equal(txhex); |
|||
|
|||
//should set known defaults
|
|||
tx.version.should.equal(1); |
|||
tx.txinsvi.toNumber().should.equal(0); |
|||
tx.txins.length.should.equal(0); |
|||
tx.txoutsvi.toNumber().should.equal(0); |
|||
tx.txouts.length.should.equal(0); |
|||
tx.nlocktime.should.equal(0xffffffff); |
|||
}); |
|||
|
|||
describe('#initialize', function() { |
|||
|
|||
it('should set these known defaults', function() { |
|||
var tx = new Transaction(); |
|||
tx.initialize(); |
|||
tx.version.should.equal(1); |
|||
tx.txinsvi.toNumber().should.equal(0); |
|||
tx.txins.length.should.equal(0); |
|||
tx.txoutsvi.toNumber().should.equal(0); |
|||
tx.txouts.length.should.equal(0); |
|||
tx.nlocktime.should.equal(0xffffffff); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#set', function() { |
|||
|
|||
it('should set all the basic parameters', function() { |
|||
var tx = Transaction().set({ |
|||
version: 0, |
|||
txinsvi: Varint(1), |
|||
txins: [txin], |
|||
txoutsvi: Varint(1), |
|||
txouts: [txout], |
|||
nlocktime: 0 |
|||
}); |
|||
should.exist(tx.version); |
|||
should.exist(tx.txinsvi); |
|||
should.exist(tx.txins); |
|||
should.exist(tx.txoutsvi); |
|||
should.exist(tx.txouts); |
|||
should.exist(tx.nlocktime); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromJSON', function() { |
|||
|
|||
it('should set all the basic parameters', function() { |
|||
var tx = Transaction().fromJSON({ |
|||
version: 0, |
|||
txinsvi: Varint(1).toJSON(), |
|||
txins: [txin.toJSON()], |
|||
txoutsvi: Varint(1).toJSON(), |
|||
txouts: [txout.toJSON()], |
|||
nlocktime: 0 |
|||
}); |
|||
should.exist(tx.version); |
|||
should.exist(tx.txinsvi); |
|||
should.exist(tx.txins); |
|||
should.exist(tx.txoutsvi); |
|||
should.exist(tx.txouts); |
|||
should.exist(tx.nlocktime); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toJSON', function() { |
|||
|
|||
it('should recover all the basic parameters', function() { |
|||
var json = tx.toJSON(); |
|||
should.exist(json.version); |
|||
should.exist(json.txinsvi); |
|||
should.exist(json.txins); |
|||
should.exist(json.txoutsvi); |
|||
should.exist(json.txouts); |
|||
should.exist(json.nlocktime); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromBuffer', function() { |
|||
|
|||
it('should recover from this known tx', function() { |
|||
Transaction().fromBuffer(txbuf).toBuffer().toString('hex').should.equal(txhex); |
|||
}); |
|||
|
|||
it('should recover from this known tx from the blockchain', function() { |
|||
Transaction().fromBuffer(tx2buf).toBuffer().toString('hex').should.equal(tx2hex); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromBufferReader', function() { |
|||
|
|||
it('should recover from this known tx', function() { |
|||
Transaction().fromBufferReader(BufferReader(txbuf)).toBuffer().toString('hex').should.equal(txhex); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toBuffer', function() { |
|||
|
|||
it('should produce this known tx', function() { |
|||
Transaction().fromBuffer(txbuf).toBuffer().toString('hex').should.equal(txhex); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toBufferWriter', function() { |
|||
|
|||
it('should produce this known tx', function() { |
|||
Transaction().fromBuffer(txbuf).toBufferWriter().concat().toString('hex').should.equal(txhex); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#hash', function() { |
|||
|
|||
it('should correctly calculate the hash of this known transaction', function() { |
|||
var tx = Transaction().fromBuffer(tx2buf); |
|||
var txhashbuf = new Buffer(Array.apply([], new Buffer(tx2idhex, 'hex')).reverse()); |
|||
tx.hash().toString('hex').should.equal(txhashbuf.toString('hex')); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#id', function() { |
|||
|
|||
it('should correctly calculate the id of this known transaction', function() { |
|||
var tx = Transaction().fromBuffer(tx2buf); |
|||
tx.id().toString('hex').should.equal(tx2idhex); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#pushin', function() { |
|||
|
|||
it('should add an input', function() { |
|||
var txin = Txin(); |
|||
var tx = Transaction(); |
|||
tx.pushin(txin); |
|||
tx.txinsvi.toNumber().should.equal(1); |
|||
tx.txins.length.should.equal(1); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#pushout', function() { |
|||
|
|||
it('should add an output', function() { |
|||
var txout = Txout(); |
|||
var tx = Transaction(); |
|||
tx.pushout(txout); |
|||
tx.txoutsvi.toNumber().should.equal(1); |
|||
tx.txouts.length.should.equal(1); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,124 @@ |
|||
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'); |
|||
|
|||
describe('Txin', function() { |
|||
|
|||
var txidbuf = new Buffer(32); |
|||
txidbuf.fill(0); |
|||
var txoutnum = 0; |
|||
var script = Script().fromString("OP_CHECKMULTISIG"); |
|||
var scriptvi = Varint(script.toBuffer().length); |
|||
var seqnum = 0; |
|||
var txin = Txin().set({ |
|||
txidbuf: txidbuf, |
|||
txoutnum: txoutnum, |
|||
scriptvi: scriptvi, |
|||
script: script, |
|||
seqnum: seqnum |
|||
}); |
|||
|
|||
it('should make a new txin', function() { |
|||
var txin = new Txin(); |
|||
should.exist(txin); |
|||
txin = Txin(); |
|||
should.exist(txin); |
|||
var txidbuf = new Buffer(32); |
|||
txidbuf.fill(0); |
|||
Txin(txidbuf).txidbuf.length.should.equal(32); |
|||
(function() { |
|||
var txidbuf2 = new Buffer(33); |
|||
txidbuf2.fill(0); |
|||
Txin(txidbuf2); |
|||
}).should.throw('txidbuf must be 32 bytes'); |
|||
}); |
|||
|
|||
describe('#set', function() { |
|||
|
|||
it('should set these vars', function() { |
|||
var txin = Txin().set({ |
|||
txidbuf: txidbuf, |
|||
txoutnum: txoutnum, |
|||
scriptvi: scriptvi, |
|||
script: script, |
|||
seqnum: seqnum |
|||
}); |
|||
should.exist(txin.txidbuf); |
|||
should.exist(txin.txoutnum); |
|||
should.exist(txin.scriptvi); |
|||
should.exist(txin.script); |
|||
should.exist(txin.seqnum); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromJSON', function() { |
|||
|
|||
it('should set these vars', function() { |
|||
var txin2 = Txin().fromJSON(txin.toJSON()); |
|||
should.exist(txin2.txidbuf); |
|||
should.exist(txin2.txoutnum); |
|||
should.exist(txin2.scriptvi); |
|||
should.exist(txin2.script); |
|||
should.exist(txin2.seqnum); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toJSON', function() { |
|||
|
|||
it('should set these vars', function() { |
|||
var json = txin.toJSON() |
|||
should.exist(json.txidbuf); |
|||
should.exist(json.txoutnum); |
|||
should.exist(json.scriptvi); |
|||
should.exist(json.script); |
|||
should.exist(json.seqnum); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromBuffer', function() { |
|||
|
|||
it('should convert this known buffer', function() { |
|||
var hex = '00000000000000000000000000000000000000000000000000000000000000000000000001ae00000000'; |
|||
var buf = new Buffer(hex, 'hex'); |
|||
var txin = Txin().fromBuffer(buf); |
|||
txin.scriptvi.toNumber().should.equal(1); |
|||
txin.script.toString().should.equal('OP_CHECKMULTISIG'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromBufferReader', function() { |
|||
|
|||
it('should convert this known buffer', function() { |
|||
var hex = '00000000000000000000000000000000000000000000000000000000000000000000000001ae00000000'; |
|||
var buf = new Buffer(hex, 'hex'); |
|||
var br = BufferReader(buf); |
|||
var txin = Txin().fromBufferReader(br); |
|||
txin.scriptvi.toNumber().should.equal(1); |
|||
txin.script.toString().should.equal('OP_CHECKMULTISIG'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toBuffer', function() { |
|||
|
|||
it('should convert this known buffer', function() { |
|||
txin.toBuffer().toString('hex').should.equal('00000000000000000000000000000000000000000000000000000000000000000000000001ae00000000'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toBufferWriter', function() { |
|||
|
|||
it('should convert this known buffer', function() { |
|||
txin.toBufferWriter().concat().toString('hex').should.equal('00000000000000000000000000000000000000000000000000000000000000000000000001ae00000000'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,110 @@ |
|||
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'); |
|||
|
|||
describe('Txout', function() { |
|||
|
|||
var valuebn = BN(5); |
|||
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(); |
|||
should.exist(txout); |
|||
txout = Txout(); |
|||
should.exist(txout); |
|||
Txout(valuebn, scriptvi, script).valuebn.toString().should.equal('5'); |
|||
}); |
|||
|
|||
describe('#set', function() { |
|||
|
|||
it('should set this object', function() { |
|||
var txout = new Txout().set({ |
|||
valuebn: valuebn, |
|||
scriptvi: scriptvi, |
|||
script: script |
|||
}); |
|||
should.exist(txout.valuebn); |
|||
should.exist(txout.scriptvi); |
|||
should.exist(txout.script); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromJSON', function() { |
|||
|
|||
it('should set from this json', function() { |
|||
var txout = Txout().fromJSON({ |
|||
valuebn: valuebn.toJSON(), |
|||
scriptvi: scriptvi.toJSON(), |
|||
script: script.toJSON() |
|||
}); |
|||
should.exist(txout.valuebn); |
|||
should.exist(txout.scriptvi); |
|||
should.exist(txout.script); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toJSON', function() { |
|||
|
|||
it('should return this json', function() { |
|||
var txout = Txout().fromJSON({ |
|||
valuebn: valuebn.toJSON(), |
|||
scriptvi: scriptvi.toJSON(), |
|||
script: script.toJSON() |
|||
}); |
|||
var json = txout.toJSON(); |
|||
should.exist(json.valuebn); |
|||
should.exist(json.scriptvi); |
|||
should.exist(json.script); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromBuffer', function() { |
|||
|
|||
it('should make this txin from this known buffer', function() { |
|||
var txout = Txout().fromBuffer(new Buffer('050000000000000001ae', 'hex')); |
|||
txout.toBuffer().toString('hex').should.equal('050000000000000001ae'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromBufferReader', function() { |
|||
|
|||
it('should make this txin from this known buffer', function() { |
|||
var txout = Txout().fromBufferReader(BufferReader(new Buffer('050000000000000001ae', 'hex'))); |
|||
txout.toBuffer().toString('hex').should.equal('050000000000000001ae'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toBuffer', function() { |
|||
|
|||
it('should output this known buffer', function() { |
|||
var txout = Txout().fromBufferReader(BufferReader(new Buffer('050000000000000001ae', 'hex'))); |
|||
txout.toBuffer().toString('hex').should.equal('050000000000000001ae'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toBufferWriter', function() { |
|||
|
|||
it('should output this known buffer', function() { |
|||
var txout = Txout().fromBufferReader(BufferReader(new Buffer('050000000000000001ae', 'hex'))); |
|||
txout.toBufferWriter().concat().toString('hex').should.equal('050000000000000001ae'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
@ -0,0 +1,123 @@ |
|||
var BN = require('../lib/bn'); |
|||
var should = require('chai').should(); |
|||
var BufferReader = require('../lib/bufferreader'); |
|||
var BufferWriter = require('../lib/bufferwriter'); |
|||
var Varint = require('../lib/varint'); |
|||
|
|||
describe('Varint', function() { |
|||
|
|||
it('should make a new varint', function() { |
|||
var buf = new Buffer('00', 'hex'); |
|||
var varint = new Varint(buf); |
|||
should.exist(varint); |
|||
varint.buf.toString('hex').should.equal('00'); |
|||
varint = Varint(buf); |
|||
should.exist(varint); |
|||
varint.buf.toString('hex').should.equal('00'); |
|||
|
|||
//various ways to use the constructor
|
|||
Varint(Varint(0).toBuffer()).toNumber().should.equal(0); |
|||
Varint(0).toNumber().should.equal(0); |
|||
Varint(BN(0)).toNumber().should.equal(0); |
|||
}); |
|||
|
|||
describe('#set', function() { |
|||
|
|||
it('should set a buffer', function() { |
|||
var buf = new Buffer('00', 'hex'); |
|||
var varint = Varint().set({buf: buf}); |
|||
varint.buf.toString('hex').should.equal('00'); |
|||
varint.set({}); |
|||
varint.buf.toString('hex').should.equal('00'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromJSON', function() { |
|||
|
|||
it('should set a buffer', function() { |
|||
var buf = BufferWriter().writeVarintNum(5).concat(); |
|||
var varint = Varint().fromJSON(buf.toString('hex')); |
|||
varint.toNumber().should.equal(5); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toJSON', function() { |
|||
|
|||
it('should return a buffer', function() { |
|||
var buf = BufferWriter().writeVarintNum(5).concat(); |
|||
var varint = Varint().fromJSON(buf.toString('hex')); |
|||
varint.toJSON().should.equal('05'); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromBuffer', function() { |
|||
|
|||
it('should set a buffer', function() { |
|||
var buf = BufferWriter().writeVarintNum(5).concat(); |
|||
var varint = Varint().fromBuffer(buf); |
|||
varint.toNumber().should.equal(5); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromBufferReader', function() { |
|||
|
|||
it('should set a buffer reader', function() { |
|||
var buf = BufferWriter().writeVarintNum(5).concat(); |
|||
var br = BufferReader(buf); |
|||
var varint = Varint().fromBufferReader(br); |
|||
varint.toNumber().should.equal(5); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromBN', function() { |
|||
|
|||
it('should set a number', function() { |
|||
var varint = Varint().fromBN(BN(5)); |
|||
varint.toNumber().should.equal(5); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#fromNumber', function() { |
|||
|
|||
it('should set a number', function() { |
|||
var varint = Varint().fromNumber(5); |
|||
varint.toNumber().should.equal(5); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toBuffer', function() { |
|||
|
|||
it('should return a buffer', function() { |
|||
buf = BufferWriter().writeVarintNum(5).concat(); |
|||
var varint = Varint(buf); |
|||
varint.toBuffer().toString('hex').should.equal(buf.toString('hex')); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toBN', function() { |
|||
|
|||
it('should return a buffer', function() { |
|||
var varint = Varint(5); |
|||
varint.toBN().toString().should.equal(BN(5).toString()); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
describe('#toNumber', function() { |
|||
|
|||
it('should return a buffer', function() { |
|||
var varint = Varint(5); |
|||
varint.toNumber().should.equal(5); |
|||
}); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
Loading…
Reference in new issue