multichain-address-validator 0.0.1

package/dist/crypto/blake256.d.ts

@@ -0,0 +1,22 @@
+export default Blake256;
+declare function Blake256(): void;
+declare class Blake256 {
+    _h: number[];
+    _s: number[];
+    _block: any;
+    _blockOffset: number;
+    _length: number[];
+    _nullt: boolean;
+    _zo: any;
+    _oo: any;
+    _length_carry(arr: any): void;
+    update(data: any, encoding: any): this;
+    _compress(): void;
+    _padding(): void;
+    digest(encoding: any): any;
+}
+declare namespace Blake256 {
+    let sigma: number[][];
+    let u256: number[];
+    let padding: any;
+}

package/dist/crypto/blake256.js

@@ -0,0 +1,169 @@
+/**
+ * Credits to https://github.com/cryptocoinjs/blake-hash
+ */
+Blake256.sigma = [
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    [14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3],
+    [11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4],
+    [7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8],
+    [9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13],
+    [2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9],
+    [12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11],
+    [13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10],
+    [6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5],
+    [10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0],
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    [14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3],
+    [11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4],
+    [7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8],
+    [9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13],
+    [2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9]
+];
+Blake256.u256 = [
+    0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
+    0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
+    0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
+    0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917
+];
+Blake256.padding = Buffer.from([
+    0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+]);
+Blake256.prototype._length_carry = function (arr) {
+    for (var j = 0; j < arr.length; ++j) {
+        if (arr[j] < 0x0100000000)
+            break;
+        arr[j] -= 0x0100000000;
+        arr[j + 1] += 1;
+    }
+};
+Blake256.prototype.update = function (data, encoding) {
+    data = Buffer.from(data, encoding);
+    var block = this._block;
+    var offset = 0;
+    while (this._blockOffset + data.length - offset >= block.length) {
+        for (var i = this._blockOffset; i < block.length;)
+            block[i++] = data[offset++];
+        this._length[0] += block.length * 8;
+        this._length_carry(this._length);
+        this._compress();
+        this._blockOffset = 0;
+    }
+    while (offset < data.length)
+        block[this._blockOffset++] = data[offset++];
+    return this;
+};
+var zo = Buffer.from([0x01]);
+var oo = Buffer.from([0x81]);
+function rot(x, n) {
+    return ((x << (32 - n)) | (x >>> n)) >>> 0;
+}
+function g(v, m, i, a, b, c, d, e) {
+    var sigma = Blake256.sigma;
+    var u256 = Blake256.u256;
+    v[a] = (v[a] + ((m[sigma[i][e]] ^ u256[sigma[i][e + 1]]) >>> 0) + v[b]) >>> 0;
+    v[d] = rot(v[d] ^ v[a], 16);
+    v[c] = (v[c] + v[d]) >>> 0;
+    v[b] = rot(v[b] ^ v[c], 12);
+    v[a] = (v[a] + ((m[sigma[i][e + 1]] ^ u256[sigma[i][e]]) >>> 0) + v[b]) >>> 0;
+    v[d] = rot(v[d] ^ v[a], 8);
+    v[c] = (v[c] + v[d]) >>> 0;
+    v[b] = rot(v[b] ^ v[c], 7);
+}
+function Blake256() {
+    this._h = [
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+    ];
+    this._s = [0, 0, 0, 0];
+    this._block = Buffer.allocUnsafe(64);
+    this._blockOffset = 0;
+    this._length = [0, 0];
+    this._nullt = false;
+    this._zo = zo;
+    this._oo = oo;
+}
+Blake256.prototype._compress = function () {
+    var u256 = Blake256.u256;
+    var v = new Array(16);
+    var m = new Array(16);
+    var i;
+    for (i = 0; i < 16; ++i)
+        m[i] = this._block.readUInt32BE(i * 4);
+    for (i = 0; i < 8; ++i)
+        v[i] = this._h[i] >>> 0;
+    for (i = 8; i < 12; ++i)
+        v[i] = (this._s[i - 8] ^ u256[i - 8]) >>> 0;
+    for (i = 12; i < 16; ++i)
+        v[i] = u256[i - 8];
+    if (!this._nullt) {
+        v[12] = (v[12] ^ this._length[0]) >>> 0;
+        v[13] = (v[13] ^ this._length[0]) >>> 0;
+        v[14] = (v[14] ^ this._length[1]) >>> 0;
+        v[15] = (v[15] ^ this._length[1]) >>> 0;
+    }
+    for (i = 0; i < 14; ++i) {
+        /* column step */
+        g(v, m, i, 0, 4, 8, 12, 0);
+        g(v, m, i, 1, 5, 9, 13, 2);
+        g(v, m, i, 2, 6, 10, 14, 4);
+        g(v, m, i, 3, 7, 11, 15, 6);
+        /* diagonal step */
+        g(v, m, i, 0, 5, 10, 15, 8);
+        g(v, m, i, 1, 6, 11, 12, 10);
+        g(v, m, i, 2, 7, 8, 13, 12);
+        g(v, m, i, 3, 4, 9, 14, 14);
+    }
+    for (i = 0; i < 16; ++i)
+        this._h[i % 8] = (this._h[i % 8] ^ v[i]) >>> 0;
+    for (i = 0; i < 8; ++i)
+        this._h[i] = (this._h[i] ^ this._s[i % 4]) >>> 0;
+};
+Blake256.prototype._padding = function () {
+    var lo = this._length[0] + this._blockOffset * 8;
+    var hi = this._length[1];
+    if (lo >= 0x0100000000) {
+        lo -= 0x0100000000;
+        hi += 1;
+    }
+    var msglen = Buffer.allocUnsafe(8);
+    msglen.writeUInt32BE(hi, 0);
+    msglen.writeUInt32BE(lo, 4);
+    if (this._blockOffset === 55) {
+        this._length[0] -= 8;
+        this.update(this._oo);
+    }
+    else {
+        if (this._blockOffset < 55) {
+            if (this._blockOffset === 0)
+                this._nullt = true;
+            this._length[0] -= (55 - this._blockOffset) * 8;
+            this.update(Blake256.padding.slice(0, 55 - this._blockOffset));
+        }
+        else {
+            this._length[0] -= (64 - this._blockOffset) * 8;
+            this.update(Blake256.padding.slice(0, 64 - this._blockOffset));
+            this._length[0] -= 55 * 8;
+            this.update(Blake256.padding.slice(1, 1 + 55));
+            this._nullt = true;
+        }
+        this.update(this._zo);
+        this._length[0] -= 8;
+    }
+    this._length[0] -= 64;
+    this.update(msglen);
+};
+Blake256.prototype.digest = function (encoding) {
+    this._padding();
+    var buffer = Buffer.allocUnsafe(32);
+    for (var i = 0; i < 8; ++i)
+        buffer.writeUInt32BE(this._h[i], i * 4);
+    return buffer.toString(encoding);
+};
+export default Blake256;

