Merge pull request bitcoinjs#145 from dcousens/b58coretests

Base58 Bitcoin core test compatibility

Author: kyledrake

qa/coretests.js

@@ -0,0 +1,128 @@
+var assert = require('assert')
+var base58 = require('..').base58
+var base58check = require('..').base58check
+var crypto = require('..').crypto
+var fs = require('fs')
+var request = require('request')
+var secureRandom = require('secure-random')
+
+function b2h(b) { return new Buffer(b).toString('hex') }
+function h2b(h) { return new Buffer(h, 'hex') }
+function randomBuf(s) {
+ return new Buffer(secureRandom(s))
+}
+
+request('https://raw.githubusercontent.com/bitcoin/bitcoin/master/src/test/data/base58_encode_decode.json', function (error, response, body) {
+ assert.ifError(error)
+ assert.equal(response.statusCode, 200)
+
+ var data = JSON.parse(body)
+ var valid = data.map(function(x) {
+ return {
+ hex: x[0],
+ string: x[1]
+ }
+ })
+
+ // https://github.com/bitcoin/bitcoin/blob/master/src/test/base58_tests.cpp#L73
+// FIXME: Doesn't work TODO
+// valid.push({
+// hex: '971a55',
+// string: ' \t\n\v\f\r skip \r\f\v\n\t '
+// })
+
+ var fixtureJSON = JSON.stringify({
+ valid: valid,
+ invalid: [
+ {
+ description: 'non-base58 string',
+ string: 'invalid'
+ },
+ {
+ description: 'non-base58 alphabet',
+ string: 'c2F0b3NoaQo='
+ },
+ {
+ description: 'leading whitespace',
+ string: ' 1111111111'
+ },
+ {
+ description: 'trailing whitespace',
+ string: '1111111111 '
+ },
+ // https://github.com/bitcoin/bitcoin/blob/master/src/test/base58_tests.cpp#L72
+ {
+ description: 'unexpected character after whitespace',
+ string: ' \t\n\v\f\r skip \r\f\v\n\t a'
+ }
+ ]
+ }, null, ' ')
+
+ fs.writeFileSync('./test/fixtures/base58.js', 'module.exports = ' + fixtureJSON)
+})
+
+request('https://raw.githubusercontent.com/bitcoin/bitcoin/master/src/test/data/base58_keys_valid.json', function (error, response, body) {
+request('https://raw.githubusercontent.com/bitcoin/bitcoin/master/src/test/data/base58_keys_invalid.json', function (error2, response2, body2) {
+ assert.ifError(error)
+ assert.ifError(error2)
+ assert.equal(response.statusCode, 200)
+ assert.equal(response2.statusCode, 200)
+
+ var validData = JSON.parse(body)
+ var invalidData = JSON.parse(body2)
+
+ var valid = validData.map(function(x) {
+ var string = x[0]
+ var hex = x[1]
+ var params = x[2]
+
+ if (params.isCompressed) {
+ hex += '01'
+ }
+ assert.equal(b2h(base58check.decode(string).payload), hex)
+
+ return {
+ string: string,
+ decode: {
+ version: base58check.decode(string).version,
+ payload: hex,
+ checksum: b2h(base58check.decode(string).checksum),
+ }
+ }
+ })
+ var invalid2 = invalidData.map(function(x) { return x[0] })
+
+ // Our own tests
+ var hash = crypto.hash160(randomBuf(65))
+ var checksum = base58check.decode(base58check.encode(hash)).checksum
+
+ var fixtureJSON = JSON.stringify({
+ valid: valid,
+ invalid: [
+ {
+ base58check: base58check.encode(hash.slice(0, 18), 0x05),
+ description: 'hash too short'
+ },
+ {
+ base58check: base58check.encode(Buffer.concat([hash, randomBuf(2)]), 0x05),
+ description: 'hash too long'
+ },
+ {
+ base58check: base58.encode(Buffer.concat([new Buffer([0x01]), hash, checksum])),
+ description: 'bad version byte',
+ },
+ {
+ base58check: base58.encode(Buffer.concat([new Buffer([0x05]), randomBuf(20), checksum])),
+ description: 'bad payload',
+ },
+ {
+ base58check: base58.encode(Buffer.concat([new Buffer([0x05]), hash, randomBuf(4)])),
+ description: 'bad SHA256 checksum',
+ }
+ ],
+ invalid2: invalid2
+ }, null, ' ')
+
+ fs.writeFileSync('./test/fixtures/base58check.js', 'module.exports = ' + fixtureJSON)
+})
+})

src/base58.js

@@ -2,78 +2,65 @@
 // Originally written by Mike Hearn for BitcoinJ
 // Copyright (c) 2011 Google Inc
 // Ported to JavaScript by Stefan Thomas
+// Merged Buffer refactorings from base58-native by Stephen Pair
+// Copyright (c) 2013 BitPay Inc
 
 var BigInteger = require('./jsbn/jsbn')
 
-// FIXME: ? This is a Base58Check alphabet
-var alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
-var base = BigInteger.valueOf(58)
-
-var alphabetMap = {}
-for (var i=0; i<alphabet.length; ++i) {
- var chr = alphabet[i]
- alphabetMap[chr] = BigInteger.valueOf(i)
+var ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+var ALPHABET_BUF = new Buffer(ALPHABET, 'ascii')
+var ALPHABET_MAP = {}
+for(var i = 0; i < ALPHABET.length; i++) {
+ ALPHABET_MAP[ALPHABET[i]] = BigInteger.valueOf(i)
 }
+var BASE = BigInteger.valueOf(58)
 
-// encode a byte array into a base58 encoded String
-// @return String
 function encode(buffer) {
  var bi = BigInteger.fromByteArrayUnsigned(buffer)
- var chars = []
+ var result = new Buffer(buffer.length << 1)
 
- while (bi.compareTo(base) >= 0) {
- var mod = bi.mod(base)
- bi = bi.subtract(mod).divide(base)
+ var i = result.length - 1
+ while (bi.compareTo(BigInteger.ZERO) > 0) {
+ var remainder = bi.mod(BASE)
+ bi = bi.divide(BASE)
 
- chars.push(alphabet[mod.intValue()])
+ result[i] = ALPHABET_BUF[remainder.intValue()]
+ i--
  }
 
- chars.push(alphabet[bi.intValue()])
-
- // Convert leading zeros too.
- for (var i=0; i<buffer.length; i++) {
- if (buffer[i] !== 0x00) break
-
- chars.push(alphabet[0])
+ // deal with leading zeros
+ var j = 0
+ while (buffer[j] === 0) {
+ result[i] = ALPHABET_BUF[0]
+ j++
+ i--
  }
 
- return chars.reverse().join('')
+ return result.slice(i + 1, result.length).toString('ascii')
 }
 
-// decode a base58 encoded String into a byte array
-// @return Array
-function decode(str) {
- var num = BigInteger.valueOf(0)
-
- var leading_zero = 0
- var seen_other = false
+function decode(string) {
+ if (string.length === 0) return new Buffer(0)
 
- for (var i=0; i<str.length; ++i) {
- var chr = str[i]
- var bi = alphabetMap[chr]
+ var num = BigInteger.ZERO.clone()
 
- // if we encounter an invalid character, decoding fails
- if (bi === undefined) {
- throw new Error('invalid base58 string: ' + str)
- }
-
- num = num.multiply(base).add(bi)
-
- if (chr === '1' && !seen_other) {
- ++leading_zero
- } else {
- seen_other = true
- }
+ for (var i = 0; i < string.length; i++) {
+ num = num.multiply(BASE)
+ num = num.add(ALPHABET_MAP[string.charAt(i)])
  }
 
- var bytes = num.toByteArrayUnsigned()
-
- // remove leading zeros
- while (leading_zero-- > 0) {
- bytes.unshift(0)
+ // deal with leading zeros
+ var i = 0
+ while ((i < string.length) && (string[i] === ALPHABET[0])) {
+ i++
  }
 
- return new Buffer(bytes)
+ // FIXME: If BigInteger supported buffers, this could be a copy
+ var buffer = new Buffer(num.toByteArrayUnsigned())
+ var padding = new Buffer(i)
+ padding.fill(0)
+
+ return Buffer.concat([padding, buffer])
 }
 
 module.exports = {

test/base58.js

@@ -1,27 +1,37 @@
 var assert = require('assert')
 var base58 = require('../').base58
-
 var fixtures = require('./fixtures/base58')
 
+function b2h(b) { return new Buffer(b).toString('hex') }
+function h2b(h) { return new Buffer(h, 'hex') }
+
 describe('base58', function() {
  describe('decode', function() {
- it('decodes the test vectors', function() {
+ it('can decode Bitcoin core test data', function() {
  fixtures.valid.forEach(function(f) {
- var actual = base58.decode(f.encoded.string)
- var expected = f.encoded.hex
+ var actual = base58.decode(f.string)
+ var expected = f.hex
+
+ assert.strictEqual(b2h(actual), expected)
+ })
+ })
 
- assert.equal(actual.toString('hex'), expected)
+ fixtures.invalid.forEach(function(f) {
+ it('throws on ' + f.description, function() {
+ assert.throws(function() {
+ base58.decode(f.string)
+ })
  })
  })
  })
 
  describe('encode', function() {
- it('encodes the test vectors', function() {
+ it('can encode Bitcoin core test data', function() {
  fixtures.valid.forEach(function(f) {
- var actual = base58.encode(new Buffer(f.encoded.hex, 'hex'))
- var expected = f.encoded.string
+ var actual = base58.encode(h2b(f.hex))
+ var expected = f.string.trim()
 
- assert.equal(actual, expected)
+ assert.strictEqual(actual, expected)
  })
  })
  })

test/base58check.js

@@ -1,43 +1,51 @@
 var assert = require('assert')
 var base58check = require('../').base58check
+var fixtures = require('./fixtures/base58check')
 
-var fixtures = require('./fixtures/base58')
+function b2h(b) { return new Buffer(b).toString('hex') }
+function h2b(h) { return new Buffer(h, 'hex') }
 
 describe('base58check', function() {
  describe('decode', function() {
- it('decodes the test vectors', function() {
+ it('can decode Bitcoin core test data', function() {
  fixtures.valid.forEach(function(f) {
- var actual = base58check.decode(f.encoded.string)
- var expected = f.decoded
-
- assert.deepEqual({
- version: actual.version,
-  payload: actual.payload.toString('hex'),
- checksum: actual.checksum.toString('hex')
- }, expected)
+ var actual = base58check.decode(f.string)
+ var expected = {
+ version: f.decode.version,
+  payload: h2b(f.decode.payload),
+ checksum: h2b(f.decode.checksum)
+ }
+
+ assert.deepEqual(actual, expected)
  })
  })
 
- it('throws on invalid strings', function() {
- fixtures.invalid.forEach(function(f) {
+ fixtures.invalid.forEach(function(f) {
+ it('throws on ' + f.description, function() {
  assert.throws(function() {
- base58check.decode(f)
+ base58check.decode(f.string)
+ })
+ })
+ })
+
+ it('throws on [invalid] Bitcoin core test data', function() {
+ fixtures.invalid2.forEach(function(f) {
+ assert.throws(function() {
+ base58check.decode(f.string)
  })
  })
  })
  })
 
  describe('encode', function() {
- it('encodes the test vectors', function() {
+ it('can encode Bitcoin core test data', function() {
  fixtures.valid.forEach(function(f) {
- var actual = base58check.encode(
- new Buffer(f.decoded.payload, 'hex'),
- f.decoded.version
- )
- var expected = f.encoded.string
+ var actual = base58check.encode(h2b(f.decode.payload), f.decode.version)
+ var expected = f.string
 
- assert.equal(actual, expected)
+ assert.strictEqual(actual, expected)
  })
  })
  })
 })
+