multicoin-address-validator-ts
Version:
Multicoin address validator for Bitcoin and other Altcoins. TS version
251 lines (250 loc) • 6.87 kB
JavaScript
;
var jsSHA = require("jssha");
var sha512256 = require('js-sha512').sha512_256;
var Blake256 = require('./blake256');
var keccak256 = require('./sha3')['keccak256'];
var Blake2B = require('./blake2b');
var base58 = require('./base58');
var base32 = require('./base32');
function numberToHex(number, length) {
var hex = number.toString(16);
if (hex.length % 2 === 1) {
hex = '0' + hex;
}
// @ts-ignore
return hex.padStart(length, '0');
}
function isHexChar(c) {
if ((c >= 'A' && c <= 'F') ||
(c >= 'a' && c <= 'f') ||
(c >= '0' && c <= '9')) {
return 1;
}
return 0;
}
/* Convert a hex char to value */
function hexChar2byte(c) {
var d = 0;
if (c >= 'A' && c <= 'F') {
d = c.charCodeAt(0) - 'A'.charCodeAt(0) + 10;
}
else if (c >= 'a' && c <= 'f') {
d = c.charCodeAt(0) - 'a'.charCodeAt(0) + 10;
}
else if (c >= '0' && c <= '9') {
d = c.charCodeAt(0) - '0'.charCodeAt(0);
}
return d;
}
/* Convert a byte to string */
function byte2hexStr(byte) {
var hexByteMap = "0123456789ABCDEF";
var str = "";
str += hexByteMap.charAt(byte >> 4);
str += hexByteMap.charAt(byte & 0x0f);
return str;
}
function byteArray2hexStr(byteArray) {
var str = "";
for (var i = 0; i < (byteArray.length - 1); i++) {
str += byte2hexStr(byteArray[i]);
}
str += byte2hexStr(byteArray[i]);
return str;
}
function hexStr2byteArray(str) {
var byteArray = Array();
var d = 0;
var i = 0;
var j = 0;
var k = 0;
for (i = 0; i < str.length; i++) {
var c = str.charAt(i);
if (isHexChar(c)) {
d <<= 4;
d += hexChar2byte(c);
j++;
if (0 === (j % 2)) {
byteArray[k++] = d;
d = 0;
}
}
}
return byteArray;
}
var COMMON_BASE = 256; // must be 256 at most!
function copyA(a) {
var ret = new Uint8Array(a.length);
for (var i = 0; i < a.length; i++) {
ret[i] = a[i];
}
return ret;
}
function isZero(a) {
for (var i = 0; i < a.length; i++) {
if (a[i] !== 0)
return false;
}
return true;
}
function clampA(a) {
var alen = a.length;
var i = 0;
while (a[alen - 1] === 0)
alen--;
var ret = new Uint8Array(alen);
for (var i = 0; i < alen; i++) {
ret[i] = a[i];
}
return ret;
}
function addD(a, d) {
var tlen = a.length;
var carry = 0;
var ret = new Uint8Array(tlen + 1);
if (d === 0)
return copyA(a);
var i = 0;
var temp = carry;
temp += a[i] + d;
carry = Math.floor(temp / COMMON_BASE);
ret[i] = temp % COMMON_BASE;
for (i = 1; i < tlen; i++) {
temp = carry;
temp += a[i];
carry = Math.floor(temp / COMMON_BASE);
ret[i] = temp % COMMON_BASE;
}
if (carry) {
ret[i] = carry;
}
ret = clampA(ret);
return ret;
}
;
function mulD(a, d) {
var tlen = a.length;
var carry = 0;
var ret = new Uint8Array(tlen + 1);
var k = 0;
var tmp;
if (isZero(a))
return copyA(a);
if (d === 0)
return new Uint8Array(tlen);
for (; k < tlen; k++) {
tmp = Number(a[k]) * d + carry;
ret[k] = tmp % COMMON_BASE;
carry = Math.floor(tmp / COMMON_BASE);
}
if (carry) {
ret[k] = carry;
}
ret = clampA(ret);
return ret;
}
function divRem(a, d) {
// @ts-ignore
var divrem = function (u, m, v, q, B) {
var k = 0, t;
for (var j = m - 1; j >= 0; j--) {
k = (k * COMMON_BASE);
k += u[j];
if (k >= v) {
t = Math.floor(k / v);
k -= t * v;
}
else {
t = 0;
}
q[j] = t;
}
return k;
};
var Q = new Uint8Array(a.length);
var R = divrem(a, a.length, d, Q, 8);
Q = clampA(Q);
return [Q, R];
}
function base10ToBase256(s) {
var blen = 0;
// checks&balances omitted
var out = new Uint8Array(1);
for (var i = 0; i < s.length; i++) {
out = mulD(out, 10);
out = addD(out, parseInt(s[i], 10));
}
return out;
}
// Assuming b being a Uint8Array
function base256ToBase10(a) {
var s = "";
var t = copyA(a);
var qr = [];
var i = a.length;
while (!isZero(t)) {
// @ts-ignore
qr = divRem(t, 10);
s = s + qr[1].toString(10);
// @ts-ignore
t = qr[0];
}
return s.split("").reverse().join("");
}
module.exports = {
numberToHex: numberToHex,
toHex: function (arrayOfBytes) {
var hex = '';
for (var i = 0; i < arrayOfBytes.length; i++) {
hex += numberToHex(arrayOfBytes[i]);
}
return hex;
},
sha256: function (payload, format) {
if (format === void 0) { format = 'HEX'; }
var sha = new jsSHA('SHA-256', format);
sha.update(payload);
return sha.getHash(format);
},
sha256x2: function (buffer, format) {
if (format === void 0) { format = 'HEX'; }
// @ts-ignore
return this.sha256(this.sha256(buffer, format), format);
},
sha256Checksum: function (payload) {
return this.sha256(this.sha256(payload)).substr(0, 8);
},
sha512_256: function (payload, format) {
if (format === void 0) { format = 'HEX'; }
var hash = sha512256.create();
// @ts-ignore
hash.update(Buffer.from(payload, format));
return hash.hex().toUpperCase();
},
blake256: function (hexString) {
return new Blake256().update(hexString, 'hex').digest('hex');
},
blake256Checksum: function (payload) {
return this.blake256(this.blake256(payload)).substr(0, 8);
},
blake2b: function (hexString, outlen) {
return new Blake2B(outlen).update(Buffer.from(hexString, 'hex')).digest('hex');
},
keccak256: function (hexString) {
return keccak256(hexString);
},
keccak256Checksum: function (payload) {
return keccak256(payload).toString().substr(0, 8);
},
blake2b256: function (hexString) {
return new Blake2B(32).update(Buffer.from(hexString, 'hex'), 32).digest('hex');
},
base58: base58.decode,
byteArray2hexStr: byteArray2hexStr,
hexStr2byteArray: hexStr2byteArray,
bigNumberToBuffer: function (bignumber, size) {
return Buffer.from(base10ToBase256(bignumber).reverse());
},
base32: base32,
base10ToBase256: base10ToBase256
};