package/dist/crypto/blake2b.d.ts

@@ -0,0 +1,13 @@
+export default Blake2b;
+declare function Blake2b(outlen: any, key: any, salt: any, personal: any): void;
+declare class Blake2b {
+    constructor(outlen: any, key: any, salt: any, personal: any);
+    b: Uint8Array;
+    h: Uint32Array;
+    t: number;
+    c: number;
+    outlen: any;
+    update(input: any): this;
+    digest(out: any): any;
+    final: any;
+}

package/dist/crypto/blake2b.js

@@ -0,0 +1,242 @@
+'use strict';
+/**
+ * Credits to https://github.com/emilbayes/blake2b
+ *
+ * Copyright (c) 2017, Emil Bay github@tixz.dk
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+// 64-bit unsigned addition
+// Sets v[a,a+1] += v[b,b+1]
+// v should be a Uint32Array
+function ADD64AA(v, a, b) {
+    var o0 = v[a] + v[b];
+    var o1 = v[a + 1] + v[b + 1];
+    if (o0 >= 0x100000000) {
+        o1++;
+    }
+    v[a] = o0;
+    v[a + 1] = o1;
+}
+// 64-bit unsigned addition
+// Sets v[a,a+1] += b
+// b0 is the low 32 bits of b, b1 represents the high 32 bits
+function ADD64AC(v, a, b0, b1) {
+    var o0 = v[a] + b0;
+    if (b0 < 0) {
+        o0 += 0x100000000;
+    }
+    var o1 = v[a + 1] + b1;
+    if (o0 >= 0x100000000) {
+        o1++;
+    }
+    v[a] = o0;
+    v[a + 1] = o1;
+}
+// Little-endian byte access
+function B2B_GET32(arr, i) {
+    return (arr[i] ^
+        (arr[i + 1] << 8) ^
+        (arr[i + 2] << 16) ^
+        (arr[i + 3] << 24));
+}
+// G Mixing function
+// The ROTRs are inlined for speed
+function B2B_G(a, b, c, d, ix, iy) {
+    var x0 = m[ix];
+    var x1 = m[ix + 1];
+    var y0 = m[iy];
+    var y1 = m[iy + 1];
+    ADD64AA(v, a, b); // v[a,a+1] += v[b,b+1] ... in JS we must store a uint64 as two uint32s
+    ADD64AC(v, a, x0, x1); // v[a, a+1] += x ... x0 is the low 32 bits of x, x1 is the high 32 bits
+    // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated to the right by 32 bits
+    var xor0 = v[d] ^ v[a];
+    var xor1 = v[d + 1] ^ v[a + 1];
+    v[d] = xor1;
+    v[d + 1] = xor0;
+    ADD64AA(v, c, d);
+    // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 24 bits
+    xor0 = v[b] ^ v[c];
+    xor1 = v[b + 1] ^ v[c + 1];
+    v[b] = (xor0 >>> 24) ^ (xor1 << 8);
+    v[b + 1] = (xor1 >>> 24) ^ (xor0 << 8);
+    ADD64AA(v, a, b);
+    ADD64AC(v, a, y0, y1);
+    // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated right by 16 bits
+    xor0 = v[d] ^ v[a];
+    xor1 = v[d + 1] ^ v[a + 1];
+    v[d] = (xor0 >>> 16) ^ (xor1 << 16);
+    v[d + 1] = (xor1 >>> 16) ^ (xor0 << 16);
+    ADD64AA(v, c, d);
+    // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 63 bits
+    xor0 = v[b] ^ v[c];
+    xor1 = v[b + 1] ^ v[c + 1];
+    v[b] = (xor1 >>> 31) ^ (xor0 << 1);
+    v[b + 1] = (xor0 >>> 31) ^ (xor1 << 1);
+}
+// Initialization Vector
+var BLAKE2B_IV32 = new Uint32Array([
+    0xF3BCC908, 0x6A09E667, 0x84CAA73B, 0xBB67AE85,
+    0xFE94F82B, 0x3C6EF372, 0x5F1D36F1, 0xA54FF53A,
+    0xADE682D1, 0x510E527F, 0x2B3E6C1F, 0x9B05688C,
+    0xFB41BD6B, 0x1F83D9AB, 0x137E2179, 0x5BE0CD19
+]);
+var SIGMA8 = [
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+    14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+    11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,
+    7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,
+    9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,
+    2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,
+    12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11,
+    13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10,
+    6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5,
+    10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0,
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+    14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3
+];
+// These are offsets into a uint64 buffer.
+// Multiply them all by 2 to make them offsets into a uint32 buffer,
+// because this is Javascript and we don't have uint64s
+var SIGMA82 = new Uint8Array(SIGMA8.map(function (x) { return x * 2; }));
+// Compression function. 'last' flag indicates last block.
+// Note we're representing 16 uint64s as 32 uint32s
+var v = new Uint32Array(32);
+var m = new Uint32Array(32);
+function blake2bCompress(ctx, last) {
+    var i = 0;
+    // init work variables
+    for (i = 0; i < 16; i++) {
+        v[i] = ctx.h[i];
+        v[i + 16] = BLAKE2B_IV32[i];
+    }
+    // low 64 bits of offset
+    v[24] = v[24] ^ ctx.t;
+    v[25] = v[25] ^ (ctx.t / 0x100000000);
+    // high 64 bits not supported, offset may not be higher than 2**53-1
+    // last block flag set ?
+    if (last) {
+        v[28] = ~v[28];
+        v[29] = ~v[29];
+    }
+    // get little-endian words
+    for (i = 0; i < 32; i++) {
+        m[i] = B2B_GET32(ctx.b, 4 * i);
+    }
+    // twelve rounds of mixing
+    for (i = 0; i < 12; i++) {
+        B2B_G(0, 8, 16, 24, SIGMA82[i * 16 + 0], SIGMA82[i * 16 + 1]);
+        B2B_G(2, 10, 18, 26, SIGMA82[i * 16 + 2], SIGMA82[i * 16 + 3]);
+        B2B_G(4, 12, 20, 28, SIGMA82[i * 16 + 4], SIGMA82[i * 16 + 5]);
+        B2B_G(6, 14, 22, 30, SIGMA82[i * 16 + 6], SIGMA82[i * 16 + 7]);
+        B2B_G(0, 10, 20, 30, SIGMA82[i * 16 + 8], SIGMA82[i * 16 + 9]);
+        B2B_G(2, 12, 22, 24, SIGMA82[i * 16 + 10], SIGMA82[i * 16 + 11]);
+        B2B_G(4, 14, 16, 26, SIGMA82[i * 16 + 12], SIGMA82[i * 16 + 13]);
+        B2B_G(6, 8, 18, 28, SIGMA82[i * 16 + 14], SIGMA82[i * 16 + 15]);
+    }
+    for (i = 0; i < 16; i++) {
+        ctx.h[i] = ctx.h[i] ^ v[i] ^ v[i + 16];
+    }
+}
+// reusable parameter_block
+var parameter_block = new Uint8Array([
+    0, 0, 0, 0, //  0: outlen, keylen, fanout, depth
+    0, 0, 0, 0, //  4: leaf length, sequential mode
+    0, 0, 0, 0, //  8: node offset
+    0, 0, 0, 0, // 12: node offset
+    0, 0, 0, 0, // 16: node depth, inner length, rfu
+    0, 0, 0, 0, // 20: rfu
+    0, 0, 0, 0, // 24: rfu
+    0, 0, 0, 0, // 28: rfu
+    0, 0, 0, 0, // 32: salt
+    0, 0, 0, 0, // 36: salt
+    0, 0, 0, 0, // 40: salt
+    0, 0, 0, 0, // 44: salt
+    0, 0, 0, 0, // 48: personal
+    0, 0, 0, 0, // 52: personal
+    0, 0, 0, 0, // 56: personal
+    0, 0, 0, 0 // 60: personal
+]);
+// Creates a BLAKE2b hashing context
+// Requires an output length between 1 and 64 bytes
+// Takes an optional Uint8Array key
+function Blake2b(outlen, key, salt, personal) {
+    // zero out parameter_block before usage
+    parameter_block.fill(0);
+    // state, 'param block'
+    this.b = new Uint8Array(128);
+    this.h = new Uint32Array(16);
+    this.t = 0; // input count
+    this.c = 0; // pointer within buffer
+    this.outlen = outlen; // output length in bytes
+    parameter_block[0] = outlen;
+    if (key)
+        parameter_block[1] = key.length;
+    parameter_block[2] = 1; // fanout
+    parameter_block[3] = 1; // depth
+    if (salt)
+        parameter_block.set(salt, 32);
+    if (personal)
+        parameter_block.set(personal, 48);
+    // initialize hash state
+    for (var i = 0; i < 16; i++) {
+        this.h[i] = BLAKE2B_IV32[i] ^ B2B_GET32(parameter_block, i * 4);
+    }
+    // key the hash, if applicable
+    if (key) {
+        blake2bUpdate(this, key);
+        // at the end
+        this.c = 128;
+    }
+}
+Blake2b.prototype.update = function (input) {
+    blake2bUpdate(this, input);
+    return this;
+};
+Blake2b.prototype.digest = function (out) {
+    var buf = (!out || out === 'binary' || out === 'hex') ? new Uint8Array(this.outlen) : out;
+    blake2bFinal(this, buf);
+    if (out === 'hex')
+        return hexSlice(buf);
+    return buf;
+};
+Blake2b.prototype.final = Blake2b.prototype.digest;
+// Updates a BLAKE2b streaming hash
+// Requires hash context and Uint8Array (byte array)
+function blake2bUpdate(ctx, input) {
+    for (var i = 0; i < input.length; i++) {
+        if (ctx.c === 128) { // buffer full ?
+            ctx.t += ctx.c; // add counters
+            blake2bCompress(ctx, false); // compress (not last)
+            ctx.c = 0; // counter to zero
+        }
+        ctx.b[ctx.c++] = input[i];
+    }
+}
+// Completes a BLAKE2b streaming hash
+// Returns a Uint8Array containing the message digest
+function blake2bFinal(ctx, out) {
+    ctx.t += ctx.c; // mark last block offset
+    while (ctx.c < 128) { // fill up with zeros
+        ctx.b[ctx.c++] = 0;
+    }
+    blake2bCompress(ctx, true); // final block flag = 1
+    for (var i = 0; i < ctx.outlen; i++) {
+        out[i] = ctx.h[i >> 2] >> (8 * (i & 3));
+    }
+    return out;
+}
+function hexSlice(buf) {
+    var str = '';
+    for (var i = 0; i < buf.length; i++)
+        str += toHex(buf[i]);
+    return str;
+}
+function toHex(n) {
+    if (n < 16)
+        return '0' + n.toString(16);
+    return n.toString(16);
+}
+export default Blake2b;

package/dist/crypto/cnBase58.d.ts

@@ -0,0 +1,7 @@
+export default cnBase58;
+declare namespace cnBase58 {
+    function encode_block(data: any, buf: any, index: any): any;
+    function encode(hex: any): string;
+    function decode_block(data: any, buf: any, index: any): any;
+    function decode(enc: any): string;
+}

package/dist/crypto/cnBase58.js

@@ -0,0 +1,209 @@
+import { BigInteger as JSBigInt } from './biginteger';
+/**
+Copyright (c) 2017, moneroexamples
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+may be used to endorse or promote products derived from this software without
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Parts of the project are originally copyright (c) 2014-2017, MyMonero.com
+*/
+var cnBase58 = (function () {
+    var b58 = {};
+    var alphabet_str = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    var alphabet = [];
+    for (var i = 0; i < alphabet_str.length; i++) {
+        alphabet.push(alphabet_str.charCodeAt(i));
+    }
+    var encoded_block_sizes = [0, 2, 3, 5, 6, 7, 9, 10, 11];
+    var alphabet_size = alphabet.length;
+    var full_block_size = 8;
+    var full_encoded_block_size = 11;
+    var UINT64_MAX = new JSBigInt(2).pow(64);
+    function hextobin(hex) {
+        if (hex.length % 2 !== 0)
+            throw "Hex string has invalid length!";
+        var res = new Uint8Array(hex.length / 2);
+        for (var i = 0; i < hex.length / 2; ++i) {
+            res[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+        }
+        return res;
+    }
+    function bintohex(bin) {
+        var out = [];
+        for (var i = 0; i < bin.length; ++i) {
+            out.push(("0" + bin[i].toString(16)).slice(-2));
+        }
+        return out.join("");
+    }
+    function strtobin(str) {
+        var res = new Uint8Array(str.length);
+        for (var i = 0; i < str.length; i++) {
+            res[i] = str.charCodeAt(i);
+        }
+        return res;
+    }
+    function bintostr(bin) {
+        var out = [];
+        for (var i = 0; i < bin.length; i++) {
+            out.push(String.fromCharCode(bin[i]));
+        }
+        return out.join("");
+    }
+    function uint8_be_to_64(data) {
+        if (data.length < 1 || data.length > 8) {
+            throw "Invalid input length";
+        }
+        var res = JSBigInt.ZERO;
+        var twopow8 = new JSBigInt(2).pow(8);
+        var i = 0;
+        switch (9 - data.length) {
+            case 1:
+                res = res.add(data[i++]);
+            case 2:
+                res = res.multiply(twopow8).add(data[i++]);
+            case 3:
+                res = res.multiply(twopow8).add(data[i++]);
+            case 4:
+                res = res.multiply(twopow8).add(data[i++]);
+            case 5:
+                res = res.multiply(twopow8).add(data[i++]);
+            case 6:
+                res = res.multiply(twopow8).add(data[i++]);
+            case 7:
+                res = res.multiply(twopow8).add(data[i++]);
+            case 8:
+                res = res.multiply(twopow8).add(data[i++]);
+                break;
+            default:
+                throw "Impossible condition";
+        }
+        return res;
+    }
+    function uint64_to_8be(num, size) {
+        var res = new Uint8Array(size);
+        if (size < 1 || size > 8) {
+            throw "Invalid input length";
+        }
+        var twopow8 = new JSBigInt(2).pow(8);
+        for (var i = size - 1; i >= 0; i--) {
+            res[i] = num.remainder(twopow8).toJSValue();
+            num = num.divide(twopow8);
+        }
+        return res;
+    }
+    b58.encode_block = function (data, buf, index) {
+        if (data.length < 1 || data.length > full_encoded_block_size) {
+            throw "Invalid block length: " + data.length;
+        }
+        var num = uint8_be_to_64(data);
+        var i = encoded_block_sizes[data.length] - 1;
+        // while num > 0
+        while (num.compare(0) === 1) {
+            var div = num.divRem(alphabet_size);
+            // remainder = num % alphabet_size
+            var remainder = div[1];
+            // num = num / alphabet_size
+            num = div[0];
+            buf[index + i] = alphabet[remainder.toJSValue()];
+            i--;
+        }
+        return buf;
+    };
+    b58.encode = function (hex) {
+        var data = hextobin(hex);
+        if (data.length === 0) {
+            return "";
+        }
+        var full_block_count = Math.floor(data.length / full_block_size);
+        var last_block_size = data.length % full_block_size;
+        var res_size = full_block_count * full_encoded_block_size + encoded_block_sizes[last_block_size];
+        var res = new Uint8Array(res_size);
+        var i;
+        for (i = 0; i < res_size; ++i) {
+            res[i] = alphabet[0];
+        }
+        for (i = 0; i < full_block_count; i++) {
+            res = b58.encode_block(data.subarray(i * full_block_size, i * full_block_size + full_block_size), res, i * full_encoded_block_size);
+        }
+        if (last_block_size > 0) {
+            res = b58.encode_block(data.subarray(full_block_count * full_block_size, full_block_count * full_block_size + last_block_size), res, full_block_count * full_encoded_block_size);
+        }
+        return bintostr(res);
+    };
+    b58.decode_block = function (data, buf, index) {
+        if (data.length < 1 || data.length > full_encoded_block_size) {
+            throw "Invalid block length: " + data.length;
+        }
+        var res_size = encoded_block_sizes.indexOf(data.length);
+        if (res_size <= 0) {
+            throw "Invalid block size";
+        }
+        var res_num = new JSBigInt(0);
+        var order = new JSBigInt(1);
+        for (var i = data.length - 1; i >= 0; i--) {
+            var digit = alphabet.indexOf(data[i]);
+            if (digit < 0) {
+                throw "Invalid symbol";
+            }
+            var product = order.multiply(digit).add(res_num);
+            // if product > UINT64_MAX
+            if (product.compare(UINT64_MAX) === 1) {
+                throw "Overflow";
+            }
+            res_num = product;
+            order = order.multiply(alphabet_size);
+        }
+        if (res_size < full_block_size && (new JSBigInt(2).pow(8 * res_size).compare(res_num) <= 0)) {
+            throw "Overflow 2";
+        }
+        buf.set(uint64_to_8be(res_num, res_size), index);
+        return buf;
+    };
+    b58.decode = function (enc) {
+        enc = strtobin(enc);
+        if (enc.length === 0) {
+            return "";
+        }
+        var full_block_count = Math.floor(enc.length / full_encoded_block_size);
+        var last_block_size = enc.length % full_encoded_block_size;
+        var last_block_decoded_size = encoded_block_sizes.indexOf(last_block_size);
+        if (last_block_decoded_size < 0) {
+            throw "Invalid encoded length";
+        }
+        var data_size = full_block_count * full_block_size + last_block_decoded_size;
+        var data = new Uint8Array(data_size);
+        for (var i = 0; i < full_block_count; i++) {
+            data = b58.decode_block(enc.subarray(i * full_encoded_block_size, i * full_encoded_block_size + full_encoded_block_size), data, i * full_block_size);
+        }
+        if (last_block_size > 0) {
+            data = b58.decode_block(enc.subarray(full_block_count * full_encoded_block_size, full_block_count * full_encoded_block_size + last_block_size), data, full_block_count * full_block_size);
+        }
+        return bintohex(data);
+    };
+    return b58;
+})();
+export default cnBase58;

package/dist/crypto/segwit_addr.d.ts

@@ -0,0 +1,12 @@
+declare namespace _default {
+    export { encode };
+    export { decode };
+    export { isValidAddress };
+}
+export default _default;
+declare function encode(hrp: any, version: any, program: any): any;
+declare function decode(hrp: any, addr: any): {
+    version: any;
+    program: number[];
+};
+declare function isValidAddress(address: any, opts?: {}): boolean;