496 lines
20 KiB
JavaScript
496 lines
20 KiB
JavaScript
"use strict";
|
|
/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.bytes = exports.stringToBytes = exports.str = exports.bytesToString = exports.hex = exports.utf8 = exports.bech32m = exports.bech32 = exports.base58check = exports.createBase58check = exports.base58xmr = exports.base58xrp = exports.base58flickr = exports.base58 = exports.base64urlnopad = exports.base64url = exports.base64nopad = exports.base64 = exports.base32crockford = exports.base32hexnopad = exports.base32hex = exports.base32nopad = exports.base32 = exports.base16 = exports.utils = void 0;
|
|
exports.assertNumber = assertNumber;
|
|
// Utilities
|
|
/**
|
|
* @__NO_SIDE_EFFECTS__
|
|
*/
|
|
function assertNumber(n) {
|
|
if (!Number.isSafeInteger(n))
|
|
throw new Error(`Wrong integer: ${n}`);
|
|
}
|
|
function isBytes(a) {
|
|
return (a instanceof Uint8Array ||
|
|
(a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
|
|
}
|
|
/**
|
|
* @__NO_SIDE_EFFECTS__
|
|
*/
|
|
function chain(...args) {
|
|
const id = (a) => a;
|
|
// Wrap call in closure so JIT can inline calls
|
|
const wrap = (a, b) => (c) => a(b(c));
|
|
// Construct chain of args[-1].encode(args[-2].encode([...]))
|
|
const encode = args.map((x) => x.encode).reduceRight(wrap, id);
|
|
// Construct chain of args[0].decode(args[1].decode(...))
|
|
const decode = args.map((x) => x.decode).reduce(wrap, id);
|
|
return { encode, decode };
|
|
}
|
|
/**
|
|
* Encodes integer radix representation to array of strings using alphabet and back
|
|
* @__NO_SIDE_EFFECTS__
|
|
*/
|
|
function alphabet(alphabet) {
|
|
return {
|
|
encode: (digits) => {
|
|
if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number'))
|
|
throw new Error('alphabet.encode input should be an array of numbers');
|
|
return digits.map((i) => {
|
|
assertNumber(i);
|
|
if (i < 0 || i >= alphabet.length)
|
|
throw new Error(`Digit index outside alphabet: ${i} (alphabet: ${alphabet.length})`);
|
|
return alphabet[i];
|
|
});
|
|
},
|
|
decode: (input) => {
|
|
if (!Array.isArray(input) || (input.length && typeof input[0] !== 'string'))
|
|
throw new Error('alphabet.decode input should be array of strings');
|
|
return input.map((letter) => {
|
|
if (typeof letter !== 'string')
|
|
throw new Error(`alphabet.decode: not string element=${letter}`);
|
|
const index = alphabet.indexOf(letter);
|
|
if (index === -1)
|
|
throw new Error(`Unknown letter: "${letter}". Allowed: ${alphabet}`);
|
|
return index;
|
|
});
|
|
},
|
|
};
|
|
}
|
|
/**
|
|
* @__NO_SIDE_EFFECTS__
|
|
*/
|
|
function join(separator = '') {
|
|
if (typeof separator !== 'string')
|
|
throw new Error('join separator should be string');
|
|
return {
|
|
encode: (from) => {
|
|
if (!Array.isArray(from) || (from.length && typeof from[0] !== 'string'))
|
|
throw new Error('join.encode input should be array of strings');
|
|
for (let i of from)
|
|
if (typeof i !== 'string')
|
|
throw new Error(`join.encode: non-string input=${i}`);
|
|
return from.join(separator);
|
|
},
|
|
decode: (to) => {
|
|
if (typeof to !== 'string')
|
|
throw new Error('join.decode input should be string');
|
|
return to.split(separator);
|
|
},
|
|
};
|
|
}
|
|
/**
|
|
* Pad strings array so it has integer number of bits
|
|
* @__NO_SIDE_EFFECTS__
|
|
*/
|
|
function padding(bits, chr = '=') {
|
|
assertNumber(bits);
|
|
if (typeof chr !== 'string')
|
|
throw new Error('padding chr should be string');
|
|
return {
|
|
encode(data) {
|
|
if (!Array.isArray(data) || (data.length && typeof data[0] !== 'string'))
|
|
throw new Error('padding.encode input should be array of strings');
|
|
for (let i of data)
|
|
if (typeof i !== 'string')
|
|
throw new Error(`padding.encode: non-string input=${i}`);
|
|
while ((data.length * bits) % 8)
|
|
data.push(chr);
|
|
return data;
|
|
},
|
|
decode(input) {
|
|
if (!Array.isArray(input) || (input.length && typeof input[0] !== 'string'))
|
|
throw new Error('padding.encode input should be array of strings');
|
|
for (let i of input)
|
|
if (typeof i !== 'string')
|
|
throw new Error(`padding.decode: non-string input=${i}`);
|
|
let end = input.length;
|
|
if ((end * bits) % 8)
|
|
throw new Error('Invalid padding: string should have whole number of bytes');
|
|
for (; end > 0 && input[end - 1] === chr; end--) {
|
|
if (!(((end - 1) * bits) % 8))
|
|
throw new Error('Invalid padding: string has too much padding');
|
|
}
|
|
return input.slice(0, end);
|
|
},
|
|
};
|
|
}
|
|
/**
|
|
* @__NO_SIDE_EFFECTS__
|
|
*/
|
|
function normalize(fn) {
|
|
if (typeof fn !== 'function')
|
|
throw new Error('normalize fn should be function');
|
|
return { encode: (from) => from, decode: (to) => fn(to) };
|
|
}
|
|
/**
|
|
* Slow: O(n^2) time complexity
|
|
* @__NO_SIDE_EFFECTS__
|
|
*/
|
|
function convertRadix(data, from, to) {
|
|
// base 1 is impossible
|
|
if (from < 2)
|
|
throw new Error(`convertRadix: wrong from=${from}, base cannot be less than 2`);
|
|
if (to < 2)
|
|
throw new Error(`convertRadix: wrong to=${to}, base cannot be less than 2`);
|
|
if (!Array.isArray(data))
|
|
throw new Error('convertRadix: data should be array');
|
|
if (!data.length)
|
|
return [];
|
|
let pos = 0;
|
|
const res = [];
|
|
const digits = Array.from(data);
|
|
digits.forEach((d) => {
|
|
assertNumber(d);
|
|
if (d < 0 || d >= from)
|
|
throw new Error(`Wrong integer: ${d}`);
|
|
});
|
|
while (true) {
|
|
let carry = 0;
|
|
let done = true;
|
|
for (let i = pos; i < digits.length; i++) {
|
|
const digit = digits[i];
|
|
const digitBase = from * carry + digit;
|
|
if (!Number.isSafeInteger(digitBase) ||
|
|
(from * carry) / from !== carry ||
|
|
digitBase - digit !== from * carry) {
|
|
throw new Error('convertRadix: carry overflow');
|
|
}
|
|
carry = digitBase % to;
|
|
const rounded = Math.floor(digitBase / to);
|
|
digits[i] = rounded;
|
|
if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)
|
|
throw new Error('convertRadix: carry overflow');
|
|
if (!done)
|
|
continue;
|
|
else if (!rounded)
|
|
pos = i;
|
|
else
|
|
done = false;
|
|
}
|
|
res.push(carry);
|
|
if (done)
|
|
break;
|
|
}
|
|
for (let i = 0; i < data.length - 1 && data[i] === 0; i++)
|
|
res.push(0);
|
|
return res.reverse();
|
|
}
|
|
const gcd = /* @__NO_SIDE_EFFECTS__ */ (a, b) => (!b ? a : gcd(b, a % b));
|
|
const radix2carry = /*@__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to));
|
|
/**
|
|
* Implemented with numbers, because BigInt is 5x slower
|
|
* @__NO_SIDE_EFFECTS__
|
|
*/
|
|
function convertRadix2(data, from, to, padding) {
|
|
if (!Array.isArray(data))
|
|
throw new Error('convertRadix2: data should be array');
|
|
if (from <= 0 || from > 32)
|
|
throw new Error(`convertRadix2: wrong from=${from}`);
|
|
if (to <= 0 || to > 32)
|
|
throw new Error(`convertRadix2: wrong to=${to}`);
|
|
if (radix2carry(from, to) > 32) {
|
|
throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${radix2carry(from, to)}`);
|
|
}
|
|
let carry = 0;
|
|
let pos = 0; // bitwise position in current element
|
|
const mask = 2 ** to - 1;
|
|
const res = [];
|
|
for (const n of data) {
|
|
assertNumber(n);
|
|
if (n >= 2 ** from)
|
|
throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
|
|
carry = (carry << from) | n;
|
|
if (pos + from > 32)
|
|
throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
|
|
pos += from;
|
|
for (; pos >= to; pos -= to)
|
|
res.push(((carry >> (pos - to)) & mask) >>> 0);
|
|
carry &= 2 ** pos - 1; // clean carry, otherwise it will cause overflow
|
|
}
|
|
carry = (carry << (to - pos)) & mask;
|
|
if (!padding && pos >= from)
|
|
throw new Error('Excess padding');
|
|
if (!padding && carry)
|
|
throw new Error(`Non-zero padding: ${carry}`);
|
|
if (padding && pos > 0)
|
|
res.push(carry >>> 0);
|
|
return res;
|
|
}
|
|
/**
|
|
* @__NO_SIDE_EFFECTS__
|
|
*/
|
|
function radix(num) {
|
|
assertNumber(num);
|
|
return {
|
|
encode: (bytes) => {
|
|
if (!isBytes(bytes))
|
|
throw new Error('radix.encode input should be Uint8Array');
|
|
return convertRadix(Array.from(bytes), 2 ** 8, num);
|
|
},
|
|
decode: (digits) => {
|
|
if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number'))
|
|
throw new Error('radix.decode input should be array of numbers');
|
|
return Uint8Array.from(convertRadix(digits, num, 2 ** 8));
|
|
},
|
|
};
|
|
}
|
|
/**
|
|
* If both bases are power of same number (like `2**8 <-> 2**64`),
|
|
* there is a linear algorithm. For now we have implementation for power-of-two bases only.
|
|
* @__NO_SIDE_EFFECTS__
|
|
*/
|
|
function radix2(bits, revPadding = false) {
|
|
assertNumber(bits);
|
|
if (bits <= 0 || bits > 32)
|
|
throw new Error('radix2: bits should be in (0..32]');
|
|
if (radix2carry(8, bits) > 32 || radix2carry(bits, 8) > 32)
|
|
throw new Error('radix2: carry overflow');
|
|
return {
|
|
encode: (bytes) => {
|
|
if (!isBytes(bytes))
|
|
throw new Error('radix2.encode input should be Uint8Array');
|
|
return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
|
|
},
|
|
decode: (digits) => {
|
|
if (!Array.isArray(digits) || (digits.length && typeof digits[0] !== 'number'))
|
|
throw new Error('radix2.decode input should be array of numbers');
|
|
return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
|
|
},
|
|
};
|
|
}
|
|
/**
|
|
* @__NO_SIDE_EFFECTS__
|
|
*/
|
|
function unsafeWrapper(fn) {
|
|
if (typeof fn !== 'function')
|
|
throw new Error('unsafeWrapper fn should be function');
|
|
return function (...args) {
|
|
try {
|
|
return fn.apply(null, args);
|
|
}
|
|
catch (e) { }
|
|
};
|
|
}
|
|
/**
|
|
* @__NO_SIDE_EFFECTS__
|
|
*/
|
|
function checksum(len, fn) {
|
|
assertNumber(len);
|
|
if (typeof fn !== 'function')
|
|
throw new Error('checksum fn should be function');
|
|
return {
|
|
encode(data) {
|
|
if (!isBytes(data))
|
|
throw new Error('checksum.encode: input should be Uint8Array');
|
|
const checksum = fn(data).slice(0, len);
|
|
const res = new Uint8Array(data.length + len);
|
|
res.set(data);
|
|
res.set(checksum, data.length);
|
|
return res;
|
|
},
|
|
decode(data) {
|
|
if (!isBytes(data))
|
|
throw new Error('checksum.decode: input should be Uint8Array');
|
|
const payload = data.slice(0, -len);
|
|
const newChecksum = fn(payload).slice(0, len);
|
|
const oldChecksum = data.slice(-len);
|
|
for (let i = 0; i < len; i++)
|
|
if (newChecksum[i] !== oldChecksum[i])
|
|
throw new Error('Invalid checksum');
|
|
return payload;
|
|
},
|
|
};
|
|
}
|
|
// prettier-ignore
|
|
exports.utils = {
|
|
alphabet, chain, checksum, convertRadix, convertRadix2, radix, radix2, join, padding,
|
|
};
|
|
// RFC 4648 aka RFC 3548
|
|
// ---------------------
|
|
exports.base16 = chain(radix2(4), alphabet('0123456789ABCDEF'), join(''));
|
|
exports.base32 = chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), padding(5), join(''));
|
|
exports.base32nopad = chain(radix2(5), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'), join(''));
|
|
exports.base32hex = chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), padding(5), join(''));
|
|
exports.base32hexnopad = chain(radix2(5), alphabet('0123456789ABCDEFGHIJKLMNOPQRSTUV'), join(''));
|
|
exports.base32crockford = chain(radix2(5), alphabet('0123456789ABCDEFGHJKMNPQRSTVWXYZ'), join(''), normalize((s) => s.toUpperCase().replace(/O/g, '0').replace(/[IL]/g, '1')));
|
|
exports.base64 = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), padding(6), join(''));
|
|
exports.base64nopad = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'), join(''));
|
|
exports.base64url = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), padding(6), join(''));
|
|
exports.base64urlnopad = chain(radix2(6), alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'), join(''));
|
|
// base58 code
|
|
// -----------
|
|
const genBase58 = (abc) => chain(radix(58), alphabet(abc), join(''));
|
|
exports.base58 = genBase58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
|
|
exports.base58flickr = genBase58('123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ');
|
|
exports.base58xrp = genBase58('rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz');
|
|
// xmr ver is done in 8-byte blocks (which equals 11 chars in decoding). Last (non-full) block padded with '1' to size in XMR_BLOCK_LEN.
|
|
// Block encoding significantly reduces quadratic complexity of base58.
|
|
// Data len (index) -> encoded block len
|
|
const XMR_BLOCK_LEN = [0, 2, 3, 5, 6, 7, 9, 10, 11];
|
|
exports.base58xmr = {
|
|
encode(data) {
|
|
let res = '';
|
|
for (let i = 0; i < data.length; i += 8) {
|
|
const block = data.subarray(i, i + 8);
|
|
res += exports.base58.encode(block).padStart(XMR_BLOCK_LEN[block.length], '1');
|
|
}
|
|
return res;
|
|
},
|
|
decode(str) {
|
|
let res = [];
|
|
for (let i = 0; i < str.length; i += 11) {
|
|
const slice = str.slice(i, i + 11);
|
|
const blockLen = XMR_BLOCK_LEN.indexOf(slice.length);
|
|
const block = exports.base58.decode(slice);
|
|
for (let j = 0; j < block.length - blockLen; j++) {
|
|
if (block[j] !== 0)
|
|
throw new Error('base58xmr: wrong padding');
|
|
}
|
|
res = res.concat(Array.from(block.slice(block.length - blockLen)));
|
|
}
|
|
return Uint8Array.from(res);
|
|
},
|
|
};
|
|
const createBase58check = (sha256) => chain(checksum(4, (data) => sha256(sha256(data))), exports.base58);
|
|
exports.createBase58check = createBase58check;
|
|
// legacy export, bad name
|
|
exports.base58check = exports.createBase58check;
|
|
const BECH_ALPHABET = /* @__PURE__ */ chain(alphabet('qpzry9x8gf2tvdw0s3jn54khce6mua7l'), join(''));
|
|
const POLYMOD_GENERATORS = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3];
|
|
/**
|
|
* @__NO_SIDE_EFFECTS__
|
|
*/
|
|
function bech32Polymod(pre) {
|
|
const b = pre >> 25;
|
|
let chk = (pre & 0x1ffffff) << 5;
|
|
for (let i = 0; i < POLYMOD_GENERATORS.length; i++) {
|
|
if (((b >> i) & 1) === 1)
|
|
chk ^= POLYMOD_GENERATORS[i];
|
|
}
|
|
return chk;
|
|
}
|
|
/**
|
|
* @__NO_SIDE_EFFECTS__
|
|
*/
|
|
function bechChecksum(prefix, words, encodingConst = 1) {
|
|
const len = prefix.length;
|
|
let chk = 1;
|
|
for (let i = 0; i < len; i++) {
|
|
const c = prefix.charCodeAt(i);
|
|
if (c < 33 || c > 126)
|
|
throw new Error(`Invalid prefix (${prefix})`);
|
|
chk = bech32Polymod(chk) ^ (c >> 5);
|
|
}
|
|
chk = bech32Polymod(chk);
|
|
for (let i = 0; i < len; i++)
|
|
chk = bech32Polymod(chk) ^ (prefix.charCodeAt(i) & 0x1f);
|
|
for (let v of words)
|
|
chk = bech32Polymod(chk) ^ v;
|
|
for (let i = 0; i < 6; i++)
|
|
chk = bech32Polymod(chk);
|
|
chk ^= encodingConst;
|
|
return BECH_ALPHABET.encode(convertRadix2([chk % 2 ** 30], 30, 5, false));
|
|
}
|
|
/**
|
|
* @__NO_SIDE_EFFECTS__
|
|
*/
|
|
function genBech32(encoding) {
|
|
const ENCODING_CONST = encoding === 'bech32' ? 1 : 0x2bc830a3;
|
|
const _words = radix2(5);
|
|
const fromWords = _words.decode;
|
|
const toWords = _words.encode;
|
|
const fromWordsUnsafe = unsafeWrapper(fromWords);
|
|
function encode(prefix, words, limit = 90) {
|
|
if (typeof prefix !== 'string')
|
|
throw new Error(`bech32.encode prefix should be string, not ${typeof prefix}`);
|
|
if (words instanceof Uint8Array)
|
|
words = Array.from(words);
|
|
if (!Array.isArray(words) || (words.length && typeof words[0] !== 'number'))
|
|
throw new Error(`bech32.encode words should be array of numbers, not ${typeof words}`);
|
|
if (prefix.length === 0)
|
|
throw new TypeError(`Invalid prefix length ${prefix.length}`);
|
|
const actualLength = prefix.length + 7 + words.length;
|
|
if (limit !== false && actualLength > limit)
|
|
throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);
|
|
const lowered = prefix.toLowerCase();
|
|
const sum = bechChecksum(lowered, words, ENCODING_CONST);
|
|
return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}`;
|
|
}
|
|
function decode(str, limit = 90) {
|
|
if (typeof str !== 'string')
|
|
throw new Error(`bech32.decode input should be string, not ${typeof str}`);
|
|
if (str.length < 8 || (limit !== false && str.length > limit))
|
|
throw new TypeError(`Wrong string length: ${str.length} (${str}). Expected (8..${limit})`);
|
|
// don't allow mixed case
|
|
const lowered = str.toLowerCase();
|
|
if (str !== lowered && str !== str.toUpperCase())
|
|
throw new Error(`String must be lowercase or uppercase`);
|
|
const sepIndex = lowered.lastIndexOf('1');
|
|
if (sepIndex === 0 || sepIndex === -1)
|
|
throw new Error(`Letter "1" must be present between prefix and data only`);
|
|
const prefix = lowered.slice(0, sepIndex);
|
|
const data = lowered.slice(sepIndex + 1);
|
|
if (data.length < 6)
|
|
throw new Error('Data must be at least 6 characters long');
|
|
const words = BECH_ALPHABET.decode(data).slice(0, -6);
|
|
const sum = bechChecksum(prefix, words, ENCODING_CONST);
|
|
if (!data.endsWith(sum))
|
|
throw new Error(`Invalid checksum in ${str}: expected "${sum}"`);
|
|
return { prefix, words };
|
|
}
|
|
const decodeUnsafe = unsafeWrapper(decode);
|
|
function decodeToBytes(str) {
|
|
const { prefix, words } = decode(str, false);
|
|
return { prefix, words, bytes: fromWords(words) };
|
|
}
|
|
function encodeFromBytes(prefix, bytes) {
|
|
return encode(prefix, toWords(bytes));
|
|
}
|
|
return {
|
|
encode,
|
|
decode,
|
|
encodeFromBytes,
|
|
decodeToBytes,
|
|
decodeUnsafe,
|
|
fromWords,
|
|
fromWordsUnsafe,
|
|
toWords,
|
|
};
|
|
}
|
|
exports.bech32 = genBech32('bech32');
|
|
exports.bech32m = genBech32('bech32m');
|
|
exports.utf8 = {
|
|
encode: (data) => new TextDecoder().decode(data),
|
|
decode: (str) => new TextEncoder().encode(str),
|
|
};
|
|
exports.hex = chain(radix2(4), alphabet('0123456789abcdef'), join(''), normalize((s) => {
|
|
if (typeof s !== 'string' || s.length % 2)
|
|
throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`);
|
|
return s.toLowerCase();
|
|
}));
|
|
// prettier-ignore
|
|
const CODERS = {
|
|
utf8: exports.utf8, hex: exports.hex, base16: exports.base16, base32: exports.base32, base64: exports.base64, base64url: exports.base64url, base58: exports.base58, base58xmr: exports.base58xmr
|
|
};
|
|
const coderTypeError = 'Invalid encoding type. Available types: utf8, hex, base16, base32, base64, base64url, base58, base58xmr';
|
|
const bytesToString = (type, bytes) => {
|
|
if (typeof type !== 'string' || !CODERS.hasOwnProperty(type))
|
|
throw new TypeError(coderTypeError);
|
|
if (!isBytes(bytes))
|
|
throw new TypeError('bytesToString() expects Uint8Array');
|
|
return CODERS[type].encode(bytes);
|
|
};
|
|
exports.bytesToString = bytesToString;
|
|
exports.str = exports.bytesToString; // as in python, but for bytes only
|
|
const stringToBytes = (type, str) => {
|
|
if (!CODERS.hasOwnProperty(type))
|
|
throw new TypeError(coderTypeError);
|
|
if (typeof str !== 'string')
|
|
throw new TypeError('stringToBytes() expects string');
|
|
return CODERS[type].decode(str);
|
|
};
|
|
exports.stringToBytes = stringToBytes;
|
|
exports.bytes = exports.stringToBytes;
|
|
//# sourceMappingURL=index.js.map
|