lukechilds
/
bitcoinjs-lib
mirror of https://github.com/lukechilds/bitcoinjs-lib.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Changes indentation to 2 spaces

hk-custom-address
Daniel Cousens 11 years ago
parent
fc2c495337
commit
f8de9a66da
2 changed files with 120 additions and 119 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 95
      src/base58.js
  2. 144
      src/convert.js

95
src/base58.js
View File

@ -10,7 +10,7 @@ var base = BigInteger.valueOf(58);
var positions = {}; var positions = {};
for (var i=0 ; i < alphabet.length ; ++i) { for (var i=0 ; i < alphabet.length ; ++i) {
positions[alphabet[i]] = i; positions[alphabet[i]] = i;
} }
// Convert a byte array to a base58-encoded string. // Convert a byte array to a base58-encoded string.
@ -18,31 +18,31 @@ for (var i=0 ; i < alphabet.length ; ++i) {
// Copyright (c) 2011 Google Inc. // Copyright (c) 2011 Google Inc.
// Ported to JavaScript by Stefan Thomas. // Ported to JavaScript by Stefan Thomas.
function encode(input) { function encode(input) {
var bi = BigInteger.fromByteArrayUnsigned(input); var bi = BigInteger.fromByteArrayUnsigned(input);
var chars = []; var chars = [];
while (bi.compareTo(base) >= 0) { while (bi.compareTo(base) >= 0) {
var mod = bi.mod(base); var mod = bi.mod(base);
chars.push(alphabet[mod.intValue()]); chars.push(alphabet[mod.intValue()]);
bi = bi.subtract(mod).divide(base); bi = bi.subtract(mod).divide(base);
} }
chars.push(alphabet[bi.intValue()]);
// Convert leading zeros too. chars.push(alphabet[bi.intValue()]);
for (var i = 0; i < input.length; i++) {
if (input[i] == 0x00) { // Convert leading zeros too.
chars.push(alphabet[0]); for (var i = 0; i < input.length; i++) {
} else break; if (input[i] == 0x00) {
} chars.push(alphabet[0]);
} else break;
}
return chars.reverse().join(''); return chars.reverse().join('');
} }
// decode a base58 string into a byte array // decode a base58 string into a byte array
// input should be a base58 encoded string // input should be a base58 encoded string
// @return Array // @return Array
function decode(input) { function decode(input) {
var base = BigInteger.valueOf(58); var base = BigInteger.valueOf(58);
var length = input.length; var length = input.length;
@ -50,54 +50,55 @@ function decode(input) {
var leading_zero = 0; var leading_zero = 0;
var seen_other = false; var seen_other = false;
for (var i=0; i<length ; ++i) { for (var i=0; i<length ; ++i) {
var chr = input[i]; var chr = input[i];
var p = positions[chr]; var p = positions[chr];
// if we encounter an invalid character, decoding fails // if we encounter an invalid character, decoding fails
if (p === undefined) { if (p === undefined) {
throw new Error('invalid base58 string: ' + input); throw new Error('invalid base58 string: ' + input);
} }
num = num.multiply(base).add(BigInteger.valueOf(p)); num = num.multiply(base).add(BigInteger.valueOf(p));
if (chr == '1' && !seen_other) { if (chr == '1' && !seen_other) {
++leading_zero; ++leading_zero;
} }
else { else {
seen_other = true; seen_other = true;
} }
} }
var bytes = num.toByteArrayUnsigned(); var bytes = num.toByteArrayUnsigned();
// remove leading zeros // remove leading zeros
while (leading_zero-- > 0) { while (leading_zero-- > 0) {
bytes.unshift(0); bytes.unshift(0);
} }
return bytes; return bytes;
} }
function checkEncode(input, vbyte) { function checkEncode(input, vbyte) {
vbyte = vbyte || 0; vbyte = vbyte || 0;
var front = [vbyte].concat(input)
return encode(front.concat(getChecksum(front))); var front = [vbyte].concat(input);
return encode(front.concat(getChecksum(front)));
} }
function checkDecode(input) { function checkDecode(input) {
var bytes = decode(input), var bytes = decode(input),
front = bytes.slice(0,bytes.length-4), front = bytes.slice(0,bytes.length-4),
back = bytes.slice(bytes.length-4); back = bytes.slice(bytes.length-4);
var checksum = getChecksum(front) var checksum = getChecksum(front);
if (""+checksum != ""+back) { if ("" + checksum != "" + back) {
throw new Error("Checksum failed"); throw new Error("Checksum failed");
} }
var o = front.slice(1); var o = front.slice(1);
o.version = front[0]; o.version = front[0];
return o; return o;
} }
function getChecksum(bytes) { function getChecksum(bytes) {

144
src/convert.js
View File

@ -3,121 +3,121 @@ var WordArray = Crypto.lib.WordArray;
var base64map = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; var base64map = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
function lpad(str, padString, length) { function lpad(str, padString, length) {
while (str.length < length) str = padString + str; while (str.length < length) str = padString + str;
return str; return str;
} }
/** /**
* Convert a byte array to a hex string * Convert a byte array to a hex string
*/ */
function bytesToHex(bytes) { function bytesToHex(bytes) {
return bytes.map(function(x) { return bytes.map(function(x) {
return lpad(x.toString(16), '0', 2) return lpad(x.toString(16), '0', 2)
}).join(''); }).join('');
}; };
/** /**
* Convert a hex string to a byte array * Convert a hex string to a byte array
*/ */
function hexToBytes(hex) { function hexToBytes(hex) {
return hex.match(/../g).map(function(x) { return hex.match(/../g).map(function(x) {
return parseInt(x,16) return parseInt(x,16)
}); });
} }
/** /**
* Convert a byte array to a base-64 string * Convert a byte array to a base-64 string
*/ */
function bytesToBase64(bytes) { function bytesToBase64(bytes) {
var base64 = [] var base64 = []
for (var i = 0; i < bytes.length; i += 3) { for (var i = 0; i < bytes.length; i += 3) {
var triplet = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2]; var triplet = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
for (var j = 0; j < 4; j++) { for (var j = 0; j < 4; j++) {
if (i * 8 + j * 6 <= bytes.length * 8) { if (i * 8 + j * 6 <= bytes.length * 8) {
base64.push(base64map.charAt((triplet >>> 6 * (3 - j)) & 0x3F)); base64.push(base64map.charAt((triplet >>> 6 * (3 - j)) & 0x3F));
} else { } else {
base64.push('='); base64.push('=');
} }
}
} }
}
return base64.join(''); return base64.join('');
} }
/** /**
* Convert a base-64 string to a byte array * Convert a base-64 string to a byte array
*/ */
function base64ToBytes(base64) { function base64ToBytes(base64) {
// Remove non-base-64 characters // Remove non-base-64 characters
base64 = base64.replace(/[^A-Z0-9+\/]/ig, ''); base64 = base64.replace(/[^A-Z0-9+\/]/ig, '');
var bytes = []; var bytes = [];
var imod4 = 0; var imod4 = 0;
for (var i = 0; i < base64.length; imod4 = ++i % 4) {
if (!imod4) continue
bytes.push(
(
(base64map.indexOf(base64.charAt(i - 1)) & (Math.pow(2, -2 * imod4 + 8) - 1)) <<
(imod4 * 2)
) |
(base64map.indexOf(base64.charAt(i)) >>> (6 - imod4 * 2))
);
}
return bytes; for (var i = 0; i < base64.length; imod4 = ++i % 4) {
if (!imod4) continue
bytes.push(
(
(base64map.indexOf(base64.charAt(i - 1)) & (Math.pow(2, -2 * imod4 + 8) - 1)) <<
(imod4 * 2)
) |
(base64map.indexOf(base64.charAt(i)) >>> (6 - imod4 * 2))
);
}
return bytes;
} }
/** /**
* Hex only (allowing bin would be potentially risky, as 01010101 = \x01 * 4 or 85) * Hex only (allowing bin would be potentially risky, as 01010101 = \x01 * 4 or 85)
*/ */
function coerceToBytes(input) { function coerceToBytes(input) {
if (typeof input != 'string') return input if (typeof input != 'string') return input
return hexToBytes(input); return hexToBytes(input);
} }
function binToBytes(bin) { function binToBytes(bin) {
return bin.match(/......../g).map(function(x) { return bin.match(/......../g).map(function(x) {
return parseInt(x,2) return parseInt(x,2)
}); });
} }
function bytesToBin(bytes) { function bytesToBin(bytes) {
return bytes.map(function(x) { return bytes.map(function(x) {
return lpad(x.toString(2), '0', 8) return lpad(x.toString(2), '0', 8)
}).join(''); }).join('');
} }
function bytesToString(bytes) { function bytesToString(bytes) {
return bytes.map(function(x){ return bytes.map(function(x){
return String.fromCharCode(x) return String.fromCharCode(x)
}).join(''); }).join('');
} }
function stringToBytes(string) { function stringToBytes(string) {
return string.split('').map(function(x) { return string.split('').map(function(x) {
return x.charCodeAt(0) return x.charCodeAt(0)
}); });
} }
/** /**
* Create a byte array representing a number with the given length * Create a byte array representing a number with the given length
*/ */
function numToBytes(num, bytes) { function numToBytes(num, bytes) {
if (bytes === undefined) bytes = 8; if (bytes === undefined) bytes = 8;
if (bytes === 0) return []; if (bytes === 0) return [];
return [num % 256].concat(numToBytes(Math.floor(num / 256), bytes - 1)); return [num % 256].concat(numToBytes(Math.floor(num / 256), bytes - 1));
} }
/** /**
* Convert a byte array to the number that it represents * Convert a byte array to the number that it represents
*/ */
function bytesToNum(bytes) { function bytesToNum(bytes) {
if (bytes.length === 0) return 0; if (bytes.length === 0) return 0;
return bytes[0] + 256 * bytesToNum(bytes.slice(1)); return bytes[0] + 256 * bytesToNum(bytes.slice(1));
} }
/** /**
@ -128,26 +128,26 @@ function bytesToNum(bytes) {
* Returns a byte array. * Returns a byte array.
*/ */
function numToVarInt(num) { function numToVarInt(num) {
if (num < 253) return [num]; if (num < 253) return [num];
if (num < 65536) return [253].concat(numToBytes(num, 2)); if (num < 65536) return [253].concat(numToBytes(num, 2));
if (num < 4294967296) return [254].concat(numToBytes(num, 4)); if (num < 4294967296) return [254].concat(numToBytes(num, 4));
return [253].concat(numToBytes(num, 8)); return [253].concat(numToBytes(num, 8));
} }
function bytesToWords(bytes) { function bytesToWords(bytes) {
var words = []; var words = [];
for (var i = 0, b = 0; i < bytes.length; i++, b += 8) { for (var i = 0, b = 0; i < bytes.length; i++, b += 8) {
words[b >>> 5] |= bytes[i] << (24 - b % 32); words[b >>> 5] |= bytes[i] << (24 - b % 32);
} }
return words; return words;
} }
function wordsToBytes(words) { function wordsToBytes(words) {
var bytes = []; var bytes = [];
for (var b = 0; b < words.length * 32; b += 8) { for (var b = 0; b < words.length * 32; b += 8) {
bytes.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF); bytes.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF);
} }
return bytes; return bytes;
} }
function bytesToWordArray(bytes) { function bytesToWordArray(bytes) {

Write Preview
Loading…
Cancel
Save