From fc2c49533732a6e769890919121d7ce820afd630 Mon Sep 17 00:00:00 2001
From: Daniel Cousens <daniel210x@gmail.com>
Date: Mon, 24 Mar 2014 15:53:57 +1100
Subject: [PATCH] Standardizes function signatures

---
 src/base58.js  | 20 +++++++++-----
 src/convert.js | 73 +++++++++++++++++++++++++++++++-------------------
 2 files changed, 59 insertions(+), 34 deletions(-)

diff --git a/src/base58.js b/src/base58.js
index 2cbb0ae..3793fa1 100644
--- a/src/base58.js
+++ b/src/base58.js
@@ -17,7 +17,7 @@ for (var i=0 ; i < alphabet.length ; ++i) {
 // Written by Mike Hearn for BitcoinJ.
 //   Copyright (c) 2011 Google Inc.
 // Ported to JavaScript by Stefan Thomas.
-module.exports.encode = function (input) {
+function encode(input) {
     var bi = BigInteger.fromByteArrayUnsigned(input);
     var chars = [];
 
@@ -41,7 +41,7 @@ module.exports.encode = function (input) {
 // decode a base58 string into a byte array
 // input should be a base58 encoded string
 // @return Array
-module.exports.decode = function (input) {
+function decode(input) {
 
   var base = BigInteger.valueOf(58);
 
@@ -78,14 +78,14 @@ module.exports.decode = function (input) {
   return bytes;
 }
 
-module.exports.checkEncode = function(input, vbyte) {
+function checkEncode(input, vbyte) {
     vbyte = vbyte || 0;
     var front = [vbyte].concat(input)
-    return module.exports.encode(front.concat(getChecksum(front)));
+    return encode(front.concat(getChecksum(front)));
 }
 
-module.exports.checkDecode = function(input) {
-    var bytes = module.exports.decode(input),
+function checkDecode(input) {
+    var bytes = decode(input),
         front = bytes.slice(0,bytes.length-4),
         back = bytes.slice(bytes.length-4);
 
@@ -105,4 +105,10 @@ function getChecksum(bytes) {
   return convert.hexToBytes(SHA256(SHA256(wordArray)).toString()).slice(0,4);
 }
 
-module.exports.getChecksum = getChecksum
+module.exports = {
+  encode: encode,
+  decode: decode,
+  checkEncode: checkEncode,
+  checkDecode: checkDecode,
+  getChecksum: getChecksum
+}
diff --git a/src/convert.js b/src/convert.js
index f042de0..bd31e28 100644
--- a/src/convert.js
+++ b/src/convert.js
@@ -2,7 +2,7 @@ var Crypto = require('crypto-js');
 var WordArray = Crypto.lib.WordArray;
 var base64map = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
 
-exports.lpad = function lpad(str, padString, length) {
+function lpad(str, padString, length) {
     while (str.length < length) str = padString + str;
     return str;
 }
@@ -10,16 +10,16 @@ exports.lpad = function lpad(str, padString, length) {
 /**
  * Convert a byte array to a hex string
  */
-exports.bytesToHex = function(bytes) {
+function bytesToHex(bytes) {
     return bytes.map(function(x) {
-        return exports.lpad(x.toString(16), '0', 2)
+        return lpad(x.toString(16), '0', 2)
     }).join('');
 };
 
 /**
  * Convert a hex string to a byte array
  */
-exports.hexToBytes = function(hex) {
+function hexToBytes(hex) {
     return hex.match(/../g).map(function(x) {
         return parseInt(x,16)
     });
@@ -28,7 +28,7 @@ exports.hexToBytes = function(hex) {
 /**
  * Convert a byte array to a base-64 string
  */
-exports.bytesToBase64 = function(bytes) {
+function bytesToBase64(bytes) {
     var base64 = []
 
     for (var i = 0; i < bytes.length; i += 3) {
@@ -49,7 +49,7 @@ exports.bytesToBase64 = function(bytes) {
 /**
  * Convert a base-64 string to a byte array
  */
-exports.base64ToBytes = function(base64) {
+function base64ToBytes(base64) {
     // Remove non-base-64 characters
     base64 = base64.replace(/[^A-Z0-9+\/]/ig, '');
 
@@ -74,30 +74,30 @@ exports.base64ToBytes = function(base64) {
 /**
  * Hex only (allowing bin would be potentially risky, as 01010101 = \x01 * 4 or 85)
  */
-exports.coerceToBytes = function(input) {
+function coerceToBytes(input) {
     if (typeof input != 'string') return input
-    return exports.hexToBytes(input);
+    return hexToBytes(input);
 }
 
-exports.binToBytes = function(bin) {
+function binToBytes(bin) {
     return bin.match(/......../g).map(function(x) {
         return parseInt(x,2)
     });
 }
 
-exports.bytesToBin = function(bytes) {
+function bytesToBin(bytes) {
     return bytes.map(function(x) {
-        return exports.lpad(x.toString(2), '0', 8)
+        return lpad(x.toString(2), '0', 8)
     }).join('');
 }
 
-exports.bytesToString = function(bytes) {
+function bytesToString(bytes) {
     return bytes.map(function(x){
         return String.fromCharCode(x)
     }).join('');
 }
 
-exports.stringToBytes = function(string) {
+function stringToBytes(string) {
     return string.split('').map(function(x) {
         return x.charCodeAt(0)
     });
@@ -106,18 +106,18 @@ exports.stringToBytes = function(string) {
 /**
  * Create a byte array representing a number with the given length
  */
-exports.numToBytes = function(num, bytes) {
+function numToBytes(num, bytes) {
     if (bytes === undefined) bytes = 8;
     if (bytes === 0) return [];
-    return [num % 256].concat(module.exports.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
  */
-exports.bytesToNum = function(bytes) {
+function bytesToNum(bytes) {
     if (bytes.length === 0) return 0;
-    return bytes[0] + 256 * module.exports.bytesToNum(bytes.slice(1));
+    return bytes[0] + 256 * bytesToNum(bytes.slice(1));
 }
 
 /**
@@ -127,14 +127,14 @@ exports.bytesToNum = function(bytes) {
  *
  * Returns a byte array.
  */
-exports.numToVarInt = function(num) {
+function numToVarInt(num) {
     if (num < 253) return [num];
-    if (num < 65536) return [253].concat(exports.numToBytes(num, 2));
-    if (num < 4294967296) return [254].concat(exports.numToBytes(num, 4));
-    return [253].concat(exports.numToBytes(num, 8));
+    if (num < 65536) return [253].concat(numToBytes(num, 2));
+    if (num < 4294967296) return [254].concat(numToBytes(num, 4));
+    return [253].concat(numToBytes(num, 8));
 }
 
-exports.bytesToWords = function (bytes) {
+function bytesToWords(bytes) {
     var words = [];
     for (var i = 0, b = 0; i < bytes.length; i++, b += 8) {
         words[b >>> 5] |= bytes[i] << (24 - b % 32);
@@ -142,7 +142,7 @@ exports.bytesToWords = function (bytes) {
     return words;
 }
 
-exports.wordsToBytes = function (words) {
+function wordsToBytes(words) {
     var bytes = [];
     for (var b = 0; b < words.length * 32; b += 8) {
         bytes.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF);
@@ -150,11 +150,30 @@ exports.wordsToBytes = function (words) {
     return bytes;
 }
 
-exports.bytesToWordArray = function (bytes) {
-  return new WordArray.init(exports.bytesToWords(bytes), bytes.length)
+function bytesToWordArray(bytes) {
+  return new WordArray.init(bytesToWords(bytes), bytes.length)
 }
 
-exports.wordArrayToBytes = function (wordArray) {
-  return exports.wordsToBytes(wordArray.words)
+function wordArrayToBytes(wordArray) {
+  return wordsToBytes(wordArray.words)
 }
 
+module.exports = {
+  lpad: lpad,
+  bytesToHex: bytesToHex,
+  hexToBytes: hexToBytes,
+  bytesToBase64: bytesToBase64,
+  base64ToBytes: base64ToBytes,
+  coerceToBytes: coerceToBytes,
+  binToBytes: binToBytes,
+  bytesToBin: bytesToBin,
+  bytesToString: bytesToString,
+  stringToBytes: stringToBytes,
+  numToBytes: numToBytes,
+  bytesToNum: bytesToNum,
+  numToVarInt: numToVarInt,
+  bytesToWords: bytesToWords,
+  wordsToBytes: wordsToBytes,
+  bytesToWordArray: bytesToWordArray,
+  wordArrayToBytes: wordArrayToBytes
+}