@hdwallet/core
Version:
A complete Hierarchical Deterministic (HD) Wallet generator for 200+ cryptocurrencies, built with TypeScript.
83,715 lines • 1.85 MB
JavaScript
const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !== 'undefined' ? window: typeof global !== 'undefined' ? global: typeof self !== 'undefined' ? self: {});
// SPDX-License-Identifier: MIT
const __name__ = 'hdwallet';
const __version__ = '1.0.0-beta.9';
const __license__ = 'MIT';
const __author__ = 'Meheret Tesfaye Batu';
const __email__ = 'meherett.batu@gmail.com';
// export const __documentation__: string = '...';
const __description__ = 'A complete Hierarchical Deterministic (HD) Wallet generator for 200+ cryptocurrencies, built with TypeScript.';
const __url__ = 'https://hdwallet.io';
const __source__ = 'https://github.com/hdwallet-io/hdwallet.js';
const __changelog__ = `${__source__}/blob/master/CHANGELOG.md`;
const __tracker__ = `${__source__}/issues`;
const __keywords__ = [
'ecc', 'kholaw', 'slip10', 'ed25519', 'nist256p1', 'secp256k1',
'hd', 'bip32', 'bip44', 'bip49', 'bip84', 'bip86', 'bip141', 'monero', 'cardano',
'entropy', 'mnemonic', 'seed', 'bip39', 'algorand', 'electrum',
'cryptocurrencies', 'bitcoin', 'ethereum', 'cryptography', 'cli', 'cip1852'
];
const __websites__ = [
'https://talonlab.org',
'https://talonlab.gitbook.io/hdwallet',
// __documentation__,
'https://hdwallet.online',
'https://hd.wallet',
__url__
];
var info = /*#__PURE__*/Object.freeze({
__proto__: null,
__name__: __name__,
__version__: __version__,
__license__: __license__,
__author__: __author__,
__email__: __email__,
__description__: __description__,
__url__: __url__,
__source__: __source__,
__changelog__: __changelog__,
__tracker__: __tracker__,
__keywords__: __keywords__,
__websites__: __websites__
});
// SPDX-License-Identifier: MIT
class BaseError extends Error {
constructor(message, options) {
if ((options?.expected || options?.got) && options?.detail) {
super(`${message}, (expected: ${options?.expected} | got: ${options?.got}) ${options?.detail}`);
}
else if (options?.expected || options?.got) {
super(`${message}, (expected: ${options?.expected} | got: ${options?.got})`);
}
else if (options?.detail) {
super(`${message} ${options?.detail}`);
}
else {
super(`${message}`);
}
}
}
class TypeError$1 extends BaseError {
}
class EntropyError extends BaseError {
}
class MnemonicError extends BaseError {
}
class SeedError extends BaseError {
}
class ECCError extends BaseError {
}
class ExtendedKeyError extends BaseError {
}
class XPrivateKeyError extends BaseError {
}
class XPublicKeyError extends BaseError {
}
class PrivateKeyError extends BaseError {
}
class WIFError extends BaseError {
}
class PublicKeyError extends BaseError {
}
class ChecksumError extends BaseError {
}
class SemanticError extends BaseError {
}
class NetworkError extends BaseError {
}
class AddressError extends BaseError {
}
class CryptocurrencyError extends BaseError {
}
class SymbolError extends BaseError {
}
class HDError extends BaseError {
}
class DerivationError extends BaseError {
}
const crypto$2 = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;
/**
* Utilities for hex, bytes, CSPRNG.
* @module
*/
/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
function isBytes(a) {
return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
}
/** Asserts something is positive integer. */
function anumber(n) {
if (!Number.isSafeInteger(n) || n < 0)
throw new Error('positive integer expected, got ' + n);
}
/** Asserts something is Uint8Array. */
function abytes(b, ...lengths) {
if (!isBytes(b))
throw new Error('Uint8Array expected');
if (lengths.length > 0 && !lengths.includes(b.length))
throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
}
/** Asserts something is hash */
function ahash(h) {
if (typeof h !== 'function' || typeof h.create !== 'function')
throw new Error('Hash should be wrapped by utils.createHasher');
anumber(h.outputLen);
anumber(h.blockLen);
}
/** Asserts a hash instance has not been destroyed / finished */
function aexists(instance, checkFinished = true) {
if (instance.destroyed)
throw new Error('Hash instance has been destroyed');
if (checkFinished && instance.finished)
throw new Error('Hash#digest() has already been called');
}
/** Asserts output is properly-sized byte array */
function aoutput(out, instance) {
abytes(out);
const min = instance.outputLen;
if (out.length < min) {
throw new Error('digestInto() expects output buffer of length at least ' + min);
}
}
/** Cast u8 / u16 / u32 to u32. */
function u32(arr) {
return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
}
/** Zeroize a byte array. Warning: JS provides no guarantees. */
function clean(...arrays) {
for (let i = 0; i < arrays.length; i++) {
arrays[i].fill(0);
}
}
/** Create DataView of an array for easy byte-level manipulation. */
function createView(arr) {
return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
}
/** The rotate right (circular right shift) operation for uint32 */
function rotr(word, shift) {
return (word << (32 - shift)) | (word >>> shift);
}
/** The rotate left (circular left shift) operation for uint32 */
function rotl(word, shift) {
return (word << shift) | ((word >>> (32 - shift)) >>> 0);
}
/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
/** The byte swap operation for uint32 */
function byteSwap(word) {
return (((word << 24) & 0xff000000) |
((word << 8) & 0xff0000) |
((word >>> 8) & 0xff00) |
((word >>> 24) & 0xff));
}
/** Conditionally byte swap if on a big-endian platform */
const swap8IfBE = isLE
? (n) => n
: (n) => byteSwap(n);
/** In place byte swap for Uint32Array */
function byteSwap32(arr) {
for (let i = 0; i < arr.length; i++) {
arr[i] = byteSwap(arr[i]);
}
return arr;
}
const swap32IfBE = isLE
? (u) => u
: byteSwap32;
// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex
const hasHexBuiltin = /* @__PURE__ */ (() =>
// @ts-ignore
typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();
// Array where index 0xf0 (240) is mapped to string 'f0'
const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
/**
* Convert byte array to hex string. Uses built-in function, when available.
* @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
*/
function bytesToHex$1(bytes) {
abytes(bytes);
// @ts-ignore
if (hasHexBuiltin)
return bytes.toHex();
// pre-caching improves the speed 6x
let hex = '';
for (let i = 0; i < bytes.length; i++) {
hex += hexes[bytes[i]];
}
return hex;
}
// We use optimized technique to convert hex string to byte array
const asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
function asciiToBase16(ch) {
if (ch >= asciis._0 && ch <= asciis._9)
return ch - asciis._0; // '2' => 50-48
if (ch >= asciis.A && ch <= asciis.F)
return ch - (asciis.A - 10); // 'B' => 66-(65-10)
if (ch >= asciis.a && ch <= asciis.f)
return ch - (asciis.a - 10); // 'b' => 98-(97-10)
return;
}
/**
* Convert hex string to byte array. Uses built-in function, when available.
* @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
*/
function hexToBytes$1(hex) {
if (typeof hex !== 'string')
throw new Error('hex string expected, got ' + typeof hex);
// @ts-ignore
if (hasHexBuiltin)
return Uint8Array.fromHex(hex);
const hl = hex.length;
const al = hl / 2;
if (hl % 2)
throw new Error('hex string expected, got unpadded hex of length ' + hl);
const array = new Uint8Array(al);
for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
const n1 = asciiToBase16(hex.charCodeAt(hi));
const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
if (n1 === undefined || n2 === undefined) {
const char = hex[hi] + hex[hi + 1];
throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
}
array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163
}
return array;
}
/**
* Converts string to bytes using UTF8 encoding.
* @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
*/
function utf8ToBytes(str) {
if (typeof str !== 'string')
throw new Error('string expected');
return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
}
/**
* Normalizes (non-hex) string or Uint8Array to Uint8Array.
* Warning: when Uint8Array is passed, it would NOT get copied.
* Keep in mind for future mutable operations.
*/
function toBytes(data) {
if (typeof data === 'string')
data = utf8ToBytes(data);
abytes(data);
return data;
}
/**
* Helper for KDFs: consumes uint8array or string.
* When string is passed, does utf8 decoding, using TextDecoder.
*/
function kdfInputToBytes(data) {
if (typeof data === 'string')
data = utf8ToBytes(data);
abytes(data);
return data;
}
/** Copies several Uint8Arrays into one. */
function concatBytes$1(...arrays) {
let sum = 0;
for (let i = 0; i < arrays.length; i++) {
const a = arrays[i];
abytes(a);
sum += a.length;
}
const res = new Uint8Array(sum);
for (let i = 0, pad = 0; i < arrays.length; i++) {
const a = arrays[i];
res.set(a, pad);
pad += a.length;
}
return res;
}
function checkOpts(defaults, opts) {
if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')
throw new Error('options should be object or undefined');
const merged = Object.assign(defaults, opts);
return merged;
}
/** For runtime check if class implements interface */
class Hash {
}
/** Wraps hash function, creating an interface on top of it */
function createHasher(hashCons) {
const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
const tmp = hashCons();
hashC.outputLen = tmp.outputLen;
hashC.blockLen = tmp.blockLen;
hashC.create = () => hashCons();
return hashC;
}
function createOptHasher(hashCons) {
const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
const tmp = hashCons({});
hashC.outputLen = tmp.outputLen;
hashC.blockLen = tmp.blockLen;
hashC.create = (opts) => hashCons(opts);
return hashC;
}
/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */
function randomBytes$1(bytesLength = 32) {
if (crypto$2 && typeof crypto$2.getRandomValues === 'function') {
return crypto$2.getRandomValues(new Uint8Array(bytesLength));
}
// Legacy Node.js compatibility
if (crypto$2 && typeof crypto$2.randomBytes === 'function') {
return Uint8Array.from(crypto$2.randomBytes(bytesLength));
}
throw new Error('crypto.getRandomValues must be defined');
}
// SPDX-License-Identifier: MIT
function getBytes(data, encoding = 'hex') {
if (data == null) {
return new Uint8Array();
}
// Already a Uint8Array?
if (data instanceof Uint8Array) {
return data;
}
// Array of numbers?
if (Array.isArray(data)) {
return new Uint8Array(data);
}
// From here on: data is a string
const str = data;
switch (encoding) {
case 'hex': {
// Strip optional 0x/0X
let s = str.startsWith('0x') || str.startsWith('0X') ? str.slice(2) : str;
// Pad odd length
if (s.length % 2 === 1)
s = '0' + s;
// Split into byte-pairs and parse
return Uint8Array.from(s.match(/.{1,2}/g).map(b => parseInt(b, 16)));
}
case 'utf8':
return new TextEncoder().encode(str);
case 'base64':
// atob → binary-string → map char codes
return Uint8Array.from(atob(str), c => c.charCodeAt(0));
default:
throw new Error(`Unsupported encoding: ${encoding}`);
}
}
function toBuffer(input, encoding = 'utf8') {
if (typeof input === 'string') {
switch (encoding) {
case 'utf8':
// UTF-8 encode a string
return new TextEncoder().encode(input);
case 'base64':
// atob gives a binary‐string; map char→byte
return Uint8Array.from(atob(input), c => c.charCodeAt(0));
case 'hex':
// split every two hex digits → parse → byte
return Uint8Array.from(input.match(/.{1,2}/g).map(byte => parseInt(byte, 16)));
default:
throw new Error(`Unsupported encoding: ${encoding}`);
}
}
// If it's already an ArrayBuffer or TypedArray
if (input instanceof ArrayBuffer) {
return new Uint8Array(input);
}
if (ArrayBuffer.isView(input)) {
return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
}
// Fallback: try Array-like (e.g. number[])
return Uint8Array.from(input);
}
function hexToBytes(hex) {
const normalized = hex.startsWith('0x') ? hex.slice(2) : hex;
if (normalized.length % 2 !== 0) {
throw new Error(`Invalid hex string length: ${normalized.length}`);
}
const bytes = new Uint8Array(normalized.length / 2);
for (let i = 0; i < bytes.length; i++) {
bytes[i] = parseInt(normalized.substr(i * 2, 2), 16);
}
return bytes;
}
function bytesToHex(bytes, prefix = false) {
const hex = Array.from(bytes)
.map(b => b.toString(16).padStart(2, '0'))
.join('');
return prefix ? `0x${hex}` : hex;
}
function bytesToString(data) {
if (data == null ||
(typeof data === 'string' && data.length === 0) ||
(data instanceof Uint8Array && data.length === 0)) {
return '';
}
if (typeof data === 'string') {
// If it’s a valid even-length hex string (0–9, A–F, a–f), return it lowercased:
if (data.length % 2 === 0 && /^[0-9A-Fa-f]+$/.test(data)) {
return data.toLowerCase();
}
// Otherwise treat `data` as UTF-8 text: encode to Uint8Array then to hex
const encoder = new TextEncoder();
const bytes = encoder.encode(data);
return bytesToHex(bytes);
}
// Uint8Array case: just convert those bytes to hex
return bytesToHex(data);
}
function randomBytes(len) {
if (!Number.isInteger(len) || len <= 0) {
throw new Error('randomBytes: length must be a positive integer');
}
return randomBytes$1(len);
}
function bytesToInteger(bytes, littleEndian = false) {
// if little-endian, reverse into a new array
const data = littleEndian
? bytes.slice().reverse()
: bytes;
return data.reduce((acc, b) => (acc << BigInt(8)) + BigInt(b), BigInt(0));
}
function ensureString(data) {
if (data instanceof Uint8Array) {
return new TextDecoder().decode(data);
}
if (typeof data === 'string') {
return data;
}
throw new TypeError$1('Invalid value for string');
}
function stringToInteger(data) {
let buf;
if (typeof data === 'string') {
// treat string as hex (even-length hex string)
buf = hexToBytes(data);
}
else {
buf = data;
}
let val = BigInt(0);
for (let i = 0; i < buf.length; i++) {
val = (val << BigInt(8)) + BigInt(buf[i]);
}
return val;
}
function equalBytes(a, b) {
if (a.length !== b.length)
return false;
for (let i = 0; i < a.length; i++) {
if (a[i] !== b[i])
return false;
}
return true;
}
function integerToBytes(value, length, endianness = 'big') {
// coerce to BigInt without using 0n
let val = typeof value === 'number' ? BigInt(value) : value;
if (val < BigInt(0)) {
throw new Error(`Cannot convert negative integers: ${val}`);
}
// build big-endian array
const bytes = [];
const ZERO = BigInt(0);
const SHIFT = BigInt(8);
const MASK = BigInt(0xff);
while (val > ZERO) {
// val & 0xffn → val & MASK
bytes.unshift(Number(val & MASK));
// val >>= 8n → val = val >> SHIFT
val = val >> SHIFT;
}
if (bytes.length === 0) {
bytes.push(0);
}
// pad/truncate
if (length !== undefined) {
if (bytes.length > length) {
throw new Error(`Integer too large to fit in ${length} bytes`);
}
while (bytes.length < length) {
bytes.unshift(0);
}
}
const result = new Uint8Array(bytes);
return endianness === 'little' ? result.reverse() : result;
}
function concatBytes(...chunks) {
const totalLength = chunks.reduce((sum, arr) => sum + arr.length, 0);
const result = new Uint8Array(totalLength);
let offset = 0;
for (const chunk of chunks) {
result.set(chunk, offset);
offset += chunk.length;
}
return result;
}
function bytesToBinaryString(data, zeroPadBits = 0) {
const bits = Array.from(data)
.map((b) => b.toString(2).padStart(8, '0'))
.join('');
return bits.length < zeroPadBits ? bits.padStart(zeroPadBits, '0') : bits;
}
function binaryStringToInteger(data) {
const bin = typeof data === 'string'
? data
: bytesToBinaryString(data);
const clean = bin.trim();
return BigInt('0b' + clean);
}
function integerToBinaryString(data, zeroPadBits = 0) {
const big = typeof data === 'bigint' ? data : BigInt(data);
const bits = big.toString(2);
return bits.length < zeroPadBits
? bits.padStart(zeroPadBits, '0')
: bits;
}
function binaryStringToBytes(data, zeroPadByteLen = 0) {
const bits = typeof data === 'string'
? data.trim()
: bytesToBinaryString(data);
const bitLen = bits.length;
const val = BigInt('0b' + bits);
let hex = val.toString(16);
if (hex.length % 2 === 1) {
hex = '0' + hex;
}
const byteLen = zeroPadByteLen > 0
? zeroPadByteLen
: Math.ceil(bitLen / 8);
const expectedHexLen = byteLen * 2;
if (hex.length < expectedHexLen) {
hex = hex.padStart(expectedHexLen, '0');
}
return hexToBytes(hex);
}
function isAllEqual(...inputs) {
if (inputs.length < 2)
return true;
const getTag = (v) => {
if (typeof v === 'string')
return 'string';
if (typeof v === 'number')
return 'number';
if (typeof v === 'boolean')
return 'boolean';
if (Array.isArray(v)) {
if (v.every(i => typeof i === 'number'))
return 'array:number';
if (v.every(i => typeof i === 'string'))
return 'array:string';
if (v.every(i => typeof i === 'boolean'))
return 'array:boolean';
return 'array:unknown';
}
if (v instanceof Uint8Array)
return 'uint8array';
if (v instanceof ArrayBuffer)
return 'arraybuffer';
if (ArrayBuffer.isView(v))
return 'view';
return 'unknown';
};
const firstTag = getTag(inputs[0]);
if (firstTag === 'unknown' || firstTag === 'array:unknown')
return false;
for (const v of inputs.slice(1)) {
if (getTag(v) !== firstTag)
return false;
}
if (firstTag === 'string' || firstTag === 'number' || firstTag === 'boolean') {
const first = inputs[0];
return inputs.every(v => v === first);
}
if (firstTag.startsWith('array:')) {
const firstArr = inputs[0];
const len = firstArr.length;
return inputs.slice(1).every(item => {
const arr = item;
if (arr.length !== len)
return false;
for (let i = 0; i < len; i++) {
if (arr[i] !== firstArr[i])
return false;
}
return true;
});
}
const normalize = (v) => {
if (v instanceof Uint8Array)
return v;
if (v instanceof ArrayBuffer)
return new Uint8Array(v);
return new Uint8Array(v.buffer, v.byteOffset, v.byteLength);
};
const firstArr = normalize(inputs[0]);
const len = firstArr.byteLength;
return inputs.slice(1).every(item => {
const arr = normalize(item);
if (arr.byteLength !== len)
return false;
for (let i = 0; i < len; i++) {
if (arr[i] !== firstArr[i])
return false;
}
return true;
});
}
function generatePassphrase(length = 32, chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789') {
const bytes = randomBytes(length);
let result = '';
for (let i = 0; i < length; i++) {
result += chars[bytes[i] % chars.length];
}
return result;
}
function getHmac(eccName) {
const encoder = new TextEncoder();
if ([
'Kholaw-Ed25519', 'SLIP10-Ed25519', 'SLIP10-Ed25519-Blake2b', 'SLIP10-Ed25519-Monero',
].includes(eccName)) {
return encoder.encode('ed25519 seed');
}
else if (eccName === 'SLIP10-Nist256p1') {
return encoder.encode('Nist256p1 seed');
}
else if (eccName === 'SLIP10-Secp256k1') {
return encoder.encode('Bitcoin seed');
}
throw new DerivationError('Unknown ECC name');
}
function excludeKeys(nested, keys) {
const out = {};
const keySet = new Set(keys); // optional optimization
for (const [k, v] of Object.entries(nested)) {
const normKey = k.replace(/-/g, '_');
if (keySet.has(normKey))
continue;
if (v &&
typeof v === 'object' &&
!Array.isArray(v) &&
!(v instanceof Uint8Array) &&
!(v instanceof Uint8Array)) {
out[k] = excludeKeys(v, keys);
}
else {
out[k] = v;
}
}
return out;
}
function pathToIndexes(path) {
if (path === 'm' || path === 'm/')
return [];
if (!path.startsWith('m/')) {
throw new DerivationError(`Bad path format, expected 'm/0'/0', got '${path}'`);
}
return path
.slice(2)
.split('/')
.map(i => i.endsWith("'")
? parseInt(i.slice(0, -1), 10) + 0x80000000
: parseInt(i, 10));
}
function indexesToPath(indexes) {
return ('m' +
indexes
.map(i => i & 0x80000000
? `/${(i & ~0x80000000).toString()}'`
: `/${i.toString()}`)
.join(''));
}
function normalizeIndex(index, hardened = false) {
if (typeof index === 'number') {
if (index < 0)
throw new DerivationError(`Bad index: ${index}`);
return [index, hardened];
}
if (typeof index === 'string') {
const m = index.match(/^(\d+)(?:-(\d+))?$/);
if (!m) {
throw new DerivationError(`Bad index format, got '${index}'`);
}
const from = parseInt(m[1], 10);
const to = m[2] ? parseInt(m[2], 10) : undefined;
if (to === undefined)
return [from, hardened];
if (from > to) {
throw new DerivationError(`Range start ${from} > end ${to}`);
}
return [from, to, hardened];
}
if (Array.isArray(index)) {
const [a, b] = index;
if (index.length !== 2 || typeof a !== 'number' || typeof b !== 'number') {
throw new DerivationError(`Bad index tuple: ${JSON.stringify(index)}`);
}
if (a < 0 || b < 0) {
throw new DerivationError(`Negative in tuple: ${index}`);
}
if (a > b) {
throw new DerivationError(`Range start ${a} > end ${b}`);
}
return [a, b, hardened];
}
throw new DerivationError(`Invalid index instance, got ${typeof index}`);
}
function normalizeDerivation(path, indexes) {
let _path = 'm';
const _indexes = [];
const _deriv = [];
if (indexes && path) {
throw new DerivationError('Provide either path or indexes, not both');
}
if (indexes) {
path = indexesToPath(indexes);
}
if (!path || path === 'm' || path === 'm/') {
return [`${_path}/`, _indexes, _deriv];
}
if (!path.startsWith('m/')) {
throw new DerivationError(`Bad path format, got '${path}'`);
}
for (const seg of path.slice(2).split('/')) {
const hardened = seg.endsWith("'");
const core = hardened ? seg.slice(0, -1) : seg;
const parts = core.split('-').map(x => parseInt(x, 10));
if (parts.length === 2) {
const [from, to] = parts;
if (from > to) {
throw new DerivationError(`Range start ${from} > end ${to}`);
}
_deriv.push([from, to, hardened]);
_indexes.push(to + (hardened ? 0x80000000 : 0));
_path += hardened ? `/${to}'` : `/${to}`;
}
else {
const idx = parts[0];
_deriv.push([idx, hardened]);
_indexes.push(idx + (hardened ? 0x80000000 : 0));
_path += hardened ? `/${idx}'` : `/${idx}`;
}
}
return [_path, _indexes, _deriv];
}
function indexTupleToInteger(idx) {
if (idx.length === 2) {
const [i, h] = idx;
return i + (h ? 0x80000000 : 0);
}
else {
const [from, to, h] = idx;
return to + (h ? 0x80000000 : 0);
}
}
function indexTupleToString(idx) {
if (idx.length === 2) {
const [i, h] = idx;
return `${i}${h ? "'" : ''}`;
}
else {
const [from, to, h] = idx;
return `${from}-${to}${h ? "'" : ''}`;
}
}
function indexStringToTuple(i) {
const hardened = i.endsWith("'");
const num = parseInt(hardened ? i.slice(0, -1) : i, 10);
return [num, hardened];
}
function xor(a, b) {
if (a.length !== b.length)
throw new DerivationError('Uint8Arrays must match length for XOR');
return getBytes(a.map((x, i) => x ^ b[i]));
}
function addNoCarry(a, b) {
if (a.length !== b.length)
throw new DerivationError('Uint8Arrays must match length for addNoCarry');
return getBytes(a.map((x, i) => (x + b[i]) & 0xff));
}
function multiplyScalarNoCarry(data, scalar) {
return getBytes(data.map(x => (x * scalar) & 0xff));
}
function isBitsSet(value, bitNum) {
return (value & (1 << bitNum)) !== 0;
}
function areBitsSet(value, mask) {
return (value & mask) !== 0;
}
function setBit(value, bitNum) {
return value | (1 << bitNum);
}
function setBits(value, mask) {
return value | mask;
}
function resetBit(value, bitNum) {
return value & ~(1 << bitNum);
}
function resetBits(value, mask) {
return value & ~mask;
}
function bytesReverse(data) {
return getBytes(data).reverse();
}
function convertBits$2(data, fromBits, toBits) {
const input = Array.isArray(data) ? data : Array.from(data);
const maxVal = (1 << toBits) - 1;
let acc = 0;
let bits = 0;
const out = [];
for (const val of input) {
if (val < 0 || val >> fromBits) {
return null;
}
acc |= val << bits;
bits += fromBits;
while (bits >= toBits) {
out.push(acc & maxVal);
acc >>= toBits;
bits -= toBits;
}
}
if (bits > 0) {
out.push(acc & maxVal);
}
return out;
}
function bytesChunkToWords(bytesChunk, wordsList, endianness) {
const len = BigInt(wordsList.length);
let chunkNum = bytesToInteger(new Uint8Array(bytesChunk), endianness !== 'big');
const i1 = Number(chunkNum % len);
const i2 = Number(((chunkNum / len) + BigInt(i1)) % len);
const i3 = Number(((chunkNum / len / len) + BigInt(i2)) % len);
return [wordsList[i1], wordsList[i2], wordsList[i3]];
}
function wordsToBytesChunk(w1, w2, w3, wordsList, endianness) {
const len = BigInt(wordsList.length);
const idxMap = new Map(wordsList.map((w, i) => [w, BigInt(i)]));
const i1 = idxMap.get(w1);
const i2 = idxMap.get(w2);
const i3 = idxMap.get(w3);
const chunk = i1 + len * ((i2 - i1 + len) % len) + len * len * ((i3 - i2 + len) % len);
const u8 = integerToBytes(chunk, 4, endianness);
return getBytes(u8);
}
function toCamelCase(input) {
return input.toLowerCase().replace(/-([a-z])/g, (_, char) => char.toUpperCase());
}
function ensureTypeMatch(instanceOrClass, expectedType, options = {}) {
const tryMatch = (type) => {
if (type === 'any')
return true;
if (type === 'null')
return instanceOrClass === null;
if (type === 'array')
return Array.isArray(instanceOrClass);
if (typeof type === 'string')
return typeof instanceOrClass === type;
if (typeof type === 'function') {
if (typeof instanceOrClass === 'function') {
let proto = instanceOrClass;
while (proto && proto !== Function.prototype) {
if (proto === type)
return true;
proto = Object.getPrototypeOf(proto);
}
return false;
}
return options.strict
? instanceOrClass?.constructor === type
: instanceOrClass instanceof type;
}
return false;
};
const allExpectedTypes = [expectedType, ...(options.otherTypes || [])];
const matched = allExpectedTypes.find(tryMatch);
if (!matched && (options.errorClass || options.otherTypes)) {
const expectedNames = allExpectedTypes.map((type) => typeof type === 'function' ? type.name : String(type));
const gotName = typeof instanceOrClass === 'function'
? instanceOrClass.name
: instanceOrClass?.constructor?.name ?? typeof instanceOrClass;
if (options.errorClass) {
throw new options.errorClass(`Invalid type`, {
expected: expectedNames, got: gotName
});
}
else {
throw new TypeError$1(`Invalid type`, {
expected: expectedNames, got: gotName
});
}
}
return matched && options.errorClass ? instanceOrClass : {
value: instanceOrClass, isValid: tryMatch(expectedType)
};
}
var utils = /*#__PURE__*/Object.freeze({
__proto__: null,
getBytes: getBytes,
toBuffer: toBuffer,
hexToBytes: hexToBytes,
bytesToHex: bytesToHex,
bytesToString: bytesToString,
randomBytes: randomBytes,
bytesToInteger: bytesToInteger,
ensureString: ensureString,
stringToInteger: stringToInteger,
equalBytes: equalBytes,
integerToBytes: integerToBytes,
concatBytes: concatBytes,
bytesToBinaryString: bytesToBinaryString,
binaryStringToInteger: binaryStringToInteger,
integerToBinaryString: integerToBinaryString,
binaryStringToBytes: binaryStringToBytes,
isAllEqual: isAllEqual,
generatePassphrase: generatePassphrase,
getHmac: getHmac,
excludeKeys: excludeKeys,
pathToIndexes: pathToIndexes,
indexesToPath: indexesToPath,
normalizeIndex: normalizeIndex,
normalizeDerivation: normalizeDerivation,
indexTupleToInteger: indexTupleToInteger,
indexTupleToString: indexTupleToString,
indexStringToTuple: indexStringToTuple,
xor: xor,
addNoCarry: addNoCarry,
multiplyScalarNoCarry: multiplyScalarNoCarry,
isBitsSet: isBitsSet,
areBitsSet: areBitsSet,
setBit: setBit,
setBits: setBits,
resetBit: resetBit,
resetBits: resetBits,
bytesReverse: bytesReverse,
convertBits: convertBits$2,
bytesChunkToWords: bytesChunkToWords,
wordsToBytesChunk: wordsToBytesChunk,
toCamelCase: toCamelCase,
ensureTypeMatch: ensureTypeMatch
});
// SPDX-License-Identifier: MIT
class NestedNamespace {
constructor(data) {
if (data instanceof Set) {
data.forEach(item => {
this[item] = item;
});
}
else if (Array.isArray(data)) {
data.forEach(item => {
if (item != null && typeof item === 'object' && !Array.isArray(item)) {
Object.entries(item).forEach(([key, value]) => {
this[key] = (value != null && typeof value === 'object')
? new NestedNamespace(value)
: value;
});
}
else {
this[item] = item;
}
});
}
else {
Object.entries(data).forEach(([key, value]) => {
this[key] = (value != null && typeof value === 'object')
? new NestedNamespace(value)
: value;
});
}
}
}
const SLIP10_ED25519_CONST = {
PRIVATE_KEY_BYTE_LENGTH: 32,
PUBLIC_KEY_PREFIX: integerToBytes(0x00),
PUBLIC_KEY_BYTE_LENGTH: 32
};
const KHOLAW_ED25519_CONST = {
...SLIP10_ED25519_CONST,
PRIVATE_KEY_BYTE_LENGTH: 64
};
const SLIP10_SECP256K1_CONST = {
POINT_COORDINATE_BYTE_LENGTH: 32,
PRIVATE_KEY_BYTE_LENGTH: 32,
PRIVATE_KEY_UNCOMPRESSED_PREFIX: 0x00,
PRIVATE_KEY_COMPRESSED_PREFIX: 0x01,
PUBLIC_KEY_UNCOMPRESSED_PREFIX: integerToBytes(0x04),
PUBLIC_KEY_COMPRESSED_BYTE_LENGTH: 33,
PUBLIC_KEY_UNCOMPRESSED_BYTE_LENGTH: 65,
CHECKSUM_BYTE_LENGTH: 4
};
class Info extends NestedNamespace {
SOURCE_CODE;
WHITEPAPER;
WEBSITES;
constructor(data) {
super(data);
}
}
class WitnessVersions extends NestedNamespace {
getWitnessVersion(address) {
return this[address.toUpperCase()];
}
}
class Entropies extends NestedNamespace {
isEntropy(entropy) {
return this.getEntropies().includes(entropy);
}
getEntropies() {
return Object.values(this);
}
}
class Mnemonics extends NestedNamespace {
isMnemonic(mnemonic) {
return this.getMnemonics().includes(mnemonic);
}
getMnemonics() {
return Object.values(this);
}
}
class Seeds extends NestedNamespace {
isSeed(seed) {
return this.getSeeds().includes(seed);
}
getSeeds() {
return Object.values(this);
}
}
class HDs extends NestedNamespace {
isHD(hd) {
return this.getHDS().includes(hd);
}
getHDS() {
return Object.values(this);
}
}
class Addresses extends NestedNamespace {
isAddress(address) {
return this.getAddresses().includes(address);
}
getAddresses() {
return Object.values(this);
}
length() {
return this.getAddresses().length;
}
}
class AddressTypes extends NestedNamespace {
isAddressType(addressType) {
return this.getAddressTypes().includes(addressType);
}
getAddressTypes() {
return Object.values(this);
}
}
class AddressPrefixes extends NestedNamespace {
isAddressPrefix(addressPrefix) {
return this.getAddressPrefixes().includes(addressPrefix);
}
getAddressPrefixes() {
return Object.values(this);
}
}
class Networks extends NestedNamespace {
isNetwork(network) {
return this.getNetworks().includes(network.toLowerCase());
}
getNetworks() {
return Object.keys(this).map(k => k.toLowerCase());
}
getNetwork(network) {
if (!this.isNetwork(network)) {
throw new NetworkError(`${network} network is not available`);
}
return this[network.toUpperCase()];
}
}
class Params extends NestedNamespace {
}
class ExtendedKeyVersions extends NestedNamespace {
isVersion(version) {
return Object.values(this).includes(Number(bytesToInteger(version)));
}
getVersions() {
return Object.keys(this).map(k => k.toLowerCase().replace(/_/g, '-'));
}
getVersion(name) {
return this[name.toUpperCase().replace(/-/g, '_')];
}
getName(version) {
const intVer = bytesToInteger(version);
return Object.entries(this).find(([, v]) => v === intVer)?.[0];
}
}
class XPrivateKeyVersions extends ExtendedKeyVersions {
}
class XPublicKeyVersions extends ExtendedKeyVersions {
}
class PUBLIC_KEY_TYPES {
static UNCOMPRESSED = 'uncompressed';
static COMPRESSED = 'compressed';
static getTypes() {
return [this.UNCOMPRESSED, this.COMPRESSED];
}
}
class WIF_TYPES {
static WIF = 'wif';
static WIF_COMPRESSED = 'wif-compressed';
static getTypes() {
return [this.WIF, this.WIF_COMPRESSED];
}
}
class SEMANTICS {
static P2WPKH = 'p2wpkh';
static P2WPKH_IN_P2SH = 'p2wpkh-in-p2sh';
static P2WSH = 'p2wsh';
static P2WSH_IN_P2SH = 'p2wsh-in-p2sh';
static getTypes() {
return [this.P2WPKH, this.P2WPKH_IN_P2SH, this.P2WSH, this.P2WSH_IN_P2SH];
}
}
class MODES {
static STANDARD = 'standard';
static SEGWIT = 'segwit';
static getTypes() {
return [this.STANDARD, this.SEGWIT];
}
}
var consts = /*#__PURE__*/Object.freeze({
__proto__: null,
NestedNamespace: NestedNamespace,
SLIP10_ED25519_CONST: SLIP10_ED25519_CONST,
KHOLAW_ED25519_CONST: KHOLAW_ED25519_CONST,
SLIP10_SECP256K1_CONST: SLIP10_SECP256K1_CONST,
Info: Info,
WitnessVersions: WitnessVersions,
Entropies: Entropies,
Mnemonics: Mnemonics,
Seeds: Seeds,
HDs: HDs,
Addresses: Addresses,
AddressTypes: AddressTypes,
AddressPrefixes: AddressPrefixes,
Networks: Networks,
Params: Params,
ExtendedKeyVersions: ExtendedKeyVersions,
XPrivateKeyVersions: XPrivateKeyVersions,
XPublicKeyVersions: XPublicKeyVersions,
PUBLIC_KEY_TYPES: PUBLIC_KEY_TYPES,
WIF_TYPES: WIF_TYPES,
SEMANTICS: SEMANTICS,
MODES: MODES
});
/**
* HMAC: RFC2104 message authentication code.
* @module
*/
class HMAC extends Hash {
constructor(hash, _key) {
super();
this.finished = false;
this.destroyed = false;
ahash(hash);
const key = toBytes(_key);
this.iHash = hash.create();
if (typeof this.iHash.update !== 'function')
throw new Error('Expected instance of class which extends utils.Hash');
this.blockLen = this.iHash.blockLen;
this.outputLen = this.iHash.outputLen;
const blockLen = this.blockLen;
const pad = new Uint8Array(blockLen);
// blockLen can be bigger than outputLen
pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
for (let i = 0; i < pad.length; i++)
pad[i] ^= 0x36;
this.iHash.update(pad);
// By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone
this.oHash = hash.create();
// Undo internal XOR && apply outer XOR
for (let i = 0; i < pad.length; i++)
pad[i] ^= 0x36 ^ 0x5c;
this.oHash.update(pad);
clean(pad);
}
update(buf) {
aexists(this);
this.iHash.update(buf);
return this;
}
digestInto(out) {
aexists(this);
abytes(out, this.outputLen);
this.finished = true;
this.iHash.digestInto(out);
this.oHash.update(out);
this.oHash.digestInto(out);
this.destroy();
}
digest() {
const out = new Uint8Array(this.oHash.outputLen);
this.digestInto(out);
return out;
}
_cloneInto(to) {
// Create new instance without calling constructor since key already in state and we don't know it.
to || (to = Object.create(Object.getPrototypeOf(this), {}));
const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
to = to;
to.finished = finished;
to.destroyed = destroyed;
to.blockLen = blockLen;
to.outputLen = outputLen;
to.oHash = oHash._cloneInto(to.oHash);
to.iHash = iHash._cloneInto(to.iHash);
return to;
}
clone() {
return this._cloneInto();
}
destroy() {
this.destroyed = true;
this.oHash.destroy();
this.iHash.destroy();
}
}
/**
* HMAC: RFC2104 message authentication code.
* @param hash - function that would be used e.g. sha256
* @param key - message key
* @param message - message data
* @example
* import { hmac } from '@noble/hashes/hmac';
* import { sha256 } from '@noble/hashes/sha2';
* const mac1 = hmac(sha256, 'key', 'message');
*/
const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
hmac.create = (hash, key) => new HMAC(hash, key);
var D$1=new Uint32Array(1);var n$1=new Uint32Array([0,1996959894,3993919788,2567524794,124634137,1886057615,3915621685,2657392035,249268274,2044508324,3772115230,2547177864,162941995,2125561021,3887607047,2428444049,498536548,1789927666,4089016648,2227061214,450548861,1843258603,4107580753,2211677639,325883990,1684777152,4251122042,2321926636,335633487,1661365465,4195302755,2366115317,997073096,1281953886,3579855332,2724688242,1006888145,1258607687,3524101629,2768942443,901097722,1119000684,3686517206,2898065728,853044451,1172266101,3705015759,2882616665,651767980,1373503546,3369554304,3218104598,565507253,1454621731,3485111705,3099436303,671266974,1594198024,3322730930,2970347812,795835527,1483230225,3244367275,3060149565,1994146192,31158534,2563907772,4023717930,1907459465,112637215,2680153253,3904427059,2013776290,251722036,2517215374,3775830040,2137656763,141376813,2439277719,3865271297,1802195444,476864866,2238001368,4066508878,1812370925,453092731,2181625025,4111451223,1706088902,314042704,2344532202,4240017532,1658658271,366619977,2362670323,4224994405,1303535960,984961486,2747007092,3569037538,1256170817,1037604311,2765210733,3554079995,1131014506,879679996,2909243462,3663771856,1141124467,855842277,2852801631,3708648649,1342533948,654459306,3188396048,3373015174,1466479909,544179635,3110523913,3462522015,1591671054,702138776,2966460450,3352799412,1504918807,783551873,3082640443,3233442989,3988292384,2596254646,62317068,1957810842,3939845945,2647816111,81470997,1943803523,3814918930,2489596804,225274430,2053790376,3826175755,2466906013,167816743,2097651377,4027552580,2265490386,503444072,1762050814,4150417245,2154129355,426522225,1852507879,4275313526,2312317920,282753626,1742555852,4189708143,2394877945,397917763,1622183637,3604390888,2714866558,953729732,1340076626,3518719985,2797360999,1068828381,1219638859,3624741850,2936675148,906185462,1090812512,3747672003,2825379669,829329135,1181335161,3412177804,3160834842,628085408,1382605366,3423369109,3138078467,570562233,1426400815,3317316542,2998733608,733239954,1555261956,3268935591,3050360625,752459403,1541320221,2607071920,3965973030,1969922972,40735498,2617837225,3943577151,1913087877,83908371,2512341634,3803740692,2075208622,213261112,2463272603,3855990285,2094854071,198958881,2262029012,4057260610,1759359992,534414190,2176718541,4139329115,1873836001,414664567,2282248934,4279200368,1711684554,285281116,2405801727,4167216745,1634467795,376229701,2685067896,3608007406,1308918612,956543938,2808555105,3495958263,1231636301,1047427035,2932959818,3654703836,1088359270,936918e3,2847714899,3736837829,1202900863,817233897,3183342108,3401237130,1404277552,615818150,3134207493,3453421203,1423857449,601450431,3009837614,3294710456,1567103746,711928724,3020668471,3272380065,1510334235,755167117]);function t$2(x=new Uint8Array,B=0){D$1[0]=B^4294967295;for(let A of x)D$1[0]=n$1[(D$1[0]^A)&255]^D$1[0]>>>8;return (D$1[0]^4294967295)>>>0}
var B$1=new Uint16Array(1);var n=new Uint16Array([0,4129,8258,12387,16516,20645,24774,28903,33032,37161,41290,45419,49548,53677,57806,61935,4657,528,12915,8786,21173,17044,29431,25302,37689,33560,45947,41818,54205,50076,62463,58334,9314,13379,1056,5121,25830,29895,17572,21637,42346,46411,34088,38153,58862,62927,50604,54669,13907,9842,5649,1584,30423,26358,22165,18100,46939,42874,38681,34616,63455,59390,55197,51132,18628,22757,26758,30887,2112,6241,10242,14371,51660,55789,59790,63919,35144,39273,43274,47403,23285,19156,31415,27286,6769,2640,14899,10770,56317,52188,64447,60318,39801,35672,47931,43802,27814,31879,19684,23749,11298,15363,3168,7233,60846,64911,52716,56781,44330,48395,36200,40265,32407,28342,24277,20212,15891,11826,7761,3696,65439,61374,57309,53244,48923,44858,40793,36728,37256,33193,45514,41451,53516,49453,61774,57711,4224,161,12482,8419,20484,16421,28742,24679,33721,37784,41979,46042,49981,54044,58239,62302,689,4752,8947,13010,16949,21012,25207,29270,46570,42443,38312,34185,62830,58703,54572,50445,13538,9411,5280,1153,29798,25671,21540,17413,42971,47098,34713,38840,59231,63358,50973,55100,9939,14066,1681,5808,26199,30326,17941,22068,55628,51565,63758,59695,39368,35305,47498,43435,22596,18533,30726,26663,6336,2273,14466,10403,52093,56156,60223,64286,35833,39896,43963,48026,19061,23124,27191,31254,2801,6864,10931,14994,64814,60687,56684,52557,48554,44427,40424,36297,31782,27655,23652,19525,15522,11395,7392,3265,61215,65342,53085,57212,44955,49082,36825,40952,28183,32310,20053,24180,11923,16050,3793,7920]);function t$1(x=new Uint8Array,A=0){B$1[0]=A;for(let C of x)B$1[0]=n[B$1[0]>>>8^C]^B$1[0]<<8;return B$1[0]}
/**
* Internal Merkle-Damgard hash utils.
* @module
*/
/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */
function setBigUint64(view, byteOffset, value, isLE) {
if (typeof view.setBigUint64 === 'function')
return view.setBigUint64(byteOffset, value, isLE);
const _32n = BigInt(32);
const _u32_max = BigInt(0xffffffff);
const wh = Number((value >> _32n) & _u32_max);
const wl = Number(value & _u32_max);
const h = isLE ? 4 : 0;
const l = isLE ? 0 : 4;
view.setUint32(byteOffset + h, wh, isLE);
view.setUint32(byteOffset + l, wl, isLE);
}
/** Choice: a ? b : c */
function Chi(a, b, c) {
return (a & b) ^ (~a & c);
}
/** Majority function, true if any two inputs is true. */
function Maj(a, b, c) {
return (a & b) ^ (a & c) ^ (b & c);
}
/**
* Merkle-Damgard hash construction base class.
* Could be used to create MD5, RIPEMD, SHA1, SHA2.
*/
class HashMD extends Hash {
constructor(blockLen, outputLen, padOffset, isLE) {
super();
this.finished = false;
this.length = 0;
this.pos = 0;
this.destroyed = false;
this.blockLen = blockLen;
this.outputLen = outputLen;
this.padOffset = padOffset;
this.isLE = isLE;
this.buffer = new Uint8Array(blockLen);
this.view = createView(this.buffer);
}
update(data) {
aexists(this);
data = toBytes(data);
abytes(data);
const { view, buffer, blockLen } = this;
const len = data.length;
for (let pos = 0; pos < len;) {
const take = Math.min(blockLen - this.pos, len - pos);
// Fast path: we have at least one block in input, cast it to view and process
if (take === blockLen) {
const dataView = createView(data);
for (; blockLen <= len - pos; pos += blockLen)
this.process(dataView, pos);
continue;
}
buffer.set(data.subarray(pos, pos + take), this.pos);
this.pos += take;
pos += take;
if (this.pos === blockLen) {
this.process(view, 0);
this.pos = 0;
}
}
this.length += data.length;
this.roundClean();
return this;
}
digestInto(out) {
aexists(this);
aoutput(out, this);
this.finished = true;
// Padding
// We can avoid allocation of buffer for padding completely if it
// was previously not allocated here. But it won't change performance.
const { buffer, view, blockLen, isLE } = this;
let { pos } = this;
// append the bit '1' to the message
buffer[pos++] = 0b10000000;
clean(this.buffer.subarray(pos));
// we have less than padOffset left in buffer, so we cannot put length in
// current block, need process it and pad again
if (this.padOffset > blockLen - pos) {
this.process(view, 0);
pos = 0;
}
// Pad until full block byte with zeros
for (let i = pos; i < blockLen; i++)
buffer[i] = 0;
// Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that
// You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.
// So we just write lowest 64 bits of that value.
setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
this.process(view, 0);
const oview = createView(out);
const len = this.outputLen;
// NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT
if (len % 4)
throw new Error('_sha2: outputLen should be aligned to 32bit');
const outLen = len / 4;
const state = this.get();
if (outLen > state.length)
throw new Error('_sha2: outputLen bigger than state');
for (let i = 0; i < outLen; i++)
oview.setUint32(4 * i, state[i], isLE);
}
digest() {
const { buffer, outputLen } = this;
this.digestInto(buffer);
const res = buffer.slice(0, outputLen);
this.destroy();
return res;
}
_cloneInto(to) {
to || (to = new this.constructor());
to.set(...this.get());
const { blockLen, buffer, length, finished, destroyed, pos } = this;
to.destroyed = destroyed;
to.finished = finished;
to.length = length;
to.pos = pos;
if (length % blockLen)
to.buffer.set(buffer);
return to;
}
clone() {
return this._cloneInto();
}
}
/**
* Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
* Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
*/
/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */
const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
]);
/** Initial SHA384 state. Bits 0..64 of frac part of sqrt of primes 23..53 */
const SHA384_IV = /* @__PURE__ */ Uint32Array.from([
0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939,
0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4,
]);
/** Initial SHA512 state. Bits 0..64 of frac part of sqrt of primes 2..19 */
const SHA512_IV = /* @__PURE__ */ Uint32Array.from([
0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1,
0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179,
]);
/**
* Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
* @todo re-check https://issues.chromium.org/issues/42212588
* @module
*/
const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
const _32n = /* @__PURE__ */ BigInt(32);
function fromBig(n, le = false) {
if (le)
return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };
return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
}
function split(lst, le = false) {
const len = lst.length;
let Ah = new Uint32Array(len);
let Al = new Uint32Array(len);
for (let i = 0; i < len; i++) {
const { h, l } = fromBig(lst[i], le);
[Ah[i], Al[i]] = [h, l];
}
return [Ah, Al];
}
// for Shift in [0, 32)
const shrSH = (h, _l, s) => h >>> s;
const shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
// Right rotate for Shift in [1, 32)
const rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));
const rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
// Right rotate for Shift in (32, 64), NOTE: 32 is special case.
const rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));
const rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));
// Right rotate for shift===32 (just swaps l&h)
const rotr32H = (_h, l) => l;
const rotr32L = (h, _l) => h;
// Left rotate for Shift in [1, 32)
const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));
const rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));
// Left rotate for Shift in (32, 64), NOTE: 32 is special case.
const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
const rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
// JS uses 32-bit signed integers for bitwise operations which means we cannot
// simple take carry out of low bit sum by shift, we need to use division.
function add(Ah, Al, Bh, Bl) {
const l = (Al >>> 0) + (Bl >>> 0);
return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };
}
// Addition with more than 2 elements
const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
const add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;
const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
const add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;
const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
const add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;
/**
* SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
* SHA256 is the fastest hash implementable in JS, even faster than Blake3.
* Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and
* [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
* @module
*/
/**
* Round constants:
* First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)
*/
// prettier-ignore
const SHA256_K = /* @__PURE__ */ Uint32Array.from([
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
]);
/** Reusable temporary buffer. "W" comes straight from spec. */
const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
class SHA256 extends HashMD {
constructor(outputLen = 32) {
super(64, outputLen, 8, false);
// We cannot use array here since array allows indexing by variable
// which means optimizer/compiler cannot use registers.
this.A = SHA256_IV[0] | 0;
this.B = SHA256_IV[1] | 0;
this.C = SHA256_IV[2] | 0;
this.D = SHA256_IV[3] | 0;
this.E = SHA256_IV[4] | 0;
this.F = SHA256_IV[5] | 0;
this.G = SHA256_IV[6] | 0;
this.H = SHA256_IV[7] | 0;
}
get() {
const { A, B, C, D, E, F, G, H } = this;
return [A, B, C, D, E, F, G, H];
}
// prettier-ignore
set(A, B, C, D, E, F, G, H) {
this.A = A | 0;
this.B = B | 0;
this.C = C | 0;
this.D = D | 0;
this.E = E | 0;
this.F = F | 0;
this.G = G | 0;
this.H = H | 0;
}
process(view, offset) {
// Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array
for (let i = 0; i < 16; i++, offset += 4)
SHA256_W[i] = view.getUint32(offset, false);
for (let i = 16; i < 64; i++) {
const W15 = SHA256_W[i - 15];
const W2 = SHA256_W[i - 2];
const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);
const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);
SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;
}
// Compression function main loop, 64 rounds
let { A, B, C, D, E, F, G, H } = this;
for (let i = 0; i < 64; i++) {
const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
const T2 = (sigma0 + Maj(A, B, C)) | 0;
H = G;
G = F;
F = E;
E = (D + T1) | 0;
D = C;
C = B;
B = A;
A = (T1 + T2) | 0;
}
// Add the compressed chunk to the current hash value
A = (A + this.A) | 0;
B = (B + this.B) | 0;
C = (C + this.C) | 0;
D = (D + this.D) | 0;
E = (E + this.E) | 0;
F = (F + this.F) | 0;
G = (G + this.G) | 0;
H = (H + this.H) | 0;
this.set(A, B, C, D, E, F, G, H);
}
roundClean() {
clean(SHA256_W);
}
destroy() {
this.set(0, 0, 0, 0, 0, 0, 0, 0);
clean(this.buffer);
}
}
// SHA2-512 is slower than sha256 in js because u64 operations are slow.
// Round contants
// First 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409
// prettier-ignore
const K512 = /* @__PURE__ */ (() => split([
'0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',
'0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',
'0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',
'0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',
'0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',
'0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',
'0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',
'0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',
'0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',
'0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',
'0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',
'0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',
'0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',
'0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',
'0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',
'0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',
'0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',
'0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',
'0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',
'0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'
].map(n => BigInt(n))))();
const SHA512_Kh = /* @__PURE__ */ (() => K512[0])();
const SHA512_Kl = /* @__PURE__ */ (() => K512[1])();
// Reusable temporary buffers
const SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
const SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
class SHA512 extends HashMD {
constructor(outputLen = 64) {
super(128, outputLen, 16, false);
// We cannot use array here since array allows indexing by variable
// which means optimizer/compiler cannot use registers.
// h -- high 32 bits, l -- low 32 bits
this.Ah = SHA512_IV[0] | 0;
this.Al = SHA512_IV[1] | 0;
this.Bh = SHA512_IV[2] | 0;
this.Bl = SHA512_IV[3] | 0;
this.Ch = SHA512_IV[4] | 0;
this.Cl = SHA512_IV[5] | 0;
this.Dh = SHA512_IV[6] | 0;
this.Dl = SHA512_IV[7] | 0;
this.Eh = SHA512_IV[8] | 0;
this.El = SHA512_IV[9] | 0;
this.Fh = SHA512_IV[10] | 0;
this.Fl = SHA512_IV[11] | 0;
this.Gh = SHA512_IV[12] | 0;
this.Gl = SHA512_IV[13] | 0;
this.Hh = SHA512_IV[14] | 0;
this.Hl = SHA512_IV[15] | 0;
}
// prettier-ignore
get() {
const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
}
// prettier-ignore
set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
this.Ah = Ah | 0;
this.Al = Al | 0;
this.Bh = Bh | 0;
this.Bl = Bl | 0;
this.Ch = Ch | 0;
this.Cl = Cl | 0;
this.Dh = Dh | 0;
this.Dl = Dl | 0;
this.Eh = Eh | 0;
this.El = El | 0;
this.Fh = Fh | 0;
this.Fl = Fl | 0;
this.Gh = Gh | 0;
this.Gl = Gl | 0;
this.Hh = Hh | 0;
this.Hl = Hl | 0;
}
process(view, offset) {
// Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array
for (let i = 0; i < 16; i++, offset += 4) {
SHA512_W_H[i] = view.getUint32(offset);
SHA512_W_L[i] = view.getUint32((offset += 4));
}
for (let i = 16; i < 80; i++) {
// s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)
const W15h = SHA512_W_H[i - 15] | 0;
const W15l = SHA512_W_L[i - 15] | 0;
const s0h = rotrSH(W15h, W15l, 1) ^ rotrSH(W15h, W15l, 8) ^ shrSH(W15h, W15l, 7);
const s0l = rotrSL(W15h, W15l, 1) ^ rotrSL(W15h, W15l, 8) ^ shrSL(W15h, W15l, 7);
// s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)
const W2h = SHA512_W_H[i - 2] | 0;
const W2l = SHA512_W_L[i - 2] | 0;
const s1h = rotrSH(W2h, W2l, 19) ^ rotrBH(W2h, W2l, 61) ^ shrSH(W2h, W2l, 6);
const s1l = rotrSL(W2h, W2l, 19) ^ rotrBL(W2h, W2l, 61) ^ shrSL(W2h, W2l, 6);
// SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];
const SUMl = add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
const SUMh = add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
SHA512_W_H[i] = SUMh | 0;
SHA512_W_L[i] = SUMl | 0;
}
let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
// Compression function main loop, 80 rounds
for (let i = 0; i < 80; i++) {
// S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)
const sigma1h = rotrSH(Eh, El, 14) ^ rotrSH(Eh, El, 18) ^ rotrBH(Eh, El, 41);
const sigma1l = rotrSL(Eh, El, 14) ^ rotrSL(Eh, El, 18) ^ rotrBL(Eh, El, 41);
//const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
const CHIh = (Eh & Fh) ^ (~Eh & Gh);
const CHIl = (El & Fl) ^ (~El & Gl);
// T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]
// prettier-ignore
const T1ll = add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
const T1h = add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
const T1l = T1ll | 0;
// S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)
const sigma0h = rotrSH(Ah, Al, 28) ^ rotrBH(Ah, Al, 34) ^ rotrBH(Ah, Al, 39);
const sigma0l = rotrSL(Ah, Al, 28) ^ rotrBL(Ah, Al, 34) ^ rotrBL(Ah, Al, 39);
const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);
const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);
Hh = Gh | 0;
Hl = Gl | 0;
Gh = Fh | 0;
Gl = Fl | 0;
Fh = Eh | 0;
Fl = El | 0;
({ h: Eh, l: El } = add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
Dh = Ch | 0;
Dl = Cl | 0;
Ch = Bh | 0;
Cl = Bl | 0;
Bh = Ah | 0;
Bl = Al | 0;
const All = add3L(T1l, sigma0l, MAJl);
Ah = add3H(All, T1h, sigma0h, MAJh);
Al = All | 0;
}
// Add the compressed chunk to the current hash value
({ h: Ah, l: Al } = add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
({ h: Bh, l: Bl } = add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
({ h: Ch, l: Cl } = add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
({ h: Dh, l: Dl } = add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
({ h: Eh, l: El } = add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
({ h: Fh, l: Fl } = add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
({ h: Gh, l: Gl } = add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
({ h: Hh, l: Hl } = add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
}
roundClean() {
clean(SHA512_W_H, SHA512_W_L);
}
destroy() {
clean(this.buffer);
this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
}
}
class SHA384 extends SHA512 {
constructor() {
super(48);
this.Ah = SHA384_IV[0] | 0;
this.Al = SHA384_IV[1] | 0;
this.Bh = SHA384_IV[2] | 0;
this.Bl = SHA384_IV[3] | 0;
this.Ch = SHA384_IV[4] | 0;
this.Cl = SHA384_IV[5] | 0;
this.Dh = SHA384_IV[6] | 0;
this.Dl = SHA384_IV[7] | 0;
this.Eh = SHA384_IV[8] | 0;
this.El = SHA384_IV[9] | 0;
this.Fh = SHA384_IV[10] | 0;
this.Fl = SHA384_IV[11] | 0;
this.Gh = SHA384_IV[12] | 0;
this.Gl = SHA384_IV[13] | 0;
this.Hh = SHA384_IV[14] | 0;
this.Hl = SHA384_IV[15] | 0;
}
}
/** SHA512/256 IV */
const T256_IV = /* @__PURE__ */ Uint32Array.from([
0x22312194, 0xfc2bf72c, 0x9f555fa3, 0xc84c64c2, 0x2393b86b, 0x6f53b151, 0x96387719, 0x5940eabd,
0x96283ee2, 0xa88effe3, 0xbe5e1e25, 0x53863992, 0x2b0199fc, 0x2c85b8aa, 0x0eb72ddc, 0x81c52ca2,
]);
class SHA512_256 extends SHA512 {
constructor() {
super(32);
this.Ah = T256_IV[0] | 0;
this.Al = T256_IV[1] | 0;
this.Bh = T256_IV[2] | 0;
this.Bl = T256_IV[3] | 0;
this.Ch = T256_IV[4] | 0;
this.Cl = T256_IV[5] | 0;
this.Dh = T256_IV[6] | 0;
this.Dl = T256_IV[7] | 0;
this.Eh = T256_IV[8] | 0;
this.El = T256_IV[9] | 0;
this.Fh = T256_IV[10] | 0;
this.Fl = T256_IV[11] | 0;
this.Gh = T256_IV[12] | 0;
this.Gl = T256_IV[13] | 0;
this.Hh = T256_IV[14] | 0;
this.Hl = T256_IV[15] | 0;
}
}
/**
* SHA2-256 hash function from RFC 4634.
*
* It is the fastest JS hash, even faster than Blake3.
* To break sha256 using birthday attack, attackers need to try 2^128 hashes.
* BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
*/
const sha256$1 = /* @__PURE__ */ createHasher(() => new SHA256());
/** SHA2-512 hash function from RFC 4634. */
const sha512$1 = /* @__PURE__ */ createHasher(() => new SHA512());
/** SHA2-384 hash function from RFC 4634. */
const sha384 = /* @__PURE__ */ createHasher(() => new SHA384());
/**
* SHA2-512/256 "truncated" hash function, with improved resistance to length extension attacks.
* See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf).
*/
const sha512_256$1 = /* @__PURE__ */ createHasher(() => new SHA512_256());
/**
* SHA3 (keccak) hash function, based on a new "Sponge function" design.
* Different from older hashes, the internal state is bigger than output size.
*
* Check out [FIPS-202](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf),
* [Website](https://keccak.team/keccak.html),
* [the differences between SHA-3 and Keccak](https://crypto.stackexchange.com/questions/15727/what-are-the-key-differences-between-the-draft-sha-3-standard-and-the-keccak-sub).
*
* Check out `sha3-addons` module for cSHAKE, k12, and others.
* @module
*/
// No __PURE__ annotations in sha3 header:
// EVERYTHING is in fact used on every export.
// Various per round constants calculations
const _0n$5 = BigInt(0);
const _1n$7 = BigInt(1);
const _2n$5 = BigInt(2);
const _7n = BigInt(7);
const _256n = BigInt(256);
const _0x71n = BigInt(0x71);
const SHA3_PI = [];
const SHA3_ROTL = [];
const _SHA3_IOTA = [];
for (let round = 0, R = _1n$7, x = 1, y = 0; round < 24; round++) {
// Pi
[x, y] = [y, (2 * x + 3 * y) % 5];
SHA3_PI.push(2 * (5 * y + x));
// Rotational
SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);
// Iota
let t = _0n$5;
for (let j = 0; j < 7; j++) {
R = ((R << _1n$7) ^ ((R >> _7n) * _0x71n)) % _256n;
if (R & _2n$5)
t ^= _1n$7 << ((_1n$7 << /* @__PURE__ */ BigInt(j)) - _1n$7);
}
_SHA3_IOTA.push(t);
}
const IOTAS = split(_SHA3_IOTA, true);
const SHA3_IOTA_H = IOTAS[0];
const SHA3_IOTA_L = IOTAS[1];
// Left rotation (without 0, 32, 64)
const rotlH = (h, l, s) => (s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s));
const rotlL = (h, l, s) => (s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s));
/** `keccakf1600` internal function, additionally allows to adjust round count. */
function keccakP(s, rounds = 24) {
const B = new Uint32Array(5 * 2);
// NOTE: all indices are x2 since we store state as u32 instead of u64 (bigints to slow in js)
for (let round = 24 - rounds; round < 24; round++) {
// Theta θ
for (let x = 0; x < 10; x++)
B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
for (let x = 0; x < 10; x += 2) {
const idx1 = (x + 8) % 10;
const idx0 = (x + 2) % 10;
const B0 = B[idx0];
const B1 = B[idx0 + 1];
const Th = rotlH(B0, B1, 1) ^ B[idx1];
const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
for (let y = 0; y < 50; y += 10) {
s[x + y] ^= Th;
s[x + y + 1] ^= Tl;
}
}
// Rho (ρ) and Pi (π)
let curH = s[2];
let curL = s[3];
for (let t = 0; t < 24; t++) {
const shift = SHA3_ROTL[t];
const Th = rotlH(curH, curL, shift);
const Tl = rotlL(curH, curL, shift);
const PI = SHA3_PI[t];
curH = s[PI];
curL = s[PI + 1];
s[PI] = Th;
s[PI + 1] = Tl;
}
// Chi (χ)
for (let y = 0; y < 50; y += 10) {
for (let x = 0; x < 10; x++)
B[x] = s[y + x];
for (let x = 0; x < 10; x++)
s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
}
// Iota (ι)
s[0] ^= SHA3_IOTA_H[round];
s[1] ^= SHA3_IOTA_L[round];
}
clean(B);
}
/** Keccak sponge function. */
class Keccak extends Hash {
// NOTE: we accept arguments in bytes instead of bits here.
constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
super();
this.pos = 0;
this.posOut = 0;
this.finished = false;
this.destroyed = false;
this.enableXOF = false;
this.blockLen = blockLen;
this.suffix = suffix;
this.outputLen = outputLen;
this.enableXOF = enableXOF;
this.rounds = rounds;
// Can be passed from user as dkLen
anumber(outputLen);
// 1600 = 5x5 matrix of 64bit. 1600 bits === 200 bytes
// 0 < blockLen < 200
if (!(0 < blockLen && blockLen < 200))
throw new Error('only keccak-f1600 function is supported');
this.state = new Uint8Array(200);
this.state32 = u32(this.state);
}
clone() {
return this._cloneInto();
}
keccak() {
swap32IfBE(this.state32);
keccakP(this.state32, this.rounds);
swap32IfBE(this.state32);
this.posOut = 0;
this.pos = 0;
}
update(data) {
aexists(this);
data = toBytes(data);
abytes(data);
const { blockLen, state } = this;
const len = data.length;
for (let pos = 0; pos < len;) {
const take = Math.min(blockLen - this.pos, len - pos);
for (let i = 0; i < take; i++)
state[this.pos++] ^= data[pos++];
if (this.pos === blockLen)
this.keccak();
}
return this;
}
finish() {
if (this.finished)
return;
this.finished = true;
const { state, suffix, pos, blockLen } = this;
// Do the padding
state[pos] ^= suffix;
if ((suffix & 0x80) !== 0 && pos === blockLen - 1)
this.keccak();
state[blockLen - 1] ^= 0x80;
this.keccak();
}
writeInto(out) {
aexists(this, false);
abytes(out);
this.finish();
const bufferOut = this.state;
const { blockLen } = this;
for (let pos = 0, len = out.length; pos < len;) {
if (this.posOut >= blockLen)
this.keccak();
const take = Math.min(blockLen - this.posOut, len - pos);
out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
this.posOut += take;
pos += take;
}
return out;
}
xofInto(out) {
// Sha3/Keccak usage with XOF is probably mistake, only SHAKE instances can do XOF
if (!this.enableXOF)
throw new Error('XOF is not possible for this instance');
return this.writeInto(out);
}
xof(bytes) {
anumber(bytes);
return this.xofInto(new Uint8Array(bytes));
}
digestInto(out) {
aoutput(out, this);
if (this.finished)
throw new Error('digest() was already called');
this.writeInto(out);
this.destroy();
return out;
}
digest() {
return this.digestInto(new Uint8Array(this.outputLen));
}
destroy() {
this.destroyed = true;
clean(this.state);
}
_cloneInto(to) {
const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
to.state32.set(this.state32);
to.pos = this.pos;
to.posOut = this.posOut;
to.finished = this.finished;
to.rounds = rounds;
// Suffix can change in cSHAKE
to.suffix = suffix;
to.outputLen = outputLen;
to.enableXOF = enableXOF;
to.destroyed = this.destroyed;
return to;
}
}
const gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen));
/** SHA3-256 hash function. Different from keccak-256. */
const sha3_256$1 = /* @__PURE__ */ (() => gen(0x06, 136, 256 / 8))();
/** keccak-256 hash function. Different from SHA3-256. */
const keccak_256 = /* @__PURE__ */ (() => gen(0x01, 136, 256 / 8))();
/**
* Internal helpers for blake hash.
* @module
*/
/**
* Internal blake variable.
* For BLAKE2b, the two extra permutations for rounds 10 and 11 are SIGMA[10..11] = SIGMA[0..1].
*/
// prettier-ignore
const BSIGMA = /* @__PURE__ */ Uint8Array.from([
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,
// Blake1, unused in others
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,
]);
/**
* blake2b (64-bit) & blake2s (8 to 32-bit) hash functions.
* b could have been faster, but there is no fast u64 in js, so s is 1.5x faster.
* @module
*/
// Same as SHA512_IV, but swapped endianness: LE instead of BE. iv[1] is iv[0], etc.
const B2B_IV = /* @__PURE__ */ Uint32Array.from([
0xf3bcc908, 0x6a09e667, 0x84caa73b, 0xbb67ae85, 0xfe94f82b, 0x3c6ef372, 0x5f1d36f1, 0xa54ff53a,
0xade682d1, 0x510e527f, 0x2b3e6c1f, 0x9b05688c, 0xfb41bd6b, 0x1f83d9ab, 0x137e2179, 0x5be0cd19,
]);
// Temporary buffer
const BBUF = /* @__PURE__ */ new Uint32Array(32);
// Mixing function G splitted in two halfs
function G1b(a, b, c, d, msg, x) {
// NOTE: V is LE here
const Xl = msg[x], Xh = msg[x + 1]; // prettier-ignore
let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1]; // prettier-ignore
let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1]; // prettier-ignore
let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1]; // prettier-ignore
let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1]; // prettier-ignore
// v[a] = (v[a] + v[b] + x) | 0;
let ll = add3L(Al, Bl, Xl);
Ah = add3H(ll, Ah, Bh, Xh);
Al = ll | 0;
// v[d] = rotr(v[d] ^ v[a], 32)
({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
({ Dh, Dl } = { Dh: rotr32H(Dh, Dl), Dl: rotr32L(Dh) });
// v[c] = (v[c] + v[d]) | 0;
({ h: Ch, l: Cl } = add(Ch, Cl, Dh, Dl));
// v[b] = rotr(v[b] ^ v[c], 24)
({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
({ Bh, Bl } = { Bh: rotrSH(Bh, Bl, 24), Bl: rotrSL(Bh, Bl, 24) });
(BBUF[2 * a] = Al), (BBUF[2 * a + 1] = Ah);
(BBUF[2 * b] = Bl), (BBUF[2 * b + 1] = Bh);
(BBUF[2 * c] = Cl), (BBUF[2 * c + 1] = Ch);
(BBUF[2 * d] = Dl), (BBUF[2 * d + 1] = Dh);
}
function G2b(a, b, c, d, msg, x) {
// NOTE: V is LE here
const Xl = msg[x], Xh = msg[x + 1]; // prettier-ignore
let Al = BBUF[2 * a], Ah = BBUF[2 * a + 1]; // prettier-ignore
let Bl = BBUF[2 * b], Bh = BBUF[2 * b + 1]; // prettier-ignore
let Cl = BBUF[2 * c], Ch = BBUF[2 * c + 1]; // prettier-ignore
let Dl = BBUF[2 * d], Dh = BBUF[2 * d + 1]; // prettier-ignore
// v[a] = (v[a] + v[b] + x) | 0;
let ll = add3L(Al, Bl, Xl);
Ah = add3H(ll, Ah, Bh, Xh);
Al = ll | 0;
// v[d] = rotr(v[d] ^ v[a], 16)
({ Dh, Dl } = { Dh: Dh ^ Ah, Dl: Dl ^ Al });
({ Dh, Dl } = { Dh: rotrSH(Dh, Dl, 16), Dl: rotrSL(Dh, Dl, 16) });
// v[c] = (v[c] + v[d]) | 0;
({ h: Ch, l: Cl } = add(Ch, Cl, Dh, Dl));
// v[b] = rotr(v[b] ^ v[c], 63)
({ Bh, Bl } = { Bh: Bh ^ Ch, Bl: Bl ^ Cl });
({ Bh, Bl } = { Bh: rotrBH(Bh, Bl, 63), Bl: rotrBL(Bh, Bl, 63) });
(BBUF[2 * a] = Al), (BBUF[2 * a + 1] = Ah);
(BBUF[2 * b] = Bl), (BBUF[2 * b + 1] = Bh);
(BBUF[2 * c] = Cl), (BBUF[2 * c + 1] = Ch);
(BBUF[2 * d] = Dl), (BBUF[2 * d + 1] = Dh);
}
function checkBlake2Opts(outputLen, opts = {}, keyLen, saltLen, persLen) {
anumber(keyLen);
if (outputLen < 0 || outputLen > keyLen)
throw new Error('outputLen bigger than keyLen');
const { key, salt, personalization } = opts;
if (key !== undefined && (key.length < 1 || key.length > keyLen))
throw new Error('key length must be undefined or 1..' + keyLen);
if (salt !== undefined && salt.length !== saltLen)
throw new Error('salt must be undefined or ' + saltLen);
if (personalization !== undefined && personalization.length !== persLen)
throw new Error('personalization must be undefined or ' + persLen);
}
/** Class, from which others are subclassed. */
class BLAKE2 extends Hash {
constructor(blockLen, outputLen) {
super();
this.finished = false;
this.destroyed = false;
this.length = 0;
this.pos = 0;
anumber(blockLen);
anumber(outputLen);
this.blockLen = blockLen;
this.outputLen = outputLen;
this.buffer = new Uint8Array(blockLen);
this.buffer32 = u32(this.buffer);
}
update(data) {
aexists(this);
data = toBytes(data);
abytes(data);
// Main difference with other hashes: there is flag for last block,
// so we cannot process current block before we know that there
// is the next one. This significantly complicates logic and reduces ability
// to do zero-copy processing
const { blockLen, buffer, buffer32 } = this;
const len = data.length;
const offset = data.byteOffset;
const buf = data.buffer;
for (let pos = 0; pos < len;) {
// If buffer is full and we still have input (don't process last block, same as blake2s)
if (this.pos === blockLen) {
swap32IfBE(buffer32);
this.compress(buffer32, 0, false);
swap32IfBE(buffer32);
this.pos = 0;
}
const take = Math.min(blockLen - this.pos, len - pos);
const dataOffset = offset + pos;
// full block && aligned to 4 bytes && not last in input
if (take === blockLen && !(dataOffset % 4) && pos + take < len) {
const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));
swap32IfBE(data32);
for (let pos32 = 0; pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {
this.length += blockLen;
this.compress(data32, pos32, false);
}
swap32IfBE(data32);
continue;
}
buffer.set(data.subarray(pos, pos + take), this.pos);
this.pos += take;
this.length += take;
pos += take;
}
return this;
}
digestInto(out) {
aexists(this);
aoutput(out, this);
const { pos, buffer32 } = this;
this.finished = true;
// Padding
clean(this.buffer.subarray(pos));
swap32IfBE(buffer32);
this.compress(buffer32, 0, true);
swap32IfBE(buffer32);
const out32 = u32(out);
this.get().forEach((v, i) => (out32[i] = swap8IfBE(v)));
}
digest() {
const { buffer, outputLen } = this;
this.digestInto(buffer);
const res = buffer.slice(0, outputLen);
this.destroy();
return res;
}
_cloneInto(to) {
const { buffer, length, finished, destroyed, outputLen, pos } = this;
to || (to = new this.constructor({ dkLen: outputLen }));
to.set(...this.get());
to.buffer.set(buffer);
to.destroyed = destroyed;
to.finished = finished;
to.length = length;
to.pos = pos;
// @ts-ignore
to.outputLen = outputLen;
return to;
}
clone() {
return this._cloneInto();
}
}
class BLAKE2b extends BLAKE2 {
constructor(opts = {}) {
const olen = opts.dkLen === undefined ? 64 : opts.dkLen;
super(128, olen);
// Same as SHA-512, but LE
this.v0l = B2B_IV[0] | 0;
this.v0h = B2B_IV[1] | 0;
this.v1l = B2B_IV[2] | 0;
this.v1h = B2B_IV[3] | 0;
this.v2l = B2B_IV[4] | 0;
this.v2h = B2B_IV[5] | 0;
this.v3l = B2B_IV[6] | 0;
this.v3h = B2B_IV[7] | 0;
this.v4l = B2B_IV[8] | 0;
this.v4h = B2B_IV[9] | 0;
this.v5l = B2B_IV[10] | 0;
this.v5h = B2B_IV[11] | 0;
this.v6l = B2B_IV[12] | 0;
this.v6h = B2B_IV[13] | 0;
this.v7l = B2B_IV[14] | 0;
this.v7h = B2B_IV[15] | 0;
checkBlake2Opts(olen, opts, 64, 16, 16);
let { key, personalization, salt } = opts;
let keyLength = 0;
if (key !== undefined) {
key = toBytes(key);
keyLength = key.length;
}
this.v0l ^= this.outputLen | (keyLength << 8) | (0x01 << 16) | (0x01 << 24);
if (salt !== undefined) {
salt = toBytes(salt);
const slt = u32(salt);
this.v4l ^= swap8IfBE(slt[0]);
this.v4h ^= swap8IfBE(slt[1]);
this.v5l ^= swap8IfBE(slt[2]);
this.v5h ^= swap8IfBE(slt[3]);
}
if (personalization !== undefined) {
personalization = toBytes(personalization);
const pers = u32(personalization);
this.v6l ^= swap8IfBE(pers[0]);
this.v6h ^= swap8IfBE(pers[1]);
this.v7l ^= swap8IfBE(pers[2]);
this.v7h ^= swap8IfBE(pers[3]);
}
if (key !== undefined) {
// Pad to blockLen and update
const tmp = new Uint8Array(this.blockLen);
tmp.set(key);
this.update(tmp);
}
}
// prettier-ignore
get() {
let { v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h } = this;
return [v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h];
}
// prettier-ignore
set(v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h) {
this.v0l = v0l | 0;
this.v0h = v0h | 0;
this.v1l = v1l | 0;
this.v1h = v1h | 0;
this.v2l = v2l | 0;
this.v2h = v2h | 0;
this.v3l = v3l | 0;
this.v3h = v3h | 0;
this.v4l = v4l | 0;
this.v4h = v4h | 0;
this.v5l = v5l | 0;
this.v5h = v5h | 0;
this.v6l = v6l | 0;
this.v6h = v6h | 0;
this.v7l = v7l | 0;
this.v7h = v7h | 0;
}
compress(msg, offset, isLast) {
this.get().forEach((v, i) => (BBUF[i] = v)); // First half from state.
BBUF.set(B2B_IV, 16); // Second half from IV.
let { h, l } = fromBig(BigInt(this.length));
BBUF[24] = B2B_IV[8] ^ l; // Low word of the offset.
BBUF[25] = B2B_IV[9] ^ h; // High word.
// Invert all bits for last block
if (isLast) {
BBUF[28] = ~BBUF[28];
BBUF[29] = ~BBUF[29];
}
let j = 0;
const s = BSIGMA;
for (let i = 0; i < 12; i++) {
G1b(0, 4, 8, 12, msg, offset + 2 * s[j++]);
G2b(0, 4, 8, 12, msg, offset + 2 * s[j++]);
G1b(1, 5, 9, 13, msg, offset + 2 * s[j++]);
G2b(1, 5, 9, 13, msg, offset + 2 * s[j++]);
G1b(2, 6, 10, 14, msg, offset + 2 * s[j++]);
G2b(2, 6, 10, 14, msg, offset + 2 * s[j++]);
G1b(3, 7, 11, 15, msg, offset + 2 * s[j++]);
G2b(3, 7, 11, 15, msg, offset + 2 * s[j++]);
G1b(0, 5, 10, 15, msg, offset + 2 * s[j++]);
G2b(0, 5, 10, 15, msg, offset + 2 * s[j++]);
G1b(1, 6, 11, 12, msg, offset + 2 * s[j++]);
G2b(1, 6, 11, 12, msg, offset + 2 * s[j++]);
G1b(2, 7, 8, 13, msg, offset + 2 * s[j++]);
G2b(2, 7, 8, 13, msg, offset + 2 * s[j++]);
G1b(3, 4, 9, 14, msg, offset + 2 * s[j++]);
G2b(3, 4, 9, 14, msg, offset + 2 * s[j++]);
}
this.v0l ^= BBUF[0] ^ BBUF[16];
this.v0h ^= BBUF[1] ^ BBUF[17];
this.v1l ^= BBUF[2] ^ BBUF[18];
this.v1h ^= BBUF[3] ^ BBUF[19];
this.v2l ^= BBUF[4] ^ BBUF[20];
this.v2h ^= BBUF[5] ^ BBUF[21];
this.v3l ^= BBUF[6] ^ BBUF[22];
this.v3h ^= BBUF[7] ^ BBUF[23];
this.v4l ^= BBUF[8] ^ BBUF[24];
this.v4h ^= BBUF[9] ^ BBUF[25];
this.v5l ^= BBUF[10] ^ BBUF[26];
this.v5h ^= BBUF[11] ^ BBUF[27];
this.v6l ^= BBUF[12] ^ BBUF[28];
this.v6h ^= BBUF[13] ^ BBUF[29];
this.v7l ^= BBUF[14] ^ BBUF[30];
this.v7h ^= BBUF[15] ^ BBUF[31];
clean(BBUF);
}
destroy() {
this.destroyed = true;
clean(this.buffer32);
this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
}
}
/**
* Blake2b hash function. 64-bit. 1.5x slower than blake2s in JS.
* @param msg - message that would be hashed
* @param opts - dkLen output length, key for MAC mode, salt, personalization
*/
const blake2b$1 = /* @__PURE__ */ createOptHasher((opts) => new BLAKE2b(opts));
SHA256_IV;
/**
* PBKDF (RFC 2898). Can be used to create a key from password and salt.
* @module
*/
// Common prologue and epilogue for sync/async functions
function pbkdf2Init(hash, _password, _salt, _opts) {
ahash(hash);
const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
const { c, dkLen, asyncTick } = opts;
anumber(c);
anumber(dkLen);
anumber(asyncTick);
if (c < 1)
throw new Error('iterations (c) should be >= 1');
const password = kdfInputToBytes(_password);
const salt = kdfInputToBytes(_salt);
// DK = PBKDF2(PRF, Password, Salt, c, dkLen);
const DK = new Uint8Array(dkLen);
// U1 = PRF(Password, Salt + INT_32_BE(i))
const PRF = hmac.create(hash, password);
const PRFSalt = PRF._cloneInto().update(salt);
return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
}
function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {
PRF.destroy();
PRFSalt.destroy();
if (prfW)
prfW.destroy();
clean(u);
return DK;
}
/**
* PBKDF2-HMAC: RFC 2898 key derivation function
* @param hash - hash function that would be used e.g. sha256
* @param password - password from which a derived key is generated
* @param salt - cryptographic salt
* @param opts - {c, dkLen} where c is work factor and dkLen is output message size
* @example
* const key = pbkdf2(sha256, 'password', 'salt', { dkLen: 32, c: Math.pow(2, 18) });
*/
function pbkdf2(hash, password, salt, opts) {
const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
let prfW; // Working copy
const arr = new Uint8Array(4);
const view = createView(arr);
const u = new Uint8Array(PRF.outputLen);
// DK = T1 + T2 + ⋯ + Tdklen/hlen
for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
// Ti = F(Password, Salt, c, i)
const Ti = DK.subarray(pos, pos + PRF.outputLen);
view.setInt32(0, ti, false);
// F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc
// U1 = PRF(Password, Salt + INT_32_BE(i))
(prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
Ti.set(u.subarray(0, Ti.length));
for (let ui = 1; ui < c; ui++) {
// Uc = PRF(Password, Uc−1)
PRF._cloneInto(prfW).update(u).digestInto(u);
for (let i = 0; i < Ti.length; i++)
Ti[i] ^= u[i];
}
}
return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
}
/**
SHA1 (RFC 3174), MD5 (RFC 1321) and RIPEMD160 (RFC 2286) legacy, weak hash functions.
Don't use them in a new protocol. What "weak" means:
- Collisions can be made with 2^18 effort in MD5, 2^60 in SHA1, 2^80 in RIPEMD160.
- No practical pre-image attacks (only theoretical, 2^123.4)
- HMAC seems kinda ok: https://datatracker.ietf.org/doc/html/rfc6151
* @module
*/
/** Initial SHA1 state */
const SHA1_IV = /* @__PURE__ */ Uint32Array.from([
0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0,
]);
// Reusable temporary buffer
const SHA1_W = /* @__PURE__ */ new Uint32Array(80);
/** SHA1 legacy hash class. */
class SHA1 extends HashMD {
constructor() {
super(64, 20, 8, false);
this.A = SHA1_IV[0] | 0;
this.B = SHA1_IV[1] | 0;
this.C = SHA1_IV[2] | 0;
this.D = SHA1_IV[3] | 0;
this.E = SHA1_IV[4] | 0;
}
get() {
const { A, B, C, D, E } = this;
return [A, B, C, D, E];
}
set(A, B, C, D, E) {
this.A = A | 0;
this.B = B | 0;
this.C = C | 0;
this.D = D | 0;
this.E = E | 0;
}
process(view, offset) {
for (let i = 0; i < 16; i++, offset += 4)
SHA1_W[i] = view.getUint32(offset, false);
for (let i = 16; i < 80; i++)
SHA1_W[i] = rotl(SHA1_W[i - 3] ^ SHA1_W[i - 8] ^ SHA1_W[i - 14] ^ SHA1_W[i - 16], 1);
// Compression function main loop, 80 rounds
let { A, B, C, D, E } = this;
for (let i = 0; i < 80; i++) {
let F, K;
if (i < 20) {
F = Chi(B, C, D);
K = 0x5a827999;
}
else if (i < 40) {
F = B ^ C ^ D;
K = 0x6ed9eba1;
}
else if (i < 60) {
F = Maj(B, C, D);
K = 0x8f1bbcdc;
}
else {
F = B ^ C ^ D;
K = 0xca62c1d6;
}
const T = (rotl(A, 5) + F + E + K + SHA1_W[i]) | 0;
E = D;
D = C;
C = rotl(B, 30);
B = A;
A = T;
}
// Add the compressed chunk to the current hash value
A = (A + this.A) | 0;
B = (B + this.B) | 0;
C = (C + this.C) | 0;
D = (D + this.D) | 0;
E = (E + this.E) | 0;
this.set(A, B, C, D, E);
}
roundClean() {
clean(SHA1_W);
}
destroy() {
this.set(0, 0, 0, 0, 0);
clean(this.buffer);
}
}
/** Per-round constants */
const p32 = /* @__PURE__ */ Math.pow(2, 32);
const K$1 = /* @__PURE__ */ Array.from({ length: 64 }, (_, i) => Math.floor(p32 * Math.abs(Math.sin(i + 1))));
/** md5 initial state: same as sha1, but 4 u32 instead of 5. */
const MD5_IV = /* @__PURE__ */ SHA1_IV.slice(0, 4);
// Reusable temporary buffer
const MD5_W = /* @__PURE__ */ new Uint32Array(16);
/** MD5 legacy hash class. */
class MD5 extends HashMD {
constructor() {
super(64, 16, 8, true);
this.A = MD5_IV[0] | 0;
this.B = MD5_IV[1] | 0;
this.C = MD5_IV[2] | 0;
this.D = MD5_IV[3] | 0;
}
get() {
const { A, B, C, D } = this;
return [A, B, C, D];
}
set(A, B, C, D) {
this.A = A | 0;
this.B = B | 0;
this.C = C | 0;
this.D = D | 0;
}
process(view, offset) {
for (let i = 0; i < 16; i++, offset += 4)
MD5_W[i] = view.getUint32(offset, true);
// Compression function main loop, 64 rounds
let { A, B, C, D } = this;
for (let i = 0; i < 64; i++) {
let F, g, s;
if (i < 16) {
F = Chi(B, C, D);
g = i;
s = [7, 12, 17, 22];
}
else if (i < 32) {
F = Chi(D, B, C);
g = (5 * i + 1) % 16;
s = [5, 9, 14, 20];
}
else if (i < 48) {
F = B ^ C ^ D;
g = (3 * i + 5) % 16;
s = [4, 11, 16, 23];
}
else {
F = C ^ (B | ~D);
g = (7 * i) % 16;
s = [6, 10, 15, 21];
}
F = F + A + K$1[i] + MD5_W[g];
A = D;
D = C;
C = B;
B = B + rotl(F, s[i % 4]);
}
// Add the compressed chunk to the current hash value
A = (A + this.A) | 0;
B = (B + this.B) | 0;
C = (C + this.C) | 0;
D = (D + this.D) | 0;
this.set(A, B, C, D);
}
roundClean() {
clean(MD5_W);
}
destroy() {
this.set(0, 0, 0, 0);
clean(this.buffer);
}
}
// RIPEMD-160
const Rho160 = /* @__PURE__ */ Uint8Array.from([
7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
]);
const Id160 = /* @__PURE__ */ (() => Uint8Array.from(new Array(16).fill(0).map((_, i) => i)))();
const Pi160 = /* @__PURE__ */ (() => Id160.map((i) => (9 * i + 5) % 16))();
const idxLR = /* @__PURE__ */ (() => {
const L = [Id160];
const R = [Pi160];
const res = [L, R];
for (let i = 0; i < 4; i++)
for (let j of res)
j.push(j[i].map((k) => Rho160[k]));
return res;
})();
const idxL = /* @__PURE__ */ (() => idxLR[0])();
const idxR = /* @__PURE__ */ (() => idxLR[1])();
// const [idxL, idxR] = idxLR;
const shifts160 = /* @__PURE__ */ [
[11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
[12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
[13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
[14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
[15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5],
].map((i) => Uint8Array.from(i));
const shiftsL160 = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts160[i][j]));
const shiftsR160 = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts160[i][j]));
const Kl160 = /* @__PURE__ */ Uint32Array.from([
0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e,
]);
const Kr160 = /* @__PURE__ */ Uint32Array.from([
0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000,
]);
// It's called f() in spec.
function ripemd_f(group, x, y, z) {
if (group === 0)
return x ^ y ^ z;
if (group === 1)
return (x & y) | (~x & z);
if (group === 2)
return (x | ~y) ^ z;
if (group === 3)
return (x & z) | (y & ~z);
return x ^ (y | ~z);
}
// Reusable temporary buffer
const BUF_160 = /* @__PURE__ */ new Uint32Array(16);
class RIPEMD160 extends HashMD {
constructor() {
super(64, 20, 8, true);
this.h0 = 0x67452301 | 0;
this.h1 = 0xefcdab89 | 0;
this.h2 = 0x98badcfe | 0;
this.h3 = 0x10325476 | 0;
this.h4 = 0xc3d2e1f0 | 0;
}
get() {
const { h0, h1, h2, h3, h4 } = this;
return [h0, h1, h2, h3, h4];
}
set(h0, h1, h2, h3, h4) {
this.h0 = h0 | 0;
this.h1 = h1 | 0;
this.h2 = h2 | 0;
this.h3 = h3 | 0;
this.h4 = h4 | 0;
}
process(view, offset) {
for (let i = 0; i < 16; i++, offset += 4)
BUF_160[i] = view.getUint32(offset, true);
// prettier-ignore
let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
// Instead of iterating 0 to 80, we split it into 5 groups
// And use the groups in constants, functions, etc. Much simpler
for (let group = 0; group < 5; group++) {
const rGroup = 4 - group;
const hbl = Kl160[group], hbr = Kr160[group]; // prettier-ignore
const rl = idxL[group], rr = idxR[group]; // prettier-ignore
const sl = shiftsL160[group], sr = shiftsR160[group]; // prettier-ignore
for (let i = 0; i < 16; i++) {
const tl = (rotl(al + ripemd_f(group, bl, cl, dl) + BUF_160[rl[i]] + hbl, sl[i]) + el) | 0;
al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl; // prettier-ignore
}
// 2 loops are 10% faster
for (let i = 0; i < 16; i++) {
const tr = (rotl(ar + ripemd_f(rGroup, br, cr, dr) + BUF_160[rr[i]] + hbr, sr[i]) + er) | 0;
ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr; // prettier-ignore
}
}
// Add the compressed chunk to the current hash value
this.set((this.h1 + cl + dr) | 0, (this.h2 + dl + er) | 0, (this.h3 + el + ar) | 0, (this.h4 + al + br) | 0, (this.h0 + bl + cr) | 0);
}
roundClean() {
clean(BUF_160);
}
destroy() {
this.destroyed = true;
clean(this.buffer);
this.set(0, 0, 0, 0, 0);
}
}
/**
* RIPEMD-160 - a legacy hash function from 1990s.
* * https://homes.esat.kuleuven.be/~bosselae/ripemd160.html
* * https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf
*/
const ripemd160$1 = /* @__PURE__ */ createHasher(() => new RIPEMD160());
// Copyright (C) 2016 Dmitry Chestnykh
/**
* Writes 4-byte little-endian representation of 32-bit unsigned
* value to array starting at offset.
*
* If byte array is not given, creates a new 4-byte one.
*
* Returns the output byte array.
*/
function writeUint32LE(value, out = new Uint8Array(4), offset = 0) {
out[offset + 0] = value >>> 0;
out[offset + 1] = value >>> 8;
out[offset + 2] = value >>> 16;
out[offset + 3] = value >>> 24;
return out;
}
/**
* Writes 8-byte little-endian representation of 64-bit unsigned
* value to byte array starting at offset.
*
* Due to JavaScript limitation, supports values up to 2^53-1.
*
* If byte array is not given, creates a new 8-byte one.
*
* Returns the output byte array.
*/
function writeUint64LE(value, out = new Uint8Array(8), offset = 0) {
writeUint32LE(value >>> 0, out, offset);
writeUint32LE(value / 0x100000000 >>> 0, out, offset + 4);
return out;
}
// Copyright (C) 2016 Dmitry Chestnykh
// MIT License. See LICENSE file for details.
/**
* Sets all values in the given array to zero and returns it.
*
* The fact that it sets bytes to zero can be relied on.
*
* There is no guarantee that this function makes data disappear from memory,
* as runtime implementation can, for example, have copying garbage collector
* that will make copies of sensitive data before we wipe it. Or that an
* operating system will write our data to swap or sleep image. Another thing
* is that an optimizing compiler can remove calls to this function or make it
* no-op. There's nothing we can do with it, so we just do our best and hope
* that everything will be okay and good will triumph over evil.
*/
function wipe(array) {
// Right now it's similar to array.fill(0). If it turns
// out that runtimes optimize this call away, maybe
// we can try something else.
for (let i = 0; i < array.length; i++) {
array[i] = 0;
}
return array;
}
// Copyright (C) 2016 Dmitry Chestnykh
// Number of ChaCha rounds (ChaCha20).
const ROUNDS = 20;
// Applies the ChaCha core function to 16-byte input,
// 32-byte key key, and puts the result into 64-byte array out.
function core(out, input, key) {
let j0 = 0x61707865; // "expa" -- ChaCha's "sigma" constant
let j1 = 0x3320646E; // "nd 3" for 32-byte keys
let j2 = 0x79622D32; // "2-by"
let j3 = 0x6B206574; // "te k"
let j4 = (key[3] << 24) | (key[2] << 16) | (key[1] << 8) | key[0];
let j5 = (key[7] << 24) | (key[6] << 16) | (key[5] << 8) | key[4];
let j6 = (key[11] << 24) | (key[10] << 16) | (key[9] << 8) | key[8];
let j7 = (key[15] << 24) | (key[14] << 16) | (key[13] << 8) | key[12];
let j8 = (key[19] << 24) | (key[18] << 16) | (key[17] << 8) | key[16];
let j9 = (key[23] << 24) | (key[22] << 16) | (key[21] << 8) | key[20];
let j10 = (key[27] << 24) | (key[26] << 16) | (key[25] << 8) | key[24];
let j11 = (key[31] << 24) | (key[30] << 16) | (key[29] << 8) | key[28];
let j12 = (input[3] << 24) | (input[2] << 16) | (input[1] << 8) | input[0];
let j13 = (input[7] << 24) | (input[6] << 16) | (input[5] << 8) | input[4];
let j14 = (input[11] << 24) | (input[10] << 16) | (input[9] << 8) | input[8];
let j15 = (input[15] << 24) | (input[14] << 16) | (input[13] << 8) | input[12];
let x0 = j0;
let x1 = j1;
let x2 = j2;
let x3 = j3;
let x4 = j4;
let x5 = j5;
let x6 = j6;
let x7 = j7;
let x8 = j8;
let x9 = j9;
let x10 = j10;
let x11 = j11;
let x12 = j12;
let x13 = j13;
let x14 = j14;
let x15 = j15;
for (let i = 0; i < ROUNDS; i += 2) {
x0 = x0 + x4 | 0;
x12 ^= x0;
x12 = x12 >>> (32 - 16) | x12 << 16;
x8 = x8 + x12 | 0;
x4 ^= x8;
x4 = x4 >>> (32 - 12) | x4 << 12;
x1 = x1 + x5 | 0;
x13 ^= x1;
x13 = x13 >>> (32 - 16) | x13 << 16;
x9 = x9 + x13 | 0;
x5 ^= x9;
x5 = x5 >>> (32 - 12) | x5 << 12;
x2 = x2 + x6 | 0;
x14 ^= x2;
x14 = x14 >>> (32 - 16) | x14 << 16;
x10 = x10 + x14 | 0;
x6 ^= x10;
x6 = x6 >>> (32 - 12) | x6 << 12;
x3 = x3 + x7 | 0;
x15 ^= x3;
x15 = x15 >>> (32 - 16) | x15 << 16;
x11 = x11 + x15 | 0;
x7 ^= x11;
x7 = x7 >>> (32 - 12) | x7 << 12;
x2 = x2 + x6 | 0;
x14 ^= x2;
x14 = x14 >>> (32 - 8) | x14 << 8;
x10 = x10 + x14 | 0;
x6 ^= x10;
x6 = x6 >>> (32 - 7) | x6 << 7;
x3 = x3 + x7 | 0;
x15 ^= x3;
x15 = x15 >>> (32 - 8) | x15 << 8;
x11 = x11 + x15 | 0;
x7 ^= x11;
x7 = x7 >>> (32 - 7) | x7 << 7;
x1 = x1 + x5 | 0;
x13 ^= x1;
x13 = x13 >>> (32 - 8) | x13 << 8;
x9 = x9 + x13 | 0;
x5 ^= x9;
x5 = x5 >>> (32 - 7) | x5 << 7;
x0 = x0 + x4 | 0;
x12 ^= x0;
x12 = x12 >>> (32 - 8) | x12 << 8;
x8 = x8 + x12 | 0;
x4 ^= x8;
x4 = x4 >>> (32 - 7) | x4 << 7;
x0 = x0 + x5 | 0;
x15 ^= x0;
x15 = x15 >>> (32 - 16) | x15 << 16;
x10 = x10 + x15 | 0;
x5 ^= x10;
x5 = x5 >>> (32 - 12) | x5 << 12;
x1 = x1 + x6 | 0;
x12 ^= x1;
x12 = x12 >>> (32 - 16) | x12 << 16;
x11 = x11 + x12 | 0;
x6 ^= x11;
x6 = x6 >>> (32 - 12) | x6 << 12;
x2 = x2 + x7 | 0;
x13 ^= x2;
x13 = x13 >>> (32 - 16) | x13 << 16;
x8 = x8 + x13 | 0;
x7 ^= x8;
x7 = x7 >>> (32 - 12) | x7 << 12;
x3 = x3 + x4 | 0;
x14 ^= x3;
x14 = x14 >>> (32 - 16) | x14 << 16;
x9 = x9 + x14 | 0;
x4 ^= x9;
x4 = x4 >>> (32 - 12) | x4 << 12;
x2 = x2 + x7 | 0;
x13 ^= x2;
x13 = x13 >>> (32 - 8) | x13 << 8;
x8 = x8 + x13 | 0;
x7 ^= x8;
x7 = x7 >>> (32 - 7) | x7 << 7;
x3 = x3 + x4 | 0;
x14 ^= x3;
x14 = x14 >>> (32 - 8) | x14 << 8;
x9 = x9 + x14 | 0;
x4 ^= x9;
x4 = x4 >>> (32 - 7) | x4 << 7;
x1 = x1 + x6 | 0;
x12 ^= x1;
x12 = x12 >>> (32 - 8) | x12 << 8;
x11 = x11 + x12 | 0;
x6 ^= x11;
x6 = x6 >>> (32 - 7) | x6 << 7;
x0 = x0 + x5 | 0;
x15 ^= x0;
x15 = x15 >>> (32 - 8) | x15 << 8;
x10 = x10 + x15 | 0;
x5 ^= x10;
x5 = x5 >>> (32 - 7) | x5 << 7;
}
writeUint32LE(x0 + j0 | 0, out, 0);
writeUint32LE(x1 + j1 | 0, out, 4);
writeUint32LE(x2 + j2 | 0, out, 8);
writeUint32LE(x3 + j3 | 0, out, 12);
writeUint32LE(x4 + j4 | 0, out, 16);
writeUint32LE(x5 + j5 | 0, out, 20);
writeUint32LE(x6 + j6 | 0, out, 24);
writeUint32LE(x7 + j7 | 0, out, 28);
writeUint32LE(x8 + j8 | 0, out, 32);
writeUint32LE(x9 + j9 | 0, out, 36);
writeUint32LE(x10 + j10 | 0, out, 40);
writeUint32LE(x11 + j11 | 0, out, 44);
writeUint32LE(x12 + j12 | 0, out, 48);
writeUint32LE(x13 + j13 | 0, out, 52);
writeUint32LE(x14 + j14 | 0, out, 56);
writeUint32LE(x15 + j15 | 0, out, 60);
}
/**
* Encrypt src with ChaCha20 stream generated for the given 32-byte key and
* 8-byte (as in original implementation) or 12-byte (as in RFC7539) nonce and
* write the result into dst and return it.
*
* dst and src may be the same, but otherwise must not overlap.
*
* If nonce is 12 bytes, users should not encrypt more than 256 GiB with the
* same key and nonce, otherwise the stream will repeat. The function will
* throw error if counter overflows to prevent this.
*
* If nonce is 8 bytes, the output is practically unlimited (2^70 bytes, which
* is more than a million petabytes). However, it is not recommended to
* generate 8-byte nonces randomly, as the chance of collision is high.
*
* Never use the same key and nonce to encrypt more than one message.
*
* If nonceInplaceCounterLength is not 0, the nonce is assumed to be a 16-byte
* array with stream counter in first nonceInplaceCounterLength bytes and nonce
* in the last remaining bytes. The counter will be incremented inplace for
* each ChaCha block. This is useful if you need to encrypt one stream of data
* in chunks.
*/
function streamXOR(key, nonce, src, dst, nonceInplaceCounterLength = 0) {
// We only support 256-bit keys.
if (key.length !== 32) {
throw new Error("ChaCha: key size must be 32 bytes");
}
if (dst.length < src.length) {
throw new Error("ChaCha: destination is shorter than source");
}
let nc;
let counterLength;
if (nonceInplaceCounterLength === 0) {
if (nonce.length !== 8 && nonce.length !== 12) {
throw new Error("ChaCha nonce must be 8 or 12 bytes");
}
nc = new Uint8Array(16);
// First counterLength bytes of nc are counter, starting with zero.
counterLength = nc.length - nonce.length;
// Last bytes of nc after counterLength are nonce, set them.
nc.set(nonce, counterLength);
}
else {
if (nonce.length !== 16) {
throw new Error("ChaCha nonce with counter must be 16 bytes");
}
// This will update passed nonce with counter inplace.
nc = nonce;
counterLength = nonceInplaceCounterLength;
}
// Allocate temporary space for ChaCha block.
const block = new Uint8Array(64);
for (let i = 0; i < src.length; i += 64) {
// Generate a block.
core(block, nc, key);
// XOR block bytes with src into dst.
for (let j = i; j < i + 64 && j < src.length; j++) {
dst[j] = src[j] ^ block[j - i];
}
// Increment counter.
incrementCounter(nc, 0, counterLength);
}
// Cleanup temporary space.
wipe(block);
if (nonceInplaceCounterLength === 0) {
// Cleanup counter.
wipe(nc);
}
return dst;
}
/**
* Generate ChaCha20 stream for the given 32-byte key and 8-byte or 12-byte
* nonce and write it into dst and return it.
*
* Never use the same key and nonce to generate more than one stream.
*
* If nonceInplaceCounterLength is not 0, it behaves the same with respect to
* the nonce as described in the streamXOR documentation.
*
* stream is like streamXOR with all-zero src.
*/
function stream(key, nonce, dst, nonceInplaceCounterLength = 0) {
wipe(dst);
return streamXOR(key, nonce, dst, dst, nonceInplaceCounterLength);
}
function incrementCounter(counter, pos, len) {
let carry = 1;
while (len--) {
carry = carry + (counter[pos] & 0xff) | 0;
counter[pos] = carry & 0xff;
carry >>>= 8;
pos++;
}
if (carry > 0) {
throw new Error("ChaCha: counter overflow");
}
}
// Copyright (C) 2016 Dmitry Chestnykh
/**
* Returns 1 if a and b are of equal length and their contents
* are equal, or 0 otherwise.
*
* Note that unlike in equal(), zero-length inputs are considered
* the same, so this function will return 1.
*/
function compare(a, b) {
if (a.length !== b.length) {
return 0;
}
let result = 0;
for (let i = 0; i < a.length; i++) {
result |= a[i] ^ b[i];
}
return (1 & ((result - 1) >>> 8));
}
/**
* Returns true if a and b are of equal non-zero length,
* and their contents are equal, or false otherwise.
*
* Note that unlike in compare() zero-length inputs are considered
* _not_ equal, so this function will return false.
*/
function equal(a, b) {
if (a.length === 0 || b.length === 0) {
return false;
}
return compare(a, b) !== 0;
}
// Copyright (C) 2016 Dmitry Chestnykh
const DIGEST_LENGTH = 16;
// Port of Andrew Moon's Poly1305-donna-16. Public domain.
// https://github.com/floodyberry/poly1305-donna
/**
* Poly1305 computes 16-byte authenticator of message using
* a one-time 32-byte key.
*
* Important: key should be used for only one message,
* it should never repeat.
*/
class Poly1305 {
digestLength = DIGEST_LENGTH;
_buffer = new Uint8Array(16);
_r = new Uint16Array(10);
_h = new Uint16Array(10);
_pad = new Uint16Array(8);
_leftover = 0;
_fin = 0;
_finished = false;
constructor(key) {
let t0 = key[0] | key[1] << 8;
this._r[0] = (t0) & 0x1fff;
let t1 = key[2] | key[3] << 8;
this._r[1] = ((t0 >>> 13) | (t1 << 3)) & 0x1fff;
let t2 = key[4] | key[5] << 8;
this._r[2] = ((t1 >>> 10) | (t2 << 6)) & 0x1f03;
let t3 = key[6] | key[7] << 8;
this._r[3] = ((t2 >>> 7) | (t3 << 9)) & 0x1fff;
let t4 = key[8] | key[9] << 8;
this._r[4] = ((t3 >>> 4) | (t4 << 12)) & 0x00ff;
this._r[5] = ((t4 >>> 1)) & 0x1ffe;
let t5 = key[10] | key[11] << 8;
this._r[6] = ((t4 >>> 14) | (t5 << 2)) & 0x1fff;
let t6 = key[12] | key[13] << 8;
this._r[7] = ((t5 >>> 11) | (t6 << 5)) & 0x1f81;
let t7 = key[14] | key[15] << 8;
this._r[8] = ((t6 >>> 8) | (t7 << 8)) & 0x1fff;
this._r[9] = ((t7 >>> 5)) & 0x007f;
this._pad[0] = key[16] | key[17] << 8;
this._pad[1] = key[18] | key[19] << 8;
this._pad[2] = key[20] | key[21] << 8;
this._pad[3] = key[22] | key[23] << 8;
this._pad[4] = key[24] | key[25] << 8;
this._pad[5] = key[26] | key[27] << 8;
this._pad[6] = key[28] | key[29] << 8;
this._pad[7] = key[30] | key[31] << 8;
}
_blocks(m, mpos, bytes) {
let hibit = this._fin ? 0 : 1 << 11;
let h0 = this._h[0], h1 = this._h[1], h2 = this._h[2], h3 = this._h[3], h4 = this._h[4], h5 = this._h[5], h6 = this._h[6], h7 = this._h[7], h8 = this._h[8], h9 = this._h[9];
let r0 = this._r[0], r1 = this._r[1], r2 = this._r[2], r3 = this._r[3], r4 = this._r[4], r5 = this._r[5], r6 = this._r[6], r7 = this._r[7], r8 = this._r[8], r9 = this._r[9];
while (bytes >= 16) {
let t0 = m[mpos + 0] | m[mpos + 1] << 8;
h0 += (t0) & 0x1fff;
let t1 = m[mpos + 2] | m[mpos + 3] << 8;
h1 += ((t0 >>> 13) | (t1 << 3)) & 0x1fff;
let t2 = m[mpos + 4] | m[mpos + 5] << 8;
h2 += ((t1 >>> 10) | (t2 << 6)) & 0x1fff;
let t3 = m[mpos + 6] | m[mpos + 7] << 8;
h3 += ((t2 >>> 7) | (t3 << 9)) & 0x1fff;
let t4 = m[mpos + 8] | m[mpos + 9] << 8;
h4 += ((t3 >>> 4) | (t4 << 12)) & 0x1fff;
h5 += ((t4 >>> 1)) & 0x1fff;
let t5 = m[mpos + 10] | m[mpos + 11] << 8;
h6 += ((t4 >>> 14) | (t5 << 2)) & 0x1fff;
let t6 = m[mpos + 12] | m[mpos + 13] << 8;
h7 += ((t5 >>> 11) | (t6 << 5)) & 0x1fff;
let t7 = m[mpos + 14] | m[mpos + 15] << 8;
h8 += ((t6 >>> 8) | (t7 << 8)) & 0x1fff;
h9 += ((t7 >>> 5)) | hibit;
let c = 0;
let d0 = c;
d0 += h0 * r0;
d0 += h1 * (5 * r9);
d0 += h2 * (5 * r8);
d0 += h3 * (5 * r7);
d0 += h4 * (5 * r6);
c = (d0 >>> 13);
d0 &= 0x1fff;
d0 += h5 * (5 * r5);
d0 += h6 * (5 * r4);
d0 += h7 * (5 * r3);
d0 += h8 * (5 * r2);
d0 += h9 * (5 * r1);
c += (d0 >>> 13);
d0 &= 0x1fff;
let d1 = c;
d1 += h0 * r1;
d1 += h1 * r0;
d1 += h2 * (5 * r9);
d1 += h3 * (5 * r8);
d1 += h4 * (5 * r7);
c = (d1 >>> 13);
d1 &= 0x1fff;
d1 += h5 * (5 * r6);
d1 += h6 * (5 * r5);
d1 += h7 * (5 * r4);
d1 += h8 * (5 * r3);
d1 += h9 * (5 * r2);
c += (d1 >>> 13);
d1 &= 0x1fff;
let d2 = c;
d2 += h0 * r2;
d2 += h1 * r1;
d2 += h2 * r0;
d2 += h3 * (5 * r9);
d2 += h4 * (5 * r8);
c = (d2 >>> 13);
d2 &= 0x1fff;
d2 += h5 * (5 * r7);
d2 += h6 * (5 * r6);
d2 += h7 * (5 * r5);
d2 += h8 * (5 * r4);
d2 += h9 * (5 * r3);
c += (d2 >>> 13);
d2 &= 0x1fff;
let d3 = c;
d3 += h0 * r3;
d3 += h1 * r2;
d3 += h2 * r1;
d3 += h3 * r0;
d3 += h4 * (5 * r9);
c = (d3 >>> 13);
d3 &= 0x1fff;
d3 += h5 * (5 * r8);
d3 += h6 * (5 * r7);
d3 += h7 * (5 * r6);
d3 += h8 * (5 * r5);
d3 += h9 * (5 * r4);
c += (d3 >>> 13);
d3 &= 0x1fff;
let d4 = c;
d4 += h0 * r4;
d4 += h1 * r3;
d4 += h2 * r2;
d4 += h3 * r1;
d4 += h4 * r0;
c = (d4 >>> 13);
d4 &= 0x1fff;
d4 += h5 * (5 * r9);
d4 += h6 * (5 * r8);
d4 += h7 * (5 * r7);
d4 += h8 * (5 * r6);
d4 += h9 * (5 * r5);
c += (d4 >>> 13);
d4 &= 0x1fff;
let d5 = c;
d5 += h0 * r5;
d5 += h1 * r4;
d5 += h2 * r3;
d5 += h3 * r2;
d5 += h4 * r1;
c = (d5 >>> 13);
d5 &= 0x1fff;
d5 += h5 * r0;
d5 += h6 * (5 * r9);
d5 += h7 * (5 * r8);
d5 += h8 * (5 * r7);
d5 += h9 * (5 * r6);
c += (d5 >>> 13);
d5 &= 0x1fff;
let d6 = c;
d6 += h0 * r6;
d6 += h1 * r5;
d6 += h2 * r4;
d6 += h3 * r3;
d6 += h4 * r2;
c = (d6 >>> 13);
d6 &= 0x1fff;
d6 += h5 * r1;
d6 += h6 * r0;
d6 += h7 * (5 * r9);
d6 += h8 * (5 * r8);
d6 += h9 * (5 * r7);
c += (d6 >>> 13);
d6 &= 0x1fff;
let d7 = c;
d7 += h0 * r7;
d7 += h1 * r6;
d7 += h2 * r5;
d7 += h3 * r4;
d7 += h4 * r3;
c = (d7 >>> 13);
d7 &= 0x1fff;
d7 += h5 * r2;
d7 += h6 * r1;
d7 += h7 * r0;
d7 += h8 * (5 * r9);
d7 += h9 * (5 * r8);
c += (d7 >>> 13);
d7 &= 0x1fff;
let d8 = c;
d8 += h0 * r8;
d8 += h1 * r7;
d8 += h2 * r6;
d8 += h3 * r5;
d8 += h4 * r4;
c = (d8 >>> 13);
d8 &= 0x1fff;
d8 += h5 * r3;
d8 += h6 * r2;
d8 += h7 * r1;
d8 += h8 * r0;
d8 += h9 * (5 * r9);
c += (d8 >>> 13);
d8 &= 0x1fff;
let d9 = c;
d9 += h0 * r9;
d9 += h1 * r8;
d9 += h2 * r7;
d9 += h3 * r6;
d9 += h4 * r5;
c = (d9 >>> 13);
d9 &= 0x1fff;
d9 += h5 * r4;
d9 += h6 * r3;
d9 += h7 * r2;
d9 += h8 * r1;
d9 += h9 * r0;
c += (d9 >>> 13);
d9 &= 0x1fff;
c = (((c << 2) + c)) | 0;
c = (c + d0) | 0;
d0 = c & 0x1fff;
c = (c >>> 13);
d1 += c;
h0 = d0;
h1 = d1;
h2 = d2;
h3 = d3;
h4 = d4;
h5 = d5;
h6 = d6;
h7 = d7;
h8 = d8;
h9 = d9;
mpos += 16;
bytes -= 16;
}
this._h[0] = h0;
this._h[1] = h1;
this._h[2] = h2;
this._h[3] = h3;
this._h[4] = h4;
this._h[5] = h5;
this._h[6] = h6;
this._h[7] = h7;
this._h[8] = h8;
this._h[9] = h9;
}
finish(mac, macpos = 0) {
const g = new Uint16Array(10);
let c;
let mask;
let f;
let i;
if (this._leftover) {
i = this._leftover;
this._buffer[i++] = 1;
for (; i < 16; i++) {
this._buffer[i] = 0;
}
this._fin = 1;
this._blocks(this._buffer, 0, 16);
}
c = this._h[1] >>> 13;
this._h[1] &= 0x1fff;
for (i = 2; i < 10; i++) {
this._h[i] += c;
c = this._h[i] >>> 13;
this._h[i] &= 0x1fff;
}
this._h[0] += (c * 5);
c = this._h[0] >>> 13;
this._h[0] &= 0x1fff;
this._h[1] += c;
c = this._h[1] >>> 13;
this._h[1] &= 0x1fff;
this._h[2] += c;
g[0] = this._h[0] + 5;
c = g[0] >>> 13;
g[0] &= 0x1fff;
for (i = 1; i < 10; i++) {
g[i] = this._h[i] + c;
c = g[i] >>> 13;
g[i] &= 0x1fff;
}
g[9] -= (1 << 13);
mask = (c ^ 1) - 1;
for (i = 0; i < 10; i++) {
g[i] &= mask;
}
mask = ~mask;
for (i = 0; i < 10; i++) {
this._h[i] = (this._h[i] & mask) | g[i];
}
this._h[0] = ((this._h[0]) | (this._h[1] << 13)) & 0xffff;
this._h[1] = ((this._h[1] >>> 3) | (this._h[2] << 10)) & 0xffff;
this._h[2] = ((this._h[2] >>> 6) | (this._h[3] << 7)) & 0xffff;
this._h[3] = ((this._h[3] >>> 9) | (this._h[4] << 4)) & 0xffff;
this._h[4] = ((this._h[4] >>> 12) | (this._h[5] << 1) | (this._h[6] << 14)) & 0xffff;
this._h[5] = ((this._h[6] >>> 2) | (this._h[7] << 11)) & 0xffff;
this._h[6] = ((this._h[7] >>> 5) | (this._h[8] << 8)) & 0xffff;
this._h[7] = ((this._h[8] >>> 8) | (this._h[9] << 5)) & 0xffff;
f = this._h[0] + this._pad[0];
this._h[0] = f & 0xffff;
for (i = 1; i < 8; i++) {
f = (((this._h[i] + this._pad[i]) | 0) + (f >>> 16)) | 0;
this._h[i] = f & 0xffff;
}
mac[macpos + 0] = this._h[0] >>> 0;
mac[macpos + 1] = this._h[0] >>> 8;
mac[macpos + 2] = this._h[1] >>> 0;
mac[macpos + 3] = this._h[1] >>> 8;
mac[macpos + 4] = this._h[2] >>> 0;
mac[macpos + 5] = this._h[2] >>> 8;
mac[macpos + 6] = this._h[3] >>> 0;
mac[macpos + 7] = this._h[3] >>> 8;
mac[macpos + 8] = this._h[4] >>> 0;
mac[macpos + 9] = this._h[4] >>> 8;
mac[macpos + 10] = this._h[5] >>> 0;
mac[macpos + 11] = this._h[5] >>> 8;
mac[macpos + 12] = this._h[6] >>> 0;
mac[macpos + 13] = this._h[6] >>> 8;
mac[macpos + 14] = this._h[7] >>> 0;
mac[macpos + 15] = this._h[7] >>> 8;
this._finished = true;
return this;
}
update(m) {
let mpos = 0;
let bytes = m.length;
let want;
if (this._leftover) {
want = (16 - this._leftover);
if (want > bytes) {
want = bytes;
}
for (let i = 0; i < want; i++) {
this._buffer[this._leftover + i] = m[mpos + i];
}
bytes -= want;
mpos += want;
this._leftover += want;
if (this._leftover < 16) {
return this;
}
this._blocks(this._buffer, 0, 16);
this._leftover = 0;
}
if (bytes >= 16) {
want = bytes - (bytes % 16);
this._blocks(m, mpos, want);
mpos += want;
bytes -= want;
}
if (bytes) {
for (let i = 0; i < bytes; i++) {
this._buffer[this._leftover + i] = m[mpos + i];
}
this._leftover += bytes;
}
return this;
}
digest() {
// TODO(dchest): it behaves differently than other hashes/HMAC,
// because it throws when finished — others just return saved result.
if (this._finished) {
throw new Error("Poly1305 was finished");
}
let mac = new Uint8Array(16);
this.finish(mac);
return mac;
}
clean() {
wipe(this._buffer);
wipe(this._r);
wipe(this._h);
wipe(this._pad);
this._leftover = 0;
this._fin = 0;
this._finished = true; // mark as finished even if not
return this;
}
}
// Copyright (C) 2016 Dmitry Chestnykh
const KEY_LENGTH = 32;
const NONCE_LENGTH = 12;
const TAG_LENGTH = 16;
const ZEROS = new Uint8Array(16);
/**
* ChaCha20-Poly1305 Authenticated Encryption with Associated Data.
*
* Defined in RFC7539.
*/
class ChaCha20Poly1305 {
nonceLength = NONCE_LENGTH;
tagLength = TAG_LENGTH;
_key;
/**
* Creates a new instance with the given 32-byte key.
*/
constructor(key) {
if (key.length !== KEY_LENGTH) {
throw new Error("ChaCha20Poly1305 needs 32-byte key");
}
// Copy key.
this._key = new Uint8Array(key);
}
/**
* Encrypts and authenticates plaintext, authenticates associated data,
* and returns sealed ciphertext, which includes authentication tag.
*
* RFC7539 specifies 12 bytes for nonce. It may be this 12-byte nonce
* ("IV"), or full 16-byte counter (called "32-bit fixed-common part")
* and nonce.
*
* If dst is given (it must be the size of plaintext + the size of tag
* length) the result will be put into it. Dst and plaintext must not
* overlap.
*/
seal(nonce, plaintext, associatedData, dst) {
if (nonce.length > 16) {
throw new Error("ChaCha20Poly1305: incorrect nonce length");
}
// Allocate space for counter, and set nonce as last bytes of it.
const counter = new Uint8Array(16);
counter.set(nonce, counter.length - nonce.length);
// Generate authentication key by taking first 32-bytes of stream.
// We pass full counter, which has 12-byte nonce and 4-byte block counter,
// and it will get incremented after generating the block, which is
// exactly what we need: we only use the first 32 bytes of 64-byte
// ChaCha block and discard the next 32 bytes.
const authKey = new Uint8Array(32);
stream(this._key, counter, authKey, 4);
// Allocate space for sealed ciphertext.
const resultLength = plaintext.length + this.tagLength;
let result;
if (dst) {
if (dst.length !== resultLength) {
throw new Error("ChaCha20Poly1305: incorrect destination length");
}
result = dst;
}
else {
result = new Uint8Array(resultLength);
}
// Encrypt plaintext.
streamXOR(this._key, counter, plaintext, result, 4);
// Authenticate.
// XXX: can "simplify" here: pass full result (which is already padded
// due to zeroes prepared for tag), and ciphertext length instead of
// subarray of result.
this._authenticate(result.subarray(result.length - this.tagLength, result.length), authKey, result.subarray(0, result.length - this.tagLength), associatedData);
// Cleanup.
wipe(counter);
return result;
}
/**
* Authenticates sealed ciphertext (which includes authentication tag) and
* associated data, decrypts ciphertext and returns decrypted plaintext.
*
* RFC7539 specifies 12 bytes for nonce. It may be this 12-byte nonce
* ("IV"), or full 16-byte counter (called "32-bit fixed-common part")
* and nonce.
*
* If authentication fails, it returns null.
*
* If dst is given (it must be of ciphertext length minus tag length),
* the result will be put into it. Dst and plaintext must not overlap.
*/
open(nonce, sealed, associatedData, dst) {
if (nonce.length > 16) {
throw new Error("ChaCha20Poly1305: incorrect nonce length");
}
// Sealed ciphertext should at least contain tag.
if (sealed.length < this.tagLength) {
// TODO(dchest): should we throw here instead?
return null;
}
// Allocate space for counter, and set nonce as last bytes of it.
const counter = new Uint8Array(16);
counter.set(nonce, counter.length - nonce.length);
// Generate authentication key by taking first 32-bytes of stream.
const authKey = new Uint8Array(32);
stream(this._key, counter, authKey, 4);
// Authenticate.
// XXX: can simplify and avoid allocation: since authenticate()
// already allocates tag (from Poly1305.digest(), it can return)
// it instead of copying to calculatedTag. But then in seal()
// we'll need to copy it.
const calculatedTag = new Uint8Array(this.tagLength);
this._authenticate(calculatedTag, authKey, sealed.subarray(0, sealed.length - this.tagLength), associatedData);
// Constant-time compare tags and return null if they differ.
if (!equal(calculatedTag, sealed.subarray(sealed.length - this.tagLength, sealed.length))) {
return null;
}
// Allocate space for decrypted plaintext.
const resultLength = sealed.length - this.tagLength;
let result;
if (dst) {
if (dst.length !== resultLength) {
throw new Error("ChaCha20Poly1305: incorrect destination length");
}
result = dst;
}
else {
result = new Uint8Array(resultLength);
}
// Decrypt.
streamXOR(this._key, counter, sealed.subarray(0, sealed.length - this.tagLength), result, 4);
// Cleanup.
wipe(counter);
return result;
}
clean() {
wipe(this._key);
return this;
}
_authenticate(tagOut, authKey, ciphertext, associatedData) {
// Initialize Poly1305 with authKey.
const h = new Poly1305(authKey);
// Authenticate padded associated data.
if (associatedData) {
h.update(associatedData);
if (associatedData.length % 16 > 0) {
h.update(ZEROS.subarray(associatedData.length % 16));
}
}
// Authenticate padded ciphertext.
h.update(ciphertext);
if (ciphertext.length % 16 > 0) {
h.update(ZEROS.subarray(ciphertext.length % 16));
}
// Authenticate length of associated data.
// XXX: can avoid allocation here?
const length = new Uint8Array(8);
if (associatedData) {
writeUint64LE(associatedData.length, length);
}
h.update(length);
// Authenticate length of ciphertext.
writeUint64LE(ciphertext.length, length);
h.update(length);
// Get tag and copy it into tagOut.
const tag = h.digest();
for (let i = 0; i < tag.length; i++) {
tagOut[i] = tag[i];
}
// Cleanup.
h.clean();
wipe(tag);
wipe(length);
}
}
// SPDX-License-Identifier: MIT
function hmacSha256(key, data) {
const mac = hmac(sha256$1, toBuffer(key), toBuffer(data)); // ← key first!
return getBytes(mac);
}
function hmacSha512(key, data) {
const mac = hmac(sha512$1, toBuffer(key), toBuffer(data)); // ← key first!
return getBytes(mac);
}
function blake2b(data, digestSize, key = new Uint8Array(0), salt = new Uint8Array(0), personalize) {
const msg = getBytes(data);
const k = getBytes(key);
const s = getBytes(salt);
const p = personalize ? getBytes(personalize) : undefined;
const hashBytes = blake2b$1(msg, {
dkLen: digestSize,
key: k.length > 0 ? k : undefined,
salt: s.length > 0 ? s : undefined,
personalize: p,
});
return getBytes(hashBytes);
}
const blake2b32 = (d, k, s) => blake2b(d, 4, k, s);
const blake2b40 = (d, k, s) => blake2b(d, 5, k, s);
const blake2b160 = (d, k, s) => blake2b(d, 20, k, s);
const blake2b224 = (d, k, s) => blake2b(d, 28, k, s);
const blake2b256 = (d, k, s) => blake2b(d, 32, k, s);
const blake2b512 = (d, k, s) => blake2b(d, 64, k, s);
function chacha20Poly1305Encrypt(key, nonce, aad, plaintext) {
const aead = new ChaCha20Poly1305(getBytes(key)); // key must be 32 bytes
const ciphertextWithTag = aead.seal(getBytes(nonce), getBytes(plaintext), getBytes(aad));
// split cipher & tag (last 16 bytes)
const ct = ciphertextWithTag.slice(0, -16);
const tag = ciphertextWithTag.slice(-16);
return { cipherText: getBytes(ct), tag: getBytes(tag) };
}
function chacha20Poly1305Decrypt(key, nonce, aad, ciphertext, tag) {
const aead = new ChaCha20Poly1305(getBytes(key));
const combined = concatBytes(getBytes(ciphertext), getBytes(tag));
const pt = aead.open(getBytes(nonce), combined, getBytes(aad));
if (!pt)
throw new Error('ChaCha20-Poly1305: authentication failed');
return getBytes(pt);
}
function sha256(data) {
const bytes = getBytes(data);
const digestBytes = sha256$1(bytes);
return getBytes(digestBytes);
}
const doubleSha256 = (d) => sha256(sha256(d));
function sha512(data) {
const bytes = getBytes(data);
const digestBytes = sha512$1(bytes);
return getBytes(digestBytes);
}
function sha512_256(data) {
const bytes = getBytes(data);
const digestBytes = sha512_256$1(bytes);
return getBytes(digestBytes);
}
function keccak256(data) {
const bytes = getBytes(data);
const digestBytes = keccak_256(bytes);
return getBytes(digestBytes);
}
function sha3_256(data) {
const bytes = getBytes(data);
const digestBytes = sha3_256$1(bytes);
return getBytes(digestBytes);
}
function ripemd160(data) {
const bytes = getBytes(data); // whatever util you already use
return getBytes(ripemd160$1(bytes));
}
function hash160(data) {
const sha = sha256(data);
return ripemd160(sha);
}
function crc32(data) {
const num = t$2(toBuffer(data));
return integerToBytes(num, 4);
}
function xmodemCrc(data) {
const num = t$1(toBuffer(data));
return integerToBytes(num, 2);
}
function pbkdf2HmacSha512(password, salt, iterations, keyLen = 64) {
if (iterations <= 0 || !Number.isSafeInteger(iterations))
throw new RangeError('iterations must be a positive integer');
if (keyLen <= 0)
throw new RangeError('keyLen must be > 0');
const dk = pbkdf2(sha512$1, toBuffer(password), toBuffer(salt), { c: iterations, dkLen: keyLen });
return getBytes(dk);
}
const getChecksum = (d) => doubleSha256(d).slice(0, SLIP10_SECP256K1_CONST.CHECKSUM_BYTE_LENGTH);
var crypto$1 = /*#__PURE__*/Object.freeze({
__proto__: null,
hmacSha256: hmacSha256,
hmacSha512: hmacSha512,
blake2b: blake2b,
blake2b32: blake2b32,
blake2b40: blake2b40,
blake2b160: blake2b160,
blake2b224: blake2b224,
blake2b256: blake2b256,
blake2b512: blake2b512,
chacha20Poly1305Encrypt: chacha20Poly1305Encrypt,
chacha20Poly1305Decrypt: chacha20Poly1305Decrypt,
sha256: sha256,
doubleSha256: doubleSha256,
sha512: sha512,
sha512_256: sha512_256,
keccak256: keccak256,
sha3_256: sha3_256,
ripemd160: ripemd160,
hash160: hash160,
crc32: crc32,
xmodemCrc: xmodemCrc,
pbkdf2HmacSha512: pbkdf2HmacSha512,
getChecksum: getChecksum
});
// SPDX-License-Identifier: MIT
class Network {
static NAME;
// Bitcoin
static PUBLIC_KEY_ADDRESS_PREFIX;
static SCRIPT_ADDRESS_PREFIX;
static HRP;
static WITNESS_VERSIONS;
static XPRIVATE_KEY_VERSIONS;
static XPUBLIC_KEY_VERSIONS;
static MESSAGE_PREFIX;
static WIF_PREFIX;
// Bitcoin-Cash | Bitcoin-Cash-SLP | eCash
static LEGACY_PUBLIC_KEY_ADDRESS_PREFIX;
static STD_PUBLIC_KEY_ADDRESS_PREFIX;
static LEGACY_SCRIPT_ADDRESS_PREFIX;
static STD_SCRIPT_ADDRESS_PREFIX;
// Monero
static STANDARD;
static INTEGRATED;
static SUB_ADDRESS;
// Cardano
static TYPE;
static PAYMENT_ADDRESS_HRP;
static REWARD_ADDRESS_HRP;
}
class Cryptocurrency {
static NAME;
static SYMBOL;
static INFO;
static ECC;
static COIN_TYPE;
static SUPPORT_BIP38;
static NETWORKS;
static DEFAULT_NETWORK;
static ENTROPIES;
static MNEMONICS;
static SEEDS;
static HDS;
static DEFAULT_HD;
static ADDRESSES;
static DEFAULT_ADDRESS;
static ADDRESS_TYPES;
static DEFAULT_ADDRESS_TYPE;
static ADDRESS_PREFIXES;
static DEFAULT_ADDRESS_PREFIX;
static SEMANTICS;
static DEFAULT_SEMANTIC;
static PARAMS;
}
// SPDX-License-Identifier: MIT
/**
* SLIP-0044 coin type registry
* https://github.com/satoshilabs/slips/blob/master/slip-0044.md
*/
const CoinTypes = {
Adcoin: 161,
AkashNetwork: 118,
Algorand: 283,
Anon: 220,
Aptos: 637,
Arbitrum: 60,
Argoneum: 421,
Artax: 219,
Aryacoin: 357,
Asiacoin: 51,
Auroracoin: 85,
Avalanche: 9000,
Avian: 921,
Axe: 4242,
Axelar: 118,
BandProtocol: 494,
Bata: 89,
BeetleCoin: 800,
BelaCoin: 73,
Binance: 714,
BitCloud: 218,
Bitcoin: 0,
BitcoinAtom: 185,
BitcoinCash: 145,
BitcoinCashSLP: 145,
BitcoinGold: 156,
BitcoinGreen: 222,
BitcoinPlus: 65,
BitcoinPrivate: 183,
BitcoinSV: 236,
BitcoinZ: 177,
Bitcore: 160,
BitSend: 91,
Blackcoin: 10,
Blocknode: 2941,
BlockStamp: 254,
Bolivarcoin: 278,
BritCoin: 70,
CanadaECoin: 34,
Cannacoin: 19,
Cardano: 1815,
Celo: 52752,
Chihuahua: 118,
Clams: 23,
ClubCoin: 79,
Compcoin: 71,
Cosmos: 118,
CPUChain: 363,
CranePay: 2304,
Crave: 186,
Dash: 5,
DeepOnion: 305,
Defcoin: 1337,
Denarius: 116,
Diamond: 152,
DigiByte: 20,
Digitalcoin: 18,
Divi: 301,
Dogecoin: 3,
dYdX: 22000118,
eCash: 145,
ECoin: 115,
EDRCoin: 56,
eGulden: 78,
Einsteinium: 41,
Elastos: 2305,
Energi: 9797,
EOS: 194,
Ergo: 429,
Ethereum: 60,
EuropeCoin: 151,
Evrmore: 175,
ExclusiveCoin: 190,
Fantom: 60,
Feathercoin: 8,
FetchAI: 118,
Filecoin: 461,
Firo: 136,
Firstcoin: 167,
FIX: 336,
Flashcoin: 120,
Flux: 19167,
Foxdcoin: 175,
FujiCoin: 75,
GameCredits: 101,
GCRCoin: 49,
GoByte: 176,
Gridcoin: 84,
GroestlCoin: 17,
Gulden: 87,
Harmony: 1023,
Helleniccoin: 168,
Hempcoin: 113,
Horizen: 121,
HuobiToken: 553,
Hush: 197,
Icon: 74,
Injective: 60,
InsaneCoin: 68,
InternetOfPeople: 66,
IRISnet: 566,
IXCoin: 86,
Jumbucks: 26,
Kava: 459,
Kobocoin: 196,
Komodo: 141,
Landcoin: 63,
LBRYCredits: 140,
Linx: 114,
Litecoin: 2,
LitecoinCash: 192,
LitecoinZ: 221,
Lkrcoin: 557,
Lynx: 191,
Mazacoin: 13,
Megacoin: 217,
Metis: 60,
Minexcoin: 182,
Monacoin: 22,
Monero: 128,
Monk: 214,
MultiversX: 508,
Myriadcoin: 90,
Namecoin: 7,
Nano: 165,
Navcoin: 130,
Near: 397,
Neblio: 146,
Neo: 888,
Neoscoin: 25,
Neurocoin: 110,
NewYorkCoin: 179,
NineChronicles: 567,
NIX: 400,
Novacoin: 50,
NuBits: 12,
NuShares: 11,
OKCash: 69,
OKTChain: 996,
Omni: 200,
Onix: 174,
Ontology: 1024,
Optimism: 60,
Osmosis: 10000118,
Particl: 44,
Peercoin: 6,
Pesobit: 62,
Phore: 444,
PiNetwork: 314159,
Pinkcoin: 117,
Pivx: 119,
Polygon: 60,
PoSWCoin: 47,
Potcoin: 81,
ProjectCoin: 533,
Putincoin: 122,
Qtum: 2301,
Rapids: 320,
Ravencoin: 175,
Reddcoin: 4,
Ripple: 144,
Ritocoin: 19169,
RSK: 137,
Rubycoin: 16,
Safecoin: 19165,
Saluscoin: 572,
Scribe: 545,
Secret: 529,
ShadowCash: 35,
Shentu: 118,
Slimcoin: 63,
Smileycoin: 59,
Solana: 501,
Solarcoin: 58,
Stafi: 907,
Stash: 49344,
Stellar: 148,
Stratis: 105,
Sugarchain: 408,
Sui: 784,
Syscoin: 57,
Terra: 330,
Tezos: 1729,
Theta: 500,
ThoughtAI: 502,
TOACoin: 159,
Tron: 195,
TWINS: 970,
UltimateSecureCash: 112,
Unobtanium: 92,
Vcash: 127,
VeChain: 818,
Verge: 77,
Vertcoin: 28,
Viacoin: 14,
Vivo: 166,
Voxels: 129,
VPNCoin: 33,
Wagerr: 0,
Whitecoin: 559,
Wincoin: 181,
XinFin: 550,
XUEZ: 225,
Ycash: 347,
Zcash: 133,
ZClassic: 147,
Zetacoin: 719,
Zilliqa: 313,
ZooBC: 883,
};
// SPDX-License-Identifier: MIT
class Point {
point;
constructor(point) {
this.point = point;
}
static fromBytes(point) {
throw new Error('Must override fromBytes()');
}
static fromCoordinates(x, y) {
throw new Error('Must override fromCoordinates()');
}
getRaw() {
return this.getRawEncoded();
}
}
// SPDX-License-Identifier: MIT
class PublicKey {
publicKey;
constructor(publicKey) {
this.publicKey = publicKey;
}
getName() {
throw new Error('Must override getName()');
}
static fromBytes(publicKey) {
throw new Error('Must override fromBytes()');
}
static fromPoint(point) {
throw new Error('Must override fromPoint()');
}
static getCompressedLength() {
throw new Error('Must override compressedLength()');
}
static getUncompressedLength() {
throw new Error('Must override uncompressedLength()');
}
static isValidBytes(bytes) {
try {
this.fromBytes(bytes);
return true;
}
catch {
return false;
}
}
static isValidPoint(point) {
try {
this.fromPoint(point);
return true;
}
catch {
return false;
}
}
}
// SPDX-License-Identifier: MIT
class PrivateKey {
privateKey;
options;
constructor(privateKey, options = {}) {
this.privateKey = privateKey;
this.options = options;
}
getName() {
throw new Error('Must override getName()');
}
static fromBytes(privateKey) {
throw new Error('Must override fromBytes()');
}
static getLength() {
throw new Error('Must override size()');
}
static isValidBytes(bytes) {
try {
this.fromBytes(bytes);
return true;
}
catch {
return false;
}
}
}
// SPDX-License-Identifier: MIT
class EllipticCurveCryptography {
static NAME;
static ORDER;
static GENERATOR;
static POINT;
static PUBLIC_KEY;
static PRIVATE_KEY;
}
/**
* Hex, bytes and number utilities.
* @module
*/
const _0n$4 = /* @__PURE__ */ BigInt(0);
const _1n$6 = /* @__PURE__ */ BigInt(1);
function abool(title, value) {
if (typeof value !== 'boolean')
throw new Error(title + ' boolean expected, got ' + value);
}
// Used in weierstrass, der
function numberToHexUnpadded(num) {
const hex = num.toString(16);
return hex.length & 1 ? '0' + hex : hex;
}
function hexToNumber(hex) {
if (typeof hex !== 'string')
throw new Error('hex string expected, got ' + typeof hex);
return hex === '' ? _0n$4 : BigInt('0x' + hex); // Big Endian
}
// BE: Big Endian, LE: Little Endian
function bytesToNumberBE(bytes) {
return hexToNumber(bytesToHex$1(bytes));
}
function bytesToNumberLE(bytes) {
abytes(bytes);
return hexToNumber(bytesToHex$1(Uint8Array.from(bytes).reverse()));
}
function numberToBytesBE(n, len) {
return hexToBytes$1(n.toString(16).padStart(len * 2, '0'));
}
function numberToBytesLE(n, len) {
return numberToBytesBE(n, len).reverse();
}
/**
* Takes hex string or Uint8Array, converts to Uint8Array.
* Validates output length.
* Will throw error for other types.
* @param title descriptive title for an error e.g. 'private key'
* @param hex hex string or Uint8Array
* @param expectedLength optional, will compare to result array's length
* @returns
*/
function ensureBytes(title, hex, expectedLength) {
let res;
if (typeof hex === 'string') {
try {
res = hexToBytes$1(hex);
}
catch (e) {
throw new Error(title + ' must be hex string or Uint8Array, cause: ' + e);
}
}
else if (isBytes(hex)) {
// Uint8Array.from() instead of hash.slice() because node.js Buffer
// is instance of Uint8Array, and its slice() creates **mutable** copy
res = Uint8Array.from(hex);
}
else {
throw new Error(title + ' must be hex string or Uint8Array');
}
const len = res.length;
if (typeof expectedLength === 'number' && len !== expectedLength)
throw new Error(title + ' of length ' + expectedLength + ' expected, got ' + len);
return res;
}
/**
* @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
*/
// export const utf8ToBytes: typeof utf8ToBytes_ = utf8ToBytes_;
/**
* Converts bytes to string using UTF8 encoding.
* @example bytesToUtf8(Uint8Array.from([97, 98, 99])) // 'abc'
*/
// export const bytesToUtf8: typeof bytesToUtf8_ = bytesToUtf8_;
// Is positive bigint
const isPosBig = (n) => typeof n === 'bigint' && _0n$4 <= n;
function inRange(n, min, max) {
return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
}
/**
* Asserts min <= n < max. NOTE: It's < max and not <= max.
* @example
* aInRange('x', x, 1n, 256n); // would assume x is in (1n..255n)
*/
function aInRange(title, n, min, max) {
// Why min <= n < max and not a (min < n < max) OR b (min <= n <= max)?
// consider P=256n, min=0n, max=P
// - a for min=0 would require -1: `inRange('x', x, -1n, P)`
// - b would commonly require subtraction: `inRange('x', x, 0n, P - 1n)`
// - our way is the cleanest: `inRange('x', x, 0n, P)
if (!inRange(n, min, max))
throw new Error('expected valid ' + title + ': ' + min + ' <= n < ' + max + ', got ' + n);
}
// Bit operations
/**
* Calculates amount of bits in a bigint.
* Same as `n.toString(2).length`
* TODO: merge with nLength in modular
*/
function bitLen(n) {
let len;
for (len = 0; n > _0n$4; n >>= _1n$6, len += 1)
;
return len;
}
/**
* Calculate mask for N bits. Not using ** operator with bigints because of old engines.
* Same as BigInt(`0b${Array(i).fill('1').join('')}`)
*/
const bitMask = (n) => (_1n$6 << BigInt(n)) - _1n$6;
/**
* Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.
* @returns function that will call DRBG until 2nd arg returns something meaningful
* @example
* const drbg = createHmacDRBG<Key>(32, 32, hmac);
* drbg(seed, bytesToKey); // bytesToKey must return Key or undefined
*/
function createHmacDrbg(hashLen, qByteLen, hmacFn) {
if (typeof hashLen !== 'number' || hashLen < 2)
throw new Error('hashLen must be a number');
if (typeof qByteLen !== 'number' || qByteLen < 2)
throw new Error('qByteLen must be a number');
if (typeof hmacFn !== 'function')
throw new Error('hmacFn must be a function');
// Step B, Step C: set hashLen to 8*ceil(hlen/8)
const u8n = (len) => new Uint8Array(len); // creates Uint8Array
const u8of = (byte) => Uint8Array.of(byte); // another shortcut
let v = u8n(hashLen); // Minimal non-full-spec HMAC-DRBG from NIST 800-90 for RFC6979 sigs.
let k = u8n(hashLen); // Steps B and C of RFC6979 3.2: set hashLen, in our case always same
let i = 0; // Iterations counter, will throw when over 1000
const reset = () => {
v.fill(1);
k.fill(0);
i = 0;
};
const h = (...b) => hmacFn(k, v, ...b); // hmac(k)(v, ...values)
const reseed = (seed = u8n(0)) => {
// HMAC-DRBG reseed() function. Steps D-G
k = h(u8of(0x00), seed); // k = hmac(k || v || 0x00 || seed)
v = h(); // v = hmac(k || v)
if (seed.length === 0)
return;
k = h(u8of(0x01), seed); // k = hmac(k || v || 0x01 || seed)
v = h(); // v = hmac(k || v)
};
const gen = () => {
// HMAC-DRBG generate() function
if (i++ >= 1000)
throw new Error('drbg: tried 1000 values');
let len = 0;
const out = [];
while (len < qByteLen) {
v = h();
const sl = v.slice();
out.push(sl);
len += v.length;
}
return concatBytes$1(...out);
};
const genUntil = (seed, pred) => {
reset();
reseed(seed); // Steps D-G
let res = undefined; // Step H: grind until k is in [1..n-1]
while (!(res = pred(gen())))
reseed();
reset();
return res;
};
return genUntil;
}
function _validateObject(object, fields, optFields = {}) {
if (!object || typeof object !== 'object')
throw new Error('expected valid options object');
function checkField(fieldName, expectedType, isOpt) {
const val = object[fieldName];
if (isOpt && val === undefined)
return;
const current = typeof val;
if (current !== expectedType || val === null)
throw new Error(`param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`);
}
Object.entries(fields).forEach(([k, v]) => checkField(k, v, false));
Object.entries(optFields).forEach(([k, v]) => checkField(k, v, true));
}
/**
* Memoizes (caches) computation result.
* Uses WeakMap: the value is going auto-cleaned by GC after last reference is removed.
*/
function memoized(fn) {
const map = new WeakMap();
return (arg, ...args) => {
const val = map.get(arg);
if (val !== undefined)
return val;
const computed = fn(arg, ...args);
map.set(arg, computed);
return computed;
};
}
/**
* Utils for modular division and fields.
* Field over 11 is a finite (Galois) field is integer number operations `mod 11`.
* There is no division: it is replaced by modular multiplicative inverse.
* @module
*/
// prettier-ignore
const _0n$3 = BigInt(0), _1n$5 = BigInt(1), _2n$4 = /* @__PURE__ */ BigInt(2), _3n$1 = /* @__PURE__ */ BigInt(3);
// prettier-ignore
const _4n$1 = /* @__PURE__ */ BigInt(4), _5n$1 = /* @__PURE__ */ BigInt(5);
const _8n$2 = /* @__PURE__ */ BigInt(8);
// Calculates a modulo b
function mod(a, b) {
const result = a % b;
return result >= _0n$3 ? result : b + result;
}
/** Does `x^(2^power)` mod p. `pow2(30, 4)` == `30^(2^4)` */
function pow2(x, power, modulo) {
let res = x;
while (power-- > _0n$3) {
res *= res;
res %= modulo;
}
return res;
}
/**
* Inverses number over modulo.
* Implemented using [Euclidean GCD](https://brilliant.org/wiki/extended-euclidean-algorithm/).
*/
function invert(number, modulo) {
if (number === _0n$3)
throw new Error('invert: expected non-zero number');
if (modulo <= _0n$3)
throw new Error('invert: expected positive modulus, got ' + modulo);
// Fermat's little theorem "CT-like" version inv(n) = n^(m-2) mod m is 30x slower.
let a = mod(number, modulo);
let b = modulo;
// prettier-ignore
let x = _0n$3, u = _1n$5;
while (a !== _0n$3) {
// JIT applies optimization if those two lines follow each other
const q = b / a;
const r = b % a;
const m = x - u * q;
// prettier-ignore
b = a, a = r, x = u, u = m;
}
const gcd = b;
if (gcd !== _1n$5)
throw new Error('invert: does not exist');
return mod(x, modulo);
}
// Not all roots are possible! Example which will throw:
// const NUM =
// n = 72057594037927816n;
// Fp = Field(BigInt('0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab'));
function sqrt3mod4(Fp, n) {
const p1div4 = (Fp.ORDER + _1n$5) / _4n$1;
const root = Fp.pow(n, p1div4);
// Throw if root^2 != n
if (!Fp.eql(Fp.sqr(root), n))
throw new Error('Cannot find square root');
return root;
}
function sqrt5mod8(Fp, n) {
const p5div8 = (Fp.ORDER - _5n$1) / _8n$2;
const n2 = Fp.mul(n, _2n$4);
const v = Fp.pow(n2, p5div8);
const nv = Fp.mul(n, v);
const i = Fp.mul(Fp.mul(nv, _2n$4), v);
const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
if (!Fp.eql(Fp.sqr(root), n))
throw new Error('Cannot find square root');
return root;
}
// TODO: Commented-out for now. Provide test vectors.
// Tonelli is too slow for extension fields Fp2.
// That means we can't use sqrt (c1, c2...) even for initialization constants.
// if (P % _16n === _9n) return sqrt9mod16;
// // prettier-ignore
// function sqrt9mod16<T>(Fp: IField<T>, n: T, p7div16?: bigint) {
// if (p7div16 === undefined) p7div16 = (Fp.ORDER + BigInt(7)) / _16n;
// const c1 = Fp.sqrt(Fp.neg(Fp.ONE)); // 1. c1 = sqrt(-1) in F, i.e., (c1^2) == -1 in F
// const c2 = Fp.sqrt(c1); // 2. c2 = sqrt(c1) in F, i.e., (c2^2) == c1 in F
// const c3 = Fp.sqrt(Fp.neg(c1)); // 3. c3 = sqrt(-c1) in F, i.e., (c3^2) == -c1 in F
// const c4 = p7div16; // 4. c4 = (q + 7) / 16 # Integer arithmetic
// let tv1 = Fp.pow(n, c4); // 1. tv1 = x^c4
// let tv2 = Fp.mul(c1, tv1); // 2. tv2 = c1 * tv1
// const tv3 = Fp.mul(c2, tv1); // 3. tv3 = c2 * tv1
// let tv4 = Fp.mul(c3, tv1); // 4. tv4 = c3 * tv1
// const e1 = Fp.eql(Fp.sqr(tv2), n); // 5. e1 = (tv2^2) == x
// const e2 = Fp.eql(Fp.sqr(tv3), n); // 6. e2 = (tv3^2) == x
// tv1 = Fp.cmov(tv1, tv2, e1); // 7. tv1 = CMOV(tv1, tv2, e1) # Select tv2 if (tv2^2) == x
// tv2 = Fp.cmov(tv4, tv3, e2); // 8. tv2 = CMOV(tv4, tv3, e2) # Select tv3 if (tv3^2) == x
// const e3 = Fp.eql(Fp.sqr(tv2), n); // 9. e3 = (tv2^2) == x
// return Fp.cmov(tv1, tv2, e3); // 10. z = CMOV(tv1, tv2, e3) # Select the sqrt from tv1 and tv2
// }
/**
* Tonelli-Shanks square root search algorithm.
* 1. https://eprint.iacr.org/2012/685.pdf (page 12)
* 2. Square Roots from 1; 24, 51, 10 to Dan Shanks
* @param P field order
* @returns function that takes field Fp (created from P) and number n
*/
function tonelliShanks(P) {
// Initialization (precomputation).
// Caching initialization could boost perf by 7%.
if (P < BigInt(3))
throw new Error('sqrt is not defined for small field');
// Factor P - 1 = Q * 2^S, where Q is odd
let Q = P - _1n$5;
let S = 0;
while (Q % _2n$4 === _0n$3) {
Q /= _2n$4;
S++;
}
// Find the first quadratic non-residue Z >= 2
let Z = _2n$4;
const _Fp = Field(P);
while (FpLegendre(_Fp, Z) === 1) {
// Basic primality test for P. After x iterations, chance of
// not finding quadratic non-residue is 2^x, so 2^1000.
if (Z++ > 1000)
throw new Error('Cannot find square root: probably non-prime P');
}
// Fast-path; usually done before Z, but we do "primality test".
if (S === 1)
return sqrt3mod4;
// Slow-path
// TODO: test on Fp2 and others
let cc = _Fp.pow(Z, Q); // c = z^Q
const Q1div2 = (Q + _1n$5) / _2n$4;
return function tonelliSlow(Fp, n) {
if (Fp.is0(n))
return n;
// Check if n is a quadratic residue using Legendre symbol
if (FpLegendre(Fp, n) !== 1)
throw new Error('Cannot find square root');
// Initialize variables for the main loop
let M = S;
let c = Fp.mul(Fp.ONE, cc); // c = z^Q, move cc from field _Fp into field Fp
let t = Fp.pow(n, Q); // t = n^Q, first guess at the fudge factor
let R = Fp.pow(n, Q1div2); // R = n^((Q+1)/2), first guess at the square root
// Main loop
// while t != 1
while (!Fp.eql(t, Fp.ONE)) {
if (Fp.is0(t))
return Fp.ZERO; // if t=0 return R=0
let i = 1;
// Find the smallest i >= 1 such that t^(2^i) ≡ 1 (mod P)
let t_tmp = Fp.sqr(t); // t^(2^1)
while (!Fp.eql(t_tmp, Fp.ONE)) {
i++;
t_tmp = Fp.sqr(t_tmp); // t^(2^2)...
if (i === M)
throw new Error('Cannot find square root');
}
// Calculate the exponent for b: 2^(M - i - 1)
const exponent = _1n$5 << BigInt(M - i - 1); // bigint is important
const b = Fp.pow(c, exponent); // b = 2^(M - i - 1)
// Update variables
M = i;
c = Fp.sqr(b); // c = b^2
t = Fp.mul(t, c); // t = (t * b^2)
R = Fp.mul(R, b); // R = R*b
}
return R;
};
}
/**
* Square root for a finite field. Will try optimized versions first:
*
* 1. P ≡ 3 (mod 4)
* 2. P ≡ 5 (mod 8)
* 3. Tonelli-Shanks algorithm
*
* Different algorithms can give different roots, it is up to user to decide which one they want.
* For example there is FpSqrtOdd/FpSqrtEven to choice root based on oddness (used for hash-to-curve).
*/
function FpSqrt(P) {
// P ≡ 3 (mod 4) => √n = n^((P+1)/4)
if (P % _4n$1 === _3n$1)
return sqrt3mod4;
// P ≡ 5 (mod 8) => Atkin algorithm, page 10 of https://eprint.iacr.org/2012/685.pdf
if (P % _8n$2 === _5n$1)
return sqrt5mod8;
// P ≡ 9 (mod 16) not implemented, see above
// Tonelli-Shanks algorithm
return tonelliShanks(P);
}
// Little-endian check for first LE bit (last BE bit);
const isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n$5) === _1n$5;
// prettier-ignore
const FIELD_FIELDS = [
'create', 'isValid', 'is0', 'neg', 'inv', 'sqrt', 'sqr',
'eql', 'add', 'sub', 'mul', 'pow', 'div',
'addN', 'subN', 'mulN', 'sqrN'
];
function validateField(field) {
const initial = {
ORDER: 'bigint',
MASK: 'bigint',
BYTES: 'number',
BITS: 'number',
};
const opts = FIELD_FIELDS.reduce((map, val) => {
map[val] = 'function';
return map;
}, initial);
_validateObject(field, opts);
// const max = 16384;
// if (field.BYTES < 1 || field.BYTES > max) throw new Error('invalid field');
// if (field.BITS < 1 || field.BITS > 8 * max) throw new Error('invalid field');
return field;
}
// Generic field functions
/**
* Same as `pow` but for Fp: non-constant-time.
* Unsafe in some contexts: uses ladder, so can expose bigint bits.
*/
function FpPow(Fp, num, power) {
if (power < _0n$3)
throw new Error('invalid exponent, negatives unsupported');
if (power === _0n$3)
return Fp.ONE;
if (power === _1n$5)
return num;
let p = Fp.ONE;
let d = num;
while (power > _0n$3) {
if (power & _1n$5)
p = Fp.mul(p, d);
d = Fp.sqr(d);
power >>= _1n$5;
}
return p;
}
/**
* Efficiently invert an array of Field elements.
* Exception-free. Will return `undefined` for 0 elements.
* @param passZero map 0 to 0 (instead of undefined)
*/
function FpInvertBatch(Fp, nums, passZero = false) {
const inverted = new Array(nums.length).fill(passZero ? Fp.ZERO : undefined);
// Walk from first to last, multiply them by each other MOD p
const multipliedAcc = nums.reduce((acc, num, i) => {
if (Fp.is0(num))
return acc;
inverted[i] = acc;
return Fp.mul(acc, num);
}, Fp.ONE);
// Invert last element
const invertedAcc = Fp.inv(multipliedAcc);
// Walk from last to first, multiply them by inverted each other MOD p
nums.reduceRight((acc, num, i) => {
if (Fp.is0(num))
return acc;
inverted[i] = Fp.mul(acc, inverted[i]);
return Fp.mul(acc, num);
}, invertedAcc);
return inverted;
}
/**
* Legendre symbol.
* Legendre constant is used to calculate Legendre symbol (a | p)
* which denotes the value of a^((p-1)/2) (mod p).
*
* * (a | p) ≡ 1 if a is a square (mod p), quadratic residue
* * (a | p) ≡ -1 if a is not a square (mod p), quadratic non residue
* * (a | p) ≡ 0 if a ≡ 0 (mod p)
*/
function FpLegendre(Fp, n) {
// We can use 3rd argument as optional cache of this value
// but seems unneeded for now. The operation is very fast.
const p1mod2 = (Fp.ORDER - _1n$5) / _2n$4;
const powered = Fp.pow(n, p1mod2);
const yes = Fp.eql(powered, Fp.ONE);
const zero = Fp.eql(powered, Fp.ZERO);
const no = Fp.eql(powered, Fp.neg(Fp.ONE));
if (!yes && !zero && !no)
throw new Error('invalid Legendre symbol result');
return yes ? 1 : zero ? 0 : -1;
}
// CURVE.n lengths
function nLength(n, nBitLength) {
// Bit size, byte size of CURVE.n
if (nBitLength !== undefined)
anumber(nBitLength);
const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;
const nByteLength = Math.ceil(_nBitLength / 8);
return { nBitLength: _nBitLength, nByteLength };
}
/**
* Creates a finite field. Major performance optimizations:
* * 1. Denormalized operations like mulN instead of mul.
* * 2. Identical object shape: never add or remove keys.
* * 3. `Object.freeze`.
* Fragile: always run a benchmark on a change.
* Security note: operations don't check 'isValid' for all elements for performance reasons,
* it is caller responsibility to check this.
* This is low-level code, please make sure you know what you're doing.
*
* Note about field properties:
* * CHARACTERISTIC p = prime number, number of elements in main subgroup.
* * ORDER q = similar to cofactor in curves, may be composite `q = p^m`.
*
* @param ORDER field order, probably prime, or could be composite
* @param bitLen how many bits the field consumes
* @param isLE (default: false) if encoding / decoding should be in little-endian
* @param redef optional faster redefinitions of sqrt and other methods
*/
function Field(ORDER, bitLenOrOpts, isLE = false, opts = {}) {
if (ORDER <= _0n$3)
throw new Error('invalid field: expected ORDER > 0, got ' + ORDER);
let _nbitLength = undefined;
let _sqrt = undefined;
if (typeof bitLenOrOpts === 'object' && bitLenOrOpts != null) {
if (opts.sqrt || isLE)
throw new Error('cannot specify opts in two arguments');
const _opts = bitLenOrOpts;
if (_opts.BITS)
_nbitLength = _opts.BITS;
if (_opts.sqrt)
_sqrt = _opts.sqrt;
if (typeof _opts.isLE === 'boolean')
isLE = _opts.isLE;
}
else {
if (typeof bitLenOrOpts === 'number')
_nbitLength = bitLenOrOpts;
if (opts.sqrt)
_sqrt = opts.sqrt;
}
const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, _nbitLength);
if (BYTES > 2048)
throw new Error('invalid field: expected ORDER of <= 2048 bytes');
let sqrtP; // cached sqrtP
const f = Object.freeze({
ORDER,
isLE,
BITS,
BYTES,
MASK: bitMask(BITS),
ZERO: _0n$3,
ONE: _1n$5,
create: (num) => mod(num, ORDER),
isValid: (num) => {
if (typeof num !== 'bigint')
throw new Error('invalid field element: expected bigint, got ' + typeof num);
return _0n$3 <= num && num < ORDER; // 0 is valid element, but it's not invertible
},
is0: (num) => num === _0n$3,
// is valid and invertible
isValidNot0: (num) => !f.is0(num) && f.isValid(num),
isOdd: (num) => (num & _1n$5) === _1n$5,
neg: (num) => mod(-num, ORDER),
eql: (lhs, rhs) => lhs === rhs,
sqr: (num) => mod(num * num, ORDER),
add: (lhs, rhs) => mod(lhs + rhs, ORDER),
sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
pow: (num, power) => FpPow(f, num, power),
div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
// Same as above, but doesn't normalize
sqrN: (num) => num * num,
addN: (lhs, rhs) => lhs + rhs,
subN: (lhs, rhs) => lhs - rhs,
mulN: (lhs, rhs) => lhs * rhs,
inv: (num) => invert(num, ORDER),
sqrt: _sqrt ||
((n) => {
if (!sqrtP)
sqrtP = FpSqrt(ORDER);
return sqrtP(f, n);
}),
toBytes: (num) => (isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES)),
fromBytes: (bytes) => {
if (bytes.length !== BYTES)
throw new Error('Field.fromBytes: expected ' + BYTES + ' bytes, got ' + bytes.length);
return isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);
},
// TODO: we don't need it here, move out to separate fn
invertBatch: (lst) => FpInvertBatch(f, lst),
// We can't move this out because Fp6, Fp12 implement it
// and it's unclear what to return in there.
cmov: (a, b, c) => (c ? b : a),
});
return Object.freeze(f);
}
/**
* Returns total number of bytes consumed by the field element.
* For example, 32 bytes for usual 256-bit weierstrass curve.
* @param fieldOrder number of field elements, usually CURVE.n
* @returns byte length of field
*/
function getFieldBytesLength(fieldOrder) {
if (typeof fieldOrder !== 'bigint')
throw new Error('field order must be bigint');
const bitLength = fieldOrder.toString(2).length;
return Math.ceil(bitLength / 8);
}
/**
* Returns minimal amount of bytes that can be safely reduced
* by field order.
* Should be 2^-128 for 128-bit curve such as P256.
* @param fieldOrder number of field elements, usually CURVE.n
* @returns byte length of target hash
*/
function getMinHashLength(fieldOrder) {
const length = getFieldBytesLength(fieldOrder);
return length + Math.ceil(length / 2);
}
/**
* "Constant-time" private key generation utility.
* Can take (n + n/2) or more bytes of uniform input e.g. from CSPRNG or KDF
* and convert them into private scalar, with the modulo bias being negligible.
* Needs at least 48 bytes of input for 32-byte private key.
* https://research.kudelskisecurity.com/2020/07/28/the-definitive-guide-to-modulo-bias-and-how-to-avoid-it/
* FIPS 186-5, A.2 https://csrc.nist.gov/publications/detail/fips/186/5/final
* RFC 9380, https://www.rfc-editor.org/rfc/rfc9380#section-5
* @param hash hash output from SHA3 or a similar function
* @param groupOrder size of subgroup - (e.g. secp256k1.CURVE.n)
* @param isLE interpret hash bytes as LE num
* @returns valid private scalar
*/
function mapHashToField(key, fieldOrder, isLE = false) {
const len = key.length;
const fieldLen = getFieldBytesLength(fieldOrder);
const minLen = getMinHashLength(fieldOrder);
// No small numbers: need to understand bias story. No huge numbers: easier to detect JS timings.
if (len < 16 || len < minLen || len > 1024)
throw new Error('expected ' + minLen + '-1024 bytes of input, got ' + len);
const num = isLE ? bytesToNumberLE(key) : bytesToNumberBE(key);
// `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0
const reduced = mod(num, fieldOrder - _1n$5) + _1n$5;
return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
}
/**
* Methods for elliptic curve multiplication by scalars.
* Contains wNAF, pippenger
* @module
*/
const _0n$2 = BigInt(0);
const _1n$4 = BigInt(1);
function negateCt(condition, item) {
const neg = item.negate();
return condition ? neg : item;
}
/**
* Takes a bunch of Projective Points but executes only one
* inversion on all of them. Inversion is very slow operation,
* so this improves performance massively.
* Optimization: converts a list of projective points to a list of identical points with Z=1.
*/
function normalizeZ(c, property, points) {
const getz = property === 'pz' ? (p) => p.pz : (p) => p.ez;
const toInv = FpInvertBatch(c.Fp, points.map(getz));
// @ts-ignore
const affined = points.map((p, i) => p.toAffine(toInv[i]));
return affined.map(c.fromAffine);
}
function validateW(W, bits) {
if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
throw new Error('invalid window size, expected [1..' + bits + '], got W=' + W);
}
function calcWOpts(W, scalarBits) {
validateW(W, scalarBits);
const windows = Math.ceil(scalarBits / W) + 1; // W=8 33. Not 32, because we skip zero
const windowSize = 2 ** (W - 1); // W=8 128. Not 256, because we skip zero
const maxNumber = 2 ** W; // W=8 256
const mask = bitMask(W); // W=8 255 == mask 0b11111111
const shiftBy = BigInt(W); // W=8 8
return { windows, windowSize, mask, maxNumber, shiftBy };
}
function calcOffsets(n, window, wOpts) {
const { windowSize, mask, maxNumber, shiftBy } = wOpts;
let wbits = Number(n & mask); // extract W bits.
let nextN = n >> shiftBy; // shift number by W bits.
// What actually happens here:
// const highestBit = Number(mask ^ (mask >> 1n));
// let wbits2 = wbits - 1; // skip zero
// if (wbits2 & highestBit) { wbits2 ^= Number(mask); // (~);
// split if bits > max: +224 => 256-32
if (wbits > windowSize) {
// we skip zero, which means instead of `>= size-1`, we do `> size`
wbits -= maxNumber; // -32, can be maxNumber - wbits, but then we need to set isNeg here.
nextN += _1n$4; // +256 (carry)
}
const offsetStart = window * windowSize;
const offset = offsetStart + Math.abs(wbits) - 1; // -1 because we skip zero
const isZero = wbits === 0; // is current window slice a 0?
const isNeg = wbits < 0; // is current window slice negative?
const isNegF = window % 2 !== 0; // fake random statement for noise
const offsetF = offsetStart; // fake offset for noise
return { nextN, offset, isZero, isNeg, isNegF, offsetF };
}
function validateMSMPoints(points, c) {
if (!Array.isArray(points))
throw new Error('array expected');
points.forEach((p, i) => {
if (!(p instanceof c))
throw new Error('invalid point at index ' + i);
});
}
function validateMSMScalars(scalars, field) {
if (!Array.isArray(scalars))
throw new Error('array of scalars expected');
scalars.forEach((s, i) => {
if (!field.isValid(s))
throw new Error('invalid scalar at index ' + i);
});
}
// Since points in different groups cannot be equal (different object constructor),
// we can have single place to store precomputes.
// Allows to make points frozen / immutable.
const pointPrecomputes = new WeakMap();
const pointWindowSizes = new WeakMap();
function getW(P) {
return pointWindowSizes.get(P) || 1;
}
function assert0(n) {
if (n !== _0n$2)
throw new Error('invalid wNAF');
}
/**
* Elliptic curve multiplication of Point by scalar. Fragile.
* Scalars should always be less than curve order: this should be checked inside of a curve itself.
* Creates precomputation tables for fast multiplication:
* - private scalar is split by fixed size windows of W bits
* - every window point is collected from window's table & added to accumulator
* - since windows are different, same point inside tables won't be accessed more than once per calc
* - each multiplication is 'Math.ceil(CURVE_ORDER / 𝑊) + 1' point additions (fixed for any scalar)
* - +1 window is neccessary for wNAF
* - wNAF reduces table size: 2x less memory + 2x faster generation, but 10% slower multiplication
*
* @todo Research returning 2d JS array of windows, instead of a single window.
* This would allow windows to be in different memory locations
*/
function wNAF(c, bits) {
return {
constTimeNegate: negateCt,
hasPrecomputes(elm) {
return getW(elm) !== 1;
},
// non-const time multiplication ladder
unsafeLadder(elm, n, p = c.ZERO) {
let d = elm;
while (n > _0n$2) {
if (n & _1n$4)
p = p.add(d);
d = d.double();
n >>= _1n$4;
}
return p;
},
/**
* Creates a wNAF precomputation window. Used for caching.
* Default window size is set by `utils.precompute()` and is equal to 8.
* Number of precomputed points depends on the curve size:
* 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
* - 𝑊 is the window size
* - 𝑛 is the bitlength of the curve order.
* For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
* @param elm Point instance
* @param W window size
* @returns precomputed point tables flattened to a single array
*/
precomputeWindow(elm, W) {
const { windows, windowSize } = calcWOpts(W, bits);
const points = [];
let p = elm;
let base = p;
for (let window = 0; window < windows; window++) {
base = p;
points.push(base);
// i=1, bc we skip 0
for (let i = 1; i < windowSize; i++) {
base = base.add(p);
points.push(base);
}
p = base.double();
}
return points;
},
/**
* Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
* @param W window size
* @param precomputes precomputed tables
* @param n scalar (we don't check here, but should be less than curve order)
* @returns real and fake (for const-time) points
*/
wNAF(W, precomputes, n) {
// Smaller version:
// https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541
// TODO: check the scalar is less than group order?
// wNAF behavior is undefined otherwise. But have to carefully remove
// other checks before wNAF. ORDER == bits here.
// Accumulators
let p = c.ZERO;
let f = c.BASE;
// This code was first written with assumption that 'f' and 'p' will never be infinity point:
// since each addition is multiplied by 2 ** W, it cannot cancel each other. However,
// there is negate now: it is possible that negated element from low value
// would be the same as high element, which will create carry into next window.
// It's not obvious how this can fail, but still worth investigating later.
const wo = calcWOpts(W, bits);
for (let window = 0; window < wo.windows; window++) {
// (n === _0n) is handled and not early-exited. isEven and offsetF are used for noise
const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);
n = nextN;
if (isZero) {
// bits are 0: add garbage to fake point
// Important part for const-time getPublicKey: add random "noise" point to f.
f = f.add(negateCt(isNegF, precomputes[offsetF]));
}
else {
// bits are 1: add to result point
p = p.add(negateCt(isNeg, precomputes[offset]));
}
}
assert0(n);
// Return both real and fake points: JIT won't eliminate f.
// At this point there is a way to F be infinity-point even if p is not,
// which makes it less const-time: around 1 bigint multiply.
return { p, f };
},
/**
* Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.
* @param W window size
* @param precomputes precomputed tables
* @param n scalar (we don't check here, but should be less than curve order)
* @param acc accumulator point to add result of multiplication
* @returns point
*/
wNAFUnsafe(W, precomputes, n, acc = c.ZERO) {
const wo = calcWOpts(W, bits);
for (let window = 0; window < wo.windows; window++) {
if (n === _0n$2)
break; // Early-exit, skip 0 value
const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);
n = nextN;
if (isZero) {
// Window bits are 0: skip processing.
// Move to next window.
continue;
}
else {
const item = precomputes[offset];
acc = acc.add(isNeg ? item.negate() : item); // Re-using acc allows to save adds in MSM
}
}
assert0(n);
return acc;
},
getPrecomputes(W, P, transform) {
// Calculate precomputes on a first run, reuse them after
let comp = pointPrecomputes.get(P);
if (!comp) {
comp = this.precomputeWindow(P, W);
if (W !== 1) {
// Doing transform outside of if brings 15% perf hit
if (typeof transform === 'function')
comp = transform(comp);
pointPrecomputes.set(P, comp);
}
}
return comp;
},
wNAFCached(P, n, transform) {
const W = getW(P);
return this.wNAF(W, this.getPrecomputes(W, P, transform), n);
},
wNAFCachedUnsafe(P, n, transform, prev) {
const W = getW(P);
if (W === 1)
return this.unsafeLadder(P, n, prev); // For W=1 ladder is ~x2 faster
return this.wNAFUnsafe(W, this.getPrecomputes(W, P, transform), n, prev);
},
// We calculate precomputes for elliptic curve point multiplication
// using windowed method. This specifies window size and
// stores precomputed values. Usually only base point would be precomputed.
setWindowSize(P, W) {
validateW(W, bits);
pointWindowSizes.set(P, W);
pointPrecomputes.delete(P);
},
};
}
/**
* Endomorphism-specific multiplication for Koblitz curves.
* Cost: 128 dbl, 0-256 adds.
*/
function mulEndoUnsafe(c, point, k1, k2) {
let acc = point;
let p1 = c.ZERO;
let p2 = c.ZERO;
while (k1 > _0n$2 || k2 > _0n$2) {
if (k1 & _1n$4)
p1 = p1.add(acc);
if (k2 & _1n$4)
p2 = p2.add(acc);
acc = acc.double();
k1 >>= _1n$4;
k2 >>= _1n$4;
}
return { p1, p2 };
}
/**
* Pippenger algorithm for multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).
* 30x faster vs naive addition on L=4096, 10x faster than precomputes.
* For N=254bit, L=1, it does: 1024 ADD + 254 DBL. For L=5: 1536 ADD + 254 DBL.
* Algorithmically constant-time (for same L), even when 1 point + scalar, or when scalar = 0.
* @param c Curve Point constructor
* @param fieldN field over CURVE.N - important that it's not over CURVE.P
* @param points array of L curve points
* @param scalars array of L scalars (aka private keys / bigints)
*/
function pippenger(c, fieldN, points, scalars) {
// If we split scalars by some window (let's say 8 bits), every chunk will only
// take 256 buckets even if there are 4096 scalars, also re-uses double.
// TODO:
// - https://eprint.iacr.org/2024/750.pdf
// - https://tches.iacr.org/index.php/TCHES/article/view/10287
// 0 is accepted in scalars
validateMSMPoints(points, c);
validateMSMScalars(scalars, fieldN);
const plength = points.length;
const slength = scalars.length;
if (plength !== slength)
throw new Error('arrays of points and scalars must have equal length');
// if (plength === 0) throw new Error('array must be of length >= 2');
const zero = c.ZERO;
const wbits = bitLen(BigInt(plength));
let windowSize = 1; // bits
if (wbits > 12)
windowSize = wbits - 3;
else if (wbits > 4)
windowSize = wbits - 2;
else if (wbits > 0)
windowSize = 2;
const MASK = bitMask(windowSize);
const buckets = new Array(Number(MASK) + 1).fill(zero); // +1 for zero array
const lastBits = Math.floor((fieldN.BITS - 1) / windowSize) * windowSize;
let sum = zero;
for (let i = lastBits; i >= 0; i -= windowSize) {
buckets.fill(zero);
for (let j = 0; j < slength; j++) {
const scalar = scalars[j];
const wbits = Number((scalar >> BigInt(i)) & MASK);
buckets[wbits] = buckets[wbits].add(points[j]);
}
let resI = zero; // not using this will do small speed-up, but will lose ct
// Skip first bucket, because it is zero
for (let j = buckets.length - 1, sumI = zero; j > 0; j--) {
sumI = sumI.add(buckets[j]);
resI = resI.add(sumI);
}
sum = sum.add(resI);
if (i !== 0)
for (let j = 0; j < windowSize; j++)
sum = sum.double();
}
return sum;
}
function createField(order, field) {
if (field) {
if (field.ORDER !== order)
throw new Error('Field.ORDER must match order: Fp == p, Fn == n');
validateField(field);
return field;
}
else {
return Field(order);
}
}
/** Validates CURVE opts and creates fields */
function _createCurveFields(type, CURVE, curveOpts = {}) {
if (!CURVE || typeof CURVE !== 'object')
throw new Error(`expected valid ${type} CURVE object`);
for (const p of ['p', 'n', 'h']) {
const val = CURVE[p];
if (!(typeof val === 'bigint' && val > _0n$2))
throw new Error(`CURVE.${p} must be positive bigint`);
}
const Fp = createField(CURVE.p, curveOpts.Fp);
const Fn = createField(CURVE.n, curveOpts.Fn);
const _b = type === 'weierstrass' ? 'b' : 'd';
const params = ['Gx', 'Gy', 'a', _b];
for (const p of params) {
// @ts-ignore
if (!Fp.isValid(CURVE[p]))
throw new Error(`CURVE.${p} must be valid field element of CURVE.Fp`);
}
return { Fp, Fn };
}
/**
* Twisted Edwards curve. The formula is: ax² + y² = 1 + dx²y².
* For design rationale of types / exports, see weierstrass module documentation.
* Untwisted Edwards curves exist, but they aren't used in real-world protocols.
* @module
*/
// Be friendly to bad ECMAScript parsers by not using bigint literals
// prettier-ignore
const _0n$1 = BigInt(0), _1n$3 = BigInt(1), _2n$3 = BigInt(2), _8n$1 = BigInt(8);
// verification rule is either zip215 or rfc8032 / nist186-5. Consult fromHex:
const VERIFY_DEFAULT = { zip215: true };
function isEdValidXY(Fp, CURVE, x, y) {
const x2 = Fp.sqr(x);
const y2 = Fp.sqr(y);
const left = Fp.add(Fp.mul(CURVE.a, x2), y2);
const right = Fp.add(Fp.ONE, Fp.mul(CURVE.d, Fp.mul(x2, y2)));
return Fp.eql(left, right);
}
function edwards(CURVE, curveOpts = {}) {
const { Fp, Fn } = _createCurveFields('edwards', CURVE, curveOpts);
const { h: cofactor, n: CURVE_ORDER } = CURVE;
_validateObject(curveOpts, {}, { uvRatio: 'function' });
// Important:
// There are some places where Fp.BYTES is used instead of nByteLength.
// So far, everything has been tested with curves of Fp.BYTES == nByteLength.
// TODO: test and find curves which behave otherwise.
const MASK = _2n$3 << (BigInt(Fn.BYTES * 8) - _1n$3);
const modP = (n) => Fp.create(n); // Function overrides
// sqrt(u/v)
const uvRatio = curveOpts.uvRatio ||
((u, v) => {
try {
return { isValid: true, value: Fp.sqrt(Fp.div(u, v)) };
}
catch (e) {
return { isValid: false, value: _0n$1 };
}
});
// Validate whether the passed curve params are valid.
// equation ax² + y² = 1 + dx²y² should work for generator point.
if (!isEdValidXY(Fp, CURVE, CURVE.Gx, CURVE.Gy))
throw new Error('bad curve params: generator point');
/**
* Asserts coordinate is valid: 0 <= n < MASK.
* Coordinates >= Fp.ORDER are allowed for zip215.
*/
function acoord(title, n, banZero = false) {
const min = banZero ? _1n$3 : _0n$1;
aInRange('coordinate ' + title, n, min, MASK);
return n;
}
function aextpoint(other) {
if (!(other instanceof Point))
throw new Error('ExtendedPoint expected');
}
// Converts Extended point to default (x, y) coordinates.
// Can accept precomputed Z^-1 - for example, from invertBatch.
const toAffineMemo = memoized((p, iz) => {
const { ex: x, ey: y, ez: z } = p;
const is0 = p.is0();
if (iz == null)
iz = is0 ? _8n$1 : Fp.inv(z); // 8 was chosen arbitrarily
const ax = modP(x * iz);
const ay = modP(y * iz);
const zz = modP(z * iz);
if (is0)
return { x: _0n$1, y: _1n$3 };
if (zz !== _1n$3)
throw new Error('invZ was invalid');
return { x: ax, y: ay };
});
const assertValidMemo = memoized((p) => {
const { a, d } = CURVE;
if (p.is0())
throw new Error('bad point: ZERO'); // TODO: optimize, with vars below?
// Equation in affine coordinates: ax² + y² = 1 + dx²y²
// Equation in projective coordinates (X/Z, Y/Z, Z): (aX² + Y²)Z² = Z⁴ + dX²Y²
const { ex: X, ey: Y, ez: Z, et: T } = p;
const X2 = modP(X * X); // X²
const Y2 = modP(Y * Y); // Y²
const Z2 = modP(Z * Z); // Z²
const Z4 = modP(Z2 * Z2); // Z⁴
const aX2 = modP(X2 * a); // aX²
const left = modP(Z2 * modP(aX2 + Y2)); // (aX² + Y²)Z²
const right = modP(Z4 + modP(d * modP(X2 * Y2))); // Z⁴ + dX²Y²
if (left !== right)
throw new Error('bad point: equation left != right (1)');
// In Extended coordinates we also have T, which is x*y=T/Z: check X*Y == Z*T
const XY = modP(X * Y);
const ZT = modP(Z * T);
if (XY !== ZT)
throw new Error('bad point: equation left != right (2)');
return true;
});
// Extended Point works in extended coordinates: (X, Y, Z, T) ∋ (x=X/Z, y=Y/Z, T=xy).
// https://en.wikipedia.org/wiki/Twisted_Edwards_curve#Extended_coordinates
class Point {
constructor(ex, ey, ez, et) {
this.ex = acoord('x', ex);
this.ey = acoord('y', ey);
this.ez = acoord('z', ez, true);
this.et = acoord('t', et);
Object.freeze(this);
}
get x() {
return this.toAffine().x;
}
get y() {
return this.toAffine().y;
}
static fromAffine(p) {
if (p instanceof Point)
throw new Error('extended point not allowed');
const { x, y } = p || {};
acoord('x', x);
acoord('y', y);
return new Point(x, y, _1n$3, modP(x * y));
}
static normalizeZ(points) {
return normalizeZ(Point, 'ez', points);
}
// Multiscalar Multiplication
static msm(points, scalars) {
return pippenger(Point, Fn, points, scalars);
}
// "Private method", don't use it directly
_setWindowSize(windowSize) {
this.precompute(windowSize);
}
precompute(windowSize = 8, isLazy = true) {
wnaf.setWindowSize(this, windowSize);
if (!isLazy)
this.multiply(_2n$3); // random number
return this;
}
// Not required for fromHex(), which always creates valid points.
// Could be useful for fromAffine().
assertValidity() {
assertValidMemo(this);
}
// Compare one point to another.
equals(other) {
aextpoint(other);
const { ex: X1, ey: Y1, ez: Z1 } = this;
const { ex: X2, ey: Y2, ez: Z2 } = other;
const X1Z2 = modP(X1 * Z2);
const X2Z1 = modP(X2 * Z1);
const Y1Z2 = modP(Y1 * Z2);
const Y2Z1 = modP(Y2 * Z1);
return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
}
is0() {
return this.equals(Point.ZERO);
}
negate() {
// Flips point sign to a negative one (-x, y in affine coords)
return new Point(modP(-this.ex), this.ey, this.ez, modP(-this.et));
}
// Fast algo for doubling Extended Point.
// https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#doubling-dbl-2008-hwcd
// Cost: 4M + 4S + 1*a + 6add + 1*2.
double() {
const { a } = CURVE;
const { ex: X1, ey: Y1, ez: Z1 } = this;
const A = modP(X1 * X1); // A = X12
const B = modP(Y1 * Y1); // B = Y12
const C = modP(_2n$3 * modP(Z1 * Z1)); // C = 2*Z12
const D = modP(a * A); // D = a*A
const x1y1 = X1 + Y1;
const E = modP(modP(x1y1 * x1y1) - A - B); // E = (X1+Y1)2-A-B
const G = D + B; // G = D+B
const F = G - C; // F = G-C
const H = D - B; // H = D-B
const X3 = modP(E * F); // X3 = E*F
const Y3 = modP(G * H); // Y3 = G*H
const T3 = modP(E * H); // T3 = E*H
const Z3 = modP(F * G); // Z3 = F*G
return new Point(X3, Y3, Z3, T3);
}
// Fast algo for adding 2 Extended Points.
// https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#addition-add-2008-hwcd
// Cost: 9M + 1*a + 1*d + 7add.
add(other) {
aextpoint(other);
const { a, d } = CURVE;
const { ex: X1, ey: Y1, ez: Z1, et: T1 } = this;
const { ex: X2, ey: Y2, ez: Z2, et: T2 } = other;
const A = modP(X1 * X2); // A = X1*X2
const B = modP(Y1 * Y2); // B = Y1*Y2
const C = modP(T1 * d * T2); // C = T1*d*T2
const D = modP(Z1 * Z2); // D = Z1*Z2
const E = modP((X1 + Y1) * (X2 + Y2) - A - B); // E = (X1+Y1)*(X2+Y2)-A-B
const F = D - C; // F = D-C
const G = D + C; // G = D+C
const H = modP(B - a * A); // H = B-a*A
const X3 = modP(E * F); // X3 = E*F
const Y3 = modP(G * H); // Y3 = G*H
const T3 = modP(E * H); // T3 = E*H
const Z3 = modP(F * G); // Z3 = F*G
return new Point(X3, Y3, Z3, T3);
}
subtract(other) {
return this.add(other.negate());
}
// Constant-time multiplication.
multiply(scalar) {
const n = scalar;
aInRange('scalar', n, _1n$3, CURVE_ORDER); // 1 <= scalar < L
const { p, f } = wnaf.wNAFCached(this, n, Point.normalizeZ);
return Point.normalizeZ([p, f])[0];
}
// Non-constant-time multiplication. Uses double-and-add algorithm.
// It's faster, but should only be used when you don't care about
// an exposed private key e.g. sig verification.
// Does NOT allow scalars higher than CURVE.n.
// Accepts optional accumulator to merge with multiply (important for sparse scalars)
multiplyUnsafe(scalar, acc = Point.ZERO) {
const n = scalar;
aInRange('scalar', n, _0n$1, CURVE_ORDER); // 0 <= scalar < L
if (n === _0n$1)
return Point.ZERO;
if (this.is0() || n === _1n$3)
return this;
return wnaf.wNAFCachedUnsafe(this, n, Point.normalizeZ, acc);
}
// Checks if point is of small order.
// If you add something to small order point, you will have "dirty"
// point with torsion component.
// Multiplies point by cofactor and checks if the result is 0.
isSmallOrder() {
return this.multiplyUnsafe(cofactor).is0();
}
// Multiplies point by curve order and checks if the result is 0.
// Returns `false` is the point is dirty.
isTorsionFree() {
return wnaf.wNAFCachedUnsafe(this, CURVE_ORDER).is0();
}
// Converts Extended point to default (x, y) coordinates.
// Can accept precomputed Z^-1 - for example, from invertBatch.
toAffine(invertedZ) {
return toAffineMemo(this, invertedZ);
}
clearCofactor() {
if (cofactor === _1n$3)
return this;
return this.multiplyUnsafe(cofactor);
}
static fromBytes(bytes, zip215 = false) {
abytes(bytes);
return this.fromHex(bytes, zip215);
}
// Converts hash string or Uint8Array to Point.
// Uses algo from RFC8032 5.1.3.
static fromHex(hex, zip215 = false) {
const { d, a } = CURVE;
const len = Fp.BYTES;
hex = ensureBytes('pointHex', hex, len); // copy hex to a new array
abool('zip215', zip215);
const normed = hex.slice(); // copy again, we'll manipulate it
const lastByte = hex[len - 1]; // select last byte
normed[len - 1] = lastByte & ~0x80; // clear last bit
const y = bytesToNumberLE(normed);
// zip215=true is good for consensus-critical apps. =false follows RFC8032 / NIST186-5.
// RFC8032 prohibits >= p, but ZIP215 doesn't
// zip215=true: 0 <= y < MASK (2^256 for ed25519)
// zip215=false: 0 <= y < P (2^255-19 for ed25519)
const max = zip215 ? MASK : Fp.ORDER;
aInRange('pointHex.y', y, _0n$1, max);
// Ed25519: x² = (y²-1)/(dy²+1) mod p. Ed448: x² = (y²-1)/(dy²-1) mod p. Generic case:
// ax²+y²=1+dx²y² => y²-1=dx²y²-ax² => y²-1=x²(dy²-a) => x²=(y²-1)/(dy²-a)
const y2 = modP(y * y); // denominator is always non-0 mod p.
const u = modP(y2 - _1n$3); // u = y² - 1
const v = modP(d * y2 - a); // v = d y² + 1.
let { isValid, value: x } = uvRatio(u, v); // √(u/v)
if (!isValid)
throw new Error('Point.fromHex: invalid y coordinate');
const isXOdd = (x & _1n$3) === _1n$3; // There are 2 square roots. Use x_0 bit to select proper
const isLastByteOdd = (lastByte & 0x80) !== 0; // x_0, last bit
if (!zip215 && x === _0n$1 && isLastByteOdd)
// if x=0 and x_0 = 1, fail
throw new Error('Point.fromHex: x=0 and x_0=1');
if (isLastByteOdd !== isXOdd)
x = modP(-x); // if x_0 != x mod 2, set x = p-x
return Point.fromAffine({ x, y });
}
static fromPrivateScalar(scalar) {
return Point.BASE.multiply(scalar);
}
toBytes() {
const { x, y } = this.toAffine();
const bytes = numberToBytesLE(y, Fp.BYTES); // each y has 2 x values (x, -y)
bytes[bytes.length - 1] |= x & _1n$3 ? 0x80 : 0; // when compressing, it's enough to store y
return bytes; // and use the last byte to encode sign of x
}
/** @deprecated use `toBytes` */
toRawBytes() {
return this.toBytes();
}
toHex() {
return bytesToHex$1(this.toBytes());
}
toString() {
return `<Point ${this.is0() ? 'ZERO' : this.toHex()}>`;
}
}
// base / generator point
Point.BASE = new Point(CURVE.Gx, CURVE.Gy, _1n$3, modP(CURVE.Gx * CURVE.Gy));
// zero / infinity / identity point
Point.ZERO = new Point(_0n$1, _1n$3, _1n$3, _0n$1); // 0, 1, 1, 0
// fields
Point.Fp = Fp;
Point.Fn = Fn;
const wnaf = wNAF(Point, Fn.BYTES * 8); // Fn.BITS?
return Point;
}
/**
* Initializes EdDSA signatures over given Edwards curve.
*/
function eddsa(Point, eddsaOpts) {
_validateObject(eddsaOpts, {
hash: 'function',
}, {
adjustScalarBytes: 'function',
randomBytes: 'function',
domain: 'function',
prehash: 'function',
mapToCurve: 'function',
});
const { prehash, hash: cHash } = eddsaOpts;
const { BASE: G, Fp, Fn } = Point;
const CURVE_ORDER = Fn.ORDER;
const randomBytes_ = eddsaOpts.randomBytes || randomBytes$1;
const adjustScalarBytes = eddsaOpts.adjustScalarBytes || ((bytes) => bytes); // NOOP
const domain = eddsaOpts.domain ||
((data, ctx, phflag) => {
abool('phflag', phflag);
if (ctx.length || phflag)
throw new Error('Contexts/pre-hash are not supported');
return data;
}); // NOOP
function modN(a) {
return Fn.create(a);
}
// Little-endian SHA512 with modulo n
function modN_LE(hash) {
// Not using Fn.fromBytes: hash can be 2*Fn.BYTES
return modN(bytesToNumberLE(hash));
}
// Get the hashed private scalar per RFC8032 5.1.5
function getPrivateScalar(key) {
const len = Fp.BYTES;
key = ensureBytes('private key', key, len);
// Hash private key with curve's hash function to produce uniformingly random input
// Check byte lengths: ensure(64, h(ensure(32, key)))
const hashed = ensureBytes('hashed private key', cHash(key), 2 * len);
const head = adjustScalarBytes(hashed.slice(0, len)); // clear first half bits, produce FE
const prefix = hashed.slice(len, 2 * len); // second half is called key prefix (5.1.6)
const scalar = modN_LE(head); // The actual private scalar
return { head, prefix, scalar };
}
// Convenience method that creates public key from scalar. RFC8032 5.1.5
function getExtendedPublicKey(key) {
const { head, prefix, scalar } = getPrivateScalar(key);
const point = G.multiply(scalar); // Point on Edwards curve aka public key
const pointBytes = point.toBytes();
return { head, prefix, scalar, point, pointBytes };
}
// Calculates EdDSA pub key. RFC8032 5.1.5. Privkey is hashed. Use first half with 3 bits cleared
function getPublicKey(privKey) {
return getExtendedPublicKey(privKey).pointBytes;
}
// int('LE', SHA512(dom2(F, C) || msgs)) mod N
function hashDomainToScalar(context = Uint8Array.of(), ...msgs) {
const msg = concatBytes$1(...msgs);
return modN_LE(cHash(domain(msg, ensureBytes('context', context), !!prehash)));
}
/** Signs message with privateKey. RFC8032 5.1.6 */
function sign(msg, privKey, options = {}) {
msg = ensureBytes('message', msg);
if (prehash)
msg = prehash(msg); // for ed25519ph etc.
const { prefix, scalar, pointBytes } = getExtendedPublicKey(privKey);
const r = hashDomainToScalar(options.context, prefix, msg); // r = dom2(F, C) || prefix || PH(M)
const R = G.multiply(r).toBytes(); // R = rG
const k = hashDomainToScalar(options.context, R, pointBytes, msg); // R || A || PH(M)
const s = modN(r + k * scalar); // S = (r + k * s) mod L
aInRange('signature.s', s, _0n$1, CURVE_ORDER); // 0 <= s < l
const L = Fp.BYTES;
const res = concatBytes$1(R, numberToBytesLE(s, L));
return ensureBytes('result', res, L * 2); // 64-byte signature
}
const verifyOpts = VERIFY_DEFAULT;
/**
* Verifies EdDSA signature against message and public key. RFC8032 5.1.7.
* An extended group equation is checked.
*/
function verify(sig, msg, publicKey, options = verifyOpts) {
const { context, zip215 } = options;
const len = Fp.BYTES; // Verifies EdDSA signature against message and public key. RFC8032 5.1.7.
sig = ensureBytes('signature', sig, 2 * len); // An extended group equation is checked.
msg = ensureBytes('message', msg);
publicKey = ensureBytes('publicKey', publicKey, len);
if (zip215 !== undefined)
abool('zip215', zip215);
if (prehash)
msg = prehash(msg); // for ed25519ph, etc
const s = bytesToNumberLE(sig.slice(len, 2 * len));
let A, R, SB;
try {
// zip215=true is good for consensus-critical apps. =false follows RFC8032 / NIST186-5.
// zip215=true: 0 <= y < MASK (2^256 for ed25519)
// zip215=false: 0 <= y < P (2^255-19 for ed25519)
A = Point.fromHex(publicKey, zip215);
R = Point.fromHex(sig.slice(0, len), zip215);
SB = G.multiplyUnsafe(s); // 0 <= s < l is done inside
}
catch (error) {
return false;
}
if (!zip215 && A.isSmallOrder())
return false;
const k = hashDomainToScalar(context, R.toBytes(), A.toBytes(), msg);
const RkA = R.add(A.multiplyUnsafe(k));
// Extended group equation
// [8][S]B = [8]R + [8][k]A'
return RkA.subtract(SB).clearCofactor().is0();
}
G.precompute(8); // Enable precomputes. Slows down first publicKey computation by 20ms.
const utils = {
getExtendedPublicKey,
/** ed25519 priv keys are uniform 32b. No need to check for modulo bias, like in secp256k1. */
randomPrivateKey: () => randomBytes_(Fp.BYTES),
/**
* We're doing scalar multiplication (used in getPublicKey etc) with precomputed BASE_POINT
* values. This slows down first getPublicKey() by milliseconds (see Speed section),
* but allows to speed-up subsequent getPublicKey() calls up to 20x.
* @param windowSize 2, 4, 8, 16
*/
precompute(windowSize = 8, point = Point.BASE) {
return point.precompute(windowSize, false);
},
};
return { getPublicKey, sign, verify, utils, Point };
}
function _eddsa_legacy_opts_to_new(c) {
const CURVE = {
a: c.a,
d: c.d,
p: c.Fp.ORDER,
n: c.n,
h: c.h,
Gx: c.Gx,
Gy: c.Gy,
};
const Fp = c.Fp;
const Fn = Field(CURVE.n, c.nBitLength, true);
const curveOpts = { Fp, Fn, uvRatio: c.uvRatio };
const eddsaOpts = {
hash: c.hash,
randomBytes: c.randomBytes,
adjustScalarBytes: c.adjustScalarBytes,
domain: c.domain,
prehash: c.prehash,
mapToCurve: c.mapToCurve,
};
return { CURVE, curveOpts, eddsaOpts };
}
function _eddsa_new_output_to_legacy(c, eddsa) {
const legacy = Object.assign({}, eddsa, { ExtendedPoint: eddsa.Point, CURVE: c });
return legacy;
}
// TODO: remove. Use eddsa
function twistedEdwards(c) {
const { CURVE, curveOpts, eddsaOpts } = _eddsa_legacy_opts_to_new(c);
const Point = edwards(CURVE, curveOpts);
const EDDSA = eddsa(Point, eddsaOpts);
return _eddsa_new_output_to_legacy(c, EDDSA);
}
/**
* ed25519 Twisted Edwards curve with following addons:
* - X25519 ECDH
* - Ristretto cofactor elimination
* - Elligator hash-to-group / point indistinguishability
* @module
*/
// prettier-ignore
BigInt(0); const _1n$2 = BigInt(1), _2n$2 = BigInt(2); BigInt(3);
// prettier-ignore
const _5n = BigInt(5), _8n = BigInt(8);
// 2n**255n - 19n
// Removing Fp.create() will still work, and is 10% faster on sign
// a: Fp.create(BigInt(-1)),
// d is -121665/121666 a.k.a. Fp.neg(121665 * Fp.inv(121666))
// Finite field 2n**255n - 19n
// Subgroup order 2n**252n + 27742317777372353535851937790883648493n;
const ed25519_CURVE = {
p: BigInt('0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed'),
n: BigInt('0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed'),
h: _8n,
a: BigInt('0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec'),
d: BigInt('0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3'),
Gx: BigInt('0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a'),
Gy: BigInt('0x6666666666666666666666666666666666666666666666666666666666666658'),
};
function ed25519_pow_2_252_3(x) {
// prettier-ignore
const _10n = BigInt(10), _20n = BigInt(20), _40n = BigInt(40), _80n = BigInt(80);
const P = ed25519_CURVE.p;
const x2 = (x * x) % P;
const b2 = (x2 * x) % P; // x^3, 11
const b4 = (pow2(b2, _2n$2, P) * b2) % P; // x^15, 1111
const b5 = (pow2(b4, _1n$2, P) * x) % P; // x^31
const b10 = (pow2(b5, _5n, P) * b5) % P;
const b20 = (pow2(b10, _10n, P) * b10) % P;
const b40 = (pow2(b20, _20n, P) * b20) % P;
const b80 = (pow2(b40, _40n, P) * b40) % P;
const b160 = (pow2(b80, _80n, P) * b80) % P;
const b240 = (pow2(b160, _80n, P) * b80) % P;
const b250 = (pow2(b240, _10n, P) * b10) % P;
const pow_p_5_8 = (pow2(b250, _2n$2, P) * x) % P;
// ^ To pow to (p+3)/8, multiply it by x.
return { pow_p_5_8, b2 };
}
function adjustScalarBytes(bytes) {
// Section 5: For X25519, in order to decode 32 random bytes as an integer scalar,
// set the three least significant bits of the first byte
bytes[0] &= 248; // 0b1111_1000
// and the most significant bit of the last to zero,
bytes[31] &= 127; // 0b0111_1111
// set the second most significant bit of the last byte to 1
bytes[31] |= 64; // 0b0100_0000
return bytes;
}
// √(-1) aka √(a) aka 2^((p-1)/4)
// Fp.sqrt(Fp.neg(1))
const ED25519_SQRT_M1 = /* @__PURE__ */ BigInt('19681161376707505956807079304988542015446066515923890162744021073123829784752');
// sqrt(u/v)
function uvRatio(u, v) {
const P = ed25519_CURVE.p;
const v3 = mod(v * v * v, P); // v³
const v7 = mod(v3 * v3 * v, P); // v⁷
// (p+3)/8 and (p-5)/8
const pow = ed25519_pow_2_252_3(u * v7).pow_p_5_8;
let x = mod(u * v3 * pow, P); // (uv³)(uv⁷)^(p-5)/8
const vx2 = mod(v * x * x, P); // vx²
const root1 = x; // First root candidate
const root2 = mod(x * ED25519_SQRT_M1, P); // Second root candidate
const useRoot1 = vx2 === u; // If vx² = u (mod p), x is a square root
const useRoot2 = vx2 === mod(-u, P); // If vx² = -u, set x <-- x * 2^((p-1)/4)
const noRoot = vx2 === mod(-u * ED25519_SQRT_M1, P); // There is no valid root, vx² = -u√(-1)
if (useRoot1)
x = root1;
if (useRoot2 || noRoot)
x = root2; // We return root2 anyway, for const-time
if (isNegativeLE(x, P))
x = mod(-x, P);
return { isValid: useRoot1 || useRoot2, value: x };
}
const Fp = /* @__PURE__ */ (() => Field(ed25519_CURVE.p, undefined, true))();
const ed25519Defaults = /* @__PURE__ */ (() => ({
...ed25519_CURVE,
Fp,
hash: sha512$1,
adjustScalarBytes,
// dom2
// Ratio of u to v. Allows us to combine inversion and square root. Uses algo from RFC8032 5.1.3.
// Constant-time, u/√v
uvRatio,
}))();
/**
* ed25519 curve with EdDSA signatures.
* @example
* import { ed25519 } from '@noble/curves/ed25519';
* const priv = ed25519.utils.randomPrivateKey();
* const pub = ed25519.getPublicKey(priv);
* const msg = new TextEncoder().encode('hello');
* const sig = ed25519.sign(msg, priv);
* ed25519.verify(sig, msg, pub); // Default mode: follows ZIP215
* ed25519.verify(sig, msg, pub, { zip215: false }); // RFC8032 / FIPS 186-5
*/
const ed25519 = /* @__PURE__ */ (() => twistedEdwards(ed25519Defaults))();
// SPDX-License-Identifier: MIT
class SLIP10Ed25519Point extends Point {
getName() {
return 'SLIP10-Ed25519';
}
static fromBytes(point) {
if (point.length !== SLIP10_ED25519_CONST.PUBLIC_KEY_BYTE_LENGTH) {
throw new Error('Invalid point bytes length');
}
try {
const pt = ed25519.Point.fromHex(point);
return new this(pt);
}
catch {
throw new Error('Invalid point bytes');
}
}
static fromCoordinates(x, y) {
try {
const pt = ed25519.Point.fromAffine({ x, y });
return new this(pt);
}
catch {
throw new Error('Invalid coordinates for ed25519');
}
}
getUnderlyingObject() {
return this.point;
}
getX() {
return this.point.x;
}
getY() {
return this.point.y;
}
getRawEncoded() {
return this.point.toRawBytes();
}
getRawDecoded() {
const xBytes = this.point.x.toString(16).padStart(64, '0');
const yBytes = this.point.y.toString(16).padStart(64, '0');
return Uint8Array.from(toBuffer(xBytes + yBytes, 'hex'));
}
add(point) {
const other = point.getUnderlyingObject();
const sum = this.point.add(other);
return new SLIP10Ed25519Point(sum);
}
multiply(scalar) {
const prod = this.point.multiply(scalar);
return new SLIP10Ed25519Point(prod);
}
}
// SPDX-License-Identifier: MIT
class SLIP10Ed25519PublicKey extends PublicKey {
getName() {
return 'SLIP10-Ed25519';
}
static fromBytes(publicKey) {
let data = publicKey;
const prefix = SLIP10_ED25519_CONST.PUBLIC_KEY_PREFIX;
if (data.length === prefix.length + SLIP10_ED25519_CONST.PUBLIC_KEY_BYTE_LENGTH &&
data[0] === prefix[0]) {
data = data.slice(prefix.length);
}
if (data.length !== SLIP10_ED25519_CONST.PUBLIC_KEY_BYTE_LENGTH) {
throw new Error('Invalid key bytes length');
}
try {
const pt = ed25519.Point.fromHex(data);
return new this(pt);
}
catch {
throw new Error('Invalid key bytes');
}
}
static fromPoint(point) {
const raw = point.getRawEncoded();
return this.fromBytes(raw);
}
static getCompressedLength() {
return SLIP10_ED25519_CONST.PUBLIC_KEY_BYTE_LENGTH + SLIP10_ED25519_CONST.PUBLIC_KEY_PREFIX.length;
}
static getUncompressedLength() {
return this.getCompressedLength();
}
getUnderlyingObject() {
return this.publicKey;
}
getRawCompressed() {
return concatBytes(SLIP10_ED25519_CONST.PUBLIC_KEY_PREFIX, this.publicKey.toRawBytes());
}
getRawUncompressed() {
return this.getRawCompressed();
}
getPoint() {
return new SLIP10Ed25519Point(this.publicKey);
}
}
// SPDX-License-Identifier: MIT
class SLIP10Ed25519PrivateKey extends PrivateKey {
getName() {
return 'SLIP10-Ed25519';
}
static fromBytes(privateKey) {
if (privateKey.length !== SLIP10_ED25519_CONST.PRIVATE_KEY_BYTE_LENGTH) {
throw new Error('Invalid private key bytes length');
}
try {
return new this(privateKey);
}
catch {
throw new Error('Invalid private key bytes');
}
}
static getLength() {
return SLIP10_ED25519_CONST.PRIVATE_KEY_BYTE_LENGTH;
}
getRaw() {
return this.privateKey;
}
getUnderlyingObject() {
return this.privateKey;
}
getPublicKey() {
const pub = ed25519.getPublicKey(this.getRaw());
return SLIP10Ed25519PublicKey.fromBytes(pub);
}
}
// SPDX-License-Identifier: MIT
class SLIP10Ed25519ECC extends EllipticCurveCryptography {
static NAME = 'SLIP10-Ed25519';
static ORDER = BigInt('7237005577332262213973186563042994240857116359379907606001950938285454250989');
static GENERATOR = SLIP10Ed25519Point.fromCoordinates(BigInt('15112221349535400772501151409588531511454012693041857206046113283949847762202'), BigInt('46316835694926478169428394003475163141307993866256225615783033603165251855960'));
static POINT = SLIP10Ed25519Point;
static PUBLIC_KEY = SLIP10Ed25519PublicKey;
static PRIVATE_KEY = SLIP10Ed25519PrivateKey;
}
// SPDX-License-Identifier: MIT
class SLIP10Ed25519Blake2bPoint extends SLIP10Ed25519Point {
getName() {
return 'SLIP10-Ed25519-Blake2b';
}
}
// SPDX-License-Identifier: MIT
class SLIP10Ed25519Blake2bPublicKey extends SLIP10Ed25519PublicKey {
getName() {
return 'SLIP10-Ed25519-Blake2b';
}
getPoint() {
return new SLIP10Ed25519Blake2bPoint(this.publicKey);
}
}
function getAugmentedNamespace(n) {
if (Object.prototype.hasOwnProperty.call(n, '__esModule')) return n;
var f = n.default;
if (typeof f == "function") {
var a = function a () {
if (this instanceof a) {
return Reflect.construct(f, arguments, this.constructor);
}
return f.apply(this, arguments);
};
a.prototype = f.prototype;
} else a = {};
Object.defineProperty(a, '__esModule', {value: true});
Object.keys(n).forEach(function (k) {
var d = Object.getOwnPropertyDescriptor(n, k);
Object.defineProperty(a, k, d.get ? d : {
enumerable: true,
get: function () {
return n[k];
}
});
});
return a;
}
function commonjsRequire(path) {
throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
}
var naclFast = {exports: {}};
var util;
var hasRequiredUtil;
function requireUtil () {
if (hasRequiredUtil) return util;
hasRequiredUtil = 1;
const ERROR_MSG_INPUT = 'Input must be an string, Buffer or Uint8Array';
// For convenience, let people hash a string, not just a Uint8Array
function normalizeInput (input) {
let ret;
if (input instanceof Uint8Array) {
ret = input;
} else if (typeof input === 'string') {
const encoder = new TextEncoder();
ret = encoder.encode(input);
} else {
throw new Error(ERROR_MSG_INPUT)
}
return ret
}
// Converts a Uint8Array to a hexadecimal string
// For example, toHex([255, 0, 255]) returns "ff00ff"
function toHex (bytes) {
return Array.prototype.map
.call(bytes, function (n) {
return (n < 16 ? '0' : '') + n.toString(16)
})
.join('')
}
// Converts any value in [0...2^32-1] to an 8-character hex string
function uint32ToHex (val) {
return (0x100000000 + val).toString(16).substring(1)
}
// For debugging: prints out hash state in the same format as the RFC
// sample computation exactly, so that you can diff
function debugPrint (label, arr, size) {
let msg = '\n' + label + ' = ';
for (let i = 0; i < arr.length; i += 2) {
if (size === 32) {
msg += uint32ToHex(arr[i]).toUpperCase();
msg += ' ';
msg += uint32ToHex(arr[i + 1]).toUpperCase();
} else if (size === 64) {
msg += uint32ToHex(arr[i + 1]).toUpperCase();
msg += uint32ToHex(arr[i]).toUpperCase();
} else throw new Error('Invalid size ' + size)
if (i % 6 === 4) {
msg += '\n' + new Array(label.length + 4).join(' ');
} else if (i < arr.length - 2) {
msg += ' ';
}
}
console.log(msg);
}
// For performance testing: generates N bytes of input, hashes M times
// Measures and prints MB/second hash performance each time
function testSpeed (hashFn, N, M) {
let startMs = new Date().getTime();
const input = new Uint8Array(N);
for (let i = 0; i < N; i++) {
input[i] = i % 256;
}
const genMs = new Date().getTime();
console.log('Generated random input in ' + (genMs - startMs) + 'ms');
startMs = genMs;
for (let i = 0; i < M; i++) {
const hashHex = hashFn(input);
const hashMs = new Date().getTime();
const ms = hashMs - startMs;
startMs = hashMs;
console.log('Hashed in ' + ms + 'ms: ' + hashHex.substring(0, 20) + '...');
console.log(
Math.round((N / (1 << 20) / (ms / 1000)) * 100) / 100 + ' MB PER SECOND'
);
}
}
util = {
normalizeInput: normalizeInput,
toHex: toHex,
debugPrint: debugPrint,
testSpeed: testSpeed
};
return util;
}
var blake2b_1;
var hasRequiredBlake2b;
function requireBlake2b () {
if (hasRequiredBlake2b) return blake2b_1;
hasRequiredBlake2b = 1;
// Blake2B in pure Javascript
// Adapted from the reference implementation in RFC7693
// Ported to Javascript by DC - https://github.com/dcposch
const util = requireUtil();
// 64-bit unsigned addition
// Sets v[a,a+1] += v[b,b+1]
// v should be a Uint32Array
function ADD64AA (v, a, b) {
const o0 = v[a] + v[b];
let 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) {
let o0 = v[a] + b0;
if (b0 < 0) {
o0 += 0x100000000;
}
let 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) {
const x0 = m[ix];
const x1 = m[ix + 1];
const y0 = m[iy];
const 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
let xor0 = v[d] ^ v[a];
let 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
const BLAKE2B_IV32 = new Uint32Array([
0xf3bcc908, 0x6a09e667, 0x84caa73b, 0xbb67ae85, 0xfe94f82b, 0x3c6ef372,
0x5f1d36f1, 0xa54ff53a, 0xade682d1, 0x510e527f, 0x2b3e6c1f, 0x9b05688c,
0xfb41bd6b, 0x1f83d9ab, 0x137e2179, 0x5be0cd19
]);
const 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
const 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
const v = new Uint32Array(32);
const m = new Uint32Array(32);
function blake2bCompress (ctx, last) {
let 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
// uncomment the DebugPrint calls to log the computation
// and match the RFC sample documentation
// util.debugPrint(' m[16]', m, 64)
for (i = 0; i < 12; i++) {
// util.debugPrint(' (i=' + (i < 10 ? ' ' : '') + i + ') v[16]', v, 64)
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]);
}
// util.debugPrint(' (i=12) v[16]', v, 64)
for (i = 0; i < 16; i++) {
ctx.h[i] = ctx.h[i] ^ v[i] ^ v[i + 16];
}
// util.debugPrint('h[8]', ctx.h, 64)
}
// reusable parameterBlock
const parameterBlock = 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
// Takes an optinal Uint8Array salt
// Takes an optinal Uint8Array personal
function blake2bInit (outlen, key, salt, personal) {
if (outlen === 0 || outlen > 64) {
throw new Error('Illegal output length, expected 0 < length <= 64')
}
if (key && key.length > 64) {
throw new Error('Illegal key, expected Uint8Array with 0 < length <= 64')
}
if (salt && salt.length !== 16) {
throw new Error('Illegal salt, expected Uint8Array with length is 16')
}
if (personal && personal.length !== 16) {
throw new Error('Illegal personal, expected Uint8Array with length is 16')
}
// state, 'param block'
const ctx = {
b: new Uint8Array(128),
h: new Uint32Array(16),
t: 0, // input count
c: 0, // pointer within buffer
outlen: outlen // output length in bytes
};
// initialize parameterBlock before usage
parameterBlock.fill(0);
parameterBlock[0] = outlen;
if (key) parameterBlock[1] = key.length;
parameterBlock[2] = 1; // fanout
parameterBlock[3] = 1; // depth
if (salt) parameterBlock.set(salt, 32);
if (personal) parameterBlock.set(personal, 48);
// initialize hash state
for (let i = 0; i < 16; i++) {
ctx.h[i] = BLAKE2B_IV32[i] ^ B2B_GET32(parameterBlock, i * 4);
}
// key the hash, if applicable
if (key) {
blake2bUpdate(ctx, key);
// at the end
ctx.c = 128;
}
return ctx
}
// Updates a BLAKE2b streaming hash
// Requires hash context and Uint8Array (byte array)
function blake2bUpdate (ctx, input) {
for (let 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) {
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
// little endian convert and store
const out = new Uint8Array(ctx.outlen);
for (let i = 0; i < ctx.outlen; i++) {
out[i] = ctx.h[i >> 2] >> (8 * (i & 3));
}
return out
}
// Computes the BLAKE2B hash of a string or byte array, and returns a Uint8Array
//
// Returns a n-byte Uint8Array
//
// Parameters:
// - input - the input bytes, as a string, Buffer or Uint8Array
// - key - optional key Uint8Array, up to 64 bytes
// - outlen - optional output length in bytes, default 64
// - salt - optional salt bytes, string, Buffer or Uint8Array
// - personal - optional personal bytes, string, Buffer or Uint8Array
function blake2b (input, key, outlen, salt, personal) {
// preprocess inputs
outlen = outlen || 64;
input = util.normalizeInput(input);
if (salt) {
salt = util.normalizeInput(salt);
}
if (personal) {
personal = util.normalizeInput(personal);
}
// do the math
const ctx = blake2bInit(outlen, key, salt, personal);
blake2bUpdate(ctx, input);
return blake2bFinal(ctx)
}
// Computes the BLAKE2B hash of a string or byte array
//
// Returns an n-byte hash in hex, all lowercase
//
// Parameters:
// - input - the input bytes, as a string, Buffer, or Uint8Array
// - key - optional key Uint8Array, up to 64 bytes
// - outlen - optional output length in bytes, default 64
// - salt - optional salt bytes, string, Buffer or Uint8Array
// - personal - optional personal bytes, string, Buffer or Uint8Array
function blake2bHex (input, key, outlen, salt, personal) {
const output = blake2b(input, key, outlen, salt, personal);
return util.toHex(output)
}
blake2b_1 = {
blake2b: blake2b,
blake2bHex: blake2bHex,
blake2bInit: blake2bInit,
blake2bUpdate: blake2bUpdate,
blake2bFinal: blake2bFinal
};
return blake2b_1;
}
var _nodeResolve_empty = {};
var _nodeResolve_empty$1 = /*#__PURE__*/Object.freeze({
__proto__: null,
'default': _nodeResolve_empty
});
var require$$1 = /*@__PURE__*/getAugmentedNamespace(_nodeResolve_empty$1);
naclFast.exports;
var hasRequiredNaclFast;
function requireNaclFast () {
if (hasRequiredNaclFast) return naclFast.exports;
hasRequiredNaclFast = 1;
(function (module) {
const blake2b = requireBlake2b();
(function(nacl) {
// Ported in 2014 by Dmitry Chestnykh and Devi Mandiri.
// Public domain.
//
// Implementation derived from TweetNaCl version 20140427.
// See for details: http://tweetnacl.cr.yp.to/
var gf = function(init) {
var i, r = new Float64Array(16);
if (init) for (i = 0; i < init.length; i++) r[i] = init[i];
return r;
};
// Pluggable, initialized in high-level API below.
var randombytes = function(/* x, n */) { throw new Error('no PRNG'); };
var _0 = new Uint8Array(16);
var _9 = new Uint8Array(32); _9[0] = 9;
var gf0 = gf(),
gf1 = gf([1]),
_121665 = gf([0xdb41, 1]),
D = gf([0x78a3, 0x1359, 0x4dca, 0x75eb, 0xd8ab, 0x4141, 0x0a4d, 0x0070, 0xe898, 0x7779, 0x4079, 0x8cc7, 0xfe73, 0x2b6f, 0x6cee, 0x5203]),
D2 = gf([0xf159, 0x26b2, 0x9b94, 0xebd6, 0xb156, 0x8283, 0x149a, 0x00e0, 0xd130, 0xeef3, 0x80f2, 0x198e, 0xfce7, 0x56df, 0xd9dc, 0x2406]),
X = gf([0xd51a, 0x8f25, 0x2d60, 0xc956, 0xa7b2, 0x9525, 0xc760, 0x692c, 0xdc5c, 0xfdd6, 0xe231, 0xc0a4, 0x53fe, 0xcd6e, 0x36d3, 0x2169]),
Y = gf([0x6658, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666]),
I = gf([0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1, 0x2480, 0x2b83]);
function vn(x, xi, y, yi, n) {
var i,d = 0;
for (i = 0; i < n; i++) d |= x[xi+i]^y[yi+i];
return (1 & ((d - 1) >>> 8)) - 1;
}
function crypto_verify_16(x, xi, y, yi) {
return vn(x,xi,y,yi,16);
}
function crypto_verify_32(x, xi, y, yi) {
return vn(x,xi,y,yi,32);
}
function core_salsa20(o, p, k, c) {
var j0 = c[ 0] & 0xff | (c[ 1] & 0xff)<<8 | (c[ 2] & 0xff)<<16 | (c[ 3] & 0xff)<<24,
j1 = k[ 0] & 0xff | (k[ 1] & 0xff)<<8 | (k[ 2] & 0xff)<<16 | (k[ 3] & 0xff)<<24,
j2 = k[ 4] & 0xff | (k[ 5] & 0xff)<<8 | (k[ 6] & 0xff)<<16 | (k[ 7] & 0xff)<<24,
j3 = k[ 8] & 0xff | (k[ 9] & 0xff)<<8 | (k[10] & 0xff)<<16 | (k[11] & 0xff)<<24,
j4 = k[12] & 0xff | (k[13] & 0xff)<<8 | (k[14] & 0xff)<<16 | (k[15] & 0xff)<<24,
j5 = c[ 4] & 0xff | (c[ 5] & 0xff)<<8 | (c[ 6] & 0xff)<<16 | (c[ 7] & 0xff)<<24,
j6 = p[ 0] & 0xff | (p[ 1] & 0xff)<<8 | (p[ 2] & 0xff)<<16 | (p[ 3] & 0xff)<<24,
j7 = p[ 4] & 0xff | (p[ 5] & 0xff)<<8 | (p[ 6] & 0xff)<<16 | (p[ 7] & 0xff)<<24,
j8 = p[ 8] & 0xff | (p[ 9] & 0xff)<<8 | (p[10] & 0xff)<<16 | (p[11] & 0xff)<<24,
j9 = p[12] & 0xff | (p[13] & 0xff)<<8 | (p[14] & 0xff)<<16 | (p[15] & 0xff)<<24,
j10 = c[ 8] & 0xff | (c[ 9] & 0xff)<<8 | (c[10] & 0xff)<<16 | (c[11] & 0xff)<<24,
j11 = k[16] & 0xff | (k[17] & 0xff)<<8 | (k[18] & 0xff)<<16 | (k[19] & 0xff)<<24,
j12 = k[20] & 0xff | (k[21] & 0xff)<<8 | (k[22] & 0xff)<<16 | (k[23] & 0xff)<<24,
j13 = k[24] & 0xff | (k[25] & 0xff)<<8 | (k[26] & 0xff)<<16 | (k[27] & 0xff)<<24,
j14 = k[28] & 0xff | (k[29] & 0xff)<<8 | (k[30] & 0xff)<<16 | (k[31] & 0xff)<<24,
j15 = c[12] & 0xff | (c[13] & 0xff)<<8 | (c[14] & 0xff)<<16 | (c[15] & 0xff)<<24;
var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7,
x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14,
x15 = j15, u;
for (var i = 0; i < 20; i += 2) {
u = x0 + x12 | 0;
x4 ^= u<<7 | u>>>(32-7);
u = x4 + x0 | 0;
x8 ^= u<<9 | u>>>(32-9);
u = x8 + x4 | 0;
x12 ^= u<<13 | u>>>(32-13);
u = x12 + x8 | 0;
x0 ^= u<<18 | u>>>(32-18);
u = x5 + x1 | 0;
x9 ^= u<<7 | u>>>(32-7);
u = x9 + x5 | 0;
x13 ^= u<<9 | u>>>(32-9);
u = x13 + x9 | 0;
x1 ^= u<<13 | u>>>(32-13);
u = x1 + x13 | 0;
x5 ^= u<<18 | u>>>(32-18);
u = x10 + x6 | 0;
x14 ^= u<<7 | u>>>(32-7);
u = x14 + x10 | 0;
x2 ^= u<<9 | u>>>(32-9);
u = x2 + x14 | 0;
x6 ^= u<<13 | u>>>(32-13);
u = x6 + x2 | 0;
x10 ^= u<<18 | u>>>(32-18);
u = x15 + x11 | 0;
x3 ^= u<<7 | u>>>(32-7);
u = x3 + x15 | 0;
x7 ^= u<<9 | u>>>(32-9);
u = x7 + x3 | 0;
x11 ^= u<<13 | u>>>(32-13);
u = x11 + x7 | 0;
x15 ^= u<<18 | u>>>(32-18);
u = x0 + x3 | 0;
x1 ^= u<<7 | u>>>(32-7);
u = x1 + x0 | 0;
x2 ^= u<<9 | u>>>(32-9);
u = x2 + x1 | 0;
x3 ^= u<<13 | u>>>(32-13);
u = x3 + x2 | 0;
x0 ^= u<<18 | u>>>(32-18);
u = x5 + x4 | 0;
x6 ^= u<<7 | u>>>(32-7);
u = x6 + x5 | 0;
x7 ^= u<<9 | u>>>(32-9);
u = x7 + x6 | 0;
x4 ^= u<<13 | u>>>(32-13);
u = x4 + x7 | 0;
x5 ^= u<<18 | u>>>(32-18);
u = x10 + x9 | 0;
x11 ^= u<<7 | u>>>(32-7);
u = x11 + x10 | 0;
x8 ^= u<<9 | u>>>(32-9);
u = x8 + x11 | 0;
x9 ^= u<<13 | u>>>(32-13);
u = x9 + x8 | 0;
x10 ^= u<<18 | u>>>(32-18);
u = x15 + x14 | 0;
x12 ^= u<<7 | u>>>(32-7);
u = x12 + x15 | 0;
x13 ^= u<<9 | u>>>(32-9);
u = x13 + x12 | 0;
x14 ^= u<<13 | u>>>(32-13);
u = x14 + x13 | 0;
x15 ^= u<<18 | u>>>(32-18);
}
x0 = x0 + j0 | 0;
x1 = x1 + j1 | 0;
x2 = x2 + j2 | 0;
x3 = x3 + j3 | 0;
x4 = x4 + j4 | 0;
x5 = x5 + j5 | 0;
x6 = x6 + j6 | 0;
x7 = x7 + j7 | 0;
x8 = x8 + j8 | 0;
x9 = x9 + j9 | 0;
x10 = x10 + j10 | 0;
x11 = x11 + j11 | 0;
x12 = x12 + j12 | 0;
x13 = x13 + j13 | 0;
x14 = x14 + j14 | 0;
x15 = x15 + j15 | 0;
o[ 0] = x0 >>> 0 & 0xff;
o[ 1] = x0 >>> 8 & 0xff;
o[ 2] = x0 >>> 16 & 0xff;
o[ 3] = x0 >>> 24 & 0xff;
o[ 4] = x1 >>> 0 & 0xff;
o[ 5] = x1 >>> 8 & 0xff;
o[ 6] = x1 >>> 16 & 0xff;
o[ 7] = x1 >>> 24 & 0xff;
o[ 8] = x2 >>> 0 & 0xff;
o[ 9] = x2 >>> 8 & 0xff;
o[10] = x2 >>> 16 & 0xff;
o[11] = x2 >>> 24 & 0xff;
o[12] = x3 >>> 0 & 0xff;
o[13] = x3 >>> 8 & 0xff;
o[14] = x3 >>> 16 & 0xff;
o[15] = x3 >>> 24 & 0xff;
o[16] = x4 >>> 0 & 0xff;
o[17] = x4 >>> 8 & 0xff;
o[18] = x4 >>> 16 & 0xff;
o[19] = x4 >>> 24 & 0xff;
o[20] = x5 >>> 0 & 0xff;
o[21] = x5 >>> 8 & 0xff;
o[22] = x5 >>> 16 & 0xff;
o[23] = x5 >>> 24 & 0xff;
o[24] = x6 >>> 0 & 0xff;
o[25] = x6 >>> 8 & 0xff;
o[26] = x6 >>> 16 & 0xff;
o[27] = x6 >>> 24 & 0xff;
o[28] = x7 >>> 0 & 0xff;
o[29] = x7 >>> 8 & 0xff;
o[30] = x7 >>> 16 & 0xff;
o[31] = x7 >>> 24 & 0xff;
o[32] = x8 >>> 0 & 0xff;
o[33] = x8 >>> 8 & 0xff;
o[34] = x8 >>> 16 & 0xff;
o[35] = x8 >>> 24 & 0xff;
o[36] = x9 >>> 0 & 0xff;
o[37] = x9 >>> 8 & 0xff;
o[38] = x9 >>> 16 & 0xff;
o[39] = x9 >>> 24 & 0xff;
o[40] = x10 >>> 0 & 0xff;
o[41] = x10 >>> 8 & 0xff;
o[42] = x10 >>> 16 & 0xff;
o[43] = x10 >>> 24 & 0xff;
o[44] = x11 >>> 0 & 0xff;
o[45] = x11 >>> 8 & 0xff;
o[46] = x11 >>> 16 & 0xff;
o[47] = x11 >>> 24 & 0xff;
o[48] = x12 >>> 0 & 0xff;
o[49] = x12 >>> 8 & 0xff;
o[50] = x12 >>> 16 & 0xff;
o[51] = x12 >>> 24 & 0xff;
o[52] = x13 >>> 0 & 0xff;
o[53] = x13 >>> 8 & 0xff;
o[54] = x13 >>> 16 & 0xff;
o[55] = x13 >>> 24 & 0xff;
o[56] = x14 >>> 0 & 0xff;
o[57] = x14 >>> 8 & 0xff;
o[58] = x14 >>> 16 & 0xff;
o[59] = x14 >>> 24 & 0xff;
o[60] = x15 >>> 0 & 0xff;
o[61] = x15 >>> 8 & 0xff;
o[62] = x15 >>> 16 & 0xff;
o[63] = x15 >>> 24 & 0xff;
}
function core_hsalsa20(o,p,k,c) {
var j0 = c[ 0] & 0xff | (c[ 1] & 0xff)<<8 | (c[ 2] & 0xff)<<16 | (c[ 3] & 0xff)<<24,
j1 = k[ 0] & 0xff | (k[ 1] & 0xff)<<8 | (k[ 2] & 0xff)<<16 | (k[ 3] & 0xff)<<24,
j2 = k[ 4] & 0xff | (k[ 5] & 0xff)<<8 | (k[ 6] & 0xff)<<16 | (k[ 7] & 0xff)<<24,
j3 = k[ 8] & 0xff | (k[ 9] & 0xff)<<8 | (k[10] & 0xff)<<16 | (k[11] & 0xff)<<24,
j4 = k[12] & 0xff | (k[13] & 0xff)<<8 | (k[14] & 0xff)<<16 | (k[15] & 0xff)<<24,
j5 = c[ 4] & 0xff | (c[ 5] & 0xff)<<8 | (c[ 6] & 0xff)<<16 | (c[ 7] & 0xff)<<24,
j6 = p[ 0] & 0xff | (p[ 1] & 0xff)<<8 | (p[ 2] & 0xff)<<16 | (p[ 3] & 0xff)<<24,
j7 = p[ 4] & 0xff | (p[ 5] & 0xff)<<8 | (p[ 6] & 0xff)<<16 | (p[ 7] & 0xff)<<24,
j8 = p[ 8] & 0xff | (p[ 9] & 0xff)<<8 | (p[10] & 0xff)<<16 | (p[11] & 0xff)<<24,
j9 = p[12] & 0xff | (p[13] & 0xff)<<8 | (p[14] & 0xff)<<16 | (p[15] & 0xff)<<24,
j10 = c[ 8] & 0xff | (c[ 9] & 0xff)<<8 | (c[10] & 0xff)<<16 | (c[11] & 0xff)<<24,
j11 = k[16] & 0xff | (k[17] & 0xff)<<8 | (k[18] & 0xff)<<16 | (k[19] & 0xff)<<24,
j12 = k[20] & 0xff | (k[21] & 0xff)<<8 | (k[22] & 0xff)<<16 | (k[23] & 0xff)<<24,
j13 = k[24] & 0xff | (k[25] & 0xff)<<8 | (k[26] & 0xff)<<16 | (k[27] & 0xff)<<24,
j14 = k[28] & 0xff | (k[29] & 0xff)<<8 | (k[30] & 0xff)<<16 | (k[31] & 0xff)<<24,
j15 = c[12] & 0xff | (c[13] & 0xff)<<8 | (c[14] & 0xff)<<16 | (c[15] & 0xff)<<24;
var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7,
x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14,
x15 = j15, u;
for (var i = 0; i < 20; i += 2) {
u = x0 + x12 | 0;
x4 ^= u<<7 | u>>>(32-7);
u = x4 + x0 | 0;
x8 ^= u<<9 | u>>>(32-9);
u = x8 + x4 | 0;
x12 ^= u<<13 | u>>>(32-13);
u = x12 + x8 | 0;
x0 ^= u<<18 | u>>>(32-18);
u = x5 + x1 | 0;
x9 ^= u<<7 | u>>>(32-7);
u = x9 + x5 | 0;
x13 ^= u<<9 | u>>>(32-9);
u = x13 + x9 | 0;
x1 ^= u<<13 | u>>>(32-13);
u = x1 + x13 | 0;
x5 ^= u<<18 | u>>>(32-18);
u = x10 + x6 | 0;
x14 ^= u<<7 | u>>>(32-7);
u = x14 + x10 | 0;
x2 ^= u<<9 | u>>>(32-9);
u = x2 + x14 | 0;
x6 ^= u<<13 | u>>>(32-13);
u = x6 + x2 | 0;
x10 ^= u<<18 | u>>>(32-18);
u = x15 + x11 | 0;
x3 ^= u<<7 | u>>>(32-7);
u = x3 + x15 | 0;
x7 ^= u<<9 | u>>>(32-9);
u = x7 + x3 | 0;
x11 ^= u<<13 | u>>>(32-13);
u = x11 + x7 | 0;
x15 ^= u<<18 | u>>>(32-18);
u = x0 + x3 | 0;
x1 ^= u<<7 | u>>>(32-7);
u = x1 + x0 | 0;
x2 ^= u<<9 | u>>>(32-9);
u = x2 + x1 | 0;
x3 ^= u<<13 | u>>>(32-13);
u = x3 + x2 | 0;
x0 ^= u<<18 | u>>>(32-18);
u = x5 + x4 | 0;
x6 ^= u<<7 | u>>>(32-7);
u = x6 + x5 | 0;
x7 ^= u<<9 | u>>>(32-9);
u = x7 + x6 | 0;
x4 ^= u<<13 | u>>>(32-13);
u = x4 + x7 | 0;
x5 ^= u<<18 | u>>>(32-18);
u = x10 + x9 | 0;
x11 ^= u<<7 | u>>>(32-7);
u = x11 + x10 | 0;
x8 ^= u<<9 | u>>>(32-9);
u = x8 + x11 | 0;
x9 ^= u<<13 | u>>>(32-13);
u = x9 + x8 | 0;
x10 ^= u<<18 | u>>>(32-18);
u = x15 + x14 | 0;
x12 ^= u<<7 | u>>>(32-7);
u = x12 + x15 | 0;
x13 ^= u<<9 | u>>>(32-9);
u = x13 + x12 | 0;
x14 ^= u<<13 | u>>>(32-13);
u = x14 + x13 | 0;
x15 ^= u<<18 | u>>>(32-18);
}
o[ 0] = x0 >>> 0 & 0xff;
o[ 1] = x0 >>> 8 & 0xff;
o[ 2] = x0 >>> 16 & 0xff;
o[ 3] = x0 >>> 24 & 0xff;
o[ 4] = x5 >>> 0 & 0xff;
o[ 5] = x5 >>> 8 & 0xff;
o[ 6] = x5 >>> 16 & 0xff;
o[ 7] = x5 >>> 24 & 0xff;
o[ 8] = x10 >>> 0 & 0xff;
o[ 9] = x10 >>> 8 & 0xff;
o[10] = x10 >>> 16 & 0xff;
o[11] = x10 >>> 24 & 0xff;
o[12] = x15 >>> 0 & 0xff;
o[13] = x15 >>> 8 & 0xff;
o[14] = x15 >>> 16 & 0xff;
o[15] = x15 >>> 24 & 0xff;
o[16] = x6 >>> 0 & 0xff;
o[17] = x6 >>> 8 & 0xff;
o[18] = x6 >>> 16 & 0xff;
o[19] = x6 >>> 24 & 0xff;
o[20] = x7 >>> 0 & 0xff;
o[21] = x7 >>> 8 & 0xff;
o[22] = x7 >>> 16 & 0xff;
o[23] = x7 >>> 24 & 0xff;
o[24] = x8 >>> 0 & 0xff;
o[25] = x8 >>> 8 & 0xff;
o[26] = x8 >>> 16 & 0xff;
o[27] = x8 >>> 24 & 0xff;
o[28] = x9 >>> 0 & 0xff;
o[29] = x9 >>> 8 & 0xff;
o[30] = x9 >>> 16 & 0xff;
o[31] = x9 >>> 24 & 0xff;
}
function crypto_core_salsa20(out,inp,k,c) {
core_salsa20(out,inp,k,c);
}
function crypto_core_hsalsa20(out,inp,k,c) {
core_hsalsa20(out,inp,k,c);
}
var sigma = new Uint8Array([101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107]);
// "expand 32-byte k"
function crypto_stream_salsa20_xor(c,cpos,m,mpos,b,n,k) {
var z = new Uint8Array(16), x = new Uint8Array(64);
var u, i;
for (i = 0; i < 16; i++) z[i] = 0;
for (i = 0; i < 8; i++) z[i] = n[i];
while (b >= 64) {
crypto_core_salsa20(x,z,k,sigma);
for (i = 0; i < 64; i++) c[cpos+i] = m[mpos+i] ^ x[i];
u = 1;
for (i = 8; i < 16; i++) {
u = u + (z[i] & 0xff) | 0;
z[i] = u & 0xff;
u >>>= 8;
}
b -= 64;
cpos += 64;
mpos += 64;
}
if (b > 0) {
crypto_core_salsa20(x,z,k,sigma);
for (i = 0; i < b; i++) c[cpos+i] = m[mpos+i] ^ x[i];
}
return 0;
}
function crypto_stream_salsa20(c,cpos,b,n,k) {
var z = new Uint8Array(16), x = new Uint8Array(64);
var u, i;
for (i = 0; i < 16; i++) z[i] = 0;
for (i = 0; i < 8; i++) z[i] = n[i];
while (b >= 64) {
crypto_core_salsa20(x,z,k,sigma);
for (i = 0; i < 64; i++) c[cpos+i] = x[i];
u = 1;
for (i = 8; i < 16; i++) {
u = u + (z[i] & 0xff) | 0;
z[i] = u & 0xff;
u >>>= 8;
}
b -= 64;
cpos += 64;
}
if (b > 0) {
crypto_core_salsa20(x,z,k,sigma);
for (i = 0; i < b; i++) c[cpos+i] = x[i];
}
return 0;
}
function crypto_stream(c,cpos,d,n,k) {
var s = new Uint8Array(32);
crypto_core_hsalsa20(s,n,k,sigma);
var sn = new Uint8Array(8);
for (var i = 0; i < 8; i++) sn[i] = n[i+16];
return crypto_stream_salsa20(c,cpos,d,sn,s);
}
function crypto_stream_xor(c,cpos,m,mpos,d,n,k) {
var s = new Uint8Array(32);
crypto_core_hsalsa20(s,n,k,sigma);
var sn = new Uint8Array(8);
for (var i = 0; i < 8; i++) sn[i] = n[i+16];
return crypto_stream_salsa20_xor(c,cpos,m,mpos,d,sn,s);
}
/*
* Port of Andrew Moon's Poly1305-donna-16. Public domain.
* https://github.com/floodyberry/poly1305-donna
*/
var poly1305 = function(key) {
this.buffer = new Uint8Array(16);
this.r = new Uint16Array(10);
this.h = new Uint16Array(10);
this.pad = new Uint16Array(8);
this.leftover = 0;
this.fin = 0;
var t0, t1, t2, t3, t4, t5, t6, t7;
t0 = key[ 0] & 0xff | (key[ 1] & 0xff) << 8; this.r[0] = ( t0 ) & 0x1fff;
t1 = key[ 2] & 0xff | (key[ 3] & 0xff) << 8; this.r[1] = ((t0 >>> 13) | (t1 << 3)) & 0x1fff;
t2 = key[ 4] & 0xff | (key[ 5] & 0xff) << 8; this.r[2] = ((t1 >>> 10) | (t2 << 6)) & 0x1f03;
t3 = key[ 6] & 0xff | (key[ 7] & 0xff) << 8; this.r[3] = ((t2 >>> 7) | (t3 << 9)) & 0x1fff;
t4 = key[ 8] & 0xff | (key[ 9] & 0xff) << 8; this.r[4] = ((t3 >>> 4) | (t4 << 12)) & 0x00ff;
this.r[5] = ((t4 >>> 1)) & 0x1ffe;
t5 = key[10] & 0xff | (key[11] & 0xff) << 8; this.r[6] = ((t4 >>> 14) | (t5 << 2)) & 0x1fff;
t6 = key[12] & 0xff | (key[13] & 0xff) << 8; this.r[7] = ((t5 >>> 11) | (t6 << 5)) & 0x1f81;
t7 = key[14] & 0xff | (key[15] & 0xff) << 8; this.r[8] = ((t6 >>> 8) | (t7 << 8)) & 0x1fff;
this.r[9] = ((t7 >>> 5)) & 0x007f;
this.pad[0] = key[16] & 0xff | (key[17] & 0xff) << 8;
this.pad[1] = key[18] & 0xff | (key[19] & 0xff) << 8;
this.pad[2] = key[20] & 0xff | (key[21] & 0xff) << 8;
this.pad[3] = key[22] & 0xff | (key[23] & 0xff) << 8;
this.pad[4] = key[24] & 0xff | (key[25] & 0xff) << 8;
this.pad[5] = key[26] & 0xff | (key[27] & 0xff) << 8;
this.pad[6] = key[28] & 0xff | (key[29] & 0xff) << 8;
this.pad[7] = key[30] & 0xff | (key[31] & 0xff) << 8;
};
poly1305.prototype.blocks = function(m, mpos, bytes) {
var hibit = this.fin ? 0 : (1 << 11);
var t0, t1, t2, t3, t4, t5, t6, t7, c;
var d0, d1, d2, d3, d4, d5, d6, d7, d8, d9;
var h0 = this.h[0],
h1 = this.h[1],
h2 = this.h[2],
h3 = this.h[3],
h4 = this.h[4],
h5 = this.h[5],
h6 = this.h[6],
h7 = this.h[7],
h8 = this.h[8],
h9 = this.h[9];
var r0 = this.r[0],
r1 = this.r[1],
r2 = this.r[2],
r3 = this.r[3],
r4 = this.r[4],
r5 = this.r[5],
r6 = this.r[6],
r7 = this.r[7],
r8 = this.r[8],
r9 = this.r[9];
while (bytes >= 16) {
t0 = m[mpos+ 0] & 0xff | (m[mpos+ 1] & 0xff) << 8; h0 += ( t0 ) & 0x1fff;
t1 = m[mpos+ 2] & 0xff | (m[mpos+ 3] & 0xff) << 8; h1 += ((t0 >>> 13) | (t1 << 3)) & 0x1fff;
t2 = m[mpos+ 4] & 0xff | (m[mpos+ 5] & 0xff) << 8; h2 += ((t1 >>> 10) | (t2 << 6)) & 0x1fff;
t3 = m[mpos+ 6] & 0xff | (m[mpos+ 7] & 0xff) << 8; h3 += ((t2 >>> 7) | (t3 << 9)) & 0x1fff;
t4 = m[mpos+ 8] & 0xff | (m[mpos+ 9] & 0xff) << 8; h4 += ((t3 >>> 4) | (t4 << 12)) & 0x1fff;
h5 += ((t4 >>> 1)) & 0x1fff;
t5 = m[mpos+10] & 0xff | (m[mpos+11] & 0xff) << 8; h6 += ((t4 >>> 14) | (t5 << 2)) & 0x1fff;
t6 = m[mpos+12] & 0xff | (m[mpos+13] & 0xff) << 8; h7 += ((t5 >>> 11) | (t6 << 5)) & 0x1fff;
t7 = m[mpos+14] & 0xff | (m[mpos+15] & 0xff) << 8; h8 += ((t6 >>> 8) | (t7 << 8)) & 0x1fff;
h9 += ((t7 >>> 5)) | hibit;
c = 0;
d0 = c;
d0 += h0 * r0;
d0 += h1 * (5 * r9);
d0 += h2 * (5 * r8);
d0 += h3 * (5 * r7);
d0 += h4 * (5 * r6);
c = (d0 >>> 13); d0 &= 0x1fff;
d0 += h5 * (5 * r5);
d0 += h6 * (5 * r4);
d0 += h7 * (5 * r3);
d0 += h8 * (5 * r2);
d0 += h9 * (5 * r1);
c += (d0 >>> 13); d0 &= 0x1fff;
d1 = c;
d1 += h0 * r1;
d1 += h1 * r0;
d1 += h2 * (5 * r9);
d1 += h3 * (5 * r8);
d1 += h4 * (5 * r7);
c = (d1 >>> 13); d1 &= 0x1fff;
d1 += h5 * (5 * r6);
d1 += h6 * (5 * r5);
d1 += h7 * (5 * r4);
d1 += h8 * (5 * r3);
d1 += h9 * (5 * r2);
c += (d1 >>> 13); d1 &= 0x1fff;
d2 = c;
d2 += h0 * r2;
d2 += h1 * r1;
d2 += h2 * r0;
d2 += h3 * (5 * r9);
d2 += h4 * (5 * r8);
c = (d2 >>> 13); d2 &= 0x1fff;
d2 += h5 * (5 * r7);
d2 += h6 * (5 * r6);
d2 += h7 * (5 * r5);
d2 += h8 * (5 * r4);
d2 += h9 * (5 * r3);
c += (d2 >>> 13); d2 &= 0x1fff;
d3 = c;
d3 += h0 * r3;
d3 += h1 * r2;
d3 += h2 * r1;
d3 += h3 * r0;
d3 += h4 * (5 * r9);
c = (d3 >>> 13); d3 &= 0x1fff;
d3 += h5 * (5 * r8);
d3 += h6 * (5 * r7);
d3 += h7 * (5 * r6);
d3 += h8 * (5 * r5);
d3 += h9 * (5 * r4);
c += (d3 >>> 13); d3 &= 0x1fff;
d4 = c;
d4 += h0 * r4;
d4 += h1 * r3;
d4 += h2 * r2;
d4 += h3 * r1;
d4 += h4 * r0;
c = (d4 >>> 13); d4 &= 0x1fff;
d4 += h5 * (5 * r9);
d4 += h6 * (5 * r8);
d4 += h7 * (5 * r7);
d4 += h8 * (5 * r6);
d4 += h9 * (5 * r5);
c += (d4 >>> 13); d4 &= 0x1fff;
d5 = c;
d5 += h0 * r5;
d5 += h1 * r4;
d5 += h2 * r3;
d5 += h3 * r2;
d5 += h4 * r1;
c = (d5 >>> 13); d5 &= 0x1fff;
d5 += h5 * r0;
d5 += h6 * (5 * r9);
d5 += h7 * (5 * r8);
d5 += h8 * (5 * r7);
d5 += h9 * (5 * r6);
c += (d5 >>> 13); d5 &= 0x1fff;
d6 = c;
d6 += h0 * r6;
d6 += h1 * r5;
d6 += h2 * r4;
d6 += h3 * r3;
d6 += h4 * r2;
c = (d6 >>> 13); d6 &= 0x1fff;
d6 += h5 * r1;
d6 += h6 * r0;
d6 += h7 * (5 * r9);
d6 += h8 * (5 * r8);
d6 += h9 * (5 * r7);
c += (d6 >>> 13); d6 &= 0x1fff;
d7 = c;
d7 += h0 * r7;
d7 += h1 * r6;
d7 += h2 * r5;
d7 += h3 * r4;
d7 += h4 * r3;
c = (d7 >>> 13); d7 &= 0x1fff;
d7 += h5 * r2;
d7 += h6 * r1;
d7 += h7 * r0;
d7 += h8 * (5 * r9);
d7 += h9 * (5 * r8);
c += (d7 >>> 13); d7 &= 0x1fff;
d8 = c;
d8 += h0 * r8;
d8 += h1 * r7;
d8 += h2 * r6;
d8 += h3 * r5;
d8 += h4 * r4;
c = (d8 >>> 13); d8 &= 0x1fff;
d8 += h5 * r3;
d8 += h6 * r2;
d8 += h7 * r1;
d8 += h8 * r0;
d8 += h9 * (5 * r9);
c += (d8 >>> 13); d8 &= 0x1fff;
d9 = c;
d9 += h0 * r9;
d9 += h1 * r8;
d9 += h2 * r7;
d9 += h3 * r6;
d9 += h4 * r5;
c = (d9 >>> 13); d9 &= 0x1fff;
d9 += h5 * r4;
d9 += h6 * r3;
d9 += h7 * r2;
d9 += h8 * r1;
d9 += h9 * r0;
c += (d9 >>> 13); d9 &= 0x1fff;
c = (((c << 2) + c)) | 0;
c = (c + d0) | 0;
d0 = c & 0x1fff;
c = (c >>> 13);
d1 += c;
h0 = d0;
h1 = d1;
h2 = d2;
h3 = d3;
h4 = d4;
h5 = d5;
h6 = d6;
h7 = d7;
h8 = d8;
h9 = d9;
mpos += 16;
bytes -= 16;
}
this.h[0] = h0;
this.h[1] = h1;
this.h[2] = h2;
this.h[3] = h3;
this.h[4] = h4;
this.h[5] = h5;
this.h[6] = h6;
this.h[7] = h7;
this.h[8] = h8;
this.h[9] = h9;
};
poly1305.prototype.finish = function(mac, macpos) {
var g = new Uint16Array(10);
var c, mask, f, i;
if (this.leftover) {
i = this.leftover;
this.buffer[i++] = 1;
for (; i < 16; i++) this.buffer[i] = 0;
this.fin = 1;
this.blocks(this.buffer, 0, 16);
}
c = this.h[1] >>> 13;
this.h[1] &= 0x1fff;
for (i = 2; i < 10; i++) {
this.h[i] += c;
c = this.h[i] >>> 13;
this.h[i] &= 0x1fff;
}
this.h[0] += (c * 5);
c = this.h[0] >>> 13;
this.h[0] &= 0x1fff;
this.h[1] += c;
c = this.h[1] >>> 13;
this.h[1] &= 0x1fff;
this.h[2] += c;
g[0] = this.h[0] + 5;
c = g[0] >>> 13;
g[0] &= 0x1fff;
for (i = 1; i < 10; i++) {
g[i] = this.h[i] + c;
c = g[i] >>> 13;
g[i] &= 0x1fff;
}
g[9] -= (1 << 13);
mask = (c ^ 1) - 1;
for (i = 0; i < 10; i++) g[i] &= mask;
mask = ~mask;
for (i = 0; i < 10; i++) this.h[i] = (this.h[i] & mask) | g[i];
this.h[0] = ((this.h[0] ) | (this.h[1] << 13) ) & 0xffff;
this.h[1] = ((this.h[1] >>> 3) | (this.h[2] << 10) ) & 0xffff;
this.h[2] = ((this.h[2] >>> 6) | (this.h[3] << 7) ) & 0xffff;
this.h[3] = ((this.h[3] >>> 9) | (this.h[4] << 4) ) & 0xffff;
this.h[4] = ((this.h[4] >>> 12) | (this.h[5] << 1) | (this.h[6] << 14)) & 0xffff;
this.h[5] = ((this.h[6] >>> 2) | (this.h[7] << 11) ) & 0xffff;
this.h[6] = ((this.h[7] >>> 5) | (this.h[8] << 8) ) & 0xffff;
this.h[7] = ((this.h[8] >>> 8) | (this.h[9] << 5) ) & 0xffff;
f = this.h[0] + this.pad[0];
this.h[0] = f & 0xffff;
for (i = 1; i < 8; i++) {
f = (((this.h[i] + this.pad[i]) | 0) + (f >>> 16)) | 0;
this.h[i] = f & 0xffff;
}
mac[macpos+ 0] = (this.h[0] >>> 0) & 0xff;
mac[macpos+ 1] = (this.h[0] >>> 8) & 0xff;
mac[macpos+ 2] = (this.h[1] >>> 0) & 0xff;
mac[macpos+ 3] = (this.h[1] >>> 8) & 0xff;
mac[macpos+ 4] = (this.h[2] >>> 0) & 0xff;
mac[macpos+ 5] = (this.h[2] >>> 8) & 0xff;
mac[macpos+ 6] = (this.h[3] >>> 0) & 0xff;
mac[macpos+ 7] = (this.h[3] >>> 8) & 0xff;
mac[macpos+ 8] = (this.h[4] >>> 0) & 0xff;
mac[macpos+ 9] = (this.h[4] >>> 8) & 0xff;
mac[macpos+10] = (this.h[5] >>> 0) & 0xff;
mac[macpos+11] = (this.h[5] >>> 8) & 0xff;
mac[macpos+12] = (this.h[6] >>> 0) & 0xff;
mac[macpos+13] = (this.h[6] >>> 8) & 0xff;
mac[macpos+14] = (this.h[7] >>> 0) & 0xff;
mac[macpos+15] = (this.h[7] >>> 8) & 0xff;
};
poly1305.prototype.update = function(m, mpos, bytes) {
var i, want;
if (this.leftover) {
want = (16 - this.leftover);
if (want > bytes)
want = bytes;
for (i = 0; i < want; i++)
this.buffer[this.leftover + i] = m[mpos+i];
bytes -= want;
mpos += want;
this.leftover += want;
if (this.leftover < 16)
return;
this.blocks(this.buffer, 0, 16);
this.leftover = 0;
}
if (bytes >= 16) {
want = bytes - (bytes % 16);
this.blocks(m, mpos, want);
mpos += want;
bytes -= want;
}
if (bytes) {
for (i = 0; i < bytes; i++)
this.buffer[this.leftover + i] = m[mpos+i];
this.leftover += bytes;
}
};
function crypto_onetimeauth(out, outpos, m, mpos, n, k) {
var s = new poly1305(k);
s.update(m, mpos, n);
s.finish(out, outpos);
return 0;
}
function crypto_onetimeauth_verify(h, hpos, m, mpos, n, k) {
var x = new Uint8Array(16);
crypto_onetimeauth(x,0,m,mpos,n,k);
return crypto_verify_16(h,hpos,x,0);
}
function crypto_secretbox(c,m,d,n,k) {
var i;
if (d < 32) return -1;
crypto_stream_xor(c,0,m,0,d,n,k);
crypto_onetimeauth(c, 16, c, 32, d - 32, c);
for (i = 0; i < 16; i++) c[i] = 0;
return 0;
}
function crypto_secretbox_open(m,c,d,n,k) {
var i;
var x = new Uint8Array(32);
if (d < 32) return -1;
crypto_stream(x,0,32,n,k);
if (crypto_onetimeauth_verify(c, 16,c, 32,d - 32,x) !== 0) return -1;
crypto_stream_xor(m,0,c,0,d,n,k);
for (i = 0; i < 32; i++) m[i] = 0;
return 0;
}
function set25519(r, a) {
var i;
for (i = 0; i < 16; i++) r[i] = a[i]|0;
}
function car25519(o) {
var i, v, c = 1;
for (i = 0; i < 16; i++) {
v = o[i] + c + 65535;
c = Math.floor(v / 65536);
o[i] = v - c * 65536;
}
o[0] += c-1 + 37 * (c-1);
}
function sel25519(p, q, b) {
var t, c = ~(b-1);
for (var i = 0; i < 16; i++) {
t = c & (p[i] ^ q[i]);
p[i] ^= t;
q[i] ^= t;
}
}
function pack25519(o, n) {
var i, j, b;
var m = gf(), t = gf();
for (i = 0; i < 16; i++) t[i] = n[i];
car25519(t);
car25519(t);
car25519(t);
for (j = 0; j < 2; j++) {
m[0] = t[0] - 0xffed;
for (i = 1; i < 15; i++) {
m[i] = t[i] - 0xffff - ((m[i-1]>>16) & 1);
m[i-1] &= 0xffff;
}
m[15] = t[15] - 0x7fff - ((m[14]>>16) & 1);
b = (m[15]>>16) & 1;
m[14] &= 0xffff;
sel25519(t, m, 1-b);
}
for (i = 0; i < 16; i++) {
o[2*i] = t[i] & 0xff;
o[2*i+1] = t[i]>>8;
}
}
function neq25519(a, b) {
var c = new Uint8Array(32), d = new Uint8Array(32);
pack25519(c, a);
pack25519(d, b);
return crypto_verify_32(c, 0, d, 0);
}
function par25519(a) {
var d = new Uint8Array(32);
pack25519(d, a);
return d[0] & 1;
}
function unpack25519(o, n) {
var i;
for (i = 0; i < 16; i++) o[i] = n[2*i] + (n[2*i+1] << 8);
o[15] &= 0x7fff;
}
function A(o, a, b) {
for (var i = 0; i < 16; i++) o[i] = a[i] + b[i];
}
function Z(o, a, b) {
for (var i = 0; i < 16; i++) o[i] = a[i] - b[i];
}
function M(o, a, b) {
var v, c,
t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0, t7 = 0,
t8 = 0, t9 = 0, t10 = 0, t11 = 0, t12 = 0, t13 = 0, t14 = 0, t15 = 0,
t16 = 0, t17 = 0, t18 = 0, t19 = 0, t20 = 0, t21 = 0, t22 = 0, t23 = 0,
t24 = 0, t25 = 0, t26 = 0, t27 = 0, t28 = 0, t29 = 0, t30 = 0,
b0 = b[0],
b1 = b[1],
b2 = b[2],
b3 = b[3],
b4 = b[4],
b5 = b[5],
b6 = b[6],
b7 = b[7],
b8 = b[8],
b9 = b[9],
b10 = b[10],
b11 = b[11],
b12 = b[12],
b13 = b[13],
b14 = b[14],
b15 = b[15];
v = a[0];
t0 += v * b0;
t1 += v * b1;
t2 += v * b2;
t3 += v * b3;
t4 += v * b4;
t5 += v * b5;
t6 += v * b6;
t7 += v * b7;
t8 += v * b8;
t9 += v * b9;
t10 += v * b10;
t11 += v * b11;
t12 += v * b12;
t13 += v * b13;
t14 += v * b14;
t15 += v * b15;
v = a[1];
t1 += v * b0;
t2 += v * b1;
t3 += v * b2;
t4 += v * b3;
t5 += v * b4;
t6 += v * b5;
t7 += v * b6;
t8 += v * b7;
t9 += v * b8;
t10 += v * b9;
t11 += v * b10;
t12 += v * b11;
t13 += v * b12;
t14 += v * b13;
t15 += v * b14;
t16 += v * b15;
v = a[2];
t2 += v * b0;
t3 += v * b1;
t4 += v * b2;
t5 += v * b3;
t6 += v * b4;
t7 += v * b5;
t8 += v * b6;
t9 += v * b7;
t10 += v * b8;
t11 += v * b9;
t12 += v * b10;
t13 += v * b11;
t14 += v * b12;
t15 += v * b13;
t16 += v * b14;
t17 += v * b15;
v = a[3];
t3 += v * b0;
t4 += v * b1;
t5 += v * b2;
t6 += v * b3;
t7 += v * b4;
t8 += v * b5;
t9 += v * b6;
t10 += v * b7;
t11 += v * b8;
t12 += v * b9;
t13 += v * b10;
t14 += v * b11;
t15 += v * b12;
t16 += v * b13;
t17 += v * b14;
t18 += v * b15;
v = a[4];
t4 += v * b0;
t5 += v * b1;
t6 += v * b2;
t7 += v * b3;
t8 += v * b4;
t9 += v * b5;
t10 += v * b6;
t11 += v * b7;
t12 += v * b8;
t13 += v * b9;
t14 += v * b10;
t15 += v * b11;
t16 += v * b12;
t17 += v * b13;
t18 += v * b14;
t19 += v * b15;
v = a[5];
t5 += v * b0;
t6 += v * b1;
t7 += v * b2;
t8 += v * b3;
t9 += v * b4;
t10 += v * b5;
t11 += v * b6;
t12 += v * b7;
t13 += v * b8;
t14 += v * b9;
t15 += v * b10;
t16 += v * b11;
t17 += v * b12;
t18 += v * b13;
t19 += v * b14;
t20 += v * b15;
v = a[6];
t6 += v * b0;
t7 += v * b1;
t8 += v * b2;
t9 += v * b3;
t10 += v * b4;
t11 += v * b5;
t12 += v * b6;
t13 += v * b7;
t14 += v * b8;
t15 += v * b9;
t16 += v * b10;
t17 += v * b11;
t18 += v * b12;
t19 += v * b13;
t20 += v * b14;
t21 += v * b15;
v = a[7];
t7 += v * b0;
t8 += v * b1;
t9 += v * b2;
t10 += v * b3;
t11 += v * b4;
t12 += v * b5;
t13 += v * b6;
t14 += v * b7;
t15 += v * b8;
t16 += v * b9;
t17 += v * b10;
t18 += v * b11;
t19 += v * b12;
t20 += v * b13;
t21 += v * b14;
t22 += v * b15;
v = a[8];
t8 += v * b0;
t9 += v * b1;
t10 += v * b2;
t11 += v * b3;
t12 += v * b4;
t13 += v * b5;
t14 += v * b6;
t15 += v * b7;
t16 += v * b8;
t17 += v * b9;
t18 += v * b10;
t19 += v * b11;
t20 += v * b12;
t21 += v * b13;
t22 += v * b14;
t23 += v * b15;
v = a[9];
t9 += v * b0;
t10 += v * b1;
t11 += v * b2;
t12 += v * b3;
t13 += v * b4;
t14 += v * b5;
t15 += v * b6;
t16 += v * b7;
t17 += v * b8;
t18 += v * b9;
t19 += v * b10;
t20 += v * b11;
t21 += v * b12;
t22 += v * b13;
t23 += v * b14;
t24 += v * b15;
v = a[10];
t10 += v * b0;
t11 += v * b1;
t12 += v * b2;
t13 += v * b3;
t14 += v * b4;
t15 += v * b5;
t16 += v * b6;
t17 += v * b7;
t18 += v * b8;
t19 += v * b9;
t20 += v * b10;
t21 += v * b11;
t22 += v * b12;
t23 += v * b13;
t24 += v * b14;
t25 += v * b15;
v = a[11];
t11 += v * b0;
t12 += v * b1;
t13 += v * b2;
t14 += v * b3;
t15 += v * b4;
t16 += v * b5;
t17 += v * b6;
t18 += v * b7;
t19 += v * b8;
t20 += v * b9;
t21 += v * b10;
t22 += v * b11;
t23 += v * b12;
t24 += v * b13;
t25 += v * b14;
t26 += v * b15;
v = a[12];
t12 += v * b0;
t13 += v * b1;
t14 += v * b2;
t15 += v * b3;
t16 += v * b4;
t17 += v * b5;
t18 += v * b6;
t19 += v * b7;
t20 += v * b8;
t21 += v * b9;
t22 += v * b10;
t23 += v * b11;
t24 += v * b12;
t25 += v * b13;
t26 += v * b14;
t27 += v * b15;
v = a[13];
t13 += v * b0;
t14 += v * b1;
t15 += v * b2;
t16 += v * b3;
t17 += v * b4;
t18 += v * b5;
t19 += v * b6;
t20 += v * b7;
t21 += v * b8;
t22 += v * b9;
t23 += v * b10;
t24 += v * b11;
t25 += v * b12;
t26 += v * b13;
t27 += v * b14;
t28 += v * b15;
v = a[14];
t14 += v * b0;
t15 += v * b1;
t16 += v * b2;
t17 += v * b3;
t18 += v * b4;
t19 += v * b5;
t20 += v * b6;
t21 += v * b7;
t22 += v * b8;
t23 += v * b9;
t24 += v * b10;
t25 += v * b11;
t26 += v * b12;
t27 += v * b13;
t28 += v * b14;
t29 += v * b15;
v = a[15];
t15 += v * b0;
t16 += v * b1;
t17 += v * b2;
t18 += v * b3;
t19 += v * b4;
t20 += v * b5;
t21 += v * b6;
t22 += v * b7;
t23 += v * b8;
t24 += v * b9;
t25 += v * b10;
t26 += v * b11;
t27 += v * b12;
t28 += v * b13;
t29 += v * b14;
t30 += v * b15;
t0 += 38 * t16;
t1 += 38 * t17;
t2 += 38 * t18;
t3 += 38 * t19;
t4 += 38 * t20;
t5 += 38 * t21;
t6 += 38 * t22;
t7 += 38 * t23;
t8 += 38 * t24;
t9 += 38 * t25;
t10 += 38 * t26;
t11 += 38 * t27;
t12 += 38 * t28;
t13 += 38 * t29;
t14 += 38 * t30;
// t15 left as is
// first car
c = 1;
v = t0 + c + 65535; c = Math.floor(v / 65536); t0 = v - c * 65536;
v = t1 + c + 65535; c = Math.floor(v / 65536); t1 = v - c * 65536;
v = t2 + c + 65535; c = Math.floor(v / 65536); t2 = v - c * 65536;
v = t3 + c + 65535; c = Math.floor(v / 65536); t3 = v - c * 65536;
v = t4 + c + 65535; c = Math.floor(v / 65536); t4 = v - c * 65536;
v = t5 + c + 65535; c = Math.floor(v / 65536); t5 = v - c * 65536;
v = t6 + c + 65535; c = Math.floor(v / 65536); t6 = v - c * 65536;
v = t7 + c + 65535; c = Math.floor(v / 65536); t7 = v - c * 65536;
v = t8 + c + 65535; c = Math.floor(v / 65536); t8 = v - c * 65536;
v = t9 + c + 65535; c = Math.floor(v / 65536); t9 = v - c * 65536;
v = t10 + c + 65535; c = Math.floor(v / 65536); t10 = v - c * 65536;
v = t11 + c + 65535; c = Math.floor(v / 65536); t11 = v - c * 65536;
v = t12 + c + 65535; c = Math.floor(v / 65536); t12 = v - c * 65536;
v = t13 + c + 65535; c = Math.floor(v / 65536); t13 = v - c * 65536;
v = t14 + c + 65535; c = Math.floor(v / 65536); t14 = v - c * 65536;
v = t15 + c + 65535; c = Math.floor(v / 65536); t15 = v - c * 65536;
t0 += c-1 + 37 * (c-1);
// second car
c = 1;
v = t0 + c + 65535; c = Math.floor(v / 65536); t0 = v - c * 65536;
v = t1 + c + 65535; c = Math.floor(v / 65536); t1 = v - c * 65536;
v = t2 + c + 65535; c = Math.floor(v / 65536); t2 = v - c * 65536;
v = t3 + c + 65535; c = Math.floor(v / 65536); t3 = v - c * 65536;
v = t4 + c + 65535; c = Math.floor(v / 65536); t4 = v - c * 65536;
v = t5 + c + 65535; c = Math.floor(v / 65536); t5 = v - c * 65536;
v = t6 + c + 65535; c = Math.floor(v / 65536); t6 = v - c * 65536;
v = t7 + c + 65535; c = Math.floor(v / 65536); t7 = v - c * 65536;
v = t8 + c + 65535; c = Math.floor(v / 65536); t8 = v - c * 65536;
v = t9 + c + 65535; c = Math.floor(v / 65536); t9 = v - c * 65536;
v = t10 + c + 65535; c = Math.floor(v / 65536); t10 = v - c * 65536;
v = t11 + c + 65535; c = Math.floor(v / 65536); t11 = v - c * 65536;
v = t12 + c + 65535; c = Math.floor(v / 65536); t12 = v - c * 65536;
v = t13 + c + 65535; c = Math.floor(v / 65536); t13 = v - c * 65536;
v = t14 + c + 65535; c = Math.floor(v / 65536); t14 = v - c * 65536;
v = t15 + c + 65535; c = Math.floor(v / 65536); t15 = v - c * 65536;
t0 += c-1 + 37 * (c-1);
o[ 0] = t0;
o[ 1] = t1;
o[ 2] = t2;
o[ 3] = t3;
o[ 4] = t4;
o[ 5] = t5;
o[ 6] = t6;
o[ 7] = t7;
o[ 8] = t8;
o[ 9] = t9;
o[10] = t10;
o[11] = t11;
o[12] = t12;
o[13] = t13;
o[14] = t14;
o[15] = t15;
}
function S(o, a) {
M(o, a, a);
}
function inv25519(o, i) {
var c = gf();
var a;
for (a = 0; a < 16; a++) c[a] = i[a];
for (a = 253; a >= 0; a--) {
S(c, c);
if(a !== 2 && a !== 4) M(c, c, i);
}
for (a = 0; a < 16; a++) o[a] = c[a];
}
function pow2523(o, i) {
var c = gf();
var a;
for (a = 0; a < 16; a++) c[a] = i[a];
for (a = 250; a >= 0; a--) {
S(c, c);
if(a !== 1) M(c, c, i);
}
for (a = 0; a < 16; a++) o[a] = c[a];
}
function crypto_scalarmult(q, n, p) {
var z = new Uint8Array(32);
var x = new Float64Array(80), r, i;
var a = gf(), b = gf(), c = gf(),
d = gf(), e = gf(), f = gf();
for (i = 0; i < 31; i++) z[i] = n[i];
z[31]=(n[31]&127)|64;
z[0]&=248;
unpack25519(x,p);
for (i = 0; i < 16; i++) {
b[i]=x[i];
d[i]=a[i]=c[i]=0;
}
a[0]=d[0]=1;
for (i=254; i>=0; --i) {
r=(z[i>>>3]>>>(i&7))&1;
sel25519(a,b,r);
sel25519(c,d,r);
A(e,a,c);
Z(a,a,c);
A(c,b,d);
Z(b,b,d);
S(d,e);
S(f,a);
M(a,c,a);
M(c,b,e);
A(e,a,c);
Z(a,a,c);
S(b,a);
Z(c,d,f);
M(a,c,_121665);
A(a,a,d);
M(c,c,a);
M(a,d,f);
M(d,b,x);
S(b,e);
sel25519(a,b,r);
sel25519(c,d,r);
}
for (i = 0; i < 16; i++) {
x[i+16]=a[i];
x[i+32]=c[i];
x[i+48]=b[i];
x[i+64]=d[i];
}
var x32 = x.subarray(32);
var x16 = x.subarray(16);
inv25519(x32,x32);
M(x16,x16,x32);
pack25519(q,x16);
return 0;
}
function crypto_scalarmult_base(q, n) {
return crypto_scalarmult(q, n, _9);
}
function crypto_box_keypair(y, x) {
randombytes(x, 32);
return crypto_scalarmult_base(y, x);
}
function crypto_box_beforenm(k, y, x) {
var s = new Uint8Array(32);
crypto_scalarmult(s, x, y);
return crypto_core_hsalsa20(k, _0, s, sigma);
}
var crypto_box_afternm = crypto_secretbox;
var crypto_box_open_afternm = crypto_secretbox_open;
function crypto_box(c, m, d, n, y, x) {
var k = new Uint8Array(32);
crypto_box_beforenm(k, y, x);
return crypto_box_afternm(c, m, d, n, k);
}
function crypto_box_open(m, c, d, n, y, x) {
var k = new Uint8Array(32);
crypto_box_beforenm(k, y, x);
return crypto_box_open_afternm(m, c, d, n, k);
}
function crypto_hash(out, m, n) {
var input = new Uint8Array(n), i;
for (i = 0; i < n; ++i) {
input[i] = m[i];
}
var hash = blake2b.blake2b(input);
for (i = 0; i < crypto_hash_BYTES; ++i) {
out[i] = hash[i];
}
return 0;
}
function add(p, q) {
var a = gf(), b = gf(), c = gf(),
d = gf(), e = gf(), f = gf(),
g = gf(), h = gf(), t = gf();
Z(a, p[1], p[0]);
Z(t, q[1], q[0]);
M(a, a, t);
A(b, p[0], p[1]);
A(t, q[0], q[1]);
M(b, b, t);
M(c, p[3], q[3]);
M(c, c, D2);
M(d, p[2], q[2]);
A(d, d, d);
Z(e, b, a);
Z(f, d, c);
A(g, d, c);
A(h, b, a);
M(p[0], e, f);
M(p[1], h, g);
M(p[2], g, f);
M(p[3], e, h);
}
function cswap(p, q, b) {
var i;
for (i = 0; i < 4; i++) {
sel25519(p[i], q[i], b);
}
}
function pack(r, p) {
var tx = gf(), ty = gf(), zi = gf();
inv25519(zi, p[2]);
M(tx, p[0], zi);
M(ty, p[1], zi);
pack25519(r, ty);
r[31] ^= par25519(tx) << 7;
}
function scalarmult(p, q, s) {
var b, i;
set25519(p[0], gf0);
set25519(p[1], gf1);
set25519(p[2], gf1);
set25519(p[3], gf0);
for (i = 255; i >= 0; --i) {
b = (s[(i/8)|0] >> (i&7)) & 1;
cswap(p, q, b);
add(q, p);
add(p, p);
cswap(p, q, b);
}
}
function scalarbase(p, s) {
var q = [gf(), gf(), gf(), gf()];
set25519(q[0], X);
set25519(q[1], Y);
set25519(q[2], gf1);
M(q[3], X, Y);
scalarmult(p, q, s);
}
function crypto_sign_keypair(pk, sk, seeded) {
var d = new Uint8Array(64);
var p = [gf(), gf(), gf(), gf()];
var i;
if (!seeded) randombytes(sk, 32);
crypto_hash(d, sk, 32);
d[0] &= 248;
d[31] &= 127;
d[31] |= 64;
scalarbase(p, d);
pack(pk, p);
for (i = 0; i < 32; i++) sk[i+32] = pk[i];
return 0;
}
var L = new Float64Array([0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x10]);
function modL(r, x) {
var carry, i, j, k;
for (i = 63; i >= 32; --i) {
carry = 0;
for (j = i - 32, k = i - 12; j < k; ++j) {
x[j] += carry - 16 * x[i] * L[j - (i - 32)];
carry = (x[j] + 128) >> 8;
x[j] -= carry * 256;
}
x[j] += carry;
x[i] = 0;
}
carry = 0;
for (j = 0; j < 32; j++) {
x[j] += carry - (x[31] >> 4) * L[j];
carry = x[j] >> 8;
x[j] &= 255;
}
for (j = 0; j < 32; j++) x[j] -= carry * L[j];
for (i = 0; i < 32; i++) {
x[i+1] += x[i] >> 8;
r[i] = x[i] & 255;
}
}
function reduce(r) {
var x = new Float64Array(64), i;
for (i = 0; i < 64; i++) x[i] = r[i];
for (i = 0; i < 64; i++) r[i] = 0;
modL(r, x);
}
// Note: difference from C - smlen returned, not passed as argument.
function crypto_sign(sm, m, n, sk) {
var d = new Uint8Array(64), h = new Uint8Array(64), r = new Uint8Array(64);
var i, j, x = new Float64Array(64);
var p = [gf(), gf(), gf(), gf()];
crypto_hash(d, sk, 32);
d[0] &= 248;
d[31] &= 127;
d[31] |= 64;
var smlen = n + 64;
for (i = 0; i < n; i++) sm[64 + i] = m[i];
for (i = 0; i < 32; i++) sm[32 + i] = d[32 + i];
crypto_hash(r, sm.subarray(32), n+32);
reduce(r);
scalarbase(p, r);
pack(sm, p);
for (i = 32; i < 64; i++) sm[i] = sk[i];
crypto_hash(h, sm, n + 64);
reduce(h);
for (i = 0; i < 64; i++) x[i] = 0;
for (i = 0; i < 32; i++) x[i] = r[i];
for (i = 0; i < 32; i++) {
for (j = 0; j < 32; j++) {
x[i+j] += h[i] * d[j];
}
}
modL(sm.subarray(32), x);
return smlen;
}
function unpackneg(r, p) {
var t = gf(), chk = gf(), num = gf(),
den = gf(), den2 = gf(), den4 = gf(),
den6 = gf();
set25519(r[2], gf1);
unpack25519(r[1], p);
S(num, r[1]);
M(den, num, D);
Z(num, num, r[2]);
A(den, r[2], den);
S(den2, den);
S(den4, den2);
M(den6, den4, den2);
M(t, den6, num);
M(t, t, den);
pow2523(t, t);
M(t, t, num);
M(t, t, den);
M(t, t, den);
M(r[0], t, den);
S(chk, r[0]);
M(chk, chk, den);
if (neq25519(chk, num)) M(r[0], r[0], I);
S(chk, r[0]);
M(chk, chk, den);
if (neq25519(chk, num)) return -1;
if (par25519(r[0]) === (p[31]>>7)) Z(r[0], gf0, r[0]);
M(r[3], r[0], r[1]);
return 0;
}
function crypto_sign_open(m, sm, n, pk) {
var i, mlen;
var t = new Uint8Array(32), h = new Uint8Array(64);
var p = [gf(), gf(), gf(), gf()],
q = [gf(), gf(), gf(), gf()];
mlen = -1;
if (n < 64) return -1;
if (unpackneg(q, pk)) return -1;
for (i = 0; i < n; i++) m[i] = sm[i];
for (i = 0; i < 32; i++) m[i+32] = pk[i];
crypto_hash(h, m, n);
reduce(h);
scalarmult(p, q, h);
scalarbase(q, sm.subarray(32));
add(p, q);
pack(t, p);
n -= 64;
if (crypto_verify_32(sm, 0, t, 0)) {
for (i = 0; i < n; i++) m[i] = 0;
return -1;
}
for (i = 0; i < n; i++) m[i] = sm[i + 64];
mlen = n;
return mlen;
}
var crypto_secretbox_KEYBYTES = 32,
crypto_secretbox_NONCEBYTES = 24,
crypto_secretbox_ZEROBYTES = 32,
crypto_secretbox_BOXZEROBYTES = 16,
crypto_scalarmult_BYTES = 32,
crypto_scalarmult_SCALARBYTES = 32,
crypto_box_PUBLICKEYBYTES = 32,
crypto_box_SECRETKEYBYTES = 32,
crypto_box_BEFORENMBYTES = 32,
crypto_box_NONCEBYTES = crypto_secretbox_NONCEBYTES,
crypto_box_ZEROBYTES = crypto_secretbox_ZEROBYTES,
crypto_box_BOXZEROBYTES = crypto_secretbox_BOXZEROBYTES,
crypto_sign_BYTES = 64,
crypto_sign_PUBLICKEYBYTES = 32,
crypto_sign_SECRETKEYBYTES = 64,
crypto_sign_SEEDBYTES = 32,
crypto_hash_BYTES = 64;
nacl.lowlevel = {
crypto_core_hsalsa20: crypto_core_hsalsa20,
crypto_stream_xor: crypto_stream_xor,
crypto_stream: crypto_stream,
crypto_stream_salsa20_xor: crypto_stream_salsa20_xor,
crypto_stream_salsa20: crypto_stream_salsa20,
crypto_onetimeauth: crypto_onetimeauth,
crypto_onetimeauth_verify: crypto_onetimeauth_verify,
crypto_verify_16: crypto_verify_16,
crypto_verify_32: crypto_verify_32,
crypto_secretbox: crypto_secretbox,
crypto_secretbox_open: crypto_secretbox_open,
crypto_scalarmult: crypto_scalarmult,
crypto_scalarmult_base: crypto_scalarmult_base,
crypto_box_beforenm: crypto_box_beforenm,
crypto_box_afternm: crypto_box_afternm,
crypto_box: crypto_box,
crypto_box_open: crypto_box_open,
crypto_box_keypair: crypto_box_keypair,
crypto_hash: crypto_hash,
crypto_sign: crypto_sign,
crypto_sign_keypair: crypto_sign_keypair,
crypto_sign_open: crypto_sign_open,
crypto_secretbox_KEYBYTES: crypto_secretbox_KEYBYTES,
crypto_secretbox_NONCEBYTES: crypto_secretbox_NONCEBYTES,
crypto_secretbox_ZEROBYTES: crypto_secretbox_ZEROBYTES,
crypto_secretbox_BOXZEROBYTES: crypto_secretbox_BOXZEROBYTES,
crypto_scalarmult_BYTES: crypto_scalarmult_BYTES,
crypto_scalarmult_SCALARBYTES: crypto_scalarmult_SCALARBYTES,
crypto_box_PUBLICKEYBYTES: crypto_box_PUBLICKEYBYTES,
crypto_box_SECRETKEYBYTES: crypto_box_SECRETKEYBYTES,
crypto_box_BEFORENMBYTES: crypto_box_BEFORENMBYTES,
crypto_box_NONCEBYTES: crypto_box_NONCEBYTES,
crypto_box_ZEROBYTES: crypto_box_ZEROBYTES,
crypto_box_BOXZEROBYTES: crypto_box_BOXZEROBYTES,
crypto_sign_BYTES: crypto_sign_BYTES,
crypto_sign_PUBLICKEYBYTES: crypto_sign_PUBLICKEYBYTES,
crypto_sign_SECRETKEYBYTES: crypto_sign_SECRETKEYBYTES,
crypto_sign_SEEDBYTES: crypto_sign_SEEDBYTES,
crypto_hash_BYTES: crypto_hash_BYTES
};
/* High-level API */
function checkLengths(k, n) {
if (k.length !== crypto_secretbox_KEYBYTES) throw new Error('bad key size');
if (n.length !== crypto_secretbox_NONCEBYTES) throw new Error('bad nonce size');
}
function checkBoxLengths(pk, sk) {
if (pk.length !== crypto_box_PUBLICKEYBYTES) throw new Error('bad public key size');
if (sk.length !== crypto_box_SECRETKEYBYTES) throw new Error('bad secret key size');
}
function checkArrayTypes() {
for (var i = 0; i < arguments.length; i++) {
if (!(arguments[i] instanceof Uint8Array))
throw new TypeError('unexpected type, use Uint8Array');
}
}
function cleanup(arr) {
for (var i = 0; i < arr.length; i++) arr[i] = 0;
}
nacl.randomBytes = function(n) {
var b = new Uint8Array(n);
randombytes(b, n);
return b;
};
nacl.secretbox = function(msg, nonce, key) {
checkArrayTypes(msg, nonce, key);
checkLengths(key, nonce);
var m = new Uint8Array(crypto_secretbox_ZEROBYTES + msg.length);
var c = new Uint8Array(m.length);
for (var i = 0; i < msg.length; i++) m[i+crypto_secretbox_ZEROBYTES] = msg[i];
crypto_secretbox(c, m, m.length, nonce, key);
return c.subarray(crypto_secretbox_BOXZEROBYTES);
};
nacl.secretbox.open = function(box, nonce, key) {
checkArrayTypes(box, nonce, key);
checkLengths(key, nonce);
var c = new Uint8Array(crypto_secretbox_BOXZEROBYTES + box.length);
var m = new Uint8Array(c.length);
for (var i = 0; i < box.length; i++) c[i+crypto_secretbox_BOXZEROBYTES] = box[i];
if (c.length < 32) return null;
if (crypto_secretbox_open(m, c, c.length, nonce, key) !== 0) return null;
return m.subarray(crypto_secretbox_ZEROBYTES);
};
nacl.secretbox.keyLength = crypto_secretbox_KEYBYTES;
nacl.secretbox.nonceLength = crypto_secretbox_NONCEBYTES;
nacl.secretbox.overheadLength = crypto_secretbox_BOXZEROBYTES;
nacl.scalarMult = function(n, p) {
checkArrayTypes(n, p);
if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error('bad n size');
if (p.length !== crypto_scalarmult_BYTES) throw new Error('bad p size');
var q = new Uint8Array(crypto_scalarmult_BYTES);
crypto_scalarmult(q, n, p);
return q;
};
nacl.scalarMult.base = function(n) {
checkArrayTypes(n);
if (n.length !== crypto_scalarmult_SCALARBYTES) throw new Error('bad n size');
var q = new Uint8Array(crypto_scalarmult_BYTES);
crypto_scalarmult_base(q, n);
return q;
};
nacl.scalarMult.scalarLength = crypto_scalarmult_SCALARBYTES;
nacl.scalarMult.groupElementLength = crypto_scalarmult_BYTES;
nacl.box = function(msg, nonce, publicKey, secretKey) {
var k = nacl.box.before(publicKey, secretKey);
return nacl.secretbox(msg, nonce, k);
};
nacl.box.before = function(publicKey, secretKey) {
checkArrayTypes(publicKey, secretKey);
checkBoxLengths(publicKey, secretKey);
var k = new Uint8Array(crypto_box_BEFORENMBYTES);
crypto_box_beforenm(k, publicKey, secretKey);
return k;
};
nacl.box.after = nacl.secretbox;
nacl.box.open = function(msg, nonce, publicKey, secretKey) {
var k = nacl.box.before(publicKey, secretKey);
return nacl.secretbox.open(msg, nonce, k);
};
nacl.box.open.after = nacl.secretbox.open;
nacl.box.keyPair = function() {
var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES);
var sk = new Uint8Array(crypto_box_SECRETKEYBYTES);
crypto_box_keypair(pk, sk);
return {publicKey: pk, secretKey: sk};
};
nacl.box.keyPair.fromSecretKey = function(secretKey) {
checkArrayTypes(secretKey);
if (secretKey.length !== crypto_box_SECRETKEYBYTES)
throw new Error('bad secret key size');
var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES);
crypto_scalarmult_base(pk, secretKey);
return {publicKey: pk, secretKey: new Uint8Array(secretKey)};
};
nacl.box.publicKeyLength = crypto_box_PUBLICKEYBYTES;
nacl.box.secretKeyLength = crypto_box_SECRETKEYBYTES;
nacl.box.sharedKeyLength = crypto_box_BEFORENMBYTES;
nacl.box.nonceLength = crypto_box_NONCEBYTES;
nacl.box.overheadLength = nacl.secretbox.overheadLength;
nacl.sign = function(msg, secretKey) {
checkArrayTypes(msg, secretKey);
if (secretKey.length !== crypto_sign_SECRETKEYBYTES)
throw new Error('bad secret key size');
var signedMsg = new Uint8Array(crypto_sign_BYTES+msg.length);
crypto_sign(signedMsg, msg, msg.length, secretKey);
return signedMsg;
};
nacl.sign.open = function(signedMsg, publicKey) {
checkArrayTypes(signedMsg, publicKey);
if (publicKey.length !== crypto_sign_PUBLICKEYBYTES)
throw new Error('bad public key size');
var tmp = new Uint8Array(signedMsg.length);
var mlen = crypto_sign_open(tmp, signedMsg, signedMsg.length, publicKey);
if (mlen < 0) return null;
var m = new Uint8Array(mlen);
for (var i = 0; i < m.length; i++) m[i] = tmp[i];
return m;
};
nacl.sign.detached = function(msg, secretKey) {
var signedMsg = nacl.sign(msg, secretKey);
var sig = new Uint8Array(crypto_sign_BYTES);
for (var i = 0; i < sig.length; i++) sig[i] = signedMsg[i];
return sig;
};
nacl.sign.detached.verify = function(msg, sig, publicKey) {
checkArrayTypes(msg, sig, publicKey);
if (sig.length !== crypto_sign_BYTES)
throw new Error('bad signature size');
if (publicKey.length !== crypto_sign_PUBLICKEYBYTES)
throw new Error('bad public key size');
var sm = new Uint8Array(crypto_sign_BYTES + msg.length);
var m = new Uint8Array(crypto_sign_BYTES + msg.length);
var i;
for (i = 0; i < crypto_sign_BYTES; i++) sm[i] = sig[i];
for (i = 0; i < msg.length; i++) sm[i+crypto_sign_BYTES] = msg[i];
return (crypto_sign_open(m, sm, sm.length, publicKey) >= 0);
};
nacl.sign.keyPair = function() {
var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);
crypto_sign_keypair(pk, sk);
return {publicKey: pk, secretKey: sk};
};
nacl.sign.keyPair.fromSecretKey = function(secretKey) {
checkArrayTypes(secretKey);
if (secretKey.length !== crypto_sign_SECRETKEYBYTES)
throw new Error('bad secret key size');
var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
for (var i = 0; i < pk.length; i++) pk[i] = secretKey[32+i];
return {publicKey: pk, secretKey: new Uint8Array(secretKey)};
};
nacl.sign.keyPair.fromSeed = function(seed) {
checkArrayTypes(seed);
if (seed.length !== crypto_sign_SEEDBYTES)
throw new Error('bad seed size');
var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);
for (var i = 0; i < 32; i++) sk[i] = seed[i];
crypto_sign_keypair(pk, sk, true);
return {publicKey: pk, secretKey: sk};
};
nacl.sign.publicKeyLength = crypto_sign_PUBLICKEYBYTES;
nacl.sign.secretKeyLength = crypto_sign_SECRETKEYBYTES;
nacl.sign.seedLength = crypto_sign_SEEDBYTES;
nacl.sign.signatureLength = crypto_sign_BYTES;
nacl.hash = function(msg) {
checkArrayTypes(msg);
var h = new Uint8Array(crypto_hash_BYTES);
crypto_hash(h, msg, msg.length);
return h;
};
nacl.hash.hashLength = crypto_hash_BYTES;
nacl.verify = function(x, y) {
checkArrayTypes(x, y);
// Zero length arguments are considered not equal.
if (x.length === 0 || y.length === 0) return false;
if (x.length !== y.length) return false;
return (vn(x, 0, y, 0, x.length) === 0) ? true : false;
};
nacl.setPRNG = function(fn) {
randombytes = fn;
};
(function() {
// Initialize PRNG if environment provides CSPRNG.
// If not, methods calling randombytes will throw.
var crypto = typeof self !== 'undefined' ? (self.crypto || self.msCrypto) : null;
if (crypto && crypto.getRandomValues) {
// Browsers.
var QUOTA = 65536;
nacl.setPRNG(function(x, n) {
var i, v = new Uint8Array(n);
for (i = 0; i < n; i += QUOTA) {
crypto.getRandomValues(v.subarray(i, i + Math.min(n - i, QUOTA)));
}
for (i = 0; i < n; i++) x[i] = v[i];
cleanup(v);
});
} else if (typeof commonjsRequire !== 'undefined') {
// Node.js.
crypto = require$$1;
if (crypto && crypto.randomBytes) {
nacl.setPRNG(function(x, n) {
var i, v = crypto.randomBytes(n);
for (i = 0; i < n; i++) x[i] = v[i];
cleanup(v);
});
}
}
})();
})(module.exports ? module.exports : (self.nacl = self.nacl || {}));
} (naclFast));
return naclFast.exports;
}
var naclFastExports = requireNaclFast();
// SPDX-License-Identifier: MIT
class SLIP10Ed25519Blake2bPrivateKey extends PrivateKey {
getName() {
return 'SLIP10-Ed25519-Blake2b';
}
static fromBytes(privateKey) {
if (privateKey.length !== SLIP10_ED25519_CONST.PRIVATE_KEY_BYTE_LENGTH) {
throw new Error('Invalid private key bytes length');
}
try {
const kp = naclFastExports.sign.keyPair.fromSeed(getBytes(privateKey));
return new this(kp);
}
catch {
throw new Error('Invalid private key bytes');
}
}
static getLength() {
return SLIP10_ED25519_CONST.PRIVATE_KEY_BYTE_LENGTH;
}
getRaw() {
const secret = this.privateKey.secretKey;
return new Uint8Array(secret.subarray(0, naclFastExports.sign.seedLength));
}
getUnderlyingObject() {
return this.privateKey;
}
getPublicKey() {
const publicKey = this.privateKey.publicKey;
return SLIP10Ed25519Blake2bPublicKey.fromBytes(publicKey);
}
}
// SPDX-License-Identifier: MIT
class SLIP10Ed25519Blake2bECC extends EllipticCurveCryptography {
static NAME = 'SLIP10-Ed25519-Blake2b';
static ORDER = SLIP10Ed25519ECC.ORDER;
static GENERATOR = SLIP10Ed25519ECC.GENERATOR;
static POINT = SLIP10Ed25519Blake2bPoint;
static PUBLIC_KEY = SLIP10Ed25519Blake2bPublicKey;
static PRIVATE_KEY = SLIP10Ed25519Blake2bPrivateKey;
}
// SPDX-License-Identifier: MIT
class SLIP10Ed25519MoneroPoint extends SLIP10Ed25519Point {
getName() {
return 'SLIP10-Ed25519-Monero';
}
}
// SPDX-License-Identifier: MIT
class SLIP10Ed25519MoneroPublicKey extends SLIP10Ed25519PublicKey {
getName() {
return 'SLIP10-Ed25519-Monero';
}
getRawCompressed() {
return this.publicKey.toRawBytes();
}
static getCompressedLength() {
return SLIP10_ED25519_CONST.PUBLIC_KEY_BYTE_LENGTH;
}
getPoint() {
return new SLIP10Ed25519MoneroPoint(this.publicKey);
}
}
// SPDX-License-Identifier: MIT
const COORD_LEN = 32;
const CURVE = ed25519.CURVE;
const L$1 = CURVE.n; // group order
function intDecode(le) {
return bytesToInteger(le, true); // little-endian
}
function intEncode(x) {
return integerToBytes(x, COORD_LEN, 'little');
}
function scalar32(input) {
if (input instanceof Uint8Array) {
if (input.length !== COORD_LEN)
throw new Error('scalar must be 32 bytes');
return input;
}
return intEncode(BigInt(input));
}
function encodePoint(P) {
return P.toRawBytes();
}
function pointScalarMulBase(k) {
const scalar = bytesToNumberLE(scalar32(k)) % L$1; // <- reduce scalar
return encodePoint(ed25519.Point.BASE.multiply(scalar));
}
function scalarReduce(s) {
const scalar = bytesToNumberLE(s instanceof Uint8Array ? s : intEncode(BigInt(s)));
const r = scalar % L$1;
return intEncode(r);
}
// SPDX-License-Identifier: MIT
class SLIP10Ed25519MoneroPrivateKey extends SLIP10Ed25519PrivateKey {
getName() {
return 'SLIP10-Ed25519-Monero';
}
getPublicKey() {
return SLIP10Ed25519MoneroPublicKey.fromBytes(pointScalarMulBase(this.getRaw()));
}
}
// SPDX-License-Identifier: MIT
class SLIP10Ed25519MoneroECC extends EllipticCurveCryptography {
static NAME = 'SLIP10-Ed25519-Monero';
static ORDER = SLIP10Ed25519ECC.ORDER;
static GENERATOR = SLIP10Ed25519ECC.GENERATOR;
static POINT = SLIP10Ed25519MoneroPoint;
static PUBLIC_KEY = SLIP10Ed25519MoneroPublicKey;
static PRIVATE_KEY = SLIP10Ed25519MoneroPrivateKey;
}
/**
* Short Weierstrass curve methods. The formula is: y² = x³ + ax + b.
*
* ### Design rationale for types
*
* * Interaction between classes from different curves should fail:
* `k256.Point.BASE.add(p256.Point.BASE)`
* * For this purpose we want to use `instanceof` operator, which is fast and works during runtime
* * Different calls of `curve()` would return different classes -
* `curve(params) !== curve(params)`: if somebody decided to monkey-patch their curve,
* it won't affect others
*
* TypeScript can't infer types for classes created inside a function. Classes is one instance
* of nominative types in TypeScript and interfaces only check for shape, so it's hard to create
* unique type for every function call.
*
* We can use generic types via some param, like curve opts, but that would:
* 1. Enable interaction between `curve(params)` and `curve(params)` (curves of same params)
* which is hard to debug.
* 2. Params can be generic and we can't enforce them to be constant value:
* if somebody creates curve from non-constant params,
* it would be allowed to interact with other curves with non-constant params
*
* @todo https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-7.html#unique-symbol
* @module
*/
function validateSigVerOpts(opts) {
if (opts.lowS !== undefined)
abool('lowS', opts.lowS);
if (opts.prehash !== undefined)
abool('prehash', opts.prehash);
}
class DERErr extends Error {
constructor(m = '') {
super(m);
}
}
/**
* ASN.1 DER encoding utilities. ASN is very complex & fragile. Format:
*
* [0x30 (SEQUENCE), bytelength, 0x02 (INTEGER), intLength, R, 0x02 (INTEGER), intLength, S]
*
* Docs: https://letsencrypt.org/docs/a-warm-welcome-to-asn1-and-der/, https://luca.ntop.org/Teaching/Appunti/asn1.html
*/
const DER = {
// asn.1 DER encoding utils
Err: DERErr,
// Basic building block is TLV (Tag-Length-Value)
_tlv: {
encode: (tag, data) => {
const { Err: E } = DER;
if (tag < 0 || tag > 256)
throw new E('tlv.encode: wrong tag');
if (data.length & 1)
throw new E('tlv.encode: unpadded data');
const dataLen = data.length / 2;
const len = numberToHexUnpadded(dataLen);
if ((len.length / 2) & 128)
throw new E('tlv.encode: long form length too big');
// length of length with long form flag
const lenLen = dataLen > 127 ? numberToHexUnpadded((len.length / 2) | 128) : '';
const t = numberToHexUnpadded(tag);
return t + lenLen + len + data;
},
// v - value, l - left bytes (unparsed)
decode(tag, data) {
const { Err: E } = DER;
let pos = 0;
if (tag < 0 || tag > 256)
throw new E('tlv.encode: wrong tag');
if (data.length < 2 || data[pos++] !== tag)
throw new E('tlv.decode: wrong tlv');
const first = data[pos++];
const isLong = !!(first & 128); // First bit of first length byte is flag for short/long form
let length = 0;
if (!isLong)
length = first;
else {
// Long form: [longFlag(1bit), lengthLength(7bit), length (BE)]
const lenLen = first & 127;
if (!lenLen)
throw new E('tlv.decode(long): indefinite length not supported');
if (lenLen > 4)
throw new E('tlv.decode(long): byte length is too big'); // this will overflow u32 in js
const lengthBytes = data.subarray(pos, pos + lenLen);
if (lengthBytes.length !== lenLen)
throw new E('tlv.decode: length bytes not complete');
if (lengthBytes[0] === 0)
throw new E('tlv.decode(long): zero leftmost byte');
for (const b of lengthBytes)
length = (length << 8) | b;
pos += lenLen;
if (length < 128)
throw new E('tlv.decode(long): not minimal encoding');
}
const v = data.subarray(pos, pos + length);
if (v.length !== length)
throw new E('tlv.decode: wrong value length');
return { v, l: data.subarray(pos + length) };
},
},
// https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
// since we always use positive integers here. It must always be empty:
// - add zero byte if exists
// - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
_int: {
encode(num) {
const { Err: E } = DER;
if (num < _0n)
throw new E('integer: negative integers are not allowed');
let hex = numberToHexUnpadded(num);
// Pad with zero byte if negative flag is present
if (Number.parseInt(hex[0], 16) & 0b1000)
hex = '00' + hex;
if (hex.length & 1)
throw new E('unexpected DER parsing assertion: unpadded hex');
return hex;
},
decode(data) {
const { Err: E } = DER;
if (data[0] & 128)
throw new E('invalid signature integer: negative');
if (data[0] === 0x00 && !(data[1] & 128))
throw new E('invalid signature integer: unnecessary leading zero');
return bytesToNumberBE(data);
},
},
toSig(hex) {
// parse DER signature
const { Err: E, _int: int, _tlv: tlv } = DER;
const data = ensureBytes('signature', hex);
const { v: seqBytes, l: seqLeftBytes } = tlv.decode(0x30, data);
if (seqLeftBytes.length)
throw new E('invalid signature: left bytes after parsing');
const { v: rBytes, l: rLeftBytes } = tlv.decode(0x02, seqBytes);
const { v: sBytes, l: sLeftBytes } = tlv.decode(0x02, rLeftBytes);
if (sLeftBytes.length)
throw new E('invalid signature: left bytes after parsing');
return { r: int.decode(rBytes), s: int.decode(sBytes) };
},
hexFromSig(sig) {
const { _tlv: tlv, _int: int } = DER;
const rs = tlv.encode(0x02, int.encode(sig.r));
const ss = tlv.encode(0x02, int.encode(sig.s));
const seq = rs + ss;
return tlv.encode(0x30, seq);
},
};
// Be friendly to bad ECMAScript parsers by not using bigint literals
// prettier-ignore
const _0n = BigInt(0), _1n$1 = BigInt(1), _2n$1 = BigInt(2), _3n = BigInt(3), _4n = BigInt(4);
// TODO: remove
function _legacyHelperEquat(Fp, a, b) {
/**
* y² = x³ + ax + b: Short weierstrass curve formula. Takes x, returns y².
* @returns y²
*/
function weierstrassEquation(x) {
const x2 = Fp.sqr(x); // x * x
const x3 = Fp.mul(x2, x); // x² * x
return Fp.add(Fp.add(x3, Fp.mul(x, a)), b); // x³ + a * x + b
}
return weierstrassEquation;
}
function _legacyHelperNormPriv(Fn, allowedPrivateKeyLengths, wrapPrivateKey) {
const { BYTES: expected } = Fn;
// Validates if priv key is valid and converts it to bigint.
function normPrivateKeyToScalar(key) {
let num;
if (typeof key === 'bigint') {
num = key;
}
else {
let bytes = ensureBytes('private key', key);
if (allowedPrivateKeyLengths) {
if (!allowedPrivateKeyLengths.includes(bytes.length * 2))
throw new Error('invalid private key');
const padded = new Uint8Array(expected);
padded.set(bytes, padded.length - bytes.length);
bytes = padded;
}
try {
num = Fn.fromBytes(bytes);
}
catch (error) {
throw new Error(`invalid private key: expected ui8a of size ${expected}, got ${typeof key}`);
}
}
if (wrapPrivateKey)
num = Fn.create(num); // disabled by default, enabled for BLS
if (!Fn.isValidNot0(num))
throw new Error('invalid private key: out of range [1..N-1]');
return num;
}
return normPrivateKeyToScalar;
}
function weierstrassN(CURVE, curveOpts = {}) {
const { Fp, Fn } = _createCurveFields('weierstrass', CURVE, curveOpts);
const { h: cofactor, n: CURVE_ORDER } = CURVE;
_validateObject(curveOpts, {}, {
allowInfinityPoint: 'boolean',
clearCofactor: 'function',
isTorsionFree: 'function',
fromBytes: 'function',
toBytes: 'function',
endo: 'object',
wrapPrivateKey: 'boolean',
});
const { endo } = curveOpts;
if (endo) {
// validateObject(endo, { beta: 'bigint', splitScalar: 'function' });
if (!Fp.is0(CURVE.a) ||
typeof endo.beta !== 'bigint' ||
typeof endo.splitScalar !== 'function') {
throw new Error('invalid endo: expected "beta": bigint and "splitScalar": function');
}
}
function assertCompressionIsSupported() {
if (!Fp.isOdd)
throw new Error('compression is not supported: Field does not have .isOdd()');
}
// Implements IEEE P1363 point encoding
function pointToBytes(_c, point, isCompressed) {
const { x, y } = point.toAffine();
const bx = Fp.toBytes(x);
abool('isCompressed', isCompressed);
if (isCompressed) {
assertCompressionIsSupported();
const hasEvenY = !Fp.isOdd(y);
return concatBytes$1(pprefix(hasEvenY), bx);
}
else {
return concatBytes$1(Uint8Array.of(0x04), bx, Fp.toBytes(y));
}
}
function pointFromBytes(bytes) {
abytes(bytes);
const L = Fp.BYTES;
const LC = L + 1; // length compressed, e.g. 33 for 32-byte field
const LU = 2 * L + 1; // length uncompressed, e.g. 65 for 32-byte field
const length = bytes.length;
const head = bytes[0];
const tail = bytes.subarray(1);
// No actual validation is done here: use .assertValidity()
if (length === LC && (head === 0x02 || head === 0x03)) {
const x = Fp.fromBytes(tail);
if (!Fp.isValid(x))
throw new Error('bad point: is not on curve, wrong x');
const y2 = weierstrassEquation(x); // y² = x³ + ax + b
let y;
try {
y = Fp.sqrt(y2); // y = y² ^ (p+1)/4
}
catch (sqrtError) {
const err = sqrtError instanceof Error ? ': ' + sqrtError.message : '';
throw new Error('bad point: is not on curve, sqrt error' + err);
}
assertCompressionIsSupported();
const isYOdd = Fp.isOdd(y); // (y & _1n) === _1n;
const isHeadOdd = (head & 1) === 1; // ECDSA-specific
if (isHeadOdd !== isYOdd)
y = Fp.neg(y);
return { x, y };
}
else if (length === LU && head === 0x04) {
// TODO: more checks
const x = Fp.fromBytes(tail.subarray(L * 0, L * 1));
const y = Fp.fromBytes(tail.subarray(L * 1, L * 2));
if (!isValidXY(x, y))
throw new Error('bad point: is not on curve');
return { x, y };
}
else {
throw new Error(`bad point: got length ${length}, expected compressed=${LC} or uncompressed=${LU}`);
}
}
const toBytes = curveOpts.toBytes || pointToBytes;
const fromBytes = curveOpts.fromBytes || pointFromBytes;
const weierstrassEquation = _legacyHelperEquat(Fp, CURVE.a, CURVE.b);
// TODO: move top-level
/** Checks whether equation holds for given x, y: y² == x³ + ax + b */
function isValidXY(x, y) {
const left = Fp.sqr(y); // y²
const right = weierstrassEquation(x); // x³ + ax + b
return Fp.eql(left, right);
}
// Validate whether the passed curve params are valid.
// Test 1: equation y² = x³ + ax + b should work for generator point.
if (!isValidXY(CURVE.Gx, CURVE.Gy))
throw new Error('bad curve params: generator point');
// Test 2: discriminant Δ part should be non-zero: 4a³ + 27b² != 0.
// Guarantees curve is genus-1, smooth (non-singular).
const _4a3 = Fp.mul(Fp.pow(CURVE.a, _3n), _4n);
const _27b2 = Fp.mul(Fp.sqr(CURVE.b), BigInt(27));
if (Fp.is0(Fp.add(_4a3, _27b2)))
throw new Error('bad curve params: a or b');
/** Asserts coordinate is valid: 0 <= n < Fp.ORDER. */
function acoord(title, n, banZero = false) {
if (!Fp.isValid(n) || (banZero && Fp.is0(n)))
throw new Error(`bad point coordinate ${title}`);
return n;
}
function aprjpoint(other) {
if (!(other instanceof Point))
throw new Error('ProjectivePoint expected');
}
// Memoized toAffine / validity check. They are heavy. Points are immutable.
// Converts Projective point to affine (x, y) coordinates.
// Can accept precomputed Z^-1 - for example, from invertBatch.
// (X, Y, Z) ∋ (x=X/Z, y=Y/Z)
const toAffineMemo = memoized((p, iz) => {
const { px: x, py: y, pz: z } = p;
// Fast-path for normalized points
if (Fp.eql(z, Fp.ONE))
return { x, y };
const is0 = p.is0();
// If invZ was 0, we return zero point. However we still want to execute
// all operations, so we replace invZ with a random number, 1.
if (iz == null)
iz = is0 ? Fp.ONE : Fp.inv(z);
const ax = Fp.mul(x, iz);
const ay = Fp.mul(y, iz);
const zz = Fp.mul(z, iz);
if (is0)
return { x: Fp.ZERO, y: Fp.ZERO };
if (!Fp.eql(zz, Fp.ONE))
throw new Error('invZ was invalid');
return { x: ax, y: ay };
});
// NOTE: on exception this will crash 'cached' and no value will be set.
// Otherwise true will be return
const assertValidMemo = memoized((p) => {
if (p.is0()) {
// (0, 1, 0) aka ZERO is invalid in most contexts.
// In BLS, ZERO can be serialized, so we allow it.
// (0, 0, 0) is invalid representation of ZERO.
if (curveOpts.allowInfinityPoint && !Fp.is0(p.py))
return;
throw new Error('bad point: ZERO');
}
// Some 3rd-party test vectors require different wording between here & `fromCompressedHex`
const { x, y } = p.toAffine();
if (!Fp.isValid(x) || !Fp.isValid(y))
throw new Error('bad point: x or y not field elements');
if (!isValidXY(x, y))
throw new Error('bad point: equation left != right');
if (!p.isTorsionFree())
throw new Error('bad point: not in prime-order subgroup');
return true;
});
function finishEndo(endoBeta, k1p, k2p, k1neg, k2neg) {
k2p = new Point(Fp.mul(k2p.px, endoBeta), k2p.py, k2p.pz);
k1p = negateCt(k1neg, k1p);
k2p = negateCt(k2neg, k2p);
return k1p.add(k2p);
}
/**
* Projective Point works in 3d / projective (homogeneous) coordinates:(X, Y, Z) ∋ (x=X/Z, y=Y/Z).
* Default Point works in 2d / affine coordinates: (x, y).
* We're doing calculations in projective, because its operations don't require costly inversion.
*/
class Point {
/** Does NOT validate if the point is valid. Use `.assertValidity()`. */
constructor(px, py, pz) {
this.px = acoord('x', px);
this.py = acoord('y', py, true);
this.pz = acoord('z', pz);
Object.freeze(this);
}
/** Does NOT validate if the point is valid. Use `.assertValidity()`. */
static fromAffine(p) {
const { x, y } = p || {};
if (!p || !Fp.isValid(x) || !Fp.isValid(y))
throw new Error('invalid affine point');
if (p instanceof Point)
throw new Error('projective point not allowed');
// (0, 0) would've produced (0, 0, 1) - instead, we need (0, 1, 0)
if (Fp.is0(x) && Fp.is0(y))
return Point.ZERO;
return new Point(x, y, Fp.ONE);
}
get x() {
return this.toAffine().x;
}
get y() {
return this.toAffine().y;
}
static normalizeZ(points) {
return normalizeZ(Point, 'pz', points);
}
static fromBytes(bytes) {
abytes(bytes);
return Point.fromHex(bytes);
}
/** Converts hash string or Uint8Array to Point. */
static fromHex(hex) {
const P = Point.fromAffine(fromBytes(ensureBytes('pointHex', hex)));
P.assertValidity();
return P;
}
/** Multiplies generator point by privateKey. */
static fromPrivateKey(privateKey) {
const normPrivateKeyToScalar = _legacyHelperNormPriv(Fn, curveOpts.allowedPrivateKeyLengths, curveOpts.wrapPrivateKey);
return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));
}
/** Multiscalar Multiplication */
static msm(points, scalars) {
return pippenger(Point, Fn, points, scalars);
}
/**
*
* @param windowSize
* @param isLazy true will defer table computation until the first multiplication
* @returns
*/
precompute(windowSize = 8, isLazy = true) {
wnaf.setWindowSize(this, windowSize);
if (!isLazy)
this.multiply(_3n); // random number
return this;
}
/** "Private method", don't use it directly */
_setWindowSize(windowSize) {
this.precompute(windowSize);
}
// TODO: return `this`
/** A point on curve is valid if it conforms to equation. */
assertValidity() {
assertValidMemo(this);
}
hasEvenY() {
const { y } = this.toAffine();
if (!Fp.isOdd)
throw new Error("Field doesn't support isOdd");
return !Fp.isOdd(y);
}
/** Compare one point to another. */
equals(other) {
aprjpoint(other);
const { px: X1, py: Y1, pz: Z1 } = this;
const { px: X2, py: Y2, pz: Z2 } = other;
const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));
const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));
return U1 && U2;
}
/** Flips point to one corresponding to (x, -y) in Affine coordinates. */
negate() {
return new Point(this.px, Fp.neg(this.py), this.pz);
}
// Renes-Costello-Batina exception-free doubling formula.
// There is 30% faster Jacobian formula, but it is not complete.
// https://eprint.iacr.org/2015/1060, algorithm 3
// Cost: 8M + 3S + 3*a + 2*b3 + 15add.
double() {
const { a, b } = CURVE;
const b3 = Fp.mul(b, _3n);
const { px: X1, py: Y1, pz: Z1 } = this;
let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore
let t0 = Fp.mul(X1, X1); // step 1
let t1 = Fp.mul(Y1, Y1);
let t2 = Fp.mul(Z1, Z1);
let t3 = Fp.mul(X1, Y1);
t3 = Fp.add(t3, t3); // step 5
Z3 = Fp.mul(X1, Z1);
Z3 = Fp.add(Z3, Z3);
X3 = Fp.mul(a, Z3);
Y3 = Fp.mul(b3, t2);
Y3 = Fp.add(X3, Y3); // step 10
X3 = Fp.sub(t1, Y3);
Y3 = Fp.add(t1, Y3);
Y3 = Fp.mul(X3, Y3);
X3 = Fp.mul(t3, X3);
Z3 = Fp.mul(b3, Z3); // step 15
t2 = Fp.mul(a, t2);
t3 = Fp.sub(t0, t2);
t3 = Fp.mul(a, t3);
t3 = Fp.add(t3, Z3);
Z3 = Fp.add(t0, t0); // step 20
t0 = Fp.add(Z3, t0);
t0 = Fp.add(t0, t2);
t0 = Fp.mul(t0, t3);
Y3 = Fp.add(Y3, t0);
t2 = Fp.mul(Y1, Z1); // step 25
t2 = Fp.add(t2, t2);
t0 = Fp.mul(t2, t3);
X3 = Fp.sub(X3, t0);
Z3 = Fp.mul(t2, t1);
Z3 = Fp.add(Z3, Z3); // step 30
Z3 = Fp.add(Z3, Z3);
return new Point(X3, Y3, Z3);
}
// Renes-Costello-Batina exception-free addition formula.
// There is 30% faster Jacobian formula, but it is not complete.
// https://eprint.iacr.org/2015/1060, algorithm 1
// Cost: 12M + 0S + 3*a + 3*b3 + 23add.
add(other) {
aprjpoint(other);
const { px: X1, py: Y1, pz: Z1 } = this;
const { px: X2, py: Y2, pz: Z2 } = other;
let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore
const a = CURVE.a;
const b3 = Fp.mul(CURVE.b, _3n);
let t0 = Fp.mul(X1, X2); // step 1
let t1 = Fp.mul(Y1, Y2);
let t2 = Fp.mul(Z1, Z2);
let t3 = Fp.add(X1, Y1);
let t4 = Fp.add(X2, Y2); // step 5
t3 = Fp.mul(t3, t4);
t4 = Fp.add(t0, t1);
t3 = Fp.sub(t3, t4);
t4 = Fp.add(X1, Z1);
let t5 = Fp.add(X2, Z2); // step 10
t4 = Fp.mul(t4, t5);
t5 = Fp.add(t0, t2);
t4 = Fp.sub(t4, t5);
t5 = Fp.add(Y1, Z1);
X3 = Fp.add(Y2, Z2); // step 15
t5 = Fp.mul(t5, X3);
X3 = Fp.add(t1, t2);
t5 = Fp.sub(t5, X3);
Z3 = Fp.mul(a, t4);
X3 = Fp.mul(b3, t2); // step 20
Z3 = Fp.add(X3, Z3);
X3 = Fp.sub(t1, Z3);
Z3 = Fp.add(t1, Z3);
Y3 = Fp.mul(X3, Z3);
t1 = Fp.add(t0, t0); // step 25
t1 = Fp.add(t1, t0);
t2 = Fp.mul(a, t2);
t4 = Fp.mul(b3, t4);
t1 = Fp.add(t1, t2);
t2 = Fp.sub(t0, t2); // step 30
t2 = Fp.mul(a, t2);
t4 = Fp.add(t4, t2);
t0 = Fp.mul(t1, t4);
Y3 = Fp.add(Y3, t0);
t0 = Fp.mul(t5, t4); // step 35
X3 = Fp.mul(t3, X3);
X3 = Fp.sub(X3, t0);
t0 = Fp.mul(t3, t1);
Z3 = Fp.mul(t5, Z3);
Z3 = Fp.add(Z3, t0); // step 40
return new Point(X3, Y3, Z3);
}
subtract(other) {
return this.add(other.negate());
}
is0() {
return this.equals(Point.ZERO);
}
/**
* Constant time multiplication.
* Uses wNAF method. Windowed method may be 10% faster,
* but takes 2x longer to generate and consumes 2x memory.
* Uses precomputes when available.
* Uses endomorphism for Koblitz curves.
* @param scalar by which the point would be multiplied
* @returns New point
*/
multiply(scalar) {
const { endo } = curveOpts;
if (!Fn.isValidNot0(scalar))
throw new Error('invalid scalar: out of range'); // 0 is invalid
let point, fake; // Fake point is used to const-time mult
const mul = (n) => wnaf.wNAFCached(this, n, Point.normalizeZ);
/** See docs for {@link EndomorphismOpts} */
if (endo) {
const { k1neg, k1, k2neg, k2 } = endo.splitScalar(scalar);
const { p: k1p, f: k1f } = mul(k1);
const { p: k2p, f: k2f } = mul(k2);
fake = k1f.add(k2f);
point = finishEndo(endo.beta, k1p, k2p, k1neg, k2neg);
}
else {
const { p, f } = mul(scalar);
point = p;
fake = f;
}
// Normalize `z` for both points, but return only real one
return Point.normalizeZ([point, fake])[0];
}
/**
* Non-constant-time multiplication. Uses double-and-add algorithm.
* It's faster, but should only be used when you don't care about
* an exposed private key e.g. sig verification, which works over *public* keys.
*/
multiplyUnsafe(sc) {
const { endo } = curveOpts;
const p = this;
if (!Fn.isValid(sc))
throw new Error('invalid scalar: out of range'); // 0 is valid
if (sc === _0n || p.is0())
return Point.ZERO;
if (sc === _1n$1)
return p; // fast-path
if (wnaf.hasPrecomputes(this))
return this.multiply(sc);
if (endo) {
const { k1neg, k1, k2neg, k2 } = endo.splitScalar(sc);
// `wNAFCachedUnsafe` is 30% slower
const { p1, p2 } = mulEndoUnsafe(Point, p, k1, k2);
return finishEndo(endo.beta, p1, p2, k1neg, k2neg);
}
else {
return wnaf.wNAFCachedUnsafe(p, sc);
}
}
multiplyAndAddUnsafe(Q, a, b) {
const sum = this.multiplyUnsafe(a).add(Q.multiplyUnsafe(b));
return sum.is0() ? undefined : sum;
}
/**
* Converts Projective point to affine (x, y) coordinates.
* @param invertedZ Z^-1 (inverted zero) - optional, precomputation is useful for invertBatch
*/
toAffine(invertedZ) {
return toAffineMemo(this, invertedZ);
}
/**
* Checks whether Point is free of torsion elements (is in prime subgroup).
* Always torsion-free for cofactor=1 curves.
*/
isTorsionFree() {
const { isTorsionFree } = curveOpts;
if (cofactor === _1n$1)
return true;
if (isTorsionFree)
return isTorsionFree(Point, this);
return wnaf.wNAFCachedUnsafe(this, CURVE_ORDER).is0();
}
clearCofactor() {
const { clearCofactor } = curveOpts;
if (cofactor === _1n$1)
return this; // Fast-path
if (clearCofactor)
return clearCofactor(Point, this);
return this.multiplyUnsafe(cofactor);
}
toBytes(isCompressed = true) {
abool('isCompressed', isCompressed);
this.assertValidity();
return toBytes(Point, this, isCompressed);
}
/** @deprecated use `toBytes` */
toRawBytes(isCompressed = true) {
return this.toBytes(isCompressed);
}
toHex(isCompressed = true) {
return bytesToHex$1(this.toBytes(isCompressed));
}
toString() {
return `<Point ${this.is0() ? 'ZERO' : this.toHex()}>`;
}
}
// base / generator point
Point.BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);
// zero / infinity / identity point
Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO); // 0, 1, 0
// fields
Point.Fp = Fp;
Point.Fn = Fn;
const bits = Fn.BITS;
const wnaf = wNAF(Point, curveOpts.endo ? Math.ceil(bits / 2) : bits);
return Point;
}
// Points start with byte 0x02 when y is even; otherwise 0x03
function pprefix(hasEvenY) {
return Uint8Array.of(hasEvenY ? 0x02 : 0x03);
}
function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
_validateObject(ecdsaOpts, { hash: 'function' }, {
hmac: 'function',
lowS: 'boolean',
randomBytes: 'function',
bits2int: 'function',
bits2int_modN: 'function',
});
const randomBytes_ = ecdsaOpts.randomBytes || randomBytes$1;
const hmac_ = ecdsaOpts.hmac ||
((key, ...msgs) => hmac(ecdsaOpts.hash, key, concatBytes$1(...msgs)));
const { Fp, Fn } = Point;
const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;
function isBiggerThanHalfOrder(number) {
const HALF = CURVE_ORDER >> _1n$1;
return number > HALF;
}
function normalizeS(s) {
return isBiggerThanHalfOrder(s) ? Fn.neg(s) : s;
}
function aValidRS(title, num) {
if (!Fn.isValidNot0(num))
throw new Error(`invalid signature ${title}: out of range 1..CURVE.n`);
}
/**
* ECDSA signature with its (r, s) properties. Supports DER & compact representations.
*/
class Signature {
constructor(r, s, recovery) {
aValidRS('r', r); // r in [1..N-1]
aValidRS('s', s); // s in [1..N-1]
this.r = r;
this.s = s;
if (recovery != null)
this.recovery = recovery;
Object.freeze(this);
}
// pair (bytes of r, bytes of s)
static fromCompact(hex) {
const L = Fn.BYTES;
const b = ensureBytes('compactSignature', hex, L * 2);
return new Signature(Fn.fromBytes(b.subarray(0, L)), Fn.fromBytes(b.subarray(L, L * 2)));
}
// DER encoded ECDSA signature
// https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
static fromDER(hex) {
const { r, s } = DER.toSig(ensureBytes('DER', hex));
return new Signature(r, s);
}
/**
* @todo remove
* @deprecated
*/
assertValidity() { }
addRecoveryBit(recovery) {
return new Signature(this.r, this.s, recovery);
}
// ProjPointType<bigint>
recoverPublicKey(msgHash) {
const FIELD_ORDER = Fp.ORDER;
const { r, s, recovery: rec } = this;
if (rec == null || ![0, 1, 2, 3].includes(rec))
throw new Error('recovery id invalid');
// ECDSA recovery is hard for cofactor > 1 curves.
// In sign, `r = q.x mod n`, and here we recover q.x from r.
// While recovering q.x >= n, we need to add r+n for cofactor=1 curves.
// However, for cofactor>1, r+n may not get q.x:
// r+n*i would need to be done instead where i is unknown.
// To easily get i, we either need to:
// a. increase amount of valid recid values (4, 5...); OR
// b. prohibit non-prime-order signatures (recid > 1).
const hasCofactor = CURVE_ORDER * _2n$1 < FIELD_ORDER;
if (hasCofactor && rec > 1)
throw new Error('recovery id is ambiguous for h>1 curve');
const radj = rec === 2 || rec === 3 ? r + CURVE_ORDER : r;
if (!Fp.isValid(radj))
throw new Error('recovery id 2 or 3 invalid');
const x = Fp.toBytes(radj);
const R = Point.fromHex(concatBytes$1(pprefix((rec & 1) === 0), x));
const ir = Fn.inv(radj); // r^-1
const h = bits2int_modN(ensureBytes('msgHash', msgHash)); // Truncate hash
const u1 = Fn.create(-h * ir); // -hr^-1
const u2 = Fn.create(s * ir); // sr^-1
// (sr^-1)R-(hr^-1)G = -(hr^-1)G + (sr^-1). unsafe is fine: there is no private data.
const Q = Point.BASE.multiplyUnsafe(u1).add(R.multiplyUnsafe(u2));
if (Q.is0())
throw new Error('point at infinify');
Q.assertValidity();
return Q;
}
// Signatures should be low-s, to prevent malleability.
hasHighS() {
return isBiggerThanHalfOrder(this.s);
}
normalizeS() {
return this.hasHighS() ? new Signature(this.r, Fn.neg(this.s), this.recovery) : this;
}
toBytes(format) {
if (format === 'compact')
return concatBytes$1(Fn.toBytes(this.r), Fn.toBytes(this.s));
if (format === 'der')
return hexToBytes$1(DER.hexFromSig(this));
throw new Error('invalid format');
}
// DER-encoded
toDERRawBytes() {
return this.toBytes('der');
}
toDERHex() {
return bytesToHex$1(this.toBytes('der'));
}
// padded bytes of r, then padded bytes of s
toCompactRawBytes() {
return this.toBytes('compact');
}
toCompactHex() {
return bytesToHex$1(this.toBytes('compact'));
}
}
const normPrivateKeyToScalar = _legacyHelperNormPriv(Fn, curveOpts.allowedPrivateKeyLengths, curveOpts.wrapPrivateKey);
const utils = {
isValidPrivateKey(privateKey) {
try {
normPrivateKeyToScalar(privateKey);
return true;
}
catch (error) {
return false;
}
},
normPrivateKeyToScalar: normPrivateKeyToScalar,
/**
* Produces cryptographically secure private key from random of size
* (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
*/
randomPrivateKey: () => {
const n = CURVE_ORDER;
return mapHashToField(randomBytes_(getMinHashLength(n)), n);
},
precompute(windowSize = 8, point = Point.BASE) {
return point.precompute(windowSize, false);
},
};
/**
* Computes public key for a private key. Checks for validity of the private key.
* @param privateKey private key
* @param isCompressed whether to return compact (default), or full key
* @returns Public key, full when isCompressed=false; short when isCompressed=true
*/
function getPublicKey(privateKey, isCompressed = true) {
return Point.fromPrivateKey(privateKey).toBytes(isCompressed);
}
/**
* Quick and dirty check for item being public key. Does not validate hex, or being on-curve.
*/
function isProbPub(item) {
if (typeof item === 'bigint')
return false;
if (item instanceof Point)
return true;
const arr = ensureBytes('key', item);
const length = arr.length;
const L = Fp.BYTES;
const LC = L + 1; // e.g. 33 for 32
const LU = 2 * L + 1; // e.g. 65 for 32
if (curveOpts.allowedPrivateKeyLengths || Fn.BYTES === LC) {
return undefined;
}
else {
return length === LC || length === LU;
}
}
/**
* ECDH (Elliptic Curve Diffie Hellman).
* Computes shared public key from private key and public key.
* Checks: 1) private key validity 2) shared key is on-curve.
* Does NOT hash the result.
* @param privateA private key
* @param publicB different public key
* @param isCompressed whether to return compact (default), or full key
* @returns shared public key
*/
function getSharedSecret(privateA, publicB, isCompressed = true) {
if (isProbPub(privateA) === true)
throw new Error('first arg must be private key');
if (isProbPub(publicB) === false)
throw new Error('second arg must be public key');
const b = Point.fromHex(publicB); // check for being on-curve
return b.multiply(normPrivateKeyToScalar(privateA)).toBytes(isCompressed);
}
// RFC6979: ensure ECDSA msg is X bytes and < N. RFC suggests optional truncating via bits2octets.
// FIPS 186-4 4.6 suggests the leftmost min(nBitLen, outLen) bits, which matches bits2int.
// bits2int can produce res>N, we can do mod(res, N) since the bitLen is the same.
// int2octets can't be used; pads small msgs with 0: unacceptatble for trunc as per RFC vectors
const bits2int = ecdsaOpts.bits2int ||
function (bytes) {
// Our custom check "just in case", for protection against DoS
if (bytes.length > 8192)
throw new Error('input is too large');
// For curves with nBitLength % 8 !== 0: bits2octets(bits2octets(m)) !== bits2octets(m)
// for some cases, since bytes.length * 8 is not actual bitLength.
const num = bytesToNumberBE(bytes); // check for == u8 done here
const delta = bytes.length * 8 - fnBits; // truncate to nBitLength leftmost bits
return delta > 0 ? num >> BigInt(delta) : num;
};
const bits2int_modN = ecdsaOpts.bits2int_modN ||
function (bytes) {
return Fn.create(bits2int(bytes)); // can't use bytesToNumberBE here
};
// NOTE: pads output with zero as per spec
const ORDER_MASK = bitMask(fnBits);
/**
* Converts to bytes. Checks if num in `[0..ORDER_MASK-1]` e.g.: `[0..2^256-1]`.
*/
function int2octets(num) {
// IMPORTANT: the check ensures working for case `Fn.BYTES != Fn.BITS * 8`
aInRange('num < 2^' + fnBits, num, _0n, ORDER_MASK);
return Fn.toBytes(num);
}
// Steps A, D of RFC6979 3.2
// Creates RFC6979 seed; converts msg/privKey to numbers.
// Used only in sign, not in verify.
// NOTE: we cannot assume here that msgHash has same amount of bytes as curve order,
// this will be invalid at least for P521. Also it can be bigger for P224 + SHA256
function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
if (['recovered', 'canonical'].some((k) => k in opts))
throw new Error('sign() legacy options not supported');
const { hash } = ecdsaOpts;
let { lowS, prehash, extraEntropy: ent } = opts; // generates low-s sigs by default
if (lowS == null)
lowS = true; // RFC6979 3.2: we skip step A, because we already provide hash
msgHash = ensureBytes('msgHash', msgHash);
validateSigVerOpts(opts);
if (prehash)
msgHash = ensureBytes('prehashed msgHash', hash(msgHash));
// We can't later call bits2octets, since nested bits2int is broken for curves
// with fnBits % 8 !== 0. Because of that, we unwrap it here as int2octets call.
// const bits2octets = (bits) => int2octets(bits2int_modN(bits))
const h1int = bits2int_modN(msgHash);
const d = normPrivateKeyToScalar(privateKey); // validate private key, convert to bigint
const seedArgs = [int2octets(d), int2octets(h1int)];
// extraEntropy. RFC6979 3.6: additional k' (optional).
if (ent != null && ent !== false) {
// K = HMAC_K(V || 0x00 || int2octets(x) || bits2octets(h1) || k')
const e = ent === true ? randomBytes_(Fp.BYTES) : ent; // generate random bytes OR pass as-is
seedArgs.push(ensureBytes('extraEntropy', e)); // check for being bytes
}
const seed = concatBytes$1(...seedArgs); // Step D of RFC6979 3.2
const m = h1int; // NOTE: no need to call bits2int second time here, it is inside truncateHash!
// Converts signature params into point w r/s, checks result for validity.
// Can use scalar blinding b^-1(bm + bdr) where b ∈ [1,q−1] according to
// https://tches.iacr.org/index.php/TCHES/article/view/7337/6509. We've decided against it:
// a) dependency on CSPRNG b) 15% slowdown c) doesn't really help since bigints are not CT
function k2sig(kBytes) {
// RFC 6979 Section 3.2, step 3: k = bits2int(T)
// Important: all mod() calls here must be done over N
const k = bits2int(kBytes); // Cannot use fields methods, since it is group element
if (!Fn.isValidNot0(k))
return; // Valid scalars (including k) must be in 1..N-1
const ik = Fn.inv(k); // k^-1 mod n
const q = Point.BASE.multiply(k).toAffine(); // q = Gk
const r = Fn.create(q.x); // r = q.x mod n
if (r === _0n)
return;
const s = Fn.create(ik * Fn.create(m + r * d)); // Not using blinding here, see comment above
if (s === _0n)
return;
let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n$1); // recovery bit (2 or 3, when q.x > n)
let normS = s;
if (lowS && isBiggerThanHalfOrder(s)) {
normS = normalizeS(s); // if lowS was passed, ensure s is always
recovery ^= 1; // // in the bottom half of N
}
return new Signature(r, normS, recovery); // use normS, not s
}
return { seed, k2sig };
}
const defaultSigOpts = { lowS: ecdsaOpts.lowS, prehash: false };
const defaultVerOpts = { lowS: ecdsaOpts.lowS, prehash: false };
/**
* Signs message hash with a private key.
* ```
* sign(m, d, k) where
* (x, y) = G × k
* r = x mod n
* s = (m + dr)/k mod n
* ```
* @param msgHash NOT message. msg needs to be hashed to `msgHash`, or use `prehash`.
* @param privKey private key
* @param opts lowS for non-malleable sigs. extraEntropy for mixing randomness into k. prehash will hash first arg.
* @returns signature with recovery param
*/
function sign(msgHash, privKey, opts = defaultSigOpts) {
const { seed, k2sig } = prepSig(msgHash, privKey, opts); // Steps A, D of RFC6979 3.2.
const drbg = createHmacDrbg(ecdsaOpts.hash.outputLen, Fn.BYTES, hmac_);
return drbg(seed, k2sig); // Steps B, C, D, E, F, G
}
// Enable precomputes. Slows down first publicKey computation by 20ms.
Point.BASE.precompute(8);
/**
* Verifies a signature against message hash and public key.
* Rejects lowS signatures by default: to override,
* specify option `{lowS: false}`. Implements section 4.1.4 from https://www.secg.org/sec1-v2.pdf:
*
* ```
* verify(r, s, h, P) where
* U1 = hs^-1 mod n
* U2 = rs^-1 mod n
* R = U1⋅G - U2⋅P
* mod(R.x, n) == r
* ```
*/
function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
const sg = signature;
msgHash = ensureBytes('msgHash', msgHash);
publicKey = ensureBytes('publicKey', publicKey);
// Verify opts
validateSigVerOpts(opts);
const { lowS, prehash, format } = opts;
// TODO: remove
if ('strict' in opts)
throw new Error('options.strict was renamed to lowS');
if (format !== undefined && !['compact', 'der', 'js'].includes(format))
throw new Error('format must be "compact", "der" or "js"');
const isHex = typeof sg === 'string' || isBytes(sg);
const isObj = !isHex &&
!format &&
typeof sg === 'object' &&
sg !== null &&
typeof sg.r === 'bigint' &&
typeof sg.s === 'bigint';
if (!isHex && !isObj)
throw new Error('invalid signature, expected Uint8Array, hex string or Signature instance');
let _sig = undefined;
let P;
// deduce signature format
try {
// if (format === 'js') {
// if (sg != null && !isBytes(sg)) _sig = new Signature(sg.r, sg.s);
// } else if (format === 'compact') {
// _sig = Signature.fromCompact(sg);
// } else if (format === 'der') {
// _sig = Signature.fromDER(sg);
// } else {
// throw new Error('invalid format');
// }
if (isObj) {
if (format === undefined || format === 'js') {
_sig = new Signature(sg.r, sg.s);
}
else {
throw new Error('invalid format');
}
}
if (isHex) {
// TODO: remove this malleable check
// Signature can be represented in 2 ways: compact (2*Fn.BYTES) & DER (variable-length).
// Since DER can also be 2*Fn.BYTES bytes, we check for it first.
try {
if (format !== 'compact')
_sig = Signature.fromDER(sg);
}
catch (derError) {
if (!(derError instanceof DER.Err))
throw derError;
}
if (!_sig && format !== 'der')
_sig = Signature.fromCompact(sg);
}
P = Point.fromHex(publicKey);
}
catch (error) {
return false;
}
if (!_sig)
return false;
if (lowS && _sig.hasHighS())
return false;
// todo: optional.hash => hash
if (prehash)
msgHash = ecdsaOpts.hash(msgHash);
const { r, s } = _sig;
const h = bits2int_modN(msgHash); // Cannot use fields methods, since it is group element
const is = Fn.inv(s); // s^-1
const u1 = Fn.create(h * is); // u1 = hs^-1 mod n
const u2 = Fn.create(r * is); // u2 = rs^-1 mod n
const R = Point.BASE.multiplyUnsafe(u1).add(P.multiplyUnsafe(u2));
if (R.is0())
return false;
const v = Fn.create(R.x); // v = r.x mod n
return v === r;
}
// TODO: clarify API for cloning .clone({hash: sha512}) ? .createWith({hash: sha512})?
// const clone = (hash: CHash): ECDSA => ecdsa(Point, { ...ecdsaOpts, ...getHash(hash) }, curveOpts);
return Object.freeze({
getPublicKey,
getSharedSecret,
sign,
verify,
utils,
Point,
Signature,
});
}
function _weierstrass_legacy_opts_to_new(c) {
const CURVE = {
a: c.a,
b: c.b,
p: c.Fp.ORDER,
n: c.n,
h: c.h,
Gx: c.Gx,
Gy: c.Gy,
};
const Fp = c.Fp;
const Fn = Field(CURVE.n, c.nBitLength);
const curveOpts = {
Fp,
Fn,
allowedPrivateKeyLengths: c.allowedPrivateKeyLengths,
allowInfinityPoint: c.allowInfinityPoint,
endo: c.endo,
wrapPrivateKey: c.wrapPrivateKey,
isTorsionFree: c.isTorsionFree,
clearCofactor: c.clearCofactor,
fromBytes: c.fromBytes,
toBytes: c.toBytes,
};
return { CURVE, curveOpts };
}
function _ecdsa_legacy_opts_to_new(c) {
const { CURVE, curveOpts } = _weierstrass_legacy_opts_to_new(c);
const ecdsaOpts = {
hash: c.hash,
hmac: c.hmac,
randomBytes: c.randomBytes,
lowS: c.lowS,
bits2int: c.bits2int,
bits2int_modN: c.bits2int_modN,
};
return { CURVE, curveOpts, ecdsaOpts };
}
function _ecdsa_new_output_to_legacy(c, ecdsa) {
return Object.assign({}, ecdsa, {
ProjectivePoint: ecdsa.Point,
CURVE: c,
});
}
// _ecdsa_legacy
function weierstrass(c) {
const { CURVE, curveOpts, ecdsaOpts } = _ecdsa_legacy_opts_to_new(c);
const Point = weierstrassN(CURVE, curveOpts);
const signs = ecdsa(Point, ecdsaOpts, curveOpts);
return _ecdsa_new_output_to_legacy(c, signs);
}
/**
* Utilities for short weierstrass curves, combined with noble-hashes.
* @module
*/
function createCurve(curveDef, defHash) {
const create = (hash) => weierstrass({ ...curveDef, hash: hash });
return { ...create(defHash), create };
}
/**
* Internal module for NIST P256, P384, P521 curves.
* Do not use for now.
* @module
*/
// p = 2n**224n * (2n**32n-1n) + 2n**192n + 2n**96n - 1n
// a = Fp256.create(BigInt('-3'));
const p256_CURVE = {
p: BigInt('0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff'),
n: BigInt('0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551'),
h: BigInt(1),
a: BigInt('0xffffffff00000001000000000000000000000000fffffffffffffffffffffffc'),
b: BigInt('0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b'),
Gx: BigInt('0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296'),
Gy: BigInt('0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5'),
};
// p = 2n**384n - 2n**128n - 2n**96n + 2n**32n - 1n
const p384_CURVE = {
p: BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000ffffffff'),
n: BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973'),
h: BigInt(1),
a: BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000fffffffc'),
b: BigInt('0xb3312fa7e23ee7e4988e056be3f82d19181d9c6efe8141120314088f5013875ac656398d8a2ed19d2a85c8edd3ec2aef'),
Gx: BigInt('0xaa87ca22be8b05378eb1c71ef320ad746e1d3b628ba79b9859f741e082542a385502f25dbf55296c3a545e3872760ab7'),
Gy: BigInt('0x3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c00a60b1ce1d7e819d7a431d7c90ea0e5f'),
};
// p = 2n**521n - 1n
const p521_CURVE = {
p: BigInt('0x1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'),
n: BigInt('0x01fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa51868783bf2f966b7fcc0148f709a5d03bb5c9b8899c47aebb6fb71e91386409'),
h: BigInt(1),
a: BigInt('0x1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc'),
b: BigInt('0x0051953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef109e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00'),
Gx: BigInt('0x00c6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3dbaa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66'),
Gy: BigInt('0x011839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650'),
};
const Fp256 = Field(p256_CURVE.p);
const Fp384 = Field(p384_CURVE.p);
const Fp521 = Field(p521_CURVE.p);
/** NIST P256 (aka secp256r1, prime256v1) curve, ECDSA and ECDH methods. */
const p256$1 = createCurve({ ...p256_CURVE, Fp: Fp256, lowS: false }, sha256$1);
/** NIST P384 (aka secp384r1) curve, ECDSA and ECDH methods. */
createCurve({ ...p384_CURVE, Fp: Fp384, lowS: false }, sha384);
/** NIST P521 (aka secp521r1) curve, ECDSA and ECDH methods. */
createCurve({ ...p521_CURVE, Fp: Fp521, lowS: false, allowedPrivateKeyLengths: [130, 131, 132] }, sha512$1);
/**
* NIST secp256r1 aka p256.
* @module
*/
const p256 = p256$1;
p256$1;
// SPDX-License-Identifier: MIT
class SLIP10Nist256p1Point extends Point {
getName() {
return 'SLIP10-Nist256p1';
}
static fromBytes(point) {
try {
const pt = p256.Point.fromHex(getBytes(point));
return new SLIP10Nist256p1Point(pt);
}
catch {
if (point.length === SLIP10_SECP256K1_CONST.POINT_COORDINATE_BYTE_LENGTH * 2) {
const x = bytesToNumberBE(point.slice(0, SLIP10_SECP256K1_CONST.POINT_COORDINATE_BYTE_LENGTH));
const y = bytesToNumberBE(point.slice(SLIP10_SECP256K1_CONST.POINT_COORDINATE_BYTE_LENGTH));
return SLIP10Nist256p1Point.fromCoordinates(BigInt(x), BigInt(y));
}
throw new Error('Invalid point bytes');
}
}
static fromCoordinates(x, y) {
const pt = new p256.Point(BigInt(x), BigInt(y), 1n);
return new SLIP10Nist256p1Point(pt);
}
getUnderlyingObject() {
return this.point;
}
getX() {
return this.point.toAffine().x;
}
getY() {
return this.point.toAffine().y;
}
getRawEncoded() {
return this.point.toRawBytes(true);
}
getRawDecoded() {
return this.point.toRawBytes(false).slice(1); // strip leading `0x04`
}
add(other) {
const p = other.getUnderlyingObject();
return new SLIP10Nist256p1Point(this.point.add(p));
}
multiply(scalar) {
return new SLIP10Nist256p1Point(this.point.multiply(scalar));
}
}
// SPDX-License-Identifier: MIT
class SLIP10Nist256p1PublicKey extends PublicKey {
getName() {
return 'SLIP10-Nist256p1';
}
static fromBytes(publicKey) {
try {
const point = p256.Point.fromHex(getBytes(publicKey));
return new SLIP10Nist256p1PublicKey(point);
}
catch {
throw new Error('Invalid key bytes');
}
}
static fromPoint(point) {
const base = point.getUnderlyingObject();
return new SLIP10Nist256p1PublicKey(base);
}
static getCompressedLength() {
return SLIP10_SECP256K1_CONST.PUBLIC_KEY_COMPRESSED_BYTE_LENGTH;
}
static getUncompressedLength() {
return SLIP10_SECP256K1_CONST.PUBLIC_KEY_UNCOMPRESSED_BYTE_LENGTH;
}
getUnderlyingObject() {
return this.publicKey;
}
getRawCompressed() {
return this.publicKey.toRawBytes(true);
}
getRawUncompressed() {
return this.publicKey.toRawBytes(false);
}
getRaw() {
return this.getRawCompressed();
}
getPoint() {
return new SLIP10Nist256p1Point(this.publicKey);
}
}
// SPDX-License-Identifier: MIT
class SLIP10Nist256p1PrivateKey extends PrivateKey {
getName() {
return 'SLIP10-Nist256p1';
}
static fromBytes(privateKey) {
if (privateKey.length !== SLIP10_SECP256K1_CONST.PRIVATE_KEY_BYTE_LENGTH) {
throw new Error('Invalid private key bytes length');
}
try {
const priv = bytesToNumberBE(getBytes(privateKey));
const point = p256.Point.BASE.multiply(priv);
return new SLIP10Nist256p1PrivateKey({ priv, point });
}
catch {
throw new Error('Invalid private key bytes');
}
}
static getLength() {
return SLIP10_SECP256K1_CONST.PRIVATE_KEY_BYTE_LENGTH;
}
getRaw() {
return numberToBytesBE(this.privateKey.priv, SLIP10_SECP256K1_CONST.PRIVATE_KEY_BYTE_LENGTH);
}
getUnderlyingObject() {
return this.privateKey;
}
getPublicKey() {
return new SLIP10Nist256p1PublicKey(this.privateKey.point);
}
}
// SPDX-License-Identifier: MIT
class SLIP10Nist256p1ECC extends EllipticCurveCryptography {
static NAME = 'SLIP10-Nist256p1';
static ORDER = p256.CURVE.n;
static GENERATOR = SLIP10Nist256p1Point.fromCoordinates(p256.CURVE.Gx, p256.CURVE.Gy);
static POINT = SLIP10Nist256p1Point;
static PUBLIC_KEY = SLIP10Nist256p1PublicKey;
static PRIVATE_KEY = SLIP10Nist256p1PrivateKey;
}
/**
* SECG secp256k1. See [pdf](https://www.secg.org/sec2-v2.pdf).
*
* Belongs to Koblitz curves: it has efficiently-computable GLV endomorphism ψ,
* check out {@link EndomorphismOpts}. Seems to be rigid (not backdoored).
* @module
*/
// Seems like generator was produced from some seed:
// `Point.BASE.multiply(Point.Fn.inv(2n, N)).toAffine().x`
// // gives short x 0x3b78ce563f89a0ed9414f5aa28ad0d96d6795f9c63n
const secp256k1_CURVE = {
p: BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f'),
n: BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141'),
h: BigInt(1),
a: BigInt(0),
b: BigInt(7),
Gx: BigInt('0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),
Gy: BigInt('0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8'),
};
BigInt(0);
const _1n = BigInt(1);
const _2n = BigInt(2);
const divNearest = (a, b) => (a + b / _2n) / b;
/**
* √n = n^((p+1)/4) for fields p = 3 mod 4. We unwrap the loop and multiply bit-by-bit.
* (P+1n/4n).toString(2) would produce bits [223x 1, 0, 22x 1, 4x 0, 11, 00]
*/
function sqrtMod(y) {
const P = secp256k1_CURVE.p;
// prettier-ignore
const _3n = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
// prettier-ignore
const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
const b2 = (y * y * y) % P; // x^3, 11
const b3 = (b2 * b2 * y) % P; // x^7
const b6 = (pow2(b3, _3n, P) * b3) % P;
const b9 = (pow2(b6, _3n, P) * b3) % P;
const b11 = (pow2(b9, _2n, P) * b2) % P;
const b22 = (pow2(b11, _11n, P) * b11) % P;
const b44 = (pow2(b22, _22n, P) * b22) % P;
const b88 = (pow2(b44, _44n, P) * b44) % P;
const b176 = (pow2(b88, _88n, P) * b88) % P;
const b220 = (pow2(b176, _44n, P) * b44) % P;
const b223 = (pow2(b220, _3n, P) * b3) % P;
const t1 = (pow2(b223, _23n, P) * b22) % P;
const t2 = (pow2(t1, _6n, P) * b2) % P;
const root = pow2(t2, _2n, P);
if (!Fpk1.eql(Fpk1.sqr(root), y))
throw new Error('Cannot find square root');
return root;
}
const Fpk1 = Field(secp256k1_CURVE.p, undefined, undefined, { sqrt: sqrtMod });
/**
* secp256k1 curve, ECDSA and ECDH methods.
*
* Field: `2n**256n - 2n**32n - 2n**9n - 2n**8n - 2n**7n - 2n**6n - 2n**4n - 1n`
*
* @example
* ```js
* import { secp256k1 } from '@noble/curves/secp256k1';
* const priv = secp256k1.utils.randomPrivateKey();
* const pub = secp256k1.getPublicKey(priv);
* const msg = new Uint8Array(32).fill(1); // message hash (not message) in ecdsa
* const sig = secp256k1.sign(msg, priv); // `{prehash: true}` option is available
* const isValid = secp256k1.verify(sig, msg, pub) === true;
* ```
*/
const secp256k1 = createCurve({
...secp256k1_CURVE,
Fp: Fpk1,
lowS: true, // Allow only low-S signatures by default in sign() and verify()
endo: {
// Endomorphism, see above
beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),
splitScalar: (k) => {
const n = secp256k1_CURVE.n;
const a1 = BigInt('0x3086d221a7d46bcde86c90e49284eb15');
const b1 = -_1n * BigInt('0xe4437ed6010e88286f547fa90abfe4c3');
const a2 = BigInt('0x114ca50f7a8e2f3f657c1108d9d44cfd8');
const b2 = a1;
const POW_2_128 = BigInt('0x100000000000000000000000000000000'); // (2n**128n).toString(16)
const c1 = divNearest(b2 * k, n);
const c2 = divNearest(-b1 * k, n);
let k1 = mod(k - c1 * a1 - c2 * a2, n);
let k2 = mod(-c1 * b1 - c2 * b2, n);
const k1neg = k1 > POW_2_128;
const k2neg = k2 > POW_2_128;
if (k1neg)
k1 = n - k1;
if (k2neg)
k2 = n - k2;
if (k1 > POW_2_128 || k2 > POW_2_128) {
throw new Error('splitScalar: Endomorphism failed, k=' + k);
}
return { k1neg, k1, k2neg, k2 };
},
},
}, sha256$1);
// SPDX-License-Identifier: MIT
class SLIP10Secp256k1Point extends Point {
getName() {
return 'SLIP10-Secp256k1';
}
static fromBytes(point) {
try {
const pubPoint = secp256k1.Point.fromHex(getBytes(point));
return new SLIP10Secp256k1Point(pubPoint);
}
catch {
throw new Error('Invalid point bytes');
}
}
static fromCoordinates(x, y) {
const pt = new secp256k1.Point(x, y, 1n);
return new SLIP10Secp256k1Point(pt);
}
getUnderlyingObject() {
return this.point;
}
getX() {
return this.point.toAffine().x;
}
getY() {
return this.point.toAffine().y;
}
getRawEncoded() {
return this.point.toRawBytes(true);
}
getRawDecoded() {
return this.point.toRawBytes(false).slice(1);
}
add(point) {
const other = point.getUnderlyingObject();
const sum = this.point.add(other);
return new SLIP10Secp256k1Point(sum);
}
multiply(scalar) {
const prod = this.point.multiply(scalar);
return new SLIP10Secp256k1Point(prod);
}
}
// SPDX-License-Identifier: MIT
class SLIP10Secp256k1PublicKey extends PublicKey {
getName() {
return 'SLIP10-Secp256k1';
}
static fromBytes(publicKey) {
try {
const point = secp256k1.Point.fromHex(getBytes(publicKey));
return new SLIP10Secp256k1PublicKey(point);
}
catch {
throw new Error('Invalid key bytes');
}
}
static fromPoint(point) {
const base = point.getUnderlyingObject();
return new SLIP10Secp256k1PublicKey(base);
}
static getCompressedLength() {
return SLIP10_SECP256K1_CONST.PUBLIC_KEY_COMPRESSED_BYTE_LENGTH;
}
static getUncompressedLength() {
return SLIP10_SECP256K1_CONST.PUBLIC_KEY_UNCOMPRESSED_BYTE_LENGTH;
}
getUnderlyingObject() {
return this.publicKey;
}
getRawCompressed() {
return this.publicKey.toRawBytes(true);
}
getRawUncompressed() {
return this.publicKey.toRawBytes(false);
}
getRaw() {
return this.getRawCompressed();
}
getPoint() {
return new SLIP10Secp256k1Point(this.publicKey);
}
}
// SPDX-License-Identifier: MIT
class SLIP10Secp256k1PrivateKey extends PrivateKey {
getName() {
return 'SLIP10-Secp256k1';
}
static fromBytes(privateKey) {
if (privateKey.length !== SLIP10_SECP256K1_CONST.PRIVATE_KEY_BYTE_LENGTH) {
throw new Error('Invalid private key bytes length');
}
try {
const priv = bytesToNumberBE(getBytes(privateKey));
const point = secp256k1.Point.BASE.multiply(priv);
return new SLIP10Secp256k1PrivateKey({ priv, point });
}
catch {
throw new Error('Invalid private key bytes');
}
}
static getLength() {
return SLIP10_SECP256K1_CONST.PRIVATE_KEY_BYTE_LENGTH;
}
getRaw() {
return numberToBytesBE(this.privateKey.priv, SLIP10_SECP256K1_CONST.PRIVATE_KEY_BYTE_LENGTH);
}
getUnderlyingObject() {
return this.privateKey;
}
getPublicKey() {
return new SLIP10Secp256k1PublicKey(this.privateKey.point);
}
}
// SPDX-License-Identifier: MIT
class SLIP10Secp256k1ECC extends EllipticCurveCryptography {
static NAME = 'SLIP10-Secp256k1';
static ORDER = BigInt('0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141');
static GENERATOR = SLIP10Secp256k1Point.fromCoordinates(BigInt('0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798'), BigInt('0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8'));
static POINT = SLIP10Secp256k1Point;
static PUBLIC_KEY = SLIP10Secp256k1PublicKey;
static PRIVATE_KEY = SLIP10Secp256k1PrivateKey;
}
// SPDX-License-Identifier: MIT
class KholawEd25519Point extends SLIP10Ed25519Point {
getName() {
return 'Kholaw-Ed25519';
}
}
// SPDX-License-Identifier: MIT
class KholawEd25519PublicKey extends SLIP10Ed25519PublicKey {
getName() {
return 'Kholaw-Ed25519';
}
getPoint() {
return new KholawEd25519Point(this.publicKey);
}
}
// SPDX-License-Identifier: MIT
class KholawEd25519PrivateKey extends SLIP10Ed25519PrivateKey {
constructor(privateKey, options) {
if (!options.extendedKey) {
throw new Error('Extended key is required');
}
if (options.extendedKey.length !== SLIP10Ed25519PrivateKey.getLength()) {
throw new Error('Invalid extended key length');
}
super(privateKey, options);
}
getName() {
return 'Kholaw-Ed25519';
}
static fromBytes(privateKey) {
if (privateKey.length !== KHOLAW_ED25519_CONST.PRIVATE_KEY_BYTE_LENGTH) {
throw new Error('Invalid private key bytes length');
}
const privateKeyBytes = privateKey.slice(0, SLIP10Ed25519PrivateKey.getLength());
const extendedKeyBytes = privateKey.slice(SLIP10Ed25519PrivateKey.getLength());
return new KholawEd25519PrivateKey(privateKeyBytes, { extendedKey: extendedKeyBytes });
}
static getLength() {
return KHOLAW_ED25519_CONST.PRIVATE_KEY_BYTE_LENGTH;
}
getRaw() {
const combined = new Uint8Array(KholawEd25519PrivateKey.getLength());
combined.set(this.privateKey);
if (!this.options.extendedKey)
throw new Error('Extended key is required');
combined.set(this.options.extendedKey, SLIP10Ed25519PrivateKey.getLength());
return combined;
}
getPublicKey() {
const point = pointScalarMulBase(this.privateKey);
return KholawEd25519PublicKey.fromBytes(point);
}
}
// SPDX-License-Identifier: MIT
class KholawEd25519ECC extends EllipticCurveCryptography {
static NAME = 'Kholaw-Ed25519';
static ORDER = SLIP10Ed25519ECC.ORDER;
static GENERATOR = SLIP10Ed25519ECC.GENERATOR;
static POINT = KholawEd25519Point;
static PUBLIC_KEY = KholawEd25519PublicKey;
static PRIVATE_KEY = KholawEd25519PrivateKey;
}
// SPDX-License-Identifier: MIT
class ECCS {
static dictionary = {
[KholawEd25519ECC.NAME]: KholawEd25519ECC,
[SLIP10Ed25519ECC.NAME]: SLIP10Ed25519ECC,
[SLIP10Ed25519Blake2bECC.NAME]: SLIP10Ed25519Blake2bECC,
[SLIP10Ed25519MoneroECC.NAME]: SLIP10Ed25519MoneroECC,
[SLIP10Nist256p1ECC.NAME]: SLIP10Nist256p1ECC,
[SLIP10Secp256k1ECC.NAME]: SLIP10Secp256k1ECC
};
static getNames() {
return Object.keys(this.dictionary);
}
static getClasses() {
return Object.values(this.dictionary);
}
static getECCClass(name) {
if (!this.isECC(name)) {
throw new ECCError(`Invalid ECC name`, { expected: this.getNames(), got: name });
}
return this.dictionary[name];
}
static isECC(name) {
return this.getNames().includes(name);
}
}
function validateAndGetPublicKey(publicKey, publicKeyCls) {
try {
if (publicKey instanceof Uint8Array) {
return publicKeyCls.fromBytes(publicKey);
}
if (typeof publicKey === 'string') {
const bytes = getBytes(publicKey);
return publicKeyCls.fromBytes(bytes);
}
if (!(publicKey instanceof publicKeyCls)) {
throw new PublicKeyError(`Invalid public key instance`, {
expected: publicKeyCls.name,
got: publicKey.constructor.name
});
}
return publicKey;
}
catch (err) {
if (err instanceof PublicKeyError)
throw err;
throw new PublicKeyError('Invalid public key data');
}
}
var eccs = /*#__PURE__*/Object.freeze({
__proto__: null,
ECCS: ECCS,
validateAndGetPublicKey: validateAndGetPublicKey,
EllipticCurveCryptography: EllipticCurveCryptography,
Point: Point,
PublicKey: PublicKey,
PrivateKey: PrivateKey,
KholawEd25519ECC: KholawEd25519ECC,
SLIP10Ed25519ECC: SLIP10Ed25519ECC,
SLIP10Ed25519Blake2bECC: SLIP10Ed25519Blake2bECC,
SLIP10Ed25519MoneroECC: SLIP10Ed25519MoneroECC,
SLIP10Nist256p1ECC: SLIP10Nist256p1ECC,
SLIP10Secp256k1ECC: SLIP10Secp256k1ECC,
KholawEd25519Point: KholawEd25519Point,
KholawEd25519PublicKey: KholawEd25519PublicKey,
KholawEd25519PrivateKey: KholawEd25519PrivateKey,
SLIP10Ed25519Point: SLIP10Ed25519Point,
SLIP10Ed25519PublicKey: SLIP10Ed25519PublicKey,
SLIP10Ed25519PrivateKey: SLIP10Ed25519PrivateKey,
SLIP10Ed25519Blake2bPoint: SLIP10Ed25519Blake2bPoint,
SLIP10Ed25519Blake2bPublicKey: SLIP10Ed25519Blake2bPublicKey,
SLIP10Ed25519Blake2bPrivateKey: SLIP10Ed25519Blake2bPrivateKey,
SLIP10Ed25519MoneroPoint: SLIP10Ed25519MoneroPoint,
SLIP10Ed25519MoneroPublicKey: SLIP10Ed25519MoneroPublicKey,
SLIP10Ed25519MoneroPrivateKey: SLIP10Ed25519MoneroPrivateKey,
SLIP10Nist256p1Point: SLIP10Nist256p1Point,
SLIP10Nist256p1PublicKey: SLIP10Nist256p1PublicKey,
SLIP10Nist256p1PrivateKey: SLIP10Nist256p1PrivateKey,
SLIP10Secp256k1Point: SLIP10Secp256k1Point,
SLIP10Secp256k1PublicKey: SLIP10Secp256k1PublicKey,
SLIP10Secp256k1PrivateKey: SLIP10Secp256k1PrivateKey
});
// SPDX-License-Identifier: MIT
class Mainnet$3i extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x17;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18AdCoin Signed Message:\n';
static WIF_PREFIX = 0xb0;
}
class Adcoin extends Cryptocurrency {
static NAME = 'Adcoin';
static SYMBOL = 'ACC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/adcoin-project/AdCoin',
WHITEPAPER: 'https://www.getadcoin.com/assets/Whitepaper_AdCoin.pdf',
WEBSITES: [
'https://www.getadcoin.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Adcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$3i
});
static DEFAULT_NETWORK = Adcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Adcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Adcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Adcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$3h extends Network {
static NAME = 'mainnet';
static HRP = 'akash';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class AkashNetwork extends Cryptocurrency {
static NAME = 'Akash-Network';
static SYMBOL = 'AKT';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/akash-network',
WEBSITES: [
'https://akash.network'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.AkashNetwork;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$3h
});
static DEFAULT_NETWORK = AkashNetwork.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = AkashNetwork.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${AkashNetwork.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
COSMOS: 'Cosmos'
});
static DEFAULT_ADDRESS = AkashNetwork.ADDRESSES.COSMOS;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$3g extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0f4331d4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
}
class Algorand extends Cryptocurrency {
static NAME = 'Algorand';
static SYMBOL = 'ALGO';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/algorand/go-algorand',
WHITEPAPER: 'https://www.algorand.com/resources/white-papers',
WEBSITES: [
'http://algorand.foundation',
'https://www.algorand.com'
]
});
static ECC = KholawEd25519ECC;
static COIN_TYPE = CoinTypes.Algorand;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$3g
});
static DEFAULT_NETWORK = Algorand.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
{ ALGORAND: 'Algorand' },
'BIP39'
]);
static MNEMONICS = new Mnemonics([
{ ALGORAND: 'Algorand' },
'BIP39'
]);
static SEEDS = new Seeds([
{ ALGORAND: 'Algorand' },
'BIP39'
]);
static HDS = new HDs([
{ ALGORAND: 'Algorand' },
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Algorand.HDS.ALGORAND;
static DEFAULT_PATH = `m/44'/${Algorand.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
ALGORAND: 'Algorand'
});
static DEFAULT_ADDRESS = Algorand.ADDRESSES.ALGORAND;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static PARAMS = new Params({
CHECKSUM_LENGTH: 0x04
});
}
// SPDX-License-Identifier: MIT
class Mainnet$3f extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x00000582;
static SCRIPT_ADDRESS_PREFIX = 0x00005389;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18ANON Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Anon extends Cryptocurrency {
static NAME = 'Anon';
static SYMBOL = 'ANON';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/anonymousbitcoin/anon',
WHITEPAPER: 'https://www.anon.community/whitepaper',
WEBSITES: [
'https://www.anon.community'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Anon;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$3f
});
static DEFAULT_NETWORK = Anon.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Anon.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Anon.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Anon.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$3e extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
}
class Aptos extends Cryptocurrency {
static NAME = 'Aptos';
static SYMBOL = 'APT';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/aptos-labs',
WHITEPAPER: 'https://aptosfoundation.org/whitepaper',
WEBSITES: [
'https://aptosfoundation.org'
]
});
static ECC = SLIP10Ed25519ECC;
static COIN_TYPE = CoinTypes.Aptos;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$3e
});
static DEFAULT_NETWORK = Aptos.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Aptos.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Aptos.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
APTOS: 'Aptos'
});
static DEFAULT_ADDRESS = Aptos.ADDRESSES.APTOS;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static PARAMS = new Params({
SUFFIX: 0x00,
ADDRESS_PREFIX: '0x'
});
}
// SPDX-License-Identifier: MIT
class Mainnet$3d extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Arbitrum extends Cryptocurrency {
static NAME = 'Arbitrum';
static SYMBOL = 'ARB';
static INFO = new Info({
WHITEPAPER: 'https://github.com/OffchainLabs',
WEBSITES: [
'https://arbitrum.foundation',
'https://arbitrum.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Arbitrum;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$3d
});
static DEFAULT_NETWORK = Arbitrum.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Arbitrum.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Arbitrum.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
ETHEREUM: 'Ethereum'
});
static DEFAULT_ADDRESS = Arbitrum.ADDRESSES.ETHEREUM;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$3c extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x32;
static SCRIPT_ADDRESS_PREFIX = 0x61;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0xbf;
}
class Argoneum extends Cryptocurrency {
static NAME = 'Argoneum';
static SYMBOL = 'AGM';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/Argoneum/argoneum',
WEBSITES: [
'https://www.argoneum.net'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Argoneum;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$3c
});
static DEFAULT_NETWORK = Argoneum.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Argoneum.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Argoneum.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Argoneum.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$3b extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x17;
static SCRIPT_ADDRESS_PREFIX = 0x00001cbd;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Artax Signed Message:\n';
static WIF_PREFIX = 0x97;
}
class Artax extends Cryptocurrency {
static NAME = 'Artax';
static SYMBOL = 'XAX';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/artax-committee/Artax',
WEBSITES: [
'http://www.artaxcoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Artax;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$3b
});
static DEFAULT_NETWORK = Artax.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Artax.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Artax.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Artax.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$3a extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x17;
static SCRIPT_ADDRESS_PREFIX = 0x6f;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Aryacoin Signed Message:\n';
static WIF_PREFIX = 0x97;
}
class Aryacoin extends Cryptocurrency {
static NAME = 'Aryacoin';
static SYMBOL = 'AYA';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/Aryacoin/Aryacoin',
WEBSITES: [
'https://aryacoin.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Aryacoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$3a
});
static DEFAULT_NETWORK = Aryacoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Aryacoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Aryacoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Aryacoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$39 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x17;
static SCRIPT_ADDRESS_PREFIX = 0x08;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18AsiaCoin Signed Message:\n';
static WIF_PREFIX = 0x97;
}
class Asiacoin extends Cryptocurrency {
static NAME = 'Asiacoin';
static SYMBOL = 'AC';
static INFO = new Info({
WEBSITES: [
'http://www.thecoin.asia'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Asiacoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$39
});
static DEFAULT_NETWORK = Asiacoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Asiacoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Asiacoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Asiacoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$38 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x17;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18AuroraCoin Signed Message:\n';
static WIF_PREFIX = 0x97;
}
class Auroracoin extends Cryptocurrency {
static NAME = 'Auroracoin';
static SYMBOL = 'AUR';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/aurarad/auroracoin',
WEBSITES: [
'https://en.auroracoin.is'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Auroracoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$38
});
static DEFAULT_NETWORK = Auroracoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Auroracoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Auroracoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Auroracoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$37 extends Network {
static NAME = 'mainnet';
static HRP = 'avax';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Avalanche extends Cryptocurrency {
static NAME = 'Avalanche';
static SYMBOL = 'AVAX';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/ava-labs/avalanchego',
WHITEPAPER: 'https://www.avalabs.org/whitepapers',
WEBSITES: [
'https://avax.network',
'https://www.avalabs.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Avalanche;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$37
});
static DEFAULT_NETWORK = Avalanche.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Avalanche.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Avalanche.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
AVALANCHE: 'Avalanche',
ETHEREUM: 'Ethereum'
});
static DEFAULT_ADDRESS = Avalanche.ADDRESSES.AVALANCHE;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static ADDRESS_TYPES = new AddressTypes({
C_CHAIN: 'c-chain',
P_CHAIN: 'p-chain',
X_CHAIN: 'x-chain'
});
static DEFAULT_ADDRESS_TYPE = Avalanche.ADDRESS_TYPES.P_CHAIN;
static PARAMS = new Params({
ADDRESS_TYPES: {
P_CHAIN: 'P-',
X_CHAIN: 'X-'
}
});
}
// SPDX-License-Identifier: MIT
class Mainnet$36 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x3c;
static SCRIPT_ADDRESS_PREFIX = 0x7a;
static HRP = 'av';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878,
P2WSH: 0x02aa7a99,
P2WSH_IN_P2SH: 0x0295b005
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2,
P2WSH: 0x02aa7ed3,
P2WSH_IN_P2SH: 0x0295b43f
});
static MESSAGE_PREFIX = 'Aviancoin Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Avian extends Cryptocurrency {
static NAME = 'Avian';
static SYMBOL = 'AVN';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/AvianNetwork/Avian',
WHITEPAPER: 'https://www.avn.network/_files/ugd/c493c9_83224e1867d24a4185421548cfd6a35a.pdf',
WEBSITES: [
'https://avn.network'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Avian;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$36
});
static DEFAULT_NETWORK = Avian.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Avian.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Avian.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' },
'P2WSH',
{ P2WSH_IN_P2SH: 'P2WSH-In-P2SH' }
]);
static DEFAULT_ADDRESS = Avian.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh', 'p2wsh', 'p2wsh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$35 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x37;
static SCRIPT_ADDRESS_PREFIX = 0x10;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0xcc;
}
class Axe extends Cryptocurrency {
static NAME = 'Axe';
static SYMBOL = 'AXE';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/AXErunners/axe',
WEBSITES: [
'https://axerunners.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Axe;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$35
});
static DEFAULT_NETWORK = Axe.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Axe.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Axe.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Axe.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$34 extends Network {
static NAME = 'mainnet';
static HRP = 'axelar';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Axelar extends Cryptocurrency {
static NAME = 'Axelar';
static SYMBOL = 'AXL';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/axelarnetwork/axelar-core',
WHITEPAPER: 'https://axelar.network/wp-content/uploads/2021/07/axelar_whitepaper.pdf',
WEBSITES: [
'https://axelar.network',
'https://app.squidrouter.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Axelar;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$34
});
static DEFAULT_NETWORK = Axelar.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Axelar.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Axelar.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
COSMOS: 'Cosmos'
});
static DEFAULT_ADDRESS = Axelar.ADDRESSES.COSMOS;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$33 extends Network {
static NAME = 'mainnet';
static HRP = 'band';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class BandProtocol extends Cryptocurrency {
static NAME = 'Band-Protocol';
static SYMBOL = 'BAND';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/bandprotocol/chain',
WHITEPAPER: 'https://bandprotocol.com/whitepaper-3.0.1.pdf',
WEBSITES: [
'https://bandprotocol.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.BandProtocol;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$33
});
static DEFAULT_NETWORK = BandProtocol.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = BandProtocol.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${BandProtocol.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
COSMOS: 'Cosmos'
});
static DEFAULT_ADDRESS = BandProtocol.ADDRESSES.COSMOS;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$32 extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Base extends Cryptocurrency {
static NAME = 'Base';
static SYMBOL = 'BASE';
static INFO = new Info({
WHITEPAPER: 'https://base.mirror.xyz',
WEBSITES: [
'https://base.org',
'https://docs.base.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Arbitrum;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$32
});
static DEFAULT_NETWORK = Base.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Base.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Base.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
ETHEREUM: 'Ethereum'
});
static DEFAULT_ADDRESS = Base.ADDRESSES.ETHEREUM;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$31 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x19;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0xa40b91bd,
P2SH: 0xa40b91bd
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0xa40c86fa,
P2SH: 0xa40c86fa
});
static MESSAGE_PREFIX = '\x18Bata Signed Message:\n';
static WIF_PREFIX = 0xa4;
}
class Bata extends Cryptocurrency {
static NAME = 'Bata';
static SYMBOL = 'BTA';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/BTA-BATA/Bataoshi',
WHITEPAPER: 'https://bata.io/wp-content/uploads/2021/09/Bata-Cryptocurrency-Whitepaper.pdf',
WEBSITES: [
'https://bata.io',
'https://bata.digital'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Bata;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$31
});
static DEFAULT_NETWORK = Bata.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Bata.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Bata.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Bata.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$30 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x1a;
static SCRIPT_ADDRESS_PREFIX = 0x55;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x19Beetlecoin Signed Message:\n';
static WIF_PREFIX = 0x99;
}
class BeetleCoin extends Cryptocurrency {
static NAME = 'Beetle-Coin';
static SYMBOL = 'BEET';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/beetledev/Wallet',
WEBSITES: [
'https://beetlecoin.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.BeetleCoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$30
});
static DEFAULT_NETWORK = BeetleCoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = BeetleCoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${BeetleCoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = BeetleCoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2$ extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x19;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18BelaCoin Signed Message:\n';
static WIF_PREFIX = 0x99;
}
class BelaCoin extends Cryptocurrency {
static NAME = 'Bela-Coin';
static SYMBOL = 'BELA';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/TheAmbiaFund/erc20bela',
WHITEPAPER: 'http://livebela.com/assets/releases/belawhitepaper.pdf',
WEBSITES: [
'http://livebela.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.BelaCoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2$
});
static DEFAULT_NETWORK = BelaCoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = BelaCoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${BelaCoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = BelaCoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2_ extends Network {
static NAME = 'mainnet';
static HRP = 'bnb';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Binance extends Cryptocurrency {
static NAME = 'Binance';
static SYMBOL = 'BNB';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/bnb-chain/bsc',
WHITEPAPER: 'https://github.com/bnb-chain/whitepaper',
WEBSITES: [
'https://www.bnbchain.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Binance;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$2_
});
static DEFAULT_NETWORK = Binance.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Binance.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Binance.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
COSMOS: 'Cosmos',
ETHEREUM: 'Ethereum'
});
static DEFAULT_ADDRESS = Binance.ADDRESSES.COSMOS;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static ADDRESS_TYPES = new AddressTypes({
CHAIN: 'chain',
SMART_CHAIN: 'smart-chain'
});
static DEFAULT_ADDRESS_TYPE = Binance.ADDRESS_TYPES.CHAIN;
}
// SPDX-License-Identifier: MIT
class Mainnet$2Z extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x19;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18BitCloud Signed Message:\n';
static WIF_PREFIX = 0x99;
}
class BitCloud extends Cryptocurrency {
static NAME = 'Bit-Cloud';
static SYMBOL = 'BTDX';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/LIMXTEC/Bitcloud',
WHITEPAPER: 'https://github.com/LIMXTEC/Bitcloud/blob/master/README.md',
WEBSITES: [
'https://bit-cloud.cc'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.BitCloud;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2Z
});
static DEFAULT_NETWORK = BitCloud.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = BitCloud.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${BitCloud.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = BitCloud.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2Y extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x00;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static HRP = 'bc';
static WITNESS_VERSIONS = new WitnessVersions({
P2TR: 0x01,
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2TR: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878,
P2WSH: 0x02aa7a99,
P2WSH_IN_P2SH: 0x0295b005
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2TR: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2,
P2WSH: 0x02aa7ed3,
P2WSH_IN_P2SH: 0x0295b43f
});
static MESSAGE_PREFIX = '\x18Bitcoin Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Testnet$t extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x6f;
static SCRIPT_ADDRESS_PREFIX = 0xc4;
static HRP = 'tb';
static WITNESS_VERSIONS = new WitnessVersions({
P2TR: 0x01,
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x04358394,
P2SH: 0x04358394,
P2TR: 0x04358394,
P2WPKH: 0x045f18bc,
P2WPKH_IN_P2SH: 0x044a4e28,
P2WSH: 0x02575048,
P2WSH_IN_P2SH: 0x024285b5
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x043587cf,
P2SH: 0x043587cf,
P2TR: 0x043587cf,
P2WPKH: 0x045f1cf6,
P2WPKH_IN_P2SH: 0x044a5262,
P2WSH: 0x02575483,
P2WSH_IN_P2SH: 0x024289ef
});
static MESSAGE_PREFIX = '\x18Bitcoin Signed Message:\n';
static WIF_PREFIX = 0xef;
}
class Regtest$1 extends Testnet$t {
static NAME = 'regtest';
static HRP = 'bcrt';
}
class Bitcoin extends Cryptocurrency {
static NAME = 'Bitcoin';
static SYMBOL = 'BTC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/bitcoin/bitcoin',
WHITEPAPER: 'https://bitcoin.org/bitcoin.pdf',
WEBSITES: [
'https://bitcoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Bitcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2Y,
TESTNET: Testnet$t,
REGTEST: Regtest$1
});
static DEFAULT_NETWORK = Bitcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39',
{ ELECTRUM_V1: 'Electrum-V1' },
{ ELECTRUM_V2: 'Electrum-V2' }
]);
static MNEMONICS = new Mnemonics([
'BIP39',
{ ELECTRUM_V1: 'Electrum-V1' },
{ ELECTRUM_V2: 'Electrum-V2' }
]);
static SEEDS = new Seeds([
'BIP39',
{ ELECTRUM_V1: 'Electrum-V1' },
{ ELECTRUM_V2: 'Electrum-V2' }
]);
static HDS = new HDs([
'BIP32',
'BIP44',
'BIP49',
'BIP84',
'BIP86',
'BIP141',
{ ELECTRUM_V1: 'Electrum-V1' },
{ ELECTRUM_V2: 'Electrum-V2' }
]);
static DEFAULT_HD = Bitcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Bitcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2TR',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' },
'P2WSH',
{ P2WSH_IN_P2SH: 'P2WSH-In-P2SH' }
]);
static DEFAULT_ADDRESS = Bitcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2tr', 'p2wpkh', 'p2wpkh-in-p2sh', 'p2wsh', 'p2wsh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static PARAMS = new Params({
ALPHABET: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz',
FIELD_SIZE: '0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F',
TAP_TWEAK_SHA256: 'e80fe1639c9ca050e3af1b39c143c63e429cbceb15d940fbb5c5a1f4af57c5e9'
});
}
// SPDX-License-Identifier: MIT
class Mainnet$2X extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x17;
static SCRIPT_ADDRESS_PREFIX = 0x0a;
static HRP = 'bca';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x0488ade4,
P2WPKH_IN_P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x0488b21e,
P2WPKH_IN_P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Bitcoin Atom Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class BitcoinAtom extends Cryptocurrency {
static NAME = 'Bitcoin-Atom';
static SYMBOL = 'BCA';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/bitcoin-atom/bitcoin-atom',
WEBSITES: [
'https://bitcoinatom.io/'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.BitcoinAtom;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2X
});
static DEFAULT_NETWORK = BitcoinAtom.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = BitcoinAtom.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${BitcoinAtom.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' }
]);
static DEFAULT_ADDRESS = BitcoinAtom.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2W extends Network {
static NAME = 'mainnet';
static LEGACY_PUBLIC_KEY_ADDRESS_PREFIX = 0x00;
static LEGACY_SCRIPT_ADDRESS_PREFIX = 0x05;
static STD_PUBLIC_KEY_ADDRESS_PREFIX = 0x00;
static STD_SCRIPT_ADDRESS_PREFIX = 0x08;
static HRP = 'bitcoincash';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878,
P2WSH: 0x02aa7a99,
P2WSH_IN_P2SH: 0x0295b005
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2,
P2WSH: 0x02aa7ed3,
P2WSH_IN_P2SH: 0x0295b43f
});
static WIF_PREFIX = 0x80;
}
class Testnet$s extends Network {
static NAME = 'testnet';
static LEGACY_PUBLIC_KEY_ADDRESS_PREFIX = 0x6f;
static LEGACY_SCRIPT_ADDRESS_PREFIX = 0xc4;
static STD_PUBLIC_KEY_ADDRESS_PREFIX = 0x00;
static STD_SCRIPT_ADDRESS_PREFIX = 0x08;
static HRP = 'bchtest';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x04358394,
P2SH: 0x04358394,
P2WPKH: 0x045f18bc,
P2WPKH_IN_P2SH: 0x044a4e28,
P2WSH: 0x02575048,
P2WSH_IN_P2SH: 0x024285b5
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x043587cf,
P2SH: 0x043587cf,
P2WPKH: 0x045f1cf6,
P2WPKH_IN_P2SH: 0x044a5262,
P2WSH: 0x02575483,
P2WSH_IN_P2SH: 0x024289ef
});
static WIF_PREFIX = 0xef;
}
class Regtest extends Testnet$s {
static NAME = 'regtest';
static HRP = 'bchreg';
}
class BitcoinCash extends Cryptocurrency {
static NAME = 'Bitcoin-Cash';
static SYMBOL = 'BCH';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/bitcoincashorg/bitcoincash.org',
WEBSITES: [
'http://bch.info'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.BitcoinCash;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$2W,
TESTNET: Testnet$s,
REGTEST: Regtest
});
static DEFAULT_NETWORK = BitcoinCash.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = BitcoinCash.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${BitcoinCash.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' },
'P2WSH',
{ P2WSH_IN_P2SH: 'P2WSH-In-P2SH' }
]);
static DEFAULT_ADDRESS = BitcoinCash.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh', 'p2wsh', 'p2wsh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static ADDRESS_TYPES = new AddressTypes({
STD: 'std',
LEGACY: 'legacy'
});
static DEFAULT_ADDRESS_TYPE = BitcoinCash.ADDRESS_TYPES.STD;
}
// SPDX-License-Identifier: MIT
class Mainnet$2V extends Network {
static NAME = 'mainnet';
static LEGACY_PUBLIC_KEY_ADDRESS_PREFIX = 0x00;
static LEGACY_SCRIPT_ADDRESS_PREFIX = 0x05;
static STD_PUBLIC_KEY_ADDRESS_PREFIX = 0x00;
static STD_SCRIPT_ADDRESS_PREFIX = 0x08;
static HRP = 'simpleledger';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878,
P2WSH: 0x02aa7a99,
P2WSH_IN_P2SH: 0x0295b005
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2,
P2WSH: 0x02aa7ed3,
P2WSH_IN_P2SH: 0x0295b43f
});
static WIF_PREFIX = 0x80;
}
class Testnet$r extends Network {
static NAME = 'testnet';
static LEGACY_PUBLIC_KEY_ADDRESS_PREFIX = 0x6f;
static LEGACY_SCRIPT_ADDRESS_PREFIX = 0xc4;
static STD_PUBLIC_KEY_ADDRESS_PREFIX = 0x00;
static STD_SCRIPT_ADDRESS_PREFIX = 0x08;
static HRP = 'slptest';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x04358394,
P2SH: 0x04358394,
P2WPKH: 0x045f18bc,
P2WPKH_IN_P2SH: 0x044a4e28,
P2WSH: 0x02575048,
P2WSH_IN_P2SH: 0x024285b5
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x043587cf,
P2SH: 0x043587cf,
P2WPKH: 0x045f1cf6,
P2WPKH_IN_P2SH: 0x044a5262,
P2WSH: 0x02575483,
P2WSH_IN_P2SH: 0x024289ef
});
static WIF_PREFIX = 0xef;
}
class BitcoinCashSLP extends Cryptocurrency {
static NAME = 'Bitcoin-Cash-SLP';
static SYMBOL = 'SLP';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/bitcoincashorg/bitcoincash.org',
WEBSITES: [
'http://bch.info'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.BitcoinCashSLP;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$2V,
TESTNET: Testnet$r
});
static DEFAULT_NETWORK = BitcoinCashSLP.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = BitcoinCashSLP.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${BitcoinCashSLP.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' },
'P2WSH',
{ P2WSH_IN_P2SH: 'P2WSH-In-P2SH' }
]);
static DEFAULT_ADDRESS = BitcoinCashSLP.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh', 'p2wsh', 'p2wsh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static ADDRESS_TYPES = new AddressTypes({
STD: 'std',
LEGACY: 'legacy'
});
static DEFAULT_ADDRESS_TYPE = BitcoinCashSLP.ADDRESS_TYPES.STD;
}
// SPDX-License-Identifier: MIT
class Mainnet$2U extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x26;
static SCRIPT_ADDRESS_PREFIX = 0x17;
static HRP = 'btg';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878,
P2WSH: 0x02aa7a99,
P2WSH_IN_P2SH: 0x0295b005
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2,
P2WSH: 0x02aa7ed3,
P2WSH_IN_P2SH: 0x0295b43f
});
static MESSAGE_PREFIX = '\x1dBitcoin Gold Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class BitcoinGold extends Cryptocurrency {
static NAME = 'Bitcoin-Gold';
static SYMBOL = 'BTG';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/BTCGPU/BTCGPU',
WHITEPAPER: 'https://github.com/BTCGPU/BTCGPU/wiki/Technical-Spec',
WEBSITES: [
'https://bitcoingold.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.BitcoinGold;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2U
});
static DEFAULT_NETWORK = BitcoinGold.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = BitcoinGold.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${BitcoinGold.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' },
'P2WSH',
{ P2WSH_IN_P2SH: 'P2WSH-In-P2SH' }
]);
static DEFAULT_ADDRESS = BitcoinGold.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh', 'p2wsh', 'p2wsh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2T extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x26;
static SCRIPT_ADDRESS_PREFIX = 0x00001cbd;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18BitcoinGreen Signed Message:\n';
static WIF_PREFIX = 0x2e;
}
class BitcoinGreen extends Cryptocurrency {
static NAME = 'Bitcoin-Green';
static SYMBOL = 'BITG';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/bitcoin-green/bitcoingreen',
WEBSITES: [
'https://bitg.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.BitcoinGreen;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2T
});
static DEFAULT_NETWORK = BitcoinGreen.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = BitcoinGreen.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${BitcoinGreen.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = BitcoinGreen.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2S extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x19;
static SCRIPT_ADDRESS_PREFIX = 0x08;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18BitcoinPlus Signed Message:\n';
static WIF_PREFIX = 0x99;
}
class BitcoinPlus extends Cryptocurrency {
static NAME = 'Bitcoin-Plus';
static SYMBOL = 'XBC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/bitcoinplusorg/xbcwalletsource',
WHITEPAPER: 'https://bitcoinplus.org/wp-content/uploads/2020/09/bitcoin-plus-whitepaper.pdf',
WEBSITES: [
'https://bitcoinplus.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.BitcoinPlus;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2S
});
static DEFAULT_NETWORK = BitcoinPlus.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = BitcoinPlus.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${BitcoinPlus.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = BitcoinPlus.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2R extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x00001325;
static SCRIPT_ADDRESS_PREFIX = 0x000013af;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18BitcoinPrivate Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Testnet$q extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x00001957;
static SCRIPT_ADDRESS_PREFIX = 0x000019e0;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x04358394,
P2SH: 0x04358394
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x043587cf,
P2SH: 0x043587cf
});
static MESSAGE_PREFIX = '\x18BitcoinPrivate Signed Message:\n';
static WIF_PREFIX = 0xef;
}
class BitcoinPrivate extends Cryptocurrency {
static NAME = 'Bitcoin-Private';
static SYMBOL = 'BTCP';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/BTCPrivate/BitcoinPrivate',
WHITEPAPER: 'https://btcprivate.org/whitepaper.pdf',
WEBSITES: [
'https://btcprivate.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.BitcoinPrivate;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2R,
TESTNET: Testnet$q
});
static DEFAULT_NETWORK = BitcoinPrivate.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = BitcoinPrivate.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${BitcoinPrivate.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = BitcoinPrivate.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2Q extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x00;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0x80;
}
class BitcoinSV extends Cryptocurrency {
static NAME = 'Bitcoin-SV';
static SYMBOL = 'BSV';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/bitcoin-sv/bitcoin-sv',
WEBSITES: [
'https://www.bsvblockchain.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.BitcoinSV;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2Q
});
static DEFAULT_NETWORK = BitcoinSV.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = BitcoinSV.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${BitcoinSV.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = BitcoinSV.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2P extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x00001cb8;
static SCRIPT_ADDRESS_PREFIX = 0x00001cbd;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18BitcoinZ Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class BitcoinZ extends Cryptocurrency {
static NAME = 'BitcoinZ';
static SYMBOL = 'BTCZ';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/btcz/bitcoinz',
WHITEPAPER: 'https://getbtcz.com/btcz-analytical-description',
WEBSITES: [
'https://getbtcz.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.BitcoinZ;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2P
});
static DEFAULT_NETWORK = BitcoinZ.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = BitcoinZ.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${BitcoinZ.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = BitcoinZ.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2O extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x03;
static SCRIPT_ADDRESS_PREFIX = 0x7d;
static HRP = 'bitcore';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x0488ade4,
P2WPKH_IN_P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x0488b21e,
P2WPKH_IN_P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18BitCore Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Bitcore extends Cryptocurrency {
static NAME = 'Bitcore';
static SYMBOL = 'BTX';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/bitcore-btx/BitCore',
WHITEPAPER: 'https://bitcore.cc/#coinspec-anchor',
WEBSITES: [
'https://bitcore.cc'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Bitcore;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2O
});
static DEFAULT_NETWORK = Bitcore.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Bitcore.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Bitcore.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' }
]);
static DEFAULT_ADDRESS = Bitcore.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2N extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x66;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Bitsend Signed Message:\n';
static WIF_PREFIX = 0xcc;
}
class BitSend extends Cryptocurrency {
static NAME = 'Bit-Send';
static SYMBOL = 'BSD';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/LIMXTEC/BitSend',
WHITEPAPER: 'https://github.com/LIMXTEC/BitSend/releases/download/v0.14.0.5/Z.bitsend_whitePaper.Dec_17.pdf',
WEBSITES: [
'https://bitsend.cc',
'http://www.mybitsend.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.BitSend;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2N
});
static DEFAULT_NETWORK = BitSend.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = BitSend.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${BitSend.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = BitSend.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2M extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x19;
static SCRIPT_ADDRESS_PREFIX = 0x55;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x02cfbf60,
P2SH: 0x02cfbf60
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x02cfbede,
P2SH: 0x02cfbede
});
static MESSAGE_PREFIX = '\x18BlackCoin Signed Message:\n';
static WIF_PREFIX = 0x99;
}
class Blackcoin extends Cryptocurrency {
static NAME = 'Blackcoin';
static SYMBOL = 'BLK';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/coinblack',
WHITEPAPER: 'https://blackcoin.org/blackcoin-pos-protocol-v2-whitepaper.pdf',
WEBSITES: [
'https://blackcoin.org',
'https://blackcoinmore.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Blackcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2M
});
static DEFAULT_NETWORK = Blackcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Blackcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Blackcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Blackcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2L extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x19;
static SCRIPT_ADDRESS_PREFIX = 0x3f;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Blocknode Signed Message:\n';
static WIF_PREFIX = 0x4b;
}
class Testnet$p extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x55;
static SCRIPT_ADDRESS_PREFIX = 0x7d;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x04358394,
P2SH: 0x04358394
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x043587cf,
P2SH: 0x043587cf
});
static MESSAGE_PREFIX = '\x18Blocknode Testnet Signed Message:\n';
static WIF_PREFIX = 0x89;
}
class Blocknode extends Cryptocurrency {
static NAME = 'Blocknode';
static SYMBOL = 'BND';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/blocknodetech/blocknode',
WEBSITES: [
'https://blocknode.tech'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Blocknode;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2L,
TESTNET: Testnet$p
});
static DEFAULT_NETWORK = Blocknode.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Blocknode.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Blocknode.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Blocknode.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2K extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x00;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static HRP = 'bc';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x0488ade4,
P2WPKH_IN_P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x0488b21e,
P2WPKH_IN_P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18BlockStamp Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class BlockStamp extends Cryptocurrency {
static NAME = 'Block-Stamp';
static SYMBOL = 'BST';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/BlockStamp',
WHITEPAPER: 'https://whitepaper.blockstamp.info',
WEBSITES: [
'https://blockstamp.info'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.BlockStamp;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2K
});
static DEFAULT_NETWORK = BlockStamp.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = BlockStamp.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${BlockStamp.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' }
]);
static DEFAULT_ADDRESS = BlockStamp.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2J extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x55;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = 'Bolivarcoin Signed Message:\n';
static WIF_PREFIX = 0xd5;
}
class Bolivarcoin extends Cryptocurrency {
static NAME = 'Bolivarcoin';
static SYMBOL = 'BOLI';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/BOLI-Project/BolivarCoin',
WEBSITES: [
'https://bolis.info'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Bolivarcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2J
});
static DEFAULT_NETWORK = Bolivarcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Bolivarcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Bolivarcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Bolivarcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2I extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x19;
static SCRIPT_ADDRESS_PREFIX = 0x55;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18BritCoin Signed Message:\n';
static WIF_PREFIX = 0x99;
}
class BritCoin extends Cryptocurrency {
static NAME = 'Brit-Coin';
static SYMBOL = 'BRIT';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/britcoin3',
WEBSITES: [
'http://britcoin.xyz'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.BritCoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2I
});
static DEFAULT_NETWORK = BritCoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = BritCoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${BritCoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = BritCoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2H extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x1c;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Canada eCoin Signed Message:\n';
static WIF_PREFIX = 0x9c;
}
class CanadaECoin extends Cryptocurrency {
static NAME = 'Canada-eCoin';
static SYMBOL = 'CDN';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/Canada-eCoin',
WEBSITES: [
'http://www.canadaecoin.ca'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.CanadaECoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2H
});
static DEFAULT_NETWORK = CanadaECoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = CanadaECoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${CanadaECoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = CanadaECoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2G extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x1c;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Cannacoin Signed Message:\n';
static WIF_PREFIX = 0x9c;
}
class Cannacoin extends Cryptocurrency {
static NAME = 'Cannacoin';
static SYMBOL = 'CCN';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/cannacoin-official/Cannacoin',
WHITEPAPER: 'https://wiki.cannacoin.org/whitepaper.html',
WEBSITES: [
'https://cannacoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Cannacoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2G
});
static DEFAULT_NETWORK = Cannacoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Cannacoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Cannacoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Cannacoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Types extends NestedNamespace {
getCardanoTypes() {
return Object.values(this);
}
isCardanoType(type) {
return this.getCardanoTypes().includes(type);
}
}
class Mainnet$2F extends Network {
static NAME = 'mainnet';
static TYPE = 0x01;
static PAYMENT_ADDRESS_HRP = 'addr';
static REWARD_ADDRESS_HRP = 'stake';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0f4331d4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
}
class Testnet$o extends Network {
static NAME = 'testnet';
static TYPE = 0x00;
static PAYMENT_ADDRESS_HRP = 'addr_test';
static REWARD_ADDRESS_HRP = 'stake_test';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x04358394
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x043587cf
});
}
class Cardano extends Cryptocurrency {
static NAME = 'Cardano';
static SYMBOL = 'ADA';
static INFO = new Info({
SOURCE_CODE: 'https://cardanoupdates.com',
WHITEPAPER: 'https://docs.cardano.org/en/latest',
WEBSITES: [
'https://www.cardano.org'
]
});
static ECC = KholawEd25519ECC;
static COIN_TYPE = CoinTypes.Cardano;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$2F,
TESTNET: Testnet$o
});
static DEFAULT_NETWORK = Cardano.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds({
CARDANO: 'Cardano'
});
static HDS = new HDs({
CARDANO: 'Cardano'
});
static DEFAULT_HD = Cardano.HDS.CARDANO;
static DEFAULT_PATH = `m/44'/${Cardano.COIN_TYPE}'/0'/0/0`;
static TYPES = new Types({
BYRON_ICARUS: 'byron-icarus',
BYRON_LEDGER: 'byron-ledger',
BYRON_LEGACY: 'byron-legacy',
SHELLEY_ICARUS: 'shelley-icarus',
SHELLEY_LEDGER: 'shelley-ledger'
});
static ADDRESSES = new Addresses({
CARDANO: 'Cardano'
});
static DEFAULT_ADDRESS = Cardano.ADDRESSES.CARDANO;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static ADDRESS_TYPES = new AddressTypes({
PUBLIC_KEY: 'public-key',
REDEMPTION: 'redemption',
PAYMENT: 'payment',
STAKING: 'staking',
REWARD: 'reward'
});
static PARAMS = new Params({
PUBLIC_KEY_ADDRESS: 0x00,
REDEMPTION_ADDRESS: 0x02,
PAYMENT_PREFIX: 0x00,
REWARD_PREFIX: 0x0e
});
}
// SPDX-License-Identifier: MIT
class Mainnet$2E extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Celo extends Cryptocurrency {
static NAME = 'Celo';
static SYMBOL = 'CELO';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/celo-org/celo-monorepo',
WHITEPAPER: 'http://docs.celo.org',
WEBSITES: [
'https://celo.org',
'https://www.celocamp.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Celo;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$2E
});
static DEFAULT_NETWORK = Celo.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Celo.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Celo.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
ETHEREUM: 'Ethereum'
});
static DEFAULT_ADDRESS = Celo.ADDRESSES.ETHEREUM;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2D extends Network {
static NAME = 'mainnet';
static HRP = 'chihuahua';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Chihuahua extends Cryptocurrency {
static NAME = 'Chihuahua';
static SYMBOL = 'HUA';
static INFO = new Info({
WHITEPAPER: 'https://docs.chihuahua.army',
WEBSITES: [
'http://chihuahua.army'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Chihuahua;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$2D
});
static DEFAULT_NETWORK = Chihuahua.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Chihuahua.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Chihuahua.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
COSMOS: 'Cosmos'
});
static DEFAULT_ADDRESS = Chihuahua.ADDRESSES.COSMOS;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2C extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x89;
static SCRIPT_ADDRESS_PREFIX = 0x0d;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0xa8c17826,
P2SH: 0xa8c17826
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0xa8c26d64,
P2SH: 0xa8c26d64
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0x85;
}
class Clams extends Cryptocurrency {
static NAME = 'Clams';
static SYMBOL = 'CLAM';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/nochowderforyou/clams',
WEBSITES: [
'http://clamcoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Clams;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2C
});
static DEFAULT_NETWORK = Clams.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Clams.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Clams.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Clams.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2B extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x1c;
static SCRIPT_ADDRESS_PREFIX = 0x55;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18ClubCoin Signed Message:\n';
static WIF_PREFIX = 0x99;
}
class ClubCoin extends Cryptocurrency {
static NAME = 'Club-Coin';
static SYMBOL = 'CLUB';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/BitClubDev/ClubCoin',
WEBSITES: [
'http://clubcoin.co'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.ClubCoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2B
});
static DEFAULT_NETWORK = ClubCoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = ClubCoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${ClubCoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = ClubCoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2A extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x1c;
static SCRIPT_ADDRESS_PREFIX = 0x55;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18CompCoin Signed Message:\n';
static WIF_PREFIX = 0x9c;
}
class Compcoin extends Cryptocurrency {
static NAME = 'Compcoin';
static SYMBOL = 'CMP';
static INFO = new Info({
WEBSITES: [
'https://compcoin.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Compcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2A
});
static DEFAULT_NETWORK = Compcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Compcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Compcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Compcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2z extends Network {
static NAME = 'mainnet';
static HRP = 'cosmos';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Cosmos extends Cryptocurrency {
static NAME = 'Cosmos';
static SYMBOL = 'ATOM';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/cosmos',
WHITEPAPER: 'https://cosmos.network/resources/whitepaper',
WEBSITES: [
'https://cosmos.network'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Cosmos;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$2z
});
static DEFAULT_NETWORK = Cosmos.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Cosmos.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Cosmos.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
COSMOS: 'Cosmos'
});
static DEFAULT_ADDRESS = Cosmos.ADDRESSES.COSMOS;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2y extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x1c;
static SCRIPT_ADDRESS_PREFIX = 0x1e;
static HRP = 'cpu';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2
});
static MESSAGE_PREFIX = '\x1dCPUchain Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class CPUChain extends Cryptocurrency {
static NAME = 'CPU-Chain';
static SYMBOL = 'CPU';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/cpuchain/cpuchain',
WHITEPAPER: 'https://cpuchain.org/assets/v1.pdf',
WEBSITES: [
'https://cpuchain.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.CPUChain;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2y
});
static DEFAULT_NETWORK = CPUChain.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = CPUChain.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${CPUChain.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' }
]);
static DEFAULT_ADDRESS = CPUChain.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2x extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x1c;
static SCRIPT_ADDRESS_PREFIX = 0x0a;
static HRP = 'cp';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2
});
static MESSAGE_PREFIX = '\x18Bitcoin Signed Message:\n';
static WIF_PREFIX = 0x7b;
}
class CranePay extends Cryptocurrency {
static NAME = 'Crane-Pay';
static SYMBOL = 'CRP';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/cranepay/cranepay-core',
WEBSITES: [
'https://cranepay.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.CranePay;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2x
});
static DEFAULT_NETWORK = CranePay.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = CranePay.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${CranePay.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' }
]);
static DEFAULT_ADDRESS = CranePay.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2w extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x46;
static SCRIPT_ADDRESS_PREFIX = 0x55;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18DarkNet Signed Message:\n';
static WIF_PREFIX = 0x99;
}
class Crave extends Cryptocurrency {
static NAME = 'Crave';
static SYMBOL = 'CRAVE';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/Crave-Community-Project/Crave-Project',
WHITEPAPER: 'https://crave.cc/specifications',
WEBSITES: [
'https://crave.cc'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Crave;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2w
});
static DEFAULT_NETWORK = Crave.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Crave.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Crave.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Crave.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2v extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x4c;
static SCRIPT_ADDRESS_PREFIX = 0x10;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Bitcoin Signed Message:\n';
static WIF_PREFIX = 0xcc;
}
class Testnet$n extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x8c;
static SCRIPT_ADDRESS_PREFIX = 0x13;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x04358394,
P2SH: 0x04358394
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x043587cf,
P2SH: 0x043587cf
});
static MESSAGE_PREFIX = '\x18Bitcoin Signed Message:\n';
static WIF_PREFIX = 0xef;
}
class Dash extends Cryptocurrency {
static NAME = 'Dash';
static SYMBOL = 'DASH';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/dashpay/dash',
WHITEPAPER: 'https://docs.dash.org',
WEBSITES: [
'https://www.dash.org',
'https://newsroom.dash.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Dash;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2v,
TESTNET: Testnet$n
});
static DEFAULT_NETWORK = Dash.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Dash.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Dash.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Dash.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2u extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x1f;
static SCRIPT_ADDRESS_PREFIX = 0x4e;
static HRP = 'dpn';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x0488ade4,
P2WPKH_IN_P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x0488b21e,
P2WPKH_IN_P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18DeepOnion Signed Message:\n';
static WIF_PREFIX = 0x9f;
}
class DeepOnion extends Cryptocurrency {
static NAME = 'DeepOnion';
static SYMBOL = 'ONION';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/deeponion/deeponion',
WHITEPAPER: 'https://deeponion.org/White-Paper.pdf',
WEBSITES: [
'https://deeponion.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.DeepOnion;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2u
});
static DEFAULT_NETWORK = DeepOnion.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = DeepOnion.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${DeepOnion.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' }
]);
static DEFAULT_ADDRESS = DeepOnion.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2t extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x1e;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18defcoin Signed Message:\n';
static WIF_PREFIX = 0x9e;
}
class Defcoin extends Cryptocurrency {
static NAME = 'Defcoin';
static SYMBOL = 'DFC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/mspicer/Defcoin',
WEBSITES: [
'https://defcoin-ng.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Defcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2t
});
static DEFAULT_NETWORK = Defcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Defcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Defcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Defcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2s extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x1e;
static SCRIPT_ADDRESS_PREFIX = 0x5a;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x19Denarius Signed Message:\n';
static WIF_PREFIX = 0x9e;
}
class Denarius extends Cryptocurrency {
static NAME = 'Denarius';
static SYMBOL = 'DNR';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/metaspartan/denarius',
WHITEPAPER: 'https://denarius.io/wp-content/uploads/2020/06/whitescroll.pdf',
WEBSITES: [
'https://denarius.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Denarius;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2s
});
static DEFAULT_NETWORK = Denarius.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Denarius.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Denarius.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Denarius.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2r extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x5a;
static SCRIPT_ADDRESS_PREFIX = 0x08;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Diamond Signed Message:\n';
static WIF_PREFIX = 0xda;
}
class Diamond extends Cryptocurrency {
static NAME = 'Diamond';
static SYMBOL = 'DMD';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/DMDcoin/Diamond',
WHITEPAPER: 'https://bit.diamonds/DMD_WP.pdf',
WEBSITES: [
'http://bit.diamonds'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Diamond;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2r
});
static DEFAULT_NETWORK = Diamond.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Diamond.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Diamond.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Diamond.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2q extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x1e;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static HRP = 'dgb';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2
});
static MESSAGE_PREFIX = '\x19DigiByte Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class DigiByte extends Cryptocurrency {
static NAME = 'Digi-Byte';
static SYMBOL = 'DGB';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/DigiByte-Core/digibyte',
WHITEPAPER: 'https://digibyte.io/docs/infopaper.pdf',
WEBSITES: [
'https://digibyte.org',
'https://dgbwiki.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.DigiByte;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2q
});
static DEFAULT_NETWORK = DigiByte.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = DigiByte.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${DigiByte.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' }
]);
static DEFAULT_ADDRESS = DigiByte.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2p extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x1e;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x9e0488b2,
P2SH: 0x9e0488b2
});
static MESSAGE_PREFIX = '\x18Digitalcoin Signed Message:\n';
static WIF_PREFIX = 0x9e;
}
class Digitalcoin extends Cryptocurrency {
static NAME = 'Digitalcoin';
static SYMBOL = 'DGC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/lomtax/digitalcoin',
WHITEPAPER: 'https://github.com/lomtax/digitalcoin/blob/master/README.md',
WEBSITES: [
'http://digitalcoin.co',
'https://digitalcoin.tech'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Digitalcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2p
});
static DEFAULT_NETWORK = Digitalcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Digitalcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Digitalcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Digitalcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2o extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x1e;
static SCRIPT_ADDRESS_PREFIX = 0x0d;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0221312b,
P2SH: 0x0221312b
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x022d2533,
P2SH: 0x022d2533
});
static MESSAGE_PREFIX = '\x19Divi Signed Message:\n';
static WIF_PREFIX = 0xd4;
}
class Testnet$m extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x1e;
static SCRIPT_ADDRESS_PREFIX = 0x0d;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x3a805837,
P2SH: 0x3a805837
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x3a8061a0,
P2SH: 0x3a8061a0
});
static MESSAGE_PREFIX = '\x19Divi Signed Message:\n';
static WIF_PREFIX = 0xd4;
}
class Divi extends Cryptocurrency {
static NAME = 'Divi';
static SYMBOL = 'DIVI';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/Divicoin/Divi',
WHITEPAPER: 'https://wiki.diviproject.org/#whitepaper',
WEBSITES: [
'https://www.diviproject.org',
'https://diviwallet.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Divi;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2o,
TESTNET: Testnet$m
});
static DEFAULT_NETWORK = Divi.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Divi.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Divi.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Divi.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2n extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x1e;
static SCRIPT_ADDRESS_PREFIX = 0x16;
static HRP = 'dogecoin';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
DOGECOIN: 0x02fac398,
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
DOGECOIN: 0x02facafd,
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2
});
static MESSAGE_PREFIX = '\x19Dogecoin Signed Message:\n';
static WIF_PREFIX = 0xf1;
}
class Testnet$l extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x71;
static SCRIPT_ADDRESS_PREFIX = 0xc4;
static HRP = 'dogecointestnet';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
DOGECOIN: 0x04358394,
P2PKH: 0x04358394,
P2SH: 0x04358394,
P2WPKH: 0x04358394,
P2WPKH_IN_P2SH: 0x04358394
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
DOGECOIN: 0x043587cf,
P2PKH: 0x043587cf,
P2SH: 0x043587cf,
P2WPKH: 0x043587cf,
P2WPKH_IN_P2SH: 0x043587cf
});
static MESSAGE_PREFIX = '\x19Dogecoin Signed Message:\n';
static WIF_PREFIX = 0xf1;
}
class Dogecoin extends Cryptocurrency {
static NAME = 'Dogecoin';
static SYMBOL = 'DOGE';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/dogecoin/dogecoin',
WHITEPAPER: 'https://github.com/dogecoin/dogecoin/blob/master/README.md',
WEBSITES: [
'http://dogecoin.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Dogecoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2n,
TESTNET: Testnet$l
});
static DEFAULT_NETWORK = Dogecoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Dogecoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Dogecoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' }
]);
static DEFAULT_ADDRESS = Dogecoin.ADDRESSES.P2PKH;
static SEMANTICS = ['dogecoin', 'p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh'];
static DEFAULT_SEMANTIC = 'dogecoin';
}
// SPDX-License-Identifier: MIT
class Mainnet$2m extends Network {
static NAME = 'mainnet';
static HRP = 'dydx';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class dYdX extends Cryptocurrency {
static NAME = 'dYdX';
static SYMBOL = 'DYDX';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/dydxprotocol',
WEBSITES: [
'https://dydx.exchange'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.dYdX;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$2m
});
static DEFAULT_NETWORK = dYdX.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = dYdX.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${dYdX.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
COSMOS: 'Cosmos'
});
static DEFAULT_ADDRESS = dYdX.ADDRESSES.COSMOS;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2l extends Network {
static NAME = 'mainnet';
static LEGACY_PUBLIC_KEY_ADDRESS_PREFIX = 0x00;
static LEGACY_SCRIPT_ADDRESS_PREFIX = 0x05;
static STD_PUBLIC_KEY_ADDRESS_PREFIX = 0x00;
static STD_SCRIPT_ADDRESS_PREFIX = 0x08;
static HRP = 'ecash';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878,
P2WSH: 0x02aa7a99,
P2WSH_IN_P2SH: 0x0295b005
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2,
P2WSH: 0x02aa7ed3,
P2WSH_IN_P2SH: 0x0295b43f
});
static WIF_PREFIX = 0x80;
}
class Testnet$k extends Network {
static NAME = 'testnet';
static LEGACY_PUBLIC_KEY_ADDRESS_PREFIX = 0x6f;
static LEGACY_SCRIPT_ADDRESS_PREFIX = 0xc4;
static STD_PUBLIC_KEY_ADDRESS_PREFIX = 0x00;
static STD_SCRIPT_ADDRESS_PREFIX = 0x08;
static HRP = 'ectest';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x04358394,
P2SH: 0x04358394,
P2WPKH: 0x045f18bc,
P2WPKH_IN_P2SH: 0x044a4e28,
P2WSH: 0x02575048,
P2WSH_IN_P2SH: 0x024285b5
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x043587cf,
P2SH: 0x043587cf,
P2WPKH: 0x045f1cf6,
P2WPKH_IN_P2SH: 0x044a5262,
P2WSH: 0x02575483,
P2WSH_IN_P2SH: 0x024289ef
});
static WIF_PREFIX = 0xef;
}
class eCash extends Cryptocurrency {
static NAME = 'eCash';
static SYMBOL = 'XEC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/bitcoin-abc',
WEBSITES: [
'https://e.cash'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.eCash;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$2l,
TESTNET: Testnet$k
});
static DEFAULT_NETWORK = eCash.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = eCash.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${eCash.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' },
'P2WSH',
{ P2WSH_IN_P2SH: 'P2WSH-In-P2SH' }
]);
static DEFAULT_ADDRESS = eCash.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh', 'p2wsh', 'p2wsh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static ADDRESS_TYPES = new AddressTypes({
STD: 'std',
LEGACY: 'legacy'
});
static DEFAULT_ADDRESS_TYPE = eCash.ADDRESS_TYPES.STD;
}
// SPDX-License-Identifier: MIT
class Mainnet$2k extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x5c;
static SCRIPT_ADDRESS_PREFIX = 0x14;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18eCoin Signed Message:\n';
static WIF_PREFIX = 0xdc;
}
class ECoin extends Cryptocurrency {
static NAME = 'E-Coin';
static SYMBOL = 'ECN';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/ecoinclub/ecoin',
WEBSITES: [
'https://www.ecoinsource.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.ECoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2k
});
static DEFAULT_NETWORK = ECoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = ECoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${ECoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = ECoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2j extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x5d;
static SCRIPT_ADDRESS_PREFIX = 0x1c;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18EDRcoin Signed Message:\n';
static WIF_PREFIX = 0xdd;
}
class EDRCoin extends Cryptocurrency {
static NAME = 'EDR-Coin';
static SYMBOL = 'EDRC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/EDRCoin/EDRcoin-src',
WEBSITES: [
'https://www.edrcoin.cash',
'https://edrcoin.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.EDRCoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2j
});
static DEFAULT_NETWORK = EDRCoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = EDRCoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${EDRCoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = EDRCoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2i extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x30;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Egulden Signed Message:\n';
static WIF_PREFIX = 0xb0;
}
class eGulden extends Cryptocurrency {
static NAME = 'e-Gulden';
static SYMBOL = 'EFL';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/Electronic-Gulden-Foundation/egulden',
WEBSITES: [
'http://www.e-gulden.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.eGulden;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2i
});
static DEFAULT_NETWORK = eGulden.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = eGulden.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${eGulden.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = eGulden.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2h extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x21;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Einsteinium Signed Message:\n';
static WIF_PREFIX = 0xa1;
}
class Einsteinium extends Cryptocurrency {
static NAME = 'Einsteinium';
static SYMBOL = 'EMC2';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/emc2foundation/einsteinium',
WHITEPAPER: 'https://www.emc2.foundation/coin-specification',
WEBSITES: [
'https://www.emc2.foundation'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Einsteinium;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2h
});
static DEFAULT_NETWORK = Einsteinium.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Einsteinium.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Einsteinium.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Einsteinium.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2g extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x21;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0x80;
}
class Elastos extends Cryptocurrency {
static NAME = 'Elastos';
static SYMBOL = 'ELA';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/elastos',
WHITEPAPER: 'https://www.elastos.org/downloads/elastos_whitepaper_en.pdf',
WEBSITES: [
'https://elastos.info',
'https://elastos.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Elastos;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2g
});
static DEFAULT_NETWORK = Elastos.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Elastos.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Elastos.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Elastos.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2f extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x21;
static SCRIPT_ADDRESS_PREFIX = 0x35;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0xd7dc6e9f,
P2SH: 0xd7dc6e9f
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x03b8c856,
P2SH: 0x03b8c856
});
static MESSAGE_PREFIX = 'DarkCoin Signed Message:\n';
static WIF_PREFIX = 0x6a;
}
class Energi extends Cryptocurrency {
static NAME = 'Energi';
static SYMBOL = 'NRG';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/energcryptocurrency/go-energi',
WHITEPAPER: 'https://www.energi.world/whitepaper',
WEBSITES: [
'https://energi.world',
'https://www.energiswap.exchange'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Energi;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2f
});
static DEFAULT_NETWORK = Energi.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Energi.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Energi.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Energi.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2e extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class EOS extends Cryptocurrency {
static NAME = 'EOS';
static SYMBOL = 'EOS';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/AntelopeIO/leap',
WHITEPAPER: 'https://eosnetwork.com/blog/category/eos-blue-papers',
WEBSITES: [
'https://eosnetwork.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.EOS;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$2e
});
static DEFAULT_NETWORK = EOS.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = EOS.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${EOS.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'EOS'
]);
static DEFAULT_ADDRESS = EOS.ADDRESSES.EOS;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static PARAMS = new Params({
ADDRESS_PREFIX: 'EOS',
CHECKSUM_LENGTH: 0x04
});
}
// SPDX-License-Identifier: MIT
class Mainnet$2d extends Network {
static NAME = 'mainnet';
static TYPE = 0x00;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Testnet$j extends Network {
static NAME = 'testnet';
static TYPE = 0x10;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x04358394
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x043587cf
});
static WIF_PREFIX = 0xef;
}
class Ergo extends Cryptocurrency {
static NAME = 'Ergo';
static SYMBOL = 'ERG';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/ergoplatform/ergo',
WHITEPAPER: 'https://ergoplatform.org/en/documents',
WEBSITES: [
'https://ergoplatform.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Ergo;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$2d,
TESTNET: Testnet$j
});
static DEFAULT_NETWORK = Ergo.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Ergo.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Ergo.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
ERGO: 'Ergo'
});
static DEFAULT_ADDRESS = Ergo.ADDRESSES.ERGO;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static ADDRESS_TYPES = new AddressTypes({
P2PKH: 'p2pkh',
P2SH: 'p2sh'
});
static DEFAULT_ADDRESS_TYPE = Ergo.ADDRESS_TYPES.P2PKH;
static PARAMS = new Params({
CHECKSUM_LENGTH: 0x04,
ADDRESS_TYPES: {
P2PKH: 0x01,
P2SH: 0x02
}
});
}
// SPDX-License-Identifier: MIT
class Mainnet$2c extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Ethereum extends Cryptocurrency {
static NAME = 'Ethereum';
static SYMBOL = 'ETH';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/ethereum/go-ethereum',
WHITEPAPER: 'https://github.com/ethereum/wiki/wiki/White-Paper',
WEBSITES: [
'https://www.ethereum.org',
'https://en.wikipedia.org/wiki/Ethereum'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Ethereum;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$2c
});
static DEFAULT_NETWORK = Ethereum.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Ethereum.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Ethereum.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
ETHEREUM: 'Ethereum'
});
static DEFAULT_ADDRESS = Ethereum.ADDRESSES.ETHEREUM;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static PARAMS = new Params({
ADDRESS_PREFIX: '0x'
});
}
// SPDX-License-Identifier: MIT
class Mainnet$2b extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x21;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Bitcoin Signed Message:\n';
static WIF_PREFIX = 0xa8;
}
class EuropeCoin extends Cryptocurrency {
static NAME = 'Europe-Coin';
static SYMBOL = 'ERC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/LIMXTEC/Europecoin-V3',
WHITEPAPER: 'https://www.europecoin.eu.org/projects-2/37-specifications',
WEBSITES: [
'https://www.europecoin.eu.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.EuropeCoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2b
});
static DEFAULT_NETWORK = EuropeCoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = EuropeCoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${EuropeCoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = EuropeCoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2a extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x21;
static SCRIPT_ADDRESS_PREFIX = 0x5c;
static HRP = 'ev';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x0b,
P2WSH: 0x0b
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878,
P2WSH: 0x02aa7a99,
P2WSH_IN_P2SH: 0x0295b005
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2,
P2WSH: 0x02aa7ed3,
P2WSH_IN_P2SH: 0x0295b43f
});
static MESSAGE_PREFIX = 'Evrmore Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Testnet$i extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x6f;
static SCRIPT_ADDRESS_PREFIX = 0xc4;
static HRP = 'te';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878,
P2WSH: 0x02aa7a99,
P2WSH_IN_P2SH: 0x0295b005
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2,
P2WSH: 0x02aa7ed3,
P2WSH_IN_P2SH: 0x0295b43f
});
static MESSAGE_PREFIX = 'Evrmore Signed Message:\n';
static WIF_PREFIX = 0xef;
}
class Evrmore extends Cryptocurrency {
static NAME = 'Evrmore';
static SYMBOL = 'EVR';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/EvrmoreOrg/Evrmore',
WHITEPAPER: 'https://github.com/EvrmoreOrg/whitepaper',
WEBSITES: [
'https://evrmorecoin.org/'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Evrmore;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2a,
TESTNET: Testnet$i
});
static DEFAULT_NETWORK = Evrmore.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Evrmore.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Evrmore.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' },
'P2WSH',
{ P2WSH_IN_P2SH: 'P2WSH-In-P2SH' }
]);
static DEFAULT_ADDRESS = Evrmore.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh', 'p2wsh', 'p2wsh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$29 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x21;
static SCRIPT_ADDRESS_PREFIX = 0x89;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18ExclusiveCoin Signed Message:\n';
static WIF_PREFIX = 0xa1;
}
class ExclusiveCoin extends Cryptocurrency {
static NAME = 'Exclusive-Coin';
static SYMBOL = 'EXCL';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/exclfork/excl-core',
WEBSITES: [
'https://exclusivecoin.pw'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.ExclusiveCoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$29
});
static DEFAULT_NETWORK = ExclusiveCoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = ExclusiveCoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${ExclusiveCoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = ExclusiveCoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$28 extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Fantom extends Cryptocurrency {
static NAME = 'Fantom';
static SYMBOL = 'FTM';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/Fantom-foundation/go-opera',
WHITEPAPER: 'https://fantom.foundation/fantom-research-papers',
WEBSITES: [
'https://fantom.foundation'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Fantom;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$28
});
static DEFAULT_NETWORK = Fantom.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Fantom.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Fantom.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
ETHEREUM: 'Ethereum'
});
static DEFAULT_ADDRESS = Fantom.ADDRESSES.ETHEREUM;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$27 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x0e;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488daee,
P2SH: 0x0488daee
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488bc26,
P2SH: 0x0488bc26
});
static MESSAGE_PREFIX = '\x18Feathercoin Signed Message:\n';
static WIF_PREFIX = 0x8e;
}
class Feathercoin extends Cryptocurrency {
static NAME = 'Feathercoin';
static SYMBOL = 'FTC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/FeatherCoin/Feathercoin',
WHITEPAPER: 'https://feathercoin.com/about',
WEBSITES: [
'http://feathercoin.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Feathercoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$27
});
static DEFAULT_NETWORK = Feathercoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Feathercoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Feathercoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Feathercoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$26 extends Network {
static NAME = 'mainnet';
static HRP = 'fetch';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class FetchAI extends Cryptocurrency {
static NAME = 'Fetch.ai';
static SYMBOL = 'FET';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/fetchai',
WHITEPAPER: 'https://www.dropbox.com/s/gxptsecwdl3jjtn/David%20Minarsch%20-%202021-04-26%2010.34.17%20-%20paper_21_finalversion.pdf?dl=0',
WEBSITES: [
'https://fetch-ai.network',
'https://docs.fetch.ai'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.FetchAI;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$26
});
static DEFAULT_NETWORK = FetchAI.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = FetchAI.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${FetchAI.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
COSMOS: 'Cosmos'
});
static DEFAULT_ADDRESS = FetchAI.ADDRESSES.COSMOS;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$25 extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Filecoin extends Cryptocurrency {
static NAME = 'Filecoin';
static SYMBOL = 'FIL';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/filecoin-project',
WHITEPAPER: 'https://docs.filecoin.io',
WEBSITES: [
'https://filecoin.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Filecoin;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$25
});
static DEFAULT_NETWORK = Filecoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Filecoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Filecoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
FILECOIN: 'Filecoin'
});
static DEFAULT_ADDRESS = Filecoin.ADDRESSES.FILECOIN;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static ADDRESS_TYPES = new AddressTypes({
SECP256K1: 'secp256k1',
BLS: 'bls'
});
static DEFAULT_ADDRESS_TYPE = Filecoin.ADDRESS_TYPES.SECP256K1;
static PARAMS = new Params({
ALPHABET: 'abcdefghijklmnopqrstuvwxyz234567',
ADDRESS_PREFIX: 'f',
ADDRESS_TYPES: {
SECP256K1: 0x01,
BLS: 0x03
}
});
}
// SPDX-License-Identifier: MIT
class Mainnet$24 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x52;
static SCRIPT_ADDRESS_PREFIX = 0x07;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Firo Signed Message:\n';
static WIF_PREFIX = 0xd2;
}
class Firo extends Cryptocurrency {
static NAME = 'Firo';
static SYMBOL = 'FIRO';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/firoorg/firo',
WEBSITES: [
'https://firo.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Firo;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$24
});
static DEFAULT_NETWORK = Firo.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Firo.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Firo.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Firo.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$23 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x23;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18FirstCoin Signed Message:\n';
static WIF_PREFIX = 0xa3;
}
class Firstcoin extends Cryptocurrency {
static NAME = 'Firstcoin';
static SYMBOL = 'FRST';
static INFO = new Info({
WHITEPAPER: 'https://first-coin-club.blogspot.com/2017/11/whitepaper.html',
WEBSITES: [
'https://firstcoinproject.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Firstcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$23
});
static DEFAULT_NETWORK = Firstcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Firstcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Firstcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Firstcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$22 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x23;
static SCRIPT_ADDRESS_PREFIX = 0x5f;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0221312b,
P2SH: 0x0221312b
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x022d2533,
P2SH: 0x022d2533
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0x3c;
}
class Testnet$h extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x4c;
static SCRIPT_ADDRESS_PREFIX = 0x89;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x3a805837,
P2SH: 0x3a805837
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x3a8061a0,
P2SH: 0x3a8061a0
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0xed;
}
class FIX extends Cryptocurrency {
static NAME = 'FIX';
static SYMBOL = 'FIX';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/NewCapital/FIX-Core',
WEBSITES: [
'https://fix.network'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.FIX;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$22,
TESTNET: Testnet$h
});
static DEFAULT_NETWORK = FIX.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = FIX.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${FIX.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = FIX.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$21 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x44;
static SCRIPT_ADDRESS_PREFIX = 0x82;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Flashcoin Signed Message:\n';
static WIF_PREFIX = 0xc4;
}
class Flashcoin extends Cryptocurrency {
static NAME = 'Flashcoin';
static SYMBOL = 'FLASH';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/flash-coin',
WHITEPAPER: 'https://www.flashcoin.io/docs/FLASHWhitepaper.pdf',
WEBSITES: [
'https://flashcoin.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Flashcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$21
});
static DEFAULT_NETWORK = Flashcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Flashcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Flashcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Flashcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$20 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x00001cb8;
static SCRIPT_ADDRESS_PREFIX = 0x00001cbd;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Zelcash Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Flux extends Cryptocurrency {
static NAME = 'Flux';
static SYMBOL = 'FLUX';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/RunOnFlux/fluxd',
WHITEPAPER: 'https://fluxwhitepaper.app.runonflux.io',
WEBSITES: [
'https://runonflux.io',
'https://home.runonflux.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Flux;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$20
});
static DEFAULT_NETWORK = Flux.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Flux.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Flux.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Flux.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1$ extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x23;
static SCRIPT_ADDRESS_PREFIX = 0x1e;
static HRP = 'fx';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878,
P2WSH: 0x02aa7a99,
P2WSH_IN_P2SH: 0x0295b005
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2,
P2WSH: 0x02aa7ed3,
P2WSH_IN_P2SH: 0x0295b43f
});
static MESSAGE_PREFIX = 'Foxdcoin Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Testnet$g extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x5f;
static SCRIPT_ADDRESS_PREFIX = 0x5a;
static HRP = 'tf';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878,
P2WSH: 0x02aa7a99,
P2WSH_IN_P2SH: 0x0295b005
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2,
P2WSH: 0x02aa7ed3,
P2WSH_IN_P2SH: 0x0295b43f
});
static MESSAGE_PREFIX = 'Foxdcoin Signed Message:\n';
static WIF_PREFIX = 0xef;
}
class Foxdcoin extends Cryptocurrency {
static NAME = 'Foxdcoin';
static SYMBOL = 'FOXD';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/foxdproject/foxdcoin',
WEBSITES: [
'https://www.foxdcoin.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Foxdcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1$,
TESTNET: Testnet$g
});
static DEFAULT_NETWORK = Foxdcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Foxdcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Foxdcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' },
'P2WSH',
{ P2WSH_IN_P2SH: 'P2WSH-In-P2SH' }
]);
static DEFAULT_ADDRESS = Foxdcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh', 'p2wsh', 'p2wsh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1_ extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x24;
static SCRIPT_ADDRESS_PREFIX = 0x10;
static HRP = 'fc';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2
});
static MESSAGE_PREFIX = '\x19FujiCoin Signed Message:\n';
static WIF_PREFIX = 0xa4;
}
class FujiCoin extends Cryptocurrency {
static NAME = 'Fuji-Coin';
static SYMBOL = 'FJC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/fujicoin/fujicoin',
WHITEPAPER: 'https://www.fujicoin.org/what-is-fujicoin.php',
WEBSITES: [
'https://www.fujicoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.FujiCoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1_
});
static DEFAULT_NETWORK = FujiCoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = FujiCoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${FujiCoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' }
]);
static DEFAULT_ADDRESS = FujiCoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1Z extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x26;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0xa6;
}
class GameCredits extends Cryptocurrency {
static NAME = 'Game-Credits';
static SYMBOL = 'GAME';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/gamecredits-project/GameCredits',
WEBSITES: [
'https://gamecredits.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.GameCredits;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1Z
});
static DEFAULT_NETWORK = GameCredits.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = GameCredits.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${GameCredits.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = GameCredits.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1Y extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x26;
static SCRIPT_ADDRESS_PREFIX = 0x61;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18GCR Signed Message:\n';
static WIF_PREFIX = 0x9a;
}
class GCRCoin extends Cryptocurrency {
static NAME = 'GCR-Coin';
static SYMBOL = 'GCR';
static INFO = new Info({
WEBSITES: [
'https://globalcoinresearch.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.GCRCoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1Y
});
static DEFAULT_NETWORK = GCRCoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = GCRCoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${GCRCoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = GCRCoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1X extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x26;
static SCRIPT_ADDRESS_PREFIX = 0x0a;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18DarkCoin Signed Message:\n';
static WIF_PREFIX = 0xc6;
}
class GoByte extends Cryptocurrency {
static NAME = 'Go-Byte';
static SYMBOL = 'GBX';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/gobytecoin/gobyte',
WHITEPAPER: 'https://gobyte-coin.readthedocs.io/en/latest/index.html',
WEBSITES: [
'https://gobyte.network'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.GoByte;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1X
});
static DEFAULT_NETWORK = GoByte.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = GoByte.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${GoByte.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = GoByte.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1W extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x3e;
static SCRIPT_ADDRESS_PREFIX = 0x55;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Gridcoin Signed Message:\n';
static WIF_PREFIX = 0xbe;
}
class Gridcoin extends Cryptocurrency {
static NAME = 'Gridcoin';
static SYMBOL = 'GRC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/gridcoin-community/Gridcoin-Research',
WHITEPAPER: 'https://www.gridcoin.us/assets/img/whitepaper.pdf',
WEBSITES: [
'http://www.gridcoin.us'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Gridcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1W
});
static DEFAULT_NETWORK = Gridcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Gridcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Gridcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Gridcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1V extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x24;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static HRP = 'grs';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2
});
static MESSAGE_PREFIX = '\x19GroestlCoin Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Testnet$f extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x6f;
static SCRIPT_ADDRESS_PREFIX = 0xc4;
static HRP = 'tgrs';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x04358394,
P2SH: 0x04358394,
P2WPKH: 0x045f18bc,
P2WPKH_IN_P2SH: 0x044a4e28
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x043587cf,
P2SH: 0x043587cf,
P2WPKH: 0x045f1cf6,
P2WPKH_IN_P2SH: 0x044a5262
});
static MESSAGE_PREFIX = '\x19GroestlCoin Signed Message:\n';
static WIF_PREFIX = 0xef;
}
class GroestlCoin extends Cryptocurrency {
static NAME = 'Groestl-Coin';
static SYMBOL = 'GRS';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/Groestlcoin/groestlcoin',
WHITEPAPER: 'http://www.groestl.info/groestl-implementation-guide.pdf',
WEBSITES: [
'https://www.groestlcoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.GroestlCoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1V,
TESTNET: Testnet$f
});
static DEFAULT_NETWORK = GroestlCoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = GroestlCoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${GroestlCoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' }
]);
static DEFAULT_ADDRESS = GroestlCoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1U extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x26;
static SCRIPT_ADDRESS_PREFIX = 0x62;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Guldencoin Signed Message:\n';
static WIF_PREFIX = 0x62;
}
class Gulden extends Cryptocurrency {
static NAME = 'Gulden';
static SYMBOL = 'NLG';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/Gulden/gulden-old',
WEBSITES: [
'https://gulden.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Gulden;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1U
});
static DEFAULT_NETWORK = Gulden.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Gulden.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Gulden.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Gulden.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1T extends Network {
static NAME = 'mainnet';
static HRP = 'one';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Harmony extends Cryptocurrency {
static NAME = 'Harmony';
static SYMBOL = 'ONE';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/harmony-one/harmony',
WHITEPAPER: 'https://harmony.one/whitepaper.pdf',
WEBSITES: [
'https://www.harmony.one',
'https://t.me/harmony_announcements'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Harmony;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$1T
});
static DEFAULT_NETWORK = Harmony.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Harmony.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Harmony.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
HARMONY: 'Harmony'
});
static DEFAULT_ADDRESS = Harmony.ADDRESSES.HARMONY;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1S extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x30;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18helleniccoin Signed Message:\n';
static WIF_PREFIX = 0xb0;
}
class Helleniccoin extends Cryptocurrency {
static NAME = 'Helleniccoin';
static SYMBOL = 'HNC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/hnc-coin/hnc-coin',
WHITEPAPER: 'https://hnc-coin.com/hnc_whitepaper.pdf',
WEBSITES: [
'https://hnc-coin.com',
'http://www.helleniccoin.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Helleniccoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1S
});
static DEFAULT_NETWORK = Helleniccoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Helleniccoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Helleniccoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Helleniccoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1R extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x28;
static SCRIPT_ADDRESS_PREFIX = 0x08;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Hempcoin Signed Message:\n';
static WIF_PREFIX = 0xa8;
}
class Hempcoin extends Cryptocurrency {
static NAME = 'Hempcoin';
static SYMBOL = 'THC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/jl777/komodo',
WHITEPAPER: 'https://hempcoin.org/thc-whitepaper.html',
WEBSITES: [
'http://hempcoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Hempcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1R
});
static DEFAULT_NETWORK = Hempcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Hempcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Hempcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Hempcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1Q extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x00002089;
static SCRIPT_ADDRESS_PREFIX = 0x00002096;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Zcash Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Horizen extends Cryptocurrency {
static NAME = 'Horizen';
static SYMBOL = 'ZEN';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/HorizenOfficial/zen',
WHITEPAPER: 'https://www.horizen.io/research',
WEBSITES: [
'https://www.horizen.io',
'https://academy.horizen.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Horizen;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1Q
});
static DEFAULT_NETWORK = Horizen.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Horizen.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Horizen.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Horizen.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1P extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class HuobiToken extends Cryptocurrency {
static NAME = 'Huobi-Token';
static SYMBOL = 'HT';
static INFO = new Info({
WEBSITES: [
'https://www.huobi.com/en-us',
'https://www.huobiwallet.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.HuobiToken;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$1P
});
static DEFAULT_NETWORK = HuobiToken.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = HuobiToken.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${HuobiToken.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
ETHEREUM: 'Ethereum'
});
static DEFAULT_ADDRESS = HuobiToken.ADDRESSES.ETHEREUM;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1O extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x00001cb8;
static SCRIPT_ADDRESS_PREFIX = 0x00001cbd;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Hush Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Hush extends Cryptocurrency {
static NAME = 'Hush';
static SYMBOL = 'HUSH';
static INFO = new Info({
SOURCE_CODE: 'https://git.hush.is/hush/hush3',
WHITEPAPER: 'https://git.hush.is',
WEBSITES: [
'https://hush.is',
'https://hush.land'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Hush;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1O
});
static DEFAULT_NETWORK = Hush.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Hush.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Hush.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Hush.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1N extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Icon extends Cryptocurrency {
static NAME = 'Icon';
static SYMBOL = 'ICX';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/icon-project',
WHITEPAPER: 'https://icondev.io',
WEBSITES: [
'https://www.icon.foundation',
'https://icon.community'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Icon;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$1N
});
static DEFAULT_NETWORK = Icon.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Icon.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Icon.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
ICON: 'Icon'
});
static DEFAULT_ADDRESS = Icon.ADDRESSES.ICON;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static PARAMS = new Params({
ADDRESS_PREFIX: 'hx',
KEY_HASH_LENGTH: 0x14
});
}
// SPDX-License-Identifier: MIT
class Mainnet$1M extends Network {
static NAME = 'mainnet';
static HRP = 'inj';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Injective extends Cryptocurrency {
static NAME = 'Injective';
static SYMBOL = 'INJ';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/InjectiveLabs',
WHITEPAPER: 'https://docs.injectiveprotocol.com/#introduction',
WEBSITES: [
'https://injective.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Injective;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$1M
});
static DEFAULT_NETWORK = Injective.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Injective.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Injective.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
INJECTIVE: 'Injective'
});
static DEFAULT_ADDRESS = Injective.ADDRESSES.INJECTIVE;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1L extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x66;
static SCRIPT_ADDRESS_PREFIX = 0x39;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18INSaNe Signed Message:\n';
static WIF_PREFIX = 0x37;
}
class InsaneCoin extends Cryptocurrency {
static NAME = 'InsaneCoin';
static SYMBOL = 'INSN';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/CryptoCoderz/INSN',
WHITEPAPER: 'https://insane.network/velocity-bluepaper',
WEBSITES: [
'https://insane.network'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.InsaneCoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1L
});
static DEFAULT_NETWORK = InsaneCoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = InsaneCoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${InsaneCoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = InsaneCoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1K extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x75;
static SCRIPT_ADDRESS_PREFIX = 0xae;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0xae3416f6,
P2SH: 0xae3416f6
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x2780915f,
P2SH: 0x2780915f
});
static MESSAGE_PREFIX = '\x18IoP Signed Message:\n';
static WIF_PREFIX = 0x31;
}
class InternetOfPeople extends Cryptocurrency {
static NAME = 'Internet-Of-People';
static SYMBOL = 'IOP';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/Internet-of-People',
WHITEPAPER: 'https://iop.global/whitepaper',
WEBSITES: [
'http://iop.global'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.InternetOfPeople;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1K
});
static DEFAULT_NETWORK = InternetOfPeople.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = InternetOfPeople.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${InternetOfPeople.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = InternetOfPeople.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1J extends Network {
static NAME = 'mainnet';
static HRP = 'iaa';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class IRISnet extends Cryptocurrency {
static NAME = 'IRISnet';
static SYMBOL = 'IRIS';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/irisnet',
WHITEPAPER: 'https://www.irisnet.org/docs/resources/whitepaper-en.html',
WEBSITES: [
'https://www.irisnet.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.IRISnet;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$1J
});
static DEFAULT_NETWORK = IRISnet.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = IRISnet.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${IRISnet.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
COSMOS: 'Cosmos'
});
static DEFAULT_ADDRESS = IRISnet.ADDRESSES.COSMOS;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1I extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x8a;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Ixcoin Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class IXCoin extends Cryptocurrency {
static NAME = 'IX-Coin';
static SYMBOL = 'IXC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/ixcore/ixcoin',
WHITEPAPER: 'https://www.scribd.com/document/357320345/Ixc-White-Paper-v3',
WEBSITES: [
'https://www.ixcoin.net'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.IXCoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1I
});
static DEFAULT_NETWORK = IXCoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = IXCoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${IXCoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = IXCoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1H extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x2b;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x037a6460,
P2SH: 0x037a6460
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x037a689a,
P2SH: 0x037a689a
});
static MESSAGE_PREFIX = '\x19Jumbucks Signed Message:\n';
static WIF_PREFIX = 0xab;
}
class Jumbucks extends Cryptocurrency {
static NAME = 'Jumbucks';
static SYMBOL = 'JBS';
static INFO = new Info({
WEBSITES: [
'http://getjumbucks.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Jumbucks;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1H
});
static DEFAULT_NETWORK = Jumbucks.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Jumbucks.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Jumbucks.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Jumbucks.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1G extends Network {
static NAME = 'mainnet';
static HRP = 'kava';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Kava extends Cryptocurrency {
static NAME = 'Kava';
static SYMBOL = 'KAVA';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/kava-labs',
WHITEPAPER: 'https://docsend.com/view/gwbwpc3',
WEBSITES: [
'https://www.kava.io',
'https://app.kava.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Kava;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$1G
});
static DEFAULT_NETWORK = Kava.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Kava.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Kava.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
COSMOS: 'Cosmos'
});
static DEFAULT_ADDRESS = Kava.ADDRESSES.COSMOS;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1F extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x23;
static SCRIPT_ADDRESS_PREFIX = 0x1c;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Kobocoin Signed Message:\n';
static WIF_PREFIX = 0xa3;
}
class Kobocoin extends Cryptocurrency {
static NAME = 'Kobocoin';
static SYMBOL = 'KOBO';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/kobocoin/Kobocoin',
WHITEPAPER: 'https://kobocoin.com/Tech.html',
WEBSITES: [
'http://kobocoin.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Kobocoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1F
});
static DEFAULT_NETWORK = Kobocoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Kobocoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Kobocoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Kobocoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1E extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x3c;
static SCRIPT_ADDRESS_PREFIX = 0x55;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Komodo Signed Message:\n';
static WIF_PREFIX = 0xbc;
}
class Komodo extends Cryptocurrency {
static NAME = 'Komodo';
static SYMBOL = 'KMD';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/KomodoPlatform/komodo',
WHITEPAPER: 'https://komodoplatform.com/whitepaper',
WEBSITES: [
'https://komodoplatform.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Komodo;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1E
});
static DEFAULT_NETWORK = Komodo.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Komodo.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Komodo.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Komodo.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1D extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x30;
static SCRIPT_ADDRESS_PREFIX = 0x7a;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Landcoin Signed Message:\n';
static WIF_PREFIX = 0xb0;
}
class Landcoin extends Cryptocurrency {
static NAME = 'Landcoin';
static SYMBOL = 'LDCN';
static INFO = new Info({
WEBSITES: [
'http://landcoin.co'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Landcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1D
});
static DEFAULT_NETWORK = Landcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Landcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Landcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Landcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1C extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x55;
static SCRIPT_ADDRESS_PREFIX = 0x7a;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18LBRYcrd Signed Message:\n';
static WIF_PREFIX = 0x1c;
}
class LBRYCredits extends Cryptocurrency {
static NAME = 'LBRY-Credits';
static SYMBOL = 'LBC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/lbryio/lbrycrd',
WHITEPAPER: 'https://lbry.tech',
WEBSITES: [
'https://lbry.com',
'https://lbry.fund'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.LBRYCredits;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1C
});
static DEFAULT_NETWORK = LBRYCredits.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = LBRYCredits.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${LBRYCredits.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = LBRYCredits.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1B extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x4b;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18LinX Signed Message:\n';
static WIF_PREFIX = 0xcb;
}
class Linx extends Cryptocurrency {
static NAME = 'Linx';
static SYMBOL = 'LINX';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/linX-project/linX',
WHITEPAPER: 'https://mylinx.io/#ABOUT',
WEBSITES: [
'https://mylinx.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Linx;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1B
});
static DEFAULT_NETWORK = Linx.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Linx.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Linx.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Linx.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1A extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x30;
static SCRIPT_ADDRESS_PREFIX = 0x32;
static HRP = 'ltc';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878,
P2WSH: 0x02aa7a99,
P2WSH_IN_P2SH: 0x0295b005
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2,
P2WSH: 0x02aa7ed3,
P2WSH_IN_P2SH: 0x0295b43f
});
static MESSAGE_PREFIX = '\x19Litecoin Signed Message:\n';
static WIF_PREFIX = 0xb0;
}
class Testnet$e extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x6f;
static SCRIPT_ADDRESS_PREFIX = 0x3a;
static HRP = 'tltc';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x04358394,
P2SH: 0x04358394,
P2WPKH: 0x045f18bc,
P2WPKH_IN_P2SH: 0x044a4e28,
P2WSH: 0x02575048,
P2WSH_IN_P2SH: 0x024285b5
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x043587cf,
P2SH: 0x043587cf,
P2WPKH: 0x045f1cf6,
P2WPKH_IN_P2SH: 0x044a5262,
P2WSH: 0x02575483,
P2WSH_IN_P2SH: 0x024289ef
});
static MESSAGE_PREFIX = '\x19Litecoin Signed Message:\n';
static WIF_PREFIX = 0xef;
}
class Litecoin extends Cryptocurrency {
static NAME = 'Litecoin';
static SYMBOL = 'LTC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/litecoin-project/litecoin',
WEBSITES: [
'https://litecoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Litecoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1A,
TESTNET: Testnet$e
});
static DEFAULT_NETWORK = Litecoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44',
'BIP84'
]);
static DEFAULT_HD = Litecoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Litecoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' },
'P2WSH',
{ P2WSH_IN_P2SH: 'P2WSH-In-P2SH' }
]);
static DEFAULT_ADDRESS = Litecoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh', 'p2wsh', 'p2wsh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1z extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x1c;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Litecoin Signed Message:\n';
static WIF_PREFIX = 0xb0;
}
class LitecoinCash extends Cryptocurrency {
static NAME = 'Litecoin-Cash';
static SYMBOL = 'LCC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/litecoincash-project/litecoincash',
WHITEPAPER: 'https://litecoinca.sh/downloads/lcc_whitepaper.pdf',
WEBSITES: [
'https://litecoinca.sh'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.LitecoinCash;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1z
});
static DEFAULT_NETWORK = LitecoinCash.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = LitecoinCash.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${LitecoinCash.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = LitecoinCash.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1y extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x00000ab3;
static SCRIPT_ADDRESS_PREFIX = 0x00000ab8;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade3,
P2SH: 0x0488ade3
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18LitecoinZ Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class LitecoinZ extends Cryptocurrency {
static NAME = 'LitecoinZ';
static SYMBOL = 'LTZ';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/litecoinz-project/litecoinz',
WHITEPAPER: 'https://litecoinz.org/downloads/LITECOINZ-WHITE-PAPER.pdf',
WEBSITES: [
'https://litecoinz.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.LitecoinZ;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1y
});
static DEFAULT_NETWORK = LitecoinZ.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = LitecoinZ.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${LitecoinZ.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = LitecoinZ.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1x extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x30;
static SCRIPT_ADDRESS_PREFIX = 0x55;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18LKRcoin Signed Message:\n';
static WIF_PREFIX = 0xb0;
}
class Lkrcoin extends Cryptocurrency {
static NAME = 'Lkrcoin';
static SYMBOL = 'LKR';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/LKRcoin/lkrcoin',
WHITEPAPER: 'https://lkrcoin.io/draft/WhitePaper.pdf',
WEBSITES: [
'https://lkrcoin.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Lkrcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1x
});
static DEFAULT_NETWORK = Lkrcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Lkrcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Lkrcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Lkrcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1w extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x2d;
static SCRIPT_ADDRESS_PREFIX = 0x32;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Lynx Signed Message:\n';
static WIF_PREFIX = 0xad;
}
class Lynx extends Cryptocurrency {
static NAME = 'Lynx';
static SYMBOL = 'LYNX';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/doh9Xiet7weesh9va9th/lynx',
WEBSITES: [
'https://getlynx.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Lynx;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1w
});
static DEFAULT_NETWORK = Lynx.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Lynx.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Lynx.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Lynx.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1v extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x32;
static SCRIPT_ADDRESS_PREFIX = 0x09;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0xe0;
}
class Mazacoin extends Cryptocurrency {
static NAME = 'Mazacoin';
static SYMBOL = 'MZC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/MazaCoin/maza',
WEBSITES: [
'http://www.mazacoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Mazacoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1v
});
static DEFAULT_NETWORK = Mazacoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Mazacoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Mazacoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Mazacoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1u extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x32;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Megacoin Signed Message:\n';
static WIF_PREFIX = 0xb2;
}
class Megacoin extends Cryptocurrency {
static NAME = 'Megacoin';
static SYMBOL = 'MEC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/LIMXTEC/Megacoin',
WHITEPAPER: 'https://megacoin.eu/Megacoin.pdf',
WEBSITES: [
'https://megacoin-mec.cc'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Megacoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1u
});
static DEFAULT_NETWORK = Megacoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Megacoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Megacoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Megacoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1t extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Metis extends Cryptocurrency {
static NAME = 'Metis';
static SYMBOL = 'METIS';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/MetisProtocol/metis',
WHITEPAPER: 'https://drive.google.com/file/d/1LS7CmKFt-FkfVXxSNu06hNgoZXxMzTC-/view',
WEBSITES: [
'https://www.metis.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Metis;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$1t
});
static DEFAULT_NETWORK = Metis.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Metis.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Metis.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
ETHEREUM: 'Ethereum'
});
static DEFAULT_ADDRESS = Metis.ADDRESSES.ETHEREUM;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1s extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x4b;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Bitcoin Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Minexcoin extends Cryptocurrency {
static NAME = 'Minexcoin';
static SYMBOL = 'MNX';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/minexcoin/minexcoin',
WHITEPAPER: 'https://minexcoin.com/html/download/wpeng.pdf',
WEBSITES: [
'https://minexcoin.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Minexcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1s
});
static DEFAULT_NETWORK = Minexcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Minexcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Minexcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Minexcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1r extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x32;
static SCRIPT_ADDRESS_PREFIX = 0x37;
static HRP = 'mona';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x0488ade4,
P2WPKH_IN_P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x0488b21e,
P2WPKH_IN_P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Monacoin Signed Message:\n';
static WIF_PREFIX = 0xb0;
}
class Monacoin extends Cryptocurrency {
static NAME = 'Monacoin';
static SYMBOL = 'MONA';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/monacoinproject/monacoin',
WHITEPAPER: 'https://monacoin.org/#about',
WEBSITES: [
'http://monacoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Monacoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1r
});
static DEFAULT_NETWORK = Monacoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Monacoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Monacoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' }
]);
static DEFAULT_ADDRESS = Monacoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1q extends Network {
static NAME = 'mainnet';
static STANDARD = 0x12;
static INTEGRATED = 0x13;
static SUB_ADDRESS = 0x2a;
}
class Stagenet extends Network {
static NAME = 'stagenet';
static STANDARD = 0x18;
static INTEGRATED = 0x19;
static SUB_ADDRESS = 0x24;
}
class Testnet$d extends Network {
static NAME = 'testnet';
static STANDARD = 0x35;
static INTEGRATED = 0x36;
static SUB_ADDRESS = 0x3f;
}
class Monero extends Cryptocurrency {
static NAME = 'Monero';
static SYMBOL = 'XMR';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/monero-project/monero',
WHITEPAPER: 'https://github.com/monero-project/research-lab/blob/master/whitepaper/whitepaper.pdf',
WEBSITES: [
'https://www.getmonero.org'
]
});
static ECC = SLIP10Ed25519MoneroECC;
static COIN_TYPE = CoinTypes.Monero;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$1q,
STAGENET: Stagenet,
TESTNET: Testnet$d
});
static DEFAULT_NETWORK = Monero.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
{ MONERO: 'Monero' },
'BIP39'
]);
static MNEMONICS = new Mnemonics([
{ MONERO: 'Monero' },
'BIP39'
]);
static SEEDS = new Seeds([
{ MONERO: 'Monero' },
'BIP39'
]);
static HDS = new HDs({
MONERO: 'Monero'
});
static DEFAULT_HD = Monero.HDS.MONERO;
static DEFAULT_PATH = `m/44'/${Monero.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
MONERO: 'Monero'
});
static DEFAULT_ADDRESS = Monero.ADDRESSES.MONERO;
static ADDRESS_TYPES = new AddressTypes({
STANDARD: 'standard',
INTEGRATED: 'integrated',
SUB_ADDRESS: 'sub-address'
});
static DEFAULT_ADDRESS_TYPE = Monero.ADDRESS_TYPES.STANDARD;
static PARAMS = new Params({
CHECKSUM_LENGTH: 0x04,
PAYMENT_ID_LENGTH: 0x08
});
}
// SPDX-License-Identifier: MIT
class Mainnet$1p extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x33;
static SCRIPT_ADDRESS_PREFIX = 0x1c;
static HRP = 'monkey';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488dde4,
P2SH: 0x0488dde4,
P2WPKH: 0x0488dde4,
P2WPKH_IN_P2SH: 0x0488dde4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x0488b21e,
P2WPKH_IN_P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = 'Monkey Signed Message:\n';
static WIF_PREFIX = 0x37;
}
class Monk extends Cryptocurrency {
static NAME = 'Monk';
static SYMBOL = 'MONK';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/decenomy/MONK',
WHITEPAPER: 'https://decenomy.net/wp-content/uploads/DECENOMY_WP_v1.0_EN.pdf',
WEBSITES: [
'http://www.monkey.vision'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Monk;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1p
});
static DEFAULT_NETWORK = Monk.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Monk.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Monk.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' }
]);
static DEFAULT_ADDRESS = Monk.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1o extends Network {
static NAME = 'mainnet';
static HRP = 'erd';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
}
class MultiversX extends Cryptocurrency {
static NAME = 'MultiversX';
static SYMBOL = 'EGLD';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/multiversx/mx-chain-go',
WHITEPAPER: 'https://files.multiversx.com/multiversx-whitepaper.pdf',
WEBSITES: [
'https://multiversx.com',
'https://multiversx.com/ecosystem'
]
});
static ECC = SLIP10Ed25519ECC;
static COIN_TYPE = CoinTypes.MultiversX;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$1o
});
static DEFAULT_NETWORK = MultiversX.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = MultiversX.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${MultiversX.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
MULTIVERSX: 'MultiversX'
});
static DEFAULT_ADDRESS = MultiversX.ADDRESSES.MULTIVERSX;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1n extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x32;
static SCRIPT_ADDRESS_PREFIX = 0x09;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0xb2;
}
class Myriadcoin extends Cryptocurrency {
static NAME = 'Myriadcoin';
static SYMBOL = 'XMY';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/myriadteam/myriadcoin',
WEBSITES: [
'http://myriadcoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Myriadcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1n
});
static DEFAULT_NETWORK = Myriadcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Myriadcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Myriadcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Myriadcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1m extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x34;
static SCRIPT_ADDRESS_PREFIX = 0x0d;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0x80;
}
class Namecoin extends Cryptocurrency {
static NAME = 'Namecoin';
static SYMBOL = 'NMC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/namecoin/namecoin-core',
WHITEPAPER: 'https://www.namecoin.org/resources/whitepaper',
WEBSITES: [
'https://www.namecoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Namecoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1m
});
static DEFAULT_NETWORK = Namecoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Namecoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Namecoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Namecoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1l extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
}
class Nano extends Cryptocurrency {
static NAME = 'Nano';
static SYMBOL = 'XNO';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/nanocurrency/nano-node',
WHITEPAPER: 'https://nano.org/en/whitepaper',
WEBSITES: [
'http://nano.org/en'
]
});
static ECC = SLIP10Ed25519Blake2bECC;
static COIN_TYPE = CoinTypes.Nano;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$1l
});
static DEFAULT_NETWORK = Nano.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Nano.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Nano.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
NANO: 'Nano'
});
static DEFAULT_ADDRESS = Nano.ADDRESSES.NANO;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static PARAMS = new Params({
ADDRESS_PREFIX: 'nano_',
ALPHABET: '13456789abcdefghijkmnopqrstuwxyz',
PAYLOAD_PADDING_DECODED: '000000',
PAYLOAD_PADDING_ENCODED: '1111'
});
}
// SPDX-License-Identifier: MIT
class Mainnet$1k extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x35;
static SCRIPT_ADDRESS_PREFIX = 0x55;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Navcoin Signed Message:\n';
static WIF_PREFIX = 0x96;
}
class Navcoin extends Cryptocurrency {
static NAME = 'Navcoin';
static SYMBOL = 'NAV';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/navcoin/navcoin-core',
WHITEPAPER: 'https://doc.nav.community',
WEBSITES: [
'http://www.navcoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Navcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1k
});
static DEFAULT_NETWORK = Navcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Navcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Navcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Navcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1j extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
}
class Near extends Cryptocurrency {
static NAME = 'Near';
static SYMBOL = 'NEAR';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/near/nearcore',
WHITEPAPER: 'https://near.org/papers/the-official-near-white-paper',
WEBSITES: [
'https://near.org'
]
});
static ECC = SLIP10Ed25519ECC;
static COIN_TYPE = CoinTypes.Near;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$1j
});
static DEFAULT_NETWORK = Near.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Near.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Near.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
NEAR: 'Near'
});
static DEFAULT_ADDRESS = Near.ADDRESSES.NEAR;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1i extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x35;
static SCRIPT_ADDRESS_PREFIX = 0x70;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Neblio Signed Message:\n';
static WIF_PREFIX = 0xb5;
}
class Neblio extends Cryptocurrency {
static NAME = 'Neblio';
static SYMBOL = 'NEBL';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/NeblioTeam/neblio',
WHITEPAPER: 'https://nebl.io/wp-content/uploads/2019/06/NeblioWhitepaper.pdf',
WEBSITES: [
'https://nebl.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Neblio;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1i
});
static DEFAULT_NETWORK = Neblio.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Neblio.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Neblio.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Neblio.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1h extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
}
class Neo extends Cryptocurrency {
static NAME = 'Neo';
static SYMBOL = 'NEO';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/neo-project/neo',
WHITEPAPER: 'https://docs.neo.org/docs/en-us/index.html',
WEBSITES: [
'https://neo.org'
]
});
static ECC = SLIP10Nist256p1ECC;
static COIN_TYPE = CoinTypes.Neo;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$1h
});
static DEFAULT_NETWORK = Neo.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Neo.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Neo.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
NEO: 'Neo'
});
static DEFAULT_ADDRESS = Neo.ADDRESSES.NEO;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static PARAMS = new Params({
ADDRESS_PREFIX: 0x21,
ADDRESS_SUFFIX: 0xac,
ADDRESS_VERSION: 0x17,
ALPHABET: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
});
}
// SPDX-License-Identifier: MIT
class Mainnet$1g extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x35;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18NeosCoin Signed Message:\n';
static WIF_PREFIX = 0xb1;
}
class Neoscoin extends Cryptocurrency {
static NAME = 'Neoscoin';
static SYMBOL = 'NEOS';
static INFO = new Info({
WHITEPAPER: 'http://neoscoin.com/whitepaper/neoscoin.pdf',
WEBSITES: [
'http://www.getneos.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Neoscoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1g
});
static DEFAULT_NETWORK = Neoscoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Neoscoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Neoscoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Neoscoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1f extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x35;
static SCRIPT_ADDRESS_PREFIX = 0x75;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18PPCoin Signed Message:\n';
static WIF_PREFIX = 0xb5;
}
class Neurocoin extends Cryptocurrency {
static NAME = 'Neurocoin';
static SYMBOL = 'NRO';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/neurocoin/neurocoin',
WEBSITES: [
'http://neurocoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Neurocoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1f
});
static DEFAULT_NETWORK = Neurocoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Neurocoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Neurocoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Neurocoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1e extends Network {
static NAME = 'mainnet';
static HRP = 'neutron';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Neutron extends Cryptocurrency {
static NAME = 'Neutron';
static SYMBOL = 'NTRN';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/neutron-org',
WHITEPAPER: 'https://docs.neutron.org',
WEBSITES: [
'https://www.neutron.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Neutron;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$1e
});
static DEFAULT_NETWORK = Neutron.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Neutron.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Neutron.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
COSMOS: 'Cosmos'
});
static DEFAULT_ADDRESS = Neutron.ADDRESSES.COSMOS;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1d extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x3c;
static SCRIPT_ADDRESS_PREFIX = 0x16;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18newyorkc Signed Message:\n';
static WIF_PREFIX = 0xbc;
}
class NewYorkCoin extends Cryptocurrency {
static NAME = 'New-York-Coin';
static SYMBOL = 'NYC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/NewYorkCoinNYC/newyorkcoin',
WEBSITES: [
'https://nycoin.net',
'https://newyorkcoin.net'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.NewYorkCoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1d
});
static DEFAULT_NETWORK = NewYorkCoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = NewYorkCoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${NewYorkCoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = NewYorkCoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1c extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class NineChronicles extends Cryptocurrency {
static NAME = 'Nine-Chronicles';
static SYMBOL = 'NCG';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/planetarium/NineChronicles',
WEBSITES: [
'https://nine-chronicles.com',
'https://presale.nine-chronicles.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.NineChronicles;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$1c
});
static DEFAULT_NETWORK = NineChronicles.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = NineChronicles.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${NineChronicles.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
ETHEREUM: 'Ethereum'
});
static DEFAULT_ADDRESS = NineChronicles.ADDRESSES.ETHEREUM;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1b extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x26;
static SCRIPT_ADDRESS_PREFIX = 0x35;
static HRP = 'nix';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x0488ade4,
P2WPKH_IN_P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x0488b21e,
P2WPKH_IN_P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Nix Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class NIX extends Cryptocurrency {
static NAME = 'NIX';
static SYMBOL = 'NIX';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/NixPlatform/NixCore',
WHITEPAPER: 'https://nixplatform.io/about/documentation',
WEBSITES: [
'https://nixplatform.io',
'https://governance.nixplatform.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.NIX;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1b
});
static DEFAULT_NETWORK = NIX.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = NIX.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${NIX.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' }
]);
static DEFAULT_ADDRESS = NIX.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1a extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x08;
static SCRIPT_ADDRESS_PREFIX = 0x14;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18NovaCoin Signed Message:\n';
static WIF_PREFIX = 0x88;
}
class Novacoin extends Cryptocurrency {
static NAME = 'Novacoin';
static SYMBOL = 'NVC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/novacoin-project/novacoin',
WHITEPAPER: 'https://github.com/novacoin-project/novacoin/wiki',
WEBSITES: [
'https://nova-coin.org',
'https://novacoin.one'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Novacoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$1a
});
static DEFAULT_NETWORK = Novacoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Novacoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Novacoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Novacoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$19 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x19;
static SCRIPT_ADDRESS_PREFIX = 0x1a;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Nu Signed Message:\n';
static WIF_PREFIX = 0x96;
}
class NuBits extends Cryptocurrency {
static NAME = 'NuBits';
static SYMBOL = 'NBT';
static INFO = new Info({
SOURCE_CODE: 'https://bitbucket.org/NuNetwork/nubits',
WHITEPAPER: 'https://nubits.com/assets/nu-whitepaper-23_sept_2014-en.pdf',
WEBSITES: [
'https://www.nubits.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.NuBits;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$19
});
static DEFAULT_NETWORK = NuBits.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = NuBits.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${NuBits.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = NuBits.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$18 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x3f;
static SCRIPT_ADDRESS_PREFIX = 0x40;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Nu Signed Message:\n';
static WIF_PREFIX = 0x95;
}
class NuShares extends Cryptocurrency {
static NAME = 'NuShares';
static SYMBOL = 'NSR';
static INFO = new Info({
SOURCE_CODE: 'https://bitbucket.org/JordanLeePeershares/nubit/overview',
WHITEPAPER: 'https://nubits.com/whitepaper',
WEBSITES: [
'https://nubits.com/nushares'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.NuShares;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$18
});
static DEFAULT_NETWORK = NuShares.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = NuShares.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${NuShares.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = NuShares.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$17 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x37;
static SCRIPT_ADDRESS_PREFIX = 0x1c;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x03cc1c73,
P2SH: 0x03cc1c73
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x03cc23d7,
P2SH: 0x03cc23d7
});
static MESSAGE_PREFIX = '\x18OKCash Signed Message:\n';
static WIF_PREFIX = 0x03;
}
class OKCash extends Cryptocurrency {
static NAME = 'OK-Cash';
static SYMBOL = 'OK';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/okcashpro/okcash',
WHITEPAPER: 'https://github.com/okcashpro/okcash-whitepaper',
WEBSITES: [
'http://okcash.co'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.OKCash;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$17
});
static DEFAULT_NETWORK = OKCash.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = OKCash.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${OKCash.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = OKCash.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$16 extends Network {
static NAME = 'mainnet';
static HRP = 'ex';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class OKTChain extends Cryptocurrency {
static NAME = 'OKT-Chain';
static SYMBOL = 'OKT';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/okex/okexchain',
WHITEPAPER: 'https://okc-docs.readthedocs.io/en/latest',
WEBSITES: [
'https://www.okx.com/okc'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.OKTChain;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$16
});
static DEFAULT_NETWORK = OKTChain.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = OKTChain.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${OKTChain.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
OKT_CHAIN: 'OKT-Chain'
});
static DEFAULT_ADDRESS = OKTChain.ADDRESSES.OKT_CHAIN;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$15 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x00;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Bitcoin Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Testnet$c extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x6f;
static SCRIPT_ADDRESS_PREFIX = 0xc4;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x04358394,
P2SH: 0x04358394
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x043587cf,
P2SH: 0x043587cf
});
static MESSAGE_PREFIX = '\x18Bitcoin Signed Message:\n';
static WIF_PREFIX = 0xef;
}
class Omni extends Cryptocurrency {
static NAME = 'Omni';
static SYMBOL = 'OMNI';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/omnilayer/omnicore',
WHITEPAPER: 'https://github.com/OmniLayer/spec',
WEBSITES: [
'http://www.omnilayer.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Omni;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$15,
TESTNET: Testnet$c
});
static DEFAULT_NETWORK = Omni.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Omni.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Omni.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Omni.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$14 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x4b;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = 'ONIX Signed Message:\n';
static WIF_PREFIX = 0xcb;
}
class Onix extends Cryptocurrency {
static NAME = 'Onix';
static SYMBOL = 'ONX';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/onix-project',
WEBSITES: [
'http://www.onixcoin.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Onix;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$14
});
static DEFAULT_NETWORK = Onix.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Onix.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Onix.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Onix.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$13 extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
}
class Ontology extends Cryptocurrency {
static NAME = 'Ontology';
static SYMBOL = 'ONT';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/ontio/ontology',
WHITEPAPER: 'https://docs.ont.io',
WEBSITES: [
'https://ont.io'
]
});
static ECC = SLIP10Nist256p1ECC;
static COIN_TYPE = CoinTypes.Ontology;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$13
});
static DEFAULT_NETWORK = Ontology.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Ontology.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Ontology.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
NEO: 'Neo'
});
static DEFAULT_ADDRESS = Ontology.ADDRESSES.NEO;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static PARAMS = new Params({
ADDRESS_VERSION: 0x17
});
}
// SPDX-License-Identifier: MIT
class Mainnet$12 extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Optimism extends Cryptocurrency {
static NAME = 'Optimism';
static SYMBOL = 'OP';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/ethereum-optimism',
WEBSITES: [
'https://www.optimism.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Optimism;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$12
});
static DEFAULT_NETWORK = Optimism.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Optimism.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Optimism.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
ETHEREUM: 'Ethereum'
});
static DEFAULT_ADDRESS = Optimism.ADDRESSES.ETHEREUM;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$11 extends Network {
static NAME = 'mainnet';
static HRP = 'osmo';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Osmosis extends Cryptocurrency {
static NAME = 'Osmosis';
static SYMBOL = 'OSMO';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/osmosis-labs/osmosis',
WEBSITES: [
'https://osmosis.zone'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Osmosis;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$11
});
static DEFAULT_NETWORK = Osmosis.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Osmosis.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Osmosis.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
COSMOS: 'Cosmos'
});
static DEFAULT_ADDRESS = Osmosis.ADDRESSES.COSMOS;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$10 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x38;
static SCRIPT_ADDRESS_PREFIX = 0x3c;
static HRP = 'pw';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x8f1daeb8,
P2SH: 0x8f1daeb8
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x696e82d1,
P2SH: 0x696e82d1
});
static MESSAGE_PREFIX = '\x18Bitcoin Signed Message:\n';
static WIF_PREFIX = 0x6c;
}
class Particl extends Cryptocurrency {
static NAME = 'Particl';
static SYMBOL = 'PART';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/particl/particl-core',
WHITEPAPER: 'https://github.com/particl/whitepaper/blob/master/Particl%20Whitepaper%20Draft%20v0.3.pdf',
WEBSITES: [
'http://particl.io',
'https://particl.store'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Particl;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$10
});
static DEFAULT_NETWORK = Particl.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Particl.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Particl.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Particl.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$$ extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x37;
static SCRIPT_ADDRESS_PREFIX = 0x75;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0xb7;
}
class Peercoin extends Cryptocurrency {
static NAME = 'Peercoin';
static SYMBOL = 'PPC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/peercoin/peercoin',
WHITEPAPER: 'https://docs.peercoin.net',
WEBSITES: [
'http://www.peercoin.net'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Peercoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$$
});
static DEFAULT_NETWORK = Peercoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Peercoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Peercoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Peercoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$_ extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x37;
static SCRIPT_ADDRESS_PREFIX = 0x55;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Pesobit Signed Message:\n';
static WIF_PREFIX = 0xb7;
}
class Pesobit extends Cryptocurrency {
static NAME = 'Pesobit';
static SYMBOL = 'PSB';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/pesobitph/pesobit-source',
WEBSITES: [
'http://www.pesobit.net'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Pesobit;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$_
});
static DEFAULT_NETWORK = Pesobit.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Pesobit.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Pesobit.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Pesobit.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$Z extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x37;
static SCRIPT_ADDRESS_PREFIX = 0x0d;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0221312b,
P2SH: 0x0221312b
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x022d2533,
P2SH: 0x022d2533
});
static MESSAGE_PREFIX = '\x18Phore Signed Message:\n';
static WIF_PREFIX = 0xd4;
}
class Phore extends Cryptocurrency {
static NAME = 'Phore';
static SYMBOL = 'PHR';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/phoreproject/Phore',
WHITEPAPER: 'https://www.dropbox.com/s/6uf405mdbdvs6iq/Phore%20White%20Paper%20v.1.1a.pdf?dl=0',
WEBSITES: [
'https://phore.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Phore;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$Z
});
static DEFAULT_NETWORK = Phore.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Phore.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Phore.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Phore.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$Y extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
}
class PiNetwork extends Cryptocurrency {
static NAME = 'Pi-Network';
static SYMBOL = 'PI';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/pi-apps',
WHITEPAPER: 'https://minepi.com/white-paper',
WEBSITES: [
'https://minepi.com'
]
});
static ECC = SLIP10Ed25519ECC;
static COIN_TYPE = CoinTypes.PiNetwork;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$Y
});
static DEFAULT_NETWORK = PiNetwork.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = PiNetwork.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${PiNetwork.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
STELLAR: 'Stellar'
});
static DEFAULT_ADDRESS = PiNetwork.ADDRESSES.STELLAR;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static ADDRESS_TYPES = new AddressTypes({
PRIVATE_KEY: 'private_key',
PUBLIC_KEY: 'public_key'
});
static DEFAULT_ADDRESS_TYPE = PiNetwork.ADDRESS_TYPES.PUBLIC_KEY;
static PARAMS = new Params({
CHECKSUM_LENGTH: 0x02,
ADDRESS_TYPES: {
PRIVATE_KEY: 18 << 3,
PUBLIC_KEY: 6 << 3
}
});
}
// SPDX-License-Identifier: MIT
class Mainnet$X extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x03;
static SCRIPT_ADDRESS_PREFIX = 0x1c;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Pinkcoin Signed Message:\n';
static WIF_PREFIX = 0x83;
}
class Pinkcoin extends Cryptocurrency {
static NAME = 'Pinkcoin';
static SYMBOL = 'PINK';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/Pink2Dev/Pink2',
WEBSITES: [
'http://getstarted.with.pink',
'https://beta.donate.with.pink'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Pinkcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$X
});
static DEFAULT_NETWORK = Pinkcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Pinkcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Pinkcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Pinkcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$W extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x1e;
static SCRIPT_ADDRESS_PREFIX = 0x0d;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0221312b,
P2SH: 0x0221312b
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x022d2533,
P2SH: 0x022d2533
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0xd4;
}
class Testnet$b extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x8b;
static SCRIPT_ADDRESS_PREFIX = 0x13;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x3a805837,
P2SH: 0x3a805837
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x3a8061a0,
P2SH: 0x3a8061a0
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0xef;
}
class Pivx extends Cryptocurrency {
static NAME = 'Pivx';
static SYMBOL = 'PIVX';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/PIVX-Project/PIVX',
WHITEPAPER: 'https://pivx.org/whitepaper',
WEBSITES: [
'https://pivx.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Pivx;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$W,
TESTNET: Testnet$b
});
static DEFAULT_NETWORK = Pivx.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Pivx.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Pivx.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Pivx.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$V extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Polygon extends Cryptocurrency {
static NAME = 'Polygon';
static SYMBOL = 'MATIC';
static INFO = new Info({
WHITEPAPER: 'https://github.com/maticnetwork/contracts',
WEBSITES: [
'https://github.com/maticnetwork/whitepaper',
'https://polygon.technology'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Polygon;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$V
});
static DEFAULT_NETWORK = Polygon.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Polygon.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Polygon.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
ETHEREUM: 'Ethereum'
});
static DEFAULT_ADDRESS = Polygon.ADDRESSES.ETHEREUM;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$U extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x37;
static SCRIPT_ADDRESS_PREFIX = 0x55;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Poswcoin Signed Message:\n';
static WIF_PREFIX = 0xb7;
}
class PoSWCoin extends Cryptocurrency {
static NAME = 'PoSW-Coin';
static SYMBOL = 'POSW';
static INFO = new Info({
WEBSITES: [
'https://posw.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.PoSWCoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$U
});
static DEFAULT_NETWORK = PoSWCoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = PoSWCoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${PoSWCoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = PoSWCoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$T extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x37;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Potcoin Signed Message:\n';
static WIF_PREFIX = 0xb7;
}
class Potcoin extends Cryptocurrency {
static NAME = 'Potcoin';
static SYMBOL = 'POT';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/potcoin/Potcoin',
WHITEPAPER: 'https://www.potcoin.com/images/blog-images/PotCoin-4.20.2016.pdf',
WEBSITES: [
'http://www.potcoin.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Potcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$T
});
static DEFAULT_NETWORK = Potcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Potcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Potcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Potcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$S extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x37;
static SCRIPT_ADDRESS_PREFIX = 0x08;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0221312b,
P2SH: 0x0221312b
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x022d2533,
P2SH: 0x022d2533
});
static MESSAGE_PREFIX = '\x18ProjectCoin Signed Message:\n';
static WIF_PREFIX = 0x75;
}
class ProjectCoin extends Cryptocurrency {
static NAME = 'Project-Coin';
static SYMBOL = 'PRJ';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/projectcoincore/ProjectCoin',
WEBSITES: [
'https://projectcoin.net'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.ProjectCoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$S
});
static DEFAULT_NETWORK = ProjectCoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = ProjectCoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${ProjectCoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = ProjectCoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$R extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x37;
static SCRIPT_ADDRESS_PREFIX = 0x14;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18PutinCoin Signed Message:\n';
static WIF_PREFIX = 0xb7;
}
class Putincoin extends Cryptocurrency {
static NAME = 'Putincoin';
static SYMBOL = 'PUT';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/PutinCoinPUT/PutinCoin',
WHITEPAPER: 'https://putincoin.org/putincoin.pdf',
WEBSITES: [
'https://putincoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Putincoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$R
});
static DEFAULT_NETWORK = Putincoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Putincoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Putincoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Putincoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$Q extends Network {
static NAME = 'mainnet';
static SCRIPT_ADDRESS_PREFIX = 0x32;
static PUBLIC_KEY_ADDRESS_PREFIX = 0x3a;
static HRP = 'qc1';
static WITNESS_VERSIONS = new WitnessVersions({
P2TR: 0x01,
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x045f18bc,
P2WPKH_IN_P2SH: 0x049d7878,
P2WSH: 0x02aa7a99,
P2WSH_IN_P2SH: 0x0295b005
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x045f1cf6,
P2WPKH_IN_P2SH: 0x049d7cb2,
P2WSH: 0x02aa7ed3,
P2WSH_IN_P2SH: 0x0295b43f
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0x80;
}
class Testnet$a extends Network {
static NAME = 'testnet';
static SCRIPT_ADDRESS_PREFIX = 0x6e;
static PUBLIC_KEY_ADDRESS_PREFIX = 0x78;
static HRP = 'tq1';
static WITNESS_VERSIONS = new WitnessVersions({
P2TR: 0x01,
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x04358394,
P2SH: 0x04358394,
P2WPKH: 0x045f18bc,
P2WPKH_IN_P2SH: 0x044a4e28,
P2WSH: 0x02575048,
P2WSH_IN_P2SH: 0x024285b5
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x043587cf,
P2SH: 0x043587cf,
P2WPKH: 0x045f1cf6,
P2WPKH_IN_P2SH: 0x044a5262,
P2WSH: 0x02575483,
P2WSH_IN_P2SH: 0x024289ef
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0xef;
}
class Qtum extends Cryptocurrency {
static NAME = 'Qtum';
static SYMBOL = 'QTUM';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/qtumproject/qtum',
WHITEPAPER: 'https://qtumorg.s3.ap-northeast-2.amazonaws.com/Qtum_New_Whitepaper_en.pdf',
WEBSITES: [
'https://qtum.org',
'https://qtum.info'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Qtum;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$Q,
TESTNET: Testnet$a
});
static DEFAULT_NETWORK = Qtum.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44',
'BIP49',
'BIP84',
'BIP86',
'BIP141'
]);
static DEFAULT_HD = Qtum.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Qtum.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2TR',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' },
'P2WSH',
{ P2WSH_IN_P2SH: 'P2WSH-In-P2SH' }
]);
static DEFAULT_ADDRESS = Qtum.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh', 'p2wsh', 'p2wsh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$P extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x3d;
static SCRIPT_ADDRESS_PREFIX = 0x06;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = 'DarkNet Signed Message:\n';
static WIF_PREFIX = 0x2e;
}
class Rapids extends Cryptocurrency {
static NAME = 'Rapids';
static SYMBOL = 'RPD';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/RapidsOfficial/Rapids',
WHITEPAPER: 'https://www.rapidsnetwork.io/whitepaper',
WEBSITES: [
'https://www.rapidsnetwork.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Rapids;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$P
});
static DEFAULT_NETWORK = Rapids.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Rapids.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Rapids.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Rapids.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$O extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x3c;
static SCRIPT_ADDRESS_PREFIX = 0x7a;
static HRP = 'ra';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x0c,
P2WSH: 0x0c
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878,
P2WSH: 0x02aa7a99,
P2WSH_IN_P2SH: 0x0295b005
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2,
P2WSH: 0x02aa7ed3,
P2WSH_IN_P2SH: 0x0295b43f
});
static MESSAGE_PREFIX = 'Raven Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Testnet$9 extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x6f;
static SCRIPT_ADDRESS_PREFIX = 0xc4;
static HRP = 'tr';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878,
P2WSH: 0x02aa7a99,
P2WSH_IN_P2SH: 0x0295b005
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2,
P2WSH: 0x02aa7ed3,
P2WSH_IN_P2SH: 0x0295b43f
});
static MESSAGE_PREFIX = 'Raven Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Ravencoin extends Cryptocurrency {
static NAME = 'Ravencoin';
static SYMBOL = 'RVN';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/RavenProject/Ravencoin',
WHITEPAPER: 'https://ravencoin.org/whitepaper',
WEBSITES: [
'https://ravencoin.org',
'https://getravencoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Ravencoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$O,
TESTNET: Testnet$9
});
static DEFAULT_NETWORK = Ravencoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Ravencoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Ravencoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' },
'P2WSH',
{ P2WSH_IN_P2SH: 'P2WSH-In-P2SH' }
]);
static DEFAULT_ADDRESS = Ravencoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh', 'p2wsh', 'p2wsh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$N extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x3d;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Reddcoin Signed Message:\n';
static WIF_PREFIX = 0xbd;
}
class Reddcoin extends Cryptocurrency {
static NAME = 'Reddcoin';
static SYMBOL = 'RDD';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/reddcoin-project/reddcoin',
WHITEPAPER: 'https://redd.love/assets/doc/Redd-Paper.pdf',
WEBSITES: [
'http://www.reddcoin.com',
'https://redd.love'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Reddcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$N
});
static DEFAULT_NETWORK = Reddcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Reddcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Reddcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Reddcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$M extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x00;
static SCRIPT_ADDRESS_PREFIX = 0x00;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0x80;
}
class Ripple extends Cryptocurrency {
static NAME = 'Ripple';
static SYMBOL = 'XRP';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/ripple/rippled',
WHITEPAPER: 'https://ripple.com/files/ripple_consensus_whitepaper.pdf',
WEBSITES: [
'https://xrpl.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Ripple;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$M
});
static DEFAULT_NETWORK = Ripple.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Ripple.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Ripple.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
RIPPLE: 'Ripple'
});
static DEFAULT_ADDRESS = Ripple.ADDRESSES.RIPPLE;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static PARAMS = new Params({
ALPHABET: 'rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz'
});
}
// SPDX-License-Identifier: MIT
class Mainnet$L extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x19;
static SCRIPT_ADDRESS_PREFIX = 0x69;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x15Rito Signed Message:\n';
static WIF_PREFIX = 0x8b;
}
class Ritocoin extends Cryptocurrency {
static NAME = 'Ritocoin';
static SYMBOL = 'RITO';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/RitoProject/Ritocoin',
WHITEPAPER: 'https://ritocoin.org/docs/whitepaper_gfx.pdf',
WEBSITES: [
'https://ritocoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Ritocoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$L
});
static DEFAULT_NETWORK = Ritocoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Ritocoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Ritocoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Ritocoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$K extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x00;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18RSK Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Testnet$8 extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x6f;
static SCRIPT_ADDRESS_PREFIX = 0xc4;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x04358394,
P2SH: 0x04358394
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x043587cf,
P2SH: 0x043587cf
});
static MESSAGE_PREFIX = '\x18RSK Testnet Signed Message:\n';
static WIF_PREFIX = 0xef;
}
class RSK extends Cryptocurrency {
static NAME = 'RSK';
static SYMBOL = 'RBTC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/rsksmart',
WHITEPAPER: 'https://developers.rsk.co',
WEBSITES: [
'https://rootstock.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.RSK;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$K,
TESTNET: Testnet$8
});
static DEFAULT_NETWORK = RSK.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = RSK.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${RSK.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = RSK.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$J extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x3c;
static SCRIPT_ADDRESS_PREFIX = 0x55;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Rubycoin Signed Message:\n';
static WIF_PREFIX = 0xbc;
}
class Rubycoin extends Cryptocurrency {
static NAME = 'Rubycoin';
static SYMBOL = 'RBY';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/rubycoinorg/rubycoin',
WEBSITES: [
'http://www.rubycoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Rubycoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$J
});
static DEFAULT_NETWORK = Rubycoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Rubycoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Rubycoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Rubycoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$I extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x3d;
static SCRIPT_ADDRESS_PREFIX = 0x56;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Safecoin Signed Message:\n';
static WIF_PREFIX = 0xbd;
}
class Safecoin extends Cryptocurrency {
static NAME = 'Safecoin';
static SYMBOL = 'SAFE';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/Fair-Exchange/safecoin',
WHITEPAPER: 'https://safecoin.org/assets/SafeWhitePaper.pdf',
WEBSITES: [
'https://www.safecoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Safecoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$I
});
static DEFAULT_NETWORK = Safecoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Safecoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Safecoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Safecoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$H extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x3f;
static SCRIPT_ADDRESS_PREFIX = 0xc4;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Salus Signed Message:\n';
static WIF_PREFIX = 0xbf;
}
class Saluscoin extends Cryptocurrency {
static NAME = 'Saluscoin';
static SYMBOL = 'SLS';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/saluscoin/SaluS',
WEBSITES: [
'http://saluscoin.info',
'https://divitia.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Saluscoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$H
});
static DEFAULT_NETWORK = Saluscoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Saluscoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Saluscoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Saluscoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$G extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x3c;
static SCRIPT_ADDRESS_PREFIX = 0x7d;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0x6e;
}
class Scribe extends Cryptocurrency {
static NAME = 'Scribe';
static SYMBOL = 'SCRIBE';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/scribenetwork/scribe',
WEBSITES: [
'http://scribe.network'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Scribe;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$G
});
static DEFAULT_NETWORK = Scribe.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Scribe.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Scribe.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Scribe.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$F extends Network {
static NAME = 'mainnet';
static HRP = 'secret';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Secret extends Cryptocurrency {
static NAME = 'Secret';
static SYMBOL = 'SCRT';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/scrtlabs/SecretNetwork',
WHITEPAPER: 'https://docs.scrt.network',
WEBSITES: [
'https://scrt.network'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Secret;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$F
});
static DEFAULT_NETWORK = Secret.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Secret.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Secret.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
COSMOS: 'Cosmos'
});
static DEFAULT_ADDRESS = Secret.ADDRESSES.COSMOS;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$E extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x3f;
static SCRIPT_ADDRESS_PREFIX = 0x7d;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0xee8031e8,
P2SH: 0xee8031e8
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0xee80286a,
P2SH: 0xee80286a
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0xbf;
}
class Testnet$7 extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x7f;
static SCRIPT_ADDRESS_PREFIX = 0xc4;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x76c1077a,
P2SH: 0x76c1077a
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x76c0fdfb,
P2SH: 0x76c0fdfb
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0xff;
}
class ShadowCash extends Cryptocurrency {
static NAME = 'Shadow-Cash';
static SYMBOL = 'SDC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/shadowproject/shadow',
WHITEPAPER: 'https://github.com/shadowproject/whitepapers',
WEBSITES: [
'http://shadowproject.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.ShadowCash;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$E,
TESTNET: Testnet$7
});
static DEFAULT_NETWORK = ShadowCash.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = ShadowCash.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${ShadowCash.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = ShadowCash.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$D extends Network {
static NAME = 'mainnet';
static HRP = 'certik';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Shentu extends Cryptocurrency {
static NAME = 'Shentu';
static SYMBOL = 'CTK';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/ShentuChain',
WHITEPAPER: 'https://www.shentu.technology/whitepaper',
WEBSITES: [
'https://www.shentu.technology'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Shentu;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$D
});
static DEFAULT_NETWORK = Shentu.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Shentu.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Shentu.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
COSMOS: 'Cosmos'
});
static DEFAULT_ADDRESS = Shentu.ADDRESSES.COSMOS;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$C extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x3f;
static SCRIPT_ADDRESS_PREFIX = 0x7d;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0xef69ea80,
P2SH: 0xef69ea80
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0xef6adf10,
P2SH: 0xef6adf10
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0x46;
}
class Testnet$6 extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x6f;
static SCRIPT_ADDRESS_PREFIX = 0xc4;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x04358394,
P2SH: 0x04358394
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x043587cf,
P2SH: 0x043587cf
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0x57;
}
class Slimcoin extends Cryptocurrency {
static NAME = 'Slimcoin';
static SYMBOL = 'SLM';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/slimcoin-project/Slimcoin',
WEBSITES: [
'http://slimco.in',
'https://slimcoin-project.github.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Slimcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$C,
TESTNET: Testnet$6
});
static DEFAULT_NETWORK = Slimcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Slimcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Slimcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Slimcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$B extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x19;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x1e5631bc,
P2SH: 0x1e5631bc
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x1e562d9a,
P2SH: 0x1e562d9a
});
static MESSAGE_PREFIX = '\x18Smileycoin Signed Message:\n';
static WIF_PREFIX = 0x05;
}
class Smileycoin extends Cryptocurrency {
static NAME = 'Smileycoin';
static SYMBOL = 'SMLY';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/tutor-web/',
WHITEPAPER: 'https://tutor-web.info/smileycoin',
WEBSITES: [
'https://smileyco.in'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Smileycoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$B
});
static DEFAULT_NETWORK = Smileycoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Smileycoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Smileycoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Smileycoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$A extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
}
class Solana extends Cryptocurrency {
static NAME = 'Solana';
static SYMBOL = 'SOL';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/solana-labs/solana',
WHITEPAPER: 'https://solana.com/solana-whitepaper.pdf',
WEBSITES: [
'https://solana.com'
]
});
static ECC = SLIP10Ed25519ECC;
static COIN_TYPE = CoinTypes.Solana;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$A
});
static DEFAULT_NETWORK = Solana.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Solana.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Solana.COIN_TYPE}'/0'/0'`;
static ADDRESSES = new Addresses({
SOLANA: 'Solana'
});
static DEFAULT_ADDRESS = Solana.ADDRESSES.SOLANA;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static PARAMS = new Params({
ALPHABET: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
});
}
// SPDX-License-Identifier: MIT
class Mainnet$z extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x12;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18SolarCoin Signed Message:\n';
static WIF_PREFIX = 0x92;
}
class Solarcoin extends Cryptocurrency {
static NAME = 'Solarcoin';
static SYMBOL = 'SLR';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/onsightit/solarcoin',
WHITEPAPER: 'https://solarcoin.org/sites/default/files/slr-basic-page/2018-02/SolarCoin_Policy_Paper_FINAL.pdf',
WEBSITES: [
'http://solarcoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Solarcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$z
});
static DEFAULT_NETWORK = Solarcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Solarcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Solarcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Solarcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$y extends Network {
static NAME = 'mainnet';
static HRP = 'stafi';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Stafi extends Cryptocurrency {
static NAME = 'Stafi';
static SYMBOL = 'FIS';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/stafiprotocol/stafi-node',
WHITEPAPER: 'https://docs.stafi.io',
WEBSITES: [
'https://www.stafi.io'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Stafi;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$y
});
static DEFAULT_NETWORK = Stafi.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Stafi.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Stafi.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
COSMOS: 'Cosmos'
});
static DEFAULT_ADDRESS = Stafi.ADDRESSES.COSMOS;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$x extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x4c;
static SCRIPT_ADDRESS_PREFIX = 0x10;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Stash Signed Message:\n';
static WIF_PREFIX = 0xcc;
}
class Testnet$5 extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x8c;
static SCRIPT_ADDRESS_PREFIX = 0x13;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x04358394,
P2SH: 0x04358394
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x043587cf,
P2SH: 0x043587cf
});
static MESSAGE_PREFIX = '\x18Stash Test Signed Message:\n';
static WIF_PREFIX = 0xef;
}
class Stash extends Cryptocurrency {
static NAME = 'Stash';
static SYMBOL = 'STASH';
static INFO = new Info({
SOURCE_CODE: 'https://docs.stash.capital',
WHITEPAPER: 'https://docs.stash.capital',
WEBSITES: [
'https://stash.capital',
'https://app.stash.capital/#/dashboard'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Stash;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$x,
TESTNET: Testnet$5
});
static DEFAULT_NETWORK = Stash.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Stash.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Stash.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Stash.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$w extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
}
class Stellar extends Cryptocurrency {
static NAME = 'Stellar';
static SYMBOL = 'XLM';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/stellar/stellar-core',
WHITEPAPER: 'https://www.stellar.org/papers/stellar-consensus-protocol.pdf',
WEBSITES: [
'https://www.stellar.org'
]
});
static ECC = SLIP10Ed25519ECC;
static COIN_TYPE = CoinTypes.Stellar;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$w
});
static DEFAULT_NETWORK = Stellar.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Stellar.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Stellar.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
STELLAR: 'Stellar'
});
static DEFAULT_ADDRESS = Stellar.ADDRESSES.STELLAR;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static ADDRESS_TYPES = new AddressTypes({
PRIVATE_KEY: 'privateKey',
PUBLIC_KEY: 'publicKey'
});
static DEFAULT_ADDRESS_TYPE = Stellar.ADDRESS_TYPES.PRIVATE_KEY;
static PARAMS = new Params({
CHECKSUM_LENGTH: 0x02,
ADDRESS_TYPES: {
PRIVATE_KEY: 18 << 3,
PUBLIC_KEY: 6 << 3
}
});
}
// SPDX-License-Identifier: MIT
class Mainnet$v extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x3f;
static SCRIPT_ADDRESS_PREFIX = 0x7d;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Stratis Signed Message:\n';
static WIF_PREFIX = 0xbf;
}
class Testnet$4 extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x41;
static SCRIPT_ADDRESS_PREFIX = 0x7d;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Stratis Test Signed Message:\n';
static WIF_PREFIX = 0xbf;
}
class Stratis extends Cryptocurrency {
static NAME = 'Stratis';
static SYMBOL = 'STRAT';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/stratisproject',
WHITEPAPER: 'https://www.stratisplatform.com/files/Stratis_Whitepaper.pdf',
WEBSITES: [
'http://stratisplatform.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Stratis;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$v,
TESTNET: Testnet$4
});
static DEFAULT_NETWORK = Stratis.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Stratis.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Stratis.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Stratis.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$u extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x3f;
static SCRIPT_ADDRESS_PREFIX = 0x7d;
static HRP = 'sugar';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2
});
static MESSAGE_PREFIX = '\x18Sugarchain Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Testnet$3 extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x42;
static SCRIPT_ADDRESS_PREFIX = 0x80;
static HRP = 'tugar';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x045f18bc,
P2SH: 0x045f18bc,
P2WPKH: 0x045f18bc,
P2WPKH_IN_P2SH: 0x044a4e28
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x045f1cf6,
P2SH: 0x045f1cf6,
P2WPKH: 0x045f1cf6,
P2WPKH_IN_P2SH: 0x044a5262
});
static MESSAGE_PREFIX = '\x18Sugarchain Signed Message:\n';
static WIF_PREFIX = 0xef;
}
class Sugarchain extends Cryptocurrency {
static NAME = 'Sugarchain';
static SYMBOL = 'SUGAR';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/sugarchain-project/sugarchain',
WHITEPAPER: 'https://sugarchain.org/whitepaper',
WEBSITES: [
'https://sugarchain.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Sugarchain;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$u,
TESTNET: Testnet$3
});
static DEFAULT_NETWORK = Sugarchain.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Sugarchain.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Sugarchain.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' }
]);
static DEFAULT_ADDRESS = Sugarchain.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$t extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
}
class Sui extends Cryptocurrency {
static NAME = 'Sui';
static SYMBOL = 'SUI';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/MystenLabs/sui',
WHITEPAPER: 'https://docs.sui.io',
WEBSITES: [
'https://sui.io'
]
});
static ECC = SLIP10Ed25519ECC;
static COIN_TYPE = CoinTypes.Sui;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$t
});
static DEFAULT_NETWORK = Sui.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Sui.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Sui.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
SUI: 'Sui'
});
static DEFAULT_ADDRESS = Sui.ADDRESSES.SUI;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static PARAMS = new Params({
KEY_TYPE: 0x00,
ADDRESS_PREFIX: '0x'
});
}
// SPDX-License-Identifier: MIT
class Mainnet$s extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x3f;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static HRP = 'sys';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x04b2430c,
P2WPKH_IN_P2SH: 0x049d7878
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x04b24746,
P2WPKH_IN_P2SH: 0x049d7cb2
});
static MESSAGE_PREFIX = '\x18Syscoin Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Syscoin extends Cryptocurrency {
static NAME = 'Syscoin';
static SYMBOL = 'SYS';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/syscoin/syscoin',
WHITEPAPER: 'https://syscoin.org/research-whitepapers',
WEBSITES: [
'http://syscoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Syscoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$s
});
static DEFAULT_NETWORK = Syscoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Syscoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Syscoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' }
]);
static DEFAULT_ADDRESS = Syscoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$r extends Network {
static NAME = 'mainnet';
static HRP = 'terra';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Terra extends Cryptocurrency {
static NAME = 'Terra';
static SYMBOL = 'LUNA';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/terra-money/core',
WHITEPAPER: 'https://docs.terra.money',
WEBSITES: [
'https://terra.money'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Terra;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$r
});
static DEFAULT_NETWORK = Terra.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Terra.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Terra.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
COSMOS: 'Cosmos'
});
static DEFAULT_ADDRESS = Terra.ADDRESSES.COSMOS;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$q extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
}
class Tezos extends Cryptocurrency {
static NAME = 'Tezos';
static SYMBOL = 'XTZ';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/tezos/tezos',
WHITEPAPER: 'https://tezos.com/whitepaper.pdf',
WEBSITES: [
'https://www.tezos.com'
]
});
static ECC = SLIP10Ed25519ECC;
static COIN_TYPE = CoinTypes.Tezos;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$q
});
static DEFAULT_NETWORK = Tezos.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Tezos.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Tezos.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
TEZOS: 'Tezos'
});
static DEFAULT_ADDRESS = Tezos.ADDRESSES.TEZOS;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static ADDRESS_PREFIXES = new AddressPrefixes({
TZ1: 'tz1',
TZ2: 'tz2',
TZ3: 'tz3'
});
static DEFAULT_ADDRESS_PREFIX = Tezos.ADDRESS_PREFIXES.TZ1;
static PARAMS = new Params({
ADDRESS_PREFIXES: {
TZ1: '06a19f',
TZ2: '06a1a1',
TZ3: '06a1a4'
}
});
}
// SPDX-License-Identifier: MIT
class Mainnet$p extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Theta extends Cryptocurrency {
static NAME = 'Theta';
static SYMBOL = 'THETA';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/thetatoken',
WHITEPAPER: 'https://s3.us-east-2.amazonaws.com/assets.thetatoken.org/Theta-white-paper-latest.pdf?v=1553657855.509',
WEBSITES: [
'https://www.thetatoken.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Theta;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$p
});
static DEFAULT_NETWORK = Theta.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Theta.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Theta.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
ETHEREUM: 'Ethereum'
});
static DEFAULT_ADDRESS = Theta.ADDRESSES.ETHEREUM;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$o extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x07;
static SCRIPT_ADDRESS_PREFIX = 0x09;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x5aebd8c6,
P2SH: 0x5aebd8c6
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0xfbc6a00d,
P2SH: 0xfbc6a00d
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0x7b;
}
class ThoughtAI extends Cryptocurrency {
static NAME = 'Thought-AI';
static SYMBOL = 'THT';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/thoughtnetwork',
WHITEPAPER: 'https://github.com/thoughtnetwork/thought-whitepaper',
WEBSITES: [
'https://thought.live'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.ThoughtAI;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$o
});
static DEFAULT_NETWORK = ThoughtAI.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = ThoughtAI.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${ThoughtAI.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = ThoughtAI.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$n extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x41;
static SCRIPT_ADDRESS_PREFIX = 0x17;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18TOA Signed Message:\n';
static WIF_PREFIX = 0xc1;
}
class TOACoin extends Cryptocurrency {
static NAME = 'TOA-Coin';
static SYMBOL = 'TOA';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/toacoin/TOA',
WHITEPAPER: 'https://toacoin.com/toa-whitepaper',
WEBSITES: [
'http://www.toacoin.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.TOACoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$n
});
static DEFAULT_NETWORK = TOACoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = TOACoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${TOACoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = TOACoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$m extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x41;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0x80;
}
class Tron extends Cryptocurrency {
static NAME = 'Tron';
static SYMBOL = 'TRX';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/tronprotocol/java-tron',
WHITEPAPER: 'https://developers.tron.network/docs',
WEBSITES: [
'https://trondao.org',
'https://tron.network'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Tron;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$m
});
static DEFAULT_NETWORK = Tron.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Tron.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Tron.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
TRON: 'Tron'
});
static DEFAULT_ADDRESS = Tron.ADDRESSES.TRON;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static PARAMS = new Params({
ALPHABET: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
});
}
// SPDX-License-Identifier: MIT
class Mainnet$l extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x49;
static SCRIPT_ADDRESS_PREFIX = 0x53;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0221312b,
P2SH: 0x0221312b
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x022d2533,
P2SH: 0x022d2533
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0x42;
}
class Testnet$2 extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x4c;
static SCRIPT_ADDRESS_PREFIX = 0x89;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x3a805837,
P2SH: 0x3a805837
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x3a8061a0,
P2SH: 0x3a8061a0
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0xed;
}
class TWINS extends Cryptocurrency {
static NAME = 'TWINS';
static SYMBOL = 'TWINS';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/NewCapital/TWINS-Core',
WEBSITES: [
'https://win.win'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.TWINS;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$l,
TESTNET: Testnet$2
});
static DEFAULT_NETWORK = TWINS.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = TWINS.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${TWINS.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = TWINS.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$k extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x44;
static SCRIPT_ADDRESS_PREFIX = 0x7d;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0xee8031e8,
P2SH: 0xee8031e8
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0xee80286a,
P2SH: 0xee80286a
});
static MESSAGE_PREFIX = '\x18UltimateSecureCash Signed Message:\n';
static WIF_PREFIX = 0xbf;
}
class UltimateSecureCash extends Cryptocurrency {
static NAME = 'Ultimate-Secure-Cash';
static SYMBOL = 'USC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/SilentTrader/UltimateSecureCash',
WHITEPAPER: 'https://ultimatesecurecash.info/#spec',
WEBSITES: [
'http://ultimatesecurecash.info'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.UltimateSecureCash;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$k
});
static DEFAULT_NETWORK = UltimateSecureCash.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = UltimateSecureCash.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${UltimateSecureCash.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = UltimateSecureCash.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$j extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x82;
static SCRIPT_ADDRESS_PREFIX = 0x1e;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Unobtanium Signed Message:\n';
static WIF_PREFIX = 0xe0;
}
class Unobtanium extends Cryptocurrency {
static NAME = 'Unobtanium';
static SYMBOL = 'UNO';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/unobtanium-official/Unobtanium',
WEBSITES: [
'http://unobtanium.uno'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Unobtanium;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$j
});
static DEFAULT_NETWORK = Unobtanium.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Unobtanium.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Unobtanium.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Unobtanium.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$i extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x47;
static SCRIPT_ADDRESS_PREFIX = 0x08;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Vcash Signed Message:\n';
static WIF_PREFIX = 0xc7;
}
class Vcash extends Cryptocurrency {
static NAME = 'Vcash';
static SYMBOL = 'VC';
static INFO = new Info({
WHITEPAPER: 'https://vcash.finance/wp-content/uploads/2023/01/VCash-3.pdf',
WEBSITES: [
'https://vcash.finance'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Vcash;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$i
});
static DEFAULT_NETWORK = Vcash.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Vcash.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Vcash.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Vcash.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$h extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class VeChain extends Cryptocurrency {
static NAME = 'VeChain';
static SYMBOL = 'VET';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/vechain',
WHITEPAPER: 'https://www.vechain.org/whitepaper/#bit_65sv8',
WEBSITES: [
'https://www.vechain.org',
'https://vebetterdao.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.VeChain;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$h
});
static DEFAULT_NETWORK = VeChain.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = VeChain.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${VeChain.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
ETHEREUM: 'Ethereum'
});
static DEFAULT_ADDRESS = VeChain.ADDRESSES.ETHEREUM;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$g extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x1e;
static SCRIPT_ADDRESS_PREFIX = 0x21;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18VERGE Signed Message:\n';
static WIF_PREFIX = 0x9e;
}
class Verge extends Cryptocurrency {
static NAME = 'Verge';
static SYMBOL = 'XVG';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/vergecurrency/verge',
WHITEPAPER: 'https://vergecurrency.com/static/blackpaper/verge-blackpaper-v5.0.pdf',
WEBSITES: [
'http://vergecurrency.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Verge;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$g
});
static DEFAULT_NETWORK = Verge.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Verge.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Verge.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Verge.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$f extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x47;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static HRP = 'vtc';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x0488ade4,
P2WPKH_IN_P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x0488b21e,
P2WPKH_IN_P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Vertcoin Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Vertcoin extends Cryptocurrency {
static NAME = 'Vertcoin';
static SYMBOL = 'VTC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/vertcoin/vertcoin',
WHITEPAPER: 'https://vertcoin.org/specs-explained',
WEBSITES: [
'http://vertcoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Vertcoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$f
});
static DEFAULT_NETWORK = Vertcoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Vertcoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Vertcoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' }
]);
static DEFAULT_ADDRESS = Vertcoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$e extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x47;
static SCRIPT_ADDRESS_PREFIX = 0x21;
static HRP = 'via';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4,
P2WPKH: 0x0488ade4,
P2WPKH_IN_P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e,
P2WPKH: 0x0488b21e,
P2WPKH_IN_P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Viacoin Signed Message:\n';
static WIF_PREFIX = 0xc7;
}
class Testnet$1 extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x7f;
static SCRIPT_ADDRESS_PREFIX = 0xc4;
static HRP = 'tvia';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x04358394,
P2SH: 0x04358394,
P2WPKH: 0x045f18bc,
P2WPKH_IN_P2SH: 0x044a4e28
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x043587cf,
P2SH: 0x043587cf,
P2WPKH: 0x045f1cf6,
P2WPKH_IN_P2SH: 0x044a5262
});
static MESSAGE_PREFIX = '\x18Viacoin Signed Message:\n';
static WIF_PREFIX = 0xff;
}
class Viacoin extends Cryptocurrency {
static NAME = 'Viacoin';
static SYMBOL = 'VIA';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/viacoin/viacoin',
WHITEPAPER: 'https://github.com/viacoin/documents/blob/master/whitepapers/Viacoin_fullcolor_whitepaper.pdf',
WEBSITES: [
'http://viacoin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Viacoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$e,
TESTNET: Testnet$1
});
static DEFAULT_NETWORK = Viacoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Viacoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Viacoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH',
'P2WPKH',
{ P2WPKH_IN_P2SH: 'P2WPKH-In-P2SH' }
]);
static DEFAULT_ADDRESS = Viacoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh', 'p2wpkh', 'p2wpkh-in-p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$d extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x46;
static SCRIPT_ADDRESS_PREFIX = 0x0a;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18DarkCoin Signed Message:\n';
static WIF_PREFIX = 0xc6;
}
class Vivo extends Cryptocurrency {
static NAME = 'Vivo';
static SYMBOL = 'VIVO';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/vivocoin/vivo',
WHITEPAPER: 'https://vivoproject.net/whitepaper.html',
WEBSITES: [
'http://www.vivoproject.net'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Vivo;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$d
});
static DEFAULT_NETWORK = Vivo.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Vivo.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Vivo.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Vivo.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$c extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x46;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Voxels Signed Message:\n';
static WIF_PREFIX = 0xc6;
}
class Voxels extends Cryptocurrency {
static NAME = 'Voxels';
static SYMBOL = 'VOX';
static INFO = new Info({
WEBSITES: [
'http://revolutionvr.live',
'https://thevoxel.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Voxels;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$c
});
static DEFAULT_NETWORK = Voxels.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Voxels.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Voxels.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Voxels.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$b extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x47;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18VpnCoin Signed Message:\n';
static WIF_PREFIX = 0xc7;
}
class VPNCoin extends Cryptocurrency {
static NAME = 'Virtual-Cash';
static SYMBOL = 'VASH';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/Bit-Net/vash',
WEBSITES: [
'http://www.bitnet.cc'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.VPNCoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$b
});
static DEFAULT_NETWORK = VPNCoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = VPNCoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${VPNCoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = VPNCoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$a extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x49;
static SCRIPT_ADDRESS_PREFIX = 0x3f;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0221312b,
P2SH: 0x0221312b
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x022d2533,
P2SH: 0x022d2533
});
static WIF_PREFIX = 0xc7;
}
class Wagerr extends Cryptocurrency {
static NAME = 'Wagerr';
static SYMBOL = 'WGR';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/wagerr/wagerr',
WHITEPAPER: 'https://www.wagerr.com/wagerr_whitepaper_v1.pdf',
WEBSITES: [
'https://www.wagerr.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Wagerr;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$a
});
static DEFAULT_NETWORK = Wagerr.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Wagerr.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Wagerr.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Wagerr.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$9 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x49;
static SCRIPT_ADDRESS_PREFIX = 0x57;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x048894ed,
P2SH: 0x048894ed
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x04887f1e,
P2SH: 0x04887f1e
});
static MESSAGE_PREFIX = '\x18Whitecoin Signed Message:\n';
static WIF_PREFIX = 0xc9;
}
class Whitecoin extends Cryptocurrency {
static NAME = 'Whitecoin';
static SYMBOL = 'XWC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/Whitecoin-XWC/Whitecoin-core',
WHITEPAPER: 'https://www.whitecoin.info/pdf/Whitecoin%20Technical%20White%20Paper_en.pdf',
WEBSITES: [
'http://whitecoin.info',
'http://xwc.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Whitecoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$9
});
static DEFAULT_NETWORK = Whitecoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Whitecoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Whitecoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Whitecoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$8 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x49;
static SCRIPT_ADDRESS_PREFIX = 0x1c;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18WinCoin Signed Message:\n';
static WIF_PREFIX = 0xc9;
}
class Wincoin extends Cryptocurrency {
static NAME = 'Wincoin';
static SYMBOL = 'WC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/Wincoinofficial/wincoin',
WHITEPAPER: 'https://wincoin.co/Public/Upload/wincoin/WINCOIN%20-%20Eng%20V%201.0.pdf',
WEBSITES: [
'https://wincoin.co'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Wincoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$8
});
static DEFAULT_NETWORK = Wincoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Wincoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Wincoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Wincoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$7 extends Network {
static NAME = 'mainnet';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class XinFin extends Cryptocurrency {
static NAME = 'XinFin';
static SYMBOL = 'XDC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/XinFinOrg/XDPoSChain',
WHITEPAPER: 'https://xinfin.org/docs/whitepaper-tech.pdf',
WEBSITES: [
'https://www.xdc.org',
'https://www.xinfin.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.XinFin;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$7
});
static DEFAULT_NETWORK = XinFin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = XinFin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${XinFin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
XINFIN: 'XinFin'
});
static DEFAULT_ADDRESS = XinFin.ADDRESSES.XINFIN;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
static PARAMS = new Params({
ADDRESS_PREFIX: 'xdc'
});
}
// SPDX-License-Identifier: MIT
class Mainnet$6 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x4b;
static SCRIPT_ADDRESS_PREFIX = 0x12;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0221312b,
P2SH: 0x0221312b
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x022d2533,
P2SH: 0x022d2533
});
static MESSAGE_PREFIX = null;
static WIF_PREFIX = 0xd4;
}
class XUEZ extends Cryptocurrency {
static NAME = 'XUEZ';
static SYMBOL = 'XUEZ';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/XUEZ/Xuez-Core',
WHITEPAPER: 'https://github.com/XUEZ/Whitepaper',
WEBSITES: [
'https://xuezcoin.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.XUEZ;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$6
});
static DEFAULT_NETWORK = XUEZ.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = XUEZ.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${XUEZ.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = XUEZ.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$5 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x00001c28;
static SCRIPT_ADDRESS_PREFIX = 0x00001c2c;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Ycash Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Ycash extends Cryptocurrency {
static NAME = 'Ycash';
static SYMBOL = 'YEC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/ycashfoundation/ycash',
WEBSITES: [
'https://y.cash',
'https://www.ycash.xyz'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Ycash;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$5
});
static DEFAULT_NETWORK = Ycash.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Ycash.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Ycash.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Ycash.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$4 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x00001cb8;
static SCRIPT_ADDRESS_PREFIX = 0x00001cbd;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Zcash Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class Testnet extends Network {
static NAME = 'testnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x00001d25;
static SCRIPT_ADDRESS_PREFIX = 0x00001cba;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x04358394,
P2SH: 0x04358394
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x043587cf,
P2SH: 0x043587cf
});
static MESSAGE_PREFIX = '\x18Zcash Signed Message:\n';
static WIF_PREFIX = 0xef;
}
class Zcash extends Cryptocurrency {
static NAME = 'Zcash';
static SYMBOL = 'ZEC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/zcash/zcash',
WHITEPAPER: 'https://github.com/zcash/zips/blob/master/protocol/protocol.pdf',
WEBSITES: [
'https://z.cash'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Zcash;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$4,
TESTNET: Testnet
});
static DEFAULT_NETWORK = Zcash.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Zcash.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Zcash.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Zcash.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$3 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x00001cb8;
static SCRIPT_ADDRESS_PREFIX = 0x00001cbd;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Zcash Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class ZClassic extends Cryptocurrency {
static NAME = 'ZClassic';
static SYMBOL = 'ZCL';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/ZClassicCommunity/zclassic',
WHITEPAPER: 'https://zclassic.org/zclassic-whitepaper.pdf',
WEBSITES: [
'https://zclassic.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.ZClassic;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$3
});
static DEFAULT_NETWORK = ZClassic.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = ZClassic.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${ZClassic.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = ZClassic.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$2 extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x50;
static SCRIPT_ADDRESS_PREFIX = 0x09;
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18Zetacoin Signed Message:\n';
static WIF_PREFIX = 0xe0;
}
class Zetacoin extends Cryptocurrency {
static NAME = 'Zetacoin';
static SYMBOL = 'ZET';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/zetacoin/zetacoin',
WEBSITES: [
'http://www.zetac.org'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Zetacoin;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet$2
});
static DEFAULT_NETWORK = Zetacoin.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Zetacoin.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Zetacoin.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = Zetacoin.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet$1 extends Network {
static NAME = 'mainnet';
static HRP = 'zil';
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e
});
static WIF_PREFIX = 0x80;
}
class Zilliqa extends Cryptocurrency {
static NAME = 'Zilliqa';
static SYMBOL = 'ZIL';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/Zilliqa/Zilliqa',
WHITEPAPER: 'https://docs.zilliqa.com/whitepaper.pdf',
WEBSITES: [
'https://www.zilliqa.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.Zilliqa;
static SUPPORT_BIP38 = false;
static NETWORKS = new Networks({
MAINNET: Mainnet$1
});
static DEFAULT_NETWORK = Zilliqa.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = Zilliqa.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${Zilliqa.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses({
ZILLIQA: 'Zilliqa'
});
static DEFAULT_ADDRESS = Zilliqa.ADDRESSES.ZILLIQA;
static SEMANTICS = ['p2pkh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class Mainnet extends Network {
static NAME = 'mainnet';
static PUBLIC_KEY_ADDRESS_PREFIX = 0x00;
static SCRIPT_ADDRESS_PREFIX = 0x05;
static HRP = 'bc';
static WITNESS_VERSIONS = new WitnessVersions({
P2WPKH: 0x00,
P2WSH: 0x00
});
static XPRIVATE_KEY_VERSIONS = new XPrivateKeyVersions({
P2PKH: 0x0488ade4,
P2SH: 0x0488ade4
});
static XPUBLIC_KEY_VERSIONS = new XPublicKeyVersions({
P2PKH: 0x0488b21e,
P2SH: 0x0488b21e
});
static MESSAGE_PREFIX = '\x18ZooBC Signed Message:\n';
static WIF_PREFIX = 0x80;
}
class ZooBC extends Cryptocurrency {
static NAME = 'ZooBC';
static SYMBOL = 'ZBC';
static INFO = new Info({
SOURCE_CODE: 'https://github.com/zoobc/zoobc-core',
WHITEPAPER: 'https://git.hush.is',
WEBSITES: [
'https://zoobc.one',
'https://zoobc.com'
]
});
static ECC = SLIP10Secp256k1ECC;
static COIN_TYPE = CoinTypes.ZooBC;
static SUPPORT_BIP38 = true;
static NETWORKS = new Networks({
MAINNET: Mainnet
});
static DEFAULT_NETWORK = ZooBC.NETWORKS.MAINNET;
static ENTROPIES = new Entropies([
'BIP39'
]);
static MNEMONICS = new Mnemonics([
'BIP39'
]);
static SEEDS = new Seeds([
'BIP39'
]);
static HDS = new HDs([
'BIP32',
'BIP44'
]);
static DEFAULT_HD = ZooBC.HDS.BIP44;
static DEFAULT_PATH = `m/44'/${ZooBC.COIN_TYPE}'/0'/0/0`;
static ADDRESSES = new Addresses([
'P2PKH',
'P2SH'
]);
static DEFAULT_ADDRESS = ZooBC.ADDRESSES.P2PKH;
static SEMANTICS = ['p2pkh', 'p2sh'];
static DEFAULT_SEMANTIC = 'p2pkh';
}
// SPDX-License-Identifier: MIT
class CRYPTOCURRENCIES {
static dictionary = {
[Adcoin.NAME]: Adcoin,
[AkashNetwork.NAME]: AkashNetwork,
[Algorand.NAME]: Algorand,
[Anon.NAME]: Anon,
[Aptos.NAME]: Aptos,
[Arbitrum.NAME]: Arbitrum,
[Argoneum.NAME]: Argoneum,
[Artax.NAME]: Artax,
[Aryacoin.NAME]: Aryacoin,
[Asiacoin.NAME]: Asiacoin,
[Auroracoin.NAME]: Auroracoin,
[Avalanche.NAME]: Avalanche,
[Avian.NAME]: Avian,
[Axe.NAME]: Axe,
[Axelar.NAME]: Axelar,
[BandProtocol.NAME]: BandProtocol,
[Base.NAME]: Base,
[Bata.NAME]: Bata,
[BeetleCoin.NAME]: BeetleCoin,
[BelaCoin.NAME]: BelaCoin,
[Binance.NAME]: Binance,
[BitCloud.NAME]: BitCloud,
[Bitcoin.NAME]: Bitcoin,
[BitcoinAtom.NAME]: BitcoinAtom,
[BitcoinCash.NAME]: BitcoinCash,
[BitcoinCashSLP.NAME]: BitcoinCashSLP,
[BitcoinGold.NAME]: BitcoinGold,
[BitcoinGreen.NAME]: BitcoinGreen,
[BitcoinPlus.NAME]: BitcoinPlus,
[BitcoinPrivate.NAME]: BitcoinPrivate,
[BitcoinSV.NAME]: BitcoinSV,
[BitcoinZ.NAME]: BitcoinZ,
[Bitcore.NAME]: Bitcore,
[BitSend.NAME]: BitSend,
[Blackcoin.NAME]: Blackcoin,
[Blocknode.NAME]: Blocknode,
[BlockStamp.NAME]: BlockStamp,
[Bolivarcoin.NAME]: Bolivarcoin,
[BritCoin.NAME]: BritCoin,
[CanadaECoin.NAME]: CanadaECoin,
[Cannacoin.NAME]: Cannacoin,
[Cardano.NAME]: Cardano,
[Celo.NAME]: Celo,
[Chihuahua.NAME]: Chihuahua,
[Clams.NAME]: Clams,
[ClubCoin.NAME]: ClubCoin,
[Compcoin.NAME]: Compcoin,
[Cosmos.NAME]: Cosmos,
[CPUChain.NAME]: CPUChain,
[CranePay.NAME]: CranePay,
[Crave.NAME]: Crave,
[Dash.NAME]: Dash,
[DeepOnion.NAME]: DeepOnion,
[Defcoin.NAME]: Defcoin,
[Denarius.NAME]: Denarius,
[Diamond.NAME]: Diamond,
[DigiByte.NAME]: DigiByte,
[Digitalcoin.NAME]: Digitalcoin,
[Divi.NAME]: Divi,
[Dogecoin.NAME]: Dogecoin,
[dYdX.NAME]: dYdX,
[eCash.NAME]: eCash,
[ECoin.NAME]: ECoin,
[EDRCoin.NAME]: EDRCoin,
[eGulden.NAME]: eGulden,
[Einsteinium.NAME]: Einsteinium,
[Elastos.NAME]: Elastos,
[Energi.NAME]: Energi,
[EOS.NAME]: EOS,
[Ergo.NAME]: Ergo,
[Ethereum.NAME]: Ethereum,
[EuropeCoin.NAME]: EuropeCoin,
[Evrmore.NAME]: Evrmore,
[ExclusiveCoin.NAME]: ExclusiveCoin,
[Fantom.NAME]: Fantom,
[Feathercoin.NAME]: Feathercoin,
[FetchAI.NAME]: FetchAI,
[Filecoin.NAME]: Filecoin,
[Firo.NAME]: Firo,
[Firstcoin.NAME]: Firstcoin,
[FIX.NAME]: FIX,
[Flashcoin.NAME]: Flashcoin,
[Flux.NAME]: Flux,
[Foxdcoin.NAME]: Foxdcoin,
[FujiCoin.NAME]: FujiCoin,
[GameCredits.NAME]: GameCredits,
[GCRCoin.NAME]: GCRCoin,
[GoByte.NAME]: GoByte,
[Gridcoin.NAME]: Gridcoin,
[GroestlCoin.NAME]: GroestlCoin,
[Gulden.NAME]: Gulden,
[Harmony.NAME]: Harmony,
[Helleniccoin.NAME]: Helleniccoin,
[Hempcoin.NAME]: Hempcoin,
[Horizen.NAME]: Horizen,
[HuobiToken.NAME]: HuobiToken,
[Hush.NAME]: Hush,
[Icon.NAME]: Icon,
[Injective.NAME]: Injective,
[InsaneCoin.NAME]: InsaneCoin,
[InternetOfPeople.NAME]: InternetOfPeople,
[IRISnet.NAME]: IRISnet,
[IXCoin.NAME]: IXCoin,
[Jumbucks.NAME]: Jumbucks,
[Kava.NAME]: Kava,
[Kobocoin.NAME]: Kobocoin,
[Komodo.NAME]: Komodo,
[Landcoin.NAME]: Landcoin,
[LBRYCredits.NAME]: LBRYCredits,
[Linx.NAME]: Linx,
[Litecoin.NAME]: Litecoin,
[LitecoinCash.NAME]: LitecoinCash,
[LitecoinZ.NAME]: LitecoinZ,
[Lkrcoin.NAME]: Lkrcoin,
[Lynx.NAME]: Lynx,
[Mazacoin.NAME]: Mazacoin,
[Megacoin.NAME]: Megacoin,
[Metis.NAME]: Metis,
[Minexcoin.NAME]: Minexcoin,
[Monacoin.NAME]: Monacoin,
[Monero.NAME]: Monero,
[Monk.NAME]: Monk,
[MultiversX.NAME]: MultiversX,
[Myriadcoin.NAME]: Myriadcoin,
[Namecoin.NAME]: Namecoin,
[Nano.NAME]: Nano,
[Navcoin.NAME]: Navcoin,
[Near.NAME]: Near,
[Neblio.NAME]: Neblio,
[Neo.NAME]: Neo,
[Neoscoin.NAME]: Neoscoin,
[Neurocoin.NAME]: Neurocoin,
[Neutron.NAME]: Neutron,
[NewYorkCoin.NAME]: NewYorkCoin,
[NineChronicles.NAME]: NineChronicles,
[NIX.NAME]: NIX,
[Novacoin.NAME]: Novacoin,
[NuBits.NAME]: NuBits,
[NuShares.NAME]: NuShares,
[OKCash.NAME]: OKCash,
[OKTChain.NAME]: OKTChain,
[Omni.NAME]: Omni,
[Onix.NAME]: Onix,
[Ontology.NAME]: Ontology,
[Optimism.NAME]: Optimism,
[Osmosis.NAME]: Osmosis,
[Particl.NAME]: Particl,
[Peercoin.NAME]: Peercoin,
[Pesobit.NAME]: Pesobit,
[Phore.NAME]: Phore,
[PiNetwork.NAME]: PiNetwork,
[Pinkcoin.NAME]: Pinkcoin,
[Pivx.NAME]: Pivx,
[Polygon.NAME]: Polygon,
[PoSWCoin.NAME]: PoSWCoin,
[Potcoin.NAME]: Potcoin,
[ProjectCoin.NAME]: ProjectCoin,
[Putincoin.NAME]: Putincoin,
[Qtum.NAME]: Qtum,
[Rapids.NAME]: Rapids,
[Ravencoin.NAME]: Ravencoin,
[Reddcoin.NAME]: Reddcoin,
[Ripple.NAME]: Ripple,
[Ritocoin.NAME]: Ritocoin,
[RSK.NAME]: RSK,
[Rubycoin.NAME]: Rubycoin,
[Safecoin.NAME]: Safecoin,
[Saluscoin.NAME]: Saluscoin,
[Scribe.NAME]: Scribe,
[Secret.NAME]: Secret,
[ShadowCash.NAME]: ShadowCash,
[Shentu.NAME]: Shentu,
[Slimcoin.NAME]: Slimcoin,
[Smileycoin.NAME]: Smileycoin,
[Solana.NAME]: Solana,
[Solarcoin.NAME]: Solarcoin,
[Stafi.NAME]: Stafi,
[Stash.NAME]: Stash,
[Stellar.NAME]: Stellar,
[Stratis.NAME]: Stratis,
[Sugarchain.NAME]: Sugarchain,
[Sui.NAME]: Sui,
[Syscoin.NAME]: Syscoin,
[Terra.NAME]: Terra,
[Tezos.NAME]: Tezos,
[Theta.NAME]: Theta,
[ThoughtAI.NAME]: ThoughtAI,
[TOACoin.NAME]: TOACoin,
[Tron.NAME]: Tron,
[TWINS.NAME]: TWINS,
[UltimateSecureCash.NAME]: UltimateSecureCash,
[Unobtanium.NAME]: Unobtanium,
[Vcash.NAME]: Vcash,
[VeChain.NAME]: VeChain,
[Verge.NAME]: Verge,
[Vertcoin.NAME]: Vertcoin,
[Viacoin.NAME]: Viacoin,
[Vivo.NAME]: Vivo,
[Voxels.NAME]: Voxels,
[VPNCoin.NAME]: VPNCoin,
[Wagerr.NAME]: Wagerr,
[Whitecoin.NAME]: Whitecoin,
[Wincoin.NAME]: Wincoin,
[XinFin.NAME]: XinFin,
[XUEZ.NAME]: XUEZ,
[Ycash.NAME]: Ycash,
[Zcash.NAME]: Zcash,
[ZClassic.NAME]: ZClassic,
[Zetacoin.NAME]: Zetacoin,
[Zilliqa.NAME]: Zilliqa,
[ZooBC.NAME]: ZooBC,
};
static getNames() {
return Object.keys(this.dictionary);
}
static getClasses() {
return Object.values(this.dictionary);
}
static getCryptocurrencyClass(name) {
if (!this.isCryptocurrency(name)) {
throw new CryptocurrencyError('Invalid cryptocurrency name', { expected: this.getNames(), got: name });
}
return this.dictionary[name];
}
static isCryptocurrency(name) {
return name in this.dictionary;
}
}
function getCryptocurrency(symbol) {
for (const cls of CRYPTOCURRENCIES.getClasses()) {
if (cls.SYMBOL === symbol) {
return cls;
}
}
throw new SymbolError(`Cryptocurrency not found with symbol ${symbol}`);
}
var cryptocurrencies = /*#__PURE__*/Object.freeze({
__proto__: null,
CRYPTOCURRENCIES: CRYPTOCURRENCIES,
getCryptocurrency: getCryptocurrency,
Cryptocurrency: Cryptocurrency,
Adcoin: Adcoin,
AkashNetwork: AkashNetwork,
Algorand: Algorand,
Anon: Anon,
Aptos: Aptos,
Arbitrum: Arbitrum,
Argoneum: Argoneum,
Artax: Artax,
Aryacoin: Aryacoin,
Asiacoin: Asiacoin,
Auroracoin: Auroracoin,
Avalanche: Avalanche,
Avian: Avian,
Axe: Axe,
Axelar: Axelar,
BandProtocol: BandProtocol,
Base: Base,
Bata: Bata,
BeetleCoin: BeetleCoin,
BelaCoin: BelaCoin,
Binance: Binance,
BitCloud: BitCloud,
Bitcoin: Bitcoin,
BitcoinAtom: BitcoinAtom,
BitcoinCash: BitcoinCash,
BitcoinCashSLP: BitcoinCashSLP,
BitcoinGold: BitcoinGold,
BitcoinGreen: BitcoinGreen,
BitcoinPlus: BitcoinPlus,
BitcoinPrivate: BitcoinPrivate,
BitcoinSV: BitcoinSV,
BitcoinZ: BitcoinZ,
Bitcore: Bitcore,
BitSend: BitSend,
Blackcoin: Blackcoin,
Blocknode: Blocknode,
BlockStamp: BlockStamp,
Bolivarcoin: Bolivarcoin,
BritCoin: BritCoin,
CanadaECoin: CanadaECoin,
Cannacoin: Cannacoin,
Cardano: Cardano,
Celo: Celo,
Chihuahua: Chihuahua,
Clams: Clams,
ClubCoin: ClubCoin,
Compcoin: Compcoin,
Cosmos: Cosmos,
CPUChain: CPUChain,
CranePay: CranePay,
Crave: Crave,
Dash: Dash,
DeepOnion: DeepOnion,
Defcoin: Defcoin,
Denarius: Denarius,
Diamond: Diamond,
DigiByte: DigiByte,
Digitalcoin: Digitalcoin,
Divi: Divi,
Dogecoin: Dogecoin,
dYdX: dYdX,
eCash: eCash,
ECoin: ECoin,
EDRCoin: EDRCoin,
eGulden: eGulden,
Einsteinium: Einsteinium,
Elastos: Elastos,
Energi: Energi,
EOS: EOS,
Ergo: Ergo,
Ethereum: Ethereum,
EuropeCoin: EuropeCoin,
Evrmore: Evrmore,
ExclusiveCoin: ExclusiveCoin,
Fantom: Fantom,
Feathercoin: Feathercoin,
FetchAI: FetchAI,
Filecoin: Filecoin,
Firo: Firo,
Firstcoin: Firstcoin,
FIX: FIX,
Flashcoin: Flashcoin,
Flux: Flux,
Foxdcoin: Foxdcoin,
FujiCoin: FujiCoin,
GameCredits: GameCredits,
GCRCoin: GCRCoin,
GoByte: GoByte,
Gridcoin: Gridcoin,
GroestlCoin: GroestlCoin,
Gulden: Gulden,
Harmony: Harmony,
Helleniccoin: Helleniccoin,
Hempcoin: Hempcoin,
Horizen: Horizen,
HuobiToken: HuobiToken,
Hush: Hush,
Icon: Icon,
Injective: Injective,
InsaneCoin: InsaneCoin,
InternetOfPeople: InternetOfPeople,
IRISnet: IRISnet,
IXCoin: IXCoin,
Jumbucks: Jumbucks,
Kava: Kava,
Kobocoin: Kobocoin,
Komodo: Komodo,
Landcoin: Landcoin,
LBRYCredits: LBRYCredits,
Linx: Linx,
Litecoin: Litecoin,
LitecoinCash: LitecoinCash,
LitecoinZ: LitecoinZ,
Lkrcoin: Lkrcoin,
Lynx: Lynx,
Mazacoin: Mazacoin,
Megacoin: Megacoin,
Metis: Metis,
Minexcoin: Minexcoin,
Monacoin: Monacoin,
Monero: Monero,
Monk: Monk,
MultiversX: MultiversX,
Myriadcoin: Myriadcoin,
Namecoin: Namecoin,
Nano: Nano,
Navcoin: Navcoin,
Near: Near,
Neblio: Neblio,
Neo: Neo,
Neoscoin: Neoscoin,
Neurocoin: Neurocoin,
Neutron: Neutron,
NewYorkCoin: NewYorkCoin,
NineChronicles: NineChronicles,
NIX: NIX,
Novacoin: Novacoin,
NuBits: NuBits,
NuShares: NuShares,
OKCash: OKCash,
OKTChain: OKTChain,
Omni: Omni,
Onix: Onix,
Ontology: Ontology,
Optimism: Optimism,
Osmosis: Osmosis,
Particl: Particl,
Peercoin: Peercoin,
Pesobit: Pesobit,
Phore: Phore,
PiNetwork: PiNetwork,
Pinkcoin: Pinkcoin,
Pivx: Pivx,
Polygon: Polygon,
PoSWCoin: PoSWCoin,
Potcoin: Potcoin,
ProjectCoin: ProjectCoin,
Putincoin: Putincoin,
Qtum: Qtum,
Rapids: Rapids,
Ravencoin: Ravencoin,
Reddcoin: Reddcoin,
Ripple: Ripple,
Ritocoin: Ritocoin,
RSK: RSK,
Rubycoin: Rubycoin,
Safecoin: Safecoin,
Saluscoin: Saluscoin,
Scribe: Scribe,
Secret: Secret,
ShadowCash: ShadowCash,
Shentu: Shentu,
Slimcoin: Slimcoin,
Smileycoin: Smileycoin,
Solana: Solana,
Solarcoin: Solarcoin,
Stafi: Stafi,
Stash: Stash,
Stellar: Stellar,
Stratis: Stratis,
Sugarchain: Sugarchain,
Sui: Sui,
Syscoin: Syscoin,
Terra: Terra,
Tezos: Tezos,
Theta: Theta,
ThoughtAI: ThoughtAI,
TOACoin: TOACoin,
Tron: Tron,
TWINS: TWINS,
UltimateSecureCash: UltimateSecureCash,
Unobtanium: Unobtanium,
Vcash: Vcash,
VeChain: VeChain,
Verge: Verge,
Vertcoin: Vertcoin,
Viacoin: Viacoin,
Vivo: Vivo,
Voxels: Voxels,
VPNCoin: VPNCoin,
Wagerr: Wagerr,
Whitecoin: Whitecoin,
Wincoin: Wincoin,
XinFin: XinFin,
XUEZ: XUEZ,
Ycash: Ycash,
Zcash: Zcash,
ZClassic: ZClassic,
Zetacoin: Zetacoin,
Zilliqa: Zilliqa,
ZooBC: ZooBC
});
// SPDX-License-Identifier: MIT
class Entropy {
entropy;
strength;
static strengths;
constructor(entropy) {
const entropyBytes = getBytes(entropy);
const strength = entropyBytes.length;
const constructor = this.constructor;
if (constructor.getName() === 'Electrum-V2') {
if (!constructor.areEntropyBitsEnough(entropyBytes)) {
throw new EntropyError('Entropy bits are not enough');
}
this.strength = BigInt(bytesToInteger(entropyBytes)).toString(2).length;
}
else {
if (!constructor.isValidBytesStrength(strength))
throw new EntropyError('Unsupported entropy strength');
this.strength = strength * 8;
}
this.entropy = bytesToHex(entropyBytes);
}
static getName() {
throw new Error('Must override getName()');
}
getName() {
return this.constructor.getName();
}
getEntropy() {
return this.entropy;
}
getStrength() {
return this.strength;
}
static generate(strength) {
if (!this.strengths.includes(strength)) {
throw new Error(`Invalid strength ${strength}`);
}
return bytesToHex(crypto.getRandomValues(new Uint8Array(strength / 8)));
}
static isValid(entropy) {
return /^[0-9a-fA-F]+$/.test(entropy) && this.isValidStrength(entropy.length * 4);
}
static isValidStrength(strength) {
return this.strengths.includes(strength);
}
static isValidBytesStrength(bytesStrength) {
return this.isValidStrength(bytesStrength * 8);
}
static areEntropyBitsEnough(entropy) {
throw new Error('Not implemented');
}
}
// SPDX-License-Identifier: MIT
const ALGORAND_ENTROPY_STRENGTHS = {
TWO_HUNDRED_FIFTY_SIX: 256
};
class AlgorandEntropy extends Entropy {
static strengths = [
ALGORAND_ENTROPY_STRENGTHS.TWO_HUNDRED_FIFTY_SIX
];
static getName() {
return 'Algorand';
}
}
// SPDX-License-Identifier: MIT
const BIP39_ENTROPY_STRENGTHS = {
ONE_HUNDRED_TWENTY_EIGHT: 128,
ONE_HUNDRED_SIXTY: 160,
ONE_HUNDRED_NINETY_TWO: 192,
TWO_HUNDRED_TWENTY_FOUR: 224,
TWO_HUNDRED_FIFTY_SIX: 256
};
class BIP39Entropy extends Entropy {
static strengths = [
BIP39_ENTROPY_STRENGTHS.ONE_HUNDRED_TWENTY_EIGHT,
BIP39_ENTROPY_STRENGTHS.ONE_HUNDRED_SIXTY,
BIP39_ENTROPY_STRENGTHS.ONE_HUNDRED_NINETY_TWO,
BIP39_ENTROPY_STRENGTHS.TWO_HUNDRED_TWENTY_FOUR,
BIP39_ENTROPY_STRENGTHS.TWO_HUNDRED_FIFTY_SIX
];
static getName() {
return 'BIP39';
}
}
// SPDX-License-Identifier: MIT
const ELECTRUM_V1_ENTROPY_STRENGTHS = {
ONE_HUNDRED_TWENTY_EIGHT: 128
};
class ElectrumV1Entropy extends Entropy {
static strengths = [
ELECTRUM_V1_ENTROPY_STRENGTHS.ONE_HUNDRED_TWENTY_EIGHT
];
static getName() {
return 'Electrum-V1';
}
}
// SPDX-License-Identifier: MIT
const ELECTRUM_V2_ENTROPY_STRENGTHS = {
ONE_HUNDRED_THIRTY_TWO: 132,
TWO_HUNDRED_SIXTY_FOUR: 264
};
class ElectrumV2Entropy extends Entropy {
static strengths = [
ELECTRUM_V2_ENTROPY_STRENGTHS.ONE_HUNDRED_THIRTY_TWO,
ELECTRUM_V2_ENTROPY_STRENGTHS.TWO_HUNDRED_SIXTY_FOUR
];
static getName() {
return 'Electrum-V2';
}
static generate(strength) {
if (!this.strengths.includes(strength)) {
throw new Error(`Invalid strength ${strength}`);
}
const byteLen = Math.ceil(strength / 8);
const mask = (BigInt(1) << BigInt(strength)) - BigInt(1);
const rndBuf = randomBytes(byteLen);
let rnd = BigInt('0x' + bytesToString(rndBuf)) & mask;
const msbMask = BigInt(1) << BigInt(strength - 1);
const combined = msbMask | rnd;
const outBytes = integerToBytes(combined, byteLen);
return bytesToHex(outBytes);
}
static isValid(entropy) {
return /^[0-9a-fA-F]+$/.test(entropy) && this.areEntropyBitsEnough(hexToBytes(entropy));
}
static isValidStrength(strength) {
return this.strengths.some((s) => strength >= s - 11 && strength <= s);
}
static areEntropyBitsEnough(entropy) {
let intVal = entropy instanceof Uint8Array ? bytesToInteger(entropy) : BigInt(entropy);
if (intVal <= BigInt(0))
return false;
const entropyStrength = intVal.toString(2).length - 1;
return this.isValidStrength(entropyStrength);
}
}
// SPDX-License-Identifier: MIT
const MONERO_ENTROPY_STRENGTHS = {
ONE_HUNDRED_TWENTY_EIGHT: 128,
TWO_HUNDRED_FIFTY_SIX: 256
};
class MoneroEntropy extends Entropy {
static strengths = [
MONERO_ENTROPY_STRENGTHS.ONE_HUNDRED_TWENTY_EIGHT,
MONERO_ENTROPY_STRENGTHS.TWO_HUNDRED_FIFTY_SIX
];
static getName() {
return 'Monero';
}
}
// SPDX-License-Identifier: MIT
class ENTROPIES {
static dictionary = {
[AlgorandEntropy.getName()]: AlgorandEntropy,
[BIP39Entropy.getName()]: BIP39Entropy,
[ElectrumV1Entropy.getName()]: ElectrumV1Entropy,
[ElectrumV2Entropy.getName()]: ElectrumV2Entropy,
[MoneroEntropy.getName()]: MoneroEntropy
};
static getNames() {
return Object.keys(this.dictionary);
}
static getClasses() {
return Object.values(this.dictionary);
}
static getEntropyClass(name) {
if (!this.isEntropy(name)) {
throw new EntropyError('Invalid Entropy name', { expected: this.getNames(), got: name });
}
return this.dictionary[name];
}
static isEntropy(name) {
return this.getNames().includes(name);
}
}
var entropies = /*#__PURE__*/Object.freeze({
__proto__: null,
ENTROPIES: ENTROPIES,
Entropy: Entropy,
AlgorandEntropy: AlgorandEntropy,
ALGORAND_ENTROPY_STRENGTHS: ALGORAND_ENTROPY_STRENGTHS,
BIP39Entropy: BIP39Entropy,
BIP39_ENTROPY_STRENGTHS: BIP39_ENTROPY_STRENGTHS,
ElectrumV1Entropy: ElectrumV1Entropy,
ELECTRUM_V1_ENTROPY_STRENGTHS: ELECTRUM_V1_ENTROPY_STRENGTHS,
ElectrumV2Entropy: ElectrumV2Entropy,
ELECTRUM_V2_ENTROPY_STRENGTHS: ELECTRUM_V2_ENTROPY_STRENGTHS,
MoneroEntropy: MoneroEntropy,
MONERO_ENTROPY_STRENGTHS: MONERO_ENTROPY_STRENGTHS
});
// SPDX-License-Identifier: MIT
class Mnemonic {
mnemonic;
words;
language;
options;
static wordsList = [];
static languages = [];
static wordLists = {};
constructor(mnemonic, options = {}) {
const constructor = this.constructor;
const words = constructor.normalize(mnemonic);
if (!constructor.isValid(words, options)) {
throw new MnemonicError('Invalid mnemonic words');
}
const [_, language] = constructor.findLanguage(words, options.wordLists);
this.mnemonic = words;
this.words = words.length;
this.language = language;
this.options = options;
}
static getName() {
throw new Error('Must override getName()');
}
getName() {
return this.constructor.getName();
}
getMnemonic() {
return this.mnemonic.join(' ');
}
getMnemonicType() {
throw new Error('Not implemented');
}
getWords() {
return this.words;
}
getLanguage() {
return this.language;
}
static fromWords(words, language, options = {}) {
throw new Error('Must override fromWords()');
}
static fromEntropy(entropy, language, options = {}) {
throw new Error('Must override fromEntropy()');
}
static encode(entropy, language, options = {}) {
throw new Error('Must override encode()');
}
static decode(mnemonic, options = {}) {
throw new Error('Must override decode()');
}
static getWordsListByLanguage(language, wordLists) {
const wordList = (wordLists ?? this.wordLists)[language];
if (!wordList) {
throw new MnemonicError(`No wordlist for language '${language}'`);
}
return wordList;
}
static findLanguage(mnemonic, wordLists) {
for (const language of this.languages) {
try {
const list = this.normalize(this.getWordsListByLanguage(language, wordLists));
const map = new Set(list);
for (const w of mnemonic) {
if (!map.has(w)) {
throw new MnemonicError(`Unknown word '${w}'`);
}
}
return [list, language];
}
catch {
continue;
}
}
throw new MnemonicError(`Invalid language for mnemonic: '${mnemonic.join(' ')}'`);
}
static isValid(mnemonic, options = {}) {
try {
this.decode(mnemonic, options);
return true;
}
catch {
return false;
}
}
static isValidLanguage(language) {
return this.languages.includes(language);
}
static isValidWords(words) {
return this.wordsList.includes(words);
}
static normalize(mnemonic) {
return typeof mnemonic === 'string' ? mnemonic.trim().split(/\s+/) : mnemonic;
}
}
// SPDX-License-Identifier: MIT
const WORDLIST$r = [
'abandon',
'ability',
'able',
'about',
'above',
'absent',
'absorb',
'abstract',
'absurd',
'abuse',
'access',
'accident',
'account',
'accuse',
'achieve',
'acid',
'acoustic',
'acquire',
'across',
'act',
'action',
'actor',
'actress',
'actual',
'adapt',
'add',
'addict',
'address',
'adjust',
'admit',
'adult',
'advance',
'advice',
'aerobic',
'affair',
'afford',
'afraid',
'again',
'age',
'agent',
'agree',
'ahead',
'aim',
'air',
'airport',
'aisle',
'alarm',
'album',
'alcohol',
'alert',
'alien',
'all',
'alley',
'allow',
'almost',
'alone',
'alpha',
'already',
'also',
'alter',
'always',
'amateur',
'amazing',
'among',
'amount',
'amused',
'analyst',
'anchor',
'ancient',
'anger',
'angle',
'angry',
'animal',
'ankle',
'announce',
'annual',
'another',
'answer',
'antenna',
'antique',
'anxiety',
'any',
'apart',
'apology',
'appear',
'apple',
'approve',
'april',
'arch',
'arctic',
'area',
'arena',
'argue',
'arm',
'armed',
'armor',
'army',
'around',
'arrange',
'arrest',
'arrive',
'arrow',
'art',
'artefact',
'artist',
'artwork',
'ask',
'aspect',
'assault',
'asset',
'assist',
'assume',
'asthma',
'athlete',
'atom',
'attack',
'attend',
'attitude',
'attract',
'auction',
'audit',
'august',
'aunt',
'author',
'auto',
'autumn',
'average',
'avocado',
'avoid',
'awake',
'aware',
'away',
'awesome',
'awful',
'awkward',
'axis',
'baby',
'bachelor',
'bacon',
'badge',
'bag',
'balance',
'balcony',
'ball',
'bamboo',
'banana',
'banner',
'bar',
'barely',
'bargain',
'barrel',
'base',
'basic',
'basket',
'battle',
'beach',
'bean',
'beauty',
'because',
'become',
'beef',
'before',
'begin',
'behave',
'behind',
'believe',
'below',
'belt',
'bench',
'benefit',
'best',
'betray',
'better',
'between',
'beyond',
'bicycle',
'bid',
'bike',
'bind',
'biology',
'bird',
'birth',
'bitter',
'black',
'blade',
'blame',
'blanket',
'blast',
'bleak',
'bless',
'blind',
'blood',
'blossom',
'blouse',
'blue',
'blur',
'blush',
'board',
'boat',
'body',
'boil',
'bomb',
'bone',
'bonus',
'book',
'boost',
'border',
'boring',
'borrow',
'boss',
'bottom',
'bounce',
'box',
'boy',
'bracket',
'brain',
'brand',
'brass',
'brave',
'bread',
'breeze',
'brick',
'bridge',
'brief',
'bright',
'bring',
'brisk',
'broccoli',
'broken',
'bronze',
'broom',
'brother',
'brown',
'brush',
'bubble',
'buddy',
'budget',
'buffalo',
'build',
'bulb',
'bulk',
'bullet',
'bundle',
'bunker',
'burden',
'burger',
'burst',
'bus',
'business',
'busy',
'butter',
'buyer',
'buzz',
'cabbage',
'cabin',
'cable',
'cactus',
'cage',
'cake',
'call',
'calm',
'camera',
'camp',
'can',
'canal',
'cancel',
'candy',
'cannon',
'canoe',
'canvas',
'canyon',
'capable',
'capital',
'captain',
'car',
'carbon',
'card',
'cargo',
'carpet',
'carry',
'cart',
'case',
'cash',
'casino',
'castle',
'casual',
'cat',
'catalog',
'catch',
'category',
'cattle',
'caught',
'cause',
'caution',
'cave',
'ceiling',
'celery',
'cement',
'census',
'century',
'cereal',
'certain',
'chair',
'chalk',
'champion',
'change',
'chaos',
'chapter',
'charge',
'chase',
'chat',
'cheap',
'check',
'cheese',
'chef',
'cherry',
'chest',
'chicken',
'chief',
'child',
'chimney',
'choice',
'choose',
'chronic',
'chuckle',
'chunk',
'churn',
'cigar',
'cinnamon',
'circle',
'citizen',
'city',
'civil',
'claim',
'clap',
'clarify',
'claw',
'clay',
'clean',
'clerk',
'clever',
'click',
'client',
'cliff',
'climb',
'clinic',
'clip',
'clock',
'clog',
'close',
'cloth',
'cloud',
'clown',
'club',
'clump',
'cluster',
'clutch',
'coach',
'coast',
'coconut',
'code',
'coffee',
'coil',
'coin',
'collect',
'color',
'column',
'combine',
'come',
'comfort',
'comic',
'common',
'company',
'concert',
'conduct',
'confirm',
'congress',
'connect',
'consider',
'control',
'convince',
'cook',
'cool',
'copper',
'copy',
'coral',
'core',
'corn',
'correct',
'cost',
'cotton',
'couch',
'country',
'couple',
'course',
'cousin',
'cover',
'coyote',
'crack',
'cradle',
'craft',
'cram',
'crane',
'crash',
'crater',
'crawl',
'crazy',
'cream',
'credit',
'creek',
'crew',
'cricket',
'crime',
'crisp',
'critic',
'crop',
'cross',
'crouch',
'crowd',
'crucial',
'cruel',
'cruise',
'crumble',
'crunch',
'crush',
'cry',
'crystal',
'cube',
'culture',
'cup',
'cupboard',
'curious',
'current',
'curtain',
'curve',
'cushion',
'custom',
'cute',
'cycle',
'dad',
'damage',
'damp',
'dance',
'danger',
'daring',
'dash',
'daughter',
'dawn',
'day',
'deal',
'debate',
'debris',
'decade',
'december',
'decide',
'decline',
'decorate',
'decrease',
'deer',
'defense',
'define',
'defy',
'degree',
'delay',
'deliver',
'demand',
'demise',
'denial',
'dentist',
'deny',
'depart',
'depend',
'deposit',
'depth',
'deputy',
'derive',
'describe',
'desert',
'design',
'desk',
'despair',
'destroy',
'detail',
'detect',
'develop',
'device',
'devote',
'diagram',
'dial',
'diamond',
'diary',
'dice',
'diesel',
'diet',
'differ',
'digital',
'dignity',
'dilemma',
'dinner',
'dinosaur',
'direct',
'dirt',
'disagree',
'discover',
'disease',
'dish',
'dismiss',
'disorder',
'display',
'distance',
'divert',
'divide',
'divorce',
'dizzy',
'doctor',
'document',
'dog',
'doll',
'dolphin',
'domain',
'donate',
'donkey',
'donor',
'door',
'dose',
'double',
'dove',
'draft',
'dragon',
'drama',
'drastic',
'draw',
'dream',
'dress',
'drift',
'drill',
'drink',
'drip',
'drive',
'drop',
'drum',
'dry',
'duck',
'dumb',
'dune',
'during',
'dust',
'dutch',
'duty',
'dwarf',
'dynamic',
'eager',
'eagle',
'early',
'earn',
'earth',
'easily',
'east',
'easy',
'echo',
'ecology',
'economy',
'edge',
'edit',
'educate',
'effort',
'egg',
'eight',
'either',
'elbow',
'elder',
'electric',
'elegant',
'element',
'elephant',
'elevator',
'elite',
'else',
'embark',
'embody',
'embrace',
'emerge',
'emotion',
'employ',
'empower',
'empty',
'enable',
'enact',
'end',
'endless',
'endorse',
'enemy',
'energy',
'enforce',
'engage',
'engine',
'enhance',
'enjoy',
'enlist',
'enough',
'enrich',
'enroll',
'ensure',
'enter',
'entire',
'entry',
'envelope',
'episode',
'equal',
'equip',
'era',
'erase',
'erode',
'erosion',
'error',
'erupt',
'escape',
'essay',
'essence',
'estate',
'eternal',
'ethics',
'evidence',
'evil',
'evoke',
'evolve',
'exact',
'example',
'excess',
'exchange',
'excite',
'exclude',
'excuse',
'execute',
'exercise',
'exhaust',
'exhibit',
'exile',
'exist',
'exit',
'exotic',
'expand',
'expect',
'expire',
'explain',
'expose',
'express',
'extend',
'extra',
'eye',
'eyebrow',
'fabric',
'face',
'faculty',
'fade',
'faint',
'faith',
'fall',
'false',
'fame',
'family',
'famous',
'fan',
'fancy',
'fantasy',
'farm',
'fashion',
'fat',
'fatal',
'father',
'fatigue',
'fault',
'favorite',
'feature',
'february',
'federal',
'fee',
'feed',
'feel',
'female',
'fence',
'festival',
'fetch',
'fever',
'few',
'fiber',
'fiction',
'field',
'figure',
'file',
'film',
'filter',
'final',
'find',
'fine',
'finger',
'finish',
'fire',
'firm',
'first',
'fiscal',
'fish',
'fit',
'fitness',
'fix',
'flag',
'flame',
'flash',
'flat',
'flavor',
'flee',
'flight',
'flip',
'float',
'flock',
'floor',
'flower',
'fluid',
'flush',
'fly',
'foam',
'focus',
'fog',
'foil',
'fold',
'follow',
'food',
'foot',
'force',
'forest',
'forget',
'fork',
'fortune',
'forum',
'forward',
'fossil',
'foster',
'found',
'fox',
'fragile',
'frame',
'frequent',
'fresh',
'friend',
'fringe',
'frog',
'front',
'frost',
'frown',
'frozen',
'fruit',
'fuel',
'fun',
'funny',
'furnace',
'fury',
'future',
'gadget',
'gain',
'galaxy',
'gallery',
'game',
'gap',
'garage',
'garbage',
'garden',
'garlic',
'garment',
'gas',
'gasp',
'gate',
'gather',
'gauge',
'gaze',
'general',
'genius',
'genre',
'gentle',
'genuine',
'gesture',
'ghost',
'giant',
'gift',
'giggle',
'ginger',
'giraffe',
'girl',
'give',
'glad',
'glance',
'glare',
'glass',
'glide',
'glimpse',
'globe',
'gloom',
'glory',
'glove',
'glow',
'glue',
'goat',
'goddess',
'gold',
'good',
'goose',
'gorilla',
'gospel',
'gossip',
'govern',
'gown',
'grab',
'grace',
'grain',
'grant',
'grape',
'grass',
'gravity',
'great',
'green',
'grid',
'grief',
'grit',
'grocery',
'group',
'grow',
'grunt',
'guard',
'guess',
'guide',
'guilt',
'guitar',
'gun',
'gym',
'habit',
'hair',
'half',
'hammer',
'hamster',
'hand',
'happy',
'harbor',
'hard',
'harsh',
'harvest',
'hat',
'have',
'hawk',
'hazard',
'head',
'health',
'heart',
'heavy',
'hedgehog',
'height',
'hello',
'helmet',
'help',
'hen',
'hero',
'hidden',
'high',
'hill',
'hint',
'hip',
'hire',
'history',
'hobby',
'hockey',
'hold',
'hole',
'holiday',
'hollow',
'home',
'honey',
'hood',
'hope',
'horn',
'horror',
'horse',
'hospital',
'host',
'hotel',
'hour',
'hover',
'hub',
'huge',
'human',
'humble',
'humor',
'hundred',
'hungry',
'hunt',
'hurdle',
'hurry',
'hurt',
'husband',
'hybrid',
'ice',
'icon',
'idea',
'identify',
'idle',
'ignore',
'ill',
'illegal',
'illness',
'image',
'imitate',
'immense',
'immune',
'impact',
'impose',
'improve',
'impulse',
'inch',
'include',
'income',
'increase',
'index',
'indicate',
'indoor',
'industry',
'infant',
'inflict',
'inform',
'inhale',
'inherit',
'initial',
'inject',
'injury',
'inmate',
'inner',
'innocent',
'input',
'inquiry',
'insane',
'insect',
'inside',
'inspire',
'install',
'intact',
'interest',
'into',
'invest',
'invite',
'involve',
'iron',
'island',
'isolate',
'issue',
'item',
'ivory',
'jacket',
'jaguar',
'jar',
'jazz',
'jealous',
'jeans',
'jelly',
'jewel',
'job',
'join',
'joke',
'journey',
'joy',
'judge',
'juice',
'jump',
'jungle',
'junior',
'junk',
'just',
'kangaroo',
'keen',
'keep',
'ketchup',
'key',
'kick',
'kid',
'kidney',
'kind',
'kingdom',
'kiss',
'kit',
'kitchen',
'kite',
'kitten',
'kiwi',
'knee',
'knife',
'knock',
'know',
'lab',
'label',
'labor',
'ladder',
'lady',
'lake',
'lamp',
'language',
'laptop',
'large',
'later',
'latin',
'laugh',
'laundry',
'lava',
'law',
'lawn',
'lawsuit',
'layer',
'lazy',
'leader',
'leaf',
'learn',
'leave',
'lecture',
'left',
'leg',
'legal',
'legend',
'leisure',
'lemon',
'lend',
'length',
'lens',
'leopard',
'lesson',
'letter',
'level',
'liar',
'liberty',
'library',
'license',
'life',
'lift',
'light',
'like',
'limb',
'limit',
'link',
'lion',
'liquid',
'list',
'little',
'live',
'lizard',
'load',
'loan',
'lobster',
'local',
'lock',
'logic',
'lonely',
'long',
'loop',
'lottery',
'loud',
'lounge',
'love',
'loyal',
'lucky',
'luggage',
'lumber',
'lunar',
'lunch',
'luxury',
'lyrics',
'machine',
'mad',
'magic',
'magnet',
'maid',
'mail',
'main',
'major',
'make',
'mammal',
'man',
'manage',
'mandate',
'mango',
'mansion',
'manual',
'maple',
'marble',
'march',
'margin',
'marine',
'market',
'marriage',
'mask',
'mass',
'master',
'match',
'material',
'math',
'matrix',
'matter',
'maximum',
'maze',
'meadow',
'mean',
'measure',
'meat',
'mechanic',
'medal',
'media',
'melody',
'melt',
'member',
'memory',
'mention',
'menu',
'mercy',
'merge',
'merit',
'merry',
'mesh',
'message',
'metal',
'method',
'middle',
'midnight',
'milk',
'million',
'mimic',
'mind',
'minimum',
'minor',
'minute',
'miracle',
'mirror',
'misery',
'miss',
'mistake',
'mix',
'mixed',
'mixture',
'mobile',
'model',
'modify',
'mom',
'moment',
'monitor',
'monkey',
'monster',
'month',
'moon',
'moral',
'more',
'morning',
'mosquito',
'mother',
'motion',
'motor',
'mountain',
'mouse',
'move',
'movie',
'much',
'muffin',
'mule',
'multiply',
'muscle',
'museum',
'mushroom',
'music',
'must',
'mutual',
'myself',
'mystery',
'myth',
'naive',
'name',
'napkin',
'narrow',
'nasty',
'nation',
'nature',
'near',
'neck',
'need',
'negative',
'neglect',
'neither',
'nephew',
'nerve',
'nest',
'net',
'network',
'neutral',
'never',
'news',
'next',
'nice',
'night',
'noble',
'noise',
'nominee',
'noodle',
'normal',
'north',
'nose',
'notable',
'note',
'nothing',
'notice',
'novel',
'now',
'nuclear',
'number',
'nurse',
'nut',
'oak',
'obey',
'object',
'oblige',
'obscure',
'observe',
'obtain',
'obvious',
'occur',
'ocean',
'october',
'odor',
'off',
'offer',
'office',
'often',
'oil',
'okay',
'old',
'olive',
'olympic',
'omit',
'once',
'one',
'onion',
'online',
'only',
'open',
'opera',
'opinion',
'oppose',
'option',
'orange',
'orbit',
'orchard',
'order',
'ordinary',
'organ',
'orient',
'original',
'orphan',
'ostrich',
'other',
'outdoor',
'outer',
'output',
'outside',
'oval',
'oven',
'over',
'own',
'owner',
'oxygen',
'oyster',
'ozone',
'pact',
'paddle',
'page',
'pair',
'palace',
'palm',
'panda',
'panel',
'panic',
'panther',
'paper',
'parade',
'parent',
'park',
'parrot',
'party',
'pass',
'patch',
'path',
'patient',
'patrol',
'pattern',
'pause',
'pave',
'payment',
'peace',
'peanut',
'pear',
'peasant',
'pelican',
'pen',
'penalty',
'pencil',
'people',
'pepper',
'perfect',
'permit',
'person',
'pet',
'phone',
'photo',
'phrase',
'physical',
'piano',
'picnic',
'picture',
'piece',
'pig',
'pigeon',
'pill',
'pilot',
'pink',
'pioneer',
'pipe',
'pistol',
'pitch',
'pizza',
'place',
'planet',
'plastic',
'plate',
'play',
'please',
'pledge',
'pluck',
'plug',
'plunge',
'poem',
'poet',
'point',
'polar',
'pole',
'police',
'pond',
'pony',
'pool',
'popular',
'portion',
'position',
'possible',
'post',
'potato',
'pottery',
'poverty',
'powder',
'power',
'practice',
'praise',
'predict',
'prefer',
'prepare',
'present',
'pretty',
'prevent',
'price',
'pride',
'primary',
'print',
'priority',
'prison',
'private',
'prize',
'problem',
'process',
'produce',
'profit',
'program',
'project',
'promote',
'proof',
'property',
'prosper',
'protect',
'proud',
'provide',
'public',
'pudding',
'pull',
'pulp',
'pulse',
'pumpkin',
'punch',
'pupil',
'puppy',
'purchase',
'purity',
'purpose',
'purse',
'push',
'put',
'puzzle',
'pyramid',
'quality',
'quantum',
'quarter',
'question',
'quick',
'quit',
'quiz',
'quote',
'rabbit',
'raccoon',
'race',
'rack',
'radar',
'radio',
'rail',
'rain',
'raise',
'rally',
'ramp',
'ranch',
'random',
'range',
'rapid',
'rare',
'rate',
'rather',
'raven',
'raw',
'razor',
'ready',
'real',
'reason',
'rebel',
'rebuild',
'recall',
'receive',
'recipe',
'record',
'recycle',
'reduce',
'reflect',
'reform',
'refuse',
'region',
'regret',
'regular',
'reject',
'relax',
'release',
'relief',
'rely',
'remain',
'remember',
'remind',
'remove',
'render',
'renew',
'rent',
'reopen',
'repair',
'repeat',
'replace',
'report',
'require',
'rescue',
'resemble',
'resist',
'resource',
'response',
'result',
'retire',
'retreat',
'return',
'reunion',
'reveal',
'review',
'reward',
'rhythm',
'rib',
'ribbon',
'rice',
'rich',
'ride',
'ridge',
'rifle',
'right',
'rigid',
'ring',
'riot',
'ripple',
'risk',
'ritual',
'rival',
'river',
'road',
'roast',
'robot',
'robust',
'rocket',
'romance',
'roof',
'rookie',
'room',
'rose',
'rotate',
'rough',
'round',
'route',
'royal',
'rubber',
'rude',
'rug',
'rule',
'run',
'runway',
'rural',
'sad',
'saddle',
'sadness',
'safe',
'sail',
'salad',
'salmon',
'salon',
'salt',
'salute',
'same',
'sample',
'sand',
'satisfy',
'satoshi',
'sauce',
'sausage',
'save',
'say',
'scale',
'scan',
'scare',
'scatter',
'scene',
'scheme',
'school',
'science',
'scissors',
'scorpion',
'scout',
'scrap',
'screen',
'script',
'scrub',
'sea',
'search',
'season',
'seat',
'second',
'secret',
'section',
'security',
'seed',
'seek',
'segment',
'select',
'sell',
'seminar',
'senior',
'sense',
'sentence',
'series',
'service',
'session',
'settle',
'setup',
'seven',
'shadow',
'shaft',
'shallow',
'share',
'shed',
'shell',
'sheriff',
'shield',
'shift',
'shine',
'ship',
'shiver',
'shock',
'shoe',
'shoot',
'shop',
'short',
'shoulder',
'shove',
'shrimp',
'shrug',
'shuffle',
'shy',
'sibling',
'sick',
'side',
'siege',
'sight',
'sign',
'silent',
'silk',
'silly',
'silver',
'similar',
'simple',
'since',
'sing',
'siren',
'sister',
'situate',
'six',
'size',
'skate',
'sketch',
'ski',
'skill',
'skin',
'skirt',
'skull',
'slab',
'slam',
'sleep',
'slender',
'slice',
'slide',
'slight',
'slim',
'slogan',
'slot',
'slow',
'slush',
'small',
'smart',
'smile',
'smoke',
'smooth',
'snack',
'snake',
'snap',
'sniff',
'snow',
'soap',
'soccer',
'social',
'sock',
'soda',
'soft',
'solar',
'soldier',
'solid',
'solution',
'solve',
'someone',
'song',
'soon',
'sorry',
'sort',
'soul',
'sound',
'soup',
'source',
'south',
'space',
'spare',
'spatial',
'spawn',
'speak',
'special',
'speed',
'spell',
'spend',
'sphere',
'spice',
'spider',
'spike',
'spin',
'spirit',
'split',
'spoil',
'sponsor',
'spoon',
'sport',
'spot',
'spray',
'spread',
'spring',
'spy',
'square',
'squeeze',
'squirrel',
'stable',
'stadium',
'staff',
'stage',
'stairs',
'stamp',
'stand',
'start',
'state',
'stay',
'steak',
'steel',
'stem',
'step',
'stereo',
'stick',
'still',
'sting',
'stock',
'stomach',
'stone',
'stool',
'story',
'stove',
'strategy',
'street',
'strike',
'strong',
'struggle',
'student',
'stuff',
'stumble',
'style',
'subject',
'submit',
'subway',
'success',
'such',
'sudden',
'suffer',
'sugar',
'suggest',
'suit',
'summer',
'sun',
'sunny',
'sunset',
'super',
'supply',
'supreme',
'sure',
'surface',
'surge',
'surprise',
'surround',
'survey',
'suspect',
'sustain',
'swallow',
'swamp',
'swap',
'swarm',
'swear',
'sweet',
'swift',
'swim',
'swing',
'switch',
'sword',
'symbol',
'symptom',
'syrup',
'system',
'table',
'tackle',
'tag',
'tail',
'talent',
'talk',
'tank',
'tape',
'target',
'task',
'taste',
'tattoo',
'taxi',
'teach',
'team',
'tell',
'ten',
'tenant',
'tennis',
'tent',
'term',
'test',
'text',
'thank',
'that',
'theme',
'then',
'theory',
'there',
'they',
'thing',
'this',
'thought',
'three',
'thrive',
'throw',
'thumb',
'thunder',
'ticket',
'tide',
'tiger',
'tilt',
'timber',
'time',
'tiny',
'tip',
'tired',
'tissue',
'title',
'toast',
'tobacco',
'today',
'toddler',
'toe',
'together',
'toilet',
'token',
'tomato',
'tomorrow',
'tone',
'tongue',
'tonight',
'tool',
'tooth',
'top',
'topic',
'topple',
'torch',
'tornado',
'tortoise',
'toss',
'total',
'tourist',
'toward',
'tower',
'town',
'toy',
'track',
'trade',
'traffic',
'tragic',
'train',
'transfer',
'trap',
'trash',
'travel',
'tray',
'treat',
'tree',
'trend',
'trial',
'tribe',
'trick',
'trigger',
'trim',
'trip',
'trophy',
'trouble',
'truck',
'true',
'truly',
'trumpet',
'trust',
'truth',
'try',
'tube',
'tuition',
'tumble',
'tuna',
'tunnel',
'turkey',
'turn',
'turtle',
'twelve',
'twenty',
'twice',
'twin',
'twist',
'two',
'type',
'typical',
'ugly',
'umbrella',
'unable',
'unaware',
'uncle',
'uncover',
'under',
'undo',
'unfair',
'unfold',
'unhappy',
'uniform',
'unique',
'unit',
'universe',
'unknown',
'unlock',
'until',
'unusual',
'unveil',
'update',
'upgrade',
'uphold',
'upon',
'upper',
'upset',
'urban',
'urge',
'usage',
'use',
'used',
'useful',
'useless',
'usual',
'utility',
'vacant',
'vacuum',
'vague',
'valid',
'valley',
'valve',
'van',
'vanish',
'vapor',
'various',
'vast',
'vault',
'vehicle',
'velvet',
'vendor',
'venture',
'venue',
'verb',
'verify',
'version',
'very',
'vessel',
'veteran',
'viable',
'vibrant',
'vicious',
'victory',
'video',
'view',
'village',
'vintage',
'violin',
'virtual',
'virus',
'visa',
'visit',
'visual',
'vital',
'vivid',
'vocal',
'voice',
'void',
'volcano',
'volume',
'vote',
'voyage',
'wage',
'wagon',
'wait',
'walk',
'wall',
'walnut',
'want',
'warfare',
'warm',
'warrior',
'wash',
'wasp',
'waste',
'water',
'wave',
'way',
'wealth',
'weapon',
'wear',
'weasel',
'weather',
'web',
'wedding',
'weekend',
'weird',
'welcome',
'west',
'wet',
'whale',
'what',
'wheat',
'wheel',
'when',
'where',
'whip',
'whisper',
'wide',
'width',
'wife',
'wild',
'will',
'win',
'window',
'wine',
'wing',
'wink',
'winner',
'winter',
'wire',
'wisdom',
'wise',
'wish',
'witness',
'wolf',
'woman',
'wonder',
'wood',
'wool',
'word',
'work',
'world',
'worry',
'worth',
'wrap',
'wreck',
'wrestle',
'wrist',
'write',
'wrong',
'yard',
'year',
'yellow',
'you',
'young',
'youth',
'zebra',
'zero',
'zone',
'zoo'
];
// SPDX-License-Identifier: MIT
const ALGORAND_MNEMONIC_WORDS = {
TWENTY_FIVE: 25
};
const ALGORAND_MNEMONIC_LANGUAGES = {
ENGLISH: 'english'
};
class AlgorandMnemonic extends Mnemonic {
static checksumLength = 2;
static wordBitLength = 11;
static wordsList = [
ALGORAND_MNEMONIC_WORDS.TWENTY_FIVE
];
static wordsToEntropyStrength = {
25: ALGORAND_ENTROPY_STRENGTHS.TWO_HUNDRED_FIFTY_SIX
};
static languages = Object.values(ALGORAND_MNEMONIC_LANGUAGES);
static wordLists = {
[ALGORAND_MNEMONIC_LANGUAGES.ENGLISH]: WORDLIST$r
};
static getName() {
return 'Algorand';
}
static fromWords(words, language, options = {}) {
if (!this.wordsList.includes(words)) {
throw new MnemonicError(`Invalid words count`, { expected: this.wordsList, got: words });
}
const strength = this.wordsToEntropyStrength[words];
const entropyHex = AlgorandEntropy.generate(strength);
return this.encode(entropyHex, language, options);
}
static fromEntropy(entropy, language, options = {}) {
const entropyBytes = typeof entropy === 'string'
? getBytes(entropy) : entropy instanceof Uint8Array
? entropy : getBytes(entropy.getEntropy());
return this.encode(entropyBytes, language, options);
}
static encode(entropyInput, language, options = {}) {
const entropyBytes = getBytes(entropyInput);
if (!AlgorandEntropy.isValidBytesStrength(entropyBytes.length)) {
throw new EntropyError('Wrong entropy strength', { expected: AlgorandEntropy.strengths, got: entropyBytes.length * 8 });
}
const fullHash = sha512_256(entropyBytes);
const checksum = fullHash.slice(0, this.checksumLength);
const checksumWords = convertBits$2(checksum, 8, this.wordBitLength);
if (!checksumWords)
throw new Error('Checksum conversion failed');
const dataWords = convertBits$2(entropyBytes, 8, this.wordBitLength);
if (!dataWords)
throw new Error('Entropy conversion failed');
const wordList = this.getWordsListByLanguage(language, this.wordLists);
const indexes = [...dataWords, checksumWords[0]];
return indexes.map(i => wordList[i]).join(' ');
}
static decode(mnemonic, options = {}) {
const words = this.normalize(mnemonic);
if (!this.wordsList.includes(words.length)) {
throw new MnemonicError('Invalid mnemonic length', { expected: this.wordsList, got: words.length });
}
const [wordList] = this.findLanguage(words, this.wordLists);
const idxMap = Object.fromEntries(wordList.map((w, i) => [w, i]));
const indexes = words.map(w => {
const idx = idxMap[w];
if (idx === undefined) {
throw new MnemonicError(`Unknown word '${w}'`);
}
return idx;
});
const allBytes = convertBits$2(indexes.slice(0, -1), this.wordBitLength, 8);
if (!allBytes)
throw new Error('Bit conversion failed');
const entropyBytesArr = allBytes.slice(0, -1);
const entropyBytes = getBytes(entropyBytesArr);
const expectedIdx = (convertBits$2(sha512_256(entropyBytes).slice(0, this.checksumLength), 8, this.wordBitLength) || [])[0];
const actualIdx = indexes[indexes.length - 1];
if (expectedIdx !== actualIdx) {
throw new ChecksumError('Invalid checksum', {
expected: wordList[expectedIdx],
got: wordList[actualIdx]
});
}
return bytesToString(entropyBytes);
}
static normalize(input) {
const arr = typeof input === 'string' ? input.trim().split(/\s+/) : input;
return arr.map(w => w.normalize('NFKD').toLowerCase());
}
}
// SPDX-License-Identifier: MIT
const WORDLIST$q = [
'的',
'一',
'是',
'在',
'不',
'了',
'有',
'和',
'人',
'这',
'中',
'大',
'为',
'上',
'个',
'国',
'我',
'以',
'要',
'他',
'时',
'来',
'用',
'们',
'生',
'到',
'作',
'地',
'于',
'出',
'就',
'分',
'对',
'成',
'会',
'可',
'主',
'发',
'年',
'动',
'同',
'工',
'也',
'能',
'下',
'过',
'子',
'说',
'产',
'种',
'面',
'而',
'方',
'后',
'多',
'定',
'行',
'学',
'法',
'所',
'民',
'得',
'经',
'十',
'三',
'之',
'进',
'着',
'等',
'部',
'度',
'家',
'电',
'力',
'里',
'如',
'水',
'化',
'高',
'自',
'二',
'理',
'起',
'小',
'物',
'现',
'实',
'加',
'量',
'都',
'两',
'体',
'制',
'机',
'当',
'使',
'点',
'从',
'业',
'本',
'去',
'把',
'性',
'好',
'应',
'开',
'它',
'合',
'还',
'因',
'由',
'其',
'些',
'然',
'前',
'外',
'天',
'政',
'四',
'日',
'那',
'社',
'义',
'事',
'平',
'形',
'相',
'全',
'表',
'间',
'样',
'与',
'关',
'各',
'重',
'新',
'线',
'内',
'数',
'正',
'心',
'反',
'你',
'明',
'看',
'原',
'又',
'么',
'利',
'比',
'或',
'但',
'质',
'气',
'第',
'向',
'道',
'命',
'此',
'变',
'条',
'只',
'没',
'结',
'解',
'问',
'意',
'建',
'月',
'公',
'无',
'系',
'军',
'很',
'情',
'者',
'最',
'立',
'代',
'想',
'已',
'通',
'并',
'提',
'直',
'题',
'党',
'程',
'展',
'五',
'果',
'料',
'象',
'员',
'革',
'位',
'入',
'常',
'文',
'总',
'次',
'品',
'式',
'活',
'设',
'及',
'管',
'特',
'件',
'长',
'求',
'老',
'头',
'基',
'资',
'边',
'流',
'路',
'级',
'少',
'图',
'山',
'统',
'接',
'知',
'较',
'将',
'组',
'见',
'计',
'别',
'她',
'手',
'角',
'期',
'根',
'论',
'运',
'农',
'指',
'几',
'九',
'区',
'强',
'放',
'决',
'西',
'被',
'干',
'做',
'必',
'战',
'先',
'回',
'则',
'任',
'取',
'据',
'处',
'队',
'南',
'给',
'色',
'光',
'门',
'即',
'保',
'治',
'北',
'造',
'百',
'规',
'热',
'领',
'七',
'海',
'口',
'东',
'导',
'器',
'压',
'志',
'世',
'金',
'增',
'争',
'济',
'阶',
'油',
'思',
'术',
'极',
'交',
'受',
'联',
'什',
'认',
'六',
'共',
'权',
'收',
'证',
'改',
'清',
'美',
'再',
'采',
'转',
'更',
'单',
'风',
'切',
'打',
'白',
'教',
'速',
'花',
'带',
'安',
'场',
'身',
'车',
'例',
'真',
'务',
'具',
'万',
'每',
'目',
'至',
'达',
'走',
'积',
'示',
'议',
'声',
'报',
'斗',
'完',
'类',
'八',
'离',
'华',
'名',
'确',
'才',
'科',
'张',
'信',
'马',
'节',
'话',
'米',
'整',
'空',
'元',
'况',
'今',
'集',
'温',
'传',
'土',
'许',
'步',
'群',
'广',
'石',
'记',
'需',
'段',
'研',
'界',
'拉',
'林',
'律',
'叫',
'且',
'究',
'观',
'越',
'织',
'装',
'影',
'算',
'低',
'持',
'音',
'众',
'书',
'布',
'复',
'容',
'儿',
'须',
'际',
'商',
'非',
'验',
'连',
'断',
'深',
'难',
'近',
'矿',
'千',
'周',
'委',
'素',
'技',
'备',
'半',
'办',
'青',
'省',
'列',
'习',
'响',
'约',
'支',
'般',
'史',
'感',
'劳',
'便',
'团',
'往',
'酸',
'历',
'市',
'克',
'何',
'除',
'消',
'构',
'府',
'称',
'太',
'准',
'精',
'值',
'号',
'率',
'族',
'维',
'划',
'选',
'标',
'写',
'存',
'候',
'毛',
'亲',
'快',
'效',
'斯',
'院',
'查',
'江',
'型',
'眼',
'王',
'按',
'格',
'养',
'易',
'置',
'派',
'层',
'片',
'始',
'却',
'专',
'状',
'育',
'厂',
'京',
'识',
'适',
'属',
'圆',
'包',
'火',
'住',
'调',
'满',
'县',
'局',
'照',
'参',
'红',
'细',
'引',
'听',
'该',
'铁',
'价',
'严',
'首',
'底',
'液',
'官',
'德',
'随',
'病',
'苏',
'失',
'尔',
'死',
'讲',
'配',
'女',
'黄',
'推',
'显',
'谈',
'罪',
'神',
'艺',
'呢',
'席',
'含',
'企',
'望',
'密',
'批',
'营',
'项',
'防',
'举',
'球',
'英',
'氧',
'势',
'告',
'李',
'台',
'落',
'木',
'帮',
'轮',
'破',
'亚',
'师',
'围',
'注',
'远',
'字',
'材',
'排',
'供',
'河',
'态',
'封',
'另',
'施',
'减',
'树',
'溶',
'怎',
'止',
'案',
'言',
'士',
'均',
'武',
'固',
'叶',
'鱼',
'波',
'视',
'仅',
'费',
'紧',
'爱',
'左',
'章',
'早',
'朝',
'害',
'续',
'轻',
'服',
'试',
'食',
'充',
'兵',
'源',
'判',
'护',
'司',
'足',
'某',
'练',
'差',
'致',
'板',
'田',
'降',
'黑',
'犯',
'负',
'击',
'范',
'继',
'兴',
'似',
'余',
'坚',
'曲',
'输',
'修',
'故',
'城',
'夫',
'够',
'送',
'笔',
'船',
'占',
'右',
'财',
'吃',
'富',
'春',
'职',
'觉',
'汉',
'画',
'功',
'巴',
'跟',
'虽',
'杂',
'飞',
'检',
'吸',
'助',
'升',
'阳',
'互',
'初',
'创',
'抗',
'考',
'投',
'坏',
'策',
'古',
'径',
'换',
'未',
'跑',
'留',
'钢',
'曾',
'端',
'责',
'站',
'简',
'述',
'钱',
'副',
'尽',
'帝',
'射',
'草',
'冲',
'承',
'独',
'令',
'限',
'阿',
'宣',
'环',
'双',
'请',
'超',
'微',
'让',
'控',
'州',
'良',
'轴',
'找',
'否',
'纪',
'益',
'依',
'优',
'顶',
'础',
'载',
'倒',
'房',
'突',
'坐',
'粉',
'敌',
'略',
'客',
'袁',
'冷',
'胜',
'绝',
'析',
'块',
'剂',
'测',
'丝',
'协',
'诉',
'念',
'陈',
'仍',
'罗',
'盐',
'友',
'洋',
'错',
'苦',
'夜',
'刑',
'移',
'频',
'逐',
'靠',
'混',
'母',
'短',
'皮',
'终',
'聚',
'汽',
'村',
'云',
'哪',
'既',
'距',
'卫',
'停',
'烈',
'央',
'察',
'烧',
'迅',
'境',
'若',
'印',
'洲',
'刻',
'括',
'激',
'孔',
'搞',
'甚',
'室',
'待',
'核',
'校',
'散',
'侵',
'吧',
'甲',
'游',
'久',
'菜',
'味',
'旧',
'模',
'湖',
'货',
'损',
'预',
'阻',
'毫',
'普',
'稳',
'乙',
'妈',
'植',
'息',
'扩',
'银',
'语',
'挥',
'酒',
'守',
'拿',
'序',
'纸',
'医',
'缺',
'雨',
'吗',
'针',
'刘',
'啊',
'急',
'唱',
'误',
'训',
'愿',
'审',
'附',
'获',
'茶',
'鲜',
'粮',
'斤',
'孩',
'脱',
'硫',
'肥',
'善',
'龙',
'演',
'父',
'渐',
'血',
'欢',
'械',
'掌',
'歌',
'沙',
'刚',
'攻',
'谓',
'盾',
'讨',
'晚',
'粒',
'乱',
'燃',
'矛',
'乎',
'杀',
'药',
'宁',
'鲁',
'贵',
'钟',
'煤',
'读',
'班',
'伯',
'香',
'介',
'迫',
'句',
'丰',
'培',
'握',
'兰',
'担',
'弦',
'蛋',
'沉',
'假',
'穿',
'执',
'答',
'乐',
'谁',
'顺',
'烟',
'缩',
'征',
'脸',
'喜',
'松',
'脚',
'困',
'异',
'免',
'背',
'星',
'福',
'买',
'染',
'井',
'概',
'慢',
'怕',
'磁',
'倍',
'祖',
'皇',
'促',
'静',
'补',
'评',
'翻',
'肉',
'践',
'尼',
'衣',
'宽',
'扬',
'棉',
'希',
'伤',
'操',
'垂',
'秋',
'宜',
'氢',
'套',
'督',
'振',
'架',
'亮',
'末',
'宪',
'庆',
'编',
'牛',
'触',
'映',
'雷',
'销',
'诗',
'座',
'居',
'抓',
'裂',
'胞',
'呼',
'娘',
'景',
'威',
'绿',
'晶',
'厚',
'盟',
'衡',
'鸡',
'孙',
'延',
'危',
'胶',
'屋',
'乡',
'临',
'陆',
'顾',
'掉',
'呀',
'灯',
'岁',
'措',
'束',
'耐',
'剧',
'玉',
'赵',
'跳',
'哥',
'季',
'课',
'凯',
'胡',
'额',
'款',
'绍',
'卷',
'齐',
'伟',
'蒸',
'殖',
'永',
'宗',
'苗',
'川',
'炉',
'岩',
'弱',
'零',
'杨',
'奏',
'沿',
'露',
'杆',
'探',
'滑',
'镇',
'饭',
'浓',
'航',
'怀',
'赶',
'库',
'夺',
'伊',
'灵',
'税',
'途',
'灭',
'赛',
'归',
'召',
'鼓',
'播',
'盘',
'裁',
'险',
'康',
'唯',
'录',
'菌',
'纯',
'借',
'糖',
'盖',
'横',
'符',
'私',
'努',
'堂',
'域',
'枪',
'润',
'幅',
'哈',
'竟',
'熟',
'虫',
'泽',
'脑',
'壤',
'碳',
'欧',
'遍',
'侧',
'寨',
'敢',
'彻',
'虑',
'斜',
'薄',
'庭',
'纳',
'弹',
'饲',
'伸',
'折',
'麦',
'湿',
'暗',
'荷',
'瓦',
'塞',
'床',
'筑',
'恶',
'户',
'访',
'塔',
'奇',
'透',
'梁',
'刀',
'旋',
'迹',
'卡',
'氯',
'遇',
'份',
'毒',
'泥',
'退',
'洗',
'摆',
'灰',
'彩',
'卖',
'耗',
'夏',
'择',
'忙',
'铜',
'献',
'硬',
'予',
'繁',
'圈',
'雪',
'函',
'亦',
'抽',
'篇',
'阵',
'阴',
'丁',
'尺',
'追',
'堆',
'雄',
'迎',
'泛',
'爸',
'楼',
'避',
'谋',
'吨',
'野',
'猪',
'旗',
'累',
'偏',
'典',
'馆',
'索',
'秦',
'脂',
'潮',
'爷',
'豆',
'忽',
'托',
'惊',
'塑',
'遗',
'愈',
'朱',
'替',
'纤',
'粗',
'倾',
'尚',
'痛',
'楚',
'谢',
'奋',
'购',
'磨',
'君',
'池',
'旁',
'碎',
'骨',
'监',
'捕',
'弟',
'暴',
'割',
'贯',
'殊',
'释',
'词',
'亡',
'壁',
'顿',
'宝',
'午',
'尘',
'闻',
'揭',
'炮',
'残',
'冬',
'桥',
'妇',
'警',
'综',
'招',
'吴',
'付',
'浮',
'遭',
'徐',
'您',
'摇',
'谷',
'赞',
'箱',
'隔',
'订',
'男',
'吹',
'园',
'纷',
'唐',
'败',
'宋',
'玻',
'巨',
'耕',
'坦',
'荣',
'闭',
'湾',
'键',
'凡',
'驻',
'锅',
'救',
'恩',
'剥',
'凝',
'碱',
'齿',
'截',
'炼',
'麻',
'纺',
'禁',
'废',
'盛',
'版',
'缓',
'净',
'睛',
'昌',
'婚',
'涉',
'筒',
'嘴',
'插',
'岸',
'朗',
'庄',
'街',
'藏',
'姑',
'贸',
'腐',
'奴',
'啦',
'惯',
'乘',
'伙',
'恢',
'匀',
'纱',
'扎',
'辩',
'耳',
'彪',
'臣',
'亿',
'璃',
'抵',
'脉',
'秀',
'萨',
'俄',
'网',
'舞',
'店',
'喷',
'纵',
'寸',
'汗',
'挂',
'洪',
'贺',
'闪',
'柬',
'爆',
'烯',
'津',
'稻',
'墙',
'软',
'勇',
'像',
'滚',
'厘',
'蒙',
'芳',
'肯',
'坡',
'柱',
'荡',
'腿',
'仪',
'旅',
'尾',
'轧',
'冰',
'贡',
'登',
'黎',
'削',
'钻',
'勒',
'逃',
'障',
'氨',
'郭',
'峰',
'币',
'港',
'伏',
'轨',
'亩',
'毕',
'擦',
'莫',
'刺',
'浪',
'秘',
'援',
'株',
'健',
'售',
'股',
'岛',
'甘',
'泡',
'睡',
'童',
'铸',
'汤',
'阀',
'休',
'汇',
'舍',
'牧',
'绕',
'炸',
'哲',
'磷',
'绩',
'朋',
'淡',
'尖',
'启',
'陷',
'柴',
'呈',
'徒',
'颜',
'泪',
'稍',
'忘',
'泵',
'蓝',
'拖',
'洞',
'授',
'镜',
'辛',
'壮',
'锋',
'贫',
'虚',
'弯',
'摩',
'泰',
'幼',
'廷',
'尊',
'窗',
'纲',
'弄',
'隶',
'疑',
'氏',
'宫',
'姐',
'震',
'瑞',
'怪',
'尤',
'琴',
'循',
'描',
'膜',
'违',
'夹',
'腰',
'缘',
'珠',
'穷',
'森',
'枝',
'竹',
'沟',
'催',
'绳',
'忆',
'邦',
'剩',
'幸',
'浆',
'栏',
'拥',
'牙',
'贮',
'礼',
'滤',
'钠',
'纹',
'罢',
'拍',
'咱',
'喊',
'袖',
'埃',
'勤',
'罚',
'焦',
'潜',
'伍',
'墨',
'欲',
'缝',
'姓',
'刊',
'饱',
'仿',
'奖',
'铝',
'鬼',
'丽',
'跨',
'默',
'挖',
'链',
'扫',
'喝',
'袋',
'炭',
'污',
'幕',
'诸',
'弧',
'励',
'梅',
'奶',
'洁',
'灾',
'舟',
'鉴',
'苯',
'讼',
'抱',
'毁',
'懂',
'寒',
'智',
'埔',
'寄',
'届',
'跃',
'渡',
'挑',
'丹',
'艰',
'贝',
'碰',
'拔',
'爹',
'戴',
'码',
'梦',
'芽',
'熔',
'赤',
'渔',
'哭',
'敬',
'颗',
'奔',
'铅',
'仲',
'虎',
'稀',
'妹',
'乏',
'珍',
'申',
'桌',
'遵',
'允',
'隆',
'螺',
'仓',
'魏',
'锐',
'晓',
'氮',
'兼',
'隐',
'碍',
'赫',
'拨',
'忠',
'肃',
'缸',
'牵',
'抢',
'博',
'巧',
'壳',
'兄',
'杜',
'讯',
'诚',
'碧',
'祥',
'柯',
'页',
'巡',
'矩',
'悲',
'灌',
'龄',
'伦',
'票',
'寻',
'桂',
'铺',
'圣',
'恐',
'恰',
'郑',
'趣',
'抬',
'荒',
'腾',
'贴',
'柔',
'滴',
'猛',
'阔',
'辆',
'妻',
'填',
'撤',
'储',
'签',
'闹',
'扰',
'紫',
'砂',
'递',
'戏',
'吊',
'陶',
'伐',
'喂',
'疗',
'瓶',
'婆',
'抚',
'臂',
'摸',
'忍',
'虾',
'蜡',
'邻',
'胸',
'巩',
'挤',
'偶',
'弃',
'槽',
'劲',
'乳',
'邓',
'吉',
'仁',
'烂',
'砖',
'租',
'乌',
'舰',
'伴',
'瓜',
'浅',
'丙',
'暂',
'燥',
'橡',
'柳',
'迷',
'暖',
'牌',
'秧',
'胆',
'详',
'簧',
'踏',
'瓷',
'谱',
'呆',
'宾',
'糊',
'洛',
'辉',
'愤',
'竞',
'隙',
'怒',
'粘',
'乃',
'绪',
'肩',
'籍',
'敏',
'涂',
'熙',
'皆',
'侦',
'悬',
'掘',
'享',
'纠',
'醒',
'狂',
'锁',
'淀',
'恨',
'牲',
'霸',
'爬',
'赏',
'逆',
'玩',
'陵',
'祝',
'秒',
'浙',
'貌',
'役',
'彼',
'悉',
'鸭',
'趋',
'凤',
'晨',
'畜',
'辈',
'秩',
'卵',
'署',
'梯',
'炎',
'滩',
'棋',
'驱',
'筛',
'峡',
'冒',
'啥',
'寿',
'译',
'浸',
'泉',
'帽',
'迟',
'硅',
'疆',
'贷',
'漏',
'稿',
'冠',
'嫩',
'胁',
'芯',
'牢',
'叛',
'蚀',
'奥',
'鸣',
'岭',
'羊',
'凭',
'串',
'塘',
'绘',
'酵',
'融',
'盆',
'锡',
'庙',
'筹',
'冻',
'辅',
'摄',
'袭',
'筋',
'拒',
'僚',
'旱',
'钾',
'鸟',
'漆',
'沈',
'眉',
'疏',
'添',
'棒',
'穗',
'硝',
'韩',
'逼',
'扭',
'侨',
'凉',
'挺',
'碗',
'栽',
'炒',
'杯',
'患',
'馏',
'劝',
'豪',
'辽',
'勃',
'鸿',
'旦',
'吏',
'拜',
'狗',
'埋',
'辊',
'掩',
'饮',
'搬',
'骂',
'辞',
'勾',
'扣',
'估',
'蒋',
'绒',
'雾',
'丈',
'朵',
'姆',
'拟',
'宇',
'辑',
'陕',
'雕',
'偿',
'蓄',
'崇',
'剪',
'倡',
'厅',
'咬',
'驶',
'薯',
'刷',
'斥',
'番',
'赋',
'奉',
'佛',
'浇',
'漫',
'曼',
'扇',
'钙',
'桃',
'扶',
'仔',
'返',
'俗',
'亏',
'腔',
'鞋',
'棱',
'覆',
'框',
'悄',
'叔',
'撞',
'骗',
'勘',
'旺',
'沸',
'孤',
'吐',
'孟',
'渠',
'屈',
'疾',
'妙',
'惜',
'仰',
'狠',
'胀',
'谐',
'抛',
'霉',
'桑',
'岗',
'嘛',
'衰',
'盗',
'渗',
'脏',
'赖',
'涌',
'甜',
'曹',
'阅',
'肌',
'哩',
'厉',
'烃',
'纬',
'毅',
'昨',
'伪',
'症',
'煮',
'叹',
'钉',
'搭',
'茎',
'笼',
'酷',
'偷',
'弓',
'锥',
'恒',
'杰',
'坑',
'鼻',
'翼',
'纶',
'叙',
'狱',
'逮',
'罐',
'络',
'棚',
'抑',
'膨',
'蔬',
'寺',
'骤',
'穆',
'冶',
'枯',
'册',
'尸',
'凸',
'绅',
'坯',
'牺',
'焰',
'轰',
'欣',
'晋',
'瘦',
'御',
'锭',
'锦',
'丧',
'旬',
'锻',
'垄',
'搜',
'扑',
'邀',
'亭',
'酯',
'迈',
'舒',
'脆',
'酶',
'闲',
'忧',
'酚',
'顽',
'羽',
'涨',
'卸',
'仗',
'陪',
'辟',
'惩',
'杭',
'姚',
'肚',
'捉',
'飘',
'漂',
'昆',
'欺',
'吾',
'郎',
'烷',
'汁',
'呵',
'饰',
'萧',
'雅',
'邮',
'迁',
'燕',
'撒',
'姻',
'赴',
'宴',
'烦',
'债',
'帐',
'斑',
'铃',
'旨',
'醇',
'董',
'饼',
'雏',
'姿',
'拌',
'傅',
'腹',
'妥',
'揉',
'贤',
'拆',
'歪',
'葡',
'胺',
'丢',
'浩',
'徽',
'昂',
'垫',
'挡',
'览',
'贪',
'慰',
'缴',
'汪',
'慌',
'冯',
'诺',
'姜',
'谊',
'凶',
'劣',
'诬',
'耀',
'昏',
'躺',
'盈',
'骑',
'乔',
'溪',
'丛',
'卢',
'抹',
'闷',
'咨',
'刮',
'驾',
'缆',
'悟',
'摘',
'铒',
'掷',
'颇',
'幻',
'柄',
'惠',
'惨',
'佳',
'仇',
'腊',
'窝',
'涤',
'剑',
'瞧',
'堡',
'泼',
'葱',
'罩',
'霍',
'捞',
'胎',
'苍',
'滨',
'俩',
'捅',
'湘',
'砍',
'霞',
'邵',
'萄',
'疯',
'淮',
'遂',
'熊',
'粪',
'烘',
'宿',
'档',
'戈',
'驳',
'嫂',
'裕',
'徙',
'箭',
'捐',
'肠',
'撑',
'晒',
'辨',
'殿',
'莲',
'摊',
'搅',
'酱',
'屏',
'疫',
'哀',
'蔡',
'堵',
'沫',
'皱',
'畅',
'叠',
'阁',
'莱',
'敲',
'辖',
'钩',
'痕',
'坝',
'巷',
'饿',
'祸',
'丘',
'玄',
'溜',
'曰',
'逻',
'彭',
'尝',
'卿',
'妨',
'艇',
'吞',
'韦',
'怨',
'矮',
'歇'
];
// SPDX-License-Identifier: MIT
const WORDLIST$p = [
'的',
'一',
'是',
'在',
'不',
'了',
'有',
'和',
'人',
'這',
'中',
'大',
'為',
'上',
'個',
'國',
'我',
'以',
'要',
'他',
'時',
'來',
'用',
'們',
'生',
'到',
'作',
'地',
'於',
'出',
'就',
'分',
'對',
'成',
'會',
'可',
'主',
'發',
'年',
'動',
'同',
'工',
'也',
'能',
'下',
'過',
'子',
'說',
'產',
'種',
'面',
'而',
'方',
'後',
'多',
'定',
'行',
'學',
'法',
'所',
'民',
'得',
'經',
'十',
'三',
'之',
'進',
'著',
'等',
'部',
'度',
'家',
'電',
'力',
'裡',
'如',
'水',
'化',
'高',
'自',
'二',
'理',
'起',
'小',
'物',
'現',
'實',
'加',
'量',
'都',
'兩',
'體',
'制',
'機',
'當',
'使',
'點',
'從',
'業',
'本',
'去',
'把',
'性',
'好',
'應',
'開',
'它',
'合',
'還',
'因',
'由',
'其',
'些',
'然',
'前',
'外',
'天',
'政',
'四',
'日',
'那',
'社',
'義',
'事',
'平',
'形',
'相',
'全',
'表',
'間',
'樣',
'與',
'關',
'各',
'重',
'新',
'線',
'內',
'數',
'正',
'心',
'反',
'你',
'明',
'看',
'原',
'又',
'麼',
'利',
'比',
'或',
'但',
'質',
'氣',
'第',
'向',
'道',
'命',
'此',
'變',
'條',
'只',
'沒',
'結',
'解',
'問',
'意',
'建',
'月',
'公',
'無',
'系',
'軍',
'很',
'情',
'者',
'最',
'立',
'代',
'想',
'已',
'通',
'並',
'提',
'直',
'題',
'黨',
'程',
'展',
'五',
'果',
'料',
'象',
'員',
'革',
'位',
'入',
'常',
'文',
'總',
'次',
'品',
'式',
'活',
'設',
'及',
'管',
'特',
'件',
'長',
'求',
'老',
'頭',
'基',
'資',
'邊',
'流',
'路',
'級',
'少',
'圖',
'山',
'統',
'接',
'知',
'較',
'將',
'組',
'見',
'計',
'別',
'她',
'手',
'角',
'期',
'根',
'論',
'運',
'農',
'指',
'幾',
'九',
'區',
'強',
'放',
'決',
'西',
'被',
'幹',
'做',
'必',
'戰',
'先',
'回',
'則',
'任',
'取',
'據',
'處',
'隊',
'南',
'給',
'色',
'光',
'門',
'即',
'保',
'治',
'北',
'造',
'百',
'規',
'熱',
'領',
'七',
'海',
'口',
'東',
'導',
'器',
'壓',
'志',
'世',
'金',
'增',
'爭',
'濟',
'階',
'油',
'思',
'術',
'極',
'交',
'受',
'聯',
'什',
'認',
'六',
'共',
'權',
'收',
'證',
'改',
'清',
'美',
'再',
'採',
'轉',
'更',
'單',
'風',
'切',
'打',
'白',
'教',
'速',
'花',
'帶',
'安',
'場',
'身',
'車',
'例',
'真',
'務',
'具',
'萬',
'每',
'目',
'至',
'達',
'走',
'積',
'示',
'議',
'聲',
'報',
'鬥',
'完',
'類',
'八',
'離',
'華',
'名',
'確',
'才',
'科',
'張',
'信',
'馬',
'節',
'話',
'米',
'整',
'空',
'元',
'況',
'今',
'集',
'溫',
'傳',
'土',
'許',
'步',
'群',
'廣',
'石',
'記',
'需',
'段',
'研',
'界',
'拉',
'林',
'律',
'叫',
'且',
'究',
'觀',
'越',
'織',
'裝',
'影',
'算',
'低',
'持',
'音',
'眾',
'書',
'布',
'复',
'容',
'兒',
'須',
'際',
'商',
'非',
'驗',
'連',
'斷',
'深',
'難',
'近',
'礦',
'千',
'週',
'委',
'素',
'技',
'備',
'半',
'辦',
'青',
'省',
'列',
'習',
'響',
'約',
'支',
'般',
'史',
'感',
'勞',
'便',
'團',
'往',
'酸',
'歷',
'市',
'克',
'何',
'除',
'消',
'構',
'府',
'稱',
'太',
'準',
'精',
'值',
'號',
'率',
'族',
'維',
'劃',
'選',
'標',
'寫',
'存',
'候',
'毛',
'親',
'快',
'效',
'斯',
'院',
'查',
'江',
'型',
'眼',
'王',
'按',
'格',
'養',
'易',
'置',
'派',
'層',
'片',
'始',
'卻',
'專',
'狀',
'育',
'廠',
'京',
'識',
'適',
'屬',
'圓',
'包',
'火',
'住',
'調',
'滿',
'縣',
'局',
'照',
'參',
'紅',
'細',
'引',
'聽',
'該',
'鐵',
'價',
'嚴',
'首',
'底',
'液',
'官',
'德',
'隨',
'病',
'蘇',
'失',
'爾',
'死',
'講',
'配',
'女',
'黃',
'推',
'顯',
'談',
'罪',
'神',
'藝',
'呢',
'席',
'含',
'企',
'望',
'密',
'批',
'營',
'項',
'防',
'舉',
'球',
'英',
'氧',
'勢',
'告',
'李',
'台',
'落',
'木',
'幫',
'輪',
'破',
'亞',
'師',
'圍',
'注',
'遠',
'字',
'材',
'排',
'供',
'河',
'態',
'封',
'另',
'施',
'減',
'樹',
'溶',
'怎',
'止',
'案',
'言',
'士',
'均',
'武',
'固',
'葉',
'魚',
'波',
'視',
'僅',
'費',
'緊',
'愛',
'左',
'章',
'早',
'朝',
'害',
'續',
'輕',
'服',
'試',
'食',
'充',
'兵',
'源',
'判',
'護',
'司',
'足',
'某',
'練',
'差',
'致',
'板',
'田',
'降',
'黑',
'犯',
'負',
'擊',
'范',
'繼',
'興',
'似',
'餘',
'堅',
'曲',
'輸',
'修',
'故',
'城',
'夫',
'夠',
'送',
'筆',
'船',
'佔',
'右',
'財',
'吃',
'富',
'春',
'職',
'覺',
'漢',
'畫',
'功',
'巴',
'跟',
'雖',
'雜',
'飛',
'檢',
'吸',
'助',
'昇',
'陽',
'互',
'初',
'創',
'抗',
'考',
'投',
'壞',
'策',
'古',
'徑',
'換',
'未',
'跑',
'留',
'鋼',
'曾',
'端',
'責',
'站',
'簡',
'述',
'錢',
'副',
'盡',
'帝',
'射',
'草',
'衝',
'承',
'獨',
'令',
'限',
'阿',
'宣',
'環',
'雙',
'請',
'超',
'微',
'讓',
'控',
'州',
'良',
'軸',
'找',
'否',
'紀',
'益',
'依',
'優',
'頂',
'礎',
'載',
'倒',
'房',
'突',
'坐',
'粉',
'敵',
'略',
'客',
'袁',
'冷',
'勝',
'絕',
'析',
'塊',
'劑',
'測',
'絲',
'協',
'訴',
'念',
'陳',
'仍',
'羅',
'鹽',
'友',
'洋',
'錯',
'苦',
'夜',
'刑',
'移',
'頻',
'逐',
'靠',
'混',
'母',
'短',
'皮',
'終',
'聚',
'汽',
'村',
'雲',
'哪',
'既',
'距',
'衛',
'停',
'烈',
'央',
'察',
'燒',
'迅',
'境',
'若',
'印',
'洲',
'刻',
'括',
'激',
'孔',
'搞',
'甚',
'室',
'待',
'核',
'校',
'散',
'侵',
'吧',
'甲',
'遊',
'久',
'菜',
'味',
'舊',
'模',
'湖',
'貨',
'損',
'預',
'阻',
'毫',
'普',
'穩',
'乙',
'媽',
'植',
'息',
'擴',
'銀',
'語',
'揮',
'酒',
'守',
'拿',
'序',
'紙',
'醫',
'缺',
'雨',
'嗎',
'針',
'劉',
'啊',
'急',
'唱',
'誤',
'訓',
'願',
'審',
'附',
'獲',
'茶',
'鮮',
'糧',
'斤',
'孩',
'脫',
'硫',
'肥',
'善',
'龍',
'演',
'父',
'漸',
'血',
'歡',
'械',
'掌',
'歌',
'沙',
'剛',
'攻',
'謂',
'盾',
'討',
'晚',
'粒',
'亂',
'燃',
'矛',
'乎',
'殺',
'藥',
'寧',
'魯',
'貴',
'鐘',
'煤',
'讀',
'班',
'伯',
'香',
'介',
'迫',
'句',
'豐',
'培',
'握',
'蘭',
'擔',
'弦',
'蛋',
'沉',
'假',
'穿',
'執',
'答',
'樂',
'誰',
'順',
'煙',
'縮',
'徵',
'臉',
'喜',
'松',
'腳',
'困',
'異',
'免',
'背',
'星',
'福',
'買',
'染',
'井',
'概',
'慢',
'怕',
'磁',
'倍',
'祖',
'皇',
'促',
'靜',
'補',
'評',
'翻',
'肉',
'踐',
'尼',
'衣',
'寬',
'揚',
'棉',
'希',
'傷',
'操',
'垂',
'秋',
'宜',
'氫',
'套',
'督',
'振',
'架',
'亮',
'末',
'憲',
'慶',
'編',
'牛',
'觸',
'映',
'雷',
'銷',
'詩',
'座',
'居',
'抓',
'裂',
'胞',
'呼',
'娘',
'景',
'威',
'綠',
'晶',
'厚',
'盟',
'衡',
'雞',
'孫',
'延',
'危',
'膠',
'屋',
'鄉',
'臨',
'陸',
'顧',
'掉',
'呀',
'燈',
'歲',
'措',
'束',
'耐',
'劇',
'玉',
'趙',
'跳',
'哥',
'季',
'課',
'凱',
'胡',
'額',
'款',
'紹',
'卷',
'齊',
'偉',
'蒸',
'殖',
'永',
'宗',
'苗',
'川',
'爐',
'岩',
'弱',
'零',
'楊',
'奏',
'沿',
'露',
'桿',
'探',
'滑',
'鎮',
'飯',
'濃',
'航',
'懷',
'趕',
'庫',
'奪',
'伊',
'靈',
'稅',
'途',
'滅',
'賽',
'歸',
'召',
'鼓',
'播',
'盤',
'裁',
'險',
'康',
'唯',
'錄',
'菌',
'純',
'借',
'糖',
'蓋',
'橫',
'符',
'私',
'努',
'堂',
'域',
'槍',
'潤',
'幅',
'哈',
'竟',
'熟',
'蟲',
'澤',
'腦',
'壤',
'碳',
'歐',
'遍',
'側',
'寨',
'敢',
'徹',
'慮',
'斜',
'薄',
'庭',
'納',
'彈',
'飼',
'伸',
'折',
'麥',
'濕',
'暗',
'荷',
'瓦',
'塞',
'床',
'築',
'惡',
'戶',
'訪',
'塔',
'奇',
'透',
'梁',
'刀',
'旋',
'跡',
'卡',
'氯',
'遇',
'份',
'毒',
'泥',
'退',
'洗',
'擺',
'灰',
'彩',
'賣',
'耗',
'夏',
'擇',
'忙',
'銅',
'獻',
'硬',
'予',
'繁',
'圈',
'雪',
'函',
'亦',
'抽',
'篇',
'陣',
'陰',
'丁',
'尺',
'追',
'堆',
'雄',
'迎',
'泛',
'爸',
'樓',
'避',
'謀',
'噸',
'野',
'豬',
'旗',
'累',
'偏',
'典',
'館',
'索',
'秦',
'脂',
'潮',
'爺',
'豆',
'忽',
'托',
'驚',
'塑',
'遺',
'愈',
'朱',
'替',
'纖',
'粗',
'傾',
'尚',
'痛',
'楚',
'謝',
'奮',
'購',
'磨',
'君',
'池',
'旁',
'碎',
'骨',
'監',
'捕',
'弟',
'暴',
'割',
'貫',
'殊',
'釋',
'詞',
'亡',
'壁',
'頓',
'寶',
'午',
'塵',
'聞',
'揭',
'炮',
'殘',
'冬',
'橋',
'婦',
'警',
'綜',
'招',
'吳',
'付',
'浮',
'遭',
'徐',
'您',
'搖',
'谷',
'贊',
'箱',
'隔',
'訂',
'男',
'吹',
'園',
'紛',
'唐',
'敗',
'宋',
'玻',
'巨',
'耕',
'坦',
'榮',
'閉',
'灣',
'鍵',
'凡',
'駐',
'鍋',
'救',
'恩',
'剝',
'凝',
'鹼',
'齒',
'截',
'煉',
'麻',
'紡',
'禁',
'廢',
'盛',
'版',
'緩',
'淨',
'睛',
'昌',
'婚',
'涉',
'筒',
'嘴',
'插',
'岸',
'朗',
'莊',
'街',
'藏',
'姑',
'貿',
'腐',
'奴',
'啦',
'慣',
'乘',
'夥',
'恢',
'勻',
'紗',
'扎',
'辯',
'耳',
'彪',
'臣',
'億',
'璃',
'抵',
'脈',
'秀',
'薩',
'俄',
'網',
'舞',
'店',
'噴',
'縱',
'寸',
'汗',
'掛',
'洪',
'賀',
'閃',
'柬',
'爆',
'烯',
'津',
'稻',
'牆',
'軟',
'勇',
'像',
'滾',
'厘',
'蒙',
'芳',
'肯',
'坡',
'柱',
'盪',
'腿',
'儀',
'旅',
'尾',
'軋',
'冰',
'貢',
'登',
'黎',
'削',
'鑽',
'勒',
'逃',
'障',
'氨',
'郭',
'峰',
'幣',
'港',
'伏',
'軌',
'畝',
'畢',
'擦',
'莫',
'刺',
'浪',
'秘',
'援',
'株',
'健',
'售',
'股',
'島',
'甘',
'泡',
'睡',
'童',
'鑄',
'湯',
'閥',
'休',
'匯',
'舍',
'牧',
'繞',
'炸',
'哲',
'磷',
'績',
'朋',
'淡',
'尖',
'啟',
'陷',
'柴',
'呈',
'徒',
'顏',
'淚',
'稍',
'忘',
'泵',
'藍',
'拖',
'洞',
'授',
'鏡',
'辛',
'壯',
'鋒',
'貧',
'虛',
'彎',
'摩',
'泰',
'幼',
'廷',
'尊',
'窗',
'綱',
'弄',
'隸',
'疑',
'氏',
'宮',
'姐',
'震',
'瑞',
'怪',
'尤',
'琴',
'循',
'描',
'膜',
'違',
'夾',
'腰',
'緣',
'珠',
'窮',
'森',
'枝',
'竹',
'溝',
'催',
'繩',
'憶',
'邦',
'剩',
'幸',
'漿',
'欄',
'擁',
'牙',
'貯',
'禮',
'濾',
'鈉',
'紋',
'罷',
'拍',
'咱',
'喊',
'袖',
'埃',
'勤',
'罰',
'焦',
'潛',
'伍',
'墨',
'欲',
'縫',
'姓',
'刊',
'飽',
'仿',
'獎',
'鋁',
'鬼',
'麗',
'跨',
'默',
'挖',
'鏈',
'掃',
'喝',
'袋',
'炭',
'污',
'幕',
'諸',
'弧',
'勵',
'梅',
'奶',
'潔',
'災',
'舟',
'鑑',
'苯',
'訟',
'抱',
'毀',
'懂',
'寒',
'智',
'埔',
'寄',
'屆',
'躍',
'渡',
'挑',
'丹',
'艱',
'貝',
'碰',
'拔',
'爹',
'戴',
'碼',
'夢',
'芽',
'熔',
'赤',
'漁',
'哭',
'敬',
'顆',
'奔',
'鉛',
'仲',
'虎',
'稀',
'妹',
'乏',
'珍',
'申',
'桌',
'遵',
'允',
'隆',
'螺',
'倉',
'魏',
'銳',
'曉',
'氮',
'兼',
'隱',
'礙',
'赫',
'撥',
'忠',
'肅',
'缸',
'牽',
'搶',
'博',
'巧',
'殼',
'兄',
'杜',
'訊',
'誠',
'碧',
'祥',
'柯',
'頁',
'巡',
'矩',
'悲',
'灌',
'齡',
'倫',
'票',
'尋',
'桂',
'鋪',
'聖',
'恐',
'恰',
'鄭',
'趣',
'抬',
'荒',
'騰',
'貼',
'柔',
'滴',
'猛',
'闊',
'輛',
'妻',
'填',
'撤',
'儲',
'簽',
'鬧',
'擾',
'紫',
'砂',
'遞',
'戲',
'吊',
'陶',
'伐',
'餵',
'療',
'瓶',
'婆',
'撫',
'臂',
'摸',
'忍',
'蝦',
'蠟',
'鄰',
'胸',
'鞏',
'擠',
'偶',
'棄',
'槽',
'勁',
'乳',
'鄧',
'吉',
'仁',
'爛',
'磚',
'租',
'烏',
'艦',
'伴',
'瓜',
'淺',
'丙',
'暫',
'燥',
'橡',
'柳',
'迷',
'暖',
'牌',
'秧',
'膽',
'詳',
'簧',
'踏',
'瓷',
'譜',
'呆',
'賓',
'糊',
'洛',
'輝',
'憤',
'競',
'隙',
'怒',
'粘',
'乃',
'緒',
'肩',
'籍',
'敏',
'塗',
'熙',
'皆',
'偵',
'懸',
'掘',
'享',
'糾',
'醒',
'狂',
'鎖',
'淀',
'恨',
'牲',
'霸',
'爬',
'賞',
'逆',
'玩',
'陵',
'祝',
'秒',
'浙',
'貌',
'役',
'彼',
'悉',
'鴨',
'趨',
'鳳',
'晨',
'畜',
'輩',
'秩',
'卵',
'署',
'梯',
'炎',
'灘',
'棋',
'驅',
'篩',
'峽',
'冒',
'啥',
'壽',
'譯',
'浸',
'泉',
'帽',
'遲',
'矽',
'疆',
'貸',
'漏',
'稿',
'冠',
'嫩',
'脅',
'芯',
'牢',
'叛',
'蝕',
'奧',
'鳴',
'嶺',
'羊',
'憑',
'串',
'塘',
'繪',
'酵',
'融',
'盆',
'錫',
'廟',
'籌',
'凍',
'輔',
'攝',
'襲',
'筋',
'拒',
'僚',
'旱',
'鉀',
'鳥',
'漆',
'沈',
'眉',
'疏',
'添',
'棒',
'穗',
'硝',
'韓',
'逼',
'扭',
'僑',
'涼',
'挺',
'碗',
'栽',
'炒',
'杯',
'患',
'餾',
'勸',
'豪',
'遼',
'勃',
'鴻',
'旦',
'吏',
'拜',
'狗',
'埋',
'輥',
'掩',
'飲',
'搬',
'罵',
'辭',
'勾',
'扣',
'估',
'蔣',
'絨',
'霧',
'丈',
'朵',
'姆',
'擬',
'宇',
'輯',
'陝',
'雕',
'償',
'蓄',
'崇',
'剪',
'倡',
'廳',
'咬',
'駛',
'薯',
'刷',
'斥',
'番',
'賦',
'奉',
'佛',
'澆',
'漫',
'曼',
'扇',
'鈣',
'桃',
'扶',
'仔',
'返',
'俗',
'虧',
'腔',
'鞋',
'棱',
'覆',
'框',
'悄',
'叔',
'撞',
'騙',
'勘',
'旺',
'沸',
'孤',
'吐',
'孟',
'渠',
'屈',
'疾',
'妙',
'惜',
'仰',
'狠',
'脹',
'諧',
'拋',
'黴',
'桑',
'崗',
'嘛',
'衰',
'盜',
'滲',
'臟',
'賴',
'湧',
'甜',
'曹',
'閱',
'肌',
'哩',
'厲',
'烴',
'緯',
'毅',
'昨',
'偽',
'症',
'煮',
'嘆',
'釘',
'搭',
'莖',
'籠',
'酷',
'偷',
'弓',
'錐',
'恆',
'傑',
'坑',
'鼻',
'翼',
'綸',
'敘',
'獄',
'逮',
'罐',
'絡',
'棚',
'抑',
'膨',
'蔬',
'寺',
'驟',
'穆',
'冶',
'枯',
'冊',
'屍',
'凸',
'紳',
'坯',
'犧',
'焰',
'轟',
'欣',
'晉',
'瘦',
'禦',
'錠',
'錦',
'喪',
'旬',
'鍛',
'壟',
'搜',
'撲',
'邀',
'亭',
'酯',
'邁',
'舒',
'脆',
'酶',
'閒',
'憂',
'酚',
'頑',
'羽',
'漲',
'卸',
'仗',
'陪',
'闢',
'懲',
'杭',
'姚',
'肚',
'捉',
'飄',
'漂',
'昆',
'欺',
'吾',
'郎',
'烷',
'汁',
'呵',
'飾',
'蕭',
'雅',
'郵',
'遷',
'燕',
'撒',
'姻',
'赴',
'宴',
'煩',
'債',
'帳',
'斑',
'鈴',
'旨',
'醇',
'董',
'餅',
'雛',
'姿',
'拌',
'傅',
'腹',
'妥',
'揉',
'賢',
'拆',
'歪',
'葡',
'胺',
'丟',
'浩',
'徽',
'昂',
'墊',
'擋',
'覽',
'貪',
'慰',
'繳',
'汪',
'慌',
'馮',
'諾',
'姜',
'誼',
'兇',
'劣',
'誣',
'耀',
'昏',
'躺',
'盈',
'騎',
'喬',
'溪',
'叢',
'盧',
'抹',
'悶',
'諮',
'刮',
'駕',
'纜',
'悟',
'摘',
'鉺',
'擲',
'頗',
'幻',
'柄',
'惠',
'慘',
'佳',
'仇',
'臘',
'窩',
'滌',
'劍',
'瞧',
'堡',
'潑',
'蔥',
'罩',
'霍',
'撈',
'胎',
'蒼',
'濱',
'倆',
'捅',
'湘',
'砍',
'霞',
'邵',
'萄',
'瘋',
'淮',
'遂',
'熊',
'糞',
'烘',
'宿',
'檔',
'戈',
'駁',
'嫂',
'裕',
'徙',
'箭',
'捐',
'腸',
'撐',
'曬',
'辨',
'殿',
'蓮',
'攤',
'攪',
'醬',
'屏',
'疫',
'哀',
'蔡',
'堵',
'沫',
'皺',
'暢',
'疊',
'閣',
'萊',
'敲',
'轄',
'鉤',
'痕',
'壩',
'巷',
'餓',
'禍',
'丘',
'玄',
'溜',
'曰',
'邏',
'彭',
'嘗',
'卿',
'妨',
'艇',
'吞',
'韋',
'怨',
'矮',
'歇'
];
// SPDX-License-Identifier: MIT
const WORDLIST$o = [
'abdikace',
'abeceda',
'adresa',
'agrese',
'akce',
'aktovka',
'alej',
'alkohol',
'amputace',
'ananas',
'andulka',
'anekdota',
'anketa',
'antika',
'anulovat',
'archa',
'arogance',
'asfalt',
'asistent',
'aspirace',
'astma',
'astronom',
'atlas',
'atletika',
'atol',
'autobus',
'azyl',
'babka',
'bachor',
'bacil',
'baculka',
'badatel',
'bageta',
'bagr',
'bahno',
'bakterie',
'balada',
'baletka',
'balkon',
'balonek',
'balvan',
'balza',
'bambus',
'bankomat',
'barbar',
'baret',
'barman',
'baroko',
'barva',
'baterka',
'batoh',
'bavlna',
'bazalka',
'bazilika',
'bazuka',
'bedna',
'beran',
'beseda',
'bestie',
'beton',
'bezinka',
'bezmoc',
'beztak',
'bicykl',
'bidlo',
'biftek',
'bikiny',
'bilance',
'biograf',
'biolog',
'bitva',
'bizon',
'blahobyt',
'blatouch',
'blecha',
'bledule',
'blesk',
'blikat',
'blizna',
'blokovat',
'bloudit',
'blud',
'bobek',
'bobr',
'bodlina',
'bodnout',
'bohatost',
'bojkot',
'bojovat',
'bokorys',
'bolest',
'borec',
'borovice',
'bota',
'boubel',
'bouchat',
'bouda',
'boule',
'bourat',
'boxer',
'bradavka',
'brambora',
'branka',
'bratr',
'brepta',
'briketa',
'brko',
'brloh',
'bronz',
'broskev',
'brunetka',
'brusinka',
'brzda',
'brzy',
'bublina',
'bubnovat',
'buchta',
'buditel',
'budka',
'budova',
'bufet',
'bujarost',
'bukvice',
'buldok',
'bulva',
'bunda',
'bunkr',
'burza',
'butik',
'buvol',
'buzola',
'bydlet',
'bylina',
'bytovka',
'bzukot',
'capart',
'carevna',
'cedr',
'cedule',
'cejch',
'cejn',
'cela',
'celer',
'celkem',
'celnice',
'cenina',
'cennost',
'cenovka',
'centrum',
'cenzor',
'cestopis',
'cetka',
'chalupa',
'chapadlo',
'charita',
'chata',
'chechtat',
'chemie',
'chichot',
'chirurg',
'chlad',
'chleba',
'chlubit',
'chmel',
'chmura',
'chobot',
'chochol',
'chodba',
'cholera',
'chomout',
'chopit',
'choroba',
'chov',
'chrapot',
'chrlit',
'chrt',
'chrup',
'chtivost',
'chudina',
'chutnat',
'chvat',
'chvilka',
'chvost',
'chyba',
'chystat',
'chytit',
'cibule',
'cigareta',
'cihelna',
'cihla',
'cinkot',
'cirkus',
'cisterna',
'citace',
'citrus',
'cizinec',
'cizost',
'clona',
'cokoliv',
'couvat',
'ctitel',
'ctnost',
'cudnost',
'cuketa',
'cukr',
'cupot',
'cvaknout',
'cval',
'cvik',
'cvrkot',
'cyklista',
'daleko',
'dareba',
'datel',
'datum',
'dcera',
'debata',
'dechovka',
'decibel',
'deficit',
'deflace',
'dekl',
'dekret',
'demokrat',
'deprese',
'derby',
'deska',
'detektiv',
'dikobraz',
'diktovat',
'dioda',
'diplom',
'disk',
'displej',
'divadlo',
'divoch',
'dlaha',
'dlouho',
'dluhopis',
'dnes',
'dobro',
'dobytek',
'docent',
'dochutit',
'dodnes',
'dohled',
'dohoda',
'dohra',
'dojem',
'dojnice',
'doklad',
'dokola',
'doktor',
'dokument',
'dolar',
'doleva',
'dolina',
'doma',
'dominant',
'domluvit',
'domov',
'donutit',
'dopad',
'dopis',
'doplnit',
'doposud',
'doprovod',
'dopustit',
'dorazit',
'dorost',
'dort',
'dosah',
'doslov',
'dostatek',
'dosud',
'dosyta',
'dotaz',
'dotek',
'dotknout',
'doufat',
'doutnat',
'dovozce',
'dozadu',
'doznat',
'dozorce',
'drahota',
'drak',
'dramatik',
'dravec',
'draze',
'drdol',
'drobnost',
'drogerie',
'drozd',
'drsnost',
'drtit',
'drzost',
'duben',
'duchovno',
'dudek',
'duha',
'duhovka',
'dusit',
'dusno',
'dutost',
'dvojice',
'dvorec',
'dynamit',
'ekolog',
'ekonomie',
'elektron',
'elipsa',
'email',
'emise',
'emoce',
'empatie',
'epizoda',
'epocha',
'epopej',
'epos',
'esej',
'esence',
'eskorta',
'eskymo',
'etiketa',
'euforie',
'evoluce',
'exekuce',
'exkurze',
'expedice',
'exploze',
'export',
'extrakt',
'facka',
'fajfka',
'fakulta',
'fanatik',
'fantazie',
'farmacie',
'favorit',
'fazole',
'federace',
'fejeton',
'fenka',
'fialka',
'figurant',
'filozof',
'filtr',
'finance',
'finta',
'fixace',
'fjord',
'flanel',
'flirt',
'flotila',
'fond',
'fosfor',
'fotbal',
'fotka',
'foton',
'frakce',
'freska',
'fronta',
'fukar',
'funkce',
'fyzika',
'galeje',
'garant',
'genetika',
'geolog',
'gilotina',
'glazura',
'glejt',
'golem',
'golfista',
'gotika',
'graf',
'gramofon',
'granule',
'grep',
'gril',
'grog',
'groteska',
'guma',
'hadice',
'hadr',
'hala',
'halenka',
'hanba',
'hanopis',
'harfa',
'harpuna',
'havran',
'hebkost',
'hejkal',
'hejno',
'hejtman',
'hektar',
'helma',
'hematom',
'herec',
'herna',
'heslo',
'hezky',
'historik',
'hladovka',
'hlasivky',
'hlava',
'hledat',
'hlen',
'hlodavec',
'hloh',
'hloupost',
'hltat',
'hlubina',
'hluchota',
'hmat',
'hmota',
'hmyz',
'hnis',
'hnojivo',
'hnout',
'hoblina',
'hoboj',
'hoch',
'hodiny',
'hodlat',
'hodnota',
'hodovat',
'hojnost',
'hokej',
'holinka',
'holka',
'holub',
'homole',
'honitba',
'honorace',
'horal',
'horda',
'horizont',
'horko',
'horlivec',
'hormon',
'hornina',
'horoskop',
'horstvo',
'hospoda',
'hostina',
'hotovost',
'houba',
'houf',
'houpat',
'houska',
'hovor',
'hradba',
'hranice',
'hravost',
'hrazda',
'hrbolek',
'hrdina',
'hrdlo',
'hrdost',
'hrnek',
'hrobka',
'hromada',
'hrot',
'hrouda',
'hrozen',
'hrstka',
'hrubost',
'hryzat',
'hubenost',
'hubnout',
'hudba',
'hukot',
'humr',
'husita',
'hustota',
'hvozd',
'hybnost',
'hydrant',
'hygiena',
'hymna',
'hysterik',
'idylka',
'ihned',
'ikona',
'iluze',
'imunita',
'infekce',
'inflace',
'inkaso',
'inovace',
'inspekce',
'internet',
'invalida',
'investor',
'inzerce',
'ironie',
'jablko',
'jachta',
'jahoda',
'jakmile',
'jakost',
'jalovec',
'jantar',
'jarmark',
'jaro',
'jasan',
'jasno',
'jatka',
'javor',
'jazyk',
'jedinec',
'jedle',
'jednatel',
'jehlan',
'jekot',
'jelen',
'jelito',
'jemnost',
'jenom',
'jepice',
'jeseter',
'jevit',
'jezdec',
'jezero',
'jinak',
'jindy',
'jinoch',
'jiskra',
'jistota',
'jitrnice',
'jizva',
'jmenovat',
'jogurt',
'jurta',
'kabaret',
'kabel',
'kabinet',
'kachna',
'kadet',
'kadidlo',
'kahan',
'kajak',
'kajuta',
'kakao',
'kaktus',
'kalamita',
'kalhoty',
'kalibr',
'kalnost',
'kamera',
'kamkoliv',
'kamna',
'kanibal',
'kanoe',
'kantor',
'kapalina',
'kapela',
'kapitola',
'kapka',
'kaple',
'kapota',
'kapr',
'kapusta',
'kapybara',
'karamel',
'karotka',
'karton',
'kasa',
'katalog',
'katedra',
'kauce',
'kauza',
'kavalec',
'kazajka',
'kazeta',
'kazivost',
'kdekoliv',
'kdesi',
'kedluben',
'kemp',
'keramika',
'kino',
'klacek',
'kladivo',
'klam',
'klapot',
'klasika',
'klaun',
'klec',
'klenba',
'klepat',
'klesnout',
'klid',
'klima',
'klisna',
'klobouk',
'klokan',
'klopa',
'kloub',
'klubovna',
'klusat',
'kluzkost',
'kmen',
'kmitat',
'kmotr',
'kniha',
'knot',
'koalice',
'koberec',
'kobka',
'kobliha',
'kobyla',
'kocour',
'kohout',
'kojenec',
'kokos',
'koktejl',
'kolaps',
'koleda',
'kolize',
'kolo',
'komando',
'kometa',
'komik',
'komnata',
'komora',
'kompas',
'komunita',
'konat',
'koncept',
'kondice',
'konec',
'konfese',
'kongres',
'konina',
'konkurs',
'kontakt',
'konzerva',
'kopanec',
'kopie',
'kopnout',
'koprovka',
'korbel',
'korektor',
'kormidlo',
'koroptev',
'korpus',
'koruna',
'koryto',
'korzet',
'kosatec',
'kostka',
'kotel',
'kotleta',
'kotoul',
'koukat',
'koupelna',
'kousek',
'kouzlo',
'kovboj',
'koza',
'kozoroh',
'krabice',
'krach',
'krajina',
'kralovat',
'krasopis',
'kravata',
'kredit',
'krejcar',
'kresba',
'kreveta',
'kriket',
'kritik',
'krize',
'krkavec',
'krmelec',
'krmivo',
'krocan',
'krok',
'kronika',
'kropit',
'kroupa',
'krovka',
'krtek',
'kruhadlo',
'krupice',
'krutost',
'krvinka',
'krychle',
'krypta',
'krystal',
'kryt',
'kudlanka',
'kufr',
'kujnost',
'kukla',
'kulajda',
'kulich',
'kulka',
'kulomet',
'kultura',
'kuna',
'kupodivu',
'kurt',
'kurzor',
'kutil',
'kvalita',
'kvasinka',
'kvestor',
'kynolog',
'kyselina',
'kytara',
'kytice',
'kytka',
'kytovec',
'kyvadlo',
'labrador',
'lachtan',
'ladnost',
'laik',
'lakomec',
'lamela',
'lampa',
'lanovka',
'lasice',
'laso',
'lastura',
'latinka',
'lavina',
'lebka',
'leckdy',
'leden',
'lednice',
'ledovka',
'ledvina',
'legenda',
'legie',
'legrace',
'lehce',
'lehkost',
'lehnout',
'lektvar',
'lenochod',
'lentilka',
'lepenka',
'lepidlo',
'letadlo',
'letec',
'letmo',
'letokruh',
'levhart',
'levitace',
'levobok',
'libra',
'lichotka',
'lidojed',
'lidskost',
'lihovina',
'lijavec',
'lilek',
'limetka',
'linie',
'linka',
'linoleum',
'listopad',
'litina',
'litovat',
'lobista',
'lodivod',
'logika',
'logoped',
'lokalita',
'loket',
'lomcovat',
'lopata',
'lopuch',
'lord',
'losos',
'lotr',
'loudal',
'louh',
'louka',
'louskat',
'lovec',
'lstivost',
'lucerna',
'lucifer',
'lump',
'lusk',
'lustrace',
'lvice',
'lyra',
'lyrika',
'lysina',
'madam',
'madlo',
'magistr',
'mahagon',
'majetek',
'majitel',
'majorita',
'makak',
'makovice',
'makrela',
'malba',
'malina',
'malovat',
'malvice',
'maminka',
'mandle',
'manko',
'marnost',
'masakr',
'maskot',
'masopust',
'matice',
'matrika',
'maturita',
'mazanec',
'mazivo',
'mazlit',
'mazurka',
'mdloba',
'mechanik',
'meditace',
'medovina',
'melasa',
'meloun',
'mentolka',
'metla',
'metoda',
'metr',
'mezera',
'migrace',
'mihnout',
'mihule',
'mikina',
'mikrofon',
'milenec',
'milimetr',
'milost',
'mimika',
'mincovna',
'minibar',
'minomet',
'minulost',
'miska',
'mistr',
'mixovat',
'mladost',
'mlha',
'mlhovina',
'mlok',
'mlsat',
'mluvit',
'mnich',
'mnohem',
'mobil',
'mocnost',
'modelka',
'modlitba',
'mohyla',
'mokro',
'molekula',
'momentka',
'monarcha',
'monokl',
'monstrum',
'montovat',
'monzun',
'mosaz',
'moskyt',
'most',
'motivace',
'motorka',
'motyka',
'moucha',
'moudrost',
'mozaika',
'mozek',
'mozol',
'mramor',
'mravenec',
'mrkev',
'mrtvola',
'mrzet',
'mrzutost',
'mstitel',
'mudrc',
'muflon',
'mulat',
'mumie',
'munice',
'muset',
'mutace',
'muzeum',
'muzikant',
'myslivec',
'mzda',
'nabourat',
'nachytat',
'nadace',
'nadbytek',
'nadhoz',
'nadobro',
'nadpis',
'nahlas',
'nahnat',
'nahodile',
'nahradit',
'naivita',
'najednou',
'najisto',
'najmout',
'naklonit',
'nakonec',
'nakrmit',
'nalevo',
'namazat',
'namluvit',
'nanometr',
'naoko',
'naopak',
'naostro',
'napadat',
'napevno',
'naplnit',
'napnout',
'naposled',
'naprosto',
'narodit',
'naruby',
'narychlo',
'nasadit',
'nasekat',
'naslepo',
'nastat',
'natolik',
'navenek',
'navrch',
'navzdory',
'nazvat',
'nebe',
'nechat',
'necky',
'nedaleko',
'nedbat',
'neduh',
'negace',
'nehet',
'nehoda',
'nejen',
'nejprve',
'neklid',
'nelibost',
'nemilost',
'nemoc',
'neochota',
'neonka',
'nepokoj',
'nerost',
'nerv',
'nesmysl',
'nesoulad',
'netvor',
'neuron',
'nevina',
'nezvykle',
'nicota',
'nijak',
'nikam',
'nikdy',
'nikl',
'nikterak',
'nitro',
'nocleh',
'nohavice',
'nominace',
'nora',
'norek',
'nositel',
'nosnost',
'nouze',
'noviny',
'novota',
'nozdra',
'nuda',
'nudle',
'nuget',
'nutit',
'nutnost',
'nutrie',
'nymfa',
'obal',
'obarvit',
'obava',
'obdiv',
'obec',
'obehnat',
'obejmout',
'obezita',
'obhajoba',
'obilnice',
'objasnit',
'objekt',
'obklopit',
'oblast',
'oblek',
'obliba',
'obloha',
'obluda',
'obnos',
'obohatit',
'obojek',
'obout',
'obrazec',
'obrna',
'obruba',
'obrys',
'obsah',
'obsluha',
'obstarat',
'obuv',
'obvaz',
'obvinit',
'obvod',
'obvykle',
'obyvatel',
'obzor',
'ocas',
'ocel',
'ocenit',
'ochladit',
'ochota',
'ochrana',
'ocitnout',
'odboj',
'odbyt',
'odchod',
'odcizit',
'odebrat',
'odeslat',
'odevzdat',
'odezva',
'odhadce',
'odhodit',
'odjet',
'odjinud',
'odkaz',
'odkoupit',
'odliv',
'odluka',
'odmlka',
'odolnost',
'odpad',
'odpis',
'odplout',
'odpor',
'odpustit',
'odpykat',
'odrazka',
'odsoudit',
'odstup',
'odsun',
'odtok',
'odtud',
'odvaha',
'odveta',
'odvolat',
'odvracet',
'odznak',
'ofina',
'ofsajd',
'ohlas',
'ohnisko',
'ohrada',
'ohrozit',
'ohryzek',
'okap',
'okenice',
'oklika',
'okno',
'okouzlit',
'okovy',
'okrasa',
'okres',
'okrsek',
'okruh',
'okupant',
'okurka',
'okusit',
'olejnina',
'olizovat',
'omak',
'omeleta',
'omezit',
'omladina',
'omlouvat',
'omluva',
'omyl',
'onehdy',
'opakovat',
'opasek',
'operace',
'opice',
'opilost',
'opisovat',
'opora',
'opozice',
'opravdu',
'oproti',
'orbital',
'orchestr',
'orgie',
'orlice',
'orloj',
'ortel',
'osada',
'oschnout',
'osika',
'osivo',
'oslava',
'oslepit',
'oslnit',
'oslovit',
'osnova',
'osoba',
'osolit',
'ospalec',
'osten',
'ostraha',
'ostuda',
'ostych',
'osvojit',
'oteplit',
'otisk',
'otop',
'otrhat',
'otrlost',
'otrok',
'otruby',
'otvor',
'ovanout',
'ovar',
'oves',
'ovlivnit',
'ovoce',
'oxid',
'ozdoba',
'pachatel',
'pacient',
'padouch',
'pahorek',
'pakt',
'palanda',
'palec',
'palivo',
'paluba',
'pamflet',
'pamlsek',
'panenka',
'panika',
'panna',
'panovat',
'panstvo',
'pantofle',
'paprika',
'parketa',
'parodie',
'parta',
'paruka',
'paryba',
'paseka',
'pasivita',
'pastelka',
'patent',
'patrona',
'pavouk',
'pazneht',
'pazourek',
'pecka',
'pedagog',
'pejsek',
'peklo',
'peloton',
'penalta',
'pendrek',
'penze',
'periskop',
'pero',
'pestrost',
'petarda',
'petice',
'petrolej',
'pevnina',
'pexeso',
'pianista',
'piha',
'pijavice',
'pikle',
'piknik',
'pilina',
'pilnost',
'pilulka',
'pinzeta',
'pipeta',
'pisatel',
'pistole',
'pitevna',
'pivnice',
'pivovar',
'placenta',
'plakat',
'plamen',
'planeta',
'plastika',
'platit',
'plavidlo',
'plaz',
'plech',
'plemeno',
'plenta',
'ples',
'pletivo',
'plevel',
'plivat',
'plnit',
'plno',
'plocha',
'plodina',
'plomba',
'plout',
'pluk',
'plyn',
'pobavit',
'pobyt',
'pochod',
'pocit',
'poctivec',
'podat',
'podcenit',
'podepsat',
'podhled',
'podivit',
'podklad',
'podmanit',
'podnik',
'podoba',
'podpora',
'podraz',
'podstata',
'podvod',
'podzim',
'poezie',
'pohanka',
'pohnutka',
'pohovor',
'pohroma',
'pohyb',
'pointa',
'pojistka',
'pojmout',
'pokazit',
'pokles',
'pokoj',
'pokrok',
'pokuta',
'pokyn',
'poledne',
'polibek',
'polknout',
'poloha',
'polynom',
'pomalu',
'pominout',
'pomlka',
'pomoc',
'pomsta',
'pomyslet',
'ponechat',
'ponorka',
'ponurost',
'popadat',
'popel',
'popisek',
'poplach',
'poprosit',
'popsat',
'popud',
'poradce',
'porce',
'porod',
'porucha',
'poryv',
'posadit',
'posed',
'posila',
'poskok',
'poslanec',
'posoudit',
'pospolu',
'postava',
'posudek',
'posyp',
'potah',
'potkan',
'potlesk',
'potomek',
'potrava',
'potupa',
'potvora',
'poukaz',
'pouto',
'pouzdro',
'povaha',
'povidla',
'povlak',
'povoz',
'povrch',
'povstat',
'povyk',
'povzdech',
'pozdrav',
'pozemek',
'poznatek',
'pozor',
'pozvat',
'pracovat',
'prahory',
'praktika',
'prales',
'praotec',
'praporek',
'prase',
'pravda',
'princip',
'prkno',
'probudit',
'procento',
'prodej',
'profese',
'prohra',
'projekt',
'prolomit',
'promile',
'pronikat',
'propad',
'prorok',
'prosba',
'proton',
'proutek',
'provaz',
'prskavka',
'prsten',
'prudkost',
'prut',
'prvek',
'prvohory',
'psanec',
'psovod',
'pstruh',
'ptactvo',
'puberta',
'puch',
'pudl',
'pukavec',
'puklina',
'pukrle',
'pult',
'pumpa',
'punc',
'pupen',
'pusa',
'pusinka',
'pustina',
'putovat',
'putyka',
'pyramida',
'pysk',
'pytel',
'racek',
'rachot',
'radiace',
'radnice',
'radon',
'raft',
'ragby',
'raketa',
'rakovina',
'rameno',
'rampouch',
'rande',
'rarach',
'rarita',
'rasovna',
'rastr',
'ratolest',
'razance',
'razidlo',
'reagovat',
'reakce',
'recept',
'redaktor',
'referent',
'reflex',
'rejnok',
'reklama',
'rekord',
'rekrut',
'rektor',
'reputace',
'revize',
'revma',
'revolver',
'rezerva',
'riskovat',
'riziko',
'robotika',
'rodokmen',
'rohovka',
'rokle',
'rokoko',
'romaneto',
'ropovod',
'ropucha',
'rorejs',
'rosol',
'rostlina',
'rotmistr',
'rotoped',
'rotunda',
'roubenka',
'roucho',
'roup',
'roura',
'rovina',
'rovnice',
'rozbor',
'rozchod',
'rozdat',
'rozeznat',
'rozhodce',
'rozinka',
'rozjezd',
'rozkaz',
'rozloha',
'rozmar',
'rozpad',
'rozruch',
'rozsah',
'roztok',
'rozum',
'rozvod',
'rubrika',
'ruchadlo',
'rukavice',
'rukopis',
'ryba',
'rybolov',
'rychlost',
'rydlo',
'rypadlo',
'rytina',
'ryzost',
'sadista',
'sahat',
'sako',
'samec',
'samizdat',
'samota',
'sanitka',
'sardinka',
'sasanka',
'satelit',
'sazba',
'sazenice',
'sbor',
'schovat',
'sebranka',
'secese',
'sedadlo',
'sediment',
'sedlo',
'sehnat',
'sejmout',
'sekera',
'sekta',
'sekunda',
'sekvoje',
'semeno',
'seno',
'servis',
'sesadit',
'seshora',
'seskok',
'seslat',
'sestra',
'sesuv',
'sesypat',
'setba',
'setina',
'setkat',
'setnout',
'setrvat',
'sever',
'seznam',
'shoda',
'shrnout',
'sifon',
'silnice',
'sirka',
'sirotek',
'sirup',
'situace',
'skafandr',
'skalisko',
'skanzen',
'skaut',
'skeptik',
'skica',
'skladba',
'sklenice',
'sklo',
'skluz',
'skoba',
'skokan',
'skoro',
'skripta',
'skrz',
'skupina',
'skvost',
'skvrna',
'slabika',
'sladidlo',
'slanina',
'slast',
'slavnost',
'sledovat',
'slepec',
'sleva',
'slezina',
'slib',
'slina',
'sliznice',
'slon',
'sloupek',
'slovo',
'sluch',
'sluha',
'slunce',
'slupka',
'slza',
'smaragd',
'smetana',
'smilstvo',
'smlouva',
'smog',
'smrad',
'smrk',
'smrtka',
'smutek',
'smysl',
'snad',
'snaha',
'snob',
'sobota',
'socha',
'sodovka',
'sokol',
'sopka',
'sotva',
'souboj',
'soucit',
'soudce',
'souhlas',
'soulad',
'soumrak',
'souprava',
'soused',
'soutok',
'souviset',
'spalovna',
'spasitel',
'spis',
'splav',
'spodek',
'spojenec',
'spolu',
'sponzor',
'spornost',
'spousta',
'sprcha',
'spustit',
'sranda',
'sraz',
'srdce',
'srna',
'srnec',
'srovnat',
'srpen',
'srst',
'srub',
'stanice',
'starosta',
'statika',
'stavba',
'stehno',
'stezka',
'stodola',
'stolek',
'stopa',
'storno',
'stoupat',
'strach',
'stres',
'strhnout',
'strom',
'struna',
'studna',
'stupnice',
'stvol',
'styk',
'subjekt',
'subtropy',
'suchar',
'sudost',
'sukno',
'sundat',
'sunout',
'surikata',
'surovina',
'svah',
'svalstvo',
'svetr',
'svatba',
'svazek',
'svisle',
'svitek',
'svoboda',
'svodidlo',
'svorka',
'svrab',
'sykavka',
'sykot',
'synek',
'synovec',
'sypat',
'sypkost',
'syrovost',
'sysel',
'sytost',
'tabletka',
'tabule',
'tahoun',
'tajemno',
'tajfun',
'tajga',
'tajit',
'tajnost',
'taktika',
'tamhle',
'tampon',
'tancovat',
'tanec',
'tanker',
'tapeta',
'tavenina',
'tazatel',
'technika',
'tehdy',
'tekutina',
'telefon',
'temnota',
'tendence',
'tenista',
'tenor',
'teplota',
'tepna',
'teprve',
'terapie',
'termoska',
'textil',
'ticho',
'tiskopis',
'titulek',
'tkadlec',
'tkanina',
'tlapka',
'tleskat',
'tlukot',
'tlupa',
'tmel',
'toaleta',
'topinka',
'topol',
'torzo',
'touha',
'toulec',
'tradice',
'traktor',
'tramp',
'trasa',
'traverza',
'trefit',
'trest',
'trezor',
'trhavina',
'trhlina',
'trochu',
'trojice',
'troska',
'trouba',
'trpce',
'trpitel',
'trpkost',
'trubec',
'truchlit',
'truhlice',
'trus',
'trvat',
'tudy',
'tuhnout',
'tuhost',
'tundra',
'turista',
'turnaj',
'tuzemsko',
'tvaroh',
'tvorba',
'tvrdost',
'tvrz',
'tygr',
'tykev',
'ubohost',
'uboze',
'ubrat',
'ubrousek',
'ubrus',
'ubytovna',
'ucho',
'uctivost',
'udivit',
'uhradit',
'ujednat',
'ujistit',
'ujmout',
'ukazatel',
'uklidnit',
'uklonit',
'ukotvit',
'ukrojit',
'ulice',
'ulita',
'ulovit',
'umyvadlo',
'unavit',
'uniforma',
'uniknout',
'upadnout',
'uplatnit',
'uplynout',
'upoutat',
'upravit',
'uran',
'urazit',
'usednout',
'usilovat',
'usmrtit',
'usnadnit',
'usnout',
'usoudit',
'ustlat',
'ustrnout',
'utahovat',
'utkat',
'utlumit',
'utonout',
'utopenec',
'utrousit',
'uvalit',
'uvolnit',
'uvozovka',
'uzdravit',
'uzel',
'uzenina',
'uzlina',
'uznat',
'vagon',
'valcha',
'valoun',
'vana',
'vandal',
'vanilka',
'varan',
'varhany',
'varovat',
'vcelku',
'vchod',
'vdova',
'vedro',
'vegetace',
'vejce',
'velbloud',
'veletrh',
'velitel',
'velmoc',
'velryba',
'venkov',
'veranda',
'verze',
'veselka',
'veskrze',
'vesnice',
'vespodu',
'vesta',
'veterina',
'veverka',
'vibrace',
'vichr',
'videohra',
'vidina',
'vidle',
'vila',
'vinice',
'viset',
'vitalita',
'vize',
'vizitka',
'vjezd',
'vklad',
'vkus',
'vlajka',
'vlak',
'vlasec',
'vlevo',
'vlhkost',
'vliv',
'vlnovka',
'vloupat',
'vnucovat',
'vnuk',
'voda',
'vodivost',
'vodoznak',
'vodstvo',
'vojensky',
'vojna',
'vojsko',
'volant',
'volba',
'volit',
'volno',
'voskovka',
'vozidlo',
'vozovna',
'vpravo',
'vrabec',
'vracet',
'vrah',
'vrata',
'vrba',
'vrcholek',
'vrhat',
'vrstva',
'vrtule',
'vsadit',
'vstoupit',
'vstup',
'vtip',
'vybavit',
'vybrat',
'vychovat',
'vydat',
'vydra',
'vyfotit',
'vyhledat',
'vyhnout',
'vyhodit',
'vyhradit',
'vyhubit',
'vyjasnit',
'vyjet',
'vyjmout',
'vyklopit',
'vykonat',
'vylekat',
'vymazat',
'vymezit',
'vymizet',
'vymyslet',
'vynechat',
'vynikat',
'vynutit',
'vypadat',
'vyplatit',
'vypravit',
'vypustit',
'vyrazit',
'vyrovnat',
'vyrvat',
'vyslovit',
'vysoko',
'vystavit',
'vysunout',
'vysypat',
'vytasit',
'vytesat',
'vytratit',
'vyvinout',
'vyvolat',
'vyvrhel',
'vyzdobit',
'vyznat',
'vzadu',
'vzbudit',
'vzchopit',
'vzdor',
'vzduch',
'vzdychat',
'vzestup',
'vzhledem',
'vzkaz',
'vzlykat',
'vznik',
'vzorek',
'vzpoura',
'vztah',
'vztek',
'xylofon',
'zabrat',
'zabydlet',
'zachovat',
'zadarmo',
'zadusit',
'zafoukat',
'zahltit',
'zahodit',
'zahrada',
'zahynout',
'zajatec',
'zajet',
'zajistit',
'zaklepat',
'zakoupit',
'zalepit',
'zamezit',
'zamotat',
'zamyslet',
'zanechat',
'zanikat',
'zaplatit',
'zapojit',
'zapsat',
'zarazit',
'zastavit',
'zasunout',
'zatajit',
'zatemnit',
'zatknout',
'zaujmout',
'zavalit',
'zavelet',
'zavinit',
'zavolat',
'zavrtat',
'zazvonit',
'zbavit',
'zbrusu',
'zbudovat',
'zbytek',
'zdaleka',
'zdarma',
'zdatnost',
'zdivo',
'zdobit',
'zdroj',
'zdvih',
'zdymadlo',
'zelenina',
'zeman',
'zemina',
'zeptat',
'zezadu',
'zezdola',
'zhatit',
'zhltnout',
'zhluboka',
'zhotovit',
'zhruba',
'zima',
'zimnice',
'zjemnit',
'zklamat',
'zkoumat',
'zkratka',
'zkumavka',
'zlato',
'zlehka',
'zloba',
'zlom',
'zlost',
'zlozvyk',
'zmapovat',
'zmar',
'zmatek',
'zmije',
'zmizet',
'zmocnit',
'zmodrat',
'zmrzlina',
'zmutovat',
'znak',
'znalost',
'znamenat',
'znovu',
'zobrazit',
'zotavit',
'zoubek',
'zoufale',
'zplodit',
'zpomalit',
'zprava',
'zprostit',
'zprudka',
'zprvu',
'zrada',
'zranit',
'zrcadlo',
'zrnitost',
'zrno',
'zrovna',
'zrychlit',
'zrzavost',
'zticha',
'ztratit',
'zubovina',
'zubr',
'zvednout',
'zvenku',
'zvesela',
'zvon',
'zvrat',
'zvukovod',
'zvyk'
];
// SPDX-License-Identifier: MIT
const WORDLIST$n = [
'abandon',
'ability',
'able',
'about',
'above',
'absent',
'absorb',
'abstract',
'absurd',
'abuse',
'access',
'accident',
'account',
'accuse',
'achieve',
'acid',
'acoustic',
'acquire',
'across',
'act',
'action',
'actor',
'actress',
'actual',
'adapt',
'add',
'addict',
'address',
'adjust',
'admit',
'adult',
'advance',
'advice',
'aerobic',
'affair',
'afford',
'afraid',
'again',
'age',
'agent',
'agree',
'ahead',
'aim',
'air',
'airport',
'aisle',
'alarm',
'album',
'alcohol',
'alert',
'alien',
'all',
'alley',
'allow',
'almost',
'alone',
'alpha',
'already',
'also',
'alter',
'always',
'amateur',
'amazing',
'among',
'amount',
'amused',
'analyst',
'anchor',
'ancient',
'anger',
'angle',
'angry',
'animal',
'ankle',
'announce',
'annual',
'another',
'answer',
'antenna',
'antique',
'anxiety',
'any',
'apart',
'apology',
'appear',
'apple',
'approve',
'april',
'arch',
'arctic',
'area',
'arena',
'argue',
'arm',
'armed',
'armor',
'army',
'around',
'arrange',
'arrest',
'arrive',
'arrow',
'art',
'artefact',
'artist',
'artwork',
'ask',
'aspect',
'assault',
'asset',
'assist',
'assume',
'asthma',
'athlete',
'atom',
'attack',
'attend',
'attitude',
'attract',
'auction',
'audit',
'august',
'aunt',
'author',
'auto',
'autumn',
'average',
'avocado',
'avoid',
'awake',
'aware',
'away',
'awesome',
'awful',
'awkward',
'axis',
'baby',
'bachelor',
'bacon',
'badge',
'bag',
'balance',
'balcony',
'ball',
'bamboo',
'banana',
'banner',
'bar',
'barely',
'bargain',
'barrel',
'base',
'basic',
'basket',
'battle',
'beach',
'bean',
'beauty',
'because',
'become',
'beef',
'before',
'begin',
'behave',
'behind',
'believe',
'below',
'belt',
'bench',
'benefit',
'best',
'betray',
'better',
'between',
'beyond',
'bicycle',
'bid',
'bike',
'bind',
'biology',
'bird',
'birth',
'bitter',
'black',
'blade',
'blame',
'blanket',
'blast',
'bleak',
'bless',
'blind',
'blood',
'blossom',
'blouse',
'blue',
'blur',
'blush',
'board',
'boat',
'body',
'boil',
'bomb',
'bone',
'bonus',
'book',
'boost',
'border',
'boring',
'borrow',
'boss',
'bottom',
'bounce',
'box',
'boy',
'bracket',
'brain',
'brand',
'brass',
'brave',
'bread',
'breeze',
'brick',
'bridge',
'brief',
'bright',
'bring',
'brisk',
'broccoli',
'broken',
'bronze',
'broom',
'brother',
'brown',
'brush',
'bubble',
'buddy',
'budget',
'buffalo',
'build',
'bulb',
'bulk',
'bullet',
'bundle',
'bunker',
'burden',
'burger',
'burst',
'bus',
'business',
'busy',
'butter',
'buyer',
'buzz',
'cabbage',
'cabin',
'cable',
'cactus',
'cage',
'cake',
'call',
'calm',
'camera',
'camp',
'can',
'canal',
'cancel',
'candy',
'cannon',
'canoe',
'canvas',
'canyon',
'capable',
'capital',
'captain',
'car',
'carbon',
'card',
'cargo',
'carpet',
'carry',
'cart',
'case',
'cash',
'casino',
'castle',
'casual',
'cat',
'catalog',
'catch',
'category',
'cattle',
'caught',
'cause',
'caution',
'cave',
'ceiling',
'celery',
'cement',
'census',
'century',
'cereal',
'certain',
'chair',
'chalk',
'champion',
'change',
'chaos',
'chapter',
'charge',
'chase',
'chat',
'cheap',
'check',
'cheese',
'chef',
'cherry',
'chest',
'chicken',
'chief',
'child',
'chimney',
'choice',
'choose',
'chronic',
'chuckle',
'chunk',
'churn',
'cigar',
'cinnamon',
'circle',
'citizen',
'city',
'civil',
'claim',
'clap',
'clarify',
'claw',
'clay',
'clean',
'clerk',
'clever',
'click',
'client',
'cliff',
'climb',
'clinic',
'clip',
'clock',
'clog',
'close',
'cloth',
'cloud',
'clown',
'club',
'clump',
'cluster',
'clutch',
'coach',
'coast',
'coconut',
'code',
'coffee',
'coil',
'coin',
'collect',
'color',
'column',
'combine',
'come',
'comfort',
'comic',
'common',
'company',
'concert',
'conduct',
'confirm',
'congress',
'connect',
'consider',
'control',
'convince',
'cook',
'cool',
'copper',
'copy',
'coral',
'core',
'corn',
'correct',
'cost',
'cotton',
'couch',
'country',
'couple',
'course',
'cousin',
'cover',
'coyote',
'crack',
'cradle',
'craft',
'cram',
'crane',
'crash',
'crater',
'crawl',
'crazy',
'cream',
'credit',
'creek',
'crew',
'cricket',
'crime',
'crisp',
'critic',
'crop',
'cross',
'crouch',
'crowd',
'crucial',
'cruel',
'cruise',
'crumble',
'crunch',
'crush',
'cry',
'crystal',
'cube',
'culture',
'cup',
'cupboard',
'curious',
'current',
'curtain',
'curve',
'cushion',
'custom',
'cute',
'cycle',
'dad',
'damage',
'damp',
'dance',
'danger',
'daring',
'dash',
'daughter',
'dawn',
'day',
'deal',
'debate',
'debris',
'decade',
'december',
'decide',
'decline',
'decorate',
'decrease',
'deer',
'defense',
'define',
'defy',
'degree',
'delay',
'deliver',
'demand',
'demise',
'denial',
'dentist',
'deny',
'depart',
'depend',
'deposit',
'depth',
'deputy',
'derive',
'describe',
'desert',
'design',
'desk',
'despair',
'destroy',
'detail',
'detect',
'develop',
'device',
'devote',
'diagram',
'dial',
'diamond',
'diary',
'dice',
'diesel',
'diet',
'differ',
'digital',
'dignity',
'dilemma',
'dinner',
'dinosaur',
'direct',
'dirt',
'disagree',
'discover',
'disease',
'dish',
'dismiss',
'disorder',
'display',
'distance',
'divert',
'divide',
'divorce',
'dizzy',
'doctor',
'document',
'dog',
'doll',
'dolphin',
'domain',
'donate',
'donkey',
'donor',
'door',
'dose',
'double',
'dove',
'draft',
'dragon',
'drama',
'drastic',
'draw',
'dream',
'dress',
'drift',
'drill',
'drink',
'drip',
'drive',
'drop',
'drum',
'dry',
'duck',
'dumb',
'dune',
'during',
'dust',
'dutch',
'duty',
'dwarf',
'dynamic',
'eager',
'eagle',
'early',
'earn',
'earth',
'easily',
'east',
'easy',
'echo',
'ecology',
'economy',
'edge',
'edit',
'educate',
'effort',
'egg',
'eight',
'either',
'elbow',
'elder',
'electric',
'elegant',
'element',
'elephant',
'elevator',
'elite',
'else',
'embark',
'embody',
'embrace',
'emerge',
'emotion',
'employ',
'empower',
'empty',
'enable',
'enact',
'end',
'endless',
'endorse',
'enemy',
'energy',
'enforce',
'engage',
'engine',
'enhance',
'enjoy',
'enlist',
'enough',
'enrich',
'enroll',
'ensure',
'enter',
'entire',
'entry',
'envelope',
'episode',
'equal',
'equip',
'era',
'erase',
'erode',
'erosion',
'error',
'erupt',
'escape',
'essay',
'essence',
'estate',
'eternal',
'ethics',
'evidence',
'evil',
'evoke',
'evolve',
'exact',
'example',
'excess',
'exchange',
'excite',
'exclude',
'excuse',
'execute',
'exercise',
'exhaust',
'exhibit',
'exile',
'exist',
'exit',
'exotic',
'expand',
'expect',
'expire',
'explain',
'expose',
'express',
'extend',
'extra',
'eye',
'eyebrow',
'fabric',
'face',
'faculty',
'fade',
'faint',
'faith',
'fall',
'false',
'fame',
'family',
'famous',
'fan',
'fancy',
'fantasy',
'farm',
'fashion',
'fat',
'fatal',
'father',
'fatigue',
'fault',
'favorite',
'feature',
'february',
'federal',
'fee',
'feed',
'feel',
'female',
'fence',
'festival',
'fetch',
'fever',
'few',
'fiber',
'fiction',
'field',
'figure',
'file',
'film',
'filter',
'final',
'find',
'fine',
'finger',
'finish',
'fire',
'firm',
'first',
'fiscal',
'fish',
'fit',
'fitness',
'fix',
'flag',
'flame',
'flash',
'flat',
'flavor',
'flee',
'flight',
'flip',
'float',
'flock',
'floor',
'flower',
'fluid',
'flush',
'fly',
'foam',
'focus',
'fog',
'foil',
'fold',
'follow',
'food',
'foot',
'force',
'forest',
'forget',
'fork',
'fortune',
'forum',
'forward',
'fossil',
'foster',
'found',
'fox',
'fragile',
'frame',
'frequent',
'fresh',
'friend',
'fringe',
'frog',
'front',
'frost',
'frown',
'frozen',
'fruit',
'fuel',
'fun',
'funny',
'furnace',
'fury',
'future',
'gadget',
'gain',
'galaxy',
'gallery',
'game',
'gap',
'garage',
'garbage',
'garden',
'garlic',
'garment',
'gas',
'gasp',
'gate',
'gather',
'gauge',
'gaze',
'general',
'genius',
'genre',
'gentle',
'genuine',
'gesture',
'ghost',
'giant',
'gift',
'giggle',
'ginger',
'giraffe',
'girl',
'give',
'glad',
'glance',
'glare',
'glass',
'glide',
'glimpse',
'globe',
'gloom',
'glory',
'glove',
'glow',
'glue',
'goat',
'goddess',
'gold',
'good',
'goose',
'gorilla',
'gospel',
'gossip',
'govern',
'gown',
'grab',
'grace',
'grain',
'grant',
'grape',
'grass',
'gravity',
'great',
'green',
'grid',
'grief',
'grit',
'grocery',
'group',
'grow',
'grunt',
'guard',
'guess',
'guide',
'guilt',
'guitar',
'gun',
'gym',
'habit',
'hair',
'half',
'hammer',
'hamster',
'hand',
'happy',
'harbor',
'hard',
'harsh',
'harvest',
'hat',
'have',
'hawk',
'hazard',
'head',
'health',
'heart',
'heavy',
'hedgehog',
'height',
'hello',
'helmet',
'help',
'hen',
'hero',
'hidden',
'high',
'hill',
'hint',
'hip',
'hire',
'history',
'hobby',
'hockey',
'hold',
'hole',
'holiday',
'hollow',
'home',
'honey',
'hood',
'hope',
'horn',
'horror',
'horse',
'hospital',
'host',
'hotel',
'hour',
'hover',
'hub',
'huge',
'human',
'humble',
'humor',
'hundred',
'hungry',
'hunt',
'hurdle',
'hurry',
'hurt',
'husband',
'hybrid',
'ice',
'icon',
'idea',
'identify',
'idle',
'ignore',
'ill',
'illegal',
'illness',
'image',
'imitate',
'immense',
'immune',
'impact',
'impose',
'improve',
'impulse',
'inch',
'include',
'income',
'increase',
'index',
'indicate',
'indoor',
'industry',
'infant',
'inflict',
'inform',
'inhale',
'inherit',
'initial',
'inject',
'injury',
'inmate',
'inner',
'innocent',
'input',
'inquiry',
'insane',
'insect',
'inside',
'inspire',
'install',
'intact',
'interest',
'into',
'invest',
'invite',
'involve',
'iron',
'island',
'isolate',
'issue',
'item',
'ivory',
'jacket',
'jaguar',
'jar',
'jazz',
'jealous',
'jeans',
'jelly',
'jewel',
'job',
'join',
'joke',
'journey',
'joy',
'judge',
'juice',
'jump',
'jungle',
'junior',
'junk',
'just',
'kangaroo',
'keen',
'keep',
'ketchup',
'key',
'kick',
'kid',
'kidney',
'kind',
'kingdom',
'kiss',
'kit',
'kitchen',
'kite',
'kitten',
'kiwi',
'knee',
'knife',
'knock',
'know',
'lab',
'label',
'labor',
'ladder',
'lady',
'lake',
'lamp',
'language',
'laptop',
'large',
'later',
'latin',
'laugh',
'laundry',
'lava',
'law',
'lawn',
'lawsuit',
'layer',
'lazy',
'leader',
'leaf',
'learn',
'leave',
'lecture',
'left',
'leg',
'legal',
'legend',
'leisure',
'lemon',
'lend',
'length',
'lens',
'leopard',
'lesson',
'letter',
'level',
'liar',
'liberty',
'library',
'license',
'life',
'lift',
'light',
'like',
'limb',
'limit',
'link',
'lion',
'liquid',
'list',
'little',
'live',
'lizard',
'load',
'loan',
'lobster',
'local',
'lock',
'logic',
'lonely',
'long',
'loop',
'lottery',
'loud',
'lounge',
'love',
'loyal',
'lucky',
'luggage',
'lumber',
'lunar',
'lunch',
'luxury',
'lyrics',
'machine',
'mad',
'magic',
'magnet',
'maid',
'mail',
'main',
'major',
'make',
'mammal',
'man',
'manage',
'mandate',
'mango',
'mansion',
'manual',
'maple',
'marble',
'march',
'margin',
'marine',
'market',
'marriage',
'mask',
'mass',
'master',
'match',
'material',
'math',
'matrix',
'matter',
'maximum',
'maze',
'meadow',
'mean',
'measure',
'meat',
'mechanic',
'medal',
'media',
'melody',
'melt',
'member',
'memory',
'mention',
'menu',
'mercy',
'merge',
'merit',
'merry',
'mesh',
'message',
'metal',
'method',
'middle',
'midnight',
'milk',
'million',
'mimic',
'mind',
'minimum',
'minor',
'minute',
'miracle',
'mirror',
'misery',
'miss',
'mistake',
'mix',
'mixed',
'mixture',
'mobile',
'model',
'modify',
'mom',
'moment',
'monitor',
'monkey',
'monster',
'month',
'moon',
'moral',
'more',
'morning',
'mosquito',
'mother',
'motion',
'motor',
'mountain',
'mouse',
'move',
'movie',
'much',
'muffin',
'mule',
'multiply',
'muscle',
'museum',
'mushroom',
'music',
'must',
'mutual',
'myself',
'mystery',
'myth',
'naive',
'name',
'napkin',
'narrow',
'nasty',
'nation',
'nature',
'near',
'neck',
'need',
'negative',
'neglect',
'neither',
'nephew',
'nerve',
'nest',
'net',
'network',
'neutral',
'never',
'news',
'next',
'nice',
'night',
'noble',
'noise',
'nominee',
'noodle',
'normal',
'north',
'nose',
'notable',
'note',
'nothing',
'notice',
'novel',
'now',
'nuclear',
'number',
'nurse',
'nut',
'oak',
'obey',
'object',
'oblige',
'obscure',
'observe',
'obtain',
'obvious',
'occur',
'ocean',
'october',
'odor',
'off',
'offer',
'office',
'often',
'oil',
'okay',
'old',
'olive',
'olympic',
'omit',
'once',
'one',
'onion',
'online',
'only',
'open',
'opera',
'opinion',
'oppose',
'option',
'orange',
'orbit',
'orchard',
'order',
'ordinary',
'organ',
'orient',
'original',
'orphan',
'ostrich',
'other',
'outdoor',
'outer',
'output',
'outside',
'oval',
'oven',
'over',
'own',
'owner',
'oxygen',
'oyster',
'ozone',
'pact',
'paddle',
'page',
'pair',
'palace',
'palm',
'panda',
'panel',
'panic',
'panther',
'paper',
'parade',
'parent',
'park',
'parrot',
'party',
'pass',
'patch',
'path',
'patient',
'patrol',
'pattern',
'pause',
'pave',
'payment',
'peace',
'peanut',
'pear',
'peasant',
'pelican',
'pen',
'penalty',
'pencil',
'people',
'pepper',
'perfect',
'permit',
'person',
'pet',
'phone',
'photo',
'phrase',
'physical',
'piano',
'picnic',
'picture',
'piece',
'pig',
'pigeon',
'pill',
'pilot',
'pink',
'pioneer',
'pipe',
'pistol',
'pitch',
'pizza',
'place',
'planet',
'plastic',
'plate',
'play',
'please',
'pledge',
'pluck',
'plug',
'plunge',
'poem',
'poet',
'point',
'polar',
'pole',
'police',
'pond',
'pony',
'pool',
'popular',
'portion',
'position',
'possible',
'post',
'potato',
'pottery',
'poverty',
'powder',
'power',
'practice',
'praise',
'predict',
'prefer',
'prepare',
'present',
'pretty',
'prevent',
'price',
'pride',
'primary',
'print',
'priority',
'prison',
'private',
'prize',
'problem',
'process',
'produce',
'profit',
'program',
'project',
'promote',
'proof',
'property',
'prosper',
'protect',
'proud',
'provide',
'public',
'pudding',
'pull',
'pulp',
'pulse',
'pumpkin',
'punch',
'pupil',
'puppy',
'purchase',
'purity',
'purpose',
'purse',
'push',
'put',
'puzzle',
'pyramid',
'quality',
'quantum',
'quarter',
'question',
'quick',
'quit',
'quiz',
'quote',
'rabbit',
'raccoon',
'race',
'rack',
'radar',
'radio',
'rail',
'rain',
'raise',
'rally',
'ramp',
'ranch',
'random',
'range',
'rapid',
'rare',
'rate',
'rather',
'raven',
'raw',
'razor',
'ready',
'real',
'reason',
'rebel',
'rebuild',
'recall',
'receive',
'recipe',
'record',
'recycle',
'reduce',
'reflect',
'reform',
'refuse',
'region',
'regret',
'regular',
'reject',
'relax',
'release',
'relief',
'rely',
'remain',
'remember',
'remind',
'remove',
'render',
'renew',
'rent',
'reopen',
'repair',
'repeat',
'replace',
'report',
'require',
'rescue',
'resemble',
'resist',
'resource',
'response',
'result',
'retire',
'retreat',
'return',
'reunion',
'reveal',
'review',
'reward',
'rhythm',
'rib',
'ribbon',
'rice',
'rich',
'ride',
'ridge',
'rifle',
'right',
'rigid',
'ring',
'riot',
'ripple',
'risk',
'ritual',
'rival',
'river',
'road',
'roast',
'robot',
'robust',
'rocket',
'romance',
'roof',
'rookie',
'room',
'rose',
'rotate',
'rough',
'round',
'route',
'royal',
'rubber',
'rude',
'rug',
'rule',
'run',
'runway',
'rural',
'sad',
'saddle',
'sadness',
'safe',
'sail',
'salad',
'salmon',
'salon',
'salt',
'salute',
'same',
'sample',
'sand',
'satisfy',
'satoshi',
'sauce',
'sausage',
'save',
'say',
'scale',
'scan',
'scare',
'scatter',
'scene',
'scheme',
'school',
'science',
'scissors',
'scorpion',
'scout',
'scrap',
'screen',
'script',
'scrub',
'sea',
'search',
'season',
'seat',
'second',
'secret',
'section',
'security',
'seed',
'seek',
'segment',
'select',
'sell',
'seminar',
'senior',
'sense',
'sentence',
'series',
'service',
'session',
'settle',
'setup',
'seven',
'shadow',
'shaft',
'shallow',
'share',
'shed',
'shell',
'sheriff',
'shield',
'shift',
'shine',
'ship',
'shiver',
'shock',
'shoe',
'shoot',
'shop',
'short',
'shoulder',
'shove',
'shrimp',
'shrug',
'shuffle',
'shy',
'sibling',
'sick',
'side',
'siege',
'sight',
'sign',
'silent',
'silk',
'silly',
'silver',
'similar',
'simple',
'since',
'sing',
'siren',
'sister',
'situate',
'six',
'size',
'skate',
'sketch',
'ski',
'skill',
'skin',
'skirt',
'skull',
'slab',
'slam',
'sleep',
'slender',
'slice',
'slide',
'slight',
'slim',
'slogan',
'slot',
'slow',
'slush',
'small',
'smart',
'smile',
'smoke',
'smooth',
'snack',
'snake',
'snap',
'sniff',
'snow',
'soap',
'soccer',
'social',
'sock',
'soda',
'soft',
'solar',
'soldier',
'solid',
'solution',
'solve',
'someone',
'song',
'soon',
'sorry',
'sort',
'soul',
'sound',
'soup',
'source',
'south',
'space',
'spare',
'spatial',
'spawn',
'speak',
'special',
'speed',
'spell',
'spend',
'sphere',
'spice',
'spider',
'spike',
'spin',
'spirit',
'split',
'spoil',
'sponsor',
'spoon',
'sport',
'spot',
'spray',
'spread',
'spring',
'spy',
'square',
'squeeze',
'squirrel',
'stable',
'stadium',
'staff',
'stage',
'stairs',
'stamp',
'stand',
'start',
'state',
'stay',
'steak',
'steel',
'stem',
'step',
'stereo',
'stick',
'still',
'sting',
'stock',
'stomach',
'stone',
'stool',
'story',
'stove',
'strategy',
'street',
'strike',
'strong',
'struggle',
'student',
'stuff',
'stumble',
'style',
'subject',
'submit',
'subway',
'success',
'such',
'sudden',
'suffer',
'sugar',
'suggest',
'suit',
'summer',
'sun',
'sunny',
'sunset',
'super',
'supply',
'supreme',
'sure',
'surface',
'surge',
'surprise',
'surround',
'survey',
'suspect',
'sustain',
'swallow',
'swamp',
'swap',
'swarm',
'swear',
'sweet',
'swift',
'swim',
'swing',
'switch',
'sword',
'symbol',
'symptom',
'syrup',
'system',
'table',
'tackle',
'tag',
'tail',
'talent',
'talk',
'tank',
'tape',
'target',
'task',
'taste',
'tattoo',
'taxi',
'teach',
'team',
'tell',
'ten',
'tenant',
'tennis',
'tent',
'term',
'test',
'text',
'thank',
'that',
'theme',
'then',
'theory',
'there',
'they',
'thing',
'this',
'thought',
'three',
'thrive',
'throw',
'thumb',
'thunder',
'ticket',
'tide',
'tiger',
'tilt',
'timber',
'time',
'tiny',
'tip',
'tired',
'tissue',
'title',
'toast',
'tobacco',
'today',
'toddler',
'toe',
'together',
'toilet',
'token',
'tomato',
'tomorrow',
'tone',
'tongue',
'tonight',
'tool',
'tooth',
'top',
'topic',
'topple',
'torch',
'tornado',
'tortoise',
'toss',
'total',
'tourist',
'toward',
'tower',
'town',
'toy',
'track',
'trade',
'traffic',
'tragic',
'train',
'transfer',
'trap',
'trash',
'travel',
'tray',
'treat',
'tree',
'trend',
'trial',
'tribe',
'trick',
'trigger',
'trim',
'trip',
'trophy',
'trouble',
'truck',
'true',
'truly',
'trumpet',
'trust',
'truth',
'try',
'tube',
'tuition',
'tumble',
'tuna',
'tunnel',
'turkey',
'turn',
'turtle',
'twelve',
'twenty',
'twice',
'twin',
'twist',
'two',
'type',
'typical',
'ugly',
'umbrella',
'unable',
'unaware',
'uncle',
'uncover',
'under',
'undo',
'unfair',
'unfold',
'unhappy',
'uniform',
'unique',
'unit',
'universe',
'unknown',
'unlock',
'until',
'unusual',
'unveil',
'update',
'upgrade',
'uphold',
'upon',
'upper',
'upset',
'urban',
'urge',
'usage',
'use',
'used',
'useful',
'useless',
'usual',
'utility',
'vacant',
'vacuum',
'vague',
'valid',
'valley',
'valve',
'van',
'vanish',
'vapor',
'various',
'vast',
'vault',
'vehicle',
'velvet',
'vendor',
'venture',
'venue',
'verb',
'verify',
'version',
'very',
'vessel',
'veteran',
'viable',
'vibrant',
'vicious',
'victory',
'video',
'view',
'village',
'vintage',
'violin',
'virtual',
'virus',
'visa',
'visit',
'visual',
'vital',
'vivid',
'vocal',
'voice',
'void',
'volcano',
'volume',
'vote',
'voyage',
'wage',
'wagon',
'wait',
'walk',
'wall',
'walnut',
'want',
'warfare',
'warm',
'warrior',
'wash',
'wasp',
'waste',
'water',
'wave',
'way',
'wealth',
'weapon',
'wear',
'weasel',
'weather',
'web',
'wedding',
'weekend',
'weird',
'welcome',
'west',
'wet',
'whale',
'what',
'wheat',
'wheel',
'when',
'where',
'whip',
'whisper',
'wide',
'width',
'wife',
'wild',
'will',
'win',
'window',
'wine',
'wing',
'wink',
'winner',
'winter',
'wire',
'wisdom',
'wise',
'wish',
'witness',
'wolf',
'woman',
'wonder',
'wood',
'wool',
'word',
'work',
'world',
'worry',
'worth',
'wrap',
'wreck',
'wrestle',
'wrist',
'write',
'wrong',
'yard',
'year',
'yellow',
'you',
'young',
'youth',
'zebra',
'zero',
'zone',
'zoo'
];
// SPDX-License-Identifier: MIT
const WORDLIST$m = [
'abaisser',
'abandon',
'abdiquer',
'abeille',
'abolir',
'aborder',
'aboutir',
'aboyer',
'abrasif',
'abreuver',
'abriter',
'abroger',
'abrupt',
'absence',
'absolu',
'absurde',
'abusif',
'abyssal',
'académie',
'acajou',
'acarien',
'accabler',
'accepter',
'acclamer',
'accolade',
'accroche',
'accuser',
'acerbe',
'achat',
'acheter',
'aciduler',
'acier',
'acompte',
'acquérir',
'acronyme',
'acteur',
'actif',
'actuel',
'adepte',
'adéquat',
'adhésif',
'adjectif',
'adjuger',
'admettre',
'admirer',
'adopter',
'adorer',
'adoucir',
'adresse',
'adroit',
'adulte',
'adverbe',
'aérer',
'aéronef',
'affaire',
'affecter',
'affiche',
'affreux',
'affubler',
'agacer',
'agencer',
'agile',
'agiter',
'agrafer',
'agréable',
'agrume',
'aider',
'aiguille',
'ailier',
'aimable',
'aisance',
'ajouter',
'ajuster',
'alarmer',
'alchimie',
'alerte',
'algèbre',
'algue',
'aliéner',
'aliment',
'alléger',
'alliage',
'allouer',
'allumer',
'alourdir',
'alpaga',
'altesse',
'alvéole',
'amateur',
'ambigu',
'ambre',
'aménager',
'amertume',
'amidon',
'amiral',
'amorcer',
'amour',
'amovible',
'amphibie',
'ampleur',
'amusant',
'analyse',
'anaphore',
'anarchie',
'anatomie',
'ancien',
'anéantir',
'angle',
'angoisse',
'anguleux',
'animal',
'annexer',
'annonce',
'annuel',
'anodin',
'anomalie',
'anonyme',
'anormal',
'antenne',
'antidote',
'anxieux',
'apaiser',
'apéritif',
'aplanir',
'apologie',
'appareil',
'appeler',
'apporter',
'appuyer',
'aquarium',
'aqueduc',
'arbitre',
'arbuste',
'ardeur',
'ardoise',
'argent',
'arlequin',
'armature',
'armement',
'armoire',
'armure',
'arpenter',
'arracher',
'arriver',
'arroser',
'arsenic',
'artériel',
'article',
'aspect',
'asphalte',
'aspirer',
'assaut',
'asservir',
'assiette',
'associer',
'assurer',
'asticot',
'astre',
'astuce',
'atelier',
'atome',
'atrium',
'atroce',
'attaque',
'attentif',
'attirer',
'attraper',
'aubaine',
'auberge',
'audace',
'audible',
'augurer',
'aurore',
'automne',
'autruche',
'avaler',
'avancer',
'avarice',
'avenir',
'averse',
'aveugle',
'aviateur',
'avide',
'avion',
'aviser',
'avoine',
'avouer',
'avril',
'axial',
'axiome',
'badge',
'bafouer',
'bagage',
'baguette',
'baignade',
'balancer',
'balcon',
'baleine',
'balisage',
'bambin',
'bancaire',
'bandage',
'banlieue',
'bannière',
'banquier',
'barbier',
'baril',
'baron',
'barque',
'barrage',
'bassin',
'bastion',
'bataille',
'bateau',
'batterie',
'baudrier',
'bavarder',
'belette',
'bélier',
'belote',
'bénéfice',
'berceau',
'berger',
'berline',
'bermuda',
'besace',
'besogne',
'bétail',
'beurre',
'biberon',
'bicycle',
'bidule',
'bijou',
'bilan',
'bilingue',
'billard',
'binaire',
'biologie',
'biopsie',
'biotype',
'biscuit',
'bison',
'bistouri',
'bitume',
'bizarre',
'blafard',
'blague',
'blanchir',
'blessant',
'blinder',
'blond',
'bloquer',
'blouson',
'bobard',
'bobine',
'boire',
'boiser',
'bolide',
'bonbon',
'bondir',
'bonheur',
'bonifier',
'bonus',
'bordure',
'borne',
'botte',
'boucle',
'boueux',
'bougie',
'boulon',
'bouquin',
'bourse',
'boussole',
'boutique',
'boxeur',
'branche',
'brasier',
'brave',
'brebis',
'brèche',
'breuvage',
'bricoler',
'brigade',
'brillant',
'brioche',
'brique',
'brochure',
'broder',
'bronzer',
'brousse',
'broyeur',
'brume',
'brusque',
'brutal',
'bruyant',
'buffle',
'buisson',
'bulletin',
'bureau',
'burin',
'bustier',
'butiner',
'butoir',
'buvable',
'buvette',
'cabanon',
'cabine',
'cachette',
'cadeau',
'cadre',
'caféine',
'caillou',
'caisson',
'calculer',
'calepin',
'calibre',
'calmer',
'calomnie',
'calvaire',
'camarade',
'caméra',
'camion',
'campagne',
'canal',
'caneton',
'canon',
'cantine',
'canular',
'capable',
'caporal',
'caprice',
'capsule',
'capter',
'capuche',
'carabine',
'carbone',
'caresser',
'caribou',
'carnage',
'carotte',
'carreau',
'carton',
'cascade',
'casier',
'casque',
'cassure',
'causer',
'caution',
'cavalier',
'caverne',
'caviar',
'cédille',
'ceinture',
'céleste',
'cellule',
'cendrier',
'censurer',
'central',
'cercle',
'cérébral',
'cerise',
'cerner',
'cerveau',
'cesser',
'chagrin',
'chaise',
'chaleur',
'chambre',
'chance',
'chapitre',
'charbon',
'chasseur',
'chaton',
'chausson',
'chavirer',
'chemise',
'chenille',
'chéquier',
'chercher',
'cheval',
'chien',
'chiffre',
'chignon',
'chimère',
'chiot',
'chlorure',
'chocolat',
'choisir',
'chose',
'chouette',
'chrome',
'chute',
'cigare',
'cigogne',
'cimenter',
'cinéma',
'cintrer',
'circuler',
'cirer',
'cirque',
'citerne',
'citoyen',
'citron',
'civil',
'clairon',
'clameur',
'claquer',
'classe',
'clavier',
'client',
'cligner',
'climat',
'clivage',
'cloche',
'clonage',
'cloporte',
'cobalt',
'cobra',
'cocasse',
'cocotier',
'coder',
'codifier',
'coffre',
'cogner',
'cohésion',
'coiffer',
'coincer',
'colère',
'colibri',
'colline',
'colmater',
'colonel',
'combat',
'comédie',
'commande',
'compact',
'concert',
'conduire',
'confier',
'congeler',
'connoter',
'consonne',
'contact',
'convexe',
'copain',
'copie',
'corail',
'corbeau',
'cordage',
'corniche',
'corpus',
'correct',
'cortège',
'cosmique',
'costume',
'coton',
'coude',
'coupure',
'courage',
'couteau',
'couvrir',
'coyote',
'crabe',
'crainte',
'cravate',
'crayon',
'créature',
'créditer',
'crémeux',
'creuser',
'crevette',
'cribler',
'crier',
'cristal',
'critère',
'croire',
'croquer',
'crotale',
'crucial',
'cruel',
'crypter',
'cubique',
'cueillir',
'cuillère',
'cuisine',
'cuivre',
'culminer',
'cultiver',
'cumuler',
'cupide',
'curatif',
'curseur',
'cyanure',
'cycle',
'cylindre',
'cynique',
'daigner',
'damier',
'danger',
'danseur',
'dauphin',
'débattre',
'débiter',
'déborder',
'débrider',
'débutant',
'décaler',
'décembre',
'déchirer',
'décider',
'déclarer',
'décorer',
'décrire',
'décupler',
'dédale',
'déductif',
'déesse',
'défensif',
'défiler',
'défrayer',
'dégager',
'dégivrer',
'déglutir',
'dégrafer',
'déjeuner',
'délice',
'déloger',
'demander',
'demeurer',
'démolir',
'dénicher',
'dénouer',
'dentelle',
'dénuder',
'départ',
'dépenser',
'déphaser',
'déplacer',
'déposer',
'déranger',
'dérober',
'désastre',
'descente',
'désert',
'désigner',
'désobéir',
'dessiner',
'destrier',
'détacher',
'détester',
'détourer',
'détresse',
'devancer',
'devenir',
'deviner',
'devoir',
'diable',
'dialogue',
'diamant',
'dicter',
'différer',
'digérer',
'digital',
'digne',
'diluer',
'dimanche',
'diminuer',
'dioxyde',
'directif',
'diriger',
'discuter',
'disposer',
'dissiper',
'distance',
'divertir',
'diviser',
'docile',
'docteur',
'dogme',
'doigt',
'domaine',
'domicile',
'dompter',
'donateur',
'donjon',
'donner',
'dopamine',
'dortoir',
'dorure',
'dosage',
'doseur',
'dossier',
'dotation',
'douanier',
'double',
'douceur',
'douter',
'doyen',
'dragon',
'draper',
'dresser',
'dribbler',
'droiture',
'duperie',
'duplexe',
'durable',
'durcir',
'dynastie',
'éblouir',
'écarter',
'écharpe',
'échelle',
'éclairer',
'éclipse',
'éclore',
'écluse',
'école',
'économie',
'écorce',
'écouter',
'écraser',
'écrémer',
'écrivain',
'écrou',
'écume',
'écureuil',
'édifier',
'éduquer',
'effacer',
'effectif',
'effigie',
'effort',
'effrayer',
'effusion',
'égaliser',
'égarer',
'éjecter',
'élaborer',
'élargir',
'électron',
'élégant',
'éléphant',
'élève',
'éligible',
'élitisme',
'éloge',
'élucider',
'éluder',
'emballer',
'embellir',
'embryon',
'émeraude',
'émission',
'emmener',
'émotion',
'émouvoir',
'empereur',
'employer',
'emporter',
'emprise',
'émulsion',
'encadrer',
'enchère',
'enclave',
'encoche',
'endiguer',
'endosser',
'endroit',
'enduire',
'énergie',
'enfance',
'enfermer',
'enfouir',
'engager',
'engin',
'englober',
'énigme',
'enjamber',
'enjeu',
'enlever',
'ennemi',
'ennuyeux',
'enrichir',
'enrobage',
'enseigne',
'entasser',
'entendre',
'entier',
'entourer',
'entraver',
'énumérer',
'envahir',
'enviable',
'envoyer',
'enzyme',
'éolien',
'épaissir',
'épargne',
'épatant',
'épaule',
'épicerie',
'épidémie',
'épier',
'épilogue',
'épine',
'épisode',
'épitaphe',
'époque',
'épreuve',
'éprouver',
'épuisant',
'équerre',
'équipe',
'ériger',
'érosion',
'erreur',
'éruption',
'escalier',
'espadon',
'espèce',
'espiègle',
'espoir',
'esprit',
'esquiver',
'essayer',
'essence',
'essieu',
'essorer',
'estime',
'estomac',
'estrade',
'étagère',
'étaler',
'étanche',
'étatique',
'éteindre',
'étendoir',
'éternel',
'éthanol',
'éthique',
'ethnie',
'étirer',
'étoffer',
'étoile',
'étonnant',
'étourdir',
'étrange',
'étroit',
'étude',
'euphorie',
'évaluer',
'évasion',
'éventail',
'évidence',
'éviter',
'évolutif',
'évoquer',
'exact',
'exagérer',
'exaucer',
'exceller',
'excitant',
'exclusif',
'excuse',
'exécuter',
'exemple',
'exercer',
'exhaler',
'exhorter',
'exigence',
'exiler',
'exister',
'exotique',
'expédier',
'explorer',
'exposer',
'exprimer',
'exquis',
'extensif',
'extraire',
'exulter',
'fable',
'fabuleux',
'facette',
'facile',
'facture',
'faiblir',
'falaise',
'fameux',
'famille',
'farceur',
'farfelu',
'farine',
'farouche',
'fasciner',
'fatal',
'fatigue',
'faucon',
'fautif',
'faveur',
'favori',
'fébrile',
'féconder',
'fédérer',
'félin',
'femme',
'fémur',
'fendoir',
'féodal',
'fermer',
'féroce',
'ferveur',
'festival',
'feuille',
'feutre',
'février',
'fiasco',
'ficeler',
'fictif',
'fidèle',
'figure',
'filature',
'filetage',
'filière',
'filleul',
'filmer',
'filou',
'filtrer',
'financer',
'finir',
'fiole',
'firme',
'fissure',
'fixer',
'flairer',
'flamme',
'flasque',
'flatteur',
'fléau',
'flèche',
'fleur',
'flexion',
'flocon',
'flore',
'fluctuer',
'fluide',
'fluvial',
'folie',
'fonderie',
'fongible',
'fontaine',
'forcer',
'forgeron',
'formuler',
'fortune',
'fossile',
'foudre',
'fougère',
'fouiller',
'foulure',
'fourmi',
'fragile',
'fraise',
'franchir',
'frapper',
'frayeur',
'frégate',
'freiner',
'frelon',
'frémir',
'frénésie',
'frère',
'friable',
'friction',
'frisson',
'frivole',
'froid',
'fromage',
'frontal',
'frotter',
'fruit',
'fugitif',
'fuite',
'fureur',
'furieux',
'furtif',
'fusion',
'futur',
'gagner',
'galaxie',
'galerie',
'gambader',
'garantir',
'gardien',
'garnir',
'garrigue',
'gazelle',
'gazon',
'géant',
'gélatine',
'gélule',
'gendarme',
'général',
'génie',
'genou',
'gentil',
'géologie',
'géomètre',
'géranium',
'germe',
'gestuel',
'geyser',
'gibier',
'gicler',
'girafe',
'givre',
'glace',
'glaive',
'glisser',
'globe',
'gloire',
'glorieux',
'golfeur',
'gomme',
'gonfler',
'gorge',
'gorille',
'goudron',
'gouffre',
'goulot',
'goupille',
'gourmand',
'goutte',
'graduel',
'graffiti',
'graine',
'grand',
'grappin',
'gratuit',
'gravir',
'grenat',
'griffure',
'griller',
'grimper',
'grogner',
'gronder',
'grotte',
'groupe',
'gruger',
'grutier',
'gruyère',
'guépard',
'guerrier',
'guide',
'guimauve',
'guitare',
'gustatif',
'gymnaste',
'gyrostat',
'habitude',
'hachoir',
'halte',
'hameau',
'hangar',
'hanneton',
'haricot',
'harmonie',
'harpon',
'hasard',
'hélium',
'hématome',
'herbe',
'hérisson',
'hermine',
'héron',
'hésiter',
'heureux',
'hiberner',
'hibou',
'hilarant',
'histoire',
'hiver',
'homard',
'hommage',
'homogène',
'honneur',
'honorer',
'honteux',
'horde',
'horizon',
'horloge',
'hormone',
'horrible',
'houleux',
'housse',
'hublot',
'huileux',
'humain',
'humble',
'humide',
'humour',
'hurler',
'hydromel',
'hygiène',
'hymne',
'hypnose',
'idylle',
'ignorer',
'iguane',
'illicite',
'illusion',
'image',
'imbiber',
'imiter',
'immense',
'immobile',
'immuable',
'impact',
'impérial',
'implorer',
'imposer',
'imprimer',
'imputer',
'incarner',
'incendie',
'incident',
'incliner',
'incolore',
'indexer',
'indice',
'inductif',
'inédit',
'ineptie',
'inexact',
'infini',
'infliger',
'informer',
'infusion',
'ingérer',
'inhaler',
'inhiber',
'injecter',
'injure',
'innocent',
'inoculer',
'inonder',
'inscrire',
'insecte',
'insigne',
'insolite',
'inspirer',
'instinct',
'insulter',
'intact',
'intense',
'intime',
'intrigue',
'intuitif',
'inutile',
'invasion',
'inventer',
'inviter',
'invoquer',
'ironique',
'irradier',
'irréel',
'irriter',
'isoler',
'ivoire',
'ivresse',
'jaguar',
'jaillir',
'jambe',
'janvier',
'jardin',
'jauger',
'jaune',
'javelot',
'jetable',
'jeton',
'jeudi',
'jeunesse',
'joindre',
'joncher',
'jongler',
'joueur',
'jouissif',
'journal',
'jovial',
'joyau',
'joyeux',
'jubiler',
'jugement',
'junior',
'jupon',
'juriste',
'justice',
'juteux',
'juvénile',
'kayak',
'kimono',
'kiosque',
'label',
'labial',
'labourer',
'lacérer',
'lactose',
'lagune',
'laine',
'laisser',
'laitier',
'lambeau',
'lamelle',
'lampe',
'lanceur',
'langage',
'lanterne',
'lapin',
'largeur',
'larme',
'laurier',
'lavabo',
'lavoir',
'lecture',
'légal',
'léger',
'légume',
'lessive',
'lettre',
'levier',
'lexique',
'lézard',
'liasse',
'libérer',
'libre',
'licence',
'licorne',
'liège',
'lièvre',
'ligature',
'ligoter',
'ligue',
'limer',
'limite',
'limonade',
'limpide',
'linéaire',
'lingot',
'lionceau',
'liquide',
'lisière',
'lister',
'lithium',
'litige',
'littoral',
'livreur',
'logique',
'lointain',
'loisir',
'lombric',
'loterie',
'louer',
'lourd',
'loutre',
'louve',
'loyal',
'lubie',
'lucide',
'lucratif',
'lueur',
'lugubre',
'luisant',
'lumière',
'lunaire',
'lundi',
'luron',
'lutter',
'luxueux',
'machine',
'magasin',
'magenta',
'magique',
'maigre',
'maillon',
'maintien',
'mairie',
'maison',
'majorer',
'malaxer',
'maléfice',
'malheur',
'malice',
'mallette',
'mammouth',
'mandater',
'maniable',
'manquant',
'manteau',
'manuel',
'marathon',
'marbre',
'marchand',
'mardi',
'maritime',
'marqueur',
'marron',
'marteler',
'mascotte',
'massif',
'matériel',
'matière',
'matraque',
'maudire',
'maussade',
'mauve',
'maximal',
'méchant',
'méconnu',
'médaille',
'médecin',
'méditer',
'méduse',
'meilleur',
'mélange',
'mélodie',
'membre',
'mémoire',
'menacer',
'mener',
'menhir',
'mensonge',
'mentor',
'mercredi',
'mérite',
'merle',
'messager',
'mesure',
'métal',
'météore',
'méthode',
'métier',
'meuble',
'miauler',
'microbe',
'miette',
'mignon',
'migrer',
'milieu',
'million',
'mimique',
'mince',
'minéral',
'minimal',
'minorer',
'minute',
'miracle',
'miroiter',
'missile',
'mixte',
'mobile',
'moderne',
'moelleux',
'mondial',
'moniteur',
'monnaie',
'monotone',
'monstre',
'montagne',
'monument',
'moqueur',
'morceau',
'morsure',
'mortier',
'moteur',
'motif',
'mouche',
'moufle',
'moulin',
'mousson',
'mouton',
'mouvant',
'multiple',
'munition',
'muraille',
'murène',
'murmure',
'muscle',
'muséum',
'musicien',
'mutation',
'muter',
'mutuel',
'myriade',
'myrtille',
'mystère',
'mythique',
'nageur',
'nappe',
'narquois',
'narrer',
'natation',
'nation',
'nature',
'naufrage',
'nautique',
'navire',
'nébuleux',
'nectar',
'néfaste',
'négation',
'négliger',
'négocier',
'neige',
'nerveux',
'nettoyer',
'neurone',
'neutron',
'neveu',
'niche',
'nickel',
'nitrate',
'niveau',
'noble',
'nocif',
'nocturne',
'noirceur',
'noisette',
'nomade',
'nombreux',
'nommer',
'normatif',
'notable',
'notifier',
'notoire',
'nourrir',
'nouveau',
'novateur',
'novembre',
'novice',
'nuage',
'nuancer',
'nuire',
'nuisible',
'numéro',
'nuptial',
'nuque',
'nutritif',
'obéir',
'objectif',
'obliger',
'obscur',
'observer',
'obstacle',
'obtenir',
'obturer',
'occasion',
'occuper',
'océan',
'octobre',
'octroyer',
'octupler',
'oculaire',
'odeur',
'odorant',
'offenser',
'officier',
'offrir',
'ogive',
'oiseau',
'oisillon',
'olfactif',
'olivier',
'ombrage',
'omettre',
'onctueux',
'onduler',
'onéreux',
'onirique',
'opale',
'opaque',
'opérer',
'opinion',
'opportun',
'opprimer',
'opter',
'optique',
'orageux',
'orange',
'orbite',
'ordonner',
'oreille',
'organe',
'orgueil',
'orifice',
'ornement',
'orque',
'ortie',
'osciller',
'osmose',
'ossature',
'otarie',
'ouragan',
'ourson',
'outil',
'outrager',
'ouvrage',
'ovation',
'oxyde',
'oxygène',
'ozone',
'paisible',
'palace',
'palmarès',
'palourde',
'palper',
'panache',
'panda',
'pangolin',
'paniquer',
'panneau',
'panorama',
'pantalon',
'papaye',
'papier',
'papoter',
'papyrus',
'paradoxe',
'parcelle',
'paresse',
'parfumer',
'parler',
'parole',
'parrain',
'parsemer',
'partager',
'parure',
'parvenir',
'passion',
'pastèque',
'paternel',
'patience',
'patron',
'pavillon',
'pavoiser',
'payer',
'paysage',
'peigne',
'peintre',
'pelage',
'pélican',
'pelle',
'pelouse',
'peluche',
'pendule',
'pénétrer',
'pénible',
'pensif',
'pénurie',
'pépite',
'péplum',
'perdrix',
'perforer',
'période',
'permuter',
'perplexe',
'persil',
'perte',
'peser',
'pétale',
'petit',
'pétrir',
'peuple',
'pharaon',
'phobie',
'phoque',
'photon',
'phrase',
'physique',
'piano',
'pictural',
'pièce',
'pierre',
'pieuvre',
'pilote',
'pinceau',
'pipette',
'piquer',
'pirogue',
'piscine',
'piston',
'pivoter',
'pixel',
'pizza',
'placard',
'plafond',
'plaisir',
'planer',
'plaque',
'plastron',
'plateau',
'pleurer',
'plexus',
'pliage',
'plomb',
'plonger',
'pluie',
'plumage',
'pochette',
'poésie',
'poète',
'pointe',
'poirier',
'poisson',
'poivre',
'polaire',
'policier',
'pollen',
'polygone',
'pommade',
'pompier',
'ponctuel',
'pondérer',
'poney',
'portique',
'position',
'posséder',
'posture',
'potager',
'poteau',
'potion',
'pouce',
'poulain',
'poumon',
'pourpre',
'poussin',
'pouvoir',
'prairie',
'pratique',
'précieux',
'prédire',
'préfixe',
'prélude',
'prénom',
'présence',
'prétexte',
'prévoir',
'primitif',
'prince',
'prison',
'priver',
'problème',
'procéder',
'prodige',
'profond',
'progrès',
'proie',
'projeter',
'prologue',
'promener',
'propre',
'prospère',
'protéger',
'prouesse',
'proverbe',
'prudence',
'pruneau',
'psychose',
'public',
'puceron',
'puiser',
'pulpe',
'pulsar',
'punaise',
'punitif',
'pupitre',
'purifier',
'puzzle',
'pyramide',
'quasar',
'querelle',
'question',
'quiétude',
'quitter',
'quotient',
'racine',
'raconter',
'radieux',
'ragondin',
'raideur',
'raisin',
'ralentir',
'rallonge',
'ramasser',
'rapide',
'rasage',
'ratisser',
'ravager',
'ravin',
'rayonner',
'réactif',
'réagir',
'réaliser',
'réanimer',
'recevoir',
'réciter',
'réclamer',
'récolter',
'recruter',
'reculer',
'recycler',
'rédiger',
'redouter',
'refaire',
'réflexe',
'réformer',
'refrain',
'refuge',
'régalien',
'région',
'réglage',
'régulier',
'réitérer',
'rejeter',
'rejouer',
'relatif',
'relever',
'relief',
'remarque',
'remède',
'remise',
'remonter',
'remplir',
'remuer',
'renard',
'renfort',
'renifler',
'renoncer',
'rentrer',
'renvoi',
'replier',
'reporter',
'reprise',
'reptile',
'requin',
'réserve',
'résineux',
'résoudre',
'respect',
'rester',
'résultat',
'rétablir',
'retenir',
'réticule',
'retomber',
'retracer',
'réunion',
'réussir',
'revanche',
'revivre',
'révolte',
'révulsif',
'richesse',
'rideau',
'rieur',
'rigide',
'rigoler',
'rincer',
'riposter',
'risible',
'risque',
'rituel',
'rival',
'rivière',
'rocheux',
'romance',
'rompre',
'ronce',
'rondin',
'roseau',
'rosier',
'rotatif',
'rotor',
'rotule',
'rouge',
'rouille',
'rouleau',
'routine',
'royaume',
'ruban',
'rubis',
'ruche',
'ruelle',
'rugueux',
'ruiner',
'ruisseau',
'ruser',
'rustique',
'rythme',
'sabler',
'saboter',
'sabre',
'sacoche',
'safari',
'sagesse',
'saisir',
'salade',
'salive',
'salon',
'saluer',
'samedi',
'sanction',
'sanglier',
'sarcasme',
'sardine',
'saturer',
'saugrenu',
'saumon',
'sauter',
'sauvage',
'savant',
'savonner',
'scalpel',
'scandale',
'scélérat',
'scénario',
'sceptre',
'schéma',
'science',
'scinder',
'score',
'scrutin',
'sculpter',
'séance',
'sécable',
'sécher',
'secouer',
'sécréter',
'sédatif',
'séduire',
'seigneur',
'séjour',
'sélectif',
'semaine',
'sembler',
'semence',
'séminal',
'sénateur',
'sensible',
'sentence',
'séparer',
'séquence',
'serein',
'sergent',
'sérieux',
'serrure',
'sérum',
'service',
'sésame',
'sévir',
'sevrage',
'sextuple',
'sidéral',
'siècle',
'siéger',
'siffler',
'sigle',
'signal',
'silence',
'silicium',
'simple',
'sincère',
'sinistre',
'siphon',
'sirop',
'sismique',
'situer',
'skier',
'social',
'socle',
'sodium',
'soigneux',
'soldat',
'soleil',
'solitude',
'soluble',
'sombre',
'sommeil',
'somnoler',
'sonde',
'songeur',
'sonnette',
'sonore',
'sorcier',
'sortir',
'sosie',
'sottise',
'soucieux',
'soudure',
'souffle',
'soulever',
'soupape',
'source',
'soutirer',
'souvenir',
'spacieux',
'spatial',
'spécial',
'sphère',
'spiral',
'stable',
'station',
'sternum',
'stimulus',
'stipuler',
'strict',
'studieux',
'stupeur',
'styliste',
'sublime',
'substrat',
'subtil',
'subvenir',
'succès',
'sucre',
'suffixe',
'suggérer',
'suiveur',
'sulfate',
'superbe',
'supplier',
'surface',
'suricate',
'surmener',
'surprise',
'sursaut',
'survie',
'suspect',
'syllabe',
'symbole',
'symétrie',
'synapse',
'syntaxe',
'système',
'tabac',
'tablier',
'tactile',
'tailler',
'talent',
'talisman',
'talonner',
'tambour',
'tamiser',
'tangible',
'tapis',
'taquiner',
'tarder',
'tarif',
'tartine',
'tasse',
'tatami',
'tatouage',
'taupe',
'taureau',
'taxer',
'témoin',
'temporel',
'tenaille',
'tendre',
'teneur',
'tenir',
'tension',
'terminer',
'terne',
'terrible',
'tétine',
'texte',
'thème',
'théorie',
'thérapie',
'thorax',
'tibia',
'tiède',
'timide',
'tirelire',
'tiroir',
'tissu',
'titane',
'titre',
'tituber',
'toboggan',
'tolérant',
'tomate',
'tonique',
'tonneau',
'toponyme',
'torche',
'tordre',
'tornade',
'torpille',
'torrent',
'torse',
'tortue',
'totem',
'toucher',
'tournage',
'tousser',
'toxine',
'traction',
'trafic',
'tragique',
'trahir',
'train',
'trancher',
'travail',
'trèfle',
'tremper',
'trésor',
'treuil',
'triage',
'tribunal',
'tricoter',
'trilogie',
'triomphe',
'tripler',
'triturer',
'trivial',
'trombone',
'tronc',
'tropical',
'troupeau',
'tuile',
'tulipe',
'tumulte',
'tunnel',
'turbine',
'tuteur',
'tutoyer',
'tuyau',
'tympan',
'typhon',
'typique',
'tyran',
'ubuesque',
'ultime',
'ultrason',
'unanime',
'unifier',
'union',
'unique',
'unitaire',
'univers',
'uranium',
'urbain',
'urticant',
'usage',
'usine',
'usuel',
'usure',
'utile',
'utopie',
'vacarme',
'vaccin',
'vagabond',
'vague',
'vaillant',
'vaincre',
'vaisseau',
'valable',
'valise',
'vallon',
'valve',
'vampire',
'vanille',
'vapeur',
'varier',
'vaseux',
'vassal',
'vaste',
'vecteur',
'vedette',
'végétal',
'véhicule',
'veinard',
'véloce',
'vendredi',
'vénérer',
'venger',
'venimeux',
'ventouse',
'verdure',
'vérin',
'vernir',
'verrou',
'verser',
'vertu',
'veston',
'vétéran',
'vétuste',
'vexant',
'vexer',
'viaduc',
'viande',
'victoire',
'vidange',
'vidéo',
'vignette',
'vigueur',
'vilain',
'village',
'vinaigre',
'violon',
'vipère',
'virement',
'virtuose',
'virus',
'visage',
'viseur',
'vision',
'visqueux',
'visuel',
'vital',
'vitesse',
'viticole',
'vitrine',
'vivace',
'vivipare',
'vocation',
'voguer',
'voile',
'voisin',
'voiture',
'volaille',
'volcan',
'voltiger',
'volume',
'vorace',
'vortex',
'voter',
'vouloir',
'voyage',
'voyelle',
'wagon',
'xénon',
'yacht',
'zèbre',
'zénith',
'zeste',
'zoologie'
];
// SPDX-License-Identifier: MIT
const WORDLIST$l = [
'abaco',
'abbaglio',
'abbinato',
'abete',
'abisso',
'abolire',
'abrasivo',
'abrogato',
'accadere',
'accenno',
'accusato',
'acetone',
'achille',
'acido',
'acqua',
'acre',
'acrilico',
'acrobata',
'acuto',
'adagio',
'addebito',
'addome',
'adeguato',
'aderire',
'adipe',
'adottare',
'adulare',
'affabile',
'affetto',
'affisso',
'affranto',
'aforisma',
'afoso',
'africano',
'agave',
'agente',
'agevole',
'aggancio',
'agire',
'agitare',
'agonismo',
'agricolo',
'agrumeto',
'aguzzo',
'alabarda',
'alato',
'albatro',
'alberato',
'albo',
'albume',
'alce',
'alcolico',
'alettone',
'alfa',
'algebra',
'aliante',
'alibi',
'alimento',
'allagato',
'allegro',
'allievo',
'allodola',
'allusivo',
'almeno',
'alogeno',
'alpaca',
'alpestre',
'altalena',
'alterno',
'alticcio',
'altrove',
'alunno',
'alveolo',
'alzare',
'amalgama',
'amanita',
'amarena',
'ambito',
'ambrato',
'ameba',
'america',
'ametista',
'amico',
'ammasso',
'ammenda',
'ammirare',
'ammonito',
'amore',
'ampio',
'ampliare',
'amuleto',
'anacardo',
'anagrafe',
'analista',
'anarchia',
'anatra',
'anca',
'ancella',
'ancora',
'andare',
'andrea',
'anello',
'angelo',
'angolare',
'angusto',
'anima',
'annegare',
'annidato',
'anno',
'annuncio',
'anonimo',
'anticipo',
'anzi',
'apatico',
'apertura',
'apode',
'apparire',
'appetito',
'appoggio',
'approdo',
'appunto',
'aprile',
'arabica',
'arachide',
'aragosta',
'araldica',
'arancio',
'aratura',
'arazzo',
'arbitro',
'archivio',
'ardito',
'arenile',
'argento',
'argine',
'arguto',
'aria',
'armonia',
'arnese',
'arredato',
'arringa',
'arrosto',
'arsenico',
'arso',
'artefice',
'arzillo',
'asciutto',
'ascolto',
'asepsi',
'asettico',
'asfalto',
'asino',
'asola',
'aspirato',
'aspro',
'assaggio',
'asse',
'assoluto',
'assurdo',
'asta',
'astenuto',
'astice',
'astratto',
'atavico',
'ateismo',
'atomico',
'atono',
'attesa',
'attivare',
'attorno',
'attrito',
'attuale',
'ausilio',
'austria',
'autista',
'autonomo',
'autunno',
'avanzato',
'avere',
'avvenire',
'avviso',
'avvolgere',
'azione',
'azoto',
'azzimo',
'azzurro',
'babele',
'baccano',
'bacino',
'baco',
'badessa',
'badilata',
'bagnato',
'baita',
'balcone',
'baldo',
'balena',
'ballata',
'balzano',
'bambino',
'bandire',
'baraonda',
'barbaro',
'barca',
'baritono',
'barlume',
'barocco',
'basilico',
'basso',
'batosta',
'battuto',
'baule',
'bava',
'bavosa',
'becco',
'beffa',
'belgio',
'belva',
'benda',
'benevole',
'benigno',
'benzina',
'bere',
'berlina',
'beta',
'bibita',
'bici',
'bidone',
'bifido',
'biga',
'bilancia',
'bimbo',
'binocolo',
'biologo',
'bipede',
'bipolare',
'birbante',
'birra',
'biscotto',
'bisesto',
'bisnonno',
'bisonte',
'bisturi',
'bizzarro',
'blando',
'blatta',
'bollito',
'bonifico',
'bordo',
'bosco',
'botanico',
'bottino',
'bozzolo',
'braccio',
'bradipo',
'brama',
'branca',
'bravura',
'bretella',
'brevetto',
'brezza',
'briglia',
'brillante',
'brindare',
'broccolo',
'brodo',
'bronzina',
'brullo',
'bruno',
'bubbone',
'buca',
'budino',
'buffone',
'buio',
'bulbo',
'buono',
'burlone',
'burrasca',
'bussola',
'busta',
'cadetto',
'caduco',
'calamaro',
'calcolo',
'calesse',
'calibro',
'calmo',
'caloria',
'cambusa',
'camerata',
'camicia',
'cammino',
'camola',
'campale',
'canapa',
'candela',
'cane',
'canino',
'canotto',
'cantina',
'capace',
'capello',
'capitolo',
'capogiro',
'cappero',
'capra',
'capsula',
'carapace',
'carcassa',
'cardo',
'carisma',
'carovana',
'carretto',
'cartolina',
'casaccio',
'cascata',
'caserma',
'caso',
'cassone',
'castello',
'casuale',
'catasta',
'catena',
'catrame',
'cauto',
'cavillo',
'cedibile',
'cedrata',
'cefalo',
'celebre',
'cellulare',
'cena',
'cenone',
'centesimo',
'ceramica',
'cercare',
'certo',
'cerume',
'cervello',
'cesoia',
'cespo',
'ceto',
'chela',
'chiaro',
'chicca',
'chiedere',
'chimera',
'china',
'chirurgo',
'chitarra',
'ciao',
'ciclismo',
'cifrare',
'cigno',
'cilindro',
'ciottolo',
'circa',
'cirrosi',
'citrico',
'cittadino',
'ciuffo',
'civetta',
'civile',
'classico',
'clinica',
'cloro',
'cocco',
'codardo',
'codice',
'coerente',
'cognome',
'collare',
'colmato',
'colore',
'colposo',
'coltivato',
'colza',
'coma',
'cometa',
'commando',
'comodo',
'computer',
'comune',
'conciso',
'condurre',
'conferma',
'congelare',
'coniuge',
'connesso',
'conoscere',
'consumo',
'continuo',
'convegno',
'coperto',
'copione',
'coppia',
'copricapo',
'corazza',
'cordata',
'coricato',
'cornice',
'corolla',
'corpo',
'corredo',
'corsia',
'cortese',
'cosmico',
'costante',
'cottura',
'covato',
'cratere',
'cravatta',
'creato',
'credere',
'cremoso',
'crescita',
'creta',
'criceto',
'crinale',
'crisi',
'critico',
'croce',
'cronaca',
'crostata',
'cruciale',
'crusca',
'cucire',
'cuculo',
'cugino',
'cullato',
'cupola',
'curatore',
'cursore',
'curvo',
'cuscino',
'custode',
'dado',
'daino',
'dalmata',
'damerino',
'daniela',
'dannoso',
'danzare',
'datato',
'davanti',
'davvero',
'debutto',
'decennio',
'deciso',
'declino',
'decollo',
'decreto',
'dedicato',
'definito',
'deforme',
'degno',
'delegare',
'delfino',
'delirio',
'delta',
'demenza',
'denotato',
'dentro',
'deposito',
'derapata',
'derivare',
'deroga',
'descritto',
'deserto',
'desiderio',
'desumere',
'detersivo',
'devoto',
'diametro',
'dicembre',
'diedro',
'difeso',
'diffuso',
'digerire',
'digitale',
'diluvio',
'dinamico',
'dinnanzi',
'dipinto',
'diploma',
'dipolo',
'diradare',
'dire',
'dirotto',
'dirupo',
'disagio',
'discreto',
'disfare',
'disgelo',
'disposto',
'distanza',
'disumano',
'dito',
'divano',
'divelto',
'dividere',
'divorato',
'doblone',
'docente',
'doganale',
'dogma',
'dolce',
'domato',
'domenica',
'dominare',
'dondolo',
'dono',
'dormire',
'dote',
'dottore',
'dovuto',
'dozzina',
'drago',
'druido',
'dubbio',
'dubitare',
'ducale',
'duna',
'duomo',
'duplice',
'duraturo',
'ebano',
'eccesso',
'ecco',
'eclissi',
'economia',
'edera',
'edicola',
'edile',
'editoria',
'educare',
'egemonia',
'egli',
'egoismo',
'egregio',
'elaborato',
'elargire',
'elegante',
'elencato',
'eletto',
'elevare',
'elfico',
'elica',
'elmo',
'elsa',
'eluso',
'emanato',
'emblema',
'emesso',
'emiro',
'emotivo',
'emozione',
'empirico',
'emulo',
'endemico',
'enduro',
'energia',
'enfasi',
'enoteca',
'entrare',
'enzima',
'epatite',
'epilogo',
'episodio',
'epocale',
'eppure',
'equatore',
'erario',
'erba',
'erboso',
'erede',
'eremita',
'erigere',
'ermetico',
'eroe',
'erosivo',
'errante',
'esagono',
'esame',
'esanime',
'esaudire',
'esca',
'esempio',
'esercito',
'esibito',
'esigente',
'esistere',
'esito',
'esofago',
'esortato',
'esoso',
'espanso',
'espresso',
'essenza',
'esso',
'esteso',
'estimare',
'estonia',
'estroso',
'esultare',
'etilico',
'etnico',
'etrusco',
'etto',
'euclideo',
'europa',
'evaso',
'evidenza',
'evitato',
'evoluto',
'evviva',
'fabbrica',
'faccenda',
'fachiro',
'falco',
'famiglia',
'fanale',
'fanfara',
'fango',
'fantasma',
'fare',
'farfalla',
'farinoso',
'farmaco',
'fascia',
'fastoso',
'fasullo',
'faticare',
'fato',
'favoloso',
'febbre',
'fecola',
'fede',
'fegato',
'felpa',
'feltro',
'femmina',
'fendere',
'fenomeno',
'fermento',
'ferro',
'fertile',
'fessura',
'festivo',
'fetta',
'feudo',
'fiaba',
'fiducia',
'fifa',
'figurato',
'filo',
'finanza',
'finestra',
'finire',
'fiore',
'fiscale',
'fisico',
'fiume',
'flacone',
'flamenco',
'flebo',
'flemma',
'florido',
'fluente',
'fluoro',
'fobico',
'focaccia',
'focoso',
'foderato',
'foglio',
'folata',
'folclore',
'folgore',
'fondente',
'fonetico',
'fonia',
'fontana',
'forbito',
'forchetta',
'foresta',
'formica',
'fornaio',
'foro',
'fortezza',
'forzare',
'fosfato',
'fosso',
'fracasso',
'frana',
'frassino',
'fratello',
'freccetta',
'frenata',
'fresco',
'frigo',
'frollino',
'fronde',
'frugale',
'frutta',
'fucilata',
'fucsia',
'fuggente',
'fulmine',
'fulvo',
'fumante',
'fumetto',
'fumoso',
'fune',
'funzione',
'fuoco',
'furbo',
'furgone',
'furore',
'fuso',
'futile',
'gabbiano',
'gaffe',
'galateo',
'gallina',
'galoppo',
'gambero',
'gamma',
'garanzia',
'garbo',
'garofano',
'garzone',
'gasdotto',
'gasolio',
'gastrico',
'gatto',
'gaudio',
'gazebo',
'gazzella',
'geco',
'gelatina',
'gelso',
'gemello',
'gemmato',
'gene',
'genitore',
'gennaio',
'genotipo',
'gergo',
'ghepardo',
'ghiaccio',
'ghisa',
'giallo',
'gilda',
'ginepro',
'giocare',
'gioiello',
'giorno',
'giove',
'girato',
'girone',
'gittata',
'giudizio',
'giurato',
'giusto',
'globulo',
'glutine',
'gnomo',
'gobba',
'golf',
'gomito',
'gommone',
'gonfio',
'gonna',
'governo',
'gracile',
'grado',
'grafico',
'grammo',
'grande',
'grattare',
'gravoso',
'grazia',
'greca',
'gregge',
'grifone',
'grigio',
'grinza',
'grotta',
'gruppo',
'guadagno',
'guaio',
'guanto',
'guardare',
'gufo',
'guidare',
'ibernato',
'icona',
'identico',
'idillio',
'idolo',
'idra',
'idrico',
'idrogeno',
'igiene',
'ignaro',
'ignorato',
'ilare',
'illeso',
'illogico',
'illudere',
'imballo',
'imbevuto',
'imbocco',
'imbuto',
'immane',
'immerso',
'immolato',
'impacco',
'impeto',
'impiego',
'importo',
'impronta',
'inalare',
'inarcare',
'inattivo',
'incanto',
'incendio',
'inchino',
'incisivo',
'incluso',
'incontro',
'incrocio',
'incubo',
'indagine',
'india',
'indole',
'inedito',
'infatti',
'infilare',
'inflitto',
'ingaggio',
'ingegno',
'inglese',
'ingordo',
'ingrosso',
'innesco',
'inodore',
'inoltrare',
'inondato',
'insano',
'insetto',
'insieme',
'insonnia',
'insulina',
'intasato',
'intero',
'intonaco',
'intuito',
'inumidire',
'invalido',
'invece',
'invito',
'iperbole',
'ipnotico',
'ipotesi',
'ippica',
'iride',
'irlanda',
'ironico',
'irrigato',
'irrorare',
'isolato',
'isotopo',
'isterico',
'istituto',
'istrice',
'italia',
'iterare',
'labbro',
'labirinto',
'lacca',
'lacerato',
'lacrima',
'lacuna',
'laddove',
'lago',
'lampo',
'lancetta',
'lanterna',
'lardoso',
'larga',
'laringe',
'lastra',
'latenza',
'latino',
'lattuga',
'lavagna',
'lavoro',
'legale',
'leggero',
'lembo',
'lentezza',
'lenza',
'leone',
'lepre',
'lesivo',
'lessato',
'lesto',
'letterale',
'leva',
'levigato',
'libero',
'lido',
'lievito',
'lilla',
'limatura',
'limitare',
'limpido',
'lineare',
'lingua',
'liquido',
'lira',
'lirica',
'lisca',
'lite',
'litigio',
'livrea',
'locanda',
'lode',
'logica',
'lombare',
'londra',
'longevo',
'loquace',
'lorenzo',
'loto',
'lotteria',
'luce',
'lucidato',
'lumaca',
'luminoso',
'lungo',
'lupo',
'luppolo',
'lusinga',
'lusso',
'lutto',
'macabro',
'macchina',
'macero',
'macinato',
'madama',
'magico',
'maglia',
'magnete',
'magro',
'maiolica',
'malafede',
'malgrado',
'malinteso',
'malsano',
'malto',
'malumore',
'mana',
'mancia',
'mandorla',
'mangiare',
'manifesto',
'mannaro',
'manovra',
'mansarda',
'mantide',
'manubrio',
'mappa',
'maratona',
'marcire',
'maretta',
'marmo',
'marsupio',
'maschera',
'massaia',
'mastino',
'materasso',
'matricola',
'mattone',
'maturo',
'mazurca',
'meandro',
'meccanico',
'mecenate',
'medesimo',
'meditare',
'mega',
'melassa',
'melis',
'melodia',
'meninge',
'meno',
'mensola',
'mercurio',
'merenda',
'merlo',
'meschino',
'mese',
'messere',
'mestolo',
'metallo',
'metodo',
'mettere',
'miagolare',
'mica',
'micelio',
'michele',
'microbo',
'midollo',
'miele',
'migliore',
'milano',
'milite',
'mimosa',
'minerale',
'mini',
'minore',
'mirino',
'mirtillo',
'miscela',
'missiva',
'misto',
'misurare',
'mitezza',
'mitigare',
'mitra',
'mittente',
'mnemonico',
'modello',
'modifica',
'modulo',
'mogano',
'mogio',
'mole',
'molosso',
'monastero',
'monco',
'mondina',
'monetario',
'monile',
'monotono',
'monsone',
'montato',
'monviso',
'mora',
'mordere',
'morsicato',
'mostro',
'motivato',
'motosega',
'motto',
'movenza',
'movimento',
'mozzo',
'mucca',
'mucosa',
'muffa',
'mughetto',
'mugnaio',
'mulatto',
'mulinello',
'multiplo',
'mummia',
'munto',
'muovere',
'murale',
'musa',
'muscolo',
'musica',
'mutevole',
'muto',
'nababbo',
'nafta',
'nanometro',
'narciso',
'narice',
'narrato',
'nascere',
'nastrare',
'naturale',
'nautica',
'naviglio',
'nebulosa',
'necrosi',
'negativo',
'negozio',
'nemmeno',
'neofita',
'neretto',
'nervo',
'nessuno',
'nettuno',
'neutrale',
'neve',
'nevrotico',
'nicchia',
'ninfa',
'nitido',
'nobile',
'nocivo',
'nodo',
'nome',
'nomina',
'nordico',
'normale',
'norvegese',
'nostrano',
'notare',
'notizia',
'notturno',
'novella',
'nucleo',
'nulla',
'numero',
'nuovo',
'nutrire',
'nuvola',
'nuziale',
'oasi',
'obbedire',
'obbligo',
'obelisco',
'oblio',
'obolo',
'obsoleto',
'occasione',
'occhio',
'occidente',
'occorrere',
'occultare',
'ocra',
'oculato',
'odierno',
'odorare',
'offerta',
'offrire',
'offuscato',
'oggetto',
'oggi',
'ognuno',
'olandese',
'olfatto',
'oliato',
'oliva',
'ologramma',
'oltre',
'omaggio',
'ombelico',
'ombra',
'omega',
'omissione',
'ondoso',
'onere',
'onice',
'onnivoro',
'onorevole',
'onta',
'operato',
'opinione',
'opposto',
'oracolo',
'orafo',
'ordine',
'orecchino',
'orefice',
'orfano',
'organico',
'origine',
'orizzonte',
'orma',
'ormeggio',
'ornativo',
'orologio',
'orrendo',
'orribile',
'ortensia',
'ortica',
'orzata',
'orzo',
'osare',
'oscurare',
'osmosi',
'ospedale',
'ospite',
'ossa',
'ossidare',
'ostacolo',
'oste',
'otite',
'otre',
'ottagono',
'ottimo',
'ottobre',
'ovale',
'ovest',
'ovino',
'oviparo',
'ovocito',
'ovunque',
'ovviare',
'ozio',
'pacchetto',
'pace',
'pacifico',
'padella',
'padrone',
'paese',
'paga',
'pagina',
'palazzina',
'palesare',
'pallido',
'palo',
'palude',
'pandoro',
'pannello',
'paolo',
'paonazzo',
'paprica',
'parabola',
'parcella',
'parere',
'pargolo',
'pari',
'parlato',
'parola',
'partire',
'parvenza',
'parziale',
'passivo',
'pasticca',
'patacca',
'patologia',
'pattume',
'pavone',
'peccato',
'pedalare',
'pedonale',
'peggio',
'peloso',
'penare',
'pendice',
'penisola',
'pennuto',
'penombra',
'pensare',
'pentola',
'pepe',
'pepita',
'perbene',
'percorso',
'perdonato',
'perforare',
'pergamena',
'periodo',
'permesso',
'perno',
'perplesso',
'persuaso',
'pertugio',
'pervaso',
'pesatore',
'pesista',
'peso',
'pestifero',
'petalo',
'pettine',
'petulante',
'pezzo',
'piacere',
'pianta',
'piattino',
'piccino',
'picozza',
'piega',
'pietra',
'piffero',
'pigiama',
'pigolio',
'pigro',
'pila',
'pilifero',
'pillola',
'pilota',
'pimpante',
'pineta',
'pinna',
'pinolo',
'pioggia',
'piombo',
'piramide',
'piretico',
'pirite',
'pirolisi',
'pitone',
'pizzico',
'placebo',
'planare',
'plasma',
'platano',
'plenario',
'pochezza',
'poderoso',
'podismo',
'poesia',
'poggiare',
'polenta',
'poligono',
'pollice',
'polmonite',
'polpetta',
'polso',
'poltrona',
'polvere',
'pomice',
'pomodoro',
'ponte',
'popoloso',
'porfido',
'poroso',
'porpora',
'porre',
'portata',
'posa',
'positivo',
'possesso',
'postulato',
'potassio',
'potere',
'pranzo',
'prassi',
'pratica',
'precluso',
'predica',
'prefisso',
'pregiato',
'prelievo',
'premere',
'prenotare',
'preparato',
'presenza',
'pretesto',
'prevalso',
'prima',
'principe',
'privato',
'problema',
'procura',
'produrre',
'profumo',
'progetto',
'prolunga',
'promessa',
'pronome',
'proposta',
'proroga',
'proteso',
'prova',
'prudente',
'prugna',
'prurito',
'psiche',
'pubblico',
'pudica',
'pugilato',
'pugno',
'pulce',
'pulito',
'pulsante',
'puntare',
'pupazzo',
'pupilla',
'puro',
'quadro',
'qualcosa',
'quasi',
'querela',
'quota',
'raccolto',
'raddoppio',
'radicale',
'radunato',
'raffica',
'ragazzo',
'ragione',
'ragno',
'ramarro',
'ramingo',
'ramo',
'randagio',
'rantolare',
'rapato',
'rapina',
'rappreso',
'rasatura',
'raschiato',
'rasente',
'rassegna',
'rastrello',
'rata',
'ravveduto',
'reale',
'recepire',
'recinto',
'recluta',
'recondito',
'recupero',
'reddito',
'redimere',
'regalato',
'registro',
'regola',
'regresso',
'relazione',
'remare',
'remoto',
'renna',
'replica',
'reprimere',
'reputare',
'resa',
'residente',
'responso',
'restauro',
'rete',
'retina',
'retorica',
'rettifica',
'revocato',
'riassunto',
'ribadire',
'ribelle',
'ribrezzo',
'ricarica',
'ricco',
'ricevere',
'riciclato',
'ricordo',
'ricreduto',
'ridicolo',
'ridurre',
'rifasare',
'riflesso',
'riforma',
'rifugio',
'rigare',
'rigettato',
'righello',
'rilassato',
'rilevato',
'rimanere',
'rimbalzo',
'rimedio',
'rimorchio',
'rinascita',
'rincaro',
'rinforzo',
'rinnovo',
'rinomato',
'rinsavito',
'rintocco',
'rinuncia',
'rinvenire',
'riparato',
'ripetuto',
'ripieno',
'riportare',
'ripresa',
'ripulire',
'risata',
'rischio',
'riserva',
'risibile',
'riso',
'rispetto',
'ristoro',
'risultato',
'risvolto',
'ritardo',
'ritegno',
'ritmico',
'ritrovo',
'riunione',
'riva',
'riverso',
'rivincita',
'rivolto',
'rizoma',
'roba',
'robotico',
'robusto',
'roccia',
'roco',
'rodaggio',
'rodere',
'roditore',
'rogito',
'rollio',
'romantico',
'rompere',
'ronzio',
'rosolare',
'rospo',
'rotante',
'rotondo',
'rotula',
'rovescio',
'rubizzo',
'rubrica',
'ruga',
'rullino',
'rumine',
'rumoroso',
'ruolo',
'rupe',
'russare',
'rustico',
'sabato',
'sabbiare',
'sabotato',
'sagoma',
'salasso',
'saldatura',
'salgemma',
'salivare',
'salmone',
'salone',
'saltare',
'saluto',
'salvo',
'sapere',
'sapido',
'saporito',
'saraceno',
'sarcasmo',
'sarto',
'sassoso',
'satellite',
'satira',
'satollo',
'saturno',
'savana',
'savio',
'saziato',
'sbadiglio',
'sbalzo',
'sbancato',
'sbarra',
'sbattere',
'sbavare',
'sbendare',
'sbirciare',
'sbloccato',
'sbocciato',
'sbrinare',
'sbruffone',
'sbuffare',
'scabroso',
'scadenza',
'scala',
'scambiare',
'scandalo',
'scapola',
'scarso',
'scatenare',
'scavato',
'scelto',
'scenico',
'scettro',
'scheda',
'schiena',
'sciarpa',
'scienza',
'scindere',
'scippo',
'sciroppo',
'scivolo',
'sclerare',
'scodella',
'scolpito',
'scomparto',
'sconforto',
'scoprire',
'scorta',
'scossone',
'scozzese',
'scriba',
'scrollare',
'scrutinio',
'scuderia',
'scultore',
'scuola',
'scuro',
'scusare',
'sdebitare',
'sdoganare',
'seccatura',
'secondo',
'sedano',
'seggiola',
'segnalato',
'segregato',
'seguito',
'selciato',
'selettivo',
'sella',
'selvaggio',
'semaforo',
'sembrare',
'seme',
'seminato',
'sempre',
'senso',
'sentire',
'sepolto',
'sequenza',
'serata',
'serbato',
'sereno',
'serio',
'serpente',
'serraglio',
'servire',
'sestina',
'setola',
'settimana',
'sfacelo',
'sfaldare',
'sfamato',
'sfarzoso',
'sfaticato',
'sfera',
'sfida',
'sfilato',
'sfinge',
'sfocato',
'sfoderare',
'sfogo',
'sfoltire',
'sforzato',
'sfratto',
'sfruttato',
'sfuggito',
'sfumare',
'sfuso',
'sgabello',
'sgarbato',
'sgonfiare',
'sgorbio',
'sgrassato',
'sguardo',
'sibilo',
'siccome',
'sierra',
'sigla',
'signore',
'silenzio',
'sillaba',
'simbolo',
'simpatico',
'simulato',
'sinfonia',
'singolo',
'sinistro',
'sino',
'sintesi',
'sinusoide',
'sipario',
'sisma',
'sistole',
'situato',
'slitta',
'slogatura',
'sloveno',
'smarrito',
'smemorato',
'smentito',
'smeraldo',
'smilzo',
'smontare',
'smottato',
'smussato',
'snellire',
'snervato',
'snodo',
'sobbalzo',
'sobrio',
'soccorso',
'sociale',
'sodale',
'soffitto',
'sogno',
'soldato',
'solenne',
'solido',
'sollazzo',
'solo',
'solubile',
'solvente',
'somatico',
'somma',
'sonda',
'sonetto',
'sonnifero',
'sopire',
'soppeso',
'sopra',
'sorgere',
'sorpasso',
'sorriso',
'sorso',
'sorteggio',
'sorvolato',
'sospiro',
'sosta',
'sottile',
'spada',
'spalla',
'spargere',
'spatola',
'spavento',
'spazzola',
'specie',
'spedire',
'spegnere',
'spelatura',
'speranza',
'spessore',
'spettrale',
'spezzato',
'spia',
'spigoloso',
'spillato',
'spinoso',
'spirale',
'splendido',
'sportivo',
'sposo',
'spranga',
'sprecare',
'spronato',
'spruzzo',
'spuntino',
'squillo',
'sradicare',
'srotolato',
'stabile',
'stacco',
'staffa',
'stagnare',
'stampato',
'stantio',
'starnuto',
'stasera',
'statuto',
'stelo',
'steppa',
'sterzo',
'stiletto',
'stima',
'stirpe',
'stivale',
'stizzoso',
'stonato',
'storico',
'strappo',
'stregato',
'stridulo',
'strozzare',
'strutto',
'stuccare',
'stufo',
'stupendo',
'subentro',
'succoso',
'sudore',
'suggerito',
'sugo',
'sultano',
'suonare',
'superbo',
'supporto',
'surgelato',
'surrogato',
'sussurro',
'sutura',
'svagare',
'svedese',
'sveglio',
'svelare',
'svenuto',
'svezia',
'sviluppo',
'svista',
'svizzera',
'svolta',
'svuotare',
'tabacco',
'tabulato',
'tacciare',
'taciturno',
'tale',
'talismano',
'tampone',
'tannino',
'tara',
'tardivo',
'targato',
'tariffa',
'tarpare',
'tartaruga',
'tasto',
'tattico',
'taverna',
'tavolata',
'tazza',
'teca',
'tecnico',
'telefono',
'temerario',
'tempo',
'temuto',
'tendone',
'tenero',
'tensione',
'tentacolo',
'teorema',
'terme',
'terrazzo',
'terzetto',
'tesi',
'tesserato',
'testato',
'tetro',
'tettoia',
'tifare',
'tigella',
'timbro',
'tinto',
'tipico',
'tipografo',
'tiraggio',
'tiro',
'titanio',
'titolo',
'titubante',
'tizio',
'tizzone',
'toccare',
'tollerare',
'tolto',
'tombola',
'tomo',
'tonfo',
'tonsilla',
'topazio',
'topologia',
'toppa',
'torba',
'tornare',
'torrone',
'tortora',
'toscano',
'tossire',
'tostatura',
'totano',
'trabocco',
'trachea',
'trafila',
'tragedia',
'tralcio',
'tramonto',
'transito',
'trapano',
'trarre',
'trasloco',
'trattato',
'trave',
'treccia',
'tremolio',
'trespolo',
'tributo',
'tricheco',
'trifoglio',
'trillo',
'trincea',
'trio',
'tristezza',
'triturato',
'trivella',
'tromba',
'trono',
'troppo',
'trottola',
'trovare',
'truccato',
'tubatura',
'tuffato',
'tulipano',
'tumulto',
'tunisia',
'turbare',
'turchino',
'tuta',
'tutela',
'ubicato',
'uccello',
'uccisore',
'udire',
'uditivo',
'uffa',
'ufficio',
'uguale',
'ulisse',
'ultimato',
'umano',
'umile',
'umorismo',
'uncinetto',
'ungere',
'ungherese',
'unicorno',
'unificato',
'unisono',
'unitario',
'unte',
'uovo',
'upupa',
'uragano',
'urgenza',
'urlo',
'usanza',
'usato',
'uscito',
'usignolo',
'usuraio',
'utensile',
'utilizzo',
'utopia',
'vacante',
'vaccinato',
'vagabondo',
'vagliato',
'valanga',
'valgo',
'valico',
'valletta',
'valoroso',
'valutare',
'valvola',
'vampata',
'vangare',
'vanitoso',
'vano',
'vantaggio',
'vanvera',
'vapore',
'varano',
'varcato',
'variante',
'vasca',
'vedetta',
'vedova',
'veduto',
'vegetale',
'veicolo',
'velcro',
'velina',
'velluto',
'veloce',
'venato',
'vendemmia',
'vento',
'verace',
'verbale',
'vergogna',
'verifica',
'vero',
'verruca',
'verticale',
'vescica',
'vessillo',
'vestale',
'veterano',
'vetrina',
'vetusto',
'viandante',
'vibrante',
'vicenda',
'vichingo',
'vicinanza',
'vidimare',
'vigilia',
'vigneto',
'vigore',
'vile',
'villano',
'vimini',
'vincitore',
'viola',
'vipera',
'virgola',
'virologo',
'virulento',
'viscoso',
'visione',
'vispo',
'vissuto',
'visura',
'vita',
'vitello',
'vittima',
'vivanda',
'vivido',
'viziare',
'voce',
'voga',
'volatile',
'volere',
'volpe',
'voragine',
'vulcano',
'zampogna',
'zanna',
'zappato',
'zattera',
'zavorra',
'zefiro',
'zelante',
'zelo',
'zenzero',
'zerbino',
'zibetto',
'zinco',
'zircone',
'zitto',
'zolla',
'zotico',
'zucchero',
'zufolo',
'zulu',
'zuppa'
];
// SPDX-License-Identifier: MIT
const WORDLIST$k = [
'あいこくしん',
'あいさつ',
'あいだ',
'あおぞら',
'あかちゃん',
'あきる',
'あけがた',
'あける',
'あこがれる',
'あさい',
'あさひ',
'あしあと',
'あじわう',
'あずかる',
'あずき',
'あそぶ',
'あたえる',
'あたためる',
'あたりまえ',
'あたる',
'あつい',
'あつかう',
'あっしゅく',
'あつまり',
'あつめる',
'あてな',
'あてはまる',
'あひる',
'あぶら',
'あぶる',
'あふれる',
'あまい',
'あまど',
'あまやかす',
'あまり',
'あみもの',
'あめりか',
'あやまる',
'あゆむ',
'あらいぐま',
'あらし',
'あらすじ',
'あらためる',
'あらゆる',
'あらわす',
'ありがとう',
'あわせる',
'あわてる',
'あんい',
'あんがい',
'あんこ',
'あんぜん',
'あんてい',
'あんない',
'あんまり',
'いいだす',
'いおん',
'いがい',
'いがく',
'いきおい',
'いきなり',
'いきもの',
'いきる',
'いくじ',
'いくぶん',
'いけばな',
'いけん',
'いこう',
'いこく',
'いこつ',
'いさましい',
'いさん',
'いしき',
'いじゅう',
'いじょう',
'いじわる',
'いずみ',
'いずれ',
'いせい',
'いせえび',
'いせかい',
'いせき',
'いぜん',
'いそうろう',
'いそがしい',
'いだい',
'いだく',
'いたずら',
'いたみ',
'いたりあ',
'いちおう',
'いちじ',
'いちど',
'いちば',
'いちぶ',
'いちりゅう',
'いつか',
'いっしゅん',
'いっせい',
'いっそう',
'いったん',
'いっち',
'いってい',
'いっぽう',
'いてざ',
'いてん',
'いどう',
'いとこ',
'いない',
'いなか',
'いねむり',
'いのち',
'いのる',
'いはつ',
'いばる',
'いはん',
'いびき',
'いひん',
'いふく',
'いへん',
'いほう',
'いみん',
'いもうと',
'いもたれ',
'いもり',
'いやがる',
'いやす',
'いよかん',
'いよく',
'いらい',
'いらすと',
'いりぐち',
'いりょう',
'いれい',
'いれもの',
'いれる',
'いろえんぴつ',
'いわい',
'いわう',
'いわかん',
'いわば',
'いわゆる',
'いんげんまめ',
'いんさつ',
'いんしょう',
'いんよう',
'うえき',
'うえる',
'うおざ',
'うがい',
'うかぶ',
'うかべる',
'うきわ',
'うくらいな',
'うくれれ',
'うけたまわる',
'うけつけ',
'うけとる',
'うけもつ',
'うける',
'うごかす',
'うごく',
'うこん',
'うさぎ',
'うしなう',
'うしろがみ',
'うすい',
'うすぎ',
'うすぐらい',
'うすめる',
'うせつ',
'うちあわせ',
'うちがわ',
'うちき',
'うちゅう',
'うっかり',
'うつくしい',
'うったえる',
'うつる',
'うどん',
'うなぎ',
'うなじ',
'うなずく',
'うなる',
'うねる',
'うのう',
'うぶげ',
'うぶごえ',
'うまれる',
'うめる',
'うもう',
'うやまう',
'うよく',
'うらがえす',
'うらぐち',
'うらない',
'うりあげ',
'うりきれ',
'うるさい',
'うれしい',
'うれゆき',
'うれる',
'うろこ',
'うわき',
'うわさ',
'うんこう',
'うんちん',
'うんてん',
'うんどう',
'えいえん',
'えいが',
'えいきょう',
'えいご',
'えいせい',
'えいぶん',
'えいよう',
'えいわ',
'えおり',
'えがお',
'えがく',
'えきたい',
'えくせる',
'えしゃく',
'えすて',
'えつらん',
'えのぐ',
'えほうまき',
'えほん',
'えまき',
'えもじ',
'えもの',
'えらい',
'えらぶ',
'えりあ',
'えんえん',
'えんかい',
'えんぎ',
'えんげき',
'えんしゅう',
'えんぜつ',
'えんそく',
'えんちょう',
'えんとつ',
'おいかける',
'おいこす',
'おいしい',
'おいつく',
'おうえん',
'おうさま',
'おうじ',
'おうせつ',
'おうたい',
'おうふく',
'おうべい',
'おうよう',
'おえる',
'おおい',
'おおう',
'おおどおり',
'おおや',
'おおよそ',
'おかえり',
'おかず',
'おがむ',
'おかわり',
'おぎなう',
'おきる',
'おくさま',
'おくじょう',
'おくりがな',
'おくる',
'おくれる',
'おこす',
'おこなう',
'おこる',
'おさえる',
'おさない',
'おさめる',
'おしいれ',
'おしえる',
'おじぎ',
'おじさん',
'おしゃれ',
'おそらく',
'おそわる',
'おたがい',
'おたく',
'おだやか',
'おちつく',
'おっと',
'おつり',
'おでかけ',
'おとしもの',
'おとなしい',
'おどり',
'おどろかす',
'おばさん',
'おまいり',
'おめでとう',
'おもいで',
'おもう',
'おもたい',
'おもちゃ',
'おやつ',
'おやゆび',
'およぼす',
'おらんだ',
'おろす',
'おんがく',
'おんけい',
'おんしゃ',
'おんせん',
'おんだん',
'おんちゅう',
'おんどけい',
'かあつ',
'かいが',
'がいき',
'がいけん',
'がいこう',
'かいさつ',
'かいしゃ',
'かいすいよく',
'かいぜん',
'かいぞうど',
'かいつう',
'かいてん',
'かいとう',
'かいふく',
'がいへき',
'かいほう',
'かいよう',
'がいらい',
'かいわ',
'かえる',
'かおり',
'かかえる',
'かがく',
'かがし',
'かがみ',
'かくご',
'かくとく',
'かざる',
'がぞう',
'かたい',
'かたち',
'がちょう',
'がっきゅう',
'がっこう',
'がっさん',
'がっしょう',
'かなざわし',
'かのう',
'がはく',
'かぶか',
'かほう',
'かほご',
'かまう',
'かまぼこ',
'かめれおん',
'かゆい',
'かようび',
'からい',
'かるい',
'かろう',
'かわく',
'かわら',
'がんか',
'かんけい',
'かんこう',
'かんしゃ',
'かんそう',
'かんたん',
'かんち',
'がんばる',
'きあい',
'きあつ',
'きいろ',
'ぎいん',
'きうい',
'きうん',
'きえる',
'きおう',
'きおく',
'きおち',
'きおん',
'きかい',
'きかく',
'きかんしゃ',
'ききて',
'きくばり',
'きくらげ',
'きけんせい',
'きこう',
'きこえる',
'きこく',
'きさい',
'きさく',
'きさま',
'きさらぎ',
'ぎじかがく',
'ぎしき',
'ぎじたいけん',
'ぎじにってい',
'ぎじゅつしゃ',
'きすう',
'きせい',
'きせき',
'きせつ',
'きそう',
'きぞく',
'きぞん',
'きたえる',
'きちょう',
'きつえん',
'ぎっちり',
'きつつき',
'きつね',
'きてい',
'きどう',
'きどく',
'きない',
'きなが',
'きなこ',
'きぬごし',
'きねん',
'きのう',
'きのした',
'きはく',
'きびしい',
'きひん',
'きふく',
'きぶん',
'きぼう',
'きほん',
'きまる',
'きみつ',
'きむずかしい',
'きめる',
'きもだめし',
'きもち',
'きもの',
'きゃく',
'きやく',
'ぎゅうにく',
'きよう',
'きょうりゅう',
'きらい',
'きらく',
'きりん',
'きれい',
'きれつ',
'きろく',
'ぎろん',
'きわめる',
'ぎんいろ',
'きんかくじ',
'きんじょ',
'きんようび',
'ぐあい',
'くいず',
'くうかん',
'くうき',
'くうぐん',
'くうこう',
'ぐうせい',
'くうそう',
'ぐうたら',
'くうふく',
'くうぼ',
'くかん',
'くきょう',
'くげん',
'ぐこう',
'くさい',
'くさき',
'くさばな',
'くさる',
'くしゃみ',
'くしょう',
'くすのき',
'くすりゆび',
'くせげ',
'くせん',
'ぐたいてき',
'くださる',
'くたびれる',
'くちこみ',
'くちさき',
'くつした',
'ぐっすり',
'くつろぐ',
'くとうてん',
'くどく',
'くなん',
'くねくね',
'くのう',
'くふう',
'くみあわせ',
'くみたてる',
'くめる',
'くやくしょ',
'くらす',
'くらべる',
'くるま',
'くれる',
'くろう',
'くわしい',
'ぐんかん',
'ぐんしょく',
'ぐんたい',
'ぐんて',
'けあな',
'けいかく',
'けいけん',
'けいこ',
'けいさつ',
'げいじゅつ',
'けいたい',
'げいのうじん',
'けいれき',
'けいろ',
'けおとす',
'けおりもの',
'げきか',
'げきげん',
'げきだん',
'げきちん',
'げきとつ',
'げきは',
'げきやく',
'げこう',
'げこくじょう',
'げざい',
'けさき',
'げざん',
'けしき',
'けしごむ',
'けしょう',
'げすと',
'けたば',
'けちゃっぷ',
'けちらす',
'けつあつ',
'けつい',
'けつえき',
'けっこん',
'けつじょ',
'けっせき',
'けってい',
'けつまつ',
'げつようび',
'げつれい',
'けつろん',
'げどく',
'けとばす',
'けとる',
'けなげ',
'けなす',
'けなみ',
'けぬき',
'げねつ',
'けねん',
'けはい',
'げひん',
'けぶかい',
'げぼく',
'けまり',
'けみかる',
'けむし',
'けむり',
'けもの',
'けらい',
'けろけろ',
'けわしい',
'けんい',
'けんえつ',
'けんお',
'けんか',
'げんき',
'けんげん',
'けんこう',
'けんさく',
'けんしゅう',
'けんすう',
'げんそう',
'けんちく',
'けんてい',
'けんとう',
'けんない',
'けんにん',
'げんぶつ',
'けんま',
'けんみん',
'けんめい',
'けんらん',
'けんり',
'こあくま',
'こいぬ',
'こいびと',
'ごうい',
'こうえん',
'こうおん',
'こうかん',
'ごうきゅう',
'ごうけい',
'こうこう',
'こうさい',
'こうじ',
'こうすい',
'ごうせい',
'こうそく',
'こうたい',
'こうちゃ',
'こうつう',
'こうてい',
'こうどう',
'こうない',
'こうはい',
'ごうほう',
'ごうまん',
'こうもく',
'こうりつ',
'こえる',
'こおり',
'ごかい',
'ごがつ',
'ごかん',
'こくご',
'こくさい',
'こくとう',
'こくない',
'こくはく',
'こぐま',
'こけい',
'こける',
'ここのか',
'こころ',
'こさめ',
'こしつ',
'こすう',
'こせい',
'こせき',
'こぜん',
'こそだて',
'こたい',
'こたえる',
'こたつ',
'こちょう',
'こっか',
'こつこつ',
'こつばん',
'こつぶ',
'こてい',
'こてん',
'ことがら',
'ことし',
'ことば',
'ことり',
'こなごな',
'こねこね',
'このまま',
'このみ',
'このよ',
'ごはん',
'こひつじ',
'こふう',
'こふん',
'こぼれる',
'ごまあぶら',
'こまかい',
'ごますり',
'こまつな',
'こまる',
'こむぎこ',
'こもじ',
'こもち',
'こもの',
'こもん',
'こやく',
'こやま',
'こゆう',
'こゆび',
'こよい',
'こよう',
'こりる',
'これくしょん',
'ころっけ',
'こわもて',
'こわれる',
'こんいん',
'こんかい',
'こんき',
'こんしゅう',
'こんすい',
'こんだて',
'こんとん',
'こんなん',
'こんびに',
'こんぽん',
'こんまけ',
'こんや',
'こんれい',
'こんわく',
'ざいえき',
'さいかい',
'さいきん',
'ざいげん',
'ざいこ',
'さいしょ',
'さいせい',
'ざいたく',
'ざいちゅう',
'さいてき',
'ざいりょう',
'さうな',
'さかいし',
'さがす',
'さかな',
'さかみち',
'さがる',
'さぎょう',
'さくし',
'さくひん',
'さくら',
'さこく',
'さこつ',
'さずかる',
'ざせき',
'さたん',
'さつえい',
'ざつおん',
'ざっか',
'ざつがく',
'さっきょく',
'ざっし',
'さつじん',
'ざっそう',
'さつたば',
'さつまいも',
'さてい',
'さといも',
'さとう',
'さとおや',
'さとし',
'さとる',
'さのう',
'さばく',
'さびしい',
'さべつ',
'さほう',
'さほど',
'さます',
'さみしい',
'さみだれ',
'さむけ',
'さめる',
'さやえんどう',
'さゆう',
'さよう',
'さよく',
'さらだ',
'ざるそば',
'さわやか',
'さわる',
'さんいん',
'さんか',
'さんきゃく',
'さんこう',
'さんさい',
'ざんしょ',
'さんすう',
'さんせい',
'さんそ',
'さんち',
'さんま',
'さんみ',
'さんらん',
'しあい',
'しあげ',
'しあさって',
'しあわせ',
'しいく',
'しいん',
'しうち',
'しえい',
'しおけ',
'しかい',
'しかく',
'じかん',
'しごと',
'しすう',
'じだい',
'したうけ',
'したぎ',
'したて',
'したみ',
'しちょう',
'しちりん',
'しっかり',
'しつじ',
'しつもん',
'してい',
'してき',
'してつ',
'じてん',
'じどう',
'しなぎれ',
'しなもの',
'しなん',
'しねま',
'しねん',
'しのぐ',
'しのぶ',
'しはい',
'しばかり',
'しはつ',
'しはらい',
'しはん',
'しひょう',
'しふく',
'じぶん',
'しへい',
'しほう',
'しほん',
'しまう',
'しまる',
'しみん',
'しむける',
'じむしょ',
'しめい',
'しめる',
'しもん',
'しゃいん',
'しゃうん',
'しゃおん',
'じゃがいも',
'しやくしょ',
'しゃくほう',
'しゃけん',
'しゃこ',
'しゃざい',
'しゃしん',
'しゃせん',
'しゃそう',
'しゃたい',
'しゃちょう',
'しゃっきん',
'じゃま',
'しゃりん',
'しゃれい',
'じゆう',
'じゅうしょ',
'しゅくはく',
'じゅしん',
'しゅっせき',
'しゅみ',
'しゅらば',
'じゅんばん',
'しょうかい',
'しょくたく',
'しょっけん',
'しょどう',
'しょもつ',
'しらせる',
'しらべる',
'しんか',
'しんこう',
'じんじゃ',
'しんせいじ',
'しんちく',
'しんりん',
'すあげ',
'すあし',
'すあな',
'ずあん',
'すいえい',
'すいか',
'すいとう',
'ずいぶん',
'すいようび',
'すうがく',
'すうじつ',
'すうせん',
'すおどり',
'すきま',
'すくう',
'すくない',
'すける',
'すごい',
'すこし',
'ずさん',
'すずしい',
'すすむ',
'すすめる',
'すっかり',
'ずっしり',
'ずっと',
'すてき',
'すてる',
'すねる',
'すのこ',
'すはだ',
'すばらしい',
'ずひょう',
'ずぶぬれ',
'すぶり',
'すふれ',
'すべて',
'すべる',
'ずほう',
'すぼん',
'すまい',
'すめし',
'すもう',
'すやき',
'すらすら',
'するめ',
'すれちがう',
'すろっと',
'すわる',
'すんぜん',
'すんぽう',
'せあぶら',
'せいかつ',
'せいげん',
'せいじ',
'せいよう',
'せおう',
'せかいかん',
'せきにん',
'せきむ',
'せきゆ',
'せきらんうん',
'せけん',
'せこう',
'せすじ',
'せたい',
'せたけ',
'せっかく',
'せっきゃく',
'ぜっく',
'せっけん',
'せっこつ',
'せっさたくま',
'せつぞく',
'せつだん',
'せつでん',
'せっぱん',
'せつび',
'せつぶん',
'せつめい',
'せつりつ',
'せなか',
'せのび',
'せはば',
'せびろ',
'せぼね',
'せまい',
'せまる',
'せめる',
'せもたれ',
'せりふ',
'ぜんあく',
'せんい',
'せんえい',
'せんか',
'せんきょ',
'せんく',
'せんげん',
'ぜんご',
'せんさい',
'せんしゅ',
'せんすい',
'せんせい',
'せんぞ',
'せんたく',
'せんちょう',
'せんてい',
'せんとう',
'せんぬき',
'せんねん',
'せんぱい',
'ぜんぶ',
'ぜんぽう',
'せんむ',
'せんめんじょ',
'せんもん',
'せんやく',
'せんゆう',
'せんよう',
'ぜんら',
'ぜんりゃく',
'せんれい',
'せんろ',
'そあく',
'そいとげる',
'そいね',
'そうがんきょう',
'そうき',
'そうご',
'そうしん',
'そうだん',
'そうなん',
'そうび',
'そうめん',
'そうり',
'そえもの',
'そえん',
'そがい',
'そげき',
'そこう',
'そこそこ',
'そざい',
'そしな',
'そせい',
'そせん',
'そそぐ',
'そだてる',
'そつう',
'そつえん',
'そっかん',
'そつぎょう',
'そっけつ',
'そっこう',
'そっせん',
'そっと',
'そとがわ',
'そとづら',
'そなえる',
'そなた',
'そふぼ',
'そぼく',
'そぼろ',
'そまつ',
'そまる',
'そむく',
'そむりえ',
'そめる',
'そもそも',
'そよかぜ',
'そらまめ',
'そろう',
'そんかい',
'そんけい',
'そんざい',
'そんしつ',
'そんぞく',
'そんちょう',
'ぞんび',
'ぞんぶん',
'そんみん',
'たあい',
'たいいん',
'たいうん',
'たいえき',
'たいおう',
'だいがく',
'たいき',
'たいぐう',
'たいけん',
'たいこ',
'たいざい',
'だいじょうぶ',
'だいすき',
'たいせつ',
'たいそう',
'だいたい',
'たいちょう',
'たいてい',
'だいどころ',
'たいない',
'たいねつ',
'たいのう',
'たいはん',
'だいひょう',
'たいふう',
'たいへん',
'たいほ',
'たいまつばな',
'たいみんぐ',
'たいむ',
'たいめん',
'たいやき',
'たいよう',
'たいら',
'たいりょく',
'たいる',
'たいわん',
'たうえ',
'たえる',
'たおす',
'たおる',
'たおれる',
'たかい',
'たかね',
'たきび',
'たくさん',
'たこく',
'たこやき',
'たさい',
'たしざん',
'だじゃれ',
'たすける',
'たずさわる',
'たそがれ',
'たたかう',
'たたく',
'ただしい',
'たたみ',
'たちばな',
'だっかい',
'だっきゃく',
'だっこ',
'だっしゅつ',
'だったい',
'たてる',
'たとえる',
'たなばた',
'たにん',
'たぬき',
'たのしみ',
'たはつ',
'たぶん',
'たべる',
'たぼう',
'たまご',
'たまる',
'だむる',
'ためいき',
'ためす',
'ためる',
'たもつ',
'たやすい',
'たよる',
'たらす',
'たりきほんがん',
'たりょう',
'たりる',
'たると',
'たれる',
'たれんと',
'たろっと',
'たわむれる',
'だんあつ',
'たんい',
'たんおん',
'たんか',
'たんき',
'たんけん',
'たんご',
'たんさん',
'たんじょうび',
'だんせい',
'たんそく',
'たんたい',
'だんち',
'たんてい',
'たんとう',
'だんな',
'たんにん',
'だんねつ',
'たんのう',
'たんぴん',
'だんぼう',
'たんまつ',
'たんめい',
'だんれつ',
'だんろ',
'だんわ',
'ちあい',
'ちあん',
'ちいき',
'ちいさい',
'ちえん',
'ちかい',
'ちから',
'ちきゅう',
'ちきん',
'ちけいず',
'ちけん',
'ちこく',
'ちさい',
'ちしき',
'ちしりょう',
'ちせい',
'ちそう',
'ちたい',
'ちたん',
'ちちおや',
'ちつじょ',
'ちてき',
'ちてん',
'ちぬき',
'ちぬり',
'ちのう',
'ちひょう',
'ちへいせん',
'ちほう',
'ちまた',
'ちみつ',
'ちみどろ',
'ちめいど',
'ちゃんこなべ',
'ちゅうい',
'ちゆりょく',
'ちょうし',
'ちょさくけん',
'ちらし',
'ちらみ',
'ちりがみ',
'ちりょう',
'ちるど',
'ちわわ',
'ちんたい',
'ちんもく',
'ついか',
'ついたち',
'つうか',
'つうじょう',
'つうはん',
'つうわ',
'つかう',
'つかれる',
'つくね',
'つくる',
'つけね',
'つける',
'つごう',
'つたえる',
'つづく',
'つつじ',
'つつむ',
'つとめる',
'つながる',
'つなみ',
'つねづね',
'つのる',
'つぶす',
'つまらない',
'つまる',
'つみき',
'つめたい',
'つもり',
'つもる',
'つよい',
'つるぼ',
'つるみく',
'つわもの',
'つわり',
'てあし',
'てあて',
'てあみ',
'ていおん',
'ていか',
'ていき',
'ていけい',
'ていこく',
'ていさつ',
'ていし',
'ていせい',
'ていたい',
'ていど',
'ていねい',
'ていひょう',
'ていへん',
'ていぼう',
'てうち',
'ておくれ',
'てきとう',
'てくび',
'でこぼこ',
'てさぎょう',
'てさげ',
'てすり',
'てそう',
'てちがい',
'てちょう',
'てつがく',
'てつづき',
'でっぱ',
'てつぼう',
'てつや',
'でぬかえ',
'てぬき',
'てぬぐい',
'てのひら',
'てはい',
'てぶくろ',
'てふだ',
'てほどき',
'てほん',
'てまえ',
'てまきずし',
'てみじか',
'てみやげ',
'てらす',
'てれび',
'てわけ',
'てわたし',
'でんあつ',
'てんいん',
'てんかい',
'てんき',
'てんぐ',
'てんけん',
'てんごく',
'てんさい',
'てんし',
'てんすう',
'でんち',
'てんてき',
'てんとう',
'てんない',
'てんぷら',
'てんぼうだい',
'てんめつ',
'てんらんかい',
'でんりょく',
'でんわ',
'どあい',
'といれ',
'どうかん',
'とうきゅう',
'どうぐ',
'とうし',
'とうむぎ',
'とおい',
'とおか',
'とおく',
'とおす',
'とおる',
'とかい',
'とかす',
'ときおり',
'ときどき',
'とくい',
'とくしゅう',
'とくてん',
'とくに',
'とくべつ',
'とけい',
'とける',
'とこや',
'とさか',
'としょかん',
'とそう',
'とたん',
'とちゅう',
'とっきゅう',
'とっくん',
'とつぜん',
'とつにゅう',
'とどける',
'ととのえる',
'とない',
'となえる',
'となり',
'とのさま',
'とばす',
'どぶがわ',
'とほう',
'とまる',
'とめる',
'ともだち',
'ともる',
'どようび',
'とらえる',
'とんかつ',
'どんぶり',
'ないかく',
'ないこう',
'ないしょ',
'ないす',
'ないせん',
'ないそう',
'なおす',
'ながい',
'なくす',
'なげる',
'なこうど',
'なさけ',
'なたでここ',
'なっとう',
'なつやすみ',
'ななおし',
'なにごと',
'なにもの',
'なにわ',
'なのか',
'なふだ',
'なまいき',
'なまえ',
'なまみ',
'なみだ',
'なめらか',
'なめる',
'なやむ',
'ならう',
'ならび',
'ならぶ',
'なれる',
'なわとび',
'なわばり',
'にあう',
'にいがた',
'にうけ',
'におい',
'にかい',
'にがて',
'にきび',
'にくしみ',
'にくまん',
'にげる',
'にさんかたんそ',
'にしき',
'にせもの',
'にちじょう',
'にちようび',
'にっか',
'にっき',
'にっけい',
'にっこう',
'にっさん',
'にっしょく',
'にっすう',
'にっせき',
'にってい',
'になう',
'にほん',
'にまめ',
'にもつ',
'にやり',
'にゅういん',
'にりんしゃ',
'にわとり',
'にんい',
'にんか',
'にんき',
'にんげん',
'にんしき',
'にんずう',
'にんそう',
'にんたい',
'にんち',
'にんてい',
'にんにく',
'にんぷ',
'にんまり',
'にんむ',
'にんめい',
'にんよう',
'ぬいくぎ',
'ぬかす',
'ぬぐいとる',
'ぬぐう',
'ぬくもり',
'ぬすむ',
'ぬまえび',
'ぬめり',
'ぬらす',
'ぬんちゃく',
'ねあげ',
'ねいき',
'ねいる',
'ねいろ',
'ねぐせ',
'ねくたい',
'ねくら',
'ねこぜ',
'ねこむ',
'ねさげ',
'ねすごす',
'ねそべる',
'ねだん',
'ねつい',
'ねっしん',
'ねつぞう',
'ねったいぎょ',
'ねぶそく',
'ねふだ',
'ねぼう',
'ねほりはほり',
'ねまき',
'ねまわし',
'ねみみ',
'ねむい',
'ねむたい',
'ねもと',
'ねらう',
'ねわざ',
'ねんいり',
'ねんおし',
'ねんかん',
'ねんきん',
'ねんぐ',
'ねんざ',
'ねんし',
'ねんちゃく',
'ねんど',
'ねんぴ',
'ねんぶつ',
'ねんまつ',
'ねんりょう',
'ねんれい',
'のいず',
'のおづま',
'のがす',
'のきなみ',
'のこぎり',
'のこす',
'のこる',
'のせる',
'のぞく',
'のぞむ',
'のたまう',
'のちほど',
'のっく',
'のばす',
'のはら',
'のべる',
'のぼる',
'のみもの',
'のやま',
'のらいぬ',
'のらねこ',
'のりもの',
'のりゆき',
'のれん',
'のんき',
'ばあい',
'はあく',
'ばあさん',
'ばいか',
'ばいく',
'はいけん',
'はいご',
'はいしん',
'はいすい',
'はいせん',
'はいそう',
'はいち',
'ばいばい',
'はいれつ',
'はえる',
'はおる',
'はかい',
'ばかり',
'はかる',
'はくしゅ',
'はけん',
'はこぶ',
'はさみ',
'はさん',
'はしご',
'ばしょ',
'はしる',
'はせる',
'ぱそこん',
'はそん',
'はたん',
'はちみつ',
'はつおん',
'はっかく',
'はづき',
'はっきり',
'はっくつ',
'はっけん',
'はっこう',
'はっさん',
'はっしん',
'はったつ',
'はっちゅう',
'はってん',
'はっぴょう',
'はっぽう',
'はなす',
'はなび',
'はにかむ',
'はぶらし',
'はみがき',
'はむかう',
'はめつ',
'はやい',
'はやし',
'はらう',
'はろうぃん',
'はわい',
'はんい',
'はんえい',
'はんおん',
'はんかく',
'はんきょう',
'ばんぐみ',
'はんこ',
'はんしゃ',
'はんすう',
'はんだん',
'ぱんち',
'ぱんつ',
'はんてい',
'はんとし',
'はんのう',
'はんぱ',
'はんぶん',
'はんぺん',
'はんぼうき',
'はんめい',
'はんらん',
'はんろん',
'ひいき',
'ひうん',
'ひえる',
'ひかく',
'ひかり',
'ひかる',
'ひかん',
'ひくい',
'ひけつ',
'ひこうき',
'ひこく',
'ひさい',
'ひさしぶり',
'ひさん',
'びじゅつかん',
'ひしょ',
'ひそか',
'ひそむ',
'ひたむき',
'ひだり',
'ひたる',
'ひつぎ',
'ひっこし',
'ひっし',
'ひつじゅひん',
'ひっす',
'ひつぜん',
'ぴったり',
'ぴっちり',
'ひつよう',
'ひてい',
'ひとごみ',
'ひなまつり',
'ひなん',
'ひねる',
'ひはん',
'ひびく',
'ひひょう',
'ひほう',
'ひまわり',
'ひまん',
'ひみつ',
'ひめい',
'ひめじし',
'ひやけ',
'ひやす',
'ひよう',
'びょうき',
'ひらがな',
'ひらく',
'ひりつ',
'ひりょう',
'ひるま',
'ひるやすみ',
'ひれい',
'ひろい',
'ひろう',
'ひろき',
'ひろゆき',
'ひんかく',
'ひんけつ',
'ひんこん',
'ひんしゅ',
'ひんそう',
'ぴんち',
'ひんぱん',
'びんぼう',
'ふあん',
'ふいうち',
'ふうけい',
'ふうせん',
'ぷうたろう',
'ふうとう',
'ふうふ',
'ふえる',
'ふおん',
'ふかい',
'ふきん',
'ふくざつ',
'ふくぶくろ',
'ふこう',
'ふさい',
'ふしぎ',
'ふじみ',
'ふすま',
'ふせい',
'ふせぐ',
'ふそく',
'ぶたにく',
'ふたん',
'ふちょう',
'ふつう',
'ふつか',
'ふっかつ',
'ふっき',
'ふっこく',
'ぶどう',
'ふとる',
'ふとん',
'ふのう',
'ふはい',
'ふひょう',
'ふへん',
'ふまん',
'ふみん',
'ふめつ',
'ふめん',
'ふよう',
'ふりこ',
'ふりる',
'ふるい',
'ふんいき',
'ぶんがく',
'ぶんぐ',
'ふんしつ',
'ぶんせき',
'ふんそう',
'ぶんぽう',
'へいあん',
'へいおん',
'へいがい',
'へいき',
'へいげん',
'へいこう',
'へいさ',
'へいしゃ',
'へいせつ',
'へいそ',
'へいたく',
'へいてん',
'へいねつ',
'へいわ',
'へきが',
'へこむ',
'べにいろ',
'べにしょうが',
'へらす',
'へんかん',
'べんきょう',
'べんごし',
'へんさい',
'へんたい',
'べんり',
'ほあん',
'ほいく',
'ぼうぎょ',
'ほうこく',
'ほうそう',
'ほうほう',
'ほうもん',
'ほうりつ',
'ほえる',
'ほおん',
'ほかん',
'ほきょう',
'ぼきん',
'ほくろ',
'ほけつ',
'ほけん',
'ほこう',
'ほこる',
'ほしい',
'ほしつ',
'ほしゅ',
'ほしょう',
'ほせい',
'ほそい',
'ほそく',
'ほたて',
'ほたる',
'ぽちぶくろ',
'ほっきょく',
'ほっさ',
'ほったん',
'ほとんど',
'ほめる',
'ほんい',
'ほんき',
'ほんけ',
'ほんしつ',
'ほんやく',
'まいにち',
'まかい',
'まかせる',
'まがる',
'まける',
'まこと',
'まさつ',
'まじめ',
'ますく',
'まぜる',
'まつり',
'まとめ',
'まなぶ',
'まぬけ',
'まねく',
'まほう',
'まもる',
'まゆげ',
'まよう',
'まろやか',
'まわす',
'まわり',
'まわる',
'まんが',
'まんきつ',
'まんぞく',
'まんなか',
'みいら',
'みうち',
'みえる',
'みがく',
'みかた',
'みかん',
'みけん',
'みこん',
'みじかい',
'みすい',
'みすえる',
'みせる',
'みっか',
'みつかる',
'みつける',
'みてい',
'みとめる',
'みなと',
'みなみかさい',
'みねらる',
'みのう',
'みのがす',
'みほん',
'みもと',
'みやげ',
'みらい',
'みりょく',
'みわく',
'みんか',
'みんぞく',
'むいか',
'むえき',
'むえん',
'むかい',
'むかう',
'むかえ',
'むかし',
'むぎちゃ',
'むける',
'むげん',
'むさぼる',
'むしあつい',
'むしば',
'むじゅん',
'むしろ',
'むすう',
'むすこ',
'むすぶ',
'むすめ',
'むせる',
'むせん',
'むちゅう',
'むなしい',
'むのう',
'むやみ',
'むよう',
'むらさき',
'むりょう',
'むろん',
'めいあん',
'めいうん',
'めいえん',
'めいかく',
'めいきょく',
'めいさい',
'めいし',
'めいそう',
'めいぶつ',
'めいれい',
'めいわく',
'めぐまれる',
'めざす',
'めした',
'めずらしい',
'めだつ',
'めまい',
'めやす',
'めんきょ',
'めんせき',
'めんどう',
'もうしあげる',
'もうどうけん',
'もえる',
'もくし',
'もくてき',
'もくようび',
'もちろん',
'もどる',
'もらう',
'もんく',
'もんだい',
'やおや',
'やける',
'やさい',
'やさしい',
'やすい',
'やすたろう',
'やすみ',
'やせる',
'やそう',
'やたい',
'やちん',
'やっと',
'やっぱり',
'やぶる',
'やめる',
'ややこしい',
'やよい',
'やわらかい',
'ゆうき',
'ゆうびんきょく',
'ゆうべ',
'ゆうめい',
'ゆけつ',
'ゆしゅつ',
'ゆせん',
'ゆそう',
'ゆたか',
'ゆちゃく',
'ゆでる',
'ゆにゅう',
'ゆびわ',
'ゆらい',
'ゆれる',
'ようい',
'ようか',
'ようきゅう',
'ようじ',
'ようす',
'ようちえん',
'よかぜ',
'よかん',
'よきん',
'よくせい',
'よくぼう',
'よけい',
'よごれる',
'よさん',
'よしゅう',
'よそう',
'よそく',
'よっか',
'よてい',
'よどがわく',
'よねつ',
'よやく',
'よゆう',
'よろこぶ',
'よろしい',
'らいう',
'らくがき',
'らくご',
'らくさつ',
'らくだ',
'らしんばん',
'らせん',
'らぞく',
'らたい',
'らっか',
'られつ',
'りえき',
'りかい',
'りきさく',
'りきせつ',
'りくぐん',
'りくつ',
'りけん',
'りこう',
'りせい',
'りそう',
'りそく',
'りてん',
'りねん',
'りゆう',
'りゅうがく',
'りよう',
'りょうり',
'りょかん',
'りょくちゃ',
'りょこう',
'りりく',
'りれき',
'りろん',
'りんご',
'るいけい',
'るいさい',
'るいじ',
'るいせき',
'るすばん',
'るりがわら',
'れいかん',
'れいぎ',
'れいせい',
'れいぞうこ',
'れいとう',
'れいぼう',
'れきし',
'れきだい',
'れんあい',
'れんけい',
'れんこん',
'れんさい',
'れんしゅう',
'れんぞく',
'れんらく',
'ろうか',
'ろうご',
'ろうじん',
'ろうそく',
'ろくが',
'ろこつ',
'ろじうら',
'ろしゅつ',
'ろせん',
'ろてん',
'ろめん',
'ろれつ',
'ろんぎ',
'ろんぱ',
'ろんぶん',
'ろんり',
'わかす',
'わかめ',
'わかやま',
'わかれる',
'わしつ',
'わじまし',
'わすれもの',
'わらう',
'われる'
];
// SPDX-License-Identifier: MIT
const WORDLIST$j = [
'가격',
'가끔',
'가난',
'가능',
'가득',
'가르침',
'가뭄',
'가방',
'가상',
'가슴',
'가운데',
'가을',
'가이드',
'가입',
'가장',
'가정',
'가족',
'가죽',
'각오',
'각자',
'간격',
'간부',
'간섭',
'간장',
'간접',
'간판',
'갈등',
'갈비',
'갈색',
'갈증',
'감각',
'감기',
'감소',
'감수성',
'감자',
'감정',
'갑자기',
'강남',
'강당',
'강도',
'강력히',
'강변',
'강북',
'강사',
'강수량',
'강아지',
'강원도',
'강의',
'강제',
'강조',
'같이',
'개구리',
'개나리',
'개방',
'개별',
'개선',
'개성',
'개인',
'객관적',
'거실',
'거액',
'거울',
'거짓',
'거품',
'걱정',
'건강',
'건물',
'건설',
'건조',
'건축',
'걸음',
'검사',
'검토',
'게시판',
'게임',
'겨울',
'견해',
'결과',
'결국',
'결론',
'결석',
'결승',
'결심',
'결정',
'결혼',
'경계',
'경고',
'경기',
'경력',
'경복궁',
'경비',
'경상도',
'경영',
'경우',
'경쟁',
'경제',
'경주',
'경찰',
'경치',
'경향',
'경험',
'계곡',
'계단',
'계란',
'계산',
'계속',
'계약',
'계절',
'계층',
'계획',
'고객',
'고구려',
'고궁',
'고급',
'고등학생',
'고무신',
'고민',
'고양이',
'고장',
'고전',
'고집',
'고춧가루',
'고통',
'고향',
'곡식',
'골목',
'골짜기',
'골프',
'공간',
'공개',
'공격',
'공군',
'공급',
'공기',
'공동',
'공무원',
'공부',
'공사',
'공식',
'공업',
'공연',
'공원',
'공장',
'공짜',
'공책',
'공통',
'공포',
'공항',
'공휴일',
'과목',
'과일',
'과장',
'과정',
'과학',
'관객',
'관계',
'관광',
'관념',
'관람',
'관련',
'관리',
'관습',
'관심',
'관점',
'관찰',
'광경',
'광고',
'광장',
'광주',
'괴로움',
'굉장히',
'교과서',
'교문',
'교복',
'교실',
'교양',
'교육',
'교장',
'교직',
'교통',
'교환',
'교훈',
'구경',
'구름',
'구멍',
'구별',
'구분',
'구석',
'구성',
'구속',
'구역',
'구입',
'구청',
'구체적',
'국가',
'국기',
'국내',
'국립',
'국물',
'국민',
'국수',
'국어',
'국왕',
'국적',
'국제',
'국회',
'군대',
'군사',
'군인',
'궁극적',
'권리',
'권위',
'권투',
'귀국',
'귀신',
'규정',
'규칙',
'균형',
'그날',
'그냥',
'그늘',
'그러나',
'그룹',
'그릇',
'그림',
'그제서야',
'그토록',
'극복',
'극히',
'근거',
'근교',
'근래',
'근로',
'근무',
'근본',
'근원',
'근육',
'근처',
'글씨',
'글자',
'금강산',
'금고',
'금년',
'금메달',
'금액',
'금연',
'금요일',
'금지',
'긍정적',
'기간',
'기관',
'기념',
'기능',
'기독교',
'기둥',
'기록',
'기름',
'기법',
'기본',
'기분',
'기쁨',
'기숙사',
'기술',
'기억',
'기업',
'기온',
'기운',
'기원',
'기적',
'기준',
'기침',
'기혼',
'기획',
'긴급',
'긴장',
'길이',
'김밥',
'김치',
'김포공항',
'깍두기',
'깜빡',
'깨달음',
'깨소금',
'껍질',
'꼭대기',
'꽃잎',
'나들이',
'나란히',
'나머지',
'나물',
'나침반',
'나흘',
'낙엽',
'난방',
'날개',
'날씨',
'날짜',
'남녀',
'남대문',
'남매',
'남산',
'남자',
'남편',
'남학생',
'낭비',
'낱말',
'내년',
'내용',
'내일',
'냄비',
'냄새',
'냇물',
'냉동',
'냉면',
'냉방',
'냉장고',
'넥타이',
'넷째',
'노동',
'노란색',
'노력',
'노인',
'녹음',
'녹차',
'녹화',
'논리',
'논문',
'논쟁',
'놀이',
'농구',
'농담',
'농민',
'농부',
'농업',
'농장',
'농촌',
'높이',
'눈동자',
'눈물',
'눈썹',
'뉴욕',
'느낌',
'늑대',
'능동적',
'능력',
'다방',
'다양성',
'다음',
'다이어트',
'다행',
'단계',
'단골',
'단독',
'단맛',
'단순',
'단어',
'단위',
'단점',
'단체',
'단추',
'단편',
'단풍',
'달걀',
'달러',
'달력',
'달리',
'닭고기',
'담당',
'담배',
'담요',
'담임',
'답변',
'답장',
'당근',
'당분간',
'당연히',
'당장',
'대규모',
'대낮',
'대단히',
'대답',
'대도시',
'대략',
'대량',
'대륙',
'대문',
'대부분',
'대신',
'대응',
'대장',
'대전',
'대접',
'대중',
'대책',
'대출',
'대충',
'대통령',
'대학',
'대한민국',
'대합실',
'대형',
'덩어리',
'데이트',
'도대체',
'도덕',
'도둑',
'도망',
'도서관',
'도심',
'도움',
'도입',
'도자기',
'도저히',
'도전',
'도중',
'도착',
'독감',
'독립',
'독서',
'독일',
'독창적',
'동화책',
'뒷모습',
'뒷산',
'딸아이',
'마누라',
'마늘',
'마당',
'마라톤',
'마련',
'마무리',
'마사지',
'마약',
'마요네즈',
'마을',
'마음',
'마이크',
'마중',
'마지막',
'마찬가지',
'마찰',
'마흔',
'막걸리',
'막내',
'막상',
'만남',
'만두',
'만세',
'만약',
'만일',
'만점',
'만족',
'만화',
'많이',
'말기',
'말씀',
'말투',
'맘대로',
'망원경',
'매년',
'매달',
'매력',
'매번',
'매스컴',
'매일',
'매장',
'맥주',
'먹이',
'먼저',
'먼지',
'멀리',
'메일',
'며느리',
'며칠',
'면담',
'멸치',
'명단',
'명령',
'명예',
'명의',
'명절',
'명칭',
'명함',
'모금',
'모니터',
'모델',
'모든',
'모범',
'모습',
'모양',
'모임',
'모조리',
'모집',
'모퉁이',
'목걸이',
'목록',
'목사',
'목소리',
'목숨',
'목적',
'목표',
'몰래',
'몸매',
'몸무게',
'몸살',
'몸속',
'몸짓',
'몸통',
'몹시',
'무관심',
'무궁화',
'무더위',
'무덤',
'무릎',
'무슨',
'무엇',
'무역',
'무용',
'무조건',
'무지개',
'무척',
'문구',
'문득',
'문법',
'문서',
'문제',
'문학',
'문화',
'물가',
'물건',
'물결',
'물고기',
'물론',
'물리학',
'물음',
'물질',
'물체',
'미국',
'미디어',
'미사일',
'미술',
'미역',
'미용실',
'미움',
'미인',
'미팅',
'미혼',
'민간',
'민족',
'민주',
'믿음',
'밀가루',
'밀리미터',
'밑바닥',
'바가지',
'바구니',
'바나나',
'바늘',
'바닥',
'바닷가',
'바람',
'바이러스',
'바탕',
'박물관',
'박사',
'박수',
'반대',
'반드시',
'반말',
'반발',
'반성',
'반응',
'반장',
'반죽',
'반지',
'반찬',
'받침',
'발가락',
'발걸음',
'발견',
'발달',
'발레',
'발목',
'발바닥',
'발생',
'발음',
'발자국',
'발전',
'발톱',
'발표',
'밤하늘',
'밥그릇',
'밥맛',
'밥상',
'밥솥',
'방금',
'방면',
'방문',
'방바닥',
'방법',
'방송',
'방식',
'방안',
'방울',
'방지',
'방학',
'방해',
'방향',
'배경',
'배꼽',
'배달',
'배드민턴',
'백두산',
'백색',
'백성',
'백인',
'백제',
'백화점',
'버릇',
'버섯',
'버튼',
'번개',
'번역',
'번지',
'번호',
'벌금',
'벌레',
'벌써',
'범위',
'범인',
'범죄',
'법률',
'법원',
'법적',
'법칙',
'베이징',
'벨트',
'변경',
'변동',
'변명',
'변신',
'변호사',
'변화',
'별도',
'별명',
'별일',
'병실',
'병아리',
'병원',
'보관',
'보너스',
'보라색',
'보람',
'보름',
'보상',
'보안',
'보자기',
'보장',
'보전',
'보존',
'보통',
'보편적',
'보험',
'복도',
'복사',
'복숭아',
'복습',
'볶음',
'본격적',
'본래',
'본부',
'본사',
'본성',
'본인',
'본질',
'볼펜',
'봉사',
'봉지',
'봉투',
'부근',
'부끄러움',
'부담',
'부동산',
'부문',
'부분',
'부산',
'부상',
'부엌',
'부인',
'부작용',
'부장',
'부정',
'부족',
'부지런히',
'부친',
'부탁',
'부품',
'부회장',
'북부',
'북한',
'분노',
'분량',
'분리',
'분명',
'분석',
'분야',
'분위기',
'분필',
'분홍색',
'불고기',
'불과',
'불교',
'불꽃',
'불만',
'불법',
'불빛',
'불안',
'불이익',
'불행',
'브랜드',
'비극',
'비난',
'비닐',
'비둘기',
'비디오',
'비로소',
'비만',
'비명',
'비밀',
'비바람',
'비빔밥',
'비상',
'비용',
'비율',
'비중',
'비타민',
'비판',
'빌딩',
'빗물',
'빗방울',
'빗줄기',
'빛깔',
'빨간색',
'빨래',
'빨리',
'사건',
'사계절',
'사나이',
'사냥',
'사람',
'사랑',
'사립',
'사모님',
'사물',
'사방',
'사상',
'사생활',
'사설',
'사슴',
'사실',
'사업',
'사용',
'사월',
'사장',
'사전',
'사진',
'사촌',
'사춘기',
'사탕',
'사투리',
'사흘',
'산길',
'산부인과',
'산업',
'산책',
'살림',
'살인',
'살짝',
'삼계탕',
'삼국',
'삼십',
'삼월',
'삼촌',
'상관',
'상금',
'상대',
'상류',
'상반기',
'상상',
'상식',
'상업',
'상인',
'상자',
'상점',
'상처',
'상추',
'상태',
'상표',
'상품',
'상황',
'새벽',
'색깔',
'색연필',
'생각',
'생명',
'생물',
'생방송',
'생산',
'생선',
'생신',
'생일',
'생활',
'서랍',
'서른',
'서명',
'서민',
'서비스',
'서양',
'서울',
'서적',
'서점',
'서쪽',
'서클',
'석사',
'석유',
'선거',
'선물',
'선배',
'선생',
'선수',
'선원',
'선장',
'선전',
'선택',
'선풍기',
'설거지',
'설날',
'설렁탕',
'설명',
'설문',
'설사',
'설악산',
'설치',
'설탕',
'섭씨',
'성공',
'성당',
'성명',
'성별',
'성인',
'성장',
'성적',
'성질',
'성함',
'세금',
'세미나',
'세상',
'세월',
'세종대왕',
'세탁',
'센터',
'센티미터',
'셋째',
'소규모',
'소극적',
'소금',
'소나기',
'소년',
'소득',
'소망',
'소문',
'소설',
'소속',
'소아과',
'소용',
'소원',
'소음',
'소중히',
'소지품',
'소질',
'소풍',
'소형',
'속담',
'속도',
'속옷',
'손가락',
'손길',
'손녀',
'손님',
'손등',
'손목',
'손뼉',
'손실',
'손질',
'손톱',
'손해',
'솔직히',
'솜씨',
'송아지',
'송이',
'송편',
'쇠고기',
'쇼핑',
'수건',
'수년',
'수단',
'수돗물',
'수동적',
'수면',
'수명',
'수박',
'수상',
'수석',
'수술',
'수시로',
'수업',
'수염',
'수영',
'수입',
'수준',
'수집',
'수출',
'수컷',
'수필',
'수학',
'수험생',
'수화기',
'숙녀',
'숙소',
'숙제',
'순간',
'순서',
'순수',
'순식간',
'순위',
'숟가락',
'술병',
'술집',
'숫자',
'스님',
'스물',
'스스로',
'스승',
'스웨터',
'스위치',
'스케이트',
'스튜디오',
'스트레스',
'스포츠',
'슬쩍',
'슬픔',
'습관',
'습기',
'승객',
'승리',
'승부',
'승용차',
'승진',
'시각',
'시간',
'시골',
'시금치',
'시나리오',
'시댁',
'시리즈',
'시멘트',
'시민',
'시부모',
'시선',
'시설',
'시스템',
'시아버지',
'시어머니',
'시월',
'시인',
'시일',
'시작',
'시장',
'시절',
'시점',
'시중',
'시즌',
'시집',
'시청',
'시합',
'시험',
'식구',
'식기',
'식당',
'식량',
'식료품',
'식물',
'식빵',
'식사',
'식생활',
'식초',
'식탁',
'식품',
'신고',
'신규',
'신념',
'신문',
'신발',
'신비',
'신사',
'신세',
'신용',
'신제품',
'신청',
'신체',
'신화',
'실감',
'실내',
'실력',
'실례',
'실망',
'실수',
'실습',
'실시',
'실장',
'실정',
'실질적',
'실천',
'실체',
'실컷',
'실태',
'실패',
'실험',
'실현',
'심리',
'심부름',
'심사',
'심장',
'심정',
'심판',
'쌍둥이',
'씨름',
'씨앗',
'아가씨',
'아나운서',
'아드님',
'아들',
'아쉬움',
'아스팔트',
'아시아',
'아울러',
'아저씨',
'아줌마',
'아직',
'아침',
'아파트',
'아프리카',
'아픔',
'아홉',
'아흔',
'악기',
'악몽',
'악수',
'안개',
'안경',
'안과',
'안내',
'안녕',
'안동',
'안방',
'안부',
'안주',
'알루미늄',
'알코올',
'암시',
'암컷',
'압력',
'앞날',
'앞문',
'애인',
'애정',
'액수',
'앨범',
'야간',
'야단',
'야옹',
'약간',
'약국',
'약속',
'약수',
'약점',
'약품',
'약혼녀',
'양념',
'양력',
'양말',
'양배추',
'양주',
'양파',
'어둠',
'어려움',
'어른',
'어젯밤',
'어쨌든',
'어쩌다가',
'어쩐지',
'언니',
'언덕',
'언론',
'언어',
'얼굴',
'얼른',
'얼음',
'얼핏',
'엄마',
'업무',
'업종',
'업체',
'엉덩이',
'엉망',
'엉터리',
'엊그제',
'에너지',
'에어컨',
'엔진',
'여건',
'여고생',
'여관',
'여군',
'여권',
'여대생',
'여덟',
'여동생',
'여든',
'여론',
'여름',
'여섯',
'여성',
'여왕',
'여인',
'여전히',
'여직원',
'여학생',
'여행',
'역사',
'역시',
'역할',
'연결',
'연구',
'연극',
'연기',
'연락',
'연설',
'연세',
'연속',
'연습',
'연애',
'연예인',
'연인',
'연장',
'연주',
'연출',
'연필',
'연합',
'연휴',
'열기',
'열매',
'열쇠',
'열심히',
'열정',
'열차',
'열흘',
'염려',
'엽서',
'영국',
'영남',
'영상',
'영양',
'영역',
'영웅',
'영원히',
'영하',
'영향',
'영혼',
'영화',
'옆구리',
'옆방',
'옆집',
'예감',
'예금',
'예방',
'예산',
'예상',
'예선',
'예술',
'예습',
'예식장',
'예약',
'예전',
'예절',
'예정',
'예컨대',
'옛날',
'오늘',
'오락',
'오랫동안',
'오렌지',
'오로지',
'오른발',
'오븐',
'오십',
'오염',
'오월',
'오전',
'오직',
'오징어',
'오페라',
'오피스텔',
'오히려',
'옥상',
'옥수수',
'온갖',
'온라인',
'온몸',
'온종일',
'온통',
'올가을',
'올림픽',
'올해',
'옷차림',
'와이셔츠',
'와인',
'완성',
'완전',
'왕비',
'왕자',
'왜냐하면',
'왠지',
'외갓집',
'외국',
'외로움',
'외삼촌',
'외출',
'외침',
'외할머니',
'왼발',
'왼손',
'왼쪽',
'요금',
'요일',
'요즘',
'요청',
'용기',
'용서',
'용어',
'우산',
'우선',
'우승',
'우연히',
'우정',
'우체국',
'우편',
'운동',
'운명',
'운반',
'운전',
'운행',
'울산',
'울음',
'움직임',
'웃어른',
'웃음',
'워낙',
'원고',
'원래',
'원서',
'원숭이',
'원인',
'원장',
'원피스',
'월급',
'월드컵',
'월세',
'월요일',
'웨이터',
'위반',
'위법',
'위성',
'위원',
'위험',
'위협',
'윗사람',
'유난히',
'유럽',
'유명',
'유물',
'유산',
'유적',
'유치원',
'유학',
'유행',
'유형',
'육군',
'육상',
'육십',
'육체',
'은행',
'음력',
'음료',
'음반',
'음성',
'음식',
'음악',
'음주',
'의견',
'의논',
'의문',
'의복',
'의식',
'의심',
'의외로',
'의욕',
'의원',
'의학',
'이것',
'이곳',
'이념',
'이놈',
'이달',
'이대로',
'이동',
'이렇게',
'이력서',
'이론적',
'이름',
'이민',
'이발소',
'이별',
'이불',
'이빨',
'이상',
'이성',
'이슬',
'이야기',
'이용',
'이웃',
'이월',
'이윽고',
'이익',
'이전',
'이중',
'이튿날',
'이틀',
'이혼',
'인간',
'인격',
'인공',
'인구',
'인근',
'인기',
'인도',
'인류',
'인물',
'인생',
'인쇄',
'인연',
'인원',
'인재',
'인종',
'인천',
'인체',
'인터넷',
'인하',
'인형',
'일곱',
'일기',
'일단',
'일대',
'일등',
'일반',
'일본',
'일부',
'일상',
'일생',
'일손',
'일요일',
'일월',
'일정',
'일종',
'일주일',
'일찍',
'일체',
'일치',
'일행',
'일회용',
'임금',
'임무',
'입대',
'입력',
'입맛',
'입사',
'입술',
'입시',
'입원',
'입장',
'입학',
'자가용',
'자격',
'자극',
'자동',
'자랑',
'자부심',
'자식',
'자신',
'자연',
'자원',
'자율',
'자전거',
'자정',
'자존심',
'자판',
'작가',
'작년',
'작성',
'작업',
'작용',
'작은딸',
'작품',
'잔디',
'잔뜩',
'잔치',
'잘못',
'잠깐',
'잠수함',
'잠시',
'잠옷',
'잠자리',
'잡지',
'장관',
'장군',
'장기간',
'장래',
'장례',
'장르',
'장마',
'장면',
'장모',
'장미',
'장비',
'장사',
'장소',
'장식',
'장애인',
'장인',
'장점',
'장차',
'장학금',
'재능',
'재빨리',
'재산',
'재생',
'재작년',
'재정',
'재채기',
'재판',
'재학',
'재활용',
'저것',
'저고리',
'저곳',
'저녁',
'저런',
'저렇게',
'저번',
'저울',
'저절로',
'저축',
'적극',
'적당히',
'적성',
'적용',
'적응',
'전개',
'전공',
'전기',
'전달',
'전라도',
'전망',
'전문',
'전반',
'전부',
'전세',
'전시',
'전용',
'전자',
'전쟁',
'전주',
'전철',
'전체',
'전통',
'전혀',
'전후',
'절대',
'절망',
'절반',
'절약',
'절차',
'점검',
'점수',
'점심',
'점원',
'점점',
'점차',
'접근',
'접시',
'접촉',
'젓가락',
'정거장',
'정도',
'정류장',
'정리',
'정말',
'정면',
'정문',
'정반대',
'정보',
'정부',
'정비',
'정상',
'정성',
'정오',
'정원',
'정장',
'정지',
'정치',
'정확히',
'제공',
'제과점',
'제대로',
'제목',
'제발',
'제법',
'제삿날',
'제안',
'제일',
'제작',
'제주도',
'제출',
'제품',
'제한',
'조각',
'조건',
'조금',
'조깅',
'조명',
'조미료',
'조상',
'조선',
'조용히',
'조절',
'조정',
'조직',
'존댓말',
'존재',
'졸업',
'졸음',
'종교',
'종로',
'종류',
'종소리',
'종업원',
'종종',
'종합',
'좌석',
'죄인',
'주관적',
'주름',
'주말',
'주머니',
'주먹',
'주문',
'주민',
'주방',
'주변',
'주식',
'주인',
'주일',
'주장',
'주전자',
'주택',
'준비',
'줄거리',
'줄기',
'줄무늬',
'중간',
'중계방송',
'중국',
'중년',
'중단',
'중독',
'중반',
'중부',
'중세',
'중소기업',
'중순',
'중앙',
'중요',
'중학교',
'즉석',
'즉시',
'즐거움',
'증가',
'증거',
'증권',
'증상',
'증세',
'지각',
'지갑',
'지경',
'지극히',
'지금',
'지급',
'지능',
'지름길',
'지리산',
'지방',
'지붕',
'지식',
'지역',
'지우개',
'지원',
'지적',
'지점',
'지진',
'지출',
'직선',
'직업',
'직원',
'직장',
'진급',
'진동',
'진로',
'진료',
'진리',
'진짜',
'진찰',
'진출',
'진통',
'진행',
'질문',
'질병',
'질서',
'짐작',
'집단',
'집안',
'집중',
'짜증',
'찌꺼기',
'차남',
'차라리',
'차량',
'차림',
'차별',
'차선',
'차츰',
'착각',
'찬물',
'찬성',
'참가',
'참기름',
'참새',
'참석',
'참여',
'참외',
'참조',
'찻잔',
'창가',
'창고',
'창구',
'창문',
'창밖',
'창작',
'창조',
'채널',
'채점',
'책가방',
'책방',
'책상',
'책임',
'챔피언',
'처벌',
'처음',
'천국',
'천둥',
'천장',
'천재',
'천천히',
'철도',
'철저히',
'철학',
'첫날',
'첫째',
'청년',
'청바지',
'청소',
'청춘',
'체계',
'체력',
'체온',
'체육',
'체중',
'체험',
'초등학생',
'초반',
'초밥',
'초상화',
'초순',
'초여름',
'초원',
'초저녁',
'초점',
'초청',
'초콜릿',
'촛불',
'총각',
'총리',
'총장',
'촬영',
'최근',
'최상',
'최선',
'최신',
'최악',
'최종',
'추석',
'추억',
'추진',
'추천',
'추측',
'축구',
'축소',
'축제',
'축하',
'출근',
'출발',
'출산',
'출신',
'출연',
'출입',
'출장',
'출판',
'충격',
'충고',
'충돌',
'충분히',
'충청도',
'취업',
'취직',
'취향',
'치약',
'친구',
'친척',
'칠십',
'칠월',
'칠판',
'침대',
'침묵',
'침실',
'칫솔',
'칭찬',
'카메라',
'카운터',
'칼국수',
'캐릭터',
'캠퍼스',
'캠페인',
'커튼',
'컨디션',
'컬러',
'컴퓨터',
'코끼리',
'코미디',
'콘서트',
'콜라',
'콤플렉스',
'콩나물',
'쾌감',
'쿠데타',
'크림',
'큰길',
'큰딸',
'큰소리',
'큰아들',
'큰어머니',
'큰일',
'큰절',
'클래식',
'클럽',
'킬로',
'타입',
'타자기',
'탁구',
'탁자',
'탄생',
'태권도',
'태양',
'태풍',
'택시',
'탤런트',
'터널',
'터미널',
'테니스',
'테스트',
'테이블',
'텔레비전',
'토론',
'토마토',
'토요일',
'통계',
'통과',
'통로',
'통신',
'통역',
'통일',
'통장',
'통제',
'통증',
'통합',
'통화',
'퇴근',
'퇴원',
'퇴직금',
'튀김',
'트럭',
'특급',
'특별',
'특성',
'특수',
'특징',
'특히',
'튼튼히',
'티셔츠',
'파란색',
'파일',
'파출소',
'판결',
'판단',
'판매',
'판사',
'팔십',
'팔월',
'팝송',
'패션',
'팩스',
'팩시밀리',
'팬티',
'퍼센트',
'페인트',
'편견',
'편의',
'편지',
'편히',
'평가',
'평균',
'평생',
'평소',
'평양',
'평일',
'평화',
'포스터',
'포인트',
'포장',
'포함',
'표면',
'표정',
'표준',
'표현',
'품목',
'품질',
'풍경',
'풍속',
'풍습',
'프랑스',
'프린터',
'플라스틱',
'피곤',
'피망',
'피아노',
'필름',
'필수',
'필요',
'필자',
'필통',
'핑계',
'하느님',
'하늘',
'하드웨어',
'하룻밤',
'하반기',
'하숙집',
'하순',
'하여튼',
'하지만',
'하천',
'하품',
'하필',
'학과',
'학교',
'학급',
'학기',
'학년',
'학력',
'학번',
'학부모',
'학비',
'학생',
'학술',
'학습',
'학용품',
'학원',
'학위',
'학자',
'학점',
'한계',
'한글',
'한꺼번에',
'한낮',
'한눈',
'한동안',
'한때',
'한라산',
'한마디',
'한문',
'한번',
'한복',
'한식',
'한여름',
'한쪽',
'할머니',
'할아버지',
'할인',
'함께',
'함부로',
'합격',
'합리적',
'항공',
'항구',
'항상',
'항의',
'해결',
'해군',
'해답',
'해당',
'해물',
'해석',
'해설',
'해수욕장',
'해안',
'핵심',
'핸드백',
'햄버거',
'햇볕',
'햇살',
'행동',
'행복',
'행사',
'행운',
'행위',
'향기',
'향상',
'향수',
'허락',
'허용',
'헬기',
'현관',
'현금',
'현대',
'현상',
'현실',
'현장',
'현재',
'현지',
'혈액',
'협력',
'형부',
'형사',
'형수',
'형식',
'형제',
'형태',
'형편',
'혜택',
'호기심',
'호남',
'호랑이',
'호박',
'호텔',
'호흡',
'혹시',
'홀로',
'홈페이지',
'홍보',
'홍수',
'홍차',
'화면',
'화분',
'화살',
'화요일',
'화장',
'화학',
'확보',
'확인',
'확장',
'확정',
'환갑',
'환경',
'환영',
'환율',
'환자',
'활기',
'활동',
'활발히',
'활용',
'활짝',
'회견',
'회관',
'회복',
'회색',
'회원',
'회장',
'회전',
'횟수',
'횡단보도',
'효율적',
'후반',
'후춧가루',
'훈련',
'훨씬',
'휴식',
'휴일',
'흉내',
'흐름',
'흑백',
'흑인',
'흔적',
'흔히',
'흥미',
'흥분',
'희곡',
'희망',
'희생',
'흰색',
'힘껏'
];
// SPDX-License-Identifier: MIT
const WORDLIST$i = [
'abacate',
'abaixo',
'abalar',
'abater',
'abduzir',
'abelha',
'aberto',
'abismo',
'abotoar',
'abranger',
'abreviar',
'abrigar',
'abrupto',
'absinto',
'absoluto',
'absurdo',
'abutre',
'acabado',
'acalmar',
'acampar',
'acanhar',
'acaso',
'aceitar',
'acelerar',
'acenar',
'acervo',
'acessar',
'acetona',
'achatar',
'acidez',
'acima',
'acionado',
'acirrar',
'aclamar',
'aclive',
'acolhida',
'acomodar',
'acoplar',
'acordar',
'acumular',
'acusador',
'adaptar',
'adega',
'adentro',
'adepto',
'adequar',
'aderente',
'adesivo',
'adeus',
'adiante',
'aditivo',
'adjetivo',
'adjunto',
'admirar',
'adorar',
'adquirir',
'adubo',
'adverso',
'advogado',
'aeronave',
'afastar',
'aferir',
'afetivo',
'afinador',
'afivelar',
'aflito',
'afluente',
'afrontar',
'agachar',
'agarrar',
'agasalho',
'agenciar',
'agilizar',
'agiota',
'agitado',
'agora',
'agradar',
'agreste',
'agrupar',
'aguardar',
'agulha',
'ajoelhar',
'ajudar',
'ajustar',
'alameda',
'alarme',
'alastrar',
'alavanca',
'albergue',
'albino',
'alcatra',
'aldeia',
'alecrim',
'alegria',
'alertar',
'alface',
'alfinete',
'algum',
'alheio',
'aliar',
'alicate',
'alienar',
'alinhar',
'aliviar',
'almofada',
'alocar',
'alpiste',
'alterar',
'altitude',
'alucinar',
'alugar',
'aluno',
'alusivo',
'alvo',
'amaciar',
'amador',
'amarelo',
'amassar',
'ambas',
'ambiente',
'ameixa',
'amenizar',
'amido',
'amistoso',
'amizade',
'amolador',
'amontoar',
'amoroso',
'amostra',
'amparar',
'ampliar',
'ampola',
'anagrama',
'analisar',
'anarquia',
'anatomia',
'andaime',
'anel',
'anexo',
'angular',
'animar',
'anjo',
'anomalia',
'anotado',
'ansioso',
'anterior',
'anuidade',
'anunciar',
'anzol',
'apagador',
'apalpar',
'apanhado',
'apego',
'apelido',
'apertada',
'apesar',
'apetite',
'apito',
'aplauso',
'aplicada',
'apoio',
'apontar',
'aposta',
'aprendiz',
'aprovar',
'aquecer',
'arame',
'aranha',
'arara',
'arcada',
'ardente',
'areia',
'arejar',
'arenito',
'aresta',
'argiloso',
'argola',
'arma',
'arquivo',
'arraial',
'arrebate',
'arriscar',
'arroba',
'arrumar',
'arsenal',
'arterial',
'artigo',
'arvoredo',
'asfaltar',
'asilado',
'aspirar',
'assador',
'assinar',
'assoalho',
'assunto',
'astral',
'atacado',
'atadura',
'atalho',
'atarefar',
'atear',
'atender',
'aterro',
'ateu',
'atingir',
'atirador',
'ativo',
'atoleiro',
'atracar',
'atrevido',
'atriz',
'atual',
'atum',
'auditor',
'aumentar',
'aura',
'aurora',
'autismo',
'autoria',
'autuar',
'avaliar',
'avante',
'avaria',
'avental',
'avesso',
'aviador',
'avisar',
'avulso',
'axila',
'azarar',
'azedo',
'azeite',
'azulejo',
'babar',
'babosa',
'bacalhau',
'bacharel',
'bacia',
'bagagem',
'baiano',
'bailar',
'baioneta',
'bairro',
'baixista',
'bajular',
'baleia',
'baliza',
'balsa',
'banal',
'bandeira',
'banho',
'banir',
'banquete',
'barato',
'barbado',
'baronesa',
'barraca',
'barulho',
'baseado',
'bastante',
'batata',
'batedor',
'batida',
'batom',
'batucar',
'baunilha',
'beber',
'beijo',
'beirada',
'beisebol',
'beldade',
'beleza',
'belga',
'beliscar',
'bendito',
'bengala',
'benzer',
'berimbau',
'berlinda',
'berro',
'besouro',
'bexiga',
'bezerro',
'bico',
'bicudo',
'bienal',
'bifocal',
'bifurcar',
'bigorna',
'bilhete',
'bimestre',
'bimotor',
'biologia',
'biombo',
'biosfera',
'bipolar',
'birrento',
'biscoito',
'bisneto',
'bispo',
'bissexto',
'bitola',
'bizarro',
'blindado',
'bloco',
'bloquear',
'boato',
'bobagem',
'bocado',
'bocejo',
'bochecha',
'boicotar',
'bolada',
'boletim',
'bolha',
'bolo',
'bombeiro',
'bonde',
'boneco',
'bonita',
'borbulha',
'borda',
'boreal',
'borracha',
'bovino',
'boxeador',
'branco',
'brasa',
'braveza',
'breu',
'briga',
'brilho',
'brincar',
'broa',
'brochura',
'bronzear',
'broto',
'bruxo',
'bucha',
'budismo',
'bufar',
'bule',
'buraco',
'busca',
'busto',
'buzina',
'cabana',
'cabelo',
'cabide',
'cabo',
'cabrito',
'cacau',
'cacetada',
'cachorro',
'cacique',
'cadastro',
'cadeado',
'cafezal',
'caiaque',
'caipira',
'caixote',
'cajado',
'caju',
'calafrio',
'calcular',
'caldeira',
'calibrar',
'calmante',
'calota',
'camada',
'cambista',
'camisa',
'camomila',
'campanha',
'camuflar',
'canavial',
'cancelar',
'caneta',
'canguru',
'canhoto',
'canivete',
'canoa',
'cansado',
'cantar',
'canudo',
'capacho',
'capela',
'capinar',
'capotar',
'capricho',
'captador',
'capuz',
'caracol',
'carbono',
'cardeal',
'careca',
'carimbar',
'carneiro',
'carpete',
'carreira',
'cartaz',
'carvalho',
'casaco',
'casca',
'casebre',
'castelo',
'casulo',
'catarata',
'cativar',
'caule',
'causador',
'cautelar',
'cavalo',
'caverna',
'cebola',
'cedilha',
'cegonha',
'celebrar',
'celular',
'cenoura',
'censo',
'centeio',
'cercar',
'cerrado',
'certeiro',
'cerveja',
'cetim',
'cevada',
'chacota',
'chaleira',
'chamado',
'chapada',
'charme',
'chatice',
'chave',
'chefe',
'chegada',
'cheiro',
'cheque',
'chicote',
'chifre',
'chinelo',
'chocalho',
'chover',
'chumbo',
'chutar',
'chuva',
'cicatriz',
'ciclone',
'cidade',
'cidreira',
'ciente',
'cigana',
'cimento',
'cinto',
'cinza',
'ciranda',
'circuito',
'cirurgia',
'citar',
'clareza',
'clero',
'clicar',
'clone',
'clube',
'coado',
'coagir',
'cobaia',
'cobertor',
'cobrar',
'cocada',
'coelho',
'coentro',
'coeso',
'cogumelo',
'coibir',
'coifa',
'coiote',
'colar',
'coleira',
'colher',
'colidir',
'colmeia',
'colono',
'coluna',
'comando',
'combinar',
'comentar',
'comitiva',
'comover',
'complexo',
'comum',
'concha',
'condor',
'conectar',
'confuso',
'congelar',
'conhecer',
'conjugar',
'consumir',
'contrato',
'convite',
'cooperar',
'copeiro',
'copiador',
'copo',
'coquetel',
'coragem',
'cordial',
'corneta',
'coronha',
'corporal',
'correio',
'cortejo',
'coruja',
'corvo',
'cosseno',
'costela',
'cotonete',
'couro',
'couve',
'covil',
'cozinha',
'cratera',
'cravo',
'creche',
'credor',
'creme',
'crer',
'crespo',
'criada',
'criminal',
'crioulo',
'crise',
'criticar',
'crosta',
'crua',
'cruzeiro',
'cubano',
'cueca',
'cuidado',
'cujo',
'culatra',
'culminar',
'culpar',
'cultura',
'cumprir',
'cunhado',
'cupido',
'curativo',
'curral',
'cursar',
'curto',
'cuspir',
'custear',
'cutelo',
'damasco',
'datar',
'debater',
'debitar',
'deboche',
'debulhar',
'decalque',
'decimal',
'declive',
'decote',
'decretar',
'dedal',
'dedicado',
'deduzir',
'defesa',
'defumar',
'degelo',
'degrau',
'degustar',
'deitado',
'deixar',
'delator',
'delegado',
'delinear',
'delonga',
'demanda',
'demitir',
'demolido',
'dentista',
'depenado',
'depilar',
'depois',
'depressa',
'depurar',
'deriva',
'derramar',
'desafio',
'desbotar',
'descanso',
'desenho',
'desfiado',
'desgaste',
'desigual',
'deslize',
'desmamar',
'desova',
'despesa',
'destaque',
'desviar',
'detalhar',
'detentor',
'detonar',
'detrito',
'deusa',
'dever',
'devido',
'devotado',
'dezena',
'diagrama',
'dialeto',
'didata',
'difuso',
'digitar',
'dilatado',
'diluente',
'diminuir',
'dinastia',
'dinheiro',
'diocese',
'direto',
'discreta',
'disfarce',
'disparo',
'disquete',
'dissipar',
'distante',
'ditador',
'diurno',
'diverso',
'divisor',
'divulgar',
'dizer',
'dobrador',
'dolorido',
'domador',
'dominado',
'donativo',
'donzela',
'dormente',
'dorsal',
'dosagem',
'dourado',
'doutor',
'drenagem',
'drible',
'drogaria',
'duelar',
'duende',
'dueto',
'duplo',
'duquesa',
'durante',
'duvidoso',
'eclodir',
'ecoar',
'ecologia',
'edificar',
'edital',
'educado',
'efeito',
'efetivar',
'ejetar',
'elaborar',
'eleger',
'eleitor',
'elenco',
'elevador',
'eliminar',
'elogiar',
'embargo',
'embolado',
'embrulho',
'embutido',
'emenda',
'emergir',
'emissor',
'empatia',
'empenho',
'empinado',
'empolgar',
'emprego',
'empurrar',
'emulador',
'encaixe',
'encenado',
'enchente',
'encontro',
'endeusar',
'endossar',
'enfaixar',
'enfeite',
'enfim',
'engajado',
'engenho',
'englobar',
'engomado',
'engraxar',
'enguia',
'enjoar',
'enlatar',
'enquanto',
'enraizar',
'enrolado',
'enrugar',
'ensaio',
'enseada',
'ensino',
'ensopado',
'entanto',
'enteado',
'entidade',
'entortar',
'entrada',
'entulho',
'envergar',
'enviado',
'envolver',
'enxame',
'enxerto',
'enxofre',
'enxuto',
'epiderme',
'equipar',
'ereto',
'erguido',
'errata',
'erva',
'ervilha',
'esbanjar',
'esbelto',
'escama',
'escola',
'escrita',
'escuta',
'esfinge',
'esfolar',
'esfregar',
'esfumado',
'esgrima',
'esmalte',
'espanto',
'espelho',
'espiga',
'esponja',
'espreita',
'espumar',
'esquerda',
'estaca',
'esteira',
'esticar',
'estofado',
'estrela',
'estudo',
'esvaziar',
'etanol',
'etiqueta',
'euforia',
'europeu',
'evacuar',
'evaporar',
'evasivo',
'eventual',
'evidente',
'evoluir',
'exagero',
'exalar',
'examinar',
'exato',
'exausto',
'excesso',
'excitar',
'exclamar',
'executar',
'exemplo',
'exibir',
'exigente',
'exonerar',
'expandir',
'expelir',
'expirar',
'explanar',
'exposto',
'expresso',
'expulsar',
'externo',
'extinto',
'extrato',
'fabricar',
'fabuloso',
'faceta',
'facial',
'fada',
'fadiga',
'faixa',
'falar',
'falta',
'familiar',
'fandango',
'fanfarra',
'fantoche',
'fardado',
'farelo',
'farinha',
'farofa',
'farpa',
'fartura',
'fatia',
'fator',
'favorita',
'faxina',
'fazenda',
'fechado',
'feijoada',
'feirante',
'felino',
'feminino',
'fenda',
'feno',
'fera',
'feriado',
'ferrugem',
'ferver',
'festejar',
'fetal',
'feudal',
'fiapo',
'fibrose',
'ficar',
'ficheiro',
'figurado',
'fileira',
'filho',
'filme',
'filtrar',
'firmeza',
'fisgada',
'fissura',
'fita',
'fivela',
'fixador',
'fixo',
'flacidez',
'flamingo',
'flanela',
'flechada',
'flora',
'flutuar',
'fluxo',
'focal',
'focinho',
'fofocar',
'fogo',
'foguete',
'foice',
'folgado',
'folheto',
'forjar',
'formiga',
'forno',
'forte',
'fosco',
'fossa',
'fragata',
'fralda',
'frango',
'frasco',
'fraterno',
'freira',
'frente',
'fretar',
'frieza',
'friso',
'fritura',
'fronha',
'frustrar',
'fruteira',
'fugir',
'fulano',
'fuligem',
'fundar',
'fungo',
'funil',
'furador',
'furioso',
'futebol',
'gabarito',
'gabinete',
'gado',
'gaiato',
'gaiola',
'gaivota',
'galega',
'galho',
'galinha',
'galocha',
'ganhar',
'garagem',
'garfo',
'gargalo',
'garimpo',
'garoupa',
'garrafa',
'gasoduto',
'gasto',
'gata',
'gatilho',
'gaveta',
'gazela',
'gelado',
'geleia',
'gelo',
'gemada',
'gemer',
'gemido',
'generoso',
'gengiva',
'genial',
'genoma',
'genro',
'geologia',
'gerador',
'germinar',
'gesso',
'gestor',
'ginasta',
'gincana',
'gingado',
'girafa',
'girino',
'glacial',
'glicose',
'global',
'glorioso',
'goela',
'goiaba',
'golfe',
'golpear',
'gordura',
'gorjeta',
'gorro',
'gostoso',
'goteira',
'governar',
'gracejo',
'gradual',
'grafite',
'gralha',
'grampo',
'granada',
'gratuito',
'graveto',
'graxa',
'grego',
'grelhar',
'greve',
'grilo',
'grisalho',
'gritaria',
'grosso',
'grotesco',
'grudado',
'grunhido',
'gruta',
'guache',
'guarani',
'guaxinim',
'guerrear',
'guiar',
'guincho',
'guisado',
'gula',
'guloso',
'guru',
'habitar',
'harmonia',
'haste',
'haver',
'hectare',
'herdar',
'heresia',
'hesitar',
'hiato',
'hibernar',
'hidratar',
'hiena',
'hino',
'hipismo',
'hipnose',
'hipoteca',
'hoje',
'holofote',
'homem',
'honesto',
'honrado',
'hormonal',
'hospedar',
'humorado',
'iate',
'ideia',
'idoso',
'ignorado',
'igreja',
'iguana',
'ileso',
'ilha',
'iludido',
'iluminar',
'ilustrar',
'imagem',
'imediato',
'imenso',
'imersivo',
'iminente',
'imitador',
'imortal',
'impacto',
'impedir',
'implante',
'impor',
'imprensa',
'impune',
'imunizar',
'inalador',
'inapto',
'inativo',
'incenso',
'inchar',
'incidir',
'incluir',
'incolor',
'indeciso',
'indireto',
'indutor',
'ineficaz',
'inerente',
'infantil',
'infestar',
'infinito',
'inflamar',
'informal',
'infrator',
'ingerir',
'inibido',
'inicial',
'inimigo',
'injetar',
'inocente',
'inodoro',
'inovador',
'inox',
'inquieto',
'inscrito',
'inseto',
'insistir',
'inspetor',
'instalar',
'insulto',
'intacto',
'integral',
'intimar',
'intocado',
'intriga',
'invasor',
'inverno',
'invicto',
'invocar',
'iogurte',
'iraniano',
'ironizar',
'irreal',
'irritado',
'isca',
'isento',
'isolado',
'isqueiro',
'italiano',
'janeiro',
'jangada',
'janta',
'jararaca',
'jardim',
'jarro',
'jasmim',
'jato',
'javali',
'jazida',
'jejum',
'joaninha',
'joelhada',
'jogador',
'joia',
'jornal',
'jorrar',
'jovem',
'juba',
'judeu',
'judoca',
'juiz',
'julgador',
'julho',
'jurado',
'jurista',
'juro',
'justa',
'labareda',
'laboral',
'lacre',
'lactante',
'ladrilho',
'lagarta',
'lagoa',
'laje',
'lamber',
'lamentar',
'laminar',
'lampejo',
'lanche',
'lapidar',
'lapso',
'laranja',
'lareira',
'largura',
'lasanha',
'lastro',
'lateral',
'latido',
'lavanda',
'lavoura',
'lavrador',
'laxante',
'lazer',
'lealdade',
'lebre',
'legado',
'legendar',
'legista',
'leigo',
'leiloar',
'leitura',
'lembrete',
'leme',
'lenhador',
'lentilha',
'leoa',
'lesma',
'leste',
'letivo',
'letreiro',
'levar',
'leveza',
'levitar',
'liberal',
'libido',
'liderar',
'ligar',
'ligeiro',
'limitar',
'limoeiro',
'limpador',
'linda',
'linear',
'linhagem',
'liquidez',
'listagem',
'lisura',
'litoral',
'livro',
'lixa',
'lixeira',
'locador',
'locutor',
'lojista',
'lombo',
'lona',
'longe',
'lontra',
'lorde',
'lotado',
'loteria',
'loucura',
'lousa',
'louvar',
'luar',
'lucidez',
'lucro',
'luneta',
'lustre',
'lutador',
'luva',
'macaco',
'macete',
'machado',
'macio',
'madeira',
'madrinha',
'magnata',
'magreza',
'maior',
'mais',
'malandro',
'malha',
'malote',
'maluco',
'mamilo',
'mamoeiro',
'mamute',
'manada',
'mancha',
'mandato',
'manequim',
'manhoso',
'manivela',
'manobrar',
'mansa',
'manter',
'manusear',
'mapeado',
'maquinar',
'marcador',
'maresia',
'marfim',
'margem',
'marinho',
'marmita',
'maroto',
'marquise',
'marreco',
'martelo',
'marujo',
'mascote',
'masmorra',
'massagem',
'mastigar',
'matagal',
'materno',
'matinal',
'matutar',
'maxilar',
'medalha',
'medida',
'medusa',
'megafone',
'meiga',
'melancia',
'melhor',
'membro',
'memorial',
'menino',
'menos',
'mensagem',
'mental',
'merecer',
'mergulho',
'mesada',
'mesclar',
'mesmo',
'mesquita',
'mestre',
'metade',
'meteoro',
'metragem',
'mexer',
'mexicano',
'micro',
'migalha',
'migrar',
'milagre',
'milenar',
'milhar',
'mimado',
'minerar',
'minhoca',
'ministro',
'minoria',
'miolo',
'mirante',
'mirtilo',
'misturar',
'mocidade',
'moderno',
'modular',
'moeda',
'moer',
'moinho',
'moita',
'moldura',
'moleza',
'molho',
'molinete',
'molusco',
'montanha',
'moqueca',
'morango',
'morcego',
'mordomo',
'morena',
'mosaico',
'mosquete',
'mostarda',
'motel',
'motim',
'moto',
'motriz',
'muda',
'muito',
'mulata',
'mulher',
'multar',
'mundial',
'munido',
'muralha',
'murcho',
'muscular',
'museu',
'musical',
'nacional',
'nadador',
'naja',
'namoro',
'narina',
'narrado',
'nascer',
'nativa',
'natureza',
'navalha',
'navegar',
'navio',
'neblina',
'nebuloso',
'negativa',
'negociar',
'negrito',
'nervoso',
'neta',
'neural',
'nevasca',
'nevoeiro',
'ninar',
'ninho',
'nitidez',
'nivelar',
'nobreza',
'noite',
'noiva',
'nomear',
'nominal',
'nordeste',
'nortear',
'notar',
'noticiar',
'noturno',
'novelo',
'novilho',
'novo',
'nublado',
'nudez',
'numeral',
'nupcial',
'nutrir',
'nuvem',
'obcecado',
'obedecer',
'objetivo',
'obrigado',
'obscuro',
'obstetra',
'obter',
'obturar',
'ocidente',
'ocioso',
'ocorrer',
'oculista',
'ocupado',
'ofegante',
'ofensiva',
'oferenda',
'oficina',
'ofuscado',
'ogiva',
'olaria',
'oleoso',
'olhar',
'oliveira',
'ombro',
'omelete',
'omisso',
'omitir',
'ondulado',
'oneroso',
'ontem',
'opcional',
'operador',
'oponente',
'oportuno',
'oposto',
'orar',
'orbitar',
'ordem',
'ordinal',
'orfanato',
'orgasmo',
'orgulho',
'oriental',
'origem',
'oriundo',
'orla',
'ortodoxo',
'orvalho',
'oscilar',
'ossada',
'osso',
'ostentar',
'otimismo',
'ousadia',
'outono',
'outubro',
'ouvido',
'ovelha',
'ovular',
'oxidar',
'oxigenar',
'pacato',
'paciente',
'pacote',
'pactuar',
'padaria',
'padrinho',
'pagar',
'pagode',
'painel',
'pairar',
'paisagem',
'palavra',
'palestra',
'palheta',
'palito',
'palmada',
'palpitar',
'pancada',
'panela',
'panfleto',
'panqueca',
'pantanal',
'papagaio',
'papelada',
'papiro',
'parafina',
'parcial',
'pardal',
'parede',
'partida',
'pasmo',
'passado',
'pastel',
'patamar',
'patente',
'patinar',
'patrono',
'paulada',
'pausar',
'peculiar',
'pedalar',
'pedestre',
'pediatra',
'pedra',
'pegada',
'peitoral',
'peixe',
'pele',
'pelicano',
'penca',
'pendurar',
'peneira',
'penhasco',
'pensador',
'pente',
'perceber',
'perfeito',
'pergunta',
'perito',
'permitir',
'perna',
'perplexo',
'persiana',
'pertence',
'peruca',
'pescado',
'pesquisa',
'pessoa',
'petiscar',
'piada',
'picado',
'piedade',
'pigmento',
'pilastra',
'pilhado',
'pilotar',
'pimenta',
'pincel',
'pinguim',
'pinha',
'pinote',
'pintar',
'pioneiro',
'pipoca',
'piquete',
'piranha',
'pires',
'pirueta',
'piscar',
'pistola',
'pitanga',
'pivete',
'planta',
'plaqueta',
'platina',
'plebeu',
'plumagem',
'pluvial',
'pneu',
'poda',
'poeira',
'poetisa',
'polegada',
'policiar',
'poluente',
'polvilho',
'pomar',
'pomba',
'ponderar',
'pontaria',
'populoso',
'porta',
'possuir',
'postal',
'pote',
'poupar',
'pouso',
'povoar',
'praia',
'prancha',
'prato',
'praxe',
'prece',
'predador',
'prefeito',
'premiar',
'prensar',
'preparar',
'presilha',
'pretexto',
'prevenir',
'prezar',
'primata',
'princesa',
'prisma',
'privado',
'processo',
'produto',
'profeta',
'proibido',
'projeto',
'prometer',
'propagar',
'prosa',
'protetor',
'provador',
'publicar',
'pudim',
'pular',
'pulmonar',
'pulseira',
'punhal',
'punir',
'pupilo',
'pureza',
'puxador',
'quadra',
'quantia',
'quarto',
'quase',
'quebrar',
'queda',
'queijo',
'quente',
'querido',
'quimono',
'quina',
'quiosque',
'rabanada',
'rabisco',
'rachar',
'racionar',
'radial',
'raiar',
'rainha',
'raio',
'raiva',
'rajada',
'ralado',
'ramal',
'ranger',
'ranhura',
'rapadura',
'rapel',
'rapidez',
'raposa',
'raquete',
'raridade',
'rasante',
'rascunho',
'rasgar',
'raspador',
'rasteira',
'rasurar',
'ratazana',
'ratoeira',
'realeza',
'reanimar',
'reaver',
'rebaixar',
'rebelde',
'rebolar',
'recado',
'recente',
'recheio',
'recibo',
'recordar',
'recrutar',
'recuar',
'rede',
'redimir',
'redonda',
'reduzida',
'reenvio',
'refinar',
'refletir',
'refogar',
'refresco',
'refugiar',
'regalia',
'regime',
'regra',
'reinado',
'reitor',
'rejeitar',
'relativo',
'remador',
'remendo',
'remorso',
'renovado',
'reparo',
'repelir',
'repleto',
'repolho',
'represa',
'repudiar',
'requerer',
'resenha',
'resfriar',
'resgatar',
'residir',
'resolver',
'respeito',
'ressaca',
'restante',
'resumir',
'retalho',
'reter',
'retirar',
'retomada',
'retratar',
'revelar',
'revisor',
'revolta',
'riacho',
'rica',
'rigidez',
'rigoroso',
'rimar',
'ringue',
'risada',
'risco',
'risonho',
'robalo',
'rochedo',
'rodada',
'rodeio',
'rodovia',
'roedor',
'roleta',
'romano',
'roncar',
'rosado',
'roseira',
'rosto',
'rota',
'roteiro',
'rotina',
'rotular',
'rouco',
'roupa',
'roxo',
'rubro',
'rugido',
'rugoso',
'ruivo',
'rumo',
'rupestre',
'russo',
'sabor',
'saciar',
'sacola',
'sacudir',
'sadio',
'safira',
'saga',
'sagrada',
'saibro',
'salada',
'saleiro',
'salgado',
'saliva',
'salpicar',
'salsicha',
'saltar',
'salvador',
'sambar',
'samurai',
'sanar',
'sanfona',
'sangue',
'sanidade',
'sapato',
'sarda',
'sargento',
'sarjeta',
'saturar',
'saudade',
'saxofone',
'sazonal',
'secar',
'secular',
'seda',
'sedento',
'sediado',
'sedoso',
'sedutor',
'segmento',
'segredo',
'segundo',
'seiva',
'seleto',
'selvagem',
'semanal',
'semente',
'senador',
'senhor',
'sensual',
'sentado',
'separado',
'sereia',
'seringa',
'serra',
'servo',
'setembro',
'setor',
'sigilo',
'silhueta',
'silicone',
'simetria',
'simpatia',
'simular',
'sinal',
'sincero',
'singular',
'sinopse',
'sintonia',
'sirene',
'siri',
'situado',
'soberano',
'sobra',
'socorro',
'sogro',
'soja',
'solda',
'soletrar',
'solteiro',
'sombrio',
'sonata',
'sondar',
'sonegar',
'sonhador',
'sono',
'soprano',
'soquete',
'sorrir',
'sorteio',
'sossego',
'sotaque',
'soterrar',
'sovado',
'sozinho',
'suavizar',
'subida',
'submerso',
'subsolo',
'subtrair',
'sucata',
'sucesso',
'suco',
'sudeste',
'sufixo',
'sugador',
'sugerir',
'sujeito',
'sulfato',
'sumir',
'suor',
'superior',
'suplicar',
'suposto',
'suprimir',
'surdina',
'surfista',
'surpresa',
'surreal',
'surtir',
'suspiro',
'sustento',
'tabela',
'tablete',
'tabuada',
'tacho',
'tagarela',
'talher',
'talo',
'talvez',
'tamanho',
'tamborim',
'tampa',
'tangente',
'tanto',
'tapar',
'tapioca',
'tardio',
'tarefa',
'tarja',
'tarraxa',
'tatuagem',
'taurino',
'taxativo',
'taxista',
'teatral',
'tecer',
'tecido',
'teclado',
'tedioso',
'teia',
'teimar',
'telefone',
'telhado',
'tempero',
'tenente',
'tensor',
'tentar',
'termal',
'terno',
'terreno',
'tese',
'tesoura',
'testado',
'teto',
'textura',
'texugo',
'tiara',
'tigela',
'tijolo',
'timbrar',
'timidez',
'tingido',
'tinteiro',
'tiragem',
'titular',
'toalha',
'tocha',
'tolerar',
'tolice',
'tomada',
'tomilho',
'tonel',
'tontura',
'topete',
'tora',
'torcido',
'torneio',
'torque',
'torrada',
'torto',
'tostar',
'touca',
'toupeira',
'toxina',
'trabalho',
'tracejar',
'tradutor',
'trafegar',
'trajeto',
'trama',
'trancar',
'trapo',
'traseiro',
'tratador',
'travar',
'treino',
'tremer',
'trepidar',
'trevo',
'triagem',
'tribo',
'triciclo',
'tridente',
'trilogia',
'trindade',
'triplo',
'triturar',
'triunfal',
'trocar',
'trombeta',
'trova',
'trunfo',
'truque',
'tubular',
'tucano',
'tudo',
'tulipa',
'tupi',
'turbo',
'turma',
'turquesa',
'tutelar',
'tutorial',
'uivar',
'umbigo',
'unha',
'unidade',
'uniforme',
'urologia',
'urso',
'urtiga',
'urubu',
'usado',
'usina',
'usufruir',
'vacina',
'vadiar',
'vagaroso',
'vaidoso',
'vala',
'valente',
'validade',
'valores',
'vantagem',
'vaqueiro',
'varanda',
'vareta',
'varrer',
'vascular',
'vasilha',
'vassoura',
'vazar',
'vazio',
'veado',
'vedar',
'vegetar',
'veicular',
'veleiro',
'velhice',
'veludo',
'vencedor',
'vendaval',
'venerar',
'ventre',
'verbal',
'verdade',
'vereador',
'vergonha',
'vermelho',
'verniz',
'versar',
'vertente',
'vespa',
'vestido',
'vetorial',
'viaduto',
'viagem',
'viajar',
'viatura',
'vibrador',
'videira',
'vidraria',
'viela',
'viga',
'vigente',
'vigiar',
'vigorar',
'vilarejo',
'vinco',
'vinheta',
'vinil',
'violeta',
'virada',
'virtude',
'visitar',
'visto',
'vitral',
'viveiro',
'vizinho',
'voador',
'voar',
'vogal',
'volante',
'voleibol',
'voltagem',
'volumoso',
'vontade',
'vulto',
'vuvuzela',
'xadrez',
'xarope',
'xeque',
'xeretar',
'xerife',
'xingar',
'zangado',
'zarpar',
'zebu',
'zelador',
'zombar',
'zoologia',
'zumbido'
];
// SPDX-License-Identifier: MIT
const WORDLIST$h = [
'абзац',
'абонент',
'абсурд',
'авангард',
'авария',
'август',
'авиация',
'автор',
'агент',
'агитация',
'агрегат',
'адвокат',
'адмирал',
'адрес',
'азарт',
'азот',
'академия',
'аквариум',
'аксиома',
'акула',
'акцент',
'акция',
'аллея',
'алмаз',
'алтарь',
'альбом',
'альянс',
'амбиция',
'анализ',
'анекдот',
'анкета',
'ансамбль',
'антенна',
'апельсин',
'аппарат',
'аппетит',
'апрель',
'аптека',
'арбуз',
'аргумент',
'аренда',
'арест',
'армия',
'аромат',
'арсенал',
'артерия',
'артист',
'архив',
'аспирант',
'асфальт',
'атака',
'атомный',
'атрибут',
'аукцион',
'афиша',
'аэропорт',
'бабочка',
'бабушка',
'багаж',
'база',
'бактерия',
'баланс',
'балерина',
'балкон',
'бандит',
'банк',
'барабан',
'барон',
'барышня',
'барьер',
'бассейн',
'батарея',
'башмак',
'башня',
'бедный',
'беженец',
'бездна',
'белка',
'белый',
'бензин',
'берег',
'беседа',
'бешеный',
'билет',
'бинокль',
'биржа',
'битва',
'благо',
'блеск',
'близкий',
'блин',
'блок',
'блюдо',
'богатый',
'бодрый',
'боец',
'бокал',
'боковой',
'бокс',
'более',
'болото',
'болтать',
'большой',
'бомба',
'борт',
'борьба',
'босой',
'ботинок',
'бояться',
'брак',
'брать',
'бревно',
'бред',
'бригада',
'бродяга',
'броня',
'бросить',
'брызги',
'брюки',
'брюхо',
'бугор',
'будка',
'будни',
'будущее',
'буква',
'букет',
'бульвар',
'бумага',
'бунт',
'бурный',
'буря',
'бутылка',
'бухта',
'бывший',
'быстро',
'бытовой',
'быть',
'бюджет',
'бюро',
'бюст',
'вагон',
'важный',
'вакцина',
'валенок',
'вальс',
'валюта',
'ванная',
'варенье',
'вариант',
'вблизи',
'вверх',
'вводить',
'вдали',
'вдвое',
'вдова',
'вдоль',
'вдруг',
'ведро',
'ведущий',
'ведьма',
'вежливо',
'везде',
'веко',
'вексель',
'велеть',
'великий',
'венец',
'веник',
'веранда',
'верблюд',
'верить',
'верный',
'версия',
'вертеть',
'верхний',
'вершина',
'весело',
'весна',
'весомый',
'вести',
'весь',
'ветеран',
'ветхий',
'вечер',
'вечно',
'вешалка',
'вещество',
'взамен',
'взгляд',
'вздох',
'взнос',
'взойти',
'взор',
'взрыв',
'взять',
'видеть',
'видимо',
'визг',
'визит',
'вилка',
'вина',
'вирус',
'висок',
'витамин',
'витрина',
'вихрь',
'вишня',
'вкус',
'влага',
'владелец',
'власть',
'влево',
'влияние',
'вложить',
'вместе',
'внешний',
'вникать',
'внимание',
'вновь',
'внук',
'внутри',
'внучка',
'внушать',
'вовлечь',
'вовремя',
'вовсю',
'вода',
'водород',
'водяной',
'воевать',
'возврат',
'возглас',
'воздух',
'возить',
'возле',
'возня',
'возраст',
'война',
'войско',
'вокзал',
'волос',
'волчий',
'вольный',
'воля',
'вообще',
'вопль',
'вопрос',
'ворота',
'восемь',
'восток',
'вплоть',
'вполне',
'вправе',
'впредь',
'впрочем',
'врач',
'вредный',
'время',
'вручить',
'всадник',
'всегда',
'вскоре',
'вскрыть',
'всплеск',
'вспышка',
'встреча',
'всюду',
'всякий',
'второй',
'вход',
'вчера',
'выбор',
'вывод',
'выгнать',
'выдать',
'выехать',
'вызов',
'выйти',
'выкуп',
'вылезти',
'вымыть',
'выпасть',
'выпить',
'выплата',
'выпуск',
'вырасти',
'выручка',
'выслать',
'высокий',
'выставка',
'вышка',
'вязать',
'вялый',
'газета',
'газовый',
'галерея',
'галстук',
'гамма',
'гарантия',
'гармония',
'гарнизон',
'гастроли',
'гвардия',
'гвоздь',
'гектар',
'генерал',
'гений',
'геном',
'геолог',
'герб',
'герой',
'гибкий',
'гигант',
'гимн',
'гипотеза',
'гитара',
'главный',
'глагол',
'гладить',
'глаз',
'глина',
'глоток',
'глубокий',
'глупый',
'глухой',
'глыба',
'глядеть',
'гнев',
'гнездо',
'гнилой',
'годовой',
'голова',
'голубой',
'голый',
'гонорар',
'гордость',
'горизонт',
'горло',
'горный',
'город',
'горшок',
'горький',
'горючее',
'горячий',
'готовый',
'градус',
'грамм',
'граница',
'граф',
'гребень',
'гриб',
'гримаса',
'грозить',
'грохот',
'грош',
'грубый',
'грудь',
'груз',
'грунт',
'группа',
'груша',
'грязный',
'губа',
'гудок',
'гулкий',
'гулять',
'гусеница',
'густо',
'гусь',
'давление',
'давно',
'даже',
'дальний',
'данный',
'дарить',
'датчик',
'дать',
'дача',
'двадцать',
'дважды',
'дверь',
'двигать',
'движение',
'двойной',
'двор',
'дебют',
'девятый',
'дежурный',
'действие',
'декабрь',
'деление',
'дело',
'дельфин',
'день',
'дерево',
'держать',
'дерзкий',
'десять',
'деталь',
'детский',
'дефект',
'дефицит',
'деятель',
'джаз',
'джинсы',
'джунгли',
'диагноз',
'диалог',
'диапазон',
'диван',
'дивизия',
'дивный',
'диета',
'дизайн',
'дикарь',
'дилер',
'динамика',
'диплом',
'директор',
'дитя',
'длинный',
'дневник',
'добрый',
'добыча',
'доверие',
'догадка',
'догнать',
'дождь',
'доклад',
'доктор',
'документ',
'долго',
'должен',
'долина',
'донос',
'дорога',
'досада',
'доска',
'достать',
'досуг',
'доход',
'доцент',
'дощатый',
'драка',
'древний',
'дремать',
'дробный',
'дрова',
'дрожать',
'другой',
'дружба',
'дубовый',
'дуга',
'думать',
'дурной',
'духи',
'душный',
'дуэль',
'дуэт',
'дыра',
'дыхание',
'дюжина',
'дядя',
'едва',
'единый',
'ерунда',
'если',
'ехать',
'жадный',
'жажда',
'жалеть',
'жалоба',
'жанр',
'жареный',
'жаркий',
'жгучий',
'жевать',
'желание',
'желудок',
'жена',
'женщина',
'жертва',
'жест',
'жидкость',
'житель',
'жить',
'жрец',
'жулик',
'журнал',
'жуткий',
'забрать',
'забыть',
'завести',
'завод',
'завтра',
'загадка',
'загнать',
'заговор',
'задача',
'задеть',
'задний',
'задолго',
'заехать',
'заказ',
'закон',
'закрыть',
'закуска',
'залезть',
'залить',
'залп',
'замок',
'замуж',
'замысел',
'занавес',
'заново',
'занять',
'заодно',
'запись',
'запрос',
'запуск',
'запястье',
'заранее',
'заросль',
'зарплата',
'заря',
'засада',
'заслуга',
'заснуть',
'застать',
'затвор',
'затеять',
'затрата',
'затылок',
'захват',
'зачем',
'защита',
'заявить',
'заяц',
'звезда',
'звено',
'звонить',
'здесь',
'зелень',
'земля',
'зеркало',
'зерно',
'зима',
'злой',
'змея',
'знамя',
'знание',
'значит',
'золотой',
'зона',
'зонтик',
'зоопарк',
'зрачок',
'зрение',
'зритель',
'зубной',
'зубр',
'игла',
'идеал',
'идеолог',
'идея',
'идол',
'идти',
'изба',
'избить',
'избрать',
'избыток',
'извлечь',
'извне',
'изгиб',
'изгнать',
'издание',
'изделие',
'изнутри',
'изобилие',
'изоляция',
'изредка',
'изрядно',
'изучение',
'изъять',
'изящный',
'икона',
'икра',
'иллюзия',
'именно',
'иметь',
'имидж',
'империя',
'импульс',
'иначе',
'инвалид',
'индекс',
'индивид',
'инерция',
'инженер',
'иногда',
'иной',
'институт',
'интерес',
'интрига',
'интуиция',
'инфаркт',
'инцидент',
'ирония',
'искать',
'испуг',
'история',
'итог',
'июнь',
'кабель',
'кабинет',
'каблук',
'кавалер',
'кадр',
'каждый',
'кажется',
'казино',
'калитка',
'камень',
'камин',
'канал',
'кандидат',
'каникулы',
'канон',
'капитан',
'капля',
'капот',
'капуста',
'карандаш',
'карета',
'каркас',
'карман',
'картина',
'карьера',
'каска',
'кассета',
'кастрюля',
'каталог',
'катер',
'каток',
'катушка',
'кафедра',
'качество',
'каша',
'кашлять',
'каюта',
'квадрат',
'квартира',
'квота',
'кепка',
'кивнуть',
'километр',
'кино',
'киоск',
'кипяток',
'кирпич',
'кислота',
'кисть',
'клавиша',
'клапан',
'класс',
'клей',
'клетка',
'клиент',
'климат',
'клиника',
'кличка',
'клоун',
'клочок',
'клуб',
'клумба',
'ключ',
'книга',
'кнопка',
'кнут',
'княгиня',
'князь',
'кобура',
'когда',
'кодекс',
'кожа',
'коктейль',
'колено',
'коллега',
'колонна',
'колпак',
'кольцо',
'колючий',
'коляска',
'команда',
'комедия',
'комиссия',
'коммуна',
'комната',
'комок',
'компания',
'комфорт',
'конвейер',
'конгресс',
'конечно',
'конкурс',
'контроль',
'концерт',
'конь',
'конюшня',
'копать',
'копейка',
'копыто',
'корабль',
'корень',
'корзина',
'коридор',
'кормить',
'корпус',
'космос',
'костюм',
'косяк',
'котел',
'котлета',
'который',
'коттедж',
'кофе',
'кофта',
'кошка',
'кража',
'край',
'красный',
'краткий',
'кредит',
'крем',
'крепкий',
'кресло',
'кривой',
'кризис',
'кристалл',
'критерий',
'кричать',
'кровь',
'крокодил',
'кролик',
'кроме',
'крона',
'круг',
'кружка',
'крупный',
'крутой',
'крушение',
'крыло',
'крыша',
'крючок',
'кстати',
'кубик',
'куда',
'кузов',
'кукла',
'кулак',
'кулиса',
'культура',
'кумир',
'купе',
'купить',
'купол',
'купюра',
'курица',
'курорт',
'курс',
'куртка',
'кусок',
'куст',
'кухня',
'кушать',
'лабиринт',
'лавка',
'лагерь',
'ладно',
'ладонь',
'лапа',
'лауреат',
'лгать',
'лебедь',
'левый',
'легенда',
'легкий',
'ледяной',
'лежать',
'лезвие',
'лезть',
'лекция',
'ленивый',
'лента',
'лепесток',
'лесной',
'лестница',
'лететь',
'лето',
'лечить',
'лига',
'лидер',
'лиловый',
'лимон',
'линия',
'липкий',
'лист',
'литр',
'лихой',
'лицо',
'лишить',
'лишний',
'ловить',
'логика',
'лодка',
'ложь',
'лозунг',
'локоть',
'лопата',
'лошадь',
'лукавый',
'луна',
'лучший',
'лысый',
'льгота',
'любить',
'любой',
'людской',
'люстра',
'лютый',
'лягушка',
'магазин',
'магия',
'майор',
'майский',
'максимум',
'макушка',
'мало',
'мальчик',
'мама',
'манера',
'марка',
'март',
'маршрут',
'масса',
'мастер',
'масштаб',
'материал',
'матч',
'махать',
'машина',
'маяк',
'мебель',
'медаль',
'медведь',
'медицина',
'медь',
'между',
'мелкий',
'мелочь',
'мемуары',
'меньше',
'меню',
'менять',
'мера',
'мерцать',
'место',
'месяц',
'металл',
'метод',
'метр',
'механизм',
'меховой',
'мечтать',
'мешать',
'мешок',
'миграция',
'микрофон',
'милиция',
'миллион',
'милость',
'миля',
'мимо',
'минерал',
'министр',
'минута',
'мирный',
'миска',
'миссия',
'митинг',
'мишень',
'младший',
'мнение',
'мнимый',
'много',
'могучий',
'модель',
'может',
'мозг',
'мокрый',
'молекула',
'молния',
'молодой',
'молчать',
'момент',
'монета',
'монитор',
'монолог',
'монстр',
'монтаж',
'мораль',
'море',
'морковь',
'мороз',
'морщина',
'мостовая',
'мотать',
'мотив',
'мотор',
'мохнатый',
'мрамор',
'мрачный',
'мстить',
'мудрый',
'мужество',
'мужчина',
'музей',
'музыка',
'мундир',
'муравей',
'мусор',
'муха',
'мчаться',
'мысль',
'мыться',
'мышца',
'мышь',
'мюзикл',
'мягкий',
'мясо',
'набор',
'навык',
'наглый',
'нагрузка',
'надежда',
'надзор',
'надо',
'наедине',
'назад',
'название',
'назло',
'наивный',
'найти',
'наконец',
'налево',
'наличие',
'налог',
'намерен',
'нанести',
'напасть',
'например',
'народ',
'наследие',
'натура',
'наука',
'наутро',
'начать',
'небо',
'неважно',
'невеста',
'негодяй',
'недавно',
'неделя',
'недолго',
'недра',
'недуг',
'нежный',
'незачем',
'некто',
'нелепый',
'неловко',
'нельзя',
'немало',
'немой',
'неплохо',
'нервный',
'нередко',
'нестись',
'неудача',
'неужели',
'нефть',
'неясный',
'нигде',
'низкий',
'никакой',
'никогда',
'никуда',
'ничто',
'ничуть',
'ниша',
'нищий',
'новость',
'новый',
'нога',
'ноготь',
'ножницы',
'ноздря',
'номер',
'носить',
'носок',
'ночь',
'ноябрь',
'нрав',
'нуль',
'нынче',
'нырять',
'нюанс',
'няня',
'обаяние',
'обед',
'обезьяна',
'обещать',
'обжечь',
'обзор',
'обилие',
'обитать',
'область',
'облик',
'обложка',
'обмен',
'обморок',
'обожать',
'обои',
'оболочка',
'оборона',
'обочина',
'образ',
'обрести',
'обрыв',
'обувь',
'обучение',
'обход',
'общество',
'общий',
'объект',
'обыск',
'обычно',
'обязать',
'овощи',
'овраг',
'овца',
'оговорка',
'ограда',
'огурец',
'одежда',
'одеяло',
'один',
'однако',
'одолеть',
'ожидать',
'озеро',
'океан',
'окно',
'около',
'окоп',
'окраина',
'октябрь',
'опасный',
'опека',
'операция',
'описание',
'оплата',
'опора',
'оппонент',
'оптимизм',
'оптовый',
'опухоль',
'опыт',
'оратор',
'орбита',
'орган',
'орден',
'орел',
'оригинал',
'ориентир',
'оркестр',
'оружие',
'осенний',
'осколок',
'осмотр',
'остров',
'отбор',
'отбыть',
'отвлечь',
'отдать',
'отдел',
'отдых',
'отель',
'отец',
'отзыв',
'отказ',
'отклик',
'открыть',
'откуда',
'отличие',
'отныне',
'отойти',
'отпуск',
'отрасль',
'отросток',
'отрывок',
'отряд',
'отсек',
'отставка',
'отсюда',
'оттенок',
'оттого',
'отчего',
'отъезд',
'офис',
'офицер',
'охота',
'охрана',
'оценка',
'очаг',
'очень',
'очередь',
'очищать',
'ошибка',
'ощущение',
'павильон',
'падать',
'пазуха',
'пакет',
'палата',
'палец',
'палуба',
'пальто',
'память',
'панель',
'паника',
'пара',
'парень',
'пароход',
'партия',
'парус',
'паспорт',
'пассажир',
'пастух',
'патент',
'патрон',
'пауза',
'паук',
'паутина',
'пафос',
'пахнуть',
'пациент',
'пачка',
'певец',
'педагог',
'пейзаж',
'пенсия',
'пепел',
'первый',
'перед',
'период',
'перо',
'перрон',
'персонаж',
'перчатка',
'песня',
'песок',
'петля',
'петрушка',
'петух',
'пехота',
'печать',
'печень',
'пешком',
'пещера',
'пианист',
'пиджак',
'пилот',
'пионер',
'пирамида',
'пирожок',
'письмо',
'пища',
'плавание',
'плакать',
'пламя',
'план',
'пласт',
'платить',
'пленный',
'плечо',
'плита',
'плод',
'плоский',
'плотный',
'плохой',
'площадь',
'плыть',
'плюс',
'пляж',
'плясать',
'победа',
'повар',
'повод',
'повсюду',
'повязка',
'погода',
'погреб',
'подбор',
'подвиг',
'подделка',
'поджать',
'поднос',
'подпись',
'подруга',
'подход',
'подчас',
'подъезд',
'поединок',
'поезд',
'поесть',
'поехать',
'пожалуй',
'пожилой',
'позади',
'позвать',
'поздний',
'позиция',
'позор',
'поиск',
'поймать',
'пойти',
'поклон',
'покой',
'покрыть',
'полдень',
'полезный',
'ползти',
'полк',
'полный',
'половина',
'полтора',
'польза',
'поляна',
'помидор',
'помнить',
'помощь',
'попасть',
'поперек',
'поплыть',
'пополам',
'поправка',
'попугай',
'попытка',
'порог',
'портрет',
'порция',
'порыв',
'порядок',
'после',
'посол',
'посреди',
'постель',
'посуда',
'потом',
'похвала',
'похожий',
'поцелуй',
'почва',
'почему',
'пошлина',
'поэма',
'поэтому',
'право',
'праздник',
'практика',
'прах',
'преграда',
'предмет',
'прежде',
'прелесть',
'премия',
'препарат',
'пресса',
'прибыть',
'прижать',
'прийти',
'приказ',
'прилавок',
'пример',
'принять',
'природа',
'притом',
'прихожая',
'прицел',
'причина',
'приют',
'прогноз',
'продукт',
'проект',
'прожить',
'прокат',
'промысел',
'пропуск',
'просто',
'против',
'профиль',
'процесс',
'прочий',
'прошлый',
'прощать',
'пружина',
'прут',
'прыжок',
'прямой',
'птица',
'публика',
'пугать',
'пуговица',
'пузырь',
'пульт',
'пуля',
'пункт',
'пускать',
'пустой',
'путь',
'пухлый',
'пучок',
'пушистый',
'пушка',
'пчела',
'пшеница',
'пылать',
'пыль',
'пышный',
'пьеса',
'пятка',
'пятно',
'пятый',
'пятьсот',
'работа',
'равнина',
'ради',
'радость',
'радуга',
'разбить',
'развитие',
'разговор',
'раздел',
'различие',
'размер',
'разный',
'разрыв',
'разум',
'район',
'ракета',
'раковина',
'рамка',
'рано',
'рапорт',
'распад',
'рассказ',
'расти',
'расход',
'расцвет',
'рация',
'рвануть',
'рваться',
'реакция',
'ребро',
'реветь',
'редактор',
'редкий',
'реестр',
'режим',
'резать',
'резерв',
'резина',
'резко',
'резной',
'рейс',
'реклама',
'рекорд',
'религия',
'рельс',
'ремень',
'ремонт',
'реплика',
'репортаж',
'ресница',
'ресторан',
'реформа',
'рецепт',
'речь',
'решение',
'ржавый',
'риск',
'рисунок',
'ритуал',
'рифма',
'робко',
'робот',
'ровесник',
'ровно',
'родной',
'рождение',
'роза',
'розовый',
'розыск',
'роль',
'роман',
'роскошь',
'роспись',
'рост',
'рубашка',
'рубеж',
'рубить',
'рубрика',
'рудник',
'рука',
'рукопись',
'румяный',
'русло',
'рухнуть',
'ручей',
'ручной',
'рыба',
'рыжий',
'рынок',
'рыхлый',
'рыцарь',
'рычаг',
'рюкзак',
'рядом',
'садовый',
'сажать',
'салон',
'салфетка',
'салют',
'самец',
'самовар',
'самый',
'сани',
'санкция',
'сапог',
'сарай',
'сатира',
'сахар',
'сбить',
'сбоку',
'сборная',
'сбыт',
'свадьба',
'свалка',
'сварить',
'свежий',
'сверху',
'свет',
'свеча',
'свинья',
'свист',
'свитер',
'свобода',
'сводка',
'свой',
'свыше',
'связь',
'сдаться',
'сделать',
'сегмент',
'сегодня',
'седло',
'седой',
'седьмой',
'сезон',
'сейф',
'сейчас',
'секрет',
'сектор',
'секунда',
'семинар',
'семья',
'сенатор',
'сено',
'сенсация',
'сентябрь',
'сервис',
'сердце',
'середина',
'сержант',
'серия',
'серый',
'сессия',
'сесть',
'сетевой',
'сжатый',
'сжечь',
'сзади',
'сигнал',
'сиденье',
'сила',
'силуэт',
'сильный',
'символ',
'симпатия',
'симфония',
'синий',
'синтез',
'синяк',
'сирень',
'система',
'ситуация',
'сияние',
'сказать',
'скала',
'скамейка',
'скандал',
'скатерть',
'скачок',
'скважина',
'сквер',
'сквозь',
'скелет',
'скидка',
'склад',
'сколько',
'скорый',
'скосить',
'скот',
'скрипка',
'скудный',
'скука',
'слабый',
'слава',
'сладкий',
'слегка',
'след',
'слеза',
'слепой',
'слесарь',
'слишком',
'слово',
'слог',
'сложный',
'сломать',
'служба',
'слух',
'случай',
'слышать',
'слюна',
'смежный',
'смелый',
'сменить',
'смесь',
'сметана',
'смех',
'смола',
'смуглый',
'смутный',
'смущать',
'смысл',
'снайпер',
'снаряд',
'сначала',
'снег',
'снизу',
'сниться',
'сно��а',
'снять',
'собака',
'соблазн',
'собрание',
'событие',
'совесть',
'совсем',
'согласие',
'создать',
'сознание',
'созреть',
'сойтись',
'сокол',
'солдат',
'соленый',
'солнце',
'солома',
'сомнение',
'сонный',
'соперник',
'соратник',
'сорвать',
'сосед',
'сосиска',
'состав',
'сотня',
'соус',
'союз',
'спад',
'спальня',
'спасти',
'спектр',
'сперва',
'спешить',
'спина',
'спирт',
'список',
'спичка',
'сплав',
'спонсор',
'спор',
'способ',
'справка',
'спустя',
'спутник',
'сразу',
'средство',
'срок',
'срыв',
'ссора',
'ссылка',
'ставить',
'стадия',
'стакан',
'станция',
'старый',
'стая',
'стебель',
'стекло',
'стена',
'степень',
'стереть',
'стиль',
'стимул',
'стирать',
'стихи',
'стоить',
'стойка',
'стол',
'стонать',
'стопа',
'сторона',
'стоянка',
'страна',
'стричь',
'строгий',
'струя',
'студент',
'стук',
'ступня',
'стыдно',
'суббота',
'субъект',
'сувенир',
'сугроб',
'сугубо',
'судить',
'судно',
'судьба',
'суета',
'суметь',
'сумма',
'сумрак',
'сундук',
'супруг',
'суровый',
'сутки',
'сухой',
'суша',
'существо',
'сфера',
'схема',
'схожий',
'сценарий',
'счастье',
'считать',
'съезд',
'сыграть',
'сырой',
'сытый',
'сыщик',
'сюда',
'сюжет',
'сюрприз',
'тайна',
'также',
'такой',
'такси',
'тактика',
'талия',
'таможня',
'танец',
'таракан',
'тарелка',
'тариф',
'тащить',
'таять',
'тварь',
'театр',
'тезис',
'текст',
'текущий',
'телефон',
'тема',
'темнота',
'теневой',
'теннис',
'теория',
'теперь',
'тепло',
'терапия',
'терзать',
'термин',
'терпеть',
'терраса',
'терять',
'тесный',
'тетрадь',
'техника',
'течение',
'тигр',
'типовой',
'тираж',
'титул',
'тихий',
'ткань',
'товарищ',
'тоже',
'толпа',
'толстый',
'толчок',
'толщина',
'только',
'тонкий',
'тонна',
'топить',
'топор',
'торговля',
'тормоз',
'торчать',
'тотчас',
'точка',
'точно',
'тощий',
'трава',
'традиция',
'трактор',
'трамвай',
'траншея',
'трасса',
'тревога',
'трезвый',
'тренер',
'трепет',
'треск',
'третий',
'трещина',
'трибуна',
'тридцать',
'триста',
'триумф',
'трогать',
'тройка',
'тронуть',
'тропа',
'тротуар',
'трубка',
'труд',
'трюк',
'тряпка',
'туго',
'туловище',
'туман',
'тумбочка',
'тундра',
'тупик',
'турист',
'турнир',
'тусклый',
'туфля',
'туча',
'тысяча',
'тяга',
'тяжело',
'убежать',
'убогий',
'уборка',
'уважение',
'увезти',
'уволить',
'угадать',
'угол',
'угощать',
'угроза',
'угрюмый',
'удар',
'удачный',
'уделять',
'удивить',
'удобный',
'удочка',
'уезжать',
'ужин',
'узел',
'узкий',
'уйти',
'указание',
'уклон',
'украсть',
'укусить',
'улетать',
'улица',
'улыбка',
'умело',
'умение',
'умный',
'умолять',
'унести',
'унижать',
'унылый',
'упаковка',
'упасть',
'упорно',
'упрек',
'урна',
'уровень',
'урожай',
'уронить',
'усадьба',
'усатый',
'усвоить',
'усилие',
'условие',
'услуга',
'усмешка',
'успеть',
'устав',
'устоять',
'утечка',
'утешать',
'утро',
'уцелеть',
'участие',
'ученик',
'учесть',
'ущелье',
'ущерб',
'уютный',
'фабрика',
'фаворит',
'факел',
'факт',
'фамилия',
'фантазия',
'фасад',
'февраль',
'феномен',
'фермер',
'фигура',
'физика',
'филиал',
'философ',
'фильм',
'финал',
'флаг',
'флот',
'фойе',
'фокус',
'фонарь',
'фонд',
'фонтан',
'форма',
'форум',
'фото',
'фрагмент',
'фраза',
'фракция',
'фронт',
'фрукт',
'функция',
'фуражка',
'футбол',
'футляр',
'халат',
'хаос',
'характер',
'хата',
'хвалить',
'хватать',
'хвойный',
'хвост',
'химия',
'хирург',
'хитрый',
'хищник',
'хлеб',
'хлынуть',
'хмурый',
'ходить',
'хозяин',
'хоккей',
'холм',
'холст',
'хорошо',
'хотеть',
'храбрый',
'храм',
'хранить',
'хребет',
'хрен',
'хрипло',
'хроника',
'хрупкий',
'художник',
'худший',
'хулиган',
'хутор',
'царь',
'цветок',
'целевой',
'целиком',
'целое',
'цель',
'цензура',
'ценить',
'центр',
'цепной',
'цикл',
'цилиндр',
'цирк',
'цитата',
'цифра',
'чайник',
'часы',
'чашка',
'человек',
'челюсть',
'чемодан',
'чемпион',
'чепуха',
'червь',
'чердак',
'через',
'чернила',
'черта',
'чеснок',
'честно',
'четверть',
'четыре',
'число',
'чистый',
'читатель',
'чтение',
'чтобы',
'чувство',
'чудак',
'чудный',
'чудо',
'чужой',
'чулок',
'чума',
'чушь',
'чуять',
'шагать',
'шанс',
'шапка',
'шарик',
'шарф',
'шахматы',
'шашлык',
'шедевр',
'шептать',
'шерсть',
'шестой',
'шинель',
'ширина',
'шишка',
'шкаф',
'школа',
'шкура',
'шланг',
'шлем',
'шнур',
'шоколад',
'шорох',
'шоссе',
'шпион',
'шприц',
'штаб',
'штамм',
'штаны',
'штатный',
'штора',
'штраф',
'штурм',
'штык',
'шумно',
'шуршать',
'шутить',
'шутка',
'щедрый',
'щека',
'щенок',
'экзамен',
'экипаж',
'экономия',
'экран',
'эксперт',
'элемент',
'элитный',
'эмоция',
'энергия',
'эпизод',
'эпоха',
'эскиз',
'эстрада',
'этап',
'этика',
'этот',
'эфир',
'эффект',
'эшелон',
'юбилей',
'юбка',
'южный',
'юмор',
'юность',
'юрист',
'юстиция',
'яблоко',
'явление',
'ягода',
'ядро',
'язык',
'яйцо',
'якобы',
'якорь',
'январь',
'яркий',
'ярмарка',
'ярость',
'ясный',
'яхта',
'ячейка',
'ящик'
];
// SPDX-License-Identifier: MIT
const WORDLIST$g = [
'ábaco',
'abdomen',
'abeja',
'abierto',
'abogado',
'abono',
'aborto',
'abrazo',
'abrir',
'abuelo',
'abuso',
'acabar',
'academia',
'acceso',
'acción',
'aceite',
'acelga',
'acento',
'aceptar',
'ácido',
'aclarar',
'acné',
'acoger',
'acoso',
'activo',
'acto',
'actriz',
'actuar',
'acudir',
'acuerdo',
'acusar',
'adicto',
'admitir',
'adoptar',
'adorno',
'aduana',
'adulto',
'aéreo',
'afectar',
'afición',
'afinar',
'afirmar',
'ágil',
'agitar',
'agonía',
'agosto',
'agotar',
'agregar',
'agrio',
'agua',
'agudo',
'águila',
'aguja',
'ahogo',
'ahorro',
'aire',
'aislar',
'ajedrez',
'ajeno',
'ajuste',
'alacrán',
'alambre',
'alarma',
'alba',
'álbum',
'alcalde',
'aldea',
'alegre',
'alejar',
'alerta',
'aleta',
'alfiler',
'alga',
'algodón',
'aliado',
'aliento',
'alivio',
'alma',
'almeja',
'almíbar',
'altar',
'alteza',
'altivo',
'alto',
'altura',
'alumno',
'alzar',
'amable',
'amante',
'amapola',
'amargo',
'amasar',
'ámbar',
'ámbito',
'ameno',
'amigo',
'amistad',
'amor',
'amparo',
'amplio',
'ancho',
'anciano',
'ancla',
'andar',
'andén',
'anemia',
'ángulo',
'anillo',
'ánimo',
'anís',
'anotar',
'antena',
'antiguo',
'antojo',
'anual',
'anular',
'anuncio',
'añadir',
'añejo',
'año',
'apagar',
'aparato',
'apetito',
'apio',
'aplicar',
'apodo',
'aporte',
'apoyo',
'aprender',
'aprobar',
'apuesta',
'apuro',
'arado',
'araña',
'arar',
'árbitro',
'árbol',
'arbusto',
'archivo',
'arco',
'arder',
'ardilla',
'arduo',
'área',
'árido',
'aries',
'armonía',
'arnés',
'aroma',
'arpa',
'arpón',
'arreglo',
'arroz',
'arruga',
'arte',
'artista',
'asa',
'asado',
'asalto',
'ascenso',
'asegurar',
'aseo',
'asesor',
'asiento',
'asilo',
'asistir',
'asno',
'asombro',
'áspero',
'astilla',
'astro',
'astuto',
'asumir',
'asunto',
'atajo',
'ataque',
'atar',
'atento',
'ateo',
'ático',
'atleta',
'átomo',
'atraer',
'atroz',
'atún',
'audaz',
'audio',
'auge',
'aula',
'aumento',
'ausente',
'autor',
'aval',
'avance',
'avaro',
'ave',
'avellana',
'avena',
'avestruz',
'avión',
'aviso',
'ayer',
'ayuda',
'ayuno',
'azafrán',
'azar',
'azote',
'azúcar',
'azufre',
'azul',
'baba',
'babor',
'bache',
'bahía',
'baile',
'bajar',
'balanza',
'balcón',
'balde',
'bambú',
'banco',
'banda',
'baño',
'barba',
'barco',
'barniz',
'barro',
'báscula',
'bastón',
'basura',
'batalla',
'batería',
'batir',
'batuta',
'baúl',
'bazar',
'bebé',
'bebida',
'bello',
'besar',
'beso',
'bestia',
'bicho',
'bien',
'bingo',
'blanco',
'bloque',
'blusa',
'boa',
'bobina',
'bobo',
'boca',
'bocina',
'boda',
'bodega',
'boina',
'bola',
'bolero',
'bolsa',
'bomba',
'bondad',
'bonito',
'bono',
'bonsái',
'borde',
'borrar',
'bosque',
'bote',
'botín',
'bóveda',
'bozal',
'bravo',
'brazo',
'brecha',
'breve',
'brillo',
'brinco',
'brisa',
'broca',
'broma',
'bronce',
'brote',
'bruja',
'brusco',
'bruto',
'buceo',
'bucle',
'bueno',
'buey',
'bufanda',
'bufón',
'búho',
'buitre',
'bulto',
'burbuja',
'burla',
'burro',
'buscar',
'butaca',
'buzón',
'caballo',
'cabeza',
'cabina',
'cabra',
'cacao',
'cadáver',
'cadena',
'caer',
'café',
'caída',
'caimán',
'caja',
'cajón',
'cal',
'calamar',
'calcio',
'caldo',
'calidad',
'calle',
'calma',
'calor',
'calvo',
'cama',
'cambio',
'camello',
'camino',
'campo',
'cáncer',
'candil',
'canela',
'canguro',
'canica',
'canto',
'caña',
'cañón',
'caoba',
'caos',
'capaz',
'capitán',
'capote',
'captar',
'capucha',
'cara',
'carbón',
'cárcel',
'careta',
'carga',
'cariño',
'carne',
'carpeta',
'carro',
'carta',
'casa',
'casco',
'casero',
'caspa',
'castor',
'catorce',
'catre',
'caudal',
'causa',
'cazo',
'cebolla',
'ceder',
'cedro',
'celda',
'célebre',
'celoso',
'célula',
'cemento',
'ceniza',
'centro',
'cerca',
'cerdo',
'cereza',
'cero',
'cerrar',
'certeza',
'césped',
'cetro',
'chacal',
'chaleco',
'champú',
'chancla',
'chapa',
'charla',
'chico',
'chiste',
'chivo',
'choque',
'choza',
'chuleta',
'chupar',
'ciclón',
'ciego',
'cielo',
'cien',
'cierto',
'cifra',
'cigarro',
'cima',
'cinco',
'cine',
'cinta',
'ciprés',
'circo',
'ciruela',
'cisne',
'cita',
'ciudad',
'clamor',
'clan',
'claro',
'clase',
'clave',
'cliente',
'clima',
'clínica',
'cobre',
'cocción',
'cochino',
'cocina',
'coco',
'código',
'codo',
'cofre',
'coger',
'cohete',
'cojín',
'cojo',
'cola',
'colcha',
'colegio',
'colgar',
'colina',
'collar',
'colmo',
'columna',
'combate',
'comer',
'comida',
'cómodo',
'compra',
'conde',
'conejo',
'conga',
'conocer',
'consejo',
'contar',
'copa',
'copia',
'corazón',
'corbata',
'corcho',
'cordón',
'corona',
'correr',
'coser',
'cosmos',
'costa',
'cráneo',
'cráter',
'crear',
'crecer',
'creído',
'crema',
'cría',
'crimen',
'cripta',
'crisis',
'cromo',
'crónica',
'croqueta',
'crudo',
'cruz',
'cuadro',
'cuarto',
'cuatro',
'cubo',
'cubrir',
'cuchara',
'cuello',
'cuento',
'cuerda',
'cuesta',
'cueva',
'cuidar',
'culebra',
'culpa',
'culto',
'cumbre',
'cumplir',
'cuna',
'cuneta',
'cuota',
'cupón',
'cúpula',
'curar',
'curioso',
'curso',
'curva',
'cutis',
'dama',
'danza',
'dar',
'dardo',
'dátil',
'deber',
'débil',
'década',
'decir',
'dedo',
'defensa',
'definir',
'dejar',
'delfín',
'delgado',
'delito',
'demora',
'denso',
'dental',
'deporte',
'derecho',
'derrota',
'desayuno',
'deseo',
'desfile',
'desnudo',
'destino',
'desvío',
'detalle',
'detener',
'deuda',
'día',
'diablo',
'diadema',
'diamante',
'diana',
'diario',
'dibujo',
'dictar',
'diente',
'dieta',
'diez',
'difícil',
'digno',
'dilema',
'diluir',
'dinero',
'directo',
'dirigir',
'disco',
'diseño',
'disfraz',
'diva',
'divino',
'doble',
'doce',
'dolor',
'domingo',
'don',
'donar',
'dorado',
'dormir',
'dorso',
'dos',
'dosis',
'dragón',
'droga',
'ducha',
'duda',
'duelo',
'dueño',
'dulce',
'dúo',
'duque',
'durar',
'dureza',
'duro',
'ébano',
'ebrio',
'echar',
'eco',
'ecuador',
'edad',
'edición',
'edificio',
'editor',
'educar',
'efecto',
'eficaz',
'eje',
'ejemplo',
'elefante',
'elegir',
'elemento',
'elevar',
'elipse',
'élite',
'elixir',
'elogio',
'eludir',
'embudo',
'emitir',
'emoción',
'empate',
'empeño',
'empleo',
'empresa',
'enano',
'encargo',
'enchufe',
'encía',
'enemigo',
'enero',
'enfado',
'enfermo',
'engaño',
'enigma',
'enlace',
'enorme',
'enredo',
'ensayo',
'enseñar',
'entero',
'entrar',
'envase',
'envío',
'época',
'equipo',
'erizo',
'escala',
'escena',
'escolar',
'escribir',
'escudo',
'esencia',
'esfera',
'esfuerzo',
'espada',
'espejo',
'espía',
'esposa',
'espuma',
'esquí',
'estar',
'este',
'estilo',
'estufa',
'etapa',
'eterno',
'ética',
'etnia',
'evadir',
'evaluar',
'evento',
'evitar',
'exacto',
'examen',
'exceso',
'excusa',
'exento',
'exigir',
'exilio',
'existir',
'éxito',
'experto',
'explicar',
'exponer',
'extremo',
'fábrica',
'fábula',
'fachada',
'fácil',
'factor',
'faena',
'faja',
'falda',
'fallo',
'falso',
'faltar',
'fama',
'familia',
'famoso',
'faraón',
'farmacia',
'farol',
'farsa',
'fase',
'fatiga',
'fauna',
'favor',
'fax',
'febrero',
'fecha',
'feliz',
'feo',
'feria',
'feroz',
'fértil',
'fervor',
'festín',
'fiable',
'fianza',
'fiar',
'fibra',
'ficción',
'ficha',
'fideo',
'fiebre',
'fiel',
'fiera',
'fiesta',
'figura',
'fijar',
'fijo',
'fila',
'filete',
'filial',
'filtro',
'fin',
'finca',
'fingir',
'finito',
'firma',
'flaco',
'flauta',
'flecha',
'flor',
'flota',
'fluir',
'flujo',
'flúor',
'fobia',
'foca',
'fogata',
'fogón',
'folio',
'folleto',
'fondo',
'forma',
'forro',
'fortuna',
'forzar',
'fosa',
'foto',
'fracaso',
'frágil',
'franja',
'frase',
'fraude',
'freír',
'freno',
'fresa',
'frío',
'frito',
'fruta',
'fuego',
'fuente',
'fuerza',
'fuga',
'fumar',
'función',
'funda',
'furgón',
'furia',
'fusil',
'fútbol',
'futuro',
'gacela',
'gafas',
'gaita',
'gajo',
'gala',
'galería',
'gallo',
'gamba',
'ganar',
'gancho',
'ganga',
'ganso',
'garaje',
'garza',
'gasolina',
'gastar',
'gato',
'gavilán',
'gemelo',
'gemir',
'gen',
'género',
'genio',
'gente',
'geranio',
'gerente',
'germen',
'gesto',
'gigante',
'gimnasio',
'girar',
'giro',
'glaciar',
'globo',
'gloria',
'gol',
'golfo',
'goloso',
'golpe',
'goma',
'gordo',
'gorila',
'gorra',
'gota',
'goteo',
'gozar',
'grada',
'gráfico',
'grano',
'grasa',
'gratis',
'grave',
'grieta',
'grillo',
'gripe',
'gris',
'grito',
'grosor',
'grúa',
'grueso',
'grumo',
'grupo',
'guante',
'guapo',
'guardia',
'guerra',
'guía',
'guiño',
'guion',
'guiso',
'guitarra',
'gusano',
'gustar',
'haber',
'hábil',
'hablar',
'hacer',
'hacha',
'hada',
'hallar',
'hamaca',
'harina',
'haz',
'hazaña',
'hebilla',
'hebra',
'hecho',
'helado',
'helio',
'hembra',
'herir',
'hermano',
'héroe',
'hervir',
'hielo',
'hierro',
'hígado',
'higiene',
'hijo',
'himno',
'historia',
'hocico',
'hogar',
'hoguera',
'hoja',
'hombre',
'hongo',
'honor',
'honra',
'hora',
'hormiga',
'horno',
'hostil',
'hoyo',
'hueco',
'huelga',
'huerta',
'hueso',
'huevo',
'huida',
'huir',
'humano',
'húmedo',
'humilde',
'humo',
'hundir',
'huracán',
'hurto',
'icono',
'ideal',
'idioma',
'ídolo',
'iglesia',
'iglú',
'igual',
'ilegal',
'ilusión',
'imagen',
'imán',
'imitar',
'impar',
'imperio',
'imponer',
'impulso',
'incapaz',
'índice',
'inerte',
'infiel',
'informe',
'ingenio',
'inicio',
'inmenso',
'inmune',
'innato',
'insecto',
'instante',
'interés',
'íntimo',
'intuir',
'inútil',
'invierno',
'ira',
'iris',
'ironía',
'isla',
'islote',
'jabalí',
'jabón',
'jamón',
'jarabe',
'jardín',
'jarra',
'jaula',
'jazmín',
'jefe',
'jeringa',
'jinete',
'jornada',
'joroba',
'joven',
'joya',
'juerga',
'jueves',
'juez',
'jugador',
'jugo',
'juguete',
'juicio',
'junco',
'jungla',
'junio',
'juntar',
'júpiter',
'jurar',
'justo',
'juvenil',
'juzgar',
'kilo',
'koala',
'labio',
'lacio',
'lacra',
'lado',
'ladrón',
'lagarto',
'lágrima',
'laguna',
'laico',
'lamer',
'lámina',
'lámpara',
'lana',
'lancha',
'langosta',
'lanza',
'lápiz',
'largo',
'larva',
'lástima',
'lata',
'látex',
'latir',
'laurel',
'lavar',
'lazo',
'leal',
'lección',
'leche',
'lector',
'leer',
'legión',
'legumbre',
'lejano',
'lengua',
'lento',
'leña',
'león',
'leopardo',
'lesión',
'letal',
'letra',
'leve',
'leyenda',
'libertad',
'libro',
'licor',
'líder',
'lidiar',
'lienzo',
'liga',
'ligero',
'lima',
'límite',
'limón',
'limpio',
'lince',
'lindo',
'línea',
'lingote',
'lino',
'linterna',
'líquido',
'liso',
'lista',
'litera',
'litio',
'litro',
'llaga',
'llama',
'llanto',
'llave',
'llegar',
'llenar',
'llevar',
'llorar',
'llover',
'lluvia',
'lobo',
'loción',
'loco',
'locura',
'lógica',
'logro',
'lombriz',
'lomo',
'lonja',
'lote',
'lucha',
'lucir',
'lugar',
'lujo',
'luna',
'lunes',
'lupa',
'lustro',
'luto',
'luz',
'maceta',
'macho',
'madera',
'madre',
'maduro',
'maestro',
'mafia',
'magia',
'mago',
'maíz',
'maldad',
'maleta',
'malla',
'malo',
'mamá',
'mambo',
'mamut',
'manco',
'mando',
'manejar',
'manga',
'maniquí',
'manjar',
'mano',
'manso',
'manta',
'mañana',
'mapa',
'máquina',
'mar',
'marco',
'marea',
'marfil',
'margen',
'marido',
'mármol',
'marrón',
'martes',
'marzo',
'masa',
'máscara',
'masivo',
'matar',
'materia',
'matiz',
'matriz',
'máximo',
'mayor',
'mazorca',
'mecha',
'medalla',
'medio',
'médula',
'mejilla',
'mejor',
'melena',
'melón',
'memoria',
'menor',
'mensaje',
'mente',
'menú',
'mercado',
'merengue',
'mérito',
'mes',
'mesón',
'meta',
'meter',
'método',
'metro',
'mezcla',
'miedo',
'miel',
'miembro',
'miga',
'mil',
'milagro',
'militar',
'millón',
'mimo',
'mina',
'minero',
'mínimo',
'minuto',
'miope',
'mirar',
'misa',
'miseria',
'misil',
'mismo',
'mitad',
'mito',
'mochila',
'moción',
'moda',
'modelo',
'moho',
'mojar',
'molde',
'moler',
'molino',
'momento',
'momia',
'monarca',
'moneda',
'monja',
'monto',
'moño',
'morada',
'morder',
'moreno',
'morir',
'morro',
'morsa',
'mortal',
'mosca',
'mostrar',
'motivo',
'mover',
'móvil',
'mozo',
'mucho',
'mudar',
'mueble',
'muela',
'muerte',
'muestra',
'mugre',
'mujer',
'mula',
'muleta',
'multa',
'mundo',
'muñeca',
'mural',
'muro',
'músculo',
'museo',
'musgo',
'música',
'muslo',
'nácar',
'nación',
'nadar',
'naipe',
'naranja',
'nariz',
'narrar',
'nasal',
'natal',
'nativo',
'natural',
'náusea',
'naval',
'nave',
'navidad',
'necio',
'néctar',
'negar',
'negocio',
'negro',
'neón',
'nervio',
'neto',
'neutro',
'nevar',
'nevera',
'nicho',
'nido',
'niebla',
'nieto',
'niñez',
'niño',
'nítido',
'nivel',
'nobleza',
'noche',
'nómina',
'noria',
'norma',
'norte',
'nota',
'noticia',
'novato',
'novela',
'novio',
'nube',
'nuca',
'núcleo',
'nudillo',
'nudo',
'nuera',
'nueve',
'nuez',
'nulo',
'número',
'nutria',
'oasis',
'obeso',
'obispo',
'objeto',
'obra',
'obrero',
'observar',
'obtener',
'obvio',
'oca',
'ocaso',
'océano',
'ochenta',
'ocho',
'ocio',
'ocre',
'octavo',
'octubre',
'oculto',
'ocupar',
'ocurrir',
'odiar',
'odio',
'odisea',
'oeste',
'ofensa',
'oferta',
'oficio',
'ofrecer',
'ogro',
'oído',
'oír',
'ojo',
'ola',
'oleada',
'olfato',
'olivo',
'olla',
'olmo',
'olor',
'olvido',
'ombligo',
'onda',
'onza',
'opaco',
'opción',
'ópera',
'opinar',
'oponer',
'optar',
'óptica',
'opuesto',
'oración',
'orador',
'oral',
'órbita',
'orca',
'orden',
'oreja',
'órgano',
'orgía',
'orgullo',
'oriente',
'origen',
'orilla',
'oro',
'orquesta',
'oruga',
'osadía',
'oscuro',
'osezno',
'oso',
'ostra',
'otoño',
'otro',
'oveja',
'óvulo',
'óxido',
'oxígeno',
'oyente',
'ozono',
'pacto',
'padre',
'paella',
'página',
'pago',
'país',
'pájaro',
'palabra',
'palco',
'paleta',
'pálido',
'palma',
'paloma',
'palpar',
'pan',
'panal',
'pánico',
'pantera',
'pañuelo',
'papá',
'papel',
'papilla',
'paquete',
'parar',
'parcela',
'pared',
'parir',
'paro',
'párpado',
'parque',
'párrafo',
'parte',
'pasar',
'paseo',
'pasión',
'paso',
'pasta',
'pata',
'patio',
'patria',
'pausa',
'pauta',
'pavo',
'payaso',
'peatón',
'pecado',
'pecera',
'pecho',
'pedal',
'pedir',
'pegar',
'peine',
'pelar',
'peldaño',
'pelea',
'peligro',
'pellejo',
'pelo',
'peluca',
'pena',
'pensar',
'peñón',
'peón',
'peor',
'pepino',
'pequeño',
'pera',
'percha',
'perder',
'pereza',
'perfil',
'perico',
'perla',
'permiso',
'perro',
'persona',
'pesa',
'pesca',
'pésimo',
'pestaña',
'pétalo',
'petróleo',
'pez',
'pezuña',
'picar',
'pichón',
'pie',
'piedra',
'pierna',
'pieza',
'pijama',
'pilar',
'piloto',
'pimienta',
'pino',
'pintor',
'pinza',
'piña',
'piojo',
'pipa',
'pirata',
'pisar',
'piscina',
'piso',
'pista',
'pitón',
'pizca',
'placa',
'plan',
'plata',
'playa',
'plaza',
'pleito',
'pleno',
'plomo',
'pluma',
'plural',
'pobre',
'poco',
'poder',
'podio',
'poema',
'poesía',
'poeta',
'polen',
'policía',
'pollo',
'polvo',
'pomada',
'pomelo',
'pomo',
'pompa',
'poner',
'porción',
'portal',
'posada',
'poseer',
'posible',
'poste',
'potencia',
'potro',
'pozo',
'prado',
'precoz',
'pregunta',
'premio',
'prensa',
'preso',
'previo',
'primo',
'príncipe',
'prisión',
'privar',
'proa',
'probar',
'proceso',
'producto',
'proeza',
'profesor',
'programa',
'prole',
'promesa',
'pronto',
'propio',
'próximo',
'prueba',
'público',
'puchero',
'pudor',
'pueblo',
'puerta',
'puesto',
'pulga',
'pulir',
'pulmón',
'pulpo',
'pulso',
'puma',
'punto',
'puñal',
'puño',
'pupa',
'pupila',
'puré',
'quedar',
'queja',
'quemar',
'querer',
'queso',
'quieto',
'química',
'quince',
'quitar',
'rábano',
'rabia',
'rabo',
'ración',
'radical',
'raíz',
'rama',
'rampa',
'rancho',
'rango',
'rapaz',
'rápido',
'rapto',
'rasgo',
'raspa',
'rato',
'rayo',
'raza',
'razón',
'reacción',
'realidad',
'rebaño',
'rebote',
'recaer',
'receta',
'rechazo',
'recoger',
'recreo',
'recto',
'recurso',
'red',
'redondo',
'reducir',
'reflejo',
'reforma',
'refrán',
'refugio',
'regalo',
'regir',
'regla',
'regreso',
'rehén',
'reino',
'reír',
'reja',
'relato',
'relevo',
'relieve',
'relleno',
'reloj',
'remar',
'remedio',
'remo',
'rencor',
'rendir',
'renta',
'reparto',
'repetir',
'reposo',
'reptil',
'res',
'rescate',
'resina',
'respeto',
'resto',
'resumen',
'retiro',
'retorno',
'retrato',
'reunir',
'revés',
'revista',
'rey',
'rezar',
'rico',
'riego',
'rienda',
'riesgo',
'rifa',
'rígido',
'rigor',
'rincón',
'riñón',
'río',
'riqueza',
'risa',
'ritmo',
'rito',
'rizo',
'roble',
'roce',
'rociar',
'rodar',
'rodeo',
'rodilla',
'roer',
'rojizo',
'rojo',
'romero',
'romper',
'ron',
'ronco',
'ronda',
'ropa',
'ropero',
'rosa',
'rosca',
'rostro',
'rotar',
'rubí',
'rubor',
'rudo',
'rueda',
'rugir',
'ruido',
'ruina',
'ruleta',
'rulo',
'rumbo',
'rumor',
'ruptura',
'ruta',
'rutina',
'sábado',
'saber',
'sabio',
'sable',
'sacar',
'sagaz',
'sagrado',
'sala',
'saldo',
'salero',
'salir',
'salmón',
'salón',
'salsa',
'salto',
'salud',
'salvar',
'samba',
'sanción',
'sandía',
'sanear',
'sangre',
'sanidad',
'sano',
'santo',
'sapo',
'saque',
'sardina',
'sartén',
'sastre',
'satán',
'sauna',
'saxofón',
'sección',
'seco',
'secreto',
'secta',
'sed',
'seguir',
'seis',
'sello',
'selva',
'semana',
'semilla',
'senda',
'sensor',
'señal',
'señor',
'separar',
'sepia',
'sequía',
'ser',
'serie',
'sermón',
'servir',
'sesenta',
'sesión',
'seta',
'setenta',
'severo',
'sexo',
'sexto',
'sidra',
'siesta',
'siete',
'siglo',
'signo',
'sílaba',
'silbar',
'silencio',
'silla',
'símbolo',
'simio',
'sirena',
'sistema',
'sitio',
'situar',
'sobre',
'socio',
'sodio',
'sol',
'solapa',
'soldado',
'soledad',
'sólido',
'soltar',
'solución',
'sombra',
'sondeo',
'sonido',
'sonoro',
'sonrisa',
'sopa',
'soplar',
'soporte',
'sordo',
'sorpresa',
'sorteo',
'sostén',
'sótano',
'suave',
'subir',
'suceso',
'sudor',
'suegra',
'suelo',
'sueño',
'suerte',
'sufrir',
'sujeto',
'sultán',
'sumar',
'superar',
'suplir',
'suponer',
'supremo',
'sur',
'surco',
'sureño',
'surgir',
'susto',
'sutil',
'tabaco',
'tabique',
'tabla',
'tabú',
'taco',
'tacto',
'tajo',
'talar',
'talco',
'talento',
'talla',
'talón',
'tamaño',
'tambor',
'tango',
'tanque',
'tapa',
'tapete',
'tapia',
'tapón',
'taquilla',
'tarde',
'tarea',
'tarifa',
'tarjeta',
'tarot',
'tarro',
'tarta',
'tatuaje',
'tauro',
'taza',
'tazón',
'teatro',
'techo',
'tecla',
'técnica',
'tejado',
'tejer',
'tejido',
'tela',
'teléfono',
'tema',
'temor',
'templo',
'tenaz',
'tender',
'tener',
'tenis',
'tenso',
'teoría',
'terapia',
'terco',
'término',
'ternura',
'terror',
'tesis',
'tesoro',
'testigo',
'tetera',
'texto',
'tez',
'tibio',
'tiburón',
'tiempo',
'tienda',
'tierra',
'tieso',
'tigre',
'tijera',
'tilde',
'timbre',
'tímido',
'timo',
'tinta',
'tío',
'típico',
'tipo',
'tira',
'tirón',
'titán',
'títere',
'título',
'tiza',
'toalla',
'tobillo',
'tocar',
'tocino',
'todo',
'toga',
'toldo',
'tomar',
'tono',
'tonto',
'topar',
'tope',
'toque',
'tórax',
'torero',
'tormenta',
'torneo',
'toro',
'torpedo',
'torre',
'torso',
'tortuga',
'tos',
'tosco',
'toser',
'tóxico',
'trabajo',
'tractor',
'traer',
'tráfico',
'trago',
'traje',
'tramo',
'trance',
'trato',
'trauma',
'trazar',
'trébol',
'tregua',
'treinta',
'tren',
'trepar',
'tres',
'tribu',
'trigo',
'tripa',
'triste',
'triunfo',
'trofeo',
'trompa',
'tronco',
'tropa',
'trote',
'trozo',
'truco',
'trueno',
'trufa',
'tubería',
'tubo',
'tuerto',
'tumba',
'tumor',
'túnel',
'túnica',
'turbina',
'turismo',
'turno',
'tutor',
'ubicar',
'úlcera',
'umbral',
'unidad',
'unir',
'universo',
'uno',
'untar',
'uña',
'urbano',
'urbe',
'urgente',
'urna',
'usar',
'usuario',
'útil',
'utopía',
'uva',
'vaca',
'vacío',
'vacuna',
'vagar',
'vago',
'vaina',
'vajilla',
'vale',
'válido',
'valle',
'valor',
'válvula',
'vampiro',
'vara',
'variar',
'varón',
'vaso',
'vecino',
'vector',
'vehículo',
'veinte',
'vejez',
'vela',
'velero',
'veloz',
'vena',
'vencer',
'venda',
'veneno',
'vengar',
'venir',
'venta',
'venus',
'ver',
'verano',
'verbo',
'verde',
'vereda',
'verja',
'verso',
'verter',
'vía',
'viaje',
'vibrar',
'vicio',
'víctima',
'vida',
'vídeo',
'vidrio',
'viejo',
'viernes',
'vigor',
'vil',
'villa',
'vinagre',
'vino',
'viñedo',
'violín',
'viral',
'virgo',
'virtud',
'visor',
'víspera',
'vista',
'vitamina',
'viudo',
'vivaz',
'vivero',
'vivir',
'vivo',
'volcán',
'volumen',
'volver',
'voraz',
'votar',
'voto',
'voz',
'vuelo',
'vulgar',
'yacer',
'yate',
'yegua',
'yema',
'yerno',
'yeso',
'yodo',
'yoga',
'yogur',
'zafiro',
'zanja',
'zapato',
'zarza',
'zona',
'zorro',
'zumo',
'zurdo'
];
// SPDX-License-Identifier: MIT
const WORDLIST$f = [
'abajur',
'abaküs',
'abartı',
'abdal',
'abdest',
'abiye',
'abluka',
'abone',
'absorbe',
'absürt',
'acayip',
'acele',
'acemi',
'açıkgöz',
'adalet',
'adam',
'adezyon',
'adisyon',
'adliye',
'adres',
'afacan',
'afili',
'afiş',
'afiyet',
'aforizm',
'afra',
'ağaç',
'ağır',
'ahbap',
'ahkam',
'ahlak',
'ahtapot',
'aidat',
'aile',
'ajan',
'akademi',
'akarsu',
'akbaş',
'akciğer',
'akdeniz',
'akıbet',
'akıl',
'akıntı',
'akide',
'akrep',
'akrobasi',
'aksiyon',
'akşam',
'aktif',
'aktör',
'aktris',
'akustik',
'alaca',
'albüm',
'alçak',
'aldanma',
'aleni',
'alet',
'alfabe',
'algılama',
'alıngan',
'alkış',
'alkol',
'alpay',
'alperen',
'altın',
'altüst',
'altyapı',
'alyuvar',
'amade',
'amatör',
'amazon',
'ambalaj',
'amblem',
'ambulans',
'amca',
'amel',
'amigo',
'amir',
'amiyane',
'amorti',
'ampul',
'anadolu',
'anahtar',
'anakonda',
'anaokul',
'anapara',
'anarşi',
'anatomi',
'anayasa',
'anekdot',
'anestezi',
'angaje',
'anka',
'anket',
'anlamlı',
'anne',
'anomali',
'anonim',
'anten',
'antlaşma',
'apse',
'araba',
'aracı',
'araf',
'arbede',
'arda',
'arefe',
'arena',
'argo',
'argüman',
'arkadaş',
'armoni',
'aroma',
'arsa',
'arsız',
'artı',
'artist',
'aruz',
'asansör',
'asayiş',
'asfalt',
'asgari',
'asil',
'asker',
'askı',
'aslan',
'asosyal',
'astsubay',
'asya',
'aşçı',
'aşırı',
'aşure',
'atabey',
'ataman',
'ateş',
'atmaca',
'atmosfer',
'atom',
'atölye',
'avcı',
'avdet',
'avize',
'avlu',
'avokado',
'avrupa',
'avukat',
'ayaz',
'ayçiçeği',
'aydın',
'aygıt',
'ayna',
'ayran',
'ayrıntı',
'azim',
'baca',
'bagaj',
'bağlantı',
'bahadır',
'bahçe',
'baki',
'bakkal',
'baklava',
'bakteri',
'balçık',
'balina',
'balo',
'balta',
'bant',
'banyo',
'bardak',
'barış',
'başbuğ',
'başıboş',
'başkan',
'başlık',
'bavul',
'bayındır',
'baykuş',
'bazlama',
'bedel',
'begüm',
'bekçi',
'bekle',
'belge',
'belki',
'bencil',
'benek',
'bengi',
'benzer',
'berjer',
'berk',
'bermuda',
'berrak',
'beşik',
'beton',
'beyin',
'beyoğlu',
'bıçak',
'biberiye',
'bidon',
'biftek',
'bihaber',
'bikini',
'bilezik',
'bilinç',
'bilye',
'bina',
'binbaşı',
'binyıl',
'bisiklet',
'bisküvi',
'bitki',
'bizzat',
'bodrum',
'boğaz',
'bohça',
'bolero',
'boncuk',
'bonfile',
'borsa',
'boru',
'bostan',
'boşboğaz',
'botanik',
'boya',
'boykot',
'boynuz',
'bozgun',
'bozkır',
'bölüm',
'börek',
'buçuk',
'bugün',
'buğday',
'buhar',
'buhran',
'bulvar',
'buram',
'burçak',
'burs',
'burun',
'butik',
'buzdağı',
'buzkıran',
'bücür',
'büfe',
'bülten',
'bütçe',
'bütün',
'büyük',
'cacık',
'cadı',
'cahil',
'cambaz',
'canhıraş',
'casus',
'cazibe',
'cehalet',
'cehennem',
'ceket',
'cemre',
'cenin',
'cennet',
'cepken',
'cerrah',
'cesur',
'cetvel',
'cevher',
'ceylan',
'cılız',
'cıva',
'cilt',
'cisim',
'ciyak',
'coğrafya',
'cömert',
'cumba',
'cüzdan',
'çabucak',
'çadır',
'çağdaş',
'çağlayan',
'çağrı',
'çakmak',
'çalışkan',
'çamaşır',
'çapa',
'çaput',
'çarık',
'çarpan',
'çarşaf',
'çayhane',
'çekirdek',
'çelebi',
'çember',
'çenet',
'çengel',
'çerçeve',
'çerez',
'çeşit',
'çeşme',
'çete',
'çevre',
'çeyiz',
'çeyrek',
'çığır',
'çılgın',
'çıngırak',
'çift',
'çiğdem',
'çikolata',
'çilek',
'çimen',
'çivi',
'çoban',
'çocuk',
'çokgen',
'çomak',
'çorba',
'çözelti',
'çubuk',
'çukur',
'çuval',
'çürük',
'dağbaşı',
'dağılım',
'daktilo',
'daldırış',
'dalga',
'dalkavuk',
'damak',
'damıtma',
'damla',
'dana',
'dandik',
'danışman',
'daniska',
'dantel',
'dargeçit',
'darphane',
'davet',
'dayı',
'defter',
'değer',
'değirmen',
'dehşet',
'delgeç',
'demir',
'deneyim',
'denge',
'depo',
'deprem',
'derdest',
'dere',
'derhal',
'derman',
'dernek',
'derviş',
'desen',
'destan',
'dışarı',
'dışbükey',
'dijital',
'dikbaşlı',
'dilekçe',
'dimağ',
'dinamik',
'dindar',
'dinleme',
'dinozor',
'dipçik',
'dipnot',
'direniş',
'dirsek',
'disiplin',
'disk',
'divriği',
'dizüstü',
'dobra',
'dodurga',
'doğalgaz',
'doktor',
'doküman',
'dolap',
'donanım',
'dondurma',
'donör',
'doruk',
'dosdoğru',
'dost',
'dosya',
'dozer',
'döküm',
'dönence',
'dörtyol',
'dövme',
'dram',
'dublaj',
'durum',
'duvak',
'duyarga',
'duyma',
'duyuru',
'düğme',
'düğüm',
'dükkan',
'dünür',
'düpedüz',
'dürbün',
'düşünür',
'düzayak',
'düzeltme',
'ebeveyn',
'ebru',
'ecel',
'ecnebi',
'ecza',
'edat',
'edilgen',
'efendi',
'efor',
'efsane',
'egemen',
'egzersiz',
'eğrelti',
'ekarte',
'ekip',
'eklem',
'ekmek',
'ekol',
'ekonomi',
'ekose',
'ekran',
'ekvator',
'elaman',
'elastik',
'elbet',
'elbise',
'elçi',
'eldiven',
'elebaşı',
'eleştiri',
'elma',
'eloğlu',
'elveda',
'emare',
'emekçi',
'emisyon',
'emniyet',
'empati',
'emsal',
'emzik',
'endüstri',
'enerji',
'engebe',
'engin',
'enişte',
'enkaz',
'entari',
'entegre',
'entrika',
'enzim',
'erdem',
'ergen',
'erguvan',
'erkek',
'erozyon',
'ertesi',
'erzak',
'esaret',
'esenlik',
'eser',
'eski',
'esnek',
'eşarp',
'eşofman',
'eşraf',
'eşya',
'eşzaman',
'etik',
'etken',
'etkinlik',
'etüt',
'evet',
'evire',
'evrak',
'evrim',
'eyalet',
'eyvah',
'ezber',
'fabrika',
'fanatik',
'fanus',
'fason',
'fasulye',
'fatih',
'fatura',
'fauna',
'favori',
'fayans',
'fayton',
'fazıl',
'fazilet',
'federal',
'felsefe',
'fener',
'feribot',
'fersah',
'fesih',
'festival',
'feveran',
'feza',
'fıçı',
'fıldır',
'fındık',
'fırça',
'fırsat',
'fırtına',
'fıtık',
'fidan',
'fidye',
'figür',
'fihrist',
'fikir',
'fildişi',
'filo',
'filtre',
'fincan',
'firuze',
'fitil',
'fiyaka',
'fizik',
'flaş',
'flüt',
'fosil',
'fren',
'fukara',
'futbol',
'garabet',
'gariban',
'garnitür',
'gazi',
'gece',
'gedik',
'gelenek',
'gelin',
'gemi',
'genç',
'geniş',
'geometri',
'gerçek',
'gevrek',
'gezegen',
'gezgin',
'geziyolu',
'gıcık',
'gıda',
'gıybet',
'girdap',
'girişim',
'gitar',
'giyecek',
'giysi',
'gizem',
'gofret',
'goril',
'göbek',
'göçebe',
'göğüs',
'gökdelen',
'gökmen',
'gökyüzü',
'gölge',
'gömlek',
'gönül',
'görenek',
'görkemli',
'görsel',
'gösteri',
'gövde',
'gözaltı',
'gözcü',
'gözdağı',
'gözleme',
'gözyaşı',
'grup',
'gurbet',
'gusül',
'gübre',
'güfte',
'gümüş',
'günaydın',
'güncel',
'gündüz',
'güneş',
'günyüzü',
'gürbüz',
'güvercin',
'güzel',
'haber',
'hacamat',
'hacim',
'hademe',
'hafız',
'hafriyat',
'hafta',
'hakan',
'hakem',
'hakikat',
'haksever',
'halı',
'hançer',
'hane',
'hangar',
'hapis',
'hapşırık',
'harf',
'haseki',
'hasret',
'hatun',
'havuç',
'haylaz',
'haysiyet',
'hayvan',
'hedef',
'hektar',
'hemen',
'hemfikir',
'hendek',
'hepsi',
'hergele',
'herhangi',
'hesap',
'heyecan',
'heykel',
'hezimet',
'hıçkırık',
'hızölçer',
'hicviye',
'hikaye',
'hikmet',
'hile',
'hisse',
'hobi',
'hoca',
'horlama',
'hormon',
'hoşbeş',
'hoşgörü',
'hoyrat',
'hörgüç',
'höyük',
'hudut',
'hukuk',
'hunhar',
'hurda',
'huysuz',
'huzur',
'hücum',
'hükümet',
'hünkar',
'hüviyet',
'ırmak',
'ısıölçer',
'ısıtıcı',
'ıspanak',
'ısrar',
'ışıldak',
'ızdırap',
'ızgara',
'ibadet',
'icat',
'içbükey',
'içecek',
'içgüdü',
'içsel',
'idman',
'iftihar',
'iğne',
'ihanet',
'ihbar',
'ihdas',
'ihmal',
'ihracat',
'ihsan',
'ikilem',
'ikindi',
'ikircik',
'iklim',
'iksir',
'iktibas',
'ilaç',
'ilçe',
'ileri',
'iletişim',
'ilgi',
'ilhak',
'ilkbahar',
'ilkokul',
'ilmek',
'imkan',
'imleç',
'imsak',
'imtihan',
'imza',
'ince',
'inkar',
'inşa',
'ipek',
'ipucu',
'irade',
'irfan',
'irmik',
'isabet',
'iskele',
'israf',
'isyan',
'işçi',
'işgal',
'işgüzar',
'işlem',
'itibar',
'itiraf',
'ivedi',
'ivme',
'iyileşme',
'iyimser',
'izbandut',
'izci',
'izdiham',
'izin',
'jakoben',
'jandarma',
'jargon',
'kabadayı',
'kablo',
'kabus',
'kaçamak',
'kadeh',
'kadın',
'kadraj',
'kafa',
'kafkas',
'kağıt',
'kağnı',
'kahkaha',
'kahraman',
'kahvaltı',
'kakül',
'kaldırım',
'kale',
'kalibre',
'kalkan',
'kalpak',
'kamış',
'kamyon',
'kanat',
'kandaş',
'kanepe',
'kanser',
'kanun',
'kaos',
'kapı',
'kaplıca',
'kaptan',
'karanlık',
'kardeş',
'karga',
'karınca',
'karmaşa',
'karşıt',
'kasırga',
'kask',
'kasvet',
'katkı',
'katman',
'kavram',
'kaygan',
'kaynakça',
'kayyum',
'kedi',
'kehanet',
'kekik',
'kelebek',
'kenar',
'kerkenez',
'kerpiç',
'kesirli',
'kesmece',
'kestane',
'keşkek',
'ketçap',
'keyfiyet',
'kıble',
'kıdemli',
'kılavuz',
'kılçık',
'kılıf',
'kıraç',
'kırmızı',
'kırsal',
'kısayol',
'kısım',
'kıskanç',
'kısmet',
'kışla',
'kıvanç',
'kıvılcım',
'kıvrık',
'kıyafet',
'kıymetli',
'kızak',
'kızılcık',
'kibar',
'kinaye',
'kira',
'kiremit',
'kirli',
'kirpik',
'kişisel',
'kitap',
'koçbaşı',
'kodaman',
'koğuş',
'kokteyl',
'kolaycı',
'kolbastı',
'kolonya',
'koltuk',
'kolye',
'kombine',
'komedyen',
'komiser',
'komposto',
'komşu',
'komuta',
'konak',
'konfor',
'koni',
'konsül',
'kopya',
'korkusuz',
'korna',
'korse',
'korunak',
'korvet',
'kostüm',
'koşul',
'koyu',
'kozmik',
'köfte',
'kökensel',
'köprücük',
'köpük',
'kördüğüm',
'körfez',
'köstebek',
'köşegen',
'kötü',
'kravat',
'kriter',
'kuantum',
'kudurma',
'kuluçka',
'kulübe',
'kumanya',
'kumbara',
'kumlu',
'kumpir',
'kumral',
'kundura',
'kupa',
'kupkuru',
'kuramsal',
'kurbağa',
'kurdele',
'kurgu',
'kurmay',
'kurşun',
'kurtuluş',
'kurultay',
'kurye',
'kusursuz',
'kuşak',
'kuşbaşı',
'kuşkulu',
'kutlama',
'kutsal',
'kutup',
'kuver',
'kuyruk',
'kuzey',
'kuzgun',
'küçük',
'külçe',
'külfet',
'külliye',
'kültürel',
'kümes',
'künefe',
'küresel',
'kütle',
'lahana',
'lahmacun',
'lamba',
'lansman',
'lavaş',
'layık',
'leğen',
'levent',
'leziz',
'lezzet',
'lider',
'likide',
'liman',
'liste',
'litre',
'liyakat',
'lodos',
'lokanta',
'lokman',
'lokum',
'lunapark',
'lütfen',
'lüzum',
'nokta',
'mabet',
'macera',
'macun',
'madalya',
'madde',
'madem',
'mağara',
'mağdur',
'mağfiret',
'mağlup',
'mahalle',
'mahcup',
'mahir',
'mahkeme',
'mahlas',
'mahrum',
'mahsul',
'makas',
'makbuz',
'makine',
'makro',
'maksat',
'makul',
'maliye',
'manav',
'mangal',
'manidar',
'manken',
'mantık',
'manzara',
'mareşal',
'margarin',
'marifet',
'market',
'marmelat',
'masaüstü',
'masmavi',
'masraf',
'masum',
'matah',
'materyal',
'matrak',
'maval',
'mavra',
'maydanoz',
'mayhoş',
'maytap',
'mazbata',
'mazeret',
'mazlum',
'mazot',
'mazur',
'meblağ',
'mebus',
'mecaz',
'mecbur',
'meclis',
'mecmua',
'mecnun',
'meçhul',
'medeni',
'mehtap',
'mekanik',
'melodi',
'meltem',
'memur',
'mendil',
'menekşe',
'menteşe',
'meraklı',
'mercek',
'merdiven',
'merhaba',
'merinos',
'merkez',
'mermi',
'mert',
'mesafe',
'mesele',
'mesken',
'meslek',
'meşale',
'meşgul',
'meşhur',
'metafor',
'metin',
'metre',
'mevcut',
'mevkidaş',
'meydan',
'meyil',
'meyve',
'meziyet',
'mezun',
'mıknatıs',
'mısra',
'mızıka',
'miğfer',
'mihrak',
'mikrofon',
'miktar',
'milat',
'milli',
'mimar',
'minare',
'mineral',
'minik',
'minyon',
'mirliva',
'misafir',
'miskin',
'miting',
'miyop',
'mizah',
'mobilya',
'model',
'monitör',
'morötesi',
'motive',
'motor',
'mozaik',
'muavin',
'mucize',
'muhafız',
'muhteşem',
'mukayese',
'mumya',
'musluk',
'muşamba',
'mutabık',
'mutfak',
'mutlu',
'muzaffer',
'muzdarip',
'mübarek',
'mücadele',
'müdür',
'müfredat',
'müftü',
'mühendis',
'mühim',
'mühlet',
'mükemmel',
'mülk',
'mümkün',
'mümtaz',
'müsrif',
'müstesna',
'müşahit',
'müşteri',
'mütercim',
'müthiş',
'müze',
'müzik',
'nabız',
'nadas',
'nadir',
'nahoş',
'nakarat',
'nakış',
'nalbur',
'namlu',
'namus',
'nankör',
'nargile',
'narkoz',
'nasıl',
'nasip',
'naylon',
'nazar',
'nazım',
'nazik',
'neden',
'nefes',
'negatif',
'neon',
'neptün',
'nerede',
'nesil',
'nesnel',
'neşeli',
'netice',
'nevresim',
'neyse',
'neyzen',
'nezaket',
'nezih',
'nezle',
'nicel',
'nilüfer',
'nimet',
'nisan',
'nispet',
'nitekim',
'nizam',
'nohut',
'noksan',
'normal',
'nostalji',
'noter',
'nöbet',
'numara',
'numune',
'nutuk',
'nüfus',
'obabaşı',
'obez',
'obje',
'ocak',
'odun',
'ofansif',
'ofis',
'oğlak',
'oğuz',
'okçu',
'oklava',
'oksijen',
'okul',
'okumuş',
'okutman',
'okuyucu',
'okyanus',
'olağan',
'olanak',
'olası',
'olay',
'olgun',
'olimpik',
'olumlu',
'omlet',
'omurga',
'onarım',
'onursal',
'opera',
'optik',
'oral',
'orantı',
'ordu',
'organik',
'orijin',
'orkide',
'orman',
'orta',
'oruç',
'otağ',
'otantik',
'otel',
'otoban',
'otogar',
'otomobil',
'otonom',
'otopark',
'otorite',
'otoyol',
'oturum',
'oyuk',
'oyuncak',
'ozan',
'ödeme',
'ödenek',
'ödev',
'ödül',
'ödünç',
'öfke',
'öğlen',
'öğrenci',
'öğün',
'öğütücü',
'öksürük',
'ölçme',
'ölçü',
'ölümsüz',
'ömür',
'önayak',
'öncü',
'önder',
'önem',
'önerge',
'öngörü',
'önlük',
'önsezi',
'öpücük',
'ördek',
'örgü',
'örtbas',
'örtme',
'örtü',
'örümcek',
'örüntü',
'öteberi',
'öteki',
'övünç',
'öykü',
'öyleyse',
'özçekim',
'özdeyiş',
'özel',
'özenti',
'özerk',
'özgürlük',
'özlem',
'özlü',
'özne',
'özsever',
'özümseme',
'özür',
'özveri',
'pabuç',
'padişah',
'palamut',
'palmiye',
'palto',
'palyaço',
'pamuk',
'panayır',
'pancar',
'panda',
'panel',
'panik',
'panjur',
'pankart',
'pano',
'pansuman',
'pantolon',
'panzehir',
'papatya',
'papyon',
'paraşüt',
'parça',
'pardösü',
'parfüm',
'parıltı',
'parkur',
'parmak',
'parodi',
'parsel',
'partner',
'pasaport',
'pasif',
'paskalya',
'pastırma',
'paşa',
'patates',
'paten',
'patika',
'patlıcan',
'patolog',
'patron',
'payanda',
'paydaş',
'payidar',
'paylaşma',
'paytak',
'peçete',
'pedal',
'peder',
'pehlivan',
'pekala',
'pekmez',
'pelerin',
'pelikan',
'pelüş',
'pembe',
'pena',
'pencere',
'pense',
'perçin',
'perde',
'pergel',
'perişan',
'peron',
'personel',
'perşembe',
'peruk',
'pervane',
'pespaye',
'pestil',
'peşin',
'petek',
'petrol',
'petunya',
'peynir',
'peyzaj',
'pınar',
'pırasa',
'pırlanta',
'pide',
'pikap',
'piknik',
'pilav',
'piliç',
'pilot',
'pipet',
'pipo',
'piramit',
'pirinç',
'pirzola',
'pist',
'pişik',
'pişman',
'piyasa',
'piyes',
'plaj',
'plaket',
'planlama',
'platform',
'plazma',
'podyum',
'poğaça',
'polat',
'polen',
'politika',
'pompa',
'popüler',
'porselen',
'portakal',
'posa',
'poster',
'poşet',
'poyraz',
'pozitif',
'pranga',
'pratik',
'prenses',
'prim',
'problem',
'profil',
'program',
'proje',
'protokol',
'prova',
'puan',
'pudra',
'pusula',
'püre',
'pürüz',
'püstül',
'püsür',
'racon',
'radar',
'radikal',
'radyo',
'rafadan',
'rafine',
'rağbet',
'rahat',
'rahle',
'rakam',
'raket',
'rakip',
'rakun',
'ralli',
'rampa',
'randevu',
'ranza',
'rapor',
'rastgele',
'rasyonel',
'razı',
'realite',
'reçine',
'refah',
'referans',
'refik',
'reform',
'rehber',
'rehin',
'reis',
'rekabet',
'reklam',
'rekor',
'rektör',
'renk',
'resim',
'resmen',
'restoran',
'retorik',
'revaç',
'revize',
'reyon',
'rezalet',
'rezerv',
'rezil',
'rıhtım',
'rıza',
'ritim',
'ritüel',
'rivayet',
'robot',
'roman',
'rota',
'rozet',
'röportaj',
'rötar',
'ruble',
'ruhban',
'ruhsat',
'rulet',
'rulo',
'runik',
'rutin',
'rutubet',
'rüşvet',
'rütbe',
'rüya',
'rüzgar',
'sabah',
'sabıka',
'sabit',
'sabun',
'saçma',
'sade',
'sadık',
'safahat',
'safdil',
'safkan',
'sağanak',
'sağduyu',
'sağlam',
'saha',
'sahiden',
'sahne',
'sakal',
'sakız',
'sakin',
'saklama',
'saksağan',
'salamura',
'salça',
'salgı',
'salınım',
'salkım',
'salon',
'saltanat',
'sanatçı',
'sancak',
'sandalye',
'saniye',
'saplantı',
'sapsız',
'saray',
'sarışın',
'sarkık',
'sarmaşık',
'satır',
'savaşım',
'savunma',
'saydam',
'sayfa',
'saygın',
'sayısal',
'sebep',
'seçenek',
'seçim',
'seçkin',
'seçmen',
'seda',
'sedir',
'sedye',
'sefer',
'sehpa',
'sekizgen',
'selektör',
'selvi',
'semavi',
'sembol',
'seminer',
'senaryo',
'sendika',
'senkron',
'sensör',
'sentez',
'sepet',
'seramik',
'serbest',
'serdar',
'seremoni',
'sergi',
'serhat',
'serin',
'sermaye',
'serpuş',
'sersem',
'serüven',
'servis',
'sesli',
'sesteş',
'sevap',
'seviye',
'seyahat',
'seyirci',
'sezon',
'sıcak',
'sıfat',
'sıhhi',
'sınanma',
'sınır',
'sıradan',
'sırdaş',
'sırma',
'sırtüstü',
'sızgıt',
'siftah',
'sigorta',
'sihirbaz',
'silah',
'silecek',
'silindir',
'simetri',
'simge',
'simit',
'sincap',
'sindirim',
'sinema',
'sinirli',
'sipariş',
'sirke',
'siroz',
'sistem',
'sivilce',
'siyasi',
'slogan',
'soba',
'sofra',
'soğuk',
'sohbet',
'sokak',
'solfej',
'solunum',
'somut',
'sonbahar',
'sonraki',
'sonsuz',
'sorunsuz',
'sosyete',
'soyağacı',
'soydaş',
'soygun',
'soytarı',
'söğüş',
'sömürge',
'sönük',
'söylem',
'sözcük',
'sözde',
'spatula',
'spektrum',
'spiker',
'spiral',
'sponsor',
'sporcu',
'sprey',
'stabil',
'statü',
'stok',
'stopaj',
'strateji',
'subay',
'sucuk',
'suçüstü',
'suhulet',
'sulama',
'sungur',
'sunucu',
'surat',
'susam',
'suskun',
'sükse',
'sükut',
'sülale',
'sünger',
'süpürge',
'sürahi',
'süreç',
'sürgün',
'sürüm',
'süsleme',
'sütanne',
'sütlaç',
'sütun',
'süvari',
'şahane',
'şahbaz',
'şahit',
'şahsiyet',
'şakıma',
'şaklaban',
'şakrak',
'şamar',
'şampiyon',
'şanslı',
'şantiye',
'şapka',
'şarkıcı',
'şartname',
'şaşırma',
'şaşkın',
'şatafat',
'şayet',
'şebeke',
'şefkat',
'şeftali',
'şehir',
'şehvet',
'şeker',
'şekil',
'şelale',
'şema',
'şemsiye',
'şerbet',
'şeref',
'şerit',
'şımarık',
'şıpıdık',
'şifre',
'şimdi',
'şimşek',
'şipşak',
'şirin',
'şişe',
'şişirme',
'şofben',
'şöhret',
'şölen',
'şüphe',
'tabaka',
'tabela',
'tabure',
'tadilat',
'taharet',
'tahıl',
'tahkim',
'tahlil',
'tahmin',
'tahrifat',
'tahsilat',
'tahta',
'taklit',
'takoz',
'taksici',
'taktik',
'takvim',
'talebe',
'talip',
'tamamen',
'tamirci',
'tampon',
'tamtakır',
'tandır',
'tanecik',
'tanıtım',
'tanrı',
'tansiyon',
'tapan',
'tapınak',
'taptaze',
'tapu',
'tarafgir',
'tarhana',
'tarım',
'tarih',
'tarla',
'tartak',
'tarumar',
'tasarım',
'tasdik',
'taslak',
'tastamam',
'taşeron',
'taşınmaz',
'taşra',
'tatava',
'tatbikat',
'tatil',
'tatlı',
'tavsiye',
'tavşan',
'tavuk',
'taze',
'taziye',
'tazminat',
'tebeşir',
'tebrik',
'tecrübe',
'teçhizat',
'tedarik',
'tedbir',
'teftiş',
'teğet',
'teğmen',
'tehdit',
'tehlike',
'tekdüze',
'tekerlek',
'tekme',
'teknik',
'tekrar',
'telef',
'telsiz',
'telve',
'temas',
'tembel',
'temiz',
'temkin',
'tempo',
'temsilci',
'tendon',
'teneke',
'tenha',
'tenkit',
'tepegöz',
'tepki',
'terazi',
'terbiye',
'tercih',
'tereyağı',
'terfi',
'terim',
'terminal',
'tersane',
'tertip',
'tesadüf',
'tescil',
'tesir',
'teslimat',
'tespit',
'testere',
'teşekkür',
'teşhir',
'teşrif',
'teşvik',
'teyze',
'tezahür',
'tezgah',
'tıbbi',
'tıkaç',
'tıkışık',
'tıknaz',
'tılsım',
'tıpkı',
'tıraş',
'tırışka',
'tırmanış',
'tırnak',
'tırpan',
'tıslama',
'ticaret',
'tilki',
'tiryaki',
'titreşim',
'tohum',
'tokat',
'tolere',
'tomar',
'tombak',
'tomurcuk',
'topaç',
'toplum',
'toprak',
'toptan',
'toraman',
'torpido',
'tortu',
'tosbağa',
'toynak',
'tören',
'trafik',
'trajedi',
'tramvay',
'transfer',
'tribün',
'triko',
'tugay',
'tuğla',
'tuğrul',
'tuhaf',
'tulumba',
'tunç',
'turan',
'turkuaz',
'turnusol',
'turşu',
'turuncu',
'tutanak',
'tutkal',
'tutsak',
'tutum',
'tuyuğ',
'tuzlu',
'tüccar',
'tüfek',
'tükenmez',
'tülbent',
'tümleç',
'tünel',
'türbin',
'türev',
'türk',
'tüzük',
'ucube',
'ucuz',
'uçak',
'uçurtma',
'ufuk',
'uğrak',
'uğur',
'ukala',
'ulaşım',
'ulema',
'ulus',
'ulvi',
'umursama',
'umut',
'unutkan',
'uslu',
'ustabaşı',
'ustura',
'usul',
'utangaç',
'uyanık',
'uyarı',
'uydu',
'uygar',
'uygulama',
'uykusuz',
'uysal',
'uyuşma',
'uzantı',
'uzay',
'uzgören',
'uzlaşma',
'uzman',
'uzun',
'ücra',
'ücret',
'üçbudak',
'üçgen',
'üçkağıt',
'üçleme',
'üfürük',
'ülke',
'ümit',
'üniforma',
'ünite',
'ünlem',
'üretken',
'ürün',
'üslup',
'üstel',
'üstün',
'üşengeç',
'üşüme',
'ütopya',
'üvey',
'üzengi',
'üzgün',
'üzüm',
'vagon',
'vaka',
'vakfiye',
'vakıf',
'vakit',
'vakum',
'vapur',
'varil',
'varlık',
'varsayım',
'varyemez',
'vasıta',
'vasiyet',
'vatandaş',
'vazife',
'vazo',
'veciz',
'vefa',
'vehim',
'veliaht',
'veresiye',
'verimli',
'verkaç',
'vernik',
'vertigo',
'vesait',
'vesika',
'vestiyer',
'veznedar',
'vicdan',
'vilayet',
'virane',
'virgül',
'vişne',
'vites',
'vokal',
'volkan',
'vurma',
'vurucu',
'vücut',
'yabancı',
'yabgu',
'yağış',
'yağlı',
'yağmur',
'yakamoz',
'yakın',
'yaklaşık',
'yalçın',
'yalıtım',
'yaman',
'yanardağ',
'yangın',
'yanıt',
'yankı',
'yanlış',
'yansıma',
'yapay',
'yapboz',
'yapımcı',
'yaprak',
'yaratık',
'yarbay',
'yardım',
'yargıç',
'yarıçap',
'yasemin',
'yastık',
'yaşam',
'yatak',
'yatırım',
'yavru',
'yaygara',
'yayıncı',
'yayla',
'yazılım',
'yekpare',
'yekvücut',
'yelkovan',
'yelpaze',
'yemek',
'yemiş',
'yengeç',
'yeniçeri',
'yeraltı',
'yerküre',
'yerleşke',
'yeryüzü',
'yeşil',
'yetenek',
'yetkili',
'yığınak',
'yıkama',
'yılbaşı',
'yıldırım',
'yılkı',
'yılmaz',
'yırtıcı',
'yiğit',
'yoğurt',
'yokuş',
'yolcu',
'yoldaş',
'yolgeçen',
'yolkesen',
'yolüstü',
'yordam',
'yorgan',
'yorumcu',
'yosun',
'yöndeş',
'yönetim',
'yönlü',
'yöntem',
'yöresel',
'yörünge',
'yufka',
'yukarı',
'yumruk',
'yumurta',
'yuvarlak',
'yücelme',
'yükçeker',
'yüklem',
'yüksek',
'yürek',
'yürütme',
'yüzde',
'yüzeysel',
'yüzgeç',
'yüzüstü',
'yüzyıl',
'zabıta',
'zafer',
'zahmet',
'zambak',
'zaptiye',
'zarafet',
'zaruret',
'zeka',
'zekice',
'zemberek',
'zemin',
'zencefil',
'zeplin',
'zeytin',
'zıbın',
'zılgıt',
'zımbırtı',
'zımpara',
'zıpkın',
'zigon',
'zihinsel',
'zihniyet',
'zincir',
'zindan',
'zirzop',
'ziyaret',
'ziynet',
'zoraki',
'zorlu',
'zorunlu',
'züğürt',
'zümre'
];
// SPDX-License-Identifier: MIT
const BIP39_MNEMONIC_WORDS = {
TWELVE: 12,
FIFTEEN: 15,
EIGHTEEN: 18,
TWENTY_ONE: 21,
TWENTY_FOUR: 24
};
const BIP39_MNEMONIC_LANGUAGES = {
CHINESE_SIMPLIFIED: 'chinese-simplified',
CHINESE_TRADITIONAL: 'chinese-traditional',
CZECH: 'czech',
ENGLISH: 'english',
FRENCH: 'french',
ITALIAN: 'italian',
JAPANESE: 'japanese',
KOREAN: 'korean',
PORTUGUESE: 'portuguese',
RUSSIAN: 'russian',
SPANISH: 'spanish',
TURKISH: 'turkish'
};
class BIP39Mnemonic extends Mnemonic {
static wordBitLength = 11;
static wordsListNumber = 2048;
static wordsList = [
BIP39_MNEMONIC_WORDS.TWELVE,
BIP39_MNEMONIC_WORDS.FIFTEEN,
BIP39_MNEMONIC_WORDS.EIGHTEEN,
BIP39_MNEMONIC_WORDS.TWENTY_ONE,
BIP39_MNEMONIC_WORDS.TWENTY_FOUR
];
static wordsToEntropyStrength = {
12: BIP39_ENTROPY_STRENGTHS.ONE_HUNDRED_TWENTY_EIGHT,
15: BIP39_ENTROPY_STRENGTHS.ONE_HUNDRED_SIXTY,
18: BIP39_ENTROPY_STRENGTHS.ONE_HUNDRED_NINETY_TWO,
21: BIP39_ENTROPY_STRENGTHS.TWO_HUNDRED_TWENTY_FOUR,
24: BIP39_ENTROPY_STRENGTHS.TWO_HUNDRED_FIFTY_SIX
};
static languages = Object.values(BIP39_MNEMONIC_LANGUAGES);
static wordLists = {
[BIP39_MNEMONIC_LANGUAGES.CHINESE_SIMPLIFIED]: WORDLIST$q,
[BIP39_MNEMONIC_LANGUAGES.CHINESE_TRADITIONAL]: WORDLIST$p,
[BIP39_MNEMONIC_LANGUAGES.CZECH]: WORDLIST$o,
[BIP39_MNEMONIC_LANGUAGES.ENGLISH]: WORDLIST$n,
[BIP39_MNEMONIC_LANGUAGES.FRENCH]: WORDLIST$m,
[BIP39_MNEMONIC_LANGUAGES.ITALIAN]: WORDLIST$l,
[BIP39_MNEMONIC_LANGUAGES.JAPANESE]: WORDLIST$k,
[BIP39_MNEMONIC_LANGUAGES.KOREAN]: WORDLIST$j,
[BIP39_MNEMONIC_LANGUAGES.PORTUGUESE]: WORDLIST$i,
[BIP39_MNEMONIC_LANGUAGES.RUSSIAN]: WORDLIST$h,
[BIP39_MNEMONIC_LANGUAGES.SPANISH]: WORDLIST$g,
[BIP39_MNEMONIC_LANGUAGES.TURKISH]: WORDLIST$f
};
static getName() {
return 'BIP39';
}
static fromWords(words, language, options = {}) {
if (!this.wordsList.includes(words)) {
throw new MnemonicError(`Invalid words`, { expected: this.wordsList, got: words });
}
const strength = this.wordsToEntropyStrength[words];
const entropyHex = BIP39Entropy.generate(strength);
return this.encode(entropyHex, language, options);
}
static fromEntropy(entropy, language, options = {}) {
let hex;
if (typeof entropy === 'string') {
hex = entropy;
}
else if (entropy instanceof Uint8Array) {
hex = bytesToHex(entropy);
}
else {
hex = entropy.getEntropy();
}
return this.encode(hex, language, options);
}
static encode(entropyInput, language, options = {}) {
const entropyBytes = typeof entropyInput === 'string' ?
hexToBytes(entropyInput) : entropyInput;
const bitLen = entropyBytes.length * 8;
if (!Object.values(this.wordsToEntropyStrength).includes(bitLen)) {
throw new EntropyError(`Unsupported entropy length ${bitLen}`);
}
const hash = sha256(entropyBytes);
const csLen = bitLen / 32;
const entBits = bytesToBinaryString(entropyBytes, bitLen);
const hashBits = bytesToBinaryString(hash, 256).slice(0, csLen);
const bits = entBits + hashBits;
const wordList = this.getWordsListByLanguage(language, this.wordLists);
if (wordList.length !== this.wordsListNumber) {
throw new Error(`Loaded wordlist length ${wordList.length} !== ${this.wordsListNumber}`);
}
const words = [];
for (let i = 0; i < bits.length / this.wordBitLength; i++) {
const idx = parseInt(bits.slice(i * this.wordBitLength, (i + 1) * this.wordBitLength), 2);
words.push(wordList[idx]);
}
return words.join(' ');
}
static decode(mnemonic, options = { checksum: false }) {
const words = this.normalize(mnemonic);
if (!this.wordsList.includes(words.length)) {
throw new MnemonicError(`Invalid words ${words.length}`, { expected: this.wordsList, got: words.length });
}
let wordList;
let idxMap = {};
if (options.wordsList && options.wordsListWithIndex) {
idxMap = options.wordsListWithIndex;
}
else {
[wordList] = this.findLanguage(words, this.wordLists);
wordList.forEach((w, i) => idxMap[w] = i);
}
const bits = words
.map(w => {
const idx = idxMap[w];
if (idx === undefined) {
throw new MnemonicError(`Unknown word: ${w}`);
}
return integerToBinaryString(idx, this.wordBitLength);
})
.join('');
const checksumLen = bits.length / 33;
const entropyBits = bits.slice(0, -checksumLen);
const givenChecksum = bits.slice(-checksumLen);
const entropyBytes = binaryStringToBytes(entropyBits);
const hash = sha256(entropyBytes);
const hashBits = bytesToBinaryString(hash, 256).slice(0, checksumLen);
if (givenChecksum !== hashBits) {
throw new ChecksumError('Checksum mismatch', { expected: givenChecksum, got: hashBits });
}
if (options.checksum) {
const totalBits = bits.length;
const padBits = totalBits % 8 === 0
? totalBits
: totalBits + (8 - (totalBits % 8));
return bytesToHex(binaryStringToBytes(bits, padBits / 8));
}
return bytesToHex(entropyBytes);
}
static normalize(input) {
const arr = typeof input === 'string' ? input.trim().split(/\s+/) : input;
return arr.map(w => w.normalize('NFKD').toLowerCase());
}
}
// SPDX-License-Identifier: MIT
const WORDLIST$e = [
'like',
'just',
'love',
'know',
'never',
'want',
'time',
'out',
'there',
'make',
'look',
'eye',
'down',
'only',
'think',
'heart',
'back',
'then',
'into',
'about',
'more',
'away',
'still',
'them',
'take',
'thing',
'even',
'through',
'long',
'always',
'world',
'too',
'friend',
'tell',
'try',
'hand',
'thought',
'over',
'here',
'other',
'need',
'smile',
'again',
'much',
'cry',
'been',
'night',
'ever',
'little',
'said',
'end',
'some',
'those',
'around',
'mind',
'people',
'girl',
'leave',
'dream',
'left',
'turn',
'myself',
'give',
'nothing',
'really',
'off',
'before',
'something',
'find',
'walk',
'wish',
'good',
'once',
'place',
'ask',
'stop',
'keep',
'watch',
'seem',
'everything',
'wait',
'got',
'yet',
'made',
'remember',
'start',
'alone',
'run',
'hope',
'maybe',
'believe',
'body',
'hate',
'after',
'close',
'talk',
'stand',
'own',
'each',
'hurt',
'help',
'home',
'god',
'soul',
'new',
'many',
'two',
'inside',
'should',
'true',
'first',
'fear',
'mean',
'better',
'play',
'another',
'gone',
'change',
'use',
'wonder',
'someone',
'hair',
'cold',
'open',
'best',
'any',
'behind',
'happen',
'water',
'dark',
'laugh',
'stay',
'forever',
'name',
'work',
'show',
'sky',
'break',
'came',
'deep',
'door',
'put',
'black',
'together',
'upon',
'happy',
'such',
'great',
'white',
'matter',
'fill',
'past',
'please',
'burn',
'cause',
'enough',
'touch',
'moment',
'soon',
'voice',
'scream',
'anything',
'stare',
'sound',
'red',
'everyone',
'hide',
'kiss',
'truth',
'death',
'beautiful',
'mine',
'blood',
'broken',
'very',
'pass',
'next',
'forget',
'tree',
'wrong',
'air',
'mother',
'understand',
'lip',
'hit',
'wall',
'memory',
'sleep',
'free',
'high',
'realize',
'school',
'might',
'skin',
'sweet',
'perfect',
'blue',
'kill',
'breath',
'dance',
'against',
'fly',
'between',
'grow',
'strong',
'under',
'listen',
'bring',
'sometimes',
'speak',
'pull',
'person',
'become',
'family',
'begin',
'ground',
'real',
'small',
'father',
'sure',
'feet',
'rest',
'young',
'finally',
'land',
'across',
'today',
'different',
'guy',
'line',
'fire',
'reason',
'reach',
'second',
'slowly',
'write',
'eat',
'smell',
'mouth',
'step',
'learn',
'three',
'floor',
'promise',
'breathe',
'darkness',
'push',
'earth',
'guess',
'save',
'song',
'above',
'along',
'both',
'color',
'house',
'almost',
'sorry',
'anymore',
'brother',
'okay',
'dear',
'game',
'fade',
'already',
'apart',
'warm',
'beauty',
'heard',
'notice',
'question',
'shine',
'began',
'piece',
'whole',
'shadow',
'secret',
'street',
'within',
'finger',
'point',
'morning',
'whisper',
'child',
'moon',
'green',
'story',
'glass',
'kid',
'silence',
'since',
'soft',
'yourself',
'empty',
'shall',
'angel',
'answer',
'baby',
'bright',
'dad',
'path',
'worry',
'hour',
'drop',
'follow',
'power',
'war',
'half',
'flow',
'heaven',
'act',
'chance',
'fact',
'least',
'tired',
'children',
'near',
'quite',
'afraid',
'rise',
'sea',
'taste',
'window',
'cover',
'nice',
'trust',
'lot',
'sad',
'cool',
'force',
'peace',
'return',
'blind',
'easy',
'ready',
'roll',
'rose',
'drive',
'held',
'music',
'beneath',
'hang',
'mom',
'paint',
'emotion',
'quiet',
'clear',
'cloud',
'few',
'pretty',
'bird',
'outside',
'paper',
'picture',
'front',
'rock',
'simple',
'anyone',
'meant',
'reality',
'road',
'sense',
'waste',
'bit',
'leaf',
'thank',
'happiness',
'meet',
'men',
'smoke',
'truly',
'decide',
'self',
'age',
'book',
'form',
'alive',
'carry',
'escape',
'damn',
'instead',
'able',
'ice',
'minute',
'throw',
'catch',
'leg',
'ring',
'course',
'goodbye',
'lead',
'poem',
'sick',
'corner',
'desire',
'known',
'problem',
'remind',
'shoulder',
'suppose',
'toward',
'wave',
'drink',
'jump',
'woman',
'pretend',
'sister',
'week',
'human',
'joy',
'crack',
'grey',
'pray',
'surprise',
'dry',
'knee',
'less',
'search',
'bleed',
'caught',
'clean',
'embrace',
'future',
'king',
'son',
'sorrow',
'chest',
'hug',
'remain',
'sat',
'worth',
'blow',
'daddy',
'final',
'parent',
'tight',
'also',
'create',
'lonely',
'safe',
'cross',
'dress',
'evil',
'silent',
'bone',
'fate',
'perhaps',
'anger',
'class',
'scar',
'snow',
'tiny',
'tonight',
'continue',
'control',
'dog',
'edge',
'mirror',
'month',
'suddenly',
'comfort',
'given',
'loud',
'quickly',
'gaze',
'plan',
'rush',
'stone',
'town',
'battle',
'ignore',
'spirit',
'stood',
'stupid',
'yours',
'brown',
'build',
'dust',
'hey',
'kept',
'pay',
'phone',
'twist',
'although',
'ball',
'beyond',
'hidden',
'nose',
'taken',
'fail',
'float',
'pure',
'somehow',
'wash',
'wrap',
'angry',
'cheek',
'creature',
'forgotten',
'heat',
'rip',
'single',
'space',
'special',
'weak',
'whatever',
'yell',
'anyway',
'blame',
'job',
'choose',
'country',
'curse',
'drift',
'echo',
'figure',
'grew',
'laughter',
'neck',
'suffer',
'worse',
'yeah',
'disappear',
'foot',
'forward',
'knife',
'mess',
'somewhere',
'stomach',
'storm',
'beg',
'idea',
'lift',
'offer',
'breeze',
'field',
'five',
'often',
'simply',
'stuck',
'win',
'allow',
'confuse',
'enjoy',
'except',
'flower',
'seek',
'strength',
'calm',
'grin',
'gun',
'heavy',
'hill',
'large',
'ocean',
'shoe',
'sigh',
'straight',
'summer',
'tongue',
'accept',
'crazy',
'everyday',
'exist',
'grass',
'mistake',
'sent',
'shut',
'surround',
'table',
'ache',
'brain',
'destroy',
'heal',
'nature',
'shout',
'sign',
'stain',
'choice',
'doubt',
'glance',
'glow',
'mountain',
'queen',
'stranger',
'throat',
'tomorrow',
'city',
'either',
'fish',
'flame',
'rather',
'shape',
'spin',
'spread',
'ash',
'distance',
'finish',
'image',
'imagine',
'important',
'nobody',
'shatter',
'warmth',
'became',
'feed',
'flesh',
'funny',
'lust',
'shirt',
'trouble',
'yellow',
'attention',
'bare',
'bite',
'money',
'protect',
'amaze',
'appear',
'born',
'choke',
'completely',
'daughter',
'fresh',
'friendship',
'gentle',
'probably',
'six',
'deserve',
'expect',
'grab',
'middle',
'nightmare',
'river',
'thousand',
'weight',
'worst',
'wound',
'barely',
'bottle',
'cream',
'regret',
'relationship',
'stick',
'test',
'crush',
'endless',
'fault',
'itself',
'rule',
'spill',
'art',
'circle',
'join',
'kick',
'mask',
'master',
'passion',
'quick',
'raise',
'smooth',
'unless',
'wander',
'actually',
'broke',
'chair',
'deal',
'favorite',
'gift',
'note',
'number',
'sweat',
'box',
'chill',
'clothes',
'lady',
'mark',
'park',
'poor',
'sadness',
'tie',
'animal',
'belong',
'brush',
'consume',
'dawn',
'forest',
'innocent',
'pen',
'pride',
'stream',
'thick',
'clay',
'complete',
'count',
'draw',
'faith',
'press',
'silver',
'struggle',
'surface',
'taught',
'teach',
'wet',
'bless',
'chase',
'climb',
'enter',
'letter',
'melt',
'metal',
'movie',
'stretch',
'swing',
'vision',
'wife',
'beside',
'crash',
'forgot',
'guide',
'haunt',
'joke',
'knock',
'plant',
'pour',
'prove',
'reveal',
'steal',
'stuff',
'trip',
'wood',
'wrist',
'bother',
'bottom',
'crawl',
'crowd',
'fix',
'forgive',
'frown',
'grace',
'loose',
'lucky',
'party',
'release',
'surely',
'survive',
'teacher',
'gently',
'grip',
'speed',
'suicide',
'travel',
'treat',
'vein',
'written',
'cage',
'chain',
'conversation',
'date',
'enemy',
'however',
'interest',
'million',
'page',
'pink',
'proud',
'sway',
'themselves',
'winter',
'church',
'cruel',
'cup',
'demon',
'experience',
'freedom',
'pair',
'pop',
'purpose',
'respect',
'shoot',
'softly',
'state',
'strange',
'bar',
'birth',
'curl',
'dirt',
'excuse',
'lord',
'lovely',
'monster',
'order',
'pack',
'pants',
'pool',
'scene',
'seven',
'shame',
'slide',
'ugly',
'among',
'blade',
'blonde',
'closet',
'creek',
'deny',
'drug',
'eternity',
'gain',
'grade',
'handle',
'key',
'linger',
'pale',
'prepare',
'swallow',
'swim',
'tremble',
'wheel',
'won',
'cast',
'cigarette',
'claim',
'college',
'direction',
'dirty',
'gather',
'ghost',
'hundred',
'loss',
'lung',
'orange',
'present',
'swear',
'swirl',
'twice',
'wild',
'bitter',
'blanket',
'doctor',
'everywhere',
'flash',
'grown',
'knowledge',
'numb',
'pressure',
'radio',
'repeat',
'ruin',
'spend',
'unknown',
'buy',
'clock',
'devil',
'early',
'false',
'fantasy',
'pound',
'precious',
'refuse',
'sheet',
'teeth',
'welcome',
'add',
'ahead',
'block',
'bury',
'caress',
'content',
'depth',
'despite',
'distant',
'marry',
'purple',
'threw',
'whenever',
'bomb',
'dull',
'easily',
'grasp',
'hospital',
'innocence',
'normal',
'receive',
'reply',
'rhyme',
'shade',
'someday',
'sword',
'toe',
'visit',
'asleep',
'bought',
'center',
'consider',
'flat',
'hero',
'history',
'ink',
'insane',
'muscle',
'mystery',
'pocket',
'reflection',
'shove',
'silently',
'smart',
'soldier',
'spot',
'stress',
'train',
'type',
'view',
'whether',
'bus',
'energy',
'explain',
'holy',
'hunger',
'inch',
'magic',
'mix',
'noise',
'nowhere',
'prayer',
'presence',
'shock',
'snap',
'spider',
'study',
'thunder',
'trail',
'admit',
'agree',
'bag',
'bang',
'bound',
'butterfly',
'cute',
'exactly',
'explode',
'familiar',
'fold',
'further',
'pierce',
'reflect',
'scent',
'selfish',
'sharp',
'sink',
'spring',
'stumble',
'universe',
'weep',
'women',
'wonderful',
'action',
'ancient',
'attempt',
'avoid',
'birthday',
'branch',
'chocolate',
'core',
'depress',
'drunk',
'especially',
'focus',
'fruit',
'honest',
'match',
'palm',
'perfectly',
'pillow',
'pity',
'poison',
'roar',
'shift',
'slightly',
'thump',
'truck',
'tune',
'twenty',
'unable',
'wipe',
'wrote',
'coat',
'constant',
'dinner',
'drove',
'egg',
'eternal',
'flight',
'flood',
'frame',
'freak',
'gasp',
'glad',
'hollow',
'motion',
'peer',
'plastic',
'root',
'screen',
'season',
'sting',
'strike',
'team',
'unlike',
'victim',
'volume',
'warn',
'weird',
'attack',
'await',
'awake',
'built',
'charm',
'crave',
'despair',
'fought',
'grant',
'grief',
'horse',
'limit',
'message',
'ripple',
'sanity',
'scatter',
'serve',
'split',
'string',
'trick',
'annoy',
'blur',
'boat',
'brave',
'clearly',
'cling',
'connect',
'fist',
'forth',
'imagination',
'iron',
'jock',
'judge',
'lesson',
'milk',
'misery',
'nail',
'naked',
'ourselves',
'poet',
'possible',
'princess',
'sail',
'size',
'snake',
'society',
'stroke',
'torture',
'toss',
'trace',
'wise',
'bloom',
'bullet',
'cell',
'check',
'cost',
'darling',
'during',
'footstep',
'fragile',
'hallway',
'hardly',
'horizon',
'invisible',
'journey',
'midnight',
'mud',
'nod',
'pause',
'relax',
'shiver',
'sudden',
'value',
'youth',
'abuse',
'admire',
'blink',
'breast',
'bruise',
'constantly',
'couple',
'creep',
'curve',
'difference',
'dumb',
'emptiness',
'gotta',
'honor',
'plain',
'planet',
'recall',
'rub',
'ship',
'slam',
'soar',
'somebody',
'tightly',
'weather',
'adore',
'approach',
'bond',
'bread',
'burst',
'candle',
'coffee',
'cousin',
'crime',
'desert',
'flutter',
'frozen',
'grand',
'heel',
'hello',
'language',
'level',
'movement',
'pleasure',
'powerful',
'random',
'rhythm',
'settle',
'silly',
'slap',
'sort',
'spoken',
'steel',
'threaten',
'tumble',
'upset',
'aside',
'awkward',
'bee',
'blank',
'board',
'button',
'card',
'carefully',
'complain',
'crap',
'deeply',
'discover',
'drag',
'dread',
'effort',
'entire',
'fairy',
'giant',
'gotten',
'greet',
'illusion',
'jeans',
'leap',
'liquid',
'march',
'mend',
'nervous',
'nine',
'replace',
'rope',
'spine',
'stole',
'terror',
'accident',
'apple',
'balance',
'boom',
'childhood',
'collect',
'demand',
'depression',
'eventually',
'faint',
'glare',
'goal',
'group',
'honey',
'kitchen',
'laid',
'limb',
'machine',
'mere',
'mold',
'murder',
'nerve',
'painful',
'poetry',
'prince',
'rabbit',
'shelter',
'shore',
'shower',
'soothe',
'stair',
'steady',
'sunlight',
'tangle',
'tease',
'treasure',
'uncle',
'begun',
'bliss',
'canvas',
'cheer',
'claw',
'clutch',
'commit',
'crimson',
'crystal',
'delight',
'doll',
'existence',
'express',
'fog',
'football',
'gay',
'goose',
'guard',
'hatred',
'illuminate',
'mass',
'math',
'mourn',
'rich',
'rough',
'skip',
'stir',
'student',
'style',
'support',
'thorn',
'tough',
'yard',
'yearn',
'yesterday',
'advice',
'appreciate',
'autumn',
'bank',
'beam',
'bowl',
'capture',
'carve',
'collapse',
'confusion',
'creation',
'dove',
'feather',
'girlfriend',
'glory',
'government',
'harsh',
'hop',
'inner',
'loser',
'moonlight',
'neighbor',
'neither',
'peach',
'pig',
'praise',
'screw',
'shield',
'shimmer',
'sneak',
'stab',
'subject',
'throughout',
'thrown',
'tower',
'twirl',
'wow',
'army',
'arrive',
'bathroom',
'bump',
'cease',
'cookie',
'couch',
'courage',
'dim',
'guilt',
'howl',
'hum',
'husband',
'insult',
'led',
'lunch',
'mock',
'mostly',
'natural',
'nearly',
'needle',
'nerd',
'peaceful',
'perfection',
'pile',
'price',
'remove',
'roam',
'sanctuary',
'serious',
'shiny',
'shook',
'sob',
'stolen',
'tap',
'vain',
'void',
'warrior',
'wrinkle',
'affection',
'apologize',
'blossom',
'bounce',
'bridge',
'cheap',
'crumble',
'decision',
'descend',
'desperately',
'dig',
'dot',
'flip',
'frighten',
'heartbeat',
'huge',
'lazy',
'lick',
'odd',
'opinion',
'process',
'puzzle',
'quietly',
'retreat',
'score',
'sentence',
'separate',
'situation',
'skill',
'soak',
'square',
'stray',
'taint',
'task',
'tide',
'underneath',
'veil',
'whistle',
'anywhere',
'bedroom',
'bid',
'bloody',
'burden',
'careful',
'compare',
'concern',
'curtain',
'decay',
'defeat',
'describe',
'double',
'dreamer',
'driver',
'dwell',
'evening',
'flare',
'flicker',
'grandma',
'guitar',
'harm',
'horrible',
'hungry',
'indeed',
'lace',
'melody',
'monkey',
'nation',
'object',
'obviously',
'rainbow',
'salt',
'scratch',
'shown',
'shy',
'stage',
'stun',
'third',
'tickle',
'useless',
'weakness',
'worship',
'worthless',
'afternoon',
'beard',
'boyfriend',
'bubble',
'busy',
'certain',
'chin',
'concrete',
'desk',
'diamond',
'doom',
'drawn',
'due',
'felicity',
'freeze',
'frost',
'garden',
'glide',
'harmony',
'hopefully',
'hunt',
'jealous',
'lightning',
'mama',
'mercy',
'peel',
'physical',
'position',
'pulse',
'punch',
'quit',
'rant',
'respond',
'salty',
'sane',
'satisfy',
'savior',
'sheep',
'slept',
'social',
'sport',
'tuck',
'utter',
'valley',
'wolf',
'aim',
'alas',
'alter',
'arrow',
'awaken',
'beaten',
'belief',
'brand',
'ceiling',
'cheese',
'clue',
'confidence',
'connection',
'daily',
'disguise',
'eager',
'erase',
'essence',
'everytime',
'expression',
'fan',
'flag',
'flirt',
'foul',
'fur',
'giggle',
'glorious',
'ignorance',
'law',
'lifeless',
'measure',
'mighty',
'muse',
'north',
'opposite',
'paradise',
'patience',
'patient',
'pencil',
'petal',
'plate',
'ponder',
'possibly',
'practice',
'slice',
'spell',
'stock',
'strife',
'strip',
'suffocate',
'suit',
'tender',
'tool',
'trade',
'velvet',
'verse',
'waist',
'witch',
'aunt',
'bench',
'bold',
'cap',
'certainly',
'click',
'companion',
'creator',
'dart',
'delicate',
'determine',
'dish',
'dragon',
'drama',
'drum',
'dude',
'everybody',
'feast',
'forehead',
'former',
'fright',
'fully',
'gas',
'hook',
'hurl',
'invite',
'juice',
'manage',
'moral',
'possess',
'raw',
'rebel',
'royal',
'scale',
'scary',
'several',
'slight',
'stubborn',
'swell',
'talent',
'tea',
'terrible',
'thread',
'torment',
'trickle',
'usually',
'vast',
'violence',
'weave',
'acid',
'agony',
'ashamed',
'awe',
'belly',
'blend',
'blush',
'character',
'cheat',
'common',
'company',
'coward',
'creak',
'danger',
'deadly',
'defense',
'define',
'depend',
'desperate',
'destination',
'dew',
'duck',
'dusty',
'embarrass',
'engine',
'example',
'explore',
'foe',
'freely',
'frustrate',
'generation',
'glove',
'guilty',
'health',
'hurry',
'idiot',
'impossible',
'inhale',
'jaw',
'kingdom',
'mention',
'mist',
'moan',
'mumble',
'mutter',
'observe',
'ode',
'pathetic',
'pattern',
'pie',
'prefer',
'puff',
'rape',
'rare',
'revenge',
'rude',
'scrape',
'spiral',
'squeeze',
'strain',
'sunset',
'suspend',
'sympathy',
'thigh',
'throne',
'total',
'unseen',
'weapon',
'weary'
];
// SPDX-License-Identifier: MIT
const ELECTRUM_V1_MNEMONIC_WORDS = {
TWELVE: 12,
};
const ELECTRUM_V1_MNEMONIC_LANGUAGES = {
ENGLISH: 'english'
};
class ElectrumV1Mnemonic extends Mnemonic {
static wordsListNumber = 1626;
static wordsList = [
ELECTRUM_V1_MNEMONIC_WORDS.TWELVE,
];
static wordsToStrength = {
[ELECTRUM_V1_MNEMONIC_WORDS.TWELVE]: ELECTRUM_V1_ENTROPY_STRENGTHS.ONE_HUNDRED_TWENTY_EIGHT,
};
static languages = Object.values(ELECTRUM_V1_MNEMONIC_LANGUAGES);
static wordLists = {
[ELECTRUM_V1_MNEMONIC_LANGUAGES.ENGLISH]: WORDLIST$e
};
static getName() {
return 'Electrum-V1';
}
static fromWords(count, language, options = {}) {
if (!this.wordsList.includes(count)) {
throw new MnemonicError('Invalid mnemonic words number', { expected: this.wordsList, got: count });
}
const entropy = ElectrumV1Entropy.generate(this.wordsToStrength[count]);
return this.encode(entropy, language, options);
}
static fromEntropy(entropy, language, options = {}) {
let raw;
if (typeof entropy === 'string') {
raw = hexToBytes(entropy);
}
else if (entropy instanceof Uint8Array) {
raw = entropy;
}
else {
raw = hexToBytes(entropy.getEntropy());
}
return this.encode(raw, language, options);
}
static encode(entropy, language, options = {}) {
const entropyBytes = getBytes(entropy);
if (!ElectrumV1Entropy.isValidBytesStrength(entropyBytes.length)) {
throw new EntropyError('Wrong entropy strength', { expected: ElectrumV1Entropy.strengths, got: entropyBytes.length * 8 });
}
const rawList = this.getWordsListByLanguage(language, this.wordLists);
const wordList = this.normalize(rawList);
const wl = wordList.length;
const mnemonic = [];
for (let i = 0; i < entropyBytes.length; i += 4) {
const chunkBytes = entropyBytes.slice(i, i + 4);
// big-endian → bigint → number
const chunkInt = Number(bytesToInteger(chunkBytes, false));
const w1 = chunkInt % wl;
const w2 = (Math.floor(chunkInt / wl) + w1) % wl;
const w3 = (Math.floor(chunkInt / wl / wl) + w2) % wl;
mnemonic.push(wordList[w1], wordList[w2], wordList[w3]);
}
return this.normalize(mnemonic).join(' ');
}
static decode(mnemonic, options = { checksum: false }) {
const words = this.normalize(mnemonic);
const count = words.length;
if (!this.wordsList.includes(count)) {
throw new MnemonicError('Invalid mnemonic words count', {
expected: this.wordsList,
got: count,
});
}
let wordsList;
let idxMap = {};
if (options.wordsList && options.wordsListWithIndex) {
wordsList = options.wordsList;
idxMap = options.wordsListWithIndex;
}
else {
[wordsList] = this.findLanguage(words, this.wordLists);
wordsList.forEach((w, i) => (idxMap[w] = i));
}
const wl = wordsList.length;
const bufs = [];
for (let i = 0; i < words.length; i += 3) {
const [w1, w2, w3] = words.slice(i, i + 3);
const i1 = idxMap[w1];
const i2 = idxMap[w2] % wl;
const i3 = idxMap[w3] % wl;
const chunkVal = i1 +
wl * ((i2 - i1 + wl) % wl) +
wl * wl * ((i3 - i2 + wl) % wl);
const chunkBytes = integerToBytes(chunkVal, 4, 'big');
bufs.push(getBytes(chunkBytes));
}
return bytesToHex(concatBytes(...bufs), false);
}
static isValid(input, options = {}) {
try {
this.decode(input, options);
return true;
}
catch {
return false;
}
}
static normalize(input) {
const arr = typeof input === 'string' ? input.trim().split(/\s+/) : input;
return arr.map(w => w.normalize('NFKD').toLowerCase());
}
}
// SPDX-License-Identifier: MIT
const WORDLIST$d = [
'的',
'一',
'是',
'在',
'不',
'了',
'有',
'和',
'人',
'这',
'中',
'大',
'为',
'上',
'个',
'国',
'我',
'以',
'要',
'他',
'时',
'来',
'用',
'们',
'生',
'到',
'作',
'地',
'于',
'出',
'就',
'分',
'对',
'成',
'会',
'可',
'主',
'发',
'年',
'动',
'同',
'工',
'也',
'能',
'下',
'过',
'子',
'说',
'产',
'种',
'面',
'而',
'方',
'后',
'多',
'定',
'行',
'学',
'法',
'所',
'民',
'得',
'经',
'十',
'三',
'之',
'进',
'着',
'等',
'部',
'度',
'家',
'电',
'力',
'里',
'如',
'水',
'化',
'高',
'自',
'二',
'理',
'起',
'小',
'物',
'现',
'实',
'加',
'量',
'都',
'两',
'体',
'制',
'机',
'当',
'使',
'点',
'从',
'业',
'本',
'去',
'把',
'性',
'好',
'应',
'开',
'它',
'合',
'还',
'因',
'由',
'其',
'些',
'然',
'前',
'外',
'天',
'政',
'四',
'日',
'那',
'社',
'义',
'事',
'平',
'形',
'相',
'全',
'表',
'间',
'样',
'与',
'关',
'各',
'重',
'新',
'线',
'内',
'数',
'正',
'心',
'反',
'你',
'明',
'看',
'原',
'又',
'么',
'利',
'比',
'或',
'但',
'质',
'气',
'第',
'向',
'道',
'命',
'此',
'变',
'条',
'只',
'没',
'结',
'解',
'问',
'意',
'建',
'月',
'公',
'无',
'系',
'军',
'很',
'情',
'者',
'最',
'立',
'代',
'想',
'已',
'通',
'并',
'提',
'直',
'题',
'党',
'程',
'展',
'五',
'果',
'料',
'象',
'员',
'革',
'位',
'入',
'常',
'文',
'总',
'次',
'品',
'式',
'活',
'设',
'及',
'管',
'特',
'件',
'长',
'求',
'老',
'头',
'基',
'资',
'边',
'流',
'路',
'级',
'少',
'图',
'山',
'统',
'接',
'知',
'较',
'将',
'组',
'见',
'计',
'别',
'她',
'手',
'角',
'期',
'根',
'论',
'运',
'农',
'指',
'几',
'九',
'区',
'强',
'放',
'决',
'西',
'被',
'干',
'做',
'必',
'战',
'先',
'回',
'则',
'任',
'取',
'据',
'处',
'队',
'南',
'给',
'色',
'光',
'门',
'即',
'保',
'治',
'北',
'造',
'百',
'规',
'热',
'领',
'七',
'海',
'口',
'东',
'导',
'器',
'压',
'志',
'世',
'金',
'增',
'争',
'济',
'阶',
'油',
'思',
'术',
'极',
'交',
'受',
'联',
'什',
'认',
'六',
'共',
'权',
'收',
'证',
'改',
'清',
'美',
'再',
'采',
'转',
'更',
'单',
'风',
'切',
'打',
'白',
'教',
'速',
'花',
'带',
'安',
'场',
'身',
'车',
'例',
'真',
'务',
'具',
'万',
'每',
'目',
'至',
'达',
'走',
'积',
'示',
'议',
'声',
'报',
'斗',
'完',
'类',
'八',
'离',
'华',
'名',
'确',
'才',
'科',
'张',
'信',
'马',
'节',
'话',
'米',
'整',
'空',
'元',
'况',
'今',
'集',
'温',
'传',
'土',
'许',
'步',
'群',
'广',
'石',
'记',
'需',
'段',
'研',
'界',
'拉',
'林',
'律',
'叫',
'且',
'究',
'观',
'越',
'织',
'装',
'影',
'算',
'低',
'持',
'音',
'众',
'书',
'布',
'复',
'容',
'儿',
'须',
'际',
'商',
'非',
'验',
'连',
'断',
'深',
'难',
'近',
'矿',
'千',
'周',
'委',
'素',
'技',
'备',
'半',
'办',
'青',
'省',
'列',
'习',
'响',
'约',
'支',
'般',
'史',
'感',
'劳',
'便',
'团',
'往',
'酸',
'历',
'市',
'克',
'何',
'除',
'消',
'构',
'府',
'称',
'太',
'准',
'精',
'值',
'号',
'率',
'族',
'维',
'划',
'选',
'标',
'写',
'存',
'候',
'毛',
'亲',
'快',
'效',
'斯',
'院',
'查',
'江',
'型',
'眼',
'王',
'按',
'格',
'养',
'易',
'置',
'派',
'层',
'片',
'始',
'却',
'专',
'状',
'育',
'厂',
'京',
'识',
'适',
'属',
'圆',
'包',
'火',
'住',
'调',
'满',
'县',
'局',
'照',
'参',
'红',
'细',
'引',
'听',
'该',
'铁',
'价',
'严',
'首',
'底',
'液',
'官',
'德',
'随',
'病',
'苏',
'失',
'尔',
'死',
'讲',
'配',
'女',
'黄',
'推',
'显',
'谈',
'罪',
'神',
'艺',
'呢',
'席',
'含',
'企',
'望',
'密',
'批',
'营',
'项',
'防',
'举',
'球',
'英',
'氧',
'势',
'告',
'李',
'台',
'落',
'木',
'帮',
'轮',
'破',
'亚',
'师',
'围',
'注',
'远',
'字',
'材',
'排',
'供',
'河',
'态',
'封',
'另',
'施',
'减',
'树',
'溶',
'怎',
'止',
'案',
'言',
'士',
'均',
'武',
'固',
'叶',
'鱼',
'波',
'视',
'仅',
'费',
'紧',
'爱',
'左',
'章',
'早',
'朝',
'害',
'续',
'轻',
'服',
'试',
'食',
'充',
'兵',
'源',
'判',
'护',
'司',
'足',
'某',
'练',
'差',
'致',
'板',
'田',
'降',
'黑',
'犯',
'负',
'击',
'范',
'继',
'兴',
'似',
'余',
'坚',
'曲',
'输',
'修',
'故',
'城',
'夫',
'够',
'送',
'笔',
'船',
'占',
'右',
'财',
'吃',
'富',
'春',
'职',
'觉',
'汉',
'画',
'功',
'巴',
'跟',
'虽',
'杂',
'飞',
'检',
'吸',
'助',
'升',
'阳',
'互',
'初',
'创',
'抗',
'考',
'投',
'坏',
'策',
'古',
'径',
'换',
'未',
'跑',
'留',
'钢',
'曾',
'端',
'责',
'站',
'简',
'述',
'钱',
'副',
'尽',
'帝',
'射',
'草',
'冲',
'承',
'独',
'令',
'限',
'阿',
'宣',
'环',
'双',
'请',
'超',
'微',
'让',
'控',
'州',
'良',
'轴',
'找',
'否',
'纪',
'益',
'依',
'优',
'顶',
'础',
'载',
'倒',
'房',
'突',
'坐',
'粉',
'敌',
'略',
'客',
'袁',
'冷',
'胜',
'绝',
'析',
'块',
'剂',
'测',
'丝',
'协',
'诉',
'念',
'陈',
'仍',
'罗',
'盐',
'友',
'洋',
'错',
'苦',
'夜',
'刑',
'移',
'频',
'逐',
'靠',
'混',
'母',
'短',
'皮',
'终',
'聚',
'汽',
'村',
'云',
'哪',
'既',
'距',
'卫',
'停',
'烈',
'央',
'察',
'烧',
'迅',
'境',
'若',
'印',
'洲',
'刻',
'括',
'激',
'孔',
'搞',
'甚',
'室',
'待',
'核',
'校',
'散',
'侵',
'吧',
'甲',
'游',
'久',
'菜',
'味',
'旧',
'模',
'湖',
'货',
'损',
'预',
'阻',
'毫',
'普',
'稳',
'乙',
'妈',
'植',
'息',
'扩',
'银',
'语',
'挥',
'酒',
'守',
'拿',
'序',
'纸',
'医',
'缺',
'雨',
'吗',
'针',
'刘',
'啊',
'急',
'唱',
'误',
'训',
'愿',
'审',
'附',
'获',
'茶',
'鲜',
'粮',
'斤',
'孩',
'脱',
'硫',
'肥',
'善',
'龙',
'演',
'父',
'渐',
'血',
'欢',
'械',
'掌',
'歌',
'沙',
'刚',
'攻',
'谓',
'盾',
'讨',
'晚',
'粒',
'乱',
'燃',
'矛',
'乎',
'杀',
'药',
'宁',
'鲁',
'贵',
'钟',
'煤',
'读',
'班',
'伯',
'香',
'介',
'迫',
'句',
'丰',
'培',
'握',
'兰',
'担',
'弦',
'蛋',
'沉',
'假',
'穿',
'执',
'答',
'乐',
'谁',
'顺',
'烟',
'缩',
'征',
'脸',
'喜',
'松',
'脚',
'困',
'异',
'免',
'背',
'星',
'福',
'买',
'染',
'井',
'概',
'慢',
'怕',
'磁',
'倍',
'祖',
'皇',
'促',
'静',
'补',
'评',
'翻',
'肉',
'践',
'尼',
'衣',
'宽',
'扬',
'棉',
'希',
'伤',
'操',
'垂',
'秋',
'宜',
'氢',
'套',
'督',
'振',
'架',
'亮',
'末',
'宪',
'庆',
'编',
'牛',
'触',
'映',
'雷',
'销',
'诗',
'座',
'居',
'抓',
'裂',
'胞',
'呼',
'娘',
'景',
'威',
'绿',
'晶',
'厚',
'盟',
'衡',
'鸡',
'孙',
'延',
'危',
'胶',
'屋',
'乡',
'临',
'陆',
'顾',
'掉',
'呀',
'灯',
'岁',
'措',
'束',
'耐',
'剧',
'玉',
'赵',
'跳',
'哥',
'季',
'课',
'凯',
'胡',
'额',
'款',
'绍',
'卷',
'齐',
'伟',
'蒸',
'殖',
'永',
'宗',
'苗',
'川',
'炉',
'岩',
'弱',
'零',
'杨',
'奏',
'沿',
'露',
'杆',
'探',
'滑',
'镇',
'饭',
'浓',
'航',
'怀',
'赶',
'库',
'夺',
'伊',
'灵',
'税',
'途',
'灭',
'赛',
'归',
'召',
'鼓',
'播',
'盘',
'裁',
'险',
'康',
'唯',
'录',
'菌',
'纯',
'借',
'糖',
'盖',
'横',
'符',
'私',
'努',
'堂',
'域',
'枪',
'润',
'幅',
'哈',
'竟',
'熟',
'虫',
'泽',
'脑',
'壤',
'碳',
'欧',
'遍',
'侧',
'寨',
'敢',
'彻',
'虑',
'斜',
'薄',
'庭',
'纳',
'弹',
'饲',
'伸',
'折',
'麦',
'湿',
'暗',
'荷',
'瓦',
'塞',
'床',
'筑',
'恶',
'户',
'访',
'塔',
'奇',
'透',
'梁',
'刀',
'旋',
'迹',
'卡',
'氯',
'遇',
'份',
'毒',
'泥',
'退',
'洗',
'摆',
'灰',
'彩',
'卖',
'耗',
'夏',
'择',
'忙',
'铜',
'献',
'硬',
'予',
'繁',
'圈',
'雪',
'函',
'亦',
'抽',
'篇',
'阵',
'阴',
'丁',
'尺',
'追',
'堆',
'雄',
'迎',
'泛',
'爸',
'楼',
'避',
'谋',
'吨',
'野',
'猪',
'旗',
'累',
'偏',
'典',
'馆',
'索',
'秦',
'脂',
'潮',
'爷',
'豆',
'忽',
'托',
'惊',
'塑',
'遗',
'愈',
'朱',
'替',
'纤',
'粗',
'倾',
'尚',
'痛',
'楚',
'谢',
'奋',
'购',
'磨',
'君',
'池',
'旁',
'碎',
'骨',
'监',
'捕',
'弟',
'暴',
'割',
'贯',
'殊',
'释',
'词',
'亡',
'壁',
'顿',
'宝',
'午',
'尘',
'闻',
'揭',
'炮',
'残',
'冬',
'桥',
'妇',
'警',
'综',
'招',
'吴',
'付',
'浮',
'遭',
'徐',
'您',
'摇',
'谷',
'赞',
'箱',
'隔',
'订',
'男',
'吹',
'园',
'纷',
'唐',
'败',
'宋',
'玻',
'巨',
'耕',
'坦',
'荣',
'闭',
'湾',
'键',
'凡',
'驻',
'锅',
'救',
'恩',
'剥',
'凝',
'碱',
'齿',
'截',
'炼',
'麻',
'纺',
'禁',
'废',
'盛',
'版',
'缓',
'净',
'睛',
'昌',
'婚',
'涉',
'筒',
'嘴',
'插',
'岸',
'朗',
'庄',
'街',
'藏',
'姑',
'贸',
'腐',
'奴',
'啦',
'惯',
'乘',
'伙',
'恢',
'匀',
'纱',
'扎',
'辩',
'耳',
'彪',
'臣',
'亿',
'璃',
'抵',
'脉',
'秀',
'萨',
'俄',
'网',
'舞',
'店',
'喷',
'纵',
'寸',
'汗',
'挂',
'洪',
'贺',
'闪',
'柬',
'爆',
'烯',
'津',
'稻',
'墙',
'软',
'勇',
'像',
'滚',
'厘',
'蒙',
'芳',
'肯',
'坡',
'柱',
'荡',
'腿',
'仪',
'旅',
'尾',
'轧',
'冰',
'贡',
'登',
'黎',
'削',
'钻',
'勒',
'逃',
'障',
'氨',
'郭',
'峰',
'币',
'港',
'伏',
'轨',
'亩',
'毕',
'擦',
'莫',
'刺',
'浪',
'秘',
'援',
'株',
'健',
'售',
'股',
'岛',
'甘',
'泡',
'睡',
'童',
'铸',
'汤',
'阀',
'休',
'汇',
'舍',
'牧',
'绕',
'炸',
'哲',
'磷',
'绩',
'朋',
'淡',
'尖',
'启',
'陷',
'柴',
'呈',
'徒',
'颜',
'泪',
'稍',
'忘',
'泵',
'蓝',
'拖',
'洞',
'授',
'镜',
'辛',
'壮',
'锋',
'贫',
'虚',
'弯',
'摩',
'泰',
'幼',
'廷',
'尊',
'窗',
'纲',
'弄',
'隶',
'疑',
'氏',
'宫',
'姐',
'震',
'瑞',
'怪',
'尤',
'琴',
'循',
'描',
'膜',
'违',
'夹',
'腰',
'缘',
'珠',
'穷',
'森',
'枝',
'竹',
'沟',
'催',
'绳',
'忆',
'邦',
'剩',
'幸',
'浆',
'栏',
'拥',
'牙',
'贮',
'礼',
'滤',
'钠',
'纹',
'罢',
'拍',
'咱',
'喊',
'袖',
'埃',
'勤',
'罚',
'焦',
'潜',
'伍',
'墨',
'欲',
'缝',
'姓',
'刊',
'饱',
'仿',
'奖',
'铝',
'鬼',
'丽',
'跨',
'默',
'挖',
'链',
'扫',
'喝',
'袋',
'炭',
'污',
'幕',
'诸',
'弧',
'励',
'梅',
'奶',
'洁',
'灾',
'舟',
'鉴',
'苯',
'讼',
'抱',
'毁',
'懂',
'寒',
'智',
'埔',
'寄',
'届',
'跃',
'渡',
'挑',
'丹',
'艰',
'贝',
'碰',
'拔',
'爹',
'戴',
'码',
'梦',
'芽',
'熔',
'赤',
'渔',
'哭',
'敬',
'颗',
'奔',
'铅',
'仲',
'虎',
'稀',
'妹',
'乏',
'珍',
'申',
'桌',
'遵',
'允',
'隆',
'螺',
'仓',
'魏',
'锐',
'晓',
'氮',
'兼',
'隐',
'碍',
'赫',
'拨',
'忠',
'肃',
'缸',
'牵',
'抢',
'博',
'巧',
'壳',
'兄',
'杜',
'讯',
'诚',
'碧',
'祥',
'柯',
'页',
'巡',
'矩',
'悲',
'灌',
'龄',
'伦',
'票',
'寻',
'桂',
'铺',
'圣',
'恐',
'恰',
'郑',
'趣',
'抬',
'荒',
'腾',
'贴',
'柔',
'滴',
'猛',
'阔',
'辆',
'妻',
'填',
'撤',
'储',
'签',
'闹',
'扰',
'紫',
'砂',
'递',
'戏',
'吊',
'陶',
'伐',
'喂',
'疗',
'瓶',
'婆',
'抚',
'臂',
'摸',
'忍',
'虾',
'蜡',
'邻',
'胸',
'巩',
'挤',
'偶',
'弃',
'槽',
'劲',
'乳',
'邓',
'吉',
'仁',
'烂',
'砖',
'租',
'乌',
'舰',
'伴',
'瓜',
'浅',
'丙',
'暂',
'燥',
'橡',
'柳',
'迷',
'暖',
'牌',
'秧',
'胆',
'详',
'簧',
'踏',
'瓷',
'谱',
'呆',
'宾',
'糊',
'洛',
'辉',
'愤',
'竞',
'隙',
'怒',
'粘',
'乃',
'绪',
'肩',
'籍',
'敏',
'涂',
'熙',
'皆',
'侦',
'悬',
'掘',
'享',
'纠',
'醒',
'狂',
'锁',
'淀',
'恨',
'牲',
'霸',
'爬',
'赏',
'逆',
'玩',
'陵',
'祝',
'秒',
'浙',
'貌',
'役',
'彼',
'悉',
'鸭',
'趋',
'凤',
'晨',
'畜',
'辈',
'秩',
'卵',
'署',
'梯',
'炎',
'滩',
'棋',
'驱',
'筛',
'峡',
'冒',
'啥',
'寿',
'译',
'浸',
'泉',
'帽',
'迟',
'硅',
'疆',
'贷',
'漏',
'稿',
'冠',
'嫩',
'胁',
'芯',
'牢',
'叛',
'蚀',
'奥',
'鸣',
'岭',
'羊',
'凭',
'串',
'塘',
'绘',
'酵',
'融',
'盆',
'锡',
'庙',
'筹',
'冻',
'辅',
'摄',
'袭',
'筋',
'拒',
'僚',
'旱',
'钾',
'鸟',
'漆',
'沈',
'眉',
'疏',
'添',
'棒',
'穗',
'硝',
'韩',
'逼',
'扭',
'侨',
'凉',
'挺',
'碗',
'栽',
'炒',
'杯',
'患',
'馏',
'劝',
'豪',
'辽',
'勃',
'鸿',
'旦',
'吏',
'拜',
'狗',
'埋',
'辊',
'掩',
'饮',
'搬',
'骂',
'辞',
'勾',
'扣',
'估',
'蒋',
'绒',
'雾',
'丈',
'朵',
'姆',
'拟',
'宇',
'辑',
'陕',
'雕',
'偿',
'蓄',
'崇',
'剪',
'倡',
'厅',
'咬',
'驶',
'薯',
'刷',
'斥',
'番',
'赋',
'奉',
'佛',
'浇',
'漫',
'曼',
'扇',
'钙',
'桃',
'扶',
'仔',
'返',
'俗',
'亏',
'腔',
'鞋',
'棱',
'覆',
'框',
'悄',
'叔',
'撞',
'骗',
'勘',
'旺',
'沸',
'孤',
'吐',
'孟',
'渠',
'屈',
'疾',
'妙',
'惜',
'仰',
'狠',
'胀',
'谐',
'抛',
'霉',
'桑',
'岗',
'嘛',
'衰',
'盗',
'渗',
'脏',
'赖',
'涌',
'甜',
'曹',
'阅',
'肌',
'哩',
'厉',
'烃',
'纬',
'毅',
'昨',
'伪',
'症',
'煮',
'叹',
'钉',
'搭',
'茎',
'笼',
'酷',
'偷',
'弓',
'锥',
'恒',
'杰',
'坑',
'鼻',
'翼',
'纶',
'叙',
'狱',
'逮',
'罐',
'络',
'棚',
'抑',
'膨',
'蔬',
'寺',
'骤',
'穆',
'冶',
'枯',
'册',
'尸',
'凸',
'绅',
'坯',
'牺',
'焰',
'轰',
'欣',
'晋',
'瘦',
'御',
'锭',
'锦',
'丧',
'旬',
'锻',
'垄',
'搜',
'扑',
'邀',
'亭',
'酯',
'迈',
'舒',
'脆',
'酶',
'闲',
'忧',
'酚',
'顽',
'羽',
'涨',
'卸',
'仗',
'陪',
'辟',
'惩',
'杭',
'姚',
'肚',
'捉',
'飘',
'漂',
'昆',
'欺',
'吾',
'郎',
'烷',
'汁',
'呵',
'饰',
'萧',
'雅',
'邮',
'迁',
'燕',
'撒',
'姻',
'赴',
'宴',
'烦',
'债',
'帐',
'斑',
'铃',
'旨',
'醇',
'董',
'饼',
'雏',
'姿',
'拌',
'傅',
'腹',
'妥',
'揉',
'贤',
'拆',
'歪',
'葡',
'胺',
'丢',
'浩',
'徽',
'昂',
'垫',
'挡',
'览',
'贪',
'慰',
'缴',
'汪',
'慌',
'冯',
'诺',
'姜',
'谊',
'凶',
'劣',
'诬',
'耀',
'昏',
'躺',
'盈',
'骑',
'乔',
'溪',
'丛',
'卢',
'抹',
'闷',
'咨',
'刮',
'驾',
'缆',
'悟',
'摘',
'铒',
'掷',
'颇',
'幻',
'柄',
'惠',
'惨',
'佳',
'仇',
'腊',
'窝',
'涤',
'剑',
'瞧',
'堡',
'泼',
'葱',
'罩',
'霍',
'捞',
'胎',
'苍',
'滨',
'俩',
'捅',
'湘',
'砍',
'霞',
'邵',
'萄',
'疯',
'淮',
'遂',
'熊',
'粪',
'烘',
'宿',
'档',
'戈',
'驳',
'嫂',
'裕',
'徙',
'箭',
'捐',
'肠',
'撑',
'晒',
'辨',
'殿',
'莲',
'摊',
'搅',
'酱',
'屏',
'疫',
'哀',
'蔡',
'堵',
'沫',
'皱',
'畅',
'叠',
'阁',
'莱',
'敲',
'辖',
'钩',
'痕',
'坝',
'巷',
'饿',
'祸',
'丘',
'玄',
'溜',
'曰',
'逻',
'彭',
'尝',
'卿',
'妨',
'艇',
'吞',
'韦',
'怨',
'矮',
'歇'
];
// SPDX-License-Identifier: MIT
const WORDLIST$c = [
'abandon',
'ability',
'able',
'about',
'above',
'absent',
'absorb',
'abstract',
'absurd',
'abuse',
'access',
'accident',
'account',
'accuse',
'achieve',
'acid',
'acoustic',
'acquire',
'across',
'act',
'action',
'actor',
'actress',
'actual',
'adapt',
'add',
'addict',
'address',
'adjust',
'admit',
'adult',
'advance',
'advice',
'aerobic',
'affair',
'afford',
'afraid',
'again',
'age',
'agent',
'agree',
'ahead',
'aim',
'air',
'airport',
'aisle',
'alarm',
'album',
'alcohol',
'alert',
'alien',
'all',
'alley',
'allow',
'almost',
'alone',
'alpha',
'already',
'also',
'alter',
'always',
'amateur',
'amazing',
'among',
'amount',
'amused',
'analyst',
'anchor',
'ancient',
'anger',
'angle',
'angry',
'animal',
'ankle',
'announce',
'annual',
'another',
'answer',
'antenna',
'antique',
'anxiety',
'any',
'apart',
'apology',
'appear',
'apple',
'approve',
'april',
'arch',
'arctic',
'area',
'arena',
'argue',
'arm',
'armed',
'armor',
'army',
'around',
'arrange',
'arrest',
'arrive',
'arrow',
'art',
'artefact',
'artist',
'artwork',
'ask',
'aspect',
'assault',
'asset',
'assist',
'assume',
'asthma',
'athlete',
'atom',
'attack',
'attend',
'attitude',
'attract',
'auction',
'audit',
'august',
'aunt',
'author',
'auto',
'autumn',
'average',
'avocado',
'avoid',
'awake',
'aware',
'away',
'awesome',
'awful',
'awkward',
'axis',
'baby',
'bachelor',
'bacon',
'badge',
'bag',
'balance',
'balcony',
'ball',
'bamboo',
'banana',
'banner',
'bar',
'barely',
'bargain',
'barrel',
'base',
'basic',
'basket',
'battle',
'beach',
'bean',
'beauty',
'because',
'become',
'beef',
'before',
'begin',
'behave',
'behind',
'believe',
'below',
'belt',
'bench',
'benefit',
'best',
'betray',
'better',
'between',
'beyond',
'bicycle',
'bid',
'bike',
'bind',
'biology',
'bird',
'birth',
'bitter',
'black',
'blade',
'blame',
'blanket',
'blast',
'bleak',
'bless',
'blind',
'blood',
'blossom',
'blouse',
'blue',
'blur',
'blush',
'board',
'boat',
'body',
'boil',
'bomb',
'bone',
'bonus',
'book',
'boost',
'border',
'boring',
'borrow',
'boss',
'bottom',
'bounce',
'box',
'boy',
'bracket',
'brain',
'brand',
'brass',
'brave',
'bread',
'breeze',
'brick',
'bridge',
'brief',
'bright',
'bring',
'brisk',
'broccoli',
'broken',
'bronze',
'broom',
'brother',
'brown',
'brush',
'bubble',
'buddy',
'budget',
'buffalo',
'build',
'bulb',
'bulk',
'bullet',
'bundle',
'bunker',
'burden',
'burger',
'burst',
'bus',
'business',
'busy',
'butter',
'buyer',
'buzz',
'cabbage',
'cabin',
'cable',
'cactus',
'cage',
'cake',
'call',
'calm',
'camera',
'camp',
'can',
'canal',
'cancel',
'candy',
'cannon',
'canoe',
'canvas',
'canyon',
'capable',
'capital',
'captain',
'car',
'carbon',
'card',
'cargo',
'carpet',
'carry',
'cart',
'case',
'cash',
'casino',
'castle',
'casual',
'cat',
'catalog',
'catch',
'category',
'cattle',
'caught',
'cause',
'caution',
'cave',
'ceiling',
'celery',
'cement',
'census',
'century',
'cereal',
'certain',
'chair',
'chalk',
'champion',
'change',
'chaos',
'chapter',
'charge',
'chase',
'chat',
'cheap',
'check',
'cheese',
'chef',
'cherry',
'chest',
'chicken',
'chief',
'child',
'chimney',
'choice',
'choose',
'chronic',
'chuckle',
'chunk',
'churn',
'cigar',
'cinnamon',
'circle',
'citizen',
'city',
'civil',
'claim',
'clap',
'clarify',
'claw',
'clay',
'clean',
'clerk',
'clever',
'click',
'client',
'cliff',
'climb',
'clinic',
'clip',
'clock',
'clog',
'close',
'cloth',
'cloud',
'clown',
'club',
'clump',
'cluster',
'clutch',
'coach',
'coast',
'coconut',
'code',
'coffee',
'coil',
'coin',
'collect',
'color',
'column',
'combine',
'come',
'comfort',
'comic',
'common',
'company',
'concert',
'conduct',
'confirm',
'congress',
'connect',
'consider',
'control',
'convince',
'cook',
'cool',
'copper',
'copy',
'coral',
'core',
'corn',
'correct',
'cost',
'cotton',
'couch',
'country',
'couple',
'course',
'cousin',
'cover',
'coyote',
'crack',
'cradle',
'craft',
'cram',
'crane',
'crash',
'crater',
'crawl',
'crazy',
'cream',
'credit',
'creek',
'crew',
'cricket',
'crime',
'crisp',
'critic',
'crop',
'cross',
'crouch',
'crowd',
'crucial',
'cruel',
'cruise',
'crumble',
'crunch',
'crush',
'cry',
'crystal',
'cube',
'culture',
'cup',
'cupboard',
'curious',
'current',
'curtain',
'curve',
'cushion',
'custom',
'cute',
'cycle',
'dad',
'damage',
'damp',
'dance',
'danger',
'daring',
'dash',
'daughter',
'dawn',
'day',
'deal',
'debate',
'debris',
'decade',
'december',
'decide',
'decline',
'decorate',
'decrease',
'deer',
'defense',
'define',
'defy',
'degree',
'delay',
'deliver',
'demand',
'demise',
'denial',
'dentist',
'deny',
'depart',
'depend',
'deposit',
'depth',
'deputy',
'derive',
'describe',
'desert',
'design',
'desk',
'despair',
'destroy',
'detail',
'detect',
'develop',
'device',
'devote',
'diagram',
'dial',
'diamond',
'diary',
'dice',
'diesel',
'diet',
'differ',
'digital',
'dignity',
'dilemma',
'dinner',
'dinosaur',
'direct',
'dirt',
'disagree',
'discover',
'disease',
'dish',
'dismiss',
'disorder',
'display',
'distance',
'divert',
'divide',
'divorce',
'dizzy',
'doctor',
'document',
'dog',
'doll',
'dolphin',
'domain',
'donate',
'donkey',
'donor',
'door',
'dose',
'double',
'dove',
'draft',
'dragon',
'drama',
'drastic',
'draw',
'dream',
'dress',
'drift',
'drill',
'drink',
'drip',
'drive',
'drop',
'drum',
'dry',
'duck',
'dumb',
'dune',
'during',
'dust',
'dutch',
'duty',
'dwarf',
'dynamic',
'eager',
'eagle',
'early',
'earn',
'earth',
'easily',
'east',
'easy',
'echo',
'ecology',
'economy',
'edge',
'edit',
'educate',
'effort',
'egg',
'eight',
'either',
'elbow',
'elder',
'electric',
'elegant',
'element',
'elephant',
'elevator',
'elite',
'else',
'embark',
'embody',
'embrace',
'emerge',
'emotion',
'employ',
'empower',
'empty',
'enable',
'enact',
'end',
'endless',
'endorse',
'enemy',
'energy',
'enforce',
'engage',
'engine',
'enhance',
'enjoy',
'enlist',
'enough',
'enrich',
'enroll',
'ensure',
'enter',
'entire',
'entry',
'envelope',
'episode',
'equal',
'equip',
'era',
'erase',
'erode',
'erosion',
'error',
'erupt',
'escape',
'essay',
'essence',
'estate',
'eternal',
'ethics',
'evidence',
'evil',
'evoke',
'evolve',
'exact',
'example',
'excess',
'exchange',
'excite',
'exclude',
'excuse',
'execute',
'exercise',
'exhaust',
'exhibit',
'exile',
'exist',
'exit',
'exotic',
'expand',
'expect',
'expire',
'explain',
'expose',
'express',
'extend',
'extra',
'eye',
'eyebrow',
'fabric',
'face',
'faculty',
'fade',
'faint',
'faith',
'fall',
'false',
'fame',
'family',
'famous',
'fan',
'fancy',
'fantasy',
'farm',
'fashion',
'fat',
'fatal',
'father',
'fatigue',
'fault',
'favorite',
'feature',
'february',
'federal',
'fee',
'feed',
'feel',
'female',
'fence',
'festival',
'fetch',
'fever',
'few',
'fiber',
'fiction',
'field',
'figure',
'file',
'film',
'filter',
'final',
'find',
'fine',
'finger',
'finish',
'fire',
'firm',
'first',
'fiscal',
'fish',
'fit',
'fitness',
'fix',
'flag',
'flame',
'flash',
'flat',
'flavor',
'flee',
'flight',
'flip',
'float',
'flock',
'floor',
'flower',
'fluid',
'flush',
'fly',
'foam',
'focus',
'fog',
'foil',
'fold',
'follow',
'food',
'foot',
'force',
'forest',
'forget',
'fork',
'fortune',
'forum',
'forward',
'fossil',
'foster',
'found',
'fox',
'fragile',
'frame',
'frequent',
'fresh',
'friend',
'fringe',
'frog',
'front',
'frost',
'frown',
'frozen',
'fruit',
'fuel',
'fun',
'funny',
'furnace',
'fury',
'future',
'gadget',
'gain',
'galaxy',
'gallery',
'game',
'gap',
'garage',
'garbage',
'garden',
'garlic',
'garment',
'gas',
'gasp',
'gate',
'gather',
'gauge',
'gaze',
'general',
'genius',
'genre',
'gentle',
'genuine',
'gesture',
'ghost',
'giant',
'gift',
'giggle',
'ginger',
'giraffe',
'girl',
'give',
'glad',
'glance',
'glare',
'glass',
'glide',
'glimpse',
'globe',
'gloom',
'glory',
'glove',
'glow',
'glue',
'goat',
'goddess',
'gold',
'good',
'goose',
'gorilla',
'gospel',
'gossip',
'govern',
'gown',
'grab',
'grace',
'grain',
'grant',
'grape',
'grass',
'gravity',
'great',
'green',
'grid',
'grief',
'grit',
'grocery',
'group',
'grow',
'grunt',
'guard',
'guess',
'guide',
'guilt',
'guitar',
'gun',
'gym',
'habit',
'hair',
'half',
'hammer',
'hamster',
'hand',
'happy',
'harbor',
'hard',
'harsh',
'harvest',
'hat',
'have',
'hawk',
'hazard',
'head',
'health',
'heart',
'heavy',
'hedgehog',
'height',
'hello',
'helmet',
'help',
'hen',
'hero',
'hidden',
'high',
'hill',
'hint',
'hip',
'hire',
'history',
'hobby',
'hockey',
'hold',
'hole',
'holiday',
'hollow',
'home',
'honey',
'hood',
'hope',
'horn',
'horror',
'horse',
'hospital',
'host',
'hotel',
'hour',
'hover',
'hub',
'huge',
'human',
'humble',
'humor',
'hundred',
'hungry',
'hunt',
'hurdle',
'hurry',
'hurt',
'husband',
'hybrid',
'ice',
'icon',
'idea',
'identify',
'idle',
'ignore',
'ill',
'illegal',
'illness',
'image',
'imitate',
'immense',
'immune',
'impact',
'impose',
'improve',
'impulse',
'inch',
'include',
'income',
'increase',
'index',
'indicate',
'indoor',
'industry',
'infant',
'inflict',
'inform',
'inhale',
'inherit',
'initial',
'inject',
'injury',
'inmate',
'inner',
'innocent',
'input',
'inquiry',
'insane',
'insect',
'inside',
'inspire',
'install',
'intact',
'interest',
'into',
'invest',
'invite',
'involve',
'iron',
'island',
'isolate',
'issue',
'item',
'ivory',
'jacket',
'jaguar',
'jar',
'jazz',
'jealous',
'jeans',
'jelly',
'jewel',
'job',
'join',
'joke',
'journey',
'joy',
'judge',
'juice',
'jump',
'jungle',
'junior',
'junk',
'just',
'kangaroo',
'keen',
'keep',
'ketchup',
'key',
'kick',
'kid',
'kidney',
'kind',
'kingdom',
'kiss',
'kit',
'kitchen',
'kite',
'kitten',
'kiwi',
'knee',
'knife',
'knock',
'know',
'lab',
'label',
'labor',
'ladder',
'lady',
'lake',
'lamp',
'language',
'laptop',
'large',
'later',
'latin',
'laugh',
'laundry',
'lava',
'law',
'lawn',
'lawsuit',
'layer',
'lazy',
'leader',
'leaf',
'learn',
'leave',
'lecture',
'left',
'leg',
'legal',
'legend',
'leisure',
'lemon',
'lend',
'length',
'lens',
'leopard',
'lesson',
'letter',
'level',
'liar',
'liberty',
'library',
'license',
'life',
'lift',
'light',
'like',
'limb',
'limit',
'link',
'lion',
'liquid',
'list',
'little',
'live',
'lizard',
'load',
'loan',
'lobster',
'local',
'lock',
'logic',
'lonely',
'long',
'loop',
'lottery',
'loud',
'lounge',
'love',
'loyal',
'lucky',
'luggage',
'lumber',
'lunar',
'lunch',
'luxury',
'lyrics',
'machine',
'mad',
'magic',
'magnet',
'maid',
'mail',
'main',
'major',
'make',
'mammal',
'man',
'manage',
'mandate',
'mango',
'mansion',
'manual',
'maple',
'marble',
'march',
'margin',
'marine',
'market',
'marriage',
'mask',
'mass',
'master',
'match',
'material',
'math',
'matrix',
'matter',
'maximum',
'maze',
'meadow',
'mean',
'measure',
'meat',
'mechanic',
'medal',
'media',
'melody',
'melt',
'member',
'memory',
'mention',
'menu',
'mercy',
'merge',
'merit',
'merry',
'mesh',
'message',
'metal',
'method',
'middle',
'midnight',
'milk',
'million',
'mimic',
'mind',
'minimum',
'minor',
'minute',
'miracle',
'mirror',
'misery',
'miss',
'mistake',
'mix',
'mixed',
'mixture',
'mobile',
'model',
'modify',
'mom',
'moment',
'monitor',
'monkey',
'monster',
'month',
'moon',
'moral',
'more',
'morning',
'mosquito',
'mother',
'motion',
'motor',
'mountain',
'mouse',
'move',
'movie',
'much',
'muffin',
'mule',
'multiply',
'muscle',
'museum',
'mushroom',
'music',
'must',
'mutual',
'myself',
'mystery',
'myth',
'naive',
'name',
'napkin',
'narrow',
'nasty',
'nation',
'nature',
'near',
'neck',
'need',
'negative',
'neglect',
'neither',
'nephew',
'nerve',
'nest',
'net',
'network',
'neutral',
'never',
'news',
'next',
'nice',
'night',
'noble',
'noise',
'nominee',
'noodle',
'normal',
'north',
'nose',
'notable',
'note',
'nothing',
'notice',
'novel',
'now',
'nuclear',
'number',
'nurse',
'nut',
'oak',
'obey',
'object',
'oblige',
'obscure',
'observe',
'obtain',
'obvious',
'occur',
'ocean',
'october',
'odor',
'off',
'offer',
'office',
'often',
'oil',
'okay',
'old',
'olive',
'olympic',
'omit',
'once',
'one',
'onion',
'online',
'only',
'open',
'opera',
'opinion',
'oppose',
'option',
'orange',
'orbit',
'orchard',
'order',
'ordinary',
'organ',
'orient',
'original',
'orphan',
'ostrich',
'other',
'outdoor',
'outer',
'output',
'outside',
'oval',
'oven',
'over',
'own',
'owner',
'oxygen',
'oyster',
'ozone',
'pact',
'paddle',
'page',
'pair',
'palace',
'palm',
'panda',
'panel',
'panic',
'panther',
'paper',
'parade',
'parent',
'park',
'parrot',
'party',
'pass',
'patch',
'path',
'patient',
'patrol',
'pattern',
'pause',
'pave',
'payment',
'peace',
'peanut',
'pear',
'peasant',
'pelican',
'pen',
'penalty',
'pencil',
'people',
'pepper',
'perfect',
'permit',
'person',
'pet',
'phone',
'photo',
'phrase',
'physical',
'piano',
'picnic',
'picture',
'piece',
'pig',
'pigeon',
'pill',
'pilot',
'pink',
'pioneer',
'pipe',
'pistol',
'pitch',
'pizza',
'place',
'planet',
'plastic',
'plate',
'play',
'please',
'pledge',
'pluck',
'plug',
'plunge',
'poem',
'poet',
'point',
'polar',
'pole',
'police',
'pond',
'pony',
'pool',
'popular',
'portion',
'position',
'possible',
'post',
'potato',
'pottery',
'poverty',
'powder',
'power',
'practice',
'praise',
'predict',
'prefer',
'prepare',
'present',
'pretty',
'prevent',
'price',
'pride',
'primary',
'print',
'priority',
'prison',
'private',
'prize',
'problem',
'process',
'produce',
'profit',
'program',
'project',
'promote',
'proof',
'property',
'prosper',
'protect',
'proud',
'provide',
'public',
'pudding',
'pull',
'pulp',
'pulse',
'pumpkin',
'punch',
'pupil',
'puppy',
'purchase',
'purity',
'purpose',
'purse',
'push',
'put',
'puzzle',
'pyramid',
'quality',
'quantum',
'quarter',
'question',
'quick',
'quit',
'quiz',
'quote',
'rabbit',
'raccoon',
'race',
'rack',
'radar',
'radio',
'rail',
'rain',
'raise',
'rally',
'ramp',
'ranch',
'random',
'range',
'rapid',
'rare',
'rate',
'rather',
'raven',
'raw',
'razor',
'ready',
'real',
'reason',
'rebel',
'rebuild',
'recall',
'receive',
'recipe',
'record',
'recycle',
'reduce',
'reflect',
'reform',
'refuse',
'region',
'regret',
'regular',
'reject',
'relax',
'release',
'relief',
'rely',
'remain',
'remember',
'remind',
'remove',
'render',
'renew',
'rent',
'reopen',
'repair',
'repeat',
'replace',
'report',
'require',
'rescue',
'resemble',
'resist',
'resource',
'response',
'result',
'retire',
'retreat',
'return',
'reunion',
'reveal',
'review',
'reward',
'rhythm',
'rib',
'ribbon',
'rice',
'rich',
'ride',
'ridge',
'rifle',
'right',
'rigid',
'ring',
'riot',
'ripple',
'risk',
'ritual',
'rival',
'river',
'road',
'roast',
'robot',
'robust',
'rocket',
'romance',
'roof',
'rookie',
'room',
'rose',
'rotate',
'rough',
'round',
'route',
'royal',
'rubber',
'rude',
'rug',
'rule',
'run',
'runway',
'rural',
'sad',
'saddle',
'sadness',
'safe',
'sail',
'salad',
'salmon',
'salon',
'salt',
'salute',
'same',
'sample',
'sand',
'satisfy',
'satoshi',
'sauce',
'sausage',
'save',
'say',
'scale',
'scan',
'scare',
'scatter',
'scene',
'scheme',
'school',
'science',
'scissors',
'scorpion',
'scout',
'scrap',
'screen',
'script',
'scrub',
'sea',
'search',
'season',
'seat',
'second',
'secret',
'section',
'security',
'seed',
'seek',
'segment',
'select',
'sell',
'seminar',
'senior',
'sense',
'sentence',
'series',
'service',
'session',
'settle',
'setup',
'seven',
'shadow',
'shaft',
'shallow',
'share',
'shed',
'shell',
'sheriff',
'shield',
'shift',
'shine',
'ship',
'shiver',
'shock',
'shoe',
'shoot',
'shop',
'short',
'shoulder',
'shove',
'shrimp',
'shrug',
'shuffle',
'shy',
'sibling',
'sick',
'side',
'siege',
'sight',
'sign',
'silent',
'silk',
'silly',
'silver',
'similar',
'simple',
'since',
'sing',
'siren',
'sister',
'situate',
'six',
'size',
'skate',
'sketch',
'ski',
'skill',
'skin',
'skirt',
'skull',
'slab',
'slam',
'sleep',
'slender',
'slice',
'slide',
'slight',
'slim',
'slogan',
'slot',
'slow',
'slush',
'small',
'smart',
'smile',
'smoke',
'smooth',
'snack',
'snake',
'snap',
'sniff',
'snow',
'soap',
'soccer',
'social',
'sock',
'soda',
'soft',
'solar',
'soldier',
'solid',
'solution',
'solve',
'someone',
'song',
'soon',
'sorry',
'sort',
'soul',
'sound',
'soup',
'source',
'south',
'space',
'spare',
'spatial',
'spawn',
'speak',
'special',
'speed',
'spell',
'spend',
'sphere',
'spice',
'spider',
'spike',
'spin',
'spirit',
'split',
'spoil',
'sponsor',
'spoon',
'sport',
'spot',
'spray',
'spread',
'spring',
'spy',
'square',
'squeeze',
'squirrel',
'stable',
'stadium',
'staff',
'stage',
'stairs',
'stamp',
'stand',
'start',
'state',
'stay',
'steak',
'steel',
'stem',
'step',
'stereo',
'stick',
'still',
'sting',
'stock',
'stomach',
'stone',
'stool',
'story',
'stove',
'strategy',
'street',
'strike',
'strong',
'struggle',
'student',
'stuff',
'stumble',
'style',
'subject',
'submit',
'subway',
'success',
'such',
'sudden',
'suffer',
'sugar',
'suggest',
'suit',
'summer',
'sun',
'sunny',
'sunset',
'super',
'supply',
'supreme',
'sure',
'surface',
'surge',
'surprise',
'surround',
'survey',
'suspect',
'sustain',
'swallow',
'swamp',
'swap',
'swarm',
'swear',
'sweet',
'swift',
'swim',
'swing',
'switch',
'sword',
'symbol',
'symptom',
'syrup',
'system',
'table',
'tackle',
'tag',
'tail',
'talent',
'talk',
'tank',
'tape',
'target',
'task',
'taste',
'tattoo',
'taxi',
'teach',
'team',
'tell',
'ten',
'tenant',
'tennis',
'tent',
'term',
'test',
'text',
'thank',
'that',
'theme',
'then',
'theory',
'there',
'they',
'thing',
'this',
'thought',
'three',
'thrive',
'throw',
'thumb',
'thunder',
'ticket',
'tide',
'tiger',
'tilt',
'timber',
'time',
'tiny',
'tip',
'tired',
'tissue',
'title',
'toast',
'tobacco',
'today',
'toddler',
'toe',
'together',
'toilet',
'token',
'tomato',
'tomorrow',
'tone',
'tongue',
'tonight',
'tool',
'tooth',
'top',
'topic',
'topple',
'torch',
'tornado',
'tortoise',
'toss',
'total',
'tourist',
'toward',
'tower',
'town',
'toy',
'track',
'trade',
'traffic',
'tragic',
'train',
'transfer',
'trap',
'trash',
'travel',
'tray',
'treat',
'tree',
'trend',
'trial',
'tribe',
'trick',
'trigger',
'trim',
'trip',
'trophy',
'trouble',
'truck',
'true',
'truly',
'trumpet',
'trust',
'truth',
'try',
'tube',
'tuition',
'tumble',
'tuna',
'tunnel',
'turkey',
'turn',
'turtle',
'twelve',
'twenty',
'twice',
'twin',
'twist',
'two',
'type',
'typical',
'ugly',
'umbrella',
'unable',
'unaware',
'uncle',
'uncover',
'under',
'undo',
'unfair',
'unfold',
'unhappy',
'uniform',
'unique',
'unit',
'universe',
'unknown',
'unlock',
'until',
'unusual',
'unveil',
'update',
'upgrade',
'uphold',
'upon',
'upper',
'upset',
'urban',
'urge',
'usage',
'use',
'used',
'useful',
'useless',
'usual',
'utility',
'vacant',
'vacuum',
'vague',
'valid',
'valley',
'valve',
'van',
'vanish',
'vapor',
'various',
'vast',
'vault',
'vehicle',
'velvet',
'vendor',
'venture',
'venue',
'verb',
'verify',
'version',
'very',
'vessel',
'veteran',
'viable',
'vibrant',
'vicious',
'victory',
'video',
'view',
'village',
'vintage',
'violin',
'virtual',
'virus',
'visa',
'visit',
'visual',
'vital',
'vivid',
'vocal',
'voice',
'void',
'volcano',
'volume',
'vote',
'voyage',
'wage',
'wagon',
'wait',
'walk',
'wall',
'walnut',
'want',
'warfare',
'warm',
'warrior',
'wash',
'wasp',
'waste',
'water',
'wave',
'way',
'wealth',
'weapon',
'wear',
'weasel',
'weather',
'web',
'wedding',
'weekend',
'weird',
'welcome',
'west',
'wet',
'whale',
'what',
'wheat',
'wheel',
'when',
'where',
'whip',
'whisper',
'wide',
'width',
'wife',
'wild',
'will',
'win',
'window',
'wine',
'wing',
'wink',
'winner',
'winter',
'wire',
'wisdom',
'wise',
'wish',
'witness',
'wolf',
'woman',
'wonder',
'wood',
'wool',
'word',
'work',
'world',
'worry',
'worth',
'wrap',
'wreck',
'wrestle',
'wrist',
'write',
'wrong',
'yard',
'year',
'yellow',
'you',
'young',
'youth',
'zebra',
'zero',
'zone',
'zoo'
];
// SPDX-License-Identifier: MIT
const WORDLIST$b = [
'abacate',
'abaixo',
'abalar',
'abater',
'abduzir',
'abelha',
'aberto',
'abismo',
'abotoar',
'abranger',
'abreviar',
'abrigar',
'abrupto',
'absinto',
'absoluto',
'absurdo',
'abutre',
'acabado',
'acalmar',
'acampar',
'acanhar',
'acaso',
'aceitar',
'acelerar',
'acenar',
'acervo',
'acessar',
'acetona',
'achatar',
'acidez',
'acima',
'acionado',
'acirrar',
'aclamar',
'aclive',
'acolhida',
'acomodar',
'acoplar',
'acordar',
'acumular',
'acusador',
'adaptar',
'adega',
'adentro',
'adepto',
'adequar',
'aderente',
'adesivo',
'adeus',
'adiante',
'aditivo',
'adjetivo',
'adjunto',
'admirar',
'adorar',
'adquirir',
'adubo',
'adverso',
'advogado',
'aeronave',
'afastar',
'aferir',
'afetivo',
'afinador',
'afivelar',
'aflito',
'afluente',
'afrontar',
'agachar',
'agarrar',
'agasalho',
'agenciar',
'agilizar',
'agiota',
'agitado',
'agora',
'agradar',
'agreste',
'agrupar',
'aguardar',
'agulha',
'ajoelhar',
'ajudar',
'ajustar',
'alameda',
'alarme',
'alastrar',
'alavanca',
'albergue',
'albino',
'alcatra',
'aldeia',
'alecrim',
'alegria',
'alertar',
'alface',
'alfinete',
'algum',
'alheio',
'aliar',
'alicate',
'alienar',
'alinhar',
'aliviar',
'almofada',
'alocar',
'alpiste',
'alterar',
'altitude',
'alucinar',
'alugar',
'aluno',
'alusivo',
'alvo',
'amaciar',
'amador',
'amarelo',
'amassar',
'ambas',
'ambiente',
'ameixa',
'amenizar',
'amido',
'amistoso',
'amizade',
'amolador',
'amontoar',
'amoroso',
'amostra',
'amparar',
'ampliar',
'ampola',
'anagrama',
'analisar',
'anarquia',
'anatomia',
'andaime',
'anel',
'anexo',
'angular',
'animar',
'anjo',
'anomalia',
'anotado',
'ansioso',
'anterior',
'anuidade',
'anunciar',
'anzol',
'apagador',
'apalpar',
'apanhado',
'apego',
'apelido',
'apertada',
'apesar',
'apetite',
'apito',
'aplauso',
'aplicada',
'apoio',
'apontar',
'aposta',
'aprendiz',
'aprovar',
'aquecer',
'arame',
'aranha',
'arara',
'arcada',
'ardente',
'areia',
'arejar',
'arenito',
'aresta',
'argiloso',
'argola',
'arma',
'arquivo',
'arraial',
'arrebate',
'arriscar',
'arroba',
'arrumar',
'arsenal',
'arterial',
'artigo',
'arvoredo',
'asfaltar',
'asilado',
'aspirar',
'assador',
'assinar',
'assoalho',
'assunto',
'astral',
'atacado',
'atadura',
'atalho',
'atarefar',
'atear',
'atender',
'aterro',
'ateu',
'atingir',
'atirador',
'ativo',
'atoleiro',
'atracar',
'atrevido',
'atriz',
'atual',
'atum',
'auditor',
'aumentar',
'aura',
'aurora',
'autismo',
'autoria',
'autuar',
'avaliar',
'avante',
'avaria',
'avental',
'avesso',
'aviador',
'avisar',
'avulso',
'axila',
'azarar',
'azedo',
'azeite',
'azulejo',
'babar',
'babosa',
'bacalhau',
'bacharel',
'bacia',
'bagagem',
'baiano',
'bailar',
'baioneta',
'bairro',
'baixista',
'bajular',
'baleia',
'baliza',
'balsa',
'banal',
'bandeira',
'banho',
'banir',
'banquete',
'barato',
'barbado',
'baronesa',
'barraca',
'barulho',
'baseado',
'bastante',
'batata',
'batedor',
'batida',
'batom',
'batucar',
'baunilha',
'beber',
'beijo',
'beirada',
'beisebol',
'beldade',
'beleza',
'belga',
'beliscar',
'bendito',
'bengala',
'benzer',
'berimbau',
'berlinda',
'berro',
'besouro',
'bexiga',
'bezerro',
'bico',
'bicudo',
'bienal',
'bifocal',
'bifurcar',
'bigorna',
'bilhete',
'bimestre',
'bimotor',
'biologia',
'biombo',
'biosfera',
'bipolar',
'birrento',
'biscoito',
'bisneto',
'bispo',
'bissexto',
'bitola',
'bizarro',
'blindado',
'bloco',
'bloquear',
'boato',
'bobagem',
'bocado',
'bocejo',
'bochecha',
'boicotar',
'bolada',
'boletim',
'bolha',
'bolo',
'bombeiro',
'bonde',
'boneco',
'bonita',
'borbulha',
'borda',
'boreal',
'borracha',
'bovino',
'boxeador',
'branco',
'brasa',
'braveza',
'breu',
'briga',
'brilho',
'brincar',
'broa',
'brochura',
'bronzear',
'broto',
'bruxo',
'bucha',
'budismo',
'bufar',
'bule',
'buraco',
'busca',
'busto',
'buzina',
'cabana',
'cabelo',
'cabide',
'cabo',
'cabrito',
'cacau',
'cacetada',
'cachorro',
'cacique',
'cadastro',
'cadeado',
'cafezal',
'caiaque',
'caipira',
'caixote',
'cajado',
'caju',
'calafrio',
'calcular',
'caldeira',
'calibrar',
'calmante',
'calota',
'camada',
'cambista',
'camisa',
'camomila',
'campanha',
'camuflar',
'canavial',
'cancelar',
'caneta',
'canguru',
'canhoto',
'canivete',
'canoa',
'cansado',
'cantar',
'canudo',
'capacho',
'capela',
'capinar',
'capotar',
'capricho',
'captador',
'capuz',
'caracol',
'carbono',
'cardeal',
'careca',
'carimbar',
'carneiro',
'carpete',
'carreira',
'cartaz',
'carvalho',
'casaco',
'casca',
'casebre',
'castelo',
'casulo',
'catarata',
'cativar',
'caule',
'causador',
'cautelar',
'cavalo',
'caverna',
'cebola',
'cedilha',
'cegonha',
'celebrar',
'celular',
'cenoura',
'censo',
'centeio',
'cercar',
'cerrado',
'certeiro',
'cerveja',
'cetim',
'cevada',
'chacota',
'chaleira',
'chamado',
'chapada',
'charme',
'chatice',
'chave',
'chefe',
'chegada',
'cheiro',
'cheque',
'chicote',
'chifre',
'chinelo',
'chocalho',
'chover',
'chumbo',
'chutar',
'chuva',
'cicatriz',
'ciclone',
'cidade',
'cidreira',
'ciente',
'cigana',
'cimento',
'cinto',
'cinza',
'ciranda',
'circuito',
'cirurgia',
'citar',
'clareza',
'clero',
'clicar',
'clone',
'clube',
'coado',
'coagir',
'cobaia',
'cobertor',
'cobrar',
'cocada',
'coelho',
'coentro',
'coeso',
'cogumelo',
'coibir',
'coifa',
'coiote',
'colar',
'coleira',
'colher',
'colidir',
'colmeia',
'colono',
'coluna',
'comando',
'combinar',
'comentar',
'comitiva',
'comover',
'complexo',
'comum',
'concha',
'condor',
'conectar',
'confuso',
'congelar',
'conhecer',
'conjugar',
'consumir',
'contrato',
'convite',
'cooperar',
'copeiro',
'copiador',
'copo',
'coquetel',
'coragem',
'cordial',
'corneta',
'coronha',
'corporal',
'correio',
'cortejo',
'coruja',
'corvo',
'cosseno',
'costela',
'cotonete',
'couro',
'couve',
'covil',
'cozinha',
'cratera',
'cravo',
'creche',
'credor',
'creme',
'crer',
'crespo',
'criada',
'criminal',
'crioulo',
'crise',
'criticar',
'crosta',
'crua',
'cruzeiro',
'cubano',
'cueca',
'cuidado',
'cujo',
'culatra',
'culminar',
'culpar',
'cultura',
'cumprir',
'cunhado',
'cupido',
'curativo',
'curral',
'cursar',
'curto',
'cuspir',
'custear',
'cutelo',
'damasco',
'datar',
'debater',
'debitar',
'deboche',
'debulhar',
'decalque',
'decimal',
'declive',
'decote',
'decretar',
'dedal',
'dedicado',
'deduzir',
'defesa',
'defumar',
'degelo',
'degrau',
'degustar',
'deitado',
'deixar',
'delator',
'delegado',
'delinear',
'delonga',
'demanda',
'demitir',
'demolido',
'dentista',
'depenado',
'depilar',
'depois',
'depressa',
'depurar',
'deriva',
'derramar',
'desafio',
'desbotar',
'descanso',
'desenho',
'desfiado',
'desgaste',
'desigual',
'deslize',
'desmamar',
'desova',
'despesa',
'destaque',
'desviar',
'detalhar',
'detentor',
'detonar',
'detrito',
'deusa',
'dever',
'devido',
'devotado',
'dezena',
'diagrama',
'dialeto',
'didata',
'difuso',
'digitar',
'dilatado',
'diluente',
'diminuir',
'dinastia',
'dinheiro',
'diocese',
'direto',
'discreta',
'disfarce',
'disparo',
'disquete',
'dissipar',
'distante',
'ditador',
'diurno',
'diverso',
'divisor',
'divulgar',
'dizer',
'dobrador',
'dolorido',
'domador',
'dominado',
'donativo',
'donzela',
'dormente',
'dorsal',
'dosagem',
'dourado',
'doutor',
'drenagem',
'drible',
'drogaria',
'duelar',
'duende',
'dueto',
'duplo',
'duquesa',
'durante',
'duvidoso',
'eclodir',
'ecoar',
'ecologia',
'edificar',
'edital',
'educado',
'efeito',
'efetivar',
'ejetar',
'elaborar',
'eleger',
'eleitor',
'elenco',
'elevador',
'eliminar',
'elogiar',
'embargo',
'embolado',
'embrulho',
'embutido',
'emenda',
'emergir',
'emissor',
'empatia',
'empenho',
'empinado',
'empolgar',
'emprego',
'empurrar',
'emulador',
'encaixe',
'encenado',
'enchente',
'encontro',
'endeusar',
'endossar',
'enfaixar',
'enfeite',
'enfim',
'engajado',
'engenho',
'englobar',
'engomado',
'engraxar',
'enguia',
'enjoar',
'enlatar',
'enquanto',
'enraizar',
'enrolado',
'enrugar',
'ensaio',
'enseada',
'ensino',
'ensopado',
'entanto',
'enteado',
'entidade',
'entortar',
'entrada',
'entulho',
'envergar',
'enviado',
'envolver',
'enxame',
'enxerto',
'enxofre',
'enxuto',
'epiderme',
'equipar',
'ereto',
'erguido',
'errata',
'erva',
'ervilha',
'esbanjar',
'esbelto',
'escama',
'escola',
'escrita',
'escuta',
'esfinge',
'esfolar',
'esfregar',
'esfumado',
'esgrima',
'esmalte',
'espanto',
'espelho',
'espiga',
'esponja',
'espreita',
'espumar',
'esquerda',
'estaca',
'esteira',
'esticar',
'estofado',
'estrela',
'estudo',
'esvaziar',
'etanol',
'etiqueta',
'euforia',
'europeu',
'evacuar',
'evaporar',
'evasivo',
'eventual',
'evidente',
'evoluir',
'exagero',
'exalar',
'examinar',
'exato',
'exausto',
'excesso',
'excitar',
'exclamar',
'executar',
'exemplo',
'exibir',
'exigente',
'exonerar',
'expandir',
'expelir',
'expirar',
'explanar',
'exposto',
'expresso',
'expulsar',
'externo',
'extinto',
'extrato',
'fabricar',
'fabuloso',
'faceta',
'facial',
'fada',
'fadiga',
'faixa',
'falar',
'falta',
'familiar',
'fandango',
'fanfarra',
'fantoche',
'fardado',
'farelo',
'farinha',
'farofa',
'farpa',
'fartura',
'fatia',
'fator',
'favorita',
'faxina',
'fazenda',
'fechado',
'feijoada',
'feirante',
'felino',
'feminino',
'fenda',
'feno',
'fera',
'feriado',
'ferrugem',
'ferver',
'festejar',
'fetal',
'feudal',
'fiapo',
'fibrose',
'ficar',
'ficheiro',
'figurado',
'fileira',
'filho',
'filme',
'filtrar',
'firmeza',
'fisgada',
'fissura',
'fita',
'fivela',
'fixador',
'fixo',
'flacidez',
'flamingo',
'flanela',
'flechada',
'flora',
'flutuar',
'fluxo',
'focal',
'focinho',
'fofocar',
'fogo',
'foguete',
'foice',
'folgado',
'folheto',
'forjar',
'formiga',
'forno',
'forte',
'fosco',
'fossa',
'fragata',
'fralda',
'frango',
'frasco',
'fraterno',
'freira',
'frente',
'fretar',
'frieza',
'friso',
'fritura',
'fronha',
'frustrar',
'fruteira',
'fugir',
'fulano',
'fuligem',
'fundar',
'fungo',
'funil',
'furador',
'furioso',
'futebol',
'gabarito',
'gabinete',
'gado',
'gaiato',
'gaiola',
'gaivota',
'galega',
'galho',
'galinha',
'galocha',
'ganhar',
'garagem',
'garfo',
'gargalo',
'garimpo',
'garoupa',
'garrafa',
'gasoduto',
'gasto',
'gata',
'gatilho',
'gaveta',
'gazela',
'gelado',
'geleia',
'gelo',
'gemada',
'gemer',
'gemido',
'generoso',
'gengiva',
'genial',
'genoma',
'genro',
'geologia',
'gerador',
'germinar',
'gesso',
'gestor',
'ginasta',
'gincana',
'gingado',
'girafa',
'girino',
'glacial',
'glicose',
'global',
'glorioso',
'goela',
'goiaba',
'golfe',
'golpear',
'gordura',
'gorjeta',
'gorro',
'gostoso',
'goteira',
'governar',
'gracejo',
'gradual',
'grafite',
'gralha',
'grampo',
'granada',
'gratuito',
'graveto',
'graxa',
'grego',
'grelhar',
'greve',
'grilo',
'grisalho',
'gritaria',
'grosso',
'grotesco',
'grudado',
'grunhido',
'gruta',
'guache',
'guarani',
'guaxinim',
'guerrear',
'guiar',
'guincho',
'guisado',
'gula',
'guloso',
'guru',
'habitar',
'harmonia',
'haste',
'haver',
'hectare',
'herdar',
'heresia',
'hesitar',
'hiato',
'hibernar',
'hidratar',
'hiena',
'hino',
'hipismo',
'hipnose',
'hipoteca',
'hoje',
'holofote',
'homem',
'honesto',
'honrado',
'hormonal',
'hospedar',
'humorado',
'iate',
'ideia',
'idoso',
'ignorado',
'igreja',
'iguana',
'ileso',
'ilha',
'iludido',
'iluminar',
'ilustrar',
'imagem',
'imediato',
'imenso',
'imersivo',
'iminente',
'imitador',
'imortal',
'impacto',
'impedir',
'implante',
'impor',
'imprensa',
'impune',
'imunizar',
'inalador',
'inapto',
'inativo',
'incenso',
'inchar',
'incidir',
'incluir',
'incolor',
'indeciso',
'indireto',
'indutor',
'ineficaz',
'inerente',
'infantil',
'infestar',
'infinito',
'inflamar',
'informal',
'infrator',
'ingerir',
'inibido',
'inicial',
'inimigo',
'injetar',
'inocente',
'inodoro',
'inovador',
'inox',
'inquieto',
'inscrito',
'inseto',
'insistir',
'inspetor',
'instalar',
'insulto',
'intacto',
'integral',
'intimar',
'intocado',
'intriga',
'invasor',
'inverno',
'invicto',
'invocar',
'iogurte',
'iraniano',
'ironizar',
'irreal',
'irritado',
'isca',
'isento',
'isolado',
'isqueiro',
'italiano',
'janeiro',
'jangada',
'janta',
'jararaca',
'jardim',
'jarro',
'jasmim',
'jato',
'javali',
'jazida',
'jejum',
'joaninha',
'joelhada',
'jogador',
'joia',
'jornal',
'jorrar',
'jovem',
'juba',
'judeu',
'judoca',
'juiz',
'julgador',
'julho',
'jurado',
'jurista',
'juro',
'justa',
'labareda',
'laboral',
'lacre',
'lactante',
'ladrilho',
'lagarta',
'lagoa',
'laje',
'lamber',
'lamentar',
'laminar',
'lampejo',
'lanche',
'lapidar',
'lapso',
'laranja',
'lareira',
'largura',
'lasanha',
'lastro',
'lateral',
'latido',
'lavanda',
'lavoura',
'lavrador',
'laxante',
'lazer',
'lealdade',
'lebre',
'legado',
'legendar',
'legista',
'leigo',
'leiloar',
'leitura',
'lembrete',
'leme',
'lenhador',
'lentilha',
'leoa',
'lesma',
'leste',
'letivo',
'letreiro',
'levar',
'leveza',
'levitar',
'liberal',
'libido',
'liderar',
'ligar',
'ligeiro',
'limitar',
'limoeiro',
'limpador',
'linda',
'linear',
'linhagem',
'liquidez',
'listagem',
'lisura',
'litoral',
'livro',
'lixa',
'lixeira',
'locador',
'locutor',
'lojista',
'lombo',
'lona',
'longe',
'lontra',
'lorde',
'lotado',
'loteria',
'loucura',
'lousa',
'louvar',
'luar',
'lucidez',
'lucro',
'luneta',
'lustre',
'lutador',
'luva',
'macaco',
'macete',
'machado',
'macio',
'madeira',
'madrinha',
'magnata',
'magreza',
'maior',
'mais',
'malandro',
'malha',
'malote',
'maluco',
'mamilo',
'mamoeiro',
'mamute',
'manada',
'mancha',
'mandato',
'manequim',
'manhoso',
'manivela',
'manobrar',
'mansa',
'manter',
'manusear',
'mapeado',
'maquinar',
'marcador',
'maresia',
'marfim',
'margem',
'marinho',
'marmita',
'maroto',
'marquise',
'marreco',
'martelo',
'marujo',
'mascote',
'masmorra',
'massagem',
'mastigar',
'matagal',
'materno',
'matinal',
'matutar',
'maxilar',
'medalha',
'medida',
'medusa',
'megafone',
'meiga',
'melancia',
'melhor',
'membro',
'memorial',
'menino',
'menos',
'mensagem',
'mental',
'merecer',
'mergulho',
'mesada',
'mesclar',
'mesmo',
'mesquita',
'mestre',
'metade',
'meteoro',
'metragem',
'mexer',
'mexicano',
'micro',
'migalha',
'migrar',
'milagre',
'milenar',
'milhar',
'mimado',
'minerar',
'minhoca',
'ministro',
'minoria',
'miolo',
'mirante',
'mirtilo',
'misturar',
'mocidade',
'moderno',
'modular',
'moeda',
'moer',
'moinho',
'moita',
'moldura',
'moleza',
'molho',
'molinete',
'molusco',
'montanha',
'moqueca',
'morango',
'morcego',
'mordomo',
'morena',
'mosaico',
'mosquete',
'mostarda',
'motel',
'motim',
'moto',
'motriz',
'muda',
'muito',
'mulata',
'mulher',
'multar',
'mundial',
'munido',
'muralha',
'murcho',
'muscular',
'museu',
'musical',
'nacional',
'nadador',
'naja',
'namoro',
'narina',
'narrado',
'nascer',
'nativa',
'natureza',
'navalha',
'navegar',
'navio',
'neblina',
'nebuloso',
'negativa',
'negociar',
'negrito',
'nervoso',
'neta',
'neural',
'nevasca',
'nevoeiro',
'ninar',
'ninho',
'nitidez',
'nivelar',
'nobreza',
'noite',
'noiva',
'nomear',
'nominal',
'nordeste',
'nortear',
'notar',
'noticiar',
'noturno',
'novelo',
'novilho',
'novo',
'nublado',
'nudez',
'numeral',
'nupcial',
'nutrir',
'nuvem',
'obcecado',
'obedecer',
'objetivo',
'obrigado',
'obscuro',
'obstetra',
'obter',
'obturar',
'ocidente',
'ocioso',
'ocorrer',
'oculista',
'ocupado',
'ofegante',
'ofensiva',
'oferenda',
'oficina',
'ofuscado',
'ogiva',
'olaria',
'oleoso',
'olhar',
'oliveira',
'ombro',
'omelete',
'omisso',
'omitir',
'ondulado',
'oneroso',
'ontem',
'opcional',
'operador',
'oponente',
'oportuno',
'oposto',
'orar',
'orbitar',
'ordem',
'ordinal',
'orfanato',
'orgasmo',
'orgulho',
'oriental',
'origem',
'oriundo',
'orla',
'ortodoxo',
'orvalho',
'oscilar',
'ossada',
'osso',
'ostentar',
'otimismo',
'ousadia',
'outono',
'outubro',
'ouvido',
'ovelha',
'ovular',
'oxidar',
'oxigenar',
'pacato',
'paciente',
'pacote',
'pactuar',
'padaria',
'padrinho',
'pagar',
'pagode',
'painel',
'pairar',
'paisagem',
'palavra',
'palestra',
'palheta',
'palito',
'palmada',
'palpitar',
'pancada',
'panela',
'panfleto',
'panqueca',
'pantanal',
'papagaio',
'papelada',
'papiro',
'parafina',
'parcial',
'pardal',
'parede',
'partida',
'pasmo',
'passado',
'pastel',
'patamar',
'patente',
'patinar',
'patrono',
'paulada',
'pausar',
'peculiar',
'pedalar',
'pedestre',
'pediatra',
'pedra',
'pegada',
'peitoral',
'peixe',
'pele',
'pelicano',
'penca',
'pendurar',
'peneira',
'penhasco',
'pensador',
'pente',
'perceber',
'perfeito',
'pergunta',
'perito',
'permitir',
'perna',
'perplexo',
'persiana',
'pertence',
'peruca',
'pescado',
'pesquisa',
'pessoa',
'petiscar',
'piada',
'picado',
'piedade',
'pigmento',
'pilastra',
'pilhado',
'pilotar',
'pimenta',
'pincel',
'pinguim',
'pinha',
'pinote',
'pintar',
'pioneiro',
'pipoca',
'piquete',
'piranha',
'pires',
'pirueta',
'piscar',
'pistola',
'pitanga',
'pivete',
'planta',
'plaqueta',
'platina',
'plebeu',
'plumagem',
'pluvial',
'pneu',
'poda',
'poeira',
'poetisa',
'polegada',
'policiar',
'poluente',
'polvilho',
'pomar',
'pomba',
'ponderar',
'pontaria',
'populoso',
'porta',
'possuir',
'postal',
'pote',
'poupar',
'pouso',
'povoar',
'praia',
'prancha',
'prato',
'praxe',
'prece',
'predador',
'prefeito',
'premiar',
'prensar',
'preparar',
'presilha',
'pretexto',
'prevenir',
'prezar',
'primata',
'princesa',
'prisma',
'privado',
'processo',
'produto',
'profeta',
'proibido',
'projeto',
'prometer',
'propagar',
'prosa',
'protetor',
'provador',
'publicar',
'pudim',
'pular',
'pulmonar',
'pulseira',
'punhal',
'punir',
'pupilo',
'pureza',
'puxador',
'quadra',
'quantia',
'quarto',
'quase',
'quebrar',
'queda',
'queijo',
'quente',
'querido',
'quimono',
'quina',
'quiosque',
'rabanada',
'rabisco',
'rachar',
'racionar',
'radial',
'raiar',
'rainha',
'raio',
'raiva',
'rajada',
'ralado',
'ramal',
'ranger',
'ranhura',
'rapadura',
'rapel',
'rapidez',
'raposa',
'raquete',
'raridade',
'rasante',
'rascunho',
'rasgar',
'raspador',
'rasteira',
'rasurar',
'ratazana',
'ratoeira',
'realeza',
'reanimar',
'reaver',
'rebaixar',
'rebelde',
'rebolar',
'recado',
'recente',
'recheio',
'recibo',
'recordar',
'recrutar',
'recuar',
'rede',
'redimir',
'redonda',
'reduzida',
'reenvio',
'refinar',
'refletir',
'refogar',
'refresco',
'refugiar',
'regalia',
'regime',
'regra',
'reinado',
'reitor',
'rejeitar',
'relativo',
'remador',
'remendo',
'remorso',
'renovado',
'reparo',
'repelir',
'repleto',
'repolho',
'represa',
'repudiar',
'requerer',
'resenha',
'resfriar',
'resgatar',
'residir',
'resolver',
'respeito',
'ressaca',
'restante',
'resumir',
'retalho',
'reter',
'retirar',
'retomada',
'retratar',
'revelar',
'revisor',
'revolta',
'riacho',
'rica',
'rigidez',
'rigoroso',
'rimar',
'ringue',
'risada',
'risco',
'risonho',
'robalo',
'rochedo',
'rodada',
'rodeio',
'rodovia',
'roedor',
'roleta',
'romano',
'roncar',
'rosado',
'roseira',
'rosto',
'rota',
'roteiro',
'rotina',
'rotular',
'rouco',
'roupa',
'roxo',
'rubro',
'rugido',
'rugoso',
'ruivo',
'rumo',
'rupestre',
'russo',
'sabor',
'saciar',
'sacola',
'sacudir',
'sadio',
'safira',
'saga',
'sagrada',
'saibro',
'salada',
'saleiro',
'salgado',
'saliva',
'salpicar',
'salsicha',
'saltar',
'salvador',
'sambar',
'samurai',
'sanar',
'sanfona',
'sangue',
'sanidade',
'sapato',
'sarda',
'sargento',
'sarjeta',
'saturar',
'saudade',
'saxofone',
'sazonal',
'secar',
'secular',
'seda',
'sedento',
'sediado',
'sedoso',
'sedutor',
'segmento',
'segredo',
'segundo',
'seiva',
'seleto',
'selvagem',
'semanal',
'semente',
'senador',
'senhor',
'sensual',
'sentado',
'separado',
'sereia',
'seringa',
'serra',
'servo',
'setembro',
'setor',
'sigilo',
'silhueta',
'silicone',
'simetria',
'simpatia',
'simular',
'sinal',
'sincero',
'singular',
'sinopse',
'sintonia',
'sirene',
'siri',
'situado',
'soberano',
'sobra',
'socorro',
'sogro',
'soja',
'solda',
'soletrar',
'solteiro',
'sombrio',
'sonata',
'sondar',
'sonegar',
'sonhador',
'sono',
'soprano',
'soquete',
'sorrir',
'sorteio',
'sossego',
'sotaque',
'soterrar',
'sovado',
'sozinho',
'suavizar',
'subida',
'submerso',
'subsolo',
'subtrair',
'sucata',
'sucesso',
'suco',
'sudeste',
'sufixo',
'sugador',
'sugerir',
'sujeito',
'sulfato',
'sumir',
'suor',
'superior',
'suplicar',
'suposto',
'suprimir',
'surdina',
'surfista',
'surpresa',
'surreal',
'surtir',
'suspiro',
'sustento',
'tabela',
'tablete',
'tabuada',
'tacho',
'tagarela',
'talher',
'talo',
'talvez',
'tamanho',
'tamborim',
'tampa',
'tangente',
'tanto',
'tapar',
'tapioca',
'tardio',
'tarefa',
'tarja',
'tarraxa',
'tatuagem',
'taurino',
'taxativo',
'taxista',
'teatral',
'tecer',
'tecido',
'teclado',
'tedioso',
'teia',
'teimar',
'telefone',
'telhado',
'tempero',
'tenente',
'tensor',
'tentar',
'termal',
'terno',
'terreno',
'tese',
'tesoura',
'testado',
'teto',
'textura',
'texugo',
'tiara',
'tigela',
'tijolo',
'timbrar',
'timidez',
'tingido',
'tinteiro',
'tiragem',
'titular',
'toalha',
'tocha',
'tolerar',
'tolice',
'tomada',
'tomilho',
'tonel',
'tontura',
'topete',
'tora',
'torcido',
'torneio',
'torque',
'torrada',
'torto',
'tostar',
'touca',
'toupeira',
'toxina',
'trabalho',
'tracejar',
'tradutor',
'trafegar',
'trajeto',
'trama',
'trancar',
'trapo',
'traseiro',
'tratador',
'travar',
'treino',
'tremer',
'trepidar',
'trevo',
'triagem',
'tribo',
'triciclo',
'tridente',
'trilogia',
'trindade',
'triplo',
'triturar',
'triunfal',
'trocar',
'trombeta',
'trova',
'trunfo',
'truque',
'tubular',
'tucano',
'tudo',
'tulipa',
'tupi',
'turbo',
'turma',
'turquesa',
'tutelar',
'tutorial',
'uivar',
'umbigo',
'unha',
'unidade',
'uniforme',
'urologia',
'urso',
'urtiga',
'urubu',
'usado',
'usina',
'usufruir',
'vacina',
'vadiar',
'vagaroso',
'vaidoso',
'vala',
'valente',
'validade',
'valores',
'vantagem',
'vaqueiro',
'varanda',
'vareta',
'varrer',
'vascular',
'vasilha',
'vassoura',
'vazar',
'vazio',
'veado',
'vedar',
'vegetar',
'veicular',
'veleiro',
'velhice',
'veludo',
'vencedor',
'vendaval',
'venerar',
'ventre',
'verbal',
'verdade',
'vereador',
'vergonha',
'vermelho',
'verniz',
'versar',
'vertente',
'vespa',
'vestido',
'vetorial',
'viaduto',
'viagem',
'viajar',
'viatura',
'vibrador',
'videira',
'vidraria',
'viela',
'viga',
'vigente',
'vigiar',
'vigorar',
'vilarejo',
'vinco',
'vinheta',
'vinil',
'violeta',
'virada',
'virtude',
'visitar',
'visto',
'vitral',
'viveiro',
'vizinho',
'voador',
'voar',
'vogal',
'volante',
'voleibol',
'voltagem',
'volumoso',
'vontade',
'vulto',
'vuvuzela',
'xadrez',
'xarope',
'xeque',
'xeretar',
'xerife',
'xingar',
'zangado',
'zarpar',
'zebu',
'zelador',
'zombar',
'zoologia',
'zumbido'
];
// SPDX-License-Identifier: MIT
const WORDLIST$a = [
'ábaco',
'abdomen',
'abeja',
'abierto',
'abogado',
'abono',
'aborto',
'abrazo',
'abrir',
'abuelo',
'abuso',
'acabar',
'academia',
'acceso',
'acción',
'aceite',
'acelga',
'acento',
'aceptar',
'ácido',
'aclarar',
'acné',
'acoger',
'acoso',
'activo',
'acto',
'actriz',
'actuar',
'acudir',
'acuerdo',
'acusar',
'adicto',
'admitir',
'adoptar',
'adorno',
'aduana',
'adulto',
'aéreo',
'afectar',
'afición',
'afinar',
'afirmar',
'ágil',
'agitar',
'agonía',
'agosto',
'agotar',
'agregar',
'agrio',
'agua',
'agudo',
'águila',
'aguja',
'ahogo',
'ahorro',
'aire',
'aislar',
'ajedrez',
'ajeno',
'ajuste',
'alacrán',
'alambre',
'alarma',
'alba',
'álbum',
'alcalde',
'aldea',
'alegre',
'alejar',
'alerta',
'aleta',
'alfiler',
'alga',
'algodón',
'aliado',
'aliento',
'alivio',
'alma',
'almeja',
'almíbar',
'altar',
'alteza',
'altivo',
'alto',
'altura',
'alumno',
'alzar',
'amable',
'amante',
'amapola',
'amargo',
'amasar',
'ámbar',
'ámbito',
'ameno',
'amigo',
'amistad',
'amor',
'amparo',
'amplio',
'ancho',
'anciano',
'ancla',
'andar',
'andén',
'anemia',
'ángulo',
'anillo',
'ánimo',
'anís',
'anotar',
'antena',
'antiguo',
'antojo',
'anual',
'anular',
'anuncio',
'añadir',
'añejo',
'año',
'apagar',
'aparato',
'apetito',
'apio',
'aplicar',
'apodo',
'aporte',
'apoyo',
'aprender',
'aprobar',
'apuesta',
'apuro',
'arado',
'araña',
'arar',
'árbitro',
'árbol',
'arbusto',
'archivo',
'arco',
'arder',
'ardilla',
'arduo',
'área',
'árido',
'aries',
'armonía',
'arnés',
'aroma',
'arpa',
'arpón',
'arreglo',
'arroz',
'arruga',
'arte',
'artista',
'asa',
'asado',
'asalto',
'ascenso',
'asegurar',
'aseo',
'asesor',
'asiento',
'asilo',
'asistir',
'asno',
'asombro',
'áspero',
'astilla',
'astro',
'astuto',
'asumir',
'asunto',
'atajo',
'ataque',
'atar',
'atento',
'ateo',
'ático',
'atleta',
'átomo',
'atraer',
'atroz',
'atún',
'audaz',
'audio',
'auge',
'aula',
'aumento',
'ausente',
'autor',
'aval',
'avance',
'avaro',
'ave',
'avellana',
'avena',
'avestruz',
'avión',
'aviso',
'ayer',
'ayuda',
'ayuno',
'azafrán',
'azar',
'azote',
'azúcar',
'azufre',
'azul',
'baba',
'babor',
'bache',
'bahía',
'baile',
'bajar',
'balanza',
'balcón',
'balde',
'bambú',
'banco',
'banda',
'baño',
'barba',
'barco',
'barniz',
'barro',
'báscula',
'bastón',
'basura',
'batalla',
'batería',
'batir',
'batuta',
'baúl',
'bazar',
'bebé',
'bebida',
'bello',
'besar',
'beso',
'bestia',
'bicho',
'bien',
'bingo',
'blanco',
'bloque',
'blusa',
'boa',
'bobina',
'bobo',
'boca',
'bocina',
'boda',
'bodega',
'boina',
'bola',
'bolero',
'bolsa',
'bomba',
'bondad',
'bonito',
'bono',
'bonsái',
'borde',
'borrar',
'bosque',
'bote',
'botín',
'bóveda',
'bozal',
'bravo',
'brazo',
'brecha',
'breve',
'brillo',
'brinco',
'brisa',
'broca',
'broma',
'bronce',
'brote',
'bruja',
'brusco',
'bruto',
'buceo',
'bucle',
'bueno',
'buey',
'bufanda',
'bufón',
'búho',
'buitre',
'bulto',
'burbuja',
'burla',
'burro',
'buscar',
'butaca',
'buzón',
'caballo',
'cabeza',
'cabina',
'cabra',
'cacao',
'cadáver',
'cadena',
'caer',
'café',
'caída',
'caimán',
'caja',
'cajón',
'cal',
'calamar',
'calcio',
'caldo',
'calidad',
'calle',
'calma',
'calor',
'calvo',
'cama',
'cambio',
'camello',
'camino',
'campo',
'cáncer',
'candil',
'canela',
'canguro',
'canica',
'canto',
'caña',
'cañón',
'caoba',
'caos',
'capaz',
'capitán',
'capote',
'captar',
'capucha',
'cara',
'carbón',
'cárcel',
'careta',
'carga',
'cariño',
'carne',
'carpeta',
'carro',
'carta',
'casa',
'casco',
'casero',
'caspa',
'castor',
'catorce',
'catre',
'caudal',
'causa',
'cazo',
'cebolla',
'ceder',
'cedro',
'celda',
'célebre',
'celoso',
'célula',
'cemento',
'ceniza',
'centro',
'cerca',
'cerdo',
'cereza',
'cero',
'cerrar',
'certeza',
'césped',
'cetro',
'chacal',
'chaleco',
'champú',
'chancla',
'chapa',
'charla',
'chico',
'chiste',
'chivo',
'choque',
'choza',
'chuleta',
'chupar',
'ciclón',
'ciego',
'cielo',
'cien',
'cierto',
'cifra',
'cigarro',
'cima',
'cinco',
'cine',
'cinta',
'ciprés',
'circo',
'ciruela',
'cisne',
'cita',
'ciudad',
'clamor',
'clan',
'claro',
'clase',
'clave',
'cliente',
'clima',
'clínica',
'cobre',
'cocción',
'cochino',
'cocina',
'coco',
'código',
'codo',
'cofre',
'coger',
'cohete',
'cojín',
'cojo',
'cola',
'colcha',
'colegio',
'colgar',
'colina',
'collar',
'colmo',
'columna',
'combate',
'comer',
'comida',
'cómodo',
'compra',
'conde',
'conejo',
'conga',
'conocer',
'consejo',
'contar',
'copa',
'copia',
'corazón',
'corbata',
'corcho',
'cordón',
'corona',
'correr',
'coser',
'cosmos',
'costa',
'cráneo',
'cráter',
'crear',
'crecer',
'creído',
'crema',
'cría',
'crimen',
'cripta',
'crisis',
'cromo',
'crónica',
'croqueta',
'crudo',
'cruz',
'cuadro',
'cuarto',
'cuatro',
'cubo',
'cubrir',
'cuchara',
'cuello',
'cuento',
'cuerda',
'cuesta',
'cueva',
'cuidar',
'culebra',
'culpa',
'culto',
'cumbre',
'cumplir',
'cuna',
'cuneta',
'cuota',
'cupón',
'cúpula',
'curar',
'curioso',
'curso',
'curva',
'cutis',
'dama',
'danza',
'dar',
'dardo',
'dátil',
'deber',
'débil',
'década',
'decir',
'dedo',
'defensa',
'definir',
'dejar',
'delfín',
'delgado',
'delito',
'demora',
'denso',
'dental',
'deporte',
'derecho',
'derrota',
'desayuno',
'deseo',
'desfile',
'desnudo',
'destino',
'desvío',
'detalle',
'detener',
'deuda',
'día',
'diablo',
'diadema',
'diamante',
'diana',
'diario',
'dibujo',
'dictar',
'diente',
'dieta',
'diez',
'difícil',
'digno',
'dilema',
'diluir',
'dinero',
'directo',
'dirigir',
'disco',
'diseño',
'disfraz',
'diva',
'divino',
'doble',
'doce',
'dolor',
'domingo',
'don',
'donar',
'dorado',
'dormir',
'dorso',
'dos',
'dosis',
'dragón',
'droga',
'ducha',
'duda',
'duelo',
'dueño',
'dulce',
'dúo',
'duque',
'durar',
'dureza',
'duro',
'ébano',
'ebrio',
'echar',
'eco',
'ecuador',
'edad',
'edición',
'edificio',
'editor',
'educar',
'efecto',
'eficaz',
'eje',
'ejemplo',
'elefante',
'elegir',
'elemento',
'elevar',
'elipse',
'élite',
'elixir',
'elogio',
'eludir',
'embudo',
'emitir',
'emoción',
'empate',
'empeño',
'empleo',
'empresa',
'enano',
'encargo',
'enchufe',
'encía',
'enemigo',
'enero',
'enfado',
'enfermo',
'engaño',
'enigma',
'enlace',
'enorme',
'enredo',
'ensayo',
'enseñar',
'entero',
'entrar',
'envase',
'envío',
'época',
'equipo',
'erizo',
'escala',
'escena',
'escolar',
'escribir',
'escudo',
'esencia',
'esfera',
'esfuerzo',
'espada',
'espejo',
'espía',
'esposa',
'espuma',
'esquí',
'estar',
'este',
'estilo',
'estufa',
'etapa',
'eterno',
'ética',
'etnia',
'evadir',
'evaluar',
'evento',
'evitar',
'exacto',
'examen',
'exceso',
'excusa',
'exento',
'exigir',
'exilio',
'existir',
'éxito',
'experto',
'explicar',
'exponer',
'extremo',
'fábrica',
'fábula',
'fachada',
'fácil',
'factor',
'faena',
'faja',
'falda',
'fallo',
'falso',
'faltar',
'fama',
'familia',
'famoso',
'faraón',
'farmacia',
'farol',
'farsa',
'fase',
'fatiga',
'fauna',
'favor',
'fax',
'febrero',
'fecha',
'feliz',
'feo',
'feria',
'feroz',
'fértil',
'fervor',
'festín',
'fiable',
'fianza',
'fiar',
'fibra',
'ficción',
'ficha',
'fideo',
'fiebre',
'fiel',
'fiera',
'fiesta',
'figura',
'fijar',
'fijo',
'fila',
'filete',
'filial',
'filtro',
'fin',
'finca',
'fingir',
'finito',
'firma',
'flaco',
'flauta',
'flecha',
'flor',
'flota',
'fluir',
'flujo',
'flúor',
'fobia',
'foca',
'fogata',
'fogón',
'folio',
'folleto',
'fondo',
'forma',
'forro',
'fortuna',
'forzar',
'fosa',
'foto',
'fracaso',
'frágil',
'franja',
'frase',
'fraude',
'freír',
'freno',
'fresa',
'frío',
'frito',
'fruta',
'fuego',
'fuente',
'fuerza',
'fuga',
'fumar',
'función',
'funda',
'furgón',
'furia',
'fusil',
'fútbol',
'futuro',
'gacela',
'gafas',
'gaita',
'gajo',
'gala',
'galería',
'gallo',
'gamba',
'ganar',
'gancho',
'ganga',
'ganso',
'garaje',
'garza',
'gasolina',
'gastar',
'gato',
'gavilán',
'gemelo',
'gemir',
'gen',
'género',
'genio',
'gente',
'geranio',
'gerente',
'germen',
'gesto',
'gigante',
'gimnasio',
'girar',
'giro',
'glaciar',
'globo',
'gloria',
'gol',
'golfo',
'goloso',
'golpe',
'goma',
'gordo',
'gorila',
'gorra',
'gota',
'goteo',
'gozar',
'grada',
'gráfico',
'grano',
'grasa',
'gratis',
'grave',
'grieta',
'grillo',
'gripe',
'gris',
'grito',
'grosor',
'grúa',
'grueso',
'grumo',
'grupo',
'guante',
'guapo',
'guardia',
'guerra',
'guía',
'guiño',
'guion',
'guiso',
'guitarra',
'gusano',
'gustar',
'haber',
'hábil',
'hablar',
'hacer',
'hacha',
'hada',
'hallar',
'hamaca',
'harina',
'haz',
'hazaña',
'hebilla',
'hebra',
'hecho',
'helado',
'helio',
'hembra',
'herir',
'hermano',
'héroe',
'hervir',
'hielo',
'hierro',
'hígado',
'higiene',
'hijo',
'himno',
'historia',
'hocico',
'hogar',
'hoguera',
'hoja',
'hombre',
'hongo',
'honor',
'honra',
'hora',
'hormiga',
'horno',
'hostil',
'hoyo',
'hueco',
'huelga',
'huerta',
'hueso',
'huevo',
'huida',
'huir',
'humano',
'húmedo',
'humilde',
'humo',
'hundir',
'huracán',
'hurto',
'icono',
'ideal',
'idioma',
'ídolo',
'iglesia',
'iglú',
'igual',
'ilegal',
'ilusión',
'imagen',
'imán',
'imitar',
'impar',
'imperio',
'imponer',
'impulso',
'incapaz',
'índice',
'inerte',
'infiel',
'informe',
'ingenio',
'inicio',
'inmenso',
'inmune',
'innato',
'insecto',
'instante',
'interés',
'íntimo',
'intuir',
'inútil',
'invierno',
'ira',
'iris',
'ironía',
'isla',
'islote',
'jabalí',
'jabón',
'jamón',
'jarabe',
'jardín',
'jarra',
'jaula',
'jazmín',
'jefe',
'jeringa',
'jinete',
'jornada',
'joroba',
'joven',
'joya',
'juerga',
'jueves',
'juez',
'jugador',
'jugo',
'juguete',
'juicio',
'junco',
'jungla',
'junio',
'juntar',
'júpiter',
'jurar',
'justo',
'juvenil',
'juzgar',
'kilo',
'koala',
'labio',
'lacio',
'lacra',
'lado',
'ladrón',
'lagarto',
'lágrima',
'laguna',
'laico',
'lamer',
'lámina',
'lámpara',
'lana',
'lancha',
'langosta',
'lanza',
'lápiz',
'largo',
'larva',
'lástima',
'lata',
'látex',
'latir',
'laurel',
'lavar',
'lazo',
'leal',
'lección',
'leche',
'lector',
'leer',
'legión',
'legumbre',
'lejano',
'lengua',
'lento',
'leña',
'león',
'leopardo',
'lesión',
'letal',
'letra',
'leve',
'leyenda',
'libertad',
'libro',
'licor',
'líder',
'lidiar',
'lienzo',
'liga',
'ligero',
'lima',
'límite',
'limón',
'limpio',
'lince',
'lindo',
'línea',
'lingote',
'lino',
'linterna',
'líquido',
'liso',
'lista',
'litera',
'litio',
'litro',
'llaga',
'llama',
'llanto',
'llave',
'llegar',
'llenar',
'llevar',
'llorar',
'llover',
'lluvia',
'lobo',
'loción',
'loco',
'locura',
'lógica',
'logro',
'lombriz',
'lomo',
'lonja',
'lote',
'lucha',
'lucir',
'lugar',
'lujo',
'luna',
'lunes',
'lupa',
'lustro',
'luto',
'luz',
'maceta',
'macho',
'madera',
'madre',
'maduro',
'maestro',
'mafia',
'magia',
'mago',
'maíz',
'maldad',
'maleta',
'malla',
'malo',
'mamá',
'mambo',
'mamut',
'manco',
'mando',
'manejar',
'manga',
'maniquí',
'manjar',
'mano',
'manso',
'manta',
'mañana',
'mapa',
'máquina',
'mar',
'marco',
'marea',
'marfil',
'margen',
'marido',
'mármol',
'marrón',
'martes',
'marzo',
'masa',
'máscara',
'masivo',
'matar',
'materia',
'matiz',
'matriz',
'máximo',
'mayor',
'mazorca',
'mecha',
'medalla',
'medio',
'médula',
'mejilla',
'mejor',
'melena',
'melón',
'memoria',
'menor',
'mensaje',
'mente',
'menú',
'mercado',
'merengue',
'mérito',
'mes',
'mesón',
'meta',
'meter',
'método',
'metro',
'mezcla',
'miedo',
'miel',
'miembro',
'miga',
'mil',
'milagro',
'militar',
'millón',
'mimo',
'mina',
'minero',
'mínimo',
'minuto',
'miope',
'mirar',
'misa',
'miseria',
'misil',
'mismo',
'mitad',
'mito',
'mochila',
'moción',
'moda',
'modelo',
'moho',
'mojar',
'molde',
'moler',
'molino',
'momento',
'momia',
'monarca',
'moneda',
'monja',
'monto',
'moño',
'morada',
'morder',
'moreno',
'morir',
'morro',
'morsa',
'mortal',
'mosca',
'mostrar',
'motivo',
'mover',
'móvil',
'mozo',
'mucho',
'mudar',
'mueble',
'muela',
'muerte',
'muestra',
'mugre',
'mujer',
'mula',
'muleta',
'multa',
'mundo',
'muñeca',
'mural',
'muro',
'músculo',
'museo',
'musgo',
'música',
'muslo',
'nácar',
'nación',
'nadar',
'naipe',
'naranja',
'nariz',
'narrar',
'nasal',
'natal',
'nativo',
'natural',
'náusea',
'naval',
'nave',
'navidad',
'necio',
'néctar',
'negar',
'negocio',
'negro',
'neón',
'nervio',
'neto',
'neutro',
'nevar',
'nevera',
'nicho',
'nido',
'niebla',
'nieto',
'niñez',
'niño',
'nítido',
'nivel',
'nobleza',
'noche',
'nómina',
'noria',
'norma',
'norte',
'nota',
'noticia',
'novato',
'novela',
'novio',
'nube',
'nuca',
'núcleo',
'nudillo',
'nudo',
'nuera',
'nueve',
'nuez',
'nulo',
'número',
'nutria',
'oasis',
'obeso',
'obispo',
'objeto',
'obra',
'obrero',
'observar',
'obtener',
'obvio',
'oca',
'ocaso',
'océano',
'ochenta',
'ocho',
'ocio',
'ocre',
'octavo',
'octubre',
'oculto',
'ocupar',
'ocurrir',
'odiar',
'odio',
'odisea',
'oeste',
'ofensa',
'oferta',
'oficio',
'ofrecer',
'ogro',
'oído',
'oír',
'ojo',
'ola',
'oleada',
'olfato',
'olivo',
'olla',
'olmo',
'olor',
'olvido',
'ombligo',
'onda',
'onza',
'opaco',
'opción',
'ópera',
'opinar',
'oponer',
'optar',
'óptica',
'opuesto',
'oración',
'orador',
'oral',
'órbita',
'orca',
'orden',
'oreja',
'órgano',
'orgía',
'orgullo',
'oriente',
'origen',
'orilla',
'oro',
'orquesta',
'oruga',
'osadía',
'oscuro',
'osezno',
'oso',
'ostra',
'otoño',
'otro',
'oveja',
'óvulo',
'óxido',
'oxígeno',
'oyente',
'ozono',
'pacto',
'padre',
'paella',
'página',
'pago',
'país',
'pájaro',
'palabra',
'palco',
'paleta',
'pálido',
'palma',
'paloma',
'palpar',
'pan',
'panal',
'pánico',
'pantera',
'pañuelo',
'papá',
'papel',
'papilla',
'paquete',
'parar',
'parcela',
'pared',
'parir',
'paro',
'párpado',
'parque',
'párrafo',
'parte',
'pasar',
'paseo',
'pasión',
'paso',
'pasta',
'pata',
'patio',
'patria',
'pausa',
'pauta',
'pavo',
'payaso',
'peatón',
'pecado',
'pecera',
'pecho',
'pedal',
'pedir',
'pegar',
'peine',
'pelar',
'peldaño',
'pelea',
'peligro',
'pellejo',
'pelo',
'peluca',
'pena',
'pensar',
'peñón',
'peón',
'peor',
'pepino',
'pequeño',
'pera',
'percha',
'perder',
'pereza',
'perfil',
'perico',
'perla',
'permiso',
'perro',
'persona',
'pesa',
'pesca',
'pésimo',
'pestaña',
'pétalo',
'petróleo',
'pez',
'pezuña',
'picar',
'pichón',
'pie',
'piedra',
'pierna',
'pieza',
'pijama',
'pilar',
'piloto',
'pimienta',
'pino',
'pintor',
'pinza',
'piña',
'piojo',
'pipa',
'pirata',
'pisar',
'piscina',
'piso',
'pista',
'pitón',
'pizca',
'placa',
'plan',
'plata',
'playa',
'plaza',
'pleito',
'pleno',
'plomo',
'pluma',
'plural',
'pobre',
'poco',
'poder',
'podio',
'poema',
'poesía',
'poeta',
'polen',
'policía',
'pollo',
'polvo',
'pomada',
'pomelo',
'pomo',
'pompa',
'poner',
'porción',
'portal',
'posada',
'poseer',
'posible',
'poste',
'potencia',
'potro',
'pozo',
'prado',
'precoz',
'pregunta',
'premio',
'prensa',
'preso',
'previo',
'primo',
'príncipe',
'prisión',
'privar',
'proa',
'probar',
'proceso',
'producto',
'proeza',
'profesor',
'programa',
'prole',
'promesa',
'pronto',
'propio',
'próximo',
'prueba',
'público',
'puchero',
'pudor',
'pueblo',
'puerta',
'puesto',
'pulga',
'pulir',
'pulmón',
'pulpo',
'pulso',
'puma',
'punto',
'puñal',
'puño',
'pupa',
'pupila',
'puré',
'quedar',
'queja',
'quemar',
'querer',
'queso',
'quieto',
'química',
'quince',
'quitar',
'rábano',
'rabia',
'rabo',
'ración',
'radical',
'raíz',
'rama',
'rampa',
'rancho',
'rango',
'rapaz',
'rápido',
'rapto',
'rasgo',
'raspa',
'rato',
'rayo',
'raza',
'razón',
'reacción',
'realidad',
'rebaño',
'rebote',
'recaer',
'receta',
'rechazo',
'recoger',
'recreo',
'recto',
'recurso',
'red',
'redondo',
'reducir',
'reflejo',
'reforma',
'refrán',
'refugio',
'regalo',
'regir',
'regla',
'regreso',
'rehén',
'reino',
'reír',
'reja',
'relato',
'relevo',
'relieve',
'relleno',
'reloj',
'remar',
'remedio',
'remo',
'rencor',
'rendir',
'renta',
'reparto',
'repetir',
'reposo',
'reptil',
'res',
'rescate',
'resina',
'respeto',
'resto',
'resumen',
'retiro',
'retorno',
'retrato',
'reunir',
'revés',
'revista',
'rey',
'rezar',
'rico',
'riego',
'rienda',
'riesgo',
'rifa',
'rígido',
'rigor',
'rincón',
'riñón',
'río',
'riqueza',
'risa',
'ritmo',
'rito',
'rizo',
'roble',
'roce',
'rociar',
'rodar',
'rodeo',
'rodilla',
'roer',
'rojizo',
'rojo',
'romero',
'romper',
'ron',
'ronco',
'ronda',
'ropa',
'ropero',
'rosa',
'rosca',
'rostro',
'rotar',
'rubí',
'rubor',
'rudo',
'rueda',
'rugir',
'ruido',
'ruina',
'ruleta',
'rulo',
'rumbo',
'rumor',
'ruptura',
'ruta',
'rutina',
'sábado',
'saber',
'sabio',
'sable',
'sacar',
'sagaz',
'sagrado',
'sala',
'saldo',
'salero',
'salir',
'salmón',
'salón',
'salsa',
'salto',
'salud',
'salvar',
'samba',
'sanción',
'sandía',
'sanear',
'sangre',
'sanidad',
'sano',
'santo',
'sapo',
'saque',
'sardina',
'sartén',
'sastre',
'satán',
'sauna',
'saxofón',
'sección',
'seco',
'secreto',
'secta',
'sed',
'seguir',
'seis',
'sello',
'selva',
'semana',
'semilla',
'senda',
'sensor',
'señal',
'señor',
'separar',
'sepia',
'sequía',
'ser',
'serie',
'sermón',
'servir',
'sesenta',
'sesión',
'seta',
'setenta',
'severo',
'sexo',
'sexto',
'sidra',
'siesta',
'siete',
'siglo',
'signo',
'sílaba',
'silbar',
'silencio',
'silla',
'símbolo',
'simio',
'sirena',
'sistema',
'sitio',
'situar',
'sobre',
'socio',
'sodio',
'sol',
'solapa',
'soldado',
'soledad',
'sólido',
'soltar',
'solución',
'sombra',
'sondeo',
'sonido',
'sonoro',
'sonrisa',
'sopa',
'soplar',
'soporte',
'sordo',
'sorpresa',
'sorteo',
'sostén',
'sótano',
'suave',
'subir',
'suceso',
'sudor',
'suegra',
'suelo',
'sueño',
'suerte',
'sufrir',
'sujeto',
'sultán',
'sumar',
'superar',
'suplir',
'suponer',
'supremo',
'sur',
'surco',
'sureño',
'surgir',
'susto',
'sutil',
'tabaco',
'tabique',
'tabla',
'tabú',
'taco',
'tacto',
'tajo',
'talar',
'talco',
'talento',
'talla',
'talón',
'tamaño',
'tambor',
'tango',
'tanque',
'tapa',
'tapete',
'tapia',
'tapón',
'taquilla',
'tarde',
'tarea',
'tarifa',
'tarjeta',
'tarot',
'tarro',
'tarta',
'tatuaje',
'tauro',
'taza',
'tazón',
'teatro',
'techo',
'tecla',
'técnica',
'tejado',
'tejer',
'tejido',
'tela',
'teléfono',
'tema',
'temor',
'templo',
'tenaz',
'tender',
'tener',
'tenis',
'tenso',
'teoría',
'terapia',
'terco',
'término',
'ternura',
'terror',
'tesis',
'tesoro',
'testigo',
'tetera',
'texto',
'tez',
'tibio',
'tiburón',
'tiempo',
'tienda',
'tierra',
'tieso',
'tigre',
'tijera',
'tilde',
'timbre',
'tímido',
'timo',
'tinta',
'tío',
'típico',
'tipo',
'tira',
'tirón',
'titán',
'títere',
'título',
'tiza',
'toalla',
'tobillo',
'tocar',
'tocino',
'todo',
'toga',
'toldo',
'tomar',
'tono',
'tonto',
'topar',
'tope',
'toque',
'tórax',
'torero',
'tormenta',
'torneo',
'toro',
'torpedo',
'torre',
'torso',
'tortuga',
'tos',
'tosco',
'toser',
'tóxico',
'trabajo',
'tractor',
'traer',
'tráfico',
'trago',
'traje',
'tramo',
'trance',
'trato',
'trauma',
'trazar',
'trébol',
'tregua',
'treinta',
'tren',
'trepar',
'tres',
'tribu',
'trigo',
'tripa',
'triste',
'triunfo',
'trofeo',
'trompa',
'tronco',
'tropa',
'trote',
'trozo',
'truco',
'trueno',
'trufa',
'tubería',
'tubo',
'tuerto',
'tumba',
'tumor',
'túnel',
'túnica',
'turbina',
'turismo',
'turno',
'tutor',
'ubicar',
'úlcera',
'umbral',
'unidad',
'unir',
'universo',
'uno',
'untar',
'uña',
'urbano',
'urbe',
'urgente',
'urna',
'usar',
'usuario',
'útil',
'utopía',
'uva',
'vaca',
'vacío',
'vacuna',
'vagar',
'vago',
'vaina',
'vajilla',
'vale',
'válido',
'valle',
'valor',
'válvula',
'vampiro',
'vara',
'variar',
'varón',
'vaso',
'vecino',
'vector',
'vehículo',
'veinte',
'vejez',
'vela',
'velero',
'veloz',
'vena',
'vencer',
'venda',
'veneno',
'vengar',
'venir',
'venta',
'venus',
'ver',
'verano',
'verbo',
'verde',
'vereda',
'verja',
'verso',
'verter',
'vía',
'viaje',
'vibrar',
'vicio',
'víctima',
'vida',
'vídeo',
'vidrio',
'viejo',
'viernes',
'vigor',
'vil',
'villa',
'vinagre',
'vino',
'viñedo',
'violín',
'viral',
'virgo',
'virtud',
'visor',
'víspera',
'vista',
'vitamina',
'viudo',
'vivaz',
'vivero',
'vivir',
'vivo',
'volcán',
'volumen',
'volver',
'voraz',
'votar',
'voto',
'voz',
'vuelo',
'vulgar',
'yacer',
'yate',
'yegua',
'yema',
'yerno',
'yeso',
'yodo',
'yoga',
'yogur',
'zafiro',
'zanja',
'zapato',
'zarza',
'zona',
'zorro',
'zumo',
'zurdo'
];
// SPDX-License-Identifier: MIT
const ELECTRUM_V2_MNEMONIC_WORDS = {
TWELVE: 12,
TWENTY_FOUR: 24
};
const ELECTRUM_V2_MNEMONIC_LANGUAGES = {
CHINESE_SIMPLIFIED: 'chinese-simplified',
ENGLISH: 'english',
PORTUGUESE: 'portuguese',
SPANISH: 'spanish'
};
const ELECTRUM_V2_MNEMONIC_TYPES = {
STANDARD: 'standard',
SEGWIT: 'segwit',
STANDARD_2FA: 'standard-2fa',
SEGWIT_2FA: 'segwit-2fa'
};
class ElectrumV2Mnemonic extends Mnemonic {
static wordBitLength = 11;
static wordsList = [
ELECTRUM_V2_MNEMONIC_WORDS.TWELVE,
ELECTRUM_V2_MNEMONIC_WORDS.TWENTY_FOUR
];
static wordsToEntropyStrength = {
12: ELECTRUM_V2_ENTROPY_STRENGTHS.ONE_HUNDRED_THIRTY_TWO,
24: ELECTRUM_V2_ENTROPY_STRENGTHS.TWO_HUNDRED_SIXTY_FOUR
};
static languages = Object.values(ELECTRUM_V2_MNEMONIC_LANGUAGES);
static wordLists = {
[ELECTRUM_V2_MNEMONIC_LANGUAGES.CHINESE_SIMPLIFIED]: WORDLIST$d,
[ELECTRUM_V2_MNEMONIC_LANGUAGES.ENGLISH]: WORDLIST$c,
[ELECTRUM_V2_MNEMONIC_LANGUAGES.PORTUGUESE]: WORDLIST$b,
[ELECTRUM_V2_MNEMONIC_LANGUAGES.SPANISH]: WORDLIST$a
};
static mnemonicTypes = {
[ELECTRUM_V2_MNEMONIC_TYPES.STANDARD]: '01',
[ELECTRUM_V2_MNEMONIC_TYPES.SEGWIT]: '100',
[ELECTRUM_V2_MNEMONIC_TYPES.STANDARD_2FA]: '101',
[ELECTRUM_V2_MNEMONIC_TYPES.SEGWIT_2FA]: '102'
};
static getName() {
return 'Electrum-V2';
}
static fromWords(count, language, option = {
mnemonicType: ELECTRUM_V2_MNEMONIC_TYPES.STANDARD,
maxAttempts: BigInt('1' + '0'.repeat(60))
}) {
if (!this.wordsList.includes(count)) {
throw new MnemonicError('Invalid mnemonic words number', {
expected: this.wordsList,
got: count,
});
}
const entropyBytes = ElectrumV2Entropy.generate(this.wordsToEntropyStrength[count]);
return this.fromEntropy(entropyBytes, language, option);
}
static fromEntropy(entropy, language, option = {
mnemonicType: ELECTRUM_V2_MNEMONIC_TYPES.STANDARD,
maxAttempts: BigInt('1' + '0'.repeat(60))
}) {
if (!option.mnemonicType) {
throw new MnemonicError('mnemonicType is required');
}
if (!option.maxAttempts) {
option.maxAttempts = BigInt('1' + '0'.repeat(60));
}
let raw;
if (typeof entropy === 'string') {
raw = getBytes(entropy);
}
else if (entropy instanceof Uint8Array) {
raw = entropy;
}
else {
raw = getBytes(entropy.getEntropy());
}
if (!ElectrumV2Entropy.areEntropyBitsEnough(raw)) {
throw new EntropyError('Entropy bit length is not enough for generating a valid mnemonic');
}
const wordsList = this.normalize(this.getWordsListByLanguage(language, this.wordLists));
const bip39List = this.normalize(this.getWordsListByLanguage(language, BIP39Mnemonic.wordLists));
const bip39Index = Object.fromEntries(bip39List.map((w, i) => [w, i]));
let ev1List = [];
let ev1Index = {};
try {
ev1List = this.normalize(this.getWordsListByLanguage(language, ElectrumV1Mnemonic.wordLists));
ev1Index = Object.fromEntries(ev1List.map((w, i) => [w, i]));
}
catch {
}
const baseEnt = bytesToInteger(raw, false);
// try offsets 0,1,2… up to maxAttempts
for (let offset = BigInt(0); offset < option.maxAttempts; offset++) {
const candidate = integerToBytes(baseEnt + offset, raw.length, 'big');
try {
return this.encode(candidate, language, {
mnemonicType: option.mnemonicType,
wordsList: wordsList,
bip39List: bip39List,
bip39Index: bip39Index,
ev1List: ev1List,
ev1Index: ev1Index
});
}
catch (err) {
if (err instanceof EntropyError) {
continue;
}
throw err;
}
}
throw new MnemonicError('Unable to generate a valid mnemonic');
}
static encode(entropy, language, option = {
mnemonicType: ELECTRUM_V2_MNEMONIC_TYPES.STANDARD
}) {
if (!option.mnemonicType) {
throw new MnemonicError('mnemonicType is required');
}
const entropyBytes = getBytes(entropy);
let ent = bytesToInteger(entropyBytes, false);
if (!ElectrumV2Entropy.areEntropyBitsEnough(entropyBytes)) {
throw new EntropyError('Invalid entropy strength for V2');
}
const wl = option.wordsList ?? this.normalize(this.getWordsListByLanguage(language, this.wordLists));
const mnemonic = [];
// repeatedly mod/divide
while (ent > BigInt(0)) {
const idx = Number(ent % BigInt(wl.length));
ent = ent / BigInt(wl.length);
mnemonic.push(wl[idx]);
}
if (BIP39Mnemonic.isValid(mnemonic, { wordsList: option.bip39List, wordsListWithIndex: option.bip39Index }) ||
ElectrumV1Mnemonic.isValid(mnemonic, { wordsList: option.ev1List, wordsListWithIndex: option.ev1Index })) {
throw new EntropyError('Entropy bytes are not suitable for generating a valid mnemonic');
}
if (!this.isType(mnemonic, option.mnemonicType)) {
throw new EntropyError(`Could not generate a '${option.mnemonicType}' mnemonic`);
}
return this.normalize(mnemonic).join(' ');
}
static decode(mnemonic, option = {
mnemonicType: ELECTRUM_V2_MNEMONIC_TYPES.STANDARD
}) {
if (!option.mnemonicType) {
throw new MnemonicError('mnemonicType is required');
}
const words = this.normalize(mnemonic);
if (!this.wordsList.includes(words.length)) {
throw new MnemonicError('Invalid mnemonic words count', {
expected: this.wordsList, got: words.length,
});
}
if (!this.isValid(words, option)) {
throw new MnemonicError(`Invalid ${option.mnemonicType} mnemonic words`);
}
const [wordsList] = this.findLanguage(words, this.wordLists);
const idxMap = Object.fromEntries(wordsList.map((w, i) => [w, i]));
let ent = BigInt(0);
// reverse process: from last word to first
for (const w of words.slice().reverse()) {
ent = ent * BigInt(wordsList.length) + BigInt(idxMap[w]);
}
// convert bigint -> bytes -> hex
const byteLen = Math.ceil(words.length * this.wordBitLength / 8);
const buf = integerToBytes(ent, byteLen, 'big');
return bytesToString(buf);
}
static isValid(input, option = {
mnemonicType: ELECTRUM_V2_MNEMONIC_TYPES.STANDARD
}) {
if (BIP39Mnemonic.isValid(input, {
wordsList: option.bip39List, wordsListWithIndex: option.bip39Index
}) ||
ElectrumV1Mnemonic.isValid(input, {
wordsList: option.ev1List, wordsListWithIndex: option.ev1Index
})) {
return false;
}
return this.isType(input, option.mnemonicType ?? ELECTRUM_V2_MNEMONIC_TYPES.STANDARD);
}
static isType(input, mnemonicType) {
const tag = bytesToString(hmacSha512(toBuffer('Seed version'), this.normalize(input).join(' ')));
return tag.startsWith(this.mnemonicTypes[mnemonicType]);
}
getMnemonicType() {
if (!this.options?.mnemonicType) {
throw new MnemonicError('mnemonicType is not found');
}
return this.options?.mnemonicType;
}
static normalize(input) {
const arr = typeof input === 'string' ? input.trim().split(/\s+/) : input;
return arr.map(w => w.normalize('NFKD').toLowerCase());
}
}
// SPDX-License-Identifier: MIT
const WORDLIST$9 = [
'的',
'一',
'是',
'在',
'不',
'了',
'有',
'和',
'人',
'这',
'中',
'大',
'为',
'上',
'个',
'国',
'我',
'以',
'要',
'他',
'时',
'来',
'用',
'们',
'生',
'到',
'作',
'地',
'于',
'出',
'就',
'分',
'对',
'成',
'会',
'可',
'主',
'发',
'年',
'动',
'同',
'工',
'也',
'能',
'下',
'过',
'子',
'说',
'产',
'种',
'面',
'而',
'方',
'后',
'多',
'定',
'行',
'学',
'法',
'所',
'民',
'得',
'经',
'十',
'三',
'之',
'进',
'着',
'等',
'部',
'度',
'家',
'电',
'力',
'里',
'如',
'水',
'化',
'高',
'自',
'二',
'理',
'起',
'小',
'物',
'现',
'实',
'加',
'量',
'都',
'两',
'体',
'制',
'机',
'当',
'使',
'点',
'从',
'业',
'本',
'去',
'把',
'性',
'好',
'应',
'开',
'它',
'合',
'还',
'因',
'由',
'其',
'些',
'然',
'前',
'外',
'天',
'政',
'四',
'日',
'那',
'社',
'义',
'事',
'平',
'形',
'相',
'全',
'表',
'间',
'样',
'与',
'关',
'各',
'重',
'新',
'线',
'内',
'数',
'正',
'心',
'反',
'你',
'明',
'看',
'原',
'又',
'么',
'利',
'比',
'或',
'但',
'质',
'气',
'第',
'向',
'道',
'命',
'此',
'变',
'条',
'只',
'没',
'结',
'解',
'问',
'意',
'建',
'月',
'公',
'无',
'系',
'军',
'很',
'情',
'者',
'最',
'立',
'代',
'想',
'已',
'通',
'并',
'提',
'直',
'题',
'党',
'程',
'展',
'五',
'果',
'料',
'象',
'员',
'革',
'位',
'入',
'常',
'文',
'总',
'次',
'品',
'式',
'活',
'设',
'及',
'管',
'特',
'件',
'长',
'求',
'老',
'头',
'基',
'资',
'边',
'流',
'路',
'级',
'少',
'图',
'山',
'统',
'接',
'知',
'较',
'将',
'组',
'见',
'计',
'别',
'她',
'手',
'角',
'期',
'根',
'论',
'运',
'农',
'指',
'几',
'九',
'区',
'强',
'放',
'决',
'西',
'被',
'干',
'做',
'必',
'战',
'先',
'回',
'则',
'任',
'取',
'据',
'处',
'队',
'南',
'给',
'色',
'光',
'门',
'即',
'保',
'治',
'北',
'造',
'百',
'规',
'热',
'领',
'七',
'海',
'口',
'东',
'导',
'器',
'压',
'志',
'世',
'金',
'增',
'争',
'济',
'阶',
'油',
'思',
'术',
'极',
'交',
'受',
'联',
'什',
'认',
'六',
'共',
'权',
'收',
'证',
'改',
'清',
'美',
'再',
'采',
'转',
'更',
'单',
'风',
'切',
'打',
'白',
'教',
'速',
'花',
'带',
'安',
'场',
'身',
'车',
'例',
'真',
'务',
'具',
'万',
'每',
'目',
'至',
'达',
'走',
'积',
'示',
'议',
'声',
'报',
'斗',
'完',
'类',
'八',
'离',
'华',
'名',
'确',
'才',
'科',
'张',
'信',
'马',
'节',
'话',
'米',
'整',
'空',
'元',
'况',
'今',
'集',
'温',
'传',
'土',
'许',
'步',
'群',
'广',
'石',
'记',
'需',
'段',
'研',
'界',
'拉',
'林',
'律',
'叫',
'且',
'究',
'观',
'越',
'织',
'装',
'影',
'算',
'低',
'持',
'音',
'众',
'书',
'布',
'复',
'容',
'儿',
'须',
'际',
'商',
'非',
'验',
'连',
'断',
'深',
'难',
'近',
'矿',
'千',
'周',
'委',
'素',
'技',
'备',
'半',
'办',
'青',
'省',
'列',
'习',
'响',
'约',
'支',
'般',
'史',
'感',
'劳',
'便',
'团',
'往',
'酸',
'历',
'市',
'克',
'何',
'除',
'消',
'构',
'府',
'称',
'太',
'准',
'精',
'值',
'号',
'率',
'族',
'维',
'划',
'选',
'标',
'写',
'存',
'候',
'毛',
'亲',
'快',
'效',
'斯',
'院',
'查',
'江',
'型',
'眼',
'王',
'按',
'格',
'养',
'易',
'置',
'派',
'层',
'片',
'始',
'却',
'专',
'状',
'育',
'厂',
'京',
'识',
'适',
'属',
'圆',
'包',
'火',
'住',
'调',
'满',
'县',
'局',
'照',
'参',
'红',
'细',
'引',
'听',
'该',
'铁',
'价',
'严',
'首',
'底',
'液',
'官',
'德',
'随',
'病',
'苏',
'失',
'尔',
'死',
'讲',
'配',
'女',
'黄',
'推',
'显',
'谈',
'罪',
'神',
'艺',
'呢',
'席',
'含',
'企',
'望',
'密',
'批',
'营',
'项',
'防',
'举',
'球',
'英',
'氧',
'势',
'告',
'李',
'台',
'落',
'木',
'帮',
'轮',
'破',
'亚',
'师',
'围',
'注',
'远',
'字',
'材',
'排',
'供',
'河',
'态',
'封',
'另',
'施',
'减',
'树',
'溶',
'怎',
'止',
'案',
'言',
'士',
'均',
'武',
'固',
'叶',
'鱼',
'波',
'视',
'仅',
'费',
'紧',
'爱',
'左',
'章',
'早',
'朝',
'害',
'续',
'轻',
'服',
'试',
'食',
'充',
'兵',
'源',
'判',
'护',
'司',
'足',
'某',
'练',
'差',
'致',
'板',
'田',
'降',
'黑',
'犯',
'负',
'击',
'范',
'继',
'兴',
'似',
'余',
'坚',
'曲',
'输',
'修',
'故',
'城',
'夫',
'够',
'送',
'笔',
'船',
'占',
'右',
'财',
'吃',
'富',
'春',
'职',
'觉',
'汉',
'画',
'功',
'巴',
'跟',
'虽',
'杂',
'飞',
'检',
'吸',
'助',
'升',
'阳',
'互',
'初',
'创',
'抗',
'考',
'投',
'坏',
'策',
'古',
'径',
'换',
'未',
'跑',
'留',
'钢',
'曾',
'端',
'责',
'站',
'简',
'述',
'钱',
'副',
'尽',
'帝',
'射',
'草',
'冲',
'承',
'独',
'令',
'限',
'阿',
'宣',
'环',
'双',
'请',
'超',
'微',
'让',
'控',
'州',
'良',
'轴',
'找',
'否',
'纪',
'益',
'依',
'优',
'顶',
'础',
'载',
'倒',
'房',
'突',
'坐',
'粉',
'敌',
'略',
'客',
'袁',
'冷',
'胜',
'绝',
'析',
'块',
'剂',
'测',
'丝',
'协',
'诉',
'念',
'陈',
'仍',
'罗',
'盐',
'友',
'洋',
'错',
'苦',
'夜',
'刑',
'移',
'频',
'逐',
'靠',
'混',
'母',
'短',
'皮',
'终',
'聚',
'汽',
'村',
'云',
'哪',
'既',
'距',
'卫',
'停',
'烈',
'央',
'察',
'烧',
'迅',
'境',
'若',
'印',
'洲',
'刻',
'括',
'激',
'孔',
'搞',
'甚',
'室',
'待',
'核',
'校',
'散',
'侵',
'吧',
'甲',
'游',
'久',
'菜',
'味',
'旧',
'模',
'湖',
'货',
'损',
'预',
'阻',
'毫',
'普',
'稳',
'乙',
'妈',
'植',
'息',
'扩',
'银',
'语',
'挥',
'酒',
'守',
'拿',
'序',
'纸',
'医',
'缺',
'雨',
'吗',
'针',
'刘',
'啊',
'急',
'唱',
'误',
'训',
'愿',
'审',
'附',
'获',
'茶',
'鲜',
'粮',
'斤',
'孩',
'脱',
'硫',
'肥',
'善',
'龙',
'演',
'父',
'渐',
'血',
'欢',
'械',
'掌',
'歌',
'沙',
'刚',
'攻',
'谓',
'盾',
'讨',
'晚',
'粒',
'乱',
'燃',
'矛',
'乎',
'杀',
'药',
'宁',
'鲁',
'贵',
'钟',
'煤',
'读',
'班',
'伯',
'香',
'介',
'迫',
'句',
'丰',
'培',
'握',
'兰',
'担',
'弦',
'蛋',
'沉',
'假',
'穿',
'执',
'答',
'乐',
'谁',
'顺',
'烟',
'缩',
'征',
'脸',
'喜',
'松',
'脚',
'困',
'异',
'免',
'背',
'星',
'福',
'买',
'染',
'井',
'概',
'慢',
'怕',
'磁',
'倍',
'祖',
'皇',
'促',
'静',
'补',
'评',
'翻',
'肉',
'践',
'尼',
'衣',
'宽',
'扬',
'棉',
'希',
'伤',
'操',
'垂',
'秋',
'宜',
'氢',
'套',
'督',
'振',
'架',
'亮',
'末',
'宪',
'庆',
'编',
'牛',
'触',
'映',
'雷',
'销',
'诗',
'座',
'居',
'抓',
'裂',
'胞',
'呼',
'娘',
'景',
'威',
'绿',
'晶',
'厚',
'盟',
'衡',
'鸡',
'孙',
'延',
'危',
'胶',
'屋',
'乡',
'临',
'陆',
'顾',
'掉',
'呀',
'灯',
'岁',
'措',
'束',
'耐',
'剧',
'玉',
'赵',
'跳',
'哥',
'季',
'课',
'凯',
'胡',
'额',
'款',
'绍',
'卷',
'齐',
'伟',
'蒸',
'殖',
'永',
'宗',
'苗',
'川',
'炉',
'岩',
'弱',
'零',
'杨',
'奏',
'沿',
'露',
'杆',
'探',
'滑',
'镇',
'饭',
'浓',
'航',
'怀',
'赶',
'库',
'夺',
'伊',
'灵',
'税',
'途',
'灭',
'赛',
'归',
'召',
'鼓',
'播',
'盘',
'裁',
'险',
'康',
'唯',
'录',
'菌',
'纯',
'借',
'糖',
'盖',
'横',
'符',
'私',
'努',
'堂',
'域',
'枪',
'润',
'幅',
'哈',
'竟',
'熟',
'虫',
'泽',
'脑',
'壤',
'碳',
'欧',
'遍',
'侧',
'寨',
'敢',
'彻',
'虑',
'斜',
'薄',
'庭',
'纳',
'弹',
'饲',
'伸',
'折',
'麦',
'湿',
'暗',
'荷',
'瓦',
'塞',
'床',
'筑',
'恶',
'户',
'访',
'塔',
'奇',
'透',
'梁',
'刀',
'旋',
'迹',
'卡',
'氯',
'遇',
'份',
'毒',
'泥',
'退',
'洗',
'摆',
'灰',
'彩',
'卖',
'耗',
'夏',
'择',
'忙',
'铜',
'献',
'硬',
'予',
'繁',
'圈',
'雪',
'函',
'亦',
'抽',
'篇',
'阵',
'阴',
'丁',
'尺',
'追',
'堆',
'雄',
'迎',
'泛',
'爸',
'楼',
'避',
'谋',
'吨',
'野',
'猪',
'旗',
'累',
'偏',
'典',
'馆',
'索',
'秦',
'脂',
'潮',
'爷',
'豆',
'忽',
'托',
'惊',
'塑',
'遗',
'愈',
'朱',
'替',
'纤',
'粗',
'倾',
'尚',
'痛',
'楚',
'谢',
'奋',
'购',
'磨',
'君',
'池',
'旁',
'碎',
'骨',
'监',
'捕',
'弟',
'暴',
'割',
'贯',
'殊',
'释',
'词',
'亡',
'壁',
'顿',
'宝',
'午',
'尘',
'闻',
'揭',
'炮',
'残',
'冬',
'桥',
'妇',
'警',
'综',
'招',
'吴',
'付',
'浮',
'遭',
'徐',
'您',
'摇',
'谷',
'赞',
'箱',
'隔',
'订',
'男',
'吹',
'园',
'纷',
'唐',
'败',
'宋',
'玻',
'巨',
'耕',
'坦',
'荣',
'闭',
'湾',
'键',
'凡',
'驻',
'锅',
'救',
'恩',
'剥',
'凝',
'碱',
'齿',
'截',
'炼',
'麻',
'纺',
'禁',
'废',
'盛',
'版',
'缓',
'净',
'睛',
'昌',
'婚',
'涉',
'筒',
'嘴',
'插',
'岸',
'朗',
'庄',
'街',
'藏',
'姑',
'贸',
'腐',
'奴',
'啦',
'惯',
'乘',
'伙',
'恢',
'匀',
'纱',
'扎',
'辩',
'耳',
'彪',
'臣',
'亿',
'璃',
'抵',
'脉',
'秀',
'萨',
'俄',
'网',
'舞',
'店',
'喷',
'纵',
'寸',
'汗',
'挂',
'洪',
'贺',
'闪',
'柬',
'爆',
'烯',
'津',
'稻',
'墙',
'软',
'勇',
'像',
'滚',
'厘',
'蒙',
'芳',
'肯',
'坡',
'柱',
'荡',
'腿',
'仪',
'旅',
'尾',
'轧',
'冰',
'贡',
'登',
'黎',
'削',
'钻',
'勒',
'逃',
'障',
'氨',
'郭',
'峰',
'币',
'港',
'伏',
'轨',
'亩',
'毕',
'擦',
'莫',
'刺',
'浪',
'秘',
'援',
'株',
'健',
'售',
'股',
'岛',
'甘',
'泡',
'睡',
'童',
'铸',
'汤',
'阀',
'休',
'汇',
'舍',
'牧',
'绕',
'炸',
'哲',
'磷',
'绩',
'朋',
'淡',
'尖',
'启',
'陷',
'柴',
'呈',
'徒',
'颜',
'泪',
'稍',
'忘',
'泵',
'蓝',
'拖',
'洞',
'授',
'镜',
'辛',
'壮',
'锋',
'贫',
'虚',
'弯',
'摩',
'泰',
'幼',
'廷',
'尊',
'窗',
'纲',
'弄',
'隶',
'疑',
'氏',
'宫',
'姐',
'震',
'瑞',
'怪',
'尤',
'琴',
'循',
'描',
'膜',
'违',
'夹',
'腰',
'缘',
'珠',
'穷',
'森',
'枝',
'竹',
'沟',
'催',
'绳',
'忆',
'邦',
'剩',
'幸',
'浆',
'栏',
'拥',
'牙',
'贮',
'礼',
'滤',
'钠',
'纹',
'罢',
'拍',
'咱',
'喊',
'袖',
'埃',
'勤',
'罚',
'焦',
'潜',
'伍',
'墨',
'欲',
'缝',
'姓',
'刊',
'饱',
'仿',
'奖',
'铝',
'鬼',
'丽',
'跨',
'默',
'挖',
'链',
'扫',
'喝',
'袋',
'炭',
'污',
'幕',
'诸',
'弧',
'励',
'梅',
'奶',
'洁',
'灾',
'舟',
'鉴',
'苯',
'讼',
'抱',
'毁',
'懂',
'寒',
'智',
'埔',
'寄',
'届',
'跃',
'渡',
'挑',
'丹',
'艰',
'贝',
'碰',
'拔',
'爹',
'戴',
'码',
'梦',
'芽',
'熔',
'赤',
'渔',
'哭',
'敬',
'颗',
'奔',
'铅',
'仲',
'虎',
'稀',
'妹',
'乏',
'珍',
'申',
'桌',
'遵',
'允',
'隆',
'螺',
'仓',
'魏',
'锐',
'晓',
'氮',
'兼',
'隐',
'碍',
'赫',
'拨',
'忠',
'肃',
'缸',
'牵',
'抢',
'博',
'巧',
'壳',
'兄',
'杜',
'讯',
'诚',
'碧',
'祥',
'柯',
'页',
'巡',
'矩',
'悲',
'灌',
'龄',
'伦',
'票',
'寻',
'桂',
'铺',
'圣',
'恐',
'恰',
'郑',
'趣',
'抬',
'荒',
'腾',
'贴',
'柔',
'滴',
'猛',
'阔',
'辆',
'妻',
'填',
'撤',
'储',
'签',
'闹',
'扰',
'紫',
'砂',
'递',
'戏',
'吊',
'陶',
'伐',
'喂',
'疗',
'瓶',
'婆',
'抚',
'臂',
'摸',
'忍',
'虾',
'蜡',
'邻',
'胸',
'巩',
'挤',
'偶',
'弃',
'槽',
'劲',
'乳',
'邓',
'吉',
'仁',
'烂',
'砖',
'租',
'乌',
'舰',
'伴',
'瓜',
'浅',
'丙',
'暂',
'燥',
'橡',
'柳',
'迷',
'暖',
'牌',
'秧',
'胆',
'详',
'簧',
'踏',
'瓷',
'谱',
'呆',
'宾',
'糊',
'洛',
'辉',
'愤',
'竞',
'隙',
'怒',
'粘',
'乃',
'绪',
'肩',
'籍',
'敏',
'涂',
'熙',
'皆',
'侦',
'悬',
'掘',
'享',
'纠',
'醒',
'狂',
'锁',
'淀',
'恨',
'牲',
'霸',
'爬',
'赏',
'逆',
'玩',
'陵',
'祝',
'秒',
'浙',
'貌'
];
// SPDX-License-Identifier: MIT
const WORDLIST$8 = [
'aalglad',
'aalscholver',
'aambeeld',
'aangeef',
'aanlandig',
'aanvaard',
'aanwakker',
'aapmens',
'aarten',
'abdicatie',
'abnormaal',
'abrikoos',
'accu',
'acuut',
'adjudant',
'admiraal',
'advies',
'afbidding',
'afdracht',
'affaire',
'affiche',
'afgang',
'afkick',
'afknap',
'aflees',
'afmijner',
'afname',
'afpreekt',
'afrader',
'afspeel',
'aftocht',
'aftrek',
'afzijdig',
'ahornboom',
'aktetas',
'akzo',
'alchemist',
'alcohol',
'aldaar',
'alexander',
'alfabet',
'alfredo',
'alice',
'alikruik',
'allrisk',
'altsax',
'alufolie',
'alziend',
'amai',
'ambacht',
'ambieer',
'amina',
'amnestie',
'amok',
'ampul',
'amuzikaal',
'angela',
'aniek',
'antje',
'antwerpen',
'anya',
'aorta',
'apache',
'apekool',
'appelaar',
'arganolie',
'argeloos',
'armoede',
'arrenslee',
'artritis',
'arubaan',
'asbak',
'ascii',
'asgrauw',
'asjes',
'asml',
'aspunt',
'asurn',
'asveld',
'aterling',
'atomair',
'atrium',
'atsma',
'atypisch',
'auping',
'aura',
'avifauna',
'axiaal',
'azoriaan',
'azteek',
'azuur',
'bachelor',
'badderen',
'badhotel',
'badmantel',
'badsteden',
'balie',
'ballans',
'balvers',
'bamibal',
'banneling',
'barracuda',
'basaal',
'batelaan',
'batje',
'beambte',
'bedlamp',
'bedwelmd',
'befaamd',
'begierd',
'begraaf',
'behield',
'beijaard',
'bejaagd',
'bekaaid',
'beks',
'bektas',
'belaad',
'belboei',
'belderbos',
'beloerd',
'beluchten',
'bemiddeld',
'benadeeld',
'benijd',
'berechten',
'beroemd',
'besef',
'besseling',
'best',
'betichten',
'bevind',
'bevochten',
'bevraagd',
'bewust',
'bidplaats',
'biefstuk',
'biemans',
'biezen',
'bijbaan',
'bijeenkom',
'bijfiguur',
'bijkaart',
'bijlage',
'bijpaard',
'bijtgaar',
'bijweg',
'bimmel',
'binck',
'bint',
'biobak',
'biotisch',
'biseks',
'bistro',
'bitter',
'bitumen',
'bizar',
'blad',
'bleken',
'blender',
'bleu',
'blief',
'blijven',
'blozen',
'bock',
'boef',
'boei',
'boks',
'bolder',
'bolus',
'bolvormig',
'bomaanval',
'bombarde',
'bomma',
'bomtapijt',
'bookmaker',
'boos',
'borg',
'bosbes',
'boshuizen',
'bosloop',
'botanicus',
'bougie',
'bovag',
'boxspring',
'braad',
'brasem',
'brevet',
'brigade',
'brinckman',
'bruid',
'budget',
'buffel',
'buks',
'bulgaar',
'buma',
'butaan',
'butler',
'buuf',
'cactus',
'cafeetje',
'camcorder',
'cannabis',
'canyon',
'capoeira',
'capsule',
'carkit',
'casanova',
'catalaan',
'ceintuur',
'celdeling',
'celplasma',
'cement',
'censeren',
'ceramisch',
'cerberus',
'cerebraal',
'cesium',
'cirkel',
'citeer',
'civiel',
'claxon',
'clenbuterol',
'clicheren',
'clijsen',
'coalitie',
'coassistentschap',
'coaxiaal',
'codetaal',
'cofinanciering',
'cognac',
'coltrui',
'comfort',
'commandant',
'condensaat',
'confectie',
'conifeer',
'convector',
'copier',
'corfu',
'correct',
'coup',
'couvert',
'creatie',
'credit',
'crematie',
'cricket',
'croupier',
'cruciaal',
'cruijff',
'cuisine',
'culemborg',
'culinair',
'curve',
'cyrano',
'dactylus',
'dading',
'dagblind',
'dagje',
'daglicht',
'dagprijs',
'dagranden',
'dakdekker',
'dakpark',
'dakterras',
'dalgrond',
'dambord',
'damkat',
'damlengte',
'damman',
'danenberg',
'debbie',
'decibel',
'defect',
'deformeer',
'degelijk',
'degradant',
'dejonghe',
'dekken',
'deppen',
'derek',
'derf',
'derhalve',
'detineren',
'devalueer',
'diaken',
'dicht',
'dictaat',
'dief',
'digitaal',
'dijbreuk',
'dijkmans',
'dimbaar',
'dinsdag',
'diode',
'dirigeer',
'disbalans',
'dobermann',
'doenbaar',
'doerak',
'dogma',
'dokhaven',
'dokwerker',
'doling',
'dolphijn',
'dolven',
'dombo',
'dooraderd',
'dopeling',
'doping',
'draderig',
'drama',
'drenkbak',
'dreumes',
'drol',
'drug',
'duaal',
'dublin',
'duplicaat',
'durven',
'dusdanig',
'dutchbat',
'dutje',
'dutten',
'duur',
'duwwerk',
'dwaal',
'dweil',
'dwing',
'dyslexie',
'ecostroom',
'ecotaks',
'educatie',
'eeckhout',
'eede',
'eemland',
'eencellig',
'eeneiig',
'eenruiter',
'eenwinter',
'eerenberg',
'eerrover',
'eersel',
'eetmaal',
'efteling',
'egaal',
'egtberts',
'eickhoff',
'eidooier',
'eiland',
'eind',
'eisden',
'ekster',
'elburg',
'elevatie',
'elfkoppig',
'elfrink',
'elftal',
'elimineer',
'elleboog',
'elma',
'elodie',
'elsa',
'embleem',
'embolie',
'emoe',
'emonds',
'emplooi',
'enduro',
'enfin',
'engageer',
'entourage',
'entstof',
'epileer',
'episch',
'eppo',
'erasmus',
'erboven',
'erebaan',
'erelijst',
'ereronden',
'ereteken',
'erfhuis',
'erfwet',
'erger',
'erica',
'ermitage',
'erna',
'ernie',
'erts',
'ertussen',
'eruitzien',
'ervaar',
'erven',
'erwt',
'esbeek',
'escort',
'esdoorn',
'essing',
'etage',
'eter',
'ethanol',
'ethicus',
'etholoog',
'eufonisch',
'eurocent',
'evacuatie',
'exact',
'examen',
'executant',
'exen',
'exit',
'exogeen',
'exotherm',
'expeditie',
'expletief',
'expres',
'extase',
'extinctie',
'faal',
'faam',
'fabel',
'facultair',
'fakir',
'fakkel',
'faliekant',
'fallisch',
'famke',
'fanclub',
'fase',
'fatsoen',
'fauna',
'federaal',
'feedback',
'feest',
'feilbaar',
'feitelijk',
'felblauw',
'figurante',
'fiod',
'fitheid',
'fixeer',
'flap',
'fleece',
'fleur',
'flexibel',
'flits',
'flos',
'flow',
'fluweel',
'foezelen',
'fokkelman',
'fokpaard',
'fokvee',
'folder',
'follikel',
'folmer',
'folteraar',
'fooi',
'foolen',
'forfait',
'forint',
'formule',
'fornuis',
'fosfaat',
'foxtrot',
'foyer',
'fragiel',
'frater',
'freak',
'freddie',
'fregat',
'freon',
'frijnen',
'fructose',
'frunniken',
'fuiven',
'funshop',
'furieus',
'fysica',
'gadget',
'galder',
'galei',
'galg',
'galvlieg',
'galzuur',
'ganesh',
'gaswet',
'gaza',
'gazelle',
'geaaid',
'gebiecht',
'gebufferd',
'gedijd',
'geef',
'geflanst',
'gefreesd',
'gegaan',
'gegijzeld',
'gegniffel',
'gegraaid',
'gehikt',
'gehobbeld',
'gehucht',
'geiser',
'geiten',
'gekaakt',
'gekheid',
'gekijf',
'gekmakend',
'gekocht',
'gekskap',
'gekte',
'gelubberd',
'gemiddeld',
'geordend',
'gepoederd',
'gepuft',
'gerda',
'gerijpt',
'geseald',
'geshockt',
'gesierd',
'geslaagd',
'gesnaaid',
'getracht',
'getwijfel',
'geuit',
'gevecht',
'gevlagd',
'gewicht',
'gezaagd',
'gezocht',
'ghanees',
'giebelen',
'giechel',
'giepmans',
'gips',
'giraal',
'gistachtig',
'gitaar',
'glaasje',
'gletsjer',
'gleuf',
'glibberen',
'glijbaan',
'gloren',
'gluipen',
'gluren',
'gluur',
'gnoe',
'goddelijk',
'godgans',
'godschalk',
'godzalig',
'goeierd',
'gogme',
'goklustig',
'gokwereld',
'gonggrijp',
'gonje',
'goor',
'grabbel',
'graf',
'graveer',
'grif',
'grolleman',
'grom',
'groosman',
'grubben',
'gruijs',
'grut',
'guacamole',
'guido',
'guppy',
'haazen',
'hachelijk',
'haex',
'haiku',
'hakhout',
'hakken',
'hanegem',
'hans',
'hanteer',
'harrie',
'hazebroek',
'hedonist',
'heil',
'heineken',
'hekhuis',
'hekman',
'helbig',
'helga',
'helwegen',
'hengelaar',
'herkansen',
'hermafrodiet',
'hertaald',
'hiaat',
'hikspoors',
'hitachi',
'hitparade',
'hobo',
'hoeve',
'holocaust',
'hond',
'honnepon',
'hoogacht',
'hotelbed',
'hufter',
'hugo',
'huilbier',
'hulk',
'humus',
'huwbaar',
'huwelijk',
'hype',
'iconisch',
'idema',
'ideogram',
'idolaat',
'ietje',
'ijker',
'ijkheid',
'ijklijn',
'ijkmaat',
'ijkwezen',
'ijmuiden',
'ijsbox',
'ijsdag',
'ijselijk',
'ijskoud',
'ilse',
'immuun',
'impliceer',
'impuls',
'inbijten',
'inbuigen',
'indijken',
'induceer',
'indy',
'infecteer',
'inhaak',
'inkijk',
'inluiden',
'inmijnen',
'inoefenen',
'inpolder',
'inrijden',
'inslaan',
'invitatie',
'inwaaien',
'ionisch',
'isaac',
'isolatie',
'isotherm',
'isra',
'italiaan',
'ivoor',
'jacobs',
'jakob',
'jammen',
'jampot',
'jarig',
'jehova',
'jenever',
'jezus',
'joana',
'jobdienst',
'josua',
'joule',
'juich',
'jurk',
'juut',
'kaas',
'kabelaar',
'kabinet',
'kagenaar',
'kajuit',
'kalebas',
'kalm',
'kanjer',
'kapucijn',
'karregat',
'kart',
'katvanger',
'katwijk',
'kegelaar',
'keiachtig',
'keizer',
'kenletter',
'kerdijk',
'keus',
'kevlar',
'kezen',
'kickback',
'kieviet',
'kijken',
'kikvors',
'kilheid',
'kilobit',
'kilsdonk',
'kipschnitzel',
'kissebis',
'klad',
'klagelijk',
'klak',
'klapbaar',
'klaver',
'klene',
'klets',
'klijnhout',
'klit',
'klok',
'klonen',
'klotefilm',
'kluif',
'klumper',
'klus',
'knabbel',
'knagen',
'knaven',
'kneedbaar',
'knmi',
'knul',
'knus',
'kokhals',
'komiek',
'komkommer',
'kompaan',
'komrij',
'komvormig',
'koning',
'kopbal',
'kopklep',
'kopnagel',
'koppejan',
'koptekst',
'kopwand',
'koraal',
'kosmisch',
'kostbaar',
'kram',
'kraneveld',
'kras',
'kreling',
'krengen',
'kribbe',
'krik',
'kruid',
'krulbol',
'kuijper',
'kuipbank',
'kuit',
'kuiven',
'kutsmoes',
'kuub',
'kwak',
'kwatong',
'kwetsbaar',
'kwezelaar',
'kwijnen',
'kwik',
'kwinkslag',
'kwitantie',
'lading',
'lakbeits',
'lakken',
'laklaag',
'lakmoes',
'lakwijk',
'lamheid',
'lamp',
'lamsbout',
'lapmiddel',
'larve',
'laser',
'latijn',
'latuw',
'lawaai',
'laxeerpil',
'lebberen',
'ledeboer',
'leefbaar',
'leeman',
'lefdoekje',
'lefhebber',
'legboor',
'legsel',
'leguaan',
'leiplaat',
'lekdicht',
'lekrijden',
'leksteen',
'lenen',
'leraar',
'lesbienne',
'leugenaar',
'leut',
'lexicaal',
'lezing',
'lieten',
'liggeld',
'lijdzaam',
'lijk',
'lijmstang',
'lijnschip',
'likdoorn',
'likken',
'liksteen',
'limburg',
'link',
'linoleum',
'lipbloem',
'lipman',
'lispelen',
'lissabon',
'litanie',
'liturgie',
'lochem',
'loempia',
'loesje',
'logheid',
'lonen',
'lonneke',
'loom',
'loos',
'losbaar',
'loslaten',
'losplaats',
'loting',
'lotnummer',
'lots',
'louie',
'lourdes',
'louter',
'lowbudget',
'luijten',
'luikenaar',
'luilak',
'luipaard',
'luizenbos',
'lulkoek',
'lumen',
'lunzen',
'lurven',
'lutjeboer',
'luttel',
'lutz',
'luuk',
'luwte',
'luyendijk',
'lyceum',
'lynx',
'maakbaar',
'magdalena',
'malheid',
'manchet',
'manfred',
'manhaftig',
'mank',
'mantel',
'marion',
'marxist',
'masmeijer',
'massaal',
'matsen',
'matverf',
'matze',
'maude',
'mayonaise',
'mechanica',
'meifeest',
'melodie',
'meppelink',
'midvoor',
'midweeks',
'midzomer',
'miezel',
'mijnraad',
'minus',
'mirck',
'mirte',
'mispakken',
'misraden',
'miswassen',
'mitella',
'moker',
'molecule',
'mombakkes',
'moonen',
'mopperaar',
'moraal',
'morgana',
'mormel',
'mosselaar',
'motregen',
'mouw',
'mufheid',
'mutueel',
'muzelman',
'naaidoos',
'naald',
'nadeel',
'nadruk',
'nagy',
'nahon',
'naima',
'nairobi',
'napalm',
'napels',
'napijn',
'napoleon',
'narigheid',
'narratief',
'naseizoen',
'nasibal',
'navigatie',
'nawijn',
'negatief',
'nekletsel',
'nekwervel',
'neolatijn',
'neonataal',
'neptunus',
'nerd',
'nest',
'neuzelaar',
'nihiliste',
'nijenhuis',
'nijging',
'nijhoff',
'nijl',
'nijptang',
'nippel',
'nokkenas',
'noordam',
'noren',
'normaal',
'nottelman',
'notulant',
'nout',
'nuance',
'nuchter',
'nudorp',
'nulde',
'nullijn',
'nulmeting',
'nunspeet',
'nylon',
'obelisk',
'object',
'oblie',
'obsceen',
'occlusie',
'oceaan',
'ochtend',
'ockhuizen',
'oerdom',
'oergezond',
'oerlaag',
'oester',
'okhuijsen',
'olifant',
'olijfboer',
'omaans',
'ombudsman',
'omdat',
'omdijken',
'omdoen',
'omgebouwd',
'omkeer',
'omkomen',
'ommegaand',
'ommuren',
'omroep',
'omruil',
'omslaan',
'omsmeden',
'omvaar',
'onaardig',
'onedel',
'onenig',
'onheilig',
'onrecht',
'onroerend',
'ontcijfer',
'onthaal',
'ontvallen',
'ontzadeld',
'onzacht',
'onzin',
'onzuiver',
'oogappel',
'ooibos',
'ooievaar',
'ooit',
'oorarts',
'oorhanger',
'oorijzer',
'oorklep',
'oorschelp',
'oorworm',
'oorzaak',
'opdagen',
'opdien',
'opdweilen',
'opel',
'opgebaard',
'opinie',
'opjutten',
'opkijken',
'opklaar',
'opkuisen',
'opkwam',
'opnaaien',
'opossum',
'opsieren',
'opsmeer',
'optreden',
'opvijzel',
'opvlammen',
'opwind',
'oraal',
'orchidee',
'orkest',
'ossuarium',
'ostendorf',
'oublie',
'oudachtig',
'oudbakken',
'oudnoors',
'oudshoorn',
'oudtante',
'oven',
'over',
'oxidant',
'pablo',
'pacht',
'paktafel',
'pakzadel',
'paljas',
'panharing',
'papfles',
'paprika',
'parochie',
'paus',
'pauze',
'paviljoen',
'peek',
'pegel',
'peigeren',
'pekela',
'pendant',
'penibel',
'pepmiddel',
'peptalk',
'periferie',
'perron',
'pessarium',
'peter',
'petfles',
'petgat',
'peuk',
'pfeifer',
'picknick',
'pief',
'pieneman',
'pijlkruid',
'pijnacker',
'pijpelink',
'pikdonker',
'pikeer',
'pilaar',
'pionier',
'pipet',
'piscine',
'pissebed',
'pitchen',
'pixel',
'plamuren',
'plan',
'plausibel',
'plegen',
'plempen',
'pleonasme',
'plezant',
'podoloog',
'pofmouw',
'pokdalig',
'ponywagen',
'popachtig',
'popidool',
'porren',
'positie',
'potten',
'pralen',
'prezen',
'prijzen',
'privaat',
'proef',
'prooi',
'prozawerk',
'pruik',
'prul',
'publiceer',
'puck',
'puilen',
'pukkelig',
'pulveren',
'pupil',
'puppy',
'purmerend',
'pustjens',
'putemmer',
'puzzelaar',
'queenie',
'quiche',
'raam',
'raar',
'raat',
'raes',
'ralf',
'rally',
'ramona',
'ramselaar',
'ranonkel',
'rapen',
'rapunzel',
'rarekiek',
'rarigheid',
'rattenhol',
'ravage',
'reactie',
'recreant',
'redacteur',
'redster',
'reewild',
'regie',
'reijnders',
'rein',
'replica',
'revanche',
'rigide',
'rijbaan',
'rijdansen',
'rijgen',
'rijkdom',
'rijles',
'rijnwijn',
'rijpma',
'rijstafel',
'rijtaak',
'rijzwepen',
'rioleer',
'ripdeal',
'riphagen',
'riskant',
'rits',
'rivaal',
'robbedoes',
'robot',
'rockact',
'rodijk',
'rogier',
'rohypnol',
'rollaag',
'rolpaal',
'roltafel',
'roof',
'roon',
'roppen',
'rosbief',
'rosharig',
'rosielle',
'rotan',
'rotleven',
'rotten',
'rotvaart',
'royaal',
'royeer',
'rubato',
'ruby',
'ruche',
'rudge',
'ruggetje',
'rugnummer',
'rugpijn',
'rugtitel',
'rugzak',
'ruilbaar',
'ruis',
'ruit',
'rukwind',
'rulijs',
'rumoeren',
'rumsdorp',
'rumtaart',
'runnen',
'russchen',
'ruwkruid',
'saboteer',
'saksisch',
'salade',
'salpeter',
'sambabal',
'samsam',
'satelliet',
'satineer',
'saus',
'scampi',
'scarabee',
'scenario',
'schobben',
'schubben',
'scout',
'secessie',
'secondair',
'seculair',
'sediment',
'seeland',
'settelen',
'setwinst',
'sheriff',
'shiatsu',
'siciliaan',
'sidderaal',
'sigma',
'sijben',
'silvana',
'simkaart',
'sinds',
'situatie',
'sjaak',
'sjardijn',
'sjezen',
'sjor',
'skinhead',
'skylab',
'slamixen',
'sleijpen',
'slijkerig',
'slordig',
'slowaak',
'sluieren',
'smadelijk',
'smiecht',
'smoel',
'smos',
'smukken',
'snackcar',
'snavel',
'sneaker',
'sneu',
'snijdbaar',
'snit',
'snorder',
'soapbox',
'soetekouw',
'soigneren',
'sojaboon',
'solo',
'solvabel',
'somber',
'sommatie',
'soort',
'soppen',
'sopraan',
'soundbar',
'spanen',
'spawater',
'spijgat',
'spinaal',
'spionage',
'spiraal',
'spleet',
'splijt',
'spoed',
'sporen',
'spul',
'spuug',
'spuw',
'stalen',
'standaard',
'star',
'stefan',
'stencil',
'stijf',
'stil',
'stip',
'stopdas',
'stoten',
'stoven',
'straat',
'strobbe',
'strubbel',
'stucadoor',
'stuif',
'stukadoor',
'subhoofd',
'subregent',
'sudoku',
'sukade',
'sulfaat',
'surinaams',
'suus',
'syfilis',
'symboliek',
'sympathie',
'synagoge',
'synchroon',
'synergie',
'systeem',
'taanderij',
'tabak',
'tachtig',
'tackelen',
'taiwanees',
'talman',
'tamheid',
'tangaslip',
'taps',
'tarkan',
'tarwe',
'tasman',
'tatjana',
'taxameter',
'teil',
'teisman',
'telbaar',
'telco',
'telganger',
'telstar',
'tenant',
'tepel',
'terzet',
'testament',
'ticket',
'tiesinga',
'tijdelijk',
'tika',
'tiksel',
'tilleman',
'timbaal',
'tinsteen',
'tiplijn',
'tippelaar',
'tjirpen',
'toezeggen',
'tolbaas',
'tolgeld',
'tolhek',
'tolo',
'tolpoort',
'toltarief',
'tolvrij',
'tomaat',
'tondeuse',
'toog',
'tooi',
'toonbaar',
'toos',
'topclub',
'toppen',
'toptalent',
'topvrouw',
'toque',
'torment',
'tornado',
'tosti',
'totdat',
'toucheer',
'toulouse',
'tournedos',
'tout',
'trabant',
'tragedie',
'trailer',
'traject',
'traktaat',
'trauma',
'tray',
'trechter',
'tred',
'tref',
'treur',
'troebel',
'tros',
'trucage',
'truffel',
'tsaar',
'tucht',
'tuenter',
'tuitelig',
'tukje',
'tuktuk',
'tulp',
'tuma',
'tureluurs',
'twijfel',
'twitteren',
'tyfoon',
'typograaf',
'ugandees',
'uiachtig',
'uier',
'uisnipper',
'ultiem',
'unitair',
'uranium',
'urbaan',
'urendag',
'ursula',
'uurcirkel',
'uurglas',
'uzelf',
'vaat',
'vakantie',
'vakleraar',
'valbijl',
'valpartij',
'valreep',
'valuatie',
'vanmiddag',
'vanonder',
'varaan',
'varken',
'vaten',
'veenbes',
'veeteler',
'velgrem',
'vellekoop',
'velvet',
'veneberg',
'venlo',
'vent',
'venusberg',
'venw',
'veredeld',
'verf',
'verhaaf',
'vermaak',
'vernaaid',
'verraad',
'vers',
'veruit',
'verzaagd',
'vetachtig',
'vetlok',
'vetmesten',
'veto',
'vetrek',
'vetstaart',
'vetten',
'veurink',
'viaduct',
'vibrafoon',
'vicariaat',
'vieux',
'vieveen',
'vijfvoud',
'villa',
'vilt',
'vimmetje',
'vindbaar',
'vips',
'virtueel',
'visdieven',
'visee',
'visie',
'vlaag',
'vleugel',
'vmbo',
'vocht',
'voesenek',
'voicemail',
'voip',
'volg',
'vork',
'vorselaar',
'voyeur',
'vracht',
'vrekkig',
'vreten',
'vrije',
'vrozen',
'vrucht',
'vucht',
'vugt',
'vulkaan',
'vulmiddel',
'vulva',
'vuren',
'waas',
'wacht',
'wadvogel',
'wafel',
'waffel',
'walhalla',
'walnoot',
'walraven',
'wals',
'walvis',
'wandaad',
'wanen',
'wanmolen',
'want',
'warklomp',
'warm',
'wasachtig',
'wasteil',
'watt',
'webhandel',
'weblog',
'webpagina',
'webzine',
'wedereis',
'wedstrijd',
'weeda',
'weert',
'wegmaaien',
'wegscheer',
'wekelijks',
'wekken',
'wekroep',
'wektoon',
'weldaad',
'welwater',
'wendbaar',
'wenkbrauw',
'wens',
'wentelaar',
'wervel',
'wesseling',
'wetboek',
'wetmatig',
'whirlpool',
'wijbrands',
'wijdbeens',
'wijk',
'wijnbes',
'wijting',
'wild',
'wimpelen',
'wingebied',
'winplaats',
'winter',
'winzucht',
'wipstaart',
'wisgerhof',
'withaar',
'witmaker',
'wokkel',
'wolf',
'wonenden',
'woning',
'worden',
'worp',
'wortel',
'wrat',
'wrijf',
'wringen',
'yoghurt',
'ypsilon',
'zaaijer',
'zaak',
'zacharias',
'zakelijk',
'zakkam',
'zakwater',
'zalf',
'zalig',
'zaniken',
'zebracode',
'zeeblauw',
'zeef',
'zeegaand',
'zeeuw',
'zege',
'zegje',
'zeil',
'zesbaans',
'zesenhalf',
'zeskantig',
'zesmaal',
'zetbaas',
'zetpil',
'zeulen',
'ziezo',
'zigzag',
'zijaltaar',
'zijbeuk',
'zijlijn',
'zijmuur',
'zijn',
'zijwaarts',
'zijzelf',
'zilt',
'zimmerman',
'zinledig',
'zinnelijk',
'zionist',
'zitdag',
'zitruimte',
'zitzak',
'zoal',
'zodoende',
'zoekbots',
'zoem',
'zoiets',
'zojuist',
'zondaar',
'zotskap',
'zottebol',
'zucht',
'zuivel',
'zulk',
'zult',
'zuster',
'zuur',
'zweedijk',
'zwendel',
'zwepen',
'zwiep',
'zwijmel',
'zworen'
];
// SPDX-License-Identifier: MIT
const WORDLIST$7 = [
'abbey',
'abducts',
'ability',
'ablaze',
'abnormal',
'abort',
'abrasive',
'absorb',
'abyss',
'academy',
'aces',
'aching',
'acidic',
'acoustic',
'acquire',
'across',
'actress',
'acumen',
'adapt',
'addicted',
'adept',
'adhesive',
'adjust',
'adopt',
'adrenalin',
'adult',
'adventure',
'aerial',
'afar',
'affair',
'afield',
'afloat',
'afoot',
'afraid',
'after',
'against',
'agenda',
'aggravate',
'agile',
'aglow',
'agnostic',
'agony',
'agreed',
'ahead',
'aided',
'ailments',
'aimless',
'airport',
'aisle',
'ajar',
'akin',
'alarms',
'album',
'alchemy',
'alerts',
'algebra',
'alkaline',
'alley',
'almost',
'aloof',
'alpine',
'already',
'also',
'altitude',
'alumni',
'always',
'amaze',
'ambush',
'amended',
'amidst',
'ammo',
'amnesty',
'among',
'amply',
'amused',
'anchor',
'android',
'anecdote',
'angled',
'ankle',
'annoyed',
'answers',
'antics',
'anvil',
'anxiety',
'anybody',
'apart',
'apex',
'aphid',
'aplomb',
'apology',
'apply',
'apricot',
'aptitude',
'aquarium',
'arbitrary',
'archer',
'ardent',
'arena',
'argue',
'arises',
'army',
'around',
'arrow',
'arsenic',
'artistic',
'ascend',
'ashtray',
'aside',
'asked',
'asleep',
'aspire',
'assorted',
'asylum',
'athlete',
'atlas',
'atom',
'atrium',
'attire',
'auburn',
'auctions',
'audio',
'august',
'aunt',
'austere',
'autumn',
'avatar',
'avidly',
'avoid',
'awakened',
'awesome',
'awful',
'awkward',
'awning',
'awoken',
'axes',
'axis',
'axle',
'aztec',
'azure',
'baby',
'bacon',
'badge',
'baffles',
'bagpipe',
'bailed',
'bakery',
'balding',
'bamboo',
'banjo',
'baptism',
'basin',
'batch',
'bawled',
'bays',
'because',
'beer',
'befit',
'begun',
'behind',
'being',
'below',
'bemused',
'benches',
'berries',
'bested',
'betting',
'bevel',
'beware',
'beyond',
'bias',
'bicycle',
'bids',
'bifocals',
'biggest',
'bikini',
'bimonthly',
'binocular',
'biology',
'biplane',
'birth',
'biscuit',
'bite',
'biweekly',
'blender',
'blip',
'bluntly',
'boat',
'bobsled',
'bodies',
'bogeys',
'boil',
'boldly',
'bomb',
'border',
'boss',
'both',
'bounced',
'bovine',
'bowling',
'boxes',
'boyfriend',
'broken',
'brunt',
'bubble',
'buckets',
'budget',
'buffet',
'bugs',
'building',
'bulb',
'bumper',
'bunch',
'business',
'butter',
'buying',
'buzzer',
'bygones',
'byline',
'bypass',
'cabin',
'cactus',
'cadets',
'cafe',
'cage',
'cajun',
'cake',
'calamity',
'camp',
'candy',
'casket',
'catch',
'cause',
'cavernous',
'cease',
'cedar',
'ceiling',
'cell',
'cement',
'cent',
'certain',
'chlorine',
'chrome',
'cider',
'cigar',
'cinema',
'circle',
'cistern',
'citadel',
'civilian',
'claim',
'click',
'clue',
'coal',
'cobra',
'cocoa',
'code',
'coexist',
'coffee',
'cogs',
'cohesive',
'coils',
'colony',
'comb',
'cool',
'copy',
'corrode',
'costume',
'cottage',
'cousin',
'cowl',
'criminal',
'cube',
'cucumber',
'cuddled',
'cuffs',
'cuisine',
'cunning',
'cupcake',
'custom',
'cycling',
'cylinder',
'cynical',
'dabbing',
'dads',
'daft',
'dagger',
'daily',
'damp',
'dangerous',
'dapper',
'darted',
'dash',
'dating',
'dauntless',
'dawn',
'daytime',
'dazed',
'debut',
'decay',
'dedicated',
'deepest',
'deftly',
'degrees',
'dehydrate',
'deity',
'dejected',
'delayed',
'demonstrate',
'dented',
'deodorant',
'depth',
'desk',
'devoid',
'dewdrop',
'dexterity',
'dialect',
'dice',
'diet',
'different',
'digit',
'dilute',
'dime',
'dinner',
'diode',
'diplomat',
'directed',
'distance',
'ditch',
'divers',
'dizzy',
'doctor',
'dodge',
'does',
'dogs',
'doing',
'dolphin',
'domestic',
'donuts',
'doorway',
'dormant',
'dosage',
'dotted',
'double',
'dove',
'down',
'dozen',
'dreams',
'drinks',
'drowning',
'drunk',
'drying',
'dual',
'dubbed',
'duckling',
'dude',
'duets',
'duke',
'dullness',
'dummy',
'dunes',
'duplex',
'duration',
'dusted',
'duties',
'dwarf',
'dwelt',
'dwindling',
'dying',
'dynamite',
'dyslexic',
'each',
'eagle',
'earth',
'easy',
'eating',
'eavesdrop',
'eccentric',
'echo',
'eclipse',
'economics',
'ecstatic',
'eden',
'edgy',
'edited',
'educated',
'eels',
'efficient',
'eggs',
'egotistic',
'eight',
'either',
'eject',
'elapse',
'elbow',
'eldest',
'eleven',
'elite',
'elope',
'else',
'eluded',
'emails',
'ember',
'emerge',
'emit',
'emotion',
'empty',
'emulate',
'energy',
'enforce',
'enhanced',
'enigma',
'enjoy',
'enlist',
'enmity',
'enough',
'enraged',
'ensign',
'entrance',
'envy',
'epoxy',
'equip',
'erase',
'erected',
'erosion',
'error',
'eskimos',
'espionage',
'essential',
'estate',
'etched',
'eternal',
'ethics',
'etiquette',
'evaluate',
'evenings',
'evicted',
'evolved',
'examine',
'excess',
'exhale',
'exit',
'exotic',
'exquisite',
'extra',
'exult',
'fabrics',
'factual',
'fading',
'fainted',
'faked',
'fall',
'family',
'fancy',
'farming',
'fatal',
'faulty',
'fawns',
'faxed',
'fazed',
'feast',
'february',
'federal',
'feel',
'feline',
'females',
'fences',
'ferry',
'festival',
'fetches',
'fever',
'fewest',
'fiat',
'fibula',
'fictional',
'fidget',
'fierce',
'fifteen',
'fight',
'films',
'firm',
'fishing',
'fitting',
'five',
'fixate',
'fizzle',
'fleet',
'flippant',
'flying',
'foamy',
'focus',
'foes',
'foggy',
'foiled',
'folding',
'fonts',
'foolish',
'fossil',
'fountain',
'fowls',
'foxes',
'foyer',
'framed',
'friendly',
'frown',
'fruit',
'frying',
'fudge',
'fuel',
'fugitive',
'fully',
'fuming',
'fungal',
'furnished',
'fuselage',
'future',
'fuzzy',
'gables',
'gadget',
'gags',
'gained',
'galaxy',
'gambit',
'gang',
'gasp',
'gather',
'gauze',
'gave',
'gawk',
'gaze',
'gearbox',
'gecko',
'geek',
'gels',
'gemstone',
'general',
'geometry',
'germs',
'gesture',
'getting',
'geyser',
'ghetto',
'ghost',
'giant',
'giddy',
'gifts',
'gigantic',
'gills',
'gimmick',
'ginger',
'girth',
'giving',
'glass',
'gleeful',
'glide',
'gnaw',
'gnome',
'goat',
'goblet',
'godfather',
'goes',
'goggles',
'going',
'goldfish',
'gone',
'goodbye',
'gopher',
'gorilla',
'gossip',
'gotten',
'gourmet',
'governing',
'gown',
'greater',
'grunt',
'guarded',
'guest',
'guide',
'gulp',
'gumball',
'guru',
'gusts',
'gutter',
'guys',
'gymnast',
'gypsy',
'gyrate',
'habitat',
'hacksaw',
'haggled',
'hairy',
'hamburger',
'happens',
'hashing',
'hatchet',
'haunted',
'having',
'hawk',
'haystack',
'hazard',
'hectare',
'hedgehog',
'heels',
'hefty',
'height',
'hemlock',
'hence',
'heron',
'hesitate',
'hexagon',
'hickory',
'hiding',
'highway',
'hijack',
'hiker',
'hills',
'himself',
'hinder',
'hippo',
'hire',
'history',
'hitched',
'hive',
'hoax',
'hobby',
'hockey',
'hoisting',
'hold',
'honked',
'hookup',
'hope',
'hornet',
'hospital',
'hotel',
'hounded',
'hover',
'howls',
'hubcaps',
'huddle',
'huge',
'hull',
'humid',
'hunter',
'hurried',
'husband',
'huts',
'hybrid',
'hydrogen',
'hyper',
'iceberg',
'icing',
'icon',
'identity',
'idiom',
'idled',
'idols',
'igloo',
'ignore',
'iguana',
'illness',
'imagine',
'imbalance',
'imitate',
'impel',
'inactive',
'inbound',
'incur',
'industrial',
'inexact',
'inflamed',
'ingested',
'initiate',
'injury',
'inkling',
'inline',
'inmate',
'innocent',
'inorganic',
'input',
'inquest',
'inroads',
'insult',
'intended',
'inundate',
'invoke',
'inwardly',
'ionic',
'irate',
'iris',
'irony',
'irritate',
'island',
'isolated',
'issued',
'italics',
'itches',
'items',
'itinerary',
'itself',
'ivory',
'jabbed',
'jackets',
'jaded',
'jagged',
'jailed',
'jamming',
'january',
'jargon',
'jaunt',
'javelin',
'jaws',
'jazz',
'jeans',
'jeers',
'jellyfish',
'jeopardy',
'jerseys',
'jester',
'jetting',
'jewels',
'jigsaw',
'jingle',
'jittery',
'jive',
'jobs',
'jockey',
'jogger',
'joining',
'joking',
'jolted',
'jostle',
'journal',
'joyous',
'jubilee',
'judge',
'juggled',
'juicy',
'jukebox',
'july',
'jump',
'junk',
'jury',
'justice',
'juvenile',
'kangaroo',
'karate',
'keep',
'kennel',
'kept',
'kernels',
'kettle',
'keyboard',
'kickoff',
'kidneys',
'king',
'kiosk',
'kisses',
'kitchens',
'kiwi',
'knapsack',
'knee',
'knife',
'knowledge',
'knuckle',
'koala',
'laboratory',
'ladder',
'lagoon',
'lair',
'lakes',
'lamb',
'language',
'laptop',
'large',
'last',
'later',
'launching',
'lava',
'lawsuit',
'layout',
'lazy',
'lectures',
'ledge',
'leech',
'left',
'legion',
'leisure',
'lemon',
'lending',
'leopard',
'lesson',
'lettuce',
'lexicon',
'liar',
'library',
'licks',
'lids',
'lied',
'lifestyle',
'light',
'likewise',
'lilac',
'limits',
'linen',
'lion',
'lipstick',
'liquid',
'listen',
'lively',
'loaded',
'lobster',
'locker',
'lodge',
'lofty',
'logic',
'loincloth',
'long',
'looking',
'lopped',
'lordship',
'losing',
'lottery',
'loudly',
'love',
'lower',
'loyal',
'lucky',
'luggage',
'lukewarm',
'lullaby',
'lumber',
'lunar',
'lurk',
'lush',
'luxury',
'lymph',
'lynx',
'lyrics',
'macro',
'madness',
'magically',
'mailed',
'major',
'makeup',
'malady',
'mammal',
'maps',
'masterful',
'match',
'maul',
'maverick',
'maximum',
'mayor',
'maze',
'meant',
'mechanic',
'medicate',
'meeting',
'megabyte',
'melting',
'memoir',
'menu',
'merger',
'mesh',
'metro',
'mews',
'mice',
'midst',
'mighty',
'mime',
'mirror',
'misery',
'mittens',
'mixture',
'moat',
'mobile',
'mocked',
'mohawk',
'moisture',
'molten',
'moment',
'money',
'moon',
'mops',
'morsel',
'mostly',
'motherly',
'mouth',
'movement',
'mowing',
'much',
'muddy',
'muffin',
'mugged',
'mullet',
'mumble',
'mundane',
'muppet',
'mural',
'musical',
'muzzle',
'myriad',
'mystery',
'myth',
'nabbing',
'nagged',
'nail',
'names',
'nanny',
'napkin',
'narrate',
'nasty',
'natural',
'nautical',
'navy',
'nearby',
'necklace',
'needed',
'negative',
'neither',
'neon',
'nephew',
'nerves',
'nestle',
'network',
'neutral',
'never',
'newt',
'nexus',
'nibs',
'niche',
'niece',
'nifty',
'nightly',
'nimbly',
'nineteen',
'nirvana',
'nitrogen',
'nobody',
'nocturnal',
'nodes',
'noises',
'nomad',
'noodles',
'northern',
'nostril',
'noted',
'nouns',
'novelty',
'nowhere',
'nozzle',
'nuance',
'nucleus',
'nudged',
'nugget',
'nuisance',
'null',
'number',
'nuns',
'nurse',
'nutshell',
'nylon',
'oaks',
'oars',
'oasis',
'oatmeal',
'obedient',
'object',
'obliged',
'obnoxious',
'observant',
'obtains',
'obvious',
'occur',
'ocean',
'october',
'odds',
'odometer',
'offend',
'often',
'oilfield',
'ointment',
'okay',
'older',
'olive',
'olympics',
'omega',
'omission',
'omnibus',
'onboard',
'oncoming',
'oneself',
'ongoing',
'onion',
'online',
'onslaught',
'onto',
'onward',
'oozed',
'opacity',
'opened',
'opposite',
'optical',
'opus',
'orange',
'orbit',
'orchid',
'orders',
'organs',
'origin',
'ornament',
'orphans',
'oscar',
'ostrich',
'otherwise',
'otter',
'ouch',
'ought',
'ounce',
'ourselves',
'oust',
'outbreak',
'oval',
'oven',
'owed',
'owls',
'owner',
'oxidant',
'oxygen',
'oyster',
'ozone',
'pact',
'paddles',
'pager',
'pairing',
'palace',
'pamphlet',
'pancakes',
'paper',
'paradise',
'pastry',
'patio',
'pause',
'pavements',
'pawnshop',
'payment',
'peaches',
'pebbles',
'peculiar',
'pedantic',
'peeled',
'pegs',
'pelican',
'pencil',
'people',
'pepper',
'perfect',
'pests',
'petals',
'phase',
'pheasants',
'phone',
'phrases',
'physics',
'piano',
'picked',
'pierce',
'pigment',
'piloted',
'pimple',
'pinched',
'pioneer',
'pipeline',
'pirate',
'pistons',
'pitched',
'pivot',
'pixels',
'pizza',
'playful',
'pledge',
'pliers',
'plotting',
'plus',
'plywood',
'poaching',
'pockets',
'podcast',
'poetry',
'point',
'poker',
'polar',
'ponies',
'pool',
'popular',
'portents',
'possible',
'potato',
'pouch',
'poverty',
'powder',
'pram',
'present',
'pride',
'problems',
'pruned',
'prying',
'psychic',
'public',
'puck',
'puddle',
'puffin',
'pulp',
'pumpkins',
'punch',
'puppy',
'purged',
'push',
'putty',
'puzzled',
'pylons',
'pyramid',
'python',
'queen',
'quick',
'quote',
'rabbits',
'racetrack',
'radar',
'rafts',
'rage',
'railway',
'raking',
'rally',
'ramped',
'randomly',
'rapid',
'rarest',
'rash',
'rated',
'ravine',
'rays',
'razor',
'react',
'rebel',
'recipe',
'reduce',
'reef',
'refer',
'regular',
'reheat',
'reinvest',
'rejoices',
'rekindle',
'relic',
'remedy',
'renting',
'reorder',
'repent',
'request',
'reruns',
'rest',
'return',
'reunion',
'revamp',
'rewind',
'rhino',
'rhythm',
'ribbon',
'richly',
'ridges',
'rift',
'rigid',
'rims',
'ringing',
'riots',
'ripped',
'rising',
'ritual',
'river',
'roared',
'robot',
'rockets',
'rodent',
'rogue',
'roles',
'romance',
'roomy',
'roped',
'roster',
'rotate',
'rounded',
'rover',
'rowboat',
'royal',
'ruby',
'rudely',
'ruffled',
'rugged',
'ruined',
'ruling',
'rumble',
'runway',
'rural',
'rustled',
'ruthless',
'sabotage',
'sack',
'sadness',
'safety',
'saga',
'sailor',
'sake',
'salads',
'sample',
'sanity',
'sapling',
'sarcasm',
'sash',
'satin',
'saucepan',
'saved',
'sawmill',
'saxophone',
'sayings',
'scamper',
'scenic',
'school',
'science',
'scoop',
'scrub',
'scuba',
'seasons',
'second',
'sedan',
'seeded',
'segments',
'seismic',
'selfish',
'semifinal',
'sensible',
'september',
'sequence',
'serving',
'session',
'setup',
'seventh',
'sewage',
'shackles',
'shelter',
'shipped',
'shocking',
'shrugged',
'shuffled',
'shyness',
'siblings',
'sickness',
'sidekick',
'sieve',
'sifting',
'sighting',
'silk',
'simplest',
'sincerely',
'sipped',
'siren',
'situated',
'sixteen',
'sizes',
'skater',
'skew',
'skirting',
'skulls',
'skydive',
'slackens',
'sleepless',
'slid',
'slower',
'slug',
'smash',
'smelting',
'smidgen',
'smog',
'smuggled',
'snake',
'sneeze',
'sniff',
'snout',
'snug',
'soapy',
'sober',
'soccer',
'soda',
'software',
'soggy',
'soil',
'solved',
'somewhere',
'sonic',
'soothe',
'soprano',
'sorry',
'southern',
'sovereign',
'sowed',
'soya',
'space',
'speedy',
'sphere',
'spiders',
'splendid',
'spout',
'sprig',
'spud',
'spying',
'square',
'stacking',
'stellar',
'stick',
'stockpile',
'strained',
'stunning',
'stylishly',
'subtly',
'succeed',
'suddenly',
'suede',
'suffice',
'sugar',
'suitcase',
'sulking',
'summon',
'sunken',
'superior',
'surfer',
'sushi',
'suture',
'swagger',
'swept',
'swiftly',
'sword',
'swung',
'syllabus',
'symptoms',
'syndrome',
'syringe',
'system',
'taboo',
'tacit',
'tadpoles',
'tagged',
'tail',
'taken',
'talent',
'tamper',
'tanks',
'tapestry',
'tarnished',
'tasked',
'tattoo',
'taunts',
'tavern',
'tawny',
'taxi',
'teardrop',
'technical',
'tedious',
'teeming',
'tell',
'template',
'tender',
'tepid',
'tequila',
'terminal',
'testing',
'tether',
'textbook',
'thaw',
'theatrics',
'thirsty',
'thorn',
'threaten',
'thumbs',
'thwart',
'ticket',
'tidy',
'tiers',
'tiger',
'tilt',
'timber',
'tinted',
'tipsy',
'tirade',
'tissue',
'titans',
'toaster',
'tobacco',
'today',
'toenail',
'toffee',
'together',
'toilet',
'token',
'tolerant',
'tomorrow',
'tonic',
'toolbox',
'topic',
'torch',
'tossed',
'total',
'touchy',
'towel',
'toxic',
'toyed',
'trash',
'trendy',
'tribal',
'trolling',
'truth',
'trying',
'tsunami',
'tubes',
'tucks',
'tudor',
'tuesday',
'tufts',
'tugs',
'tuition',
'tulips',
'tumbling',
'tunnel',
'turnip',
'tusks',
'tutor',
'tuxedo',
'twang',
'tweezers',
'twice',
'twofold',
'tycoon',
'typist',
'tyrant',
'ugly',
'ulcers',
'ultimate',
'umbrella',
'umpire',
'unafraid',
'unbending',
'uncle',
'under',
'uneven',
'unfit',
'ungainly',
'unhappy',
'union',
'unjustly',
'unknown',
'unlikely',
'unmask',
'unnoticed',
'unopened',
'unplugs',
'unquoted',
'unrest',
'unsafe',
'until',
'unusual',
'unveil',
'unwind',
'unzip',
'upbeat',
'upcoming',
'update',
'upgrade',
'uphill',
'upkeep',
'upload',
'upon',
'upper',
'upright',
'upstairs',
'uptight',
'upwards',
'urban',
'urchins',
'urgent',
'usage',
'useful',
'usher',
'using',
'usual',
'utensils',
'utility',
'utmost',
'utopia',
'uttered',
'vacation',
'vague',
'vain',
'value',
'vampire',
'vane',
'vapidly',
'vary',
'vastness',
'vats',
'vaults',
'vector',
'veered',
'vegan',
'vehicle',
'vein',
'velvet',
'venomous',
'verification',
'vessel',
'veteran',
'vexed',
'vials',
'vibrate',
'victim',
'video',
'viewpoint',
'vigilant',
'viking',
'village',
'vinegar',
'violin',
'vipers',
'virtual',
'visited',
'vitals',
'vivid',
'vixen',
'vocal',
'vogue',
'voice',
'volcano',
'vortex',
'voted',
'voucher',
'vowels',
'voyage',
'vulture',
'wade',
'waffle',
'wagtail',
'waist',
'waking',
'wallets',
'wanted',
'warped',
'washing',
'water',
'waveform',
'waxing',
'wayside',
'weavers',
'website',
'wedge',
'weekday',
'weird',
'welders',
'went',
'wept',
'were',
'western',
'wetsuit',
'whale',
'when',
'whipped',
'whole',
'wickets',
'width',
'wield',
'wife',
'wiggle',
'wildly',
'winter',
'wipeout',
'wiring',
'wise',
'withdrawn',
'wives',
'wizard',
'wobbly',
'woes',
'woken',
'wolf',
'womanly',
'wonders',
'woozy',
'worry',
'wounded',
'woven',
'wrap',
'wrist',
'wrong',
'yacht',
'yahoo',
'yanks',
'yard',
'yawning',
'yearbook',
'yellow',
'yesterday',
'yeti',
'yields',
'yodel',
'yoga',
'younger',
'yoyo',
'zapped',
'zeal',
'zebra',
'zero',
'zesty',
'zigzags',
'zinger',
'zippers',
'zodiac',
'zombie',
'zones',
'zoom'
];
// SPDX-License-Identifier: MIT
const WORDLIST$6 = [
'abandon',
'abattre',
'aboi',
'abolir',
'aborder',
'abri',
'absence',
'absolu',
'abuser',
'acacia',
'acajou',
'accent',
'accord',
'accrocher',
'accuser',
'acerbe',
'achat',
'acheter',
'acide',
'acier',
'acquis',
'acte',
'action',
'adage',
'adepte',
'adieu',
'admettre',
'admis',
'adorer',
'adresser',
'aduler',
'affaire',
'affirmer',
'afin',
'agacer',
'agent',
'agir',
'agiter',
'agonie',
'agrafe',
'agrume',
'aider',
'aigle',
'aigre',
'aile',
'ailleurs',
'aimant',
'aimer',
'ainsi',
'aise',
'ajouter',
'alarme',
'album',
'alcool',
'alerte',
'algue',
'alibi',
'aller',
'allumer',
'alors',
'amande',
'amener',
'amie',
'amorcer',
'amour',
'ample',
'amuser',
'ananas',
'ancien',
'anglais',
'angoisse',
'animal',
'anneau',
'annoncer',
'apercevoir',
'apparence',
'appel',
'apporter',
'apprendre',
'appuyer',
'arbre',
'arcade',
'arceau',
'arche',
'ardeur',
'argent',
'argile',
'aride',
'arme',
'armure',
'arracher',
'arriver',
'article',
'asile',
'aspect',
'assaut',
'assez',
'assister',
'assurer',
'astre',
'astuce',
'atlas',
'atroce',
'attacher',
'attente',
'attirer',
'aube',
'aucun',
'audace',
'auparavant',
'auquel',
'aurore',
'aussi',
'autant',
'auteur',
'autoroute',
'autre',
'aval',
'avant',
'avec',
'avenir',
'averse',
'aveu',
'avide',
'avion',
'avis',
'avoir',
'avouer',
'avril',
'azote',
'azur',
'badge',
'bagage',
'bague',
'bain',
'baisser',
'balai',
'balcon',
'balise',
'balle',
'bambou',
'banane',
'banc',
'bandage',
'banjo',
'banlieue',
'bannir',
'banque',
'baobab',
'barbe',
'barque',
'barrer',
'bassine',
'bataille',
'bateau',
'battre',
'baver',
'bavoir',
'bazar',
'beau',
'beige',
'berger',
'besoin',
'beurre',
'biais',
'biceps',
'bidule',
'bien',
'bijou',
'bilan',
'billet',
'blanc',
'blason',
'bleu',
'bloc',
'blond',
'bocal',
'boire',
'boiserie',
'boiter',
'bonbon',
'bondir',
'bonheur',
'bordure',
'borgne',
'borner',
'bosse',
'bouche',
'bouder',
'bouger',
'boule',
'bourse',
'bout',
'boxe',
'brader',
'braise',
'branche',
'braquer',
'bras',
'brave',
'brebis',
'brevet',
'brider',
'briller',
'brin',
'brique',
'briser',
'broche',
'broder',
'bronze',
'brosser',
'brouter',
'bruit',
'brute',
'budget',
'buffet',
'bulle',
'bureau',
'buriner',
'buste',
'buter',
'butiner',
'cabas',
'cabinet',
'cabri',
'cacao',
'cacher',
'cadeau',
'cadre',
'cage',
'caisse',
'caler',
'calme',
'camarade',
'camion',
'campagne',
'canal',
'canif',
'capable',
'capot',
'carat',
'caresser',
'carie',
'carpe',
'cartel',
'casier',
'casque',
'casserole',
'cause',
'cavale',
'cave',
'ceci',
'cela',
'celui',
'cendre',
'cent',
'cependant',
'cercle',
'cerise',
'cerner',
'certes',
'cerveau',
'cesser',
'chacun',
'chair',
'chaleur',
'chamois',
'chanson',
'chaque',
'charge',
'chasse',
'chat',
'chaud',
'chef',
'chemin',
'cheveu',
'chez',
'chicane',
'chien',
'chiffre',
'chiner',
'chiot',
'chlore',
'choc',
'choix',
'chose',
'chou',
'chute',
'cibler',
'cidre',
'ciel',
'cigale',
'cinq',
'cintre',
'cirage',
'cirque',
'ciseau',
'citation',
'citer',
'citron',
'civet',
'clairon',
'clan',
'classe',
'clavier',
'clef',
'climat',
'cloche',
'cloner',
'clore',
'clos',
'clou',
'club',
'cobra',
'cocon',
'coiffer',
'coin',
'colline',
'colon',
'combat',
'comme',
'compte',
'conclure',
'conduire',
'confier',
'connu',
'conseil',
'contre',
'convenir',
'copier',
'cordial',
'cornet',
'corps',
'cosmos',
'coton',
'couche',
'coude',
'couler',
'coupure',
'cour',
'couteau',
'couvrir',
'crabe',
'crainte',
'crampe',
'cran',
'creuser',
'crever',
'crier',
'crime',
'crin',
'crise',
'crochet',
'croix',
'cruel',
'cuisine',
'cuite',
'culot',
'culte',
'cumul',
'cure',
'curieux',
'cuve',
'dame',
'danger',
'dans',
'davantage',
'debout',
'dedans',
'dehors',
'delta',
'demain',
'demeurer',
'demi',
'dense',
'dent',
'depuis',
'dernier',
'descendre',
'dessus',
'destin',
'dette',
'deuil',
'deux',
'devant',
'devenir',
'devin',
'devoir',
'dicton',
'dieu',
'difficile',
'digestion',
'digue',
'diluer',
'dimanche',
'dinde',
'diode',
'dire',
'diriger',
'discours',
'disposer',
'distance',
'divan',
'divers',
'docile',
'docteur',
'dodu',
'dogme',
'doigt',
'dominer',
'donation',
'donjon',
'donner',
'dopage',
'dorer',
'dormir',
'doseur',
'douane',
'double',
'douche',
'douleur',
'doute',
'doux',
'douzaine',
'draguer',
'drame',
'drap',
'dresser',
'droit',
'duel',
'dune',
'duper',
'durant',
'durcir',
'durer',
'eaux',
'effacer',
'effet',
'effort',
'effrayant',
'elle',
'embrasser',
'emmener',
'emparer',
'empire',
'employer',
'emporter',
'enclos',
'encore',
'endive',
'endormir',
'endroit',
'enduit',
'enfant',
'enfermer',
'enfin',
'enfler',
'enfoncer',
'enfuir',
'engager',
'engin',
'enjeu',
'enlever',
'ennemi',
'ennui',
'ensemble',
'ensuite',
'entamer',
'entendre',
'entier',
'entourer',
'entre',
'envelopper',
'envie',
'envoyer',
'erreur',
'escalier',
'espace',
'espoir',
'esprit',
'essai',
'essor',
'essuyer',
'estimer',
'exact',
'examiner',
'excuse',
'exemple',
'exiger',
'exil',
'exister',
'exode',
'expliquer',
'exposer',
'exprimer',
'extase',
'fable',
'facette',
'facile',
'fade',
'faible',
'faim',
'faire',
'fait',
'falloir',
'famille',
'faner',
'farce',
'farine',
'fatigue',
'faucon',
'faune',
'faute',
'faux',
'faveur',
'favori',
'faxer',
'feinter',
'femme',
'fendre',
'fente',
'ferme',
'festin',
'feuille',
'feutre',
'fiable',
'fibre',
'ficher',
'fier',
'figer',
'figure',
'filet',
'fille',
'filmer',
'fils',
'filtre',
'final',
'finesse',
'finir',
'fiole',
'firme',
'fixe',
'flacon',
'flair',
'flamme',
'flan',
'flaque',
'fleur',
'flocon',
'flore',
'flot',
'flou',
'fluide',
'fluor',
'flux',
'focus',
'foin',
'foire',
'foison',
'folie',
'fonction',
'fondre',
'fonte',
'force',
'forer',
'forger',
'forme',
'fort',
'fosse',
'fouet',
'fouine',
'foule',
'four',
'foyer',
'frais',
'franc',
'frapper',
'freiner',
'frimer',
'friser',
'frite',
'froid',
'froncer',
'fruit',
'fugue',
'fuir',
'fuite',
'fumer',
'fureur',
'furieux',
'fuser',
'fusil',
'futile',
'futur',
'gagner',
'gain',
'gala',
'galet',
'galop',
'gamme',
'gant',
'garage',
'garde',
'garer',
'gauche',
'gaufre',
'gaule',
'gaver',
'gazon',
'geler',
'genou',
'genre',
'gens',
'gercer',
'germer',
'geste',
'gibier',
'gicler',
'gilet',
'girafe',
'givre',
'glace',
'glisser',
'globe',
'gloire',
'gluant',
'gober',
'golf',
'gommer',
'gorge',
'gosier',
'goutte',
'grain',
'gramme',
'grand',
'gras',
'grave',
'gredin',
'griffure',
'griller',
'gris',
'gronder',
'gros',
'grotte',
'groupe',
'grue',
'guerrier',
'guetter',
'guider',
'guise',
'habiter',
'hache',
'haie',
'haine',
'halte',
'hamac',
'hanche',
'hangar',
'hanter',
'haras',
'hareng',
'harpe',
'hasard',
'hausse',
'haut',
'havre',
'herbe',
'heure',
'hibou',
'hier',
'histoire',
'hiver',
'hochet',
'homme',
'honneur',
'honte',
'horde',
'horizon',
'hormone',
'houle',
'housse',
'hublot',
'huile',
'huit',
'humain',
'humble',
'humide',
'humour',
'hurler',
'idole',
'igloo',
'ignorer',
'illusion',
'image',
'immense',
'immobile',
'imposer',
'impression',
'incapable',
'inconnu',
'index',
'indiquer',
'infime',
'injure',
'inox',
'inspirer',
'instant',
'intention',
'intime',
'inutile',
'inventer',
'inviter',
'iode',
'iris',
'issue',
'ivre',
'jade',
'jadis',
'jamais',
'jambe',
'janvier',
'jardin',
'jauge',
'jaunisse',
'jeter',
'jeton',
'jeudi',
'jeune',
'joie',
'joindre',
'joli',
'joueur',
'journal',
'judo',
'juge',
'juillet',
'juin',
'jument',
'jungle',
'jupe',
'jupon',
'jurer',
'juron',
'jury',
'jusque',
'juste',
'kayak',
'ketchup',
'kilo',
'kiwi',
'koala',
'label',
'lacet',
'lacune',
'laine',
'laisse',
'lait',
'lame',
'lancer',
'lande',
'laque',
'lard',
'largeur',
'larme',
'larve',
'lasso',
'laver',
'lendemain',
'lentement',
'lequel',
'lettre',
'leur',
'lever',
'levure',
'liane',
'libre',
'lien',
'lier',
'lieutenant',
'ligne',
'ligoter',
'liguer',
'limace',
'limer',
'limite',
'lingot',
'lion',
'lire',
'lisser',
'litre',
'livre',
'lobe',
'local',
'logis',
'loin',
'loisir',
'long',
'loque',
'lors',
'lotus',
'louer',
'loup',
'lourd',
'louve',
'loyer',
'lubie',
'lucide',
'lueur',
'luge',
'luire',
'lundi',
'lune',
'lustre',
'lutin',
'lutte',
'luxe',
'machine',
'madame',
'magie',
'magnifique',
'magot',
'maigre',
'main',
'mairie',
'maison',
'malade',
'malheur',
'malin',
'manche',
'manger',
'manier',
'manoir',
'manquer',
'marche',
'mardi',
'marge',
'mariage',
'marquer',
'mars',
'masque',
'masse',
'matin',
'mauvais',
'meilleur',
'melon',
'membre',
'menacer',
'mener',
'mensonge',
'mentir',
'menu',
'merci',
'merlu',
'mesure',
'mettre',
'meuble',
'meunier',
'meute',
'miche',
'micro',
'midi',
'miel',
'miette',
'mieux',
'milieu',
'mille',
'mimer',
'mince',
'mineur',
'ministre',
'minute',
'mirage',
'miroir',
'miser',
'mite',
'mixte',
'mobile',
'mode',
'module',
'moins',
'mois',
'moment',
'momie',
'monde',
'monsieur',
'monter',
'moquer',
'moral',
'morceau',
'mordre',
'morose',
'morse',
'mortier',
'morue',
'motif',
'motte',
'moudre',
'moule',
'mourir',
'mousse',
'mouton',
'mouvement',
'moyen',
'muer',
'muette',
'mugir',
'muguet',
'mulot',
'multiple',
'munir',
'muret',
'muse',
'musique',
'muter',
'nacre',
'nager',
'nain',
'naissance',
'narine',
'narrer',
'naseau',
'nasse',
'nation',
'nature',
'naval',
'navet',
'naviguer',
'navrer',
'neige',
'nerf',
'nerveux',
'neuf',
'neutre',
'neuve',
'neveu',
'niche',
'nier',
'niveau',
'noble',
'noce',
'nocif',
'noir',
'nomade',
'nombre',
'nommer',
'nord',
'norme',
'notaire',
'notice',
'notre',
'nouer',
'nougat',
'nourrir',
'nous',
'nouveau',
'novice',
'noyade',
'noyer',
'nuage',
'nuance',
'nuire',
'nuit',
'nulle',
'nuque',
'oasis',
'objet',
'obliger',
'obscur',
'observer',
'obtenir',
'obus',
'occasion',
'occuper',
'ocre',
'octet',
'odeur',
'odorat',
'offense',
'officier',
'offrir',
'ogive',
'oiseau',
'olive',
'ombre',
'onctueux',
'onduler',
'ongle',
'onze',
'opter',
'option',
'orageux',
'oral',
'orange',
'orbite',
'ordinaire',
'ordre',
'oreille',
'organe',
'orgie',
'orgueil',
'orient',
'origan',
'orner',
'orteil',
'ortie',
'oser',
'osselet',
'otage',
'otarie',
'ouate',
'oublier',
'ouest',
'ours',
'outil',
'outre',
'ouvert',
'ouvrir',
'ovale',
'ozone',
'pacte',
'page',
'paille',
'pain',
'paire',
'paix',
'palace',
'palissade',
'palmier',
'palpiter',
'panda',
'panneau',
'papa',
'papier',
'paquet',
'parc',
'pardi',
'parfois',
'parler',
'parmi',
'parole',
'partir',
'parvenir',
'passer',
'pastel',
'patin',
'patron',
'paume',
'pause',
'pauvre',
'paver',
'pavot',
'payer',
'pays',
'peau',
'peigne',
'peinture',
'pelage',
'pelote',
'pencher',
'pendre',
'penser',
'pente',
'percer',
'perdu',
'perle',
'permettre',
'personne',
'perte',
'peser',
'pesticide',
'petit',
'peuple',
'peur',
'phase',
'photo',
'phrase',
'piano',
'pied',
'pierre',
'pieu',
'pile',
'pilier',
'pilote',
'pilule',
'piment',
'pincer',
'pinson',
'pinte',
'pion',
'piquer',
'pirate',
'pire',
'piste',
'piton',
'pitre',
'pivot',
'pizza',
'placer',
'plage',
'plaire',
'plan',
'plaque',
'plat',
'plein',
'pleurer',
'pliage',
'plier',
'plonger',
'plot',
'pluie',
'plume',
'plus',
'pneu',
'poche',
'podium',
'poids',
'poil',
'point',
'poire',
'poison',
'poitrine',
'poivre',
'police',
'pollen',
'pomme',
'pompier',
'poncer',
'pondre',
'pont',
'portion',
'poser',
'position',
'possible',
'poste',
'potage',
'potin',
'pouce',
'poudre',
'poulet',
'poumon',
'poupe',
'pour',
'pousser',
'poutre',
'pouvoir',
'prairie',
'premier',
'prendre',
'presque',
'preuve',
'prier',
'primeur',
'prince',
'prison',
'priver',
'prix',
'prochain',
'produire',
'profond',
'proie',
'projet',
'promener',
'prononcer',
'propre',
'prose',
'prouver',
'prune',
'public',
'puce',
'pudeur',
'puiser',
'pull',
'pulpe',
'puma',
'punir',
'purge',
'putois',
'quand',
'quartier',
'quasi',
'quatre',
'quel',
'question',
'queue',
'quiche',
'quille',
'quinze',
'quitter',
'quoi',
'rabais',
'raboter',
'race',
'racheter',
'racine',
'racler',
'raconter',
'radar',
'radio',
'rafale',
'rage',
'ragot',
'raideur',
'raie',
'rail',
'raison',
'ramasser',
'ramener',
'rampe',
'rance',
'rang',
'rapace',
'rapide',
'rapport',
'rarement',
'rasage',
'raser',
'rasoir',
'rassurer',
'rater',
'ratio',
'rature',
'ravage',
'ravir',
'rayer',
'rayon',
'rebond',
'recevoir',
'recherche',
'record',
'reculer',
'redevenir',
'refuser',
'regard',
'regretter',
'rein',
'rejeter',
'rejoindre',
'relation',
'relever',
'religion',
'remarquer',
'remettre',
'remise',
'remonter',
'remplir',
'remuer',
'rencontre',
'rendre',
'renier',
'renoncer',
'rentrer',
'renverser',
'repas',
'repli',
'reposer',
'reproche',
'requin',
'respect',
'ressembler',
'reste',
'retard',
'retenir',
'retirer',
'retour',
'retrouver',
'revenir',
'revoir',
'revue',
'rhume',
'ricaner',
'riche',
'rideau',
'ridicule',
'rien',
'rigide',
'rincer',
'rire',
'risquer',
'rituel',
'rivage',
'rive',
'robe',
'robot',
'robuste',
'rocade',
'roche',
'rodeur',
'rogner',
'roman',
'rompre',
'ronce',
'rondeur',
'ronger',
'roque',
'rose',
'rosir',
'rotation',
'rotule',
'roue',
'rouge',
'rouler',
'route',
'ruban',
'rubis',
'ruche',
'rude',
'ruelle',
'ruer',
'rugby',
'rugir',
'ruine',
'rumeur',
'rural',
'ruse',
'rustre',
'sable',
'sabot',
'sabre',
'sacre',
'sage',
'saint',
'saisir',
'salade',
'salive',
'salle',
'salon',
'salto',
'salut',
'salve',
'samba',
'sandale',
'sanguin',
'sapin',
'sarcasme',
'satisfaire',
'sauce',
'sauf',
'sauge',
'saule',
'sauna',
'sauter',
'sauver',
'savoir',
'science',
'scoop',
'score',
'second',
'secret',
'secte',
'seigneur',
'sein',
'seize',
'selle',
'selon',
'semaine',
'sembler',
'semer',
'semis',
'sensuel',
'sentir',
'sept',
'serpe',
'serrer',
'sertir',
'service',
'seuil',
'seulement',
'short',
'sien',
'sigle',
'signal',
'silence',
'silo',
'simple',
'singe',
'sinon',
'sinus',
'sioux',
'sirop',
'site',
'situation',
'skier',
'snob',
'sobre',
'social',
'socle',
'sodium',
'soigner',
'soir',
'soixante',
'soja',
'solaire',
'soldat',
'soleil',
'solide',
'solo',
'solvant',
'sombre',
'somme',
'somnoler',
'sondage',
'songeur',
'sonner',
'sorte',
'sosie',
'sottise',
'souci',
'soudain',
'souffrir',
'souhaiter',
'soulever',
'soumettre',
'soupe',
'sourd',
'soustraire',
'soutenir',
'souvent',
'soyeux',
'spectacle',
'sport',
'stade',
'stagiaire',
'stand',
'star',
'statue',
'stock',
'stop',
'store',
'style',
'suave',
'subir',
'sucre',
'suer',
'suffire',
'suie',
'suite',
'suivre',
'sujet',
'sulfite',
'supposer',
'surf',
'surprendre',
'surtout',
'surveiller',
'tabac',
'table',
'tabou',
'tache',
'tacler',
'tacot',
'tact',
'taie',
'taille',
'taire',
'talon',
'talus',
'tandis',
'tango',
'tanin',
'tant',
'taper',
'tapis',
'tard',
'tarif',
'tarot',
'tarte',
'tasse',
'taureau',
'taux',
'taverne',
'taxer',
'taxi',
'tellement',
'temple',
'tendre',
'tenir',
'tenter',
'tenu',
'terme',
'ternir',
'terre',
'test',
'texte',
'thym',
'tibia',
'tiers',
'tige',
'tipi',
'tique',
'tirer',
'tissu',
'titre',
'toast',
'toge',
'toile',
'toiser',
'toiture',
'tomber',
'tome',
'tonne',
'tonte',
'toque',
'torse',
'tortue',
'totem',
'toucher',
'toujours',
'tour',
'tousser',
'tout',
'toux',
'trace',
'train',
'trame',
'tranquille',
'travail',
'trembler',
'trente',
'tribu',
'trier',
'trio',
'tripe',
'triste',
'troc',
'trois',
'tromper',
'tronc',
'trop',
'trotter',
'trouer',
'truc',
'truite',
'tuba',
'tuer',
'tuile',
'turbo',
'tutu',
'tuyau',
'type',
'union',
'unique',
'unir',
'unisson',
'untel',
'urne',
'usage',
'user',
'usiner',
'usure',
'utile',
'vache',
'vague',
'vaincre',
'valeur',
'valoir',
'valser',
'valve',
'vampire',
'vaseux',
'vaste',
'veau',
'veille',
'veine',
'velours',
'velu',
'vendre',
'venir',
'vent',
'venue',
'verbe',
'verdict',
'version',
'vertige',
'verve',
'veste',
'veto',
'vexer',
'vice',
'victime',
'vide',
'vieil',
'vieux',
'vigie',
'vigne',
'ville',
'vingt',
'violent',
'virer',
'virus',
'visage',
'viser',
'visite',
'visuel',
'vitamine',
'vitrine',
'vivant',
'vivre',
'vocal',
'vodka',
'vogue',
'voici',
'voile',
'voir',
'voisin',
'voiture',
'volaille',
'volcan',
'voler',
'volt',
'votant',
'votre',
'vouer',
'vouloir',
'vous',
'voyage',
'voyou',
'vrac',
'vrai',
'yacht',
'yeti',
'yeux',
'yoga',
'zeste',
'zinc',
'zone',
'zoom'
];
// SPDX-License-Identifier: MIT
const WORDLIST$5 = [
'Abakus',
'Abart',
'abbilden',
'Abbruch',
'Abdrift',
'Abendrot',
'Abfahrt',
'abfeuern',
'Abflug',
'abfragen',
'Abglanz',
'abhärten',
'abheben',
'Abhilfe',
'Abitur',
'Abkehr',
'Ablauf',
'ablecken',
'Ablösung',
'Abnehmer',
'abnutzen',
'Abonnent',
'Abrasion',
'Abrede',
'abrüsten',
'Absicht',
'Absprung',
'Abstand',
'absuchen',
'Abteil',
'Abundanz',
'abwarten',
'Abwurf',
'Abzug',
'Achse',
'Achtung',
'Acker',
'Aderlass',
'Adler',
'Admiral',
'Adresse',
'Affe',
'Affront',
'Afrika',
'Aggregat',
'Agilität',
'ähneln',
'Ahnung',
'Ahorn',
'Akazie',
'Akkord',
'Akrobat',
'Aktfoto',
'Aktivist',
'Albatros',
'Alchimie',
'Alemanne',
'Alibi',
'Alkohol',
'Allee',
'Allüre',
'Almosen',
'Almweide',
'Aloe',
'Alpaka',
'Alpental',
'Alphabet',
'Alpinist',
'Alraune',
'Altbier',
'Alter',
'Altflöte',
'Altruist',
'Alublech',
'Aludose',
'Amateur',
'Amazonas',
'Ameise',
'Amnesie',
'Amok',
'Ampel',
'Amphibie',
'Ampulle',
'Amsel',
'Amulett',
'Anakonda',
'Analogie',
'Ananas',
'Anarchie',
'Anatomie',
'Anba',
'Anbeginn',
'anbieten',
'Anblick',
'ändern',
'andocken',
'Andrang',
'anecken',
'Anflug',
'Anfrage',
'Anführer',
'Angebot',
'Angler',
'Anhalter',
'Anhöhe',
'Animator',
'Anis',
'Anker',
'ankleben',
'Ankunft',
'Anlage',
'anlocken',
'Anmut',
'Annahme',
'Anomalie',
'Anonymus',
'Anorak',
'anpeilen',
'Anrecht',
'Anruf',
'Ansage',
'Anschein',
'Ansicht',
'Ansporn',
'Anteil',
'Antlitz',
'Antrag',
'Antwort',
'Anwohner',
'Aorta',
'Apfel',
'Appetit',
'Applaus',
'Aquarium',
'Arbeit',
'Arche',
'Argument',
'Arktis',
'Armband',
'Aroma',
'Asche',
'Askese',
'Asphalt',
'Asteroid',
'Ästhetik',
'Astronom',
'Atelier',
'Athlet',
'Atlantik',
'Atmung',
'Audienz',
'aufatmen',
'Auffahrt',
'aufholen',
'aufregen',
'Aufsatz',
'Auftritt',
'Aufwand',
'Augapfel',
'Auktion',
'Ausbruch',
'Ausflug',
'Ausgabe',
'Aushilfe',
'Ausland',
'Ausnahme',
'Aussage',
'Autobahn',
'Avocado',
'Axthieb',
'Bach',
'backen',
'Badesee',
'Bahnhof',
'Balance',
'Balkon',
'Ballett',
'Balsam',
'Banane',
'Bandage',
'Bankett',
'Barbar',
'Barde',
'Barett',
'Bargeld',
'Barkasse',
'Barriere',
'Bart',
'Bass',
'Bastler',
'Batterie',
'Bauch',
'Bauer',
'Bauholz',
'Baujahr',
'Baum',
'Baustahl',
'Bauteil',
'Bauweise',
'Bazar',
'beachten',
'Beatmung',
'beben',
'Becher',
'Becken',
'bedanken',
'beeilen',
'beenden',
'Beere',
'befinden',
'Befreier',
'Begabung',
'Begierde',
'begrüßen',
'Beiboot',
'Beichte',
'Beifall',
'Beigabe',
'Beil',
'Beispiel',
'Beitrag',
'beizen',
'bekommen',
'beladen',
'Beleg',
'bellen',
'belohnen',
'Bemalung',
'Bengel',
'Benutzer',
'Benzin',
'beraten',
'Bereich',
'Bergluft',
'Bericht',
'Bescheid',
'Besitz',
'besorgen',
'Bestand',
'Besuch',
'betanken',
'beten',
'betören',
'Bett',
'Beule',
'Beute',
'Bewegung',
'bewirken',
'Bewohner',
'bezahlen',
'Bezug',
'biegen',
'Biene',
'Bierzelt',
'bieten',
'Bikini',
'Bildung',
'Billard',
'binden',
'Biobauer',
'Biologe',
'Bionik',
'Biotop',
'Birke',
'Bison',
'Bitte',
'Biwak',
'Bizeps',
'blasen',
'Blatt',
'Blauwal',
'Blende',
'Blick',
'Blitz',
'Blockade',
'Blödelei',
'Blondine',
'Blues',
'Blume',
'Blut',
'Bodensee',
'Bogen',
'Boje',
'Bollwerk',
'Bonbon',
'Bonus',
'Boot',
'Bordarzt',
'Börse',
'Böschung',
'Boudoir',
'Boxkampf',
'Boykott',
'Brahms',
'Brandung',
'Brauerei',
'Brecher',
'Breitaxt',
'Bremse',
'brennen',
'Brett',
'Brief',
'Brigade',
'Brillanz',
'bringen',
'brodeln',
'Brosche',
'Brötchen',
'Brücke',
'Brunnen',
'Brüste',
'Brutofen',
'Buch',
'Büffel',
'Bugwelle',
'Bühne',
'Buletten',
'Bullauge',
'Bumerang',
'bummeln',
'Buntglas',
'Bürde',
'Burgherr',
'Bursche',
'Busen',
'Buslinie',
'Bussard',
'Butangas',
'Butter',
'Cabrio',
'campen',
'Captain',
'Cartoon',
'Cello',
'Chalet',
'Charisma',
'Chefarzt',
'Chiffon',
'Chipsatz',
'Chirurg',
'Chor',
'Chronik',
'Chuzpe',
'Clubhaus',
'Cockpit',
'Codewort',
'Cognac',
'Coladose',
'Computer',
'Coupon',
'Cousin',
'Cracking',
'Crash',
'Curry',
'Dach',
'Dackel',
'daddeln',
'daliegen',
'Dame',
'Dammba',
'Dämon',
'Dampflok',
'Dank',
'Darm',
'Datei',
'Datsche',
'Datteln',
'Datum',
'Dauer',
'Daunen',
'Deckel',
'Decoder',
'Defekt',
'Degen',
'Dehnung',
'Deiche',
'Dekade',
'Dekor',
'Delfin',
'Demut',
'denken',
'Deponie',
'Design',
'Desktop',
'Dessert',
'Detail',
'Detektiv',
'Dezibel',
'Diadem',
'Diagnose',
'Dialekt',
'Diamant',
'Dichter',
'Dickicht',
'Diesel',
'Diktat',
'Diplom',
'Direktor',
'Dirne',
'Diskurs',
'Distanz',
'Docht',
'Dohle',
'Dolch',
'Domäne',
'Donner',
'Dorade',
'Dorf',
'Dörrobst',
'Dorsch',
'Dossier',
'Dozent',
'Drachen',
'Draht',
'Drama',
'Drang',
'Drehbuch',
'Dreieck',
'Dressur',
'Drittel',
'Drossel',
'Druck',
'Duell',
'Duft',
'Düne',
'Dünung',
'dürfen',
'Duschbad',
'Düsenjet',
'Dynamik',
'Ebbe',
'Echolot',
'Echse',
'Eckball',
'Edding',
'Edelweiß',
'Eden',
'Edition',
'Efe',
'Effekte',
'Egoismus',
'Ehre',
'Eiablage',
'Eiche',
'Eidechse',
'Eidotter',
'Eierkopf',
'Eigelb',
'Eiland',
'Eilbote',
'Eimer',
'einatmen',
'Einband',
'Eindruck',
'Einfall',
'Eingang',
'Einkauf',
'einladen',
'Einöde',
'Einrad',
'Eintopf',
'Einwurf',
'Einzug',
'Eisbär',
'Eisen',
'Eishöhle',
'Eismeer',
'Eiweiß',
'Ekstase',
'Elan',
'Elch',
'Elefant',
'Eleganz',
'Element',
'Elfe',
'Elite',
'Elixier',
'Ellbogen',
'Eloquenz',
'Emigrant',
'Emission',
'Emotion',
'Empathie',
'Empfang',
'Endzeit',
'Energie',
'Engpass',
'Enkel',
'Enklave',
'Ente',
'entheben',
'Entität',
'entladen',
'Entwurf',
'Episode',
'Epoche',
'erachten',
'Erbauer',
'erblühen',
'Erdbeere',
'Erde',
'Erdgas',
'Erdkunde',
'Erdnuss',
'Erdöl',
'Erdteil',
'Ereignis',
'Eremit',
'erfahren',
'Erfolg',
'erfreuen',
'erfüllen',
'Ergebnis',
'erhitzen',
'erkalten',
'erkennen',
'erleben',
'Erlösung',
'ernähren',
'erneuern',
'Ernte',
'Eroberer',
'eröffnen',
'Erosion',
'Erotik',
'Erpel',
'erraten',
'Erreger',
'erröten',
'Ersatz',
'Erstflug',
'Ertrag',
'Eruption',
'erwarten',
'erwidern',
'Erzba',
'Erzeuger',
'erziehen',
'Esel',
'Eskimo',
'Eskorte',
'Espe',
'Espresso',
'essen',
'Etage',
'Etappe',
'Etat',
'Ethik',
'Etikett',
'Etüde',
'Eule',
'Euphorie',
'Europa',
'Everest',
'Examen',
'Exil',
'Exodus',
'Extrakt',
'Fabel',
'Fabrik',
'Fachmann',
'Fackel',
'Faden',
'Fagott',
'Fahne',
'Faible',
'Fairness',
'Fakt',
'Fakultät',
'Falke',
'Fallobst',
'Fälscher',
'Faltboot',
'Familie',
'Fanclub',
'Fanfare',
'Fangarm',
'Fantasie',
'Farbe',
'Farmhaus',
'Farn',
'Fasan',
'Faser',
'Fassung',
'fasten',
'Faulheit',
'Fauna',
'Faust',
'Favorit',
'Faxgerät',
'Fazit',
'fechten',
'Federboa',
'Fehler',
'Feier',
'Feige',
'feilen',
'Feinripp',
'Feldbett',
'Felge',
'Fellpony',
'Felswand',
'Ferien',
'Ferkel',
'Fernweh',
'Ferse',
'Fest',
'Fettnapf',
'Feuer',
'Fiasko',
'Fichte',
'Fiktion',
'Film',
'Filter',
'Filz',
'Finanzen',
'Findling',
'Finger',
'Fink',
'Finnwal',
'Fisch',
'Fitness',
'Fixpunkt',
'Fixstern',
'Fjord',
'Flachba',
'Flagge',
'Flamenco',
'Flanke',
'Flasche',
'Flaute',
'Fleck',
'Flegel',
'flehen',
'Fleisch',
'fliegen',
'Flinte',
'Flirt',
'Flocke',
'Floh',
'Floskel',
'Floß',
'Flöte',
'Flugzeug',
'Flunder',
'Flusstal',
'Flutung',
'Fockmast',
'Fohlen',
'Föhnlage',
'Fokus',
'folgen',
'Foliant',
'Folklore',
'Fontäne',
'Förde',
'Forelle',
'Format',
'Forscher',
'Fortgang',
'Forum',
'Fotograf',
'Frachter',
'Fragment',
'Fraktion',
'fräsen',
'Frauenpo',
'Freak',
'Fregatte',
'Freiheit',
'Freude',
'Frieden',
'Frohsinn',
'Frosch',
'Frucht',
'Frühjahr',
'Fuchs',
'Fügung',
'fühlen',
'Füller',
'Fundbüro',
'Funkboje',
'Funzel',
'Furnier',
'Fürsorge',
'Fusel',
'Fußbad',
'Futteral',
'Gabelung',
'gackern',
'Gage',
'gähnen',
'Galaxie',
'Galeere',
'Galopp',
'Gameboy',
'Gamsbart',
'Gandhi',
'Gang',
'Garage',
'Gardine',
'Garküche',
'Garten',
'Gasthaus',
'Gattung',
'gaukeln',
'Gazelle',
'Gebäck',
'Gebirge',
'Gebrä',
'Geburt',
'Gedanke',
'Gedeck',
'Gedicht',
'Gefahr',
'Gefieder',
'Geflügel',
'Gefühl',
'Gegend',
'Gehirn',
'Gehöft',
'Gehweg',
'Geige',
'Geist',
'Gelage',
'Geld',
'Gelenk',
'Gelübde',
'Gemälde',
'Gemeinde',
'Gemüse',
'genesen',
'Genuss',
'Gepäck',
'Geranie',
'Gericht',
'Germane',
'Geruch',
'Gesang',
'Geschenk',
'Gesetz',
'Gesindel',
'Gesöff',
'Gespan',
'Gestade',
'Gesuch',
'Getier',
'Getränk',
'Getümmel',
'Gewand',
'Geweih',
'Gewitter',
'Gewölbe',
'Geysir',
'Giftzahn',
'Gipfel',
'Giraffe',
'Gitarre',
'glänzen',
'Glasauge',
'Glatze',
'Gleis',
'Globus',
'Glück',
'glühen',
'Glutofen',
'Goldzahn',
'Gondel',
'gönnen',
'Gottheit',
'graben',
'Grafik',
'Grashalm',
'Graugans',
'greifen',
'Grenze',
'grillen',
'Groschen',
'Grotte',
'Grube',
'Grünalge',
'Gruppe',
'gruseln',
'Gulasch',
'Gummibär',
'Gurgel',
'Gürtel',
'Güterzug',
'Haarband',
'Habicht',
'hacken',
'hadern',
'Hafen',
'Hagel',
'Hähnchen',
'Haifisch',
'Haken',
'Halbaffe',
'Halsader',
'halten',
'Halunke',
'Handbuch',
'Hanf',
'Harfe',
'Harnisch',
'härten',
'Harz',
'Hasenohr',
'Haube',
'hauchen',
'Haupt',
'Haut',
'Havarie',
'Hebamme',
'hecheln',
'Heck',
'Hedonist',
'Heiler',
'Heimat',
'Heizung',
'Hektik',
'Held',
'helfen',
'Helium',
'Hemd',
'hemmen',
'Hengst',
'Herd',
'Hering',
'Herkunft',
'Hermelin',
'Herrchen',
'Herzdame',
'Heulboje',
'Hexe',
'Hilfe',
'Himbeere',
'Himmel',
'Hingabe',
'hinhören',
'Hinweis',
'Hirsch',
'Hirte',
'Hitzkopf',
'Hobel',
'Hochform',
'Hocker',
'hoffen',
'Hofhund',
'Hofnarr',
'Höhenzug',
'Hohlraum',
'Hölle',
'Holzboot',
'Honig',
'Honorar',
'horchen',
'Hörprobe',
'Höschen',
'Hotel',
'Hubraum',
'Hufeisen',
'Hügel',
'huldigen',
'Hülle',
'Humbug',
'Hummer',
'Humor',
'Hund',
'Hunger',
'Hupe',
'Hürde',
'Hurrikan',
'Hydrant',
'Hypnose',
'Ibis',
'Idee',
'Idiot',
'Igel',
'Illusion',
'Imitat',
'impfen',
'Import',
'Inferno',
'Ingwer',
'Inhalte',
'Inland',
'Insekt',
'Ironie',
'Irrfahrt',
'Irrtum',
'Isolator',
'Istwert',
'Jacke',
'Jade',
'Jagdhund',
'Jäger',
'Jaguar',
'Jahr',
'Jähzorn',
'Jazzfest',
'Jetpilot',
'jobben',
'Jochbein',
'jodeln',
'Jodsalz',
'Jolle',
'Journal',
'Jubel',
'Junge',
'Junimond',
'Jupiter',
'Jutesack',
'Juwel',
'Kabarett',
'Kabine',
'Kabuff',
'Käfer',
'Kaffee',
'Kahlkopf',
'Kaimauer',
'Kajüte',
'Kaktus',
'Kaliber',
'Kaltluft',
'Kamel',
'kämmen',
'Kampagne',
'Kanal',
'Kängur',
'Kanister',
'Kanone',
'Kante',
'Kan',
'kapern',
'Kapitän',
'Kapuze',
'Karneval',
'Karotte',
'Käsebrot',
'Kasper',
'Kastanie',
'Katalog',
'Kathode',
'Katze',
'kaufen',
'Kaugummi',
'Kauz',
'Kehle',
'Keilerei',
'Keksdose',
'Kellner',
'Keramik',
'Kerze',
'Kessel',
'Kette',
'keuchen',
'kichern',
'Kielboot',
'Kindheit',
'Kinnbart',
'Kinosaal',
'Kiosk',
'Kissen',
'Klammer',
'Klang',
'Klapprad',
'Klartext',
'kleben',
'Klee',
'Kleinod',
'Klima',
'Klingel',
'Klippe',
'Klischee',
'Kloster',
'Klugheit',
'Klüngel',
'kneten',
'Knie',
'Knöchel',
'knüpfen',
'Kobold',
'Kochbuch',
'Kohlrabi',
'Koje',
'Kokosöl',
'Kolibri',
'Kolumne',
'Kombüse',
'Komiker',
'kommen',
'Konto',
'Konzept',
'Kopfkino',
'Kordhose',
'Korken',
'Korsett',
'Kosename',
'Krabbe',
'Krach',
'Kraft',
'Krähe',
'Kralle',
'Krapfen',
'Krater',
'kraulen',
'Kreuz',
'Krokodil',
'Kröte',
'Kugel',
'Kuhhirt',
'Kühnheit',
'Künstler',
'Kurort',
'Kurve',
'Kurzfilm',
'kuscheln',
'küssen',
'Kutter',
'Labor',
'lachen',
'Lackaffe',
'Ladeluke',
'Lagune',
'Laib',
'Lakritze',
'Lammfell',
'Land',
'Langmut',
'Lappalie',
'Last',
'Laterne',
'Latzhose',
'Laubsäge',
'laufen',
'Laune',
'Lausbub',
'Lavasee',
'Leben',
'Leder',
'Leerlauf',
'Lehm',
'Lehrer',
'leihen',
'Lektüre',
'Lenker',
'Lerche',
'Leseecke',
'Leuchter',
'Lexikon',
'Libelle',
'Libido',
'Licht',
'Liebe',
'liefern',
'Liftboy',
'Limonade',
'Lineal',
'Linoleum',
'List',
'Liveband',
'Lobrede',
'locken',
'Löffel',
'Logbuch',
'Logik',
'Lohn',
'Loipe',
'Lokal',
'Lorbeer',
'Lösung',
'löten',
'Lottofee',
'Löwe',
'Luchs',
'Luder',
'Luftpost',
'Luke',
'Lümmel',
'Lunge',
'lutschen',
'Luxus',
'Macht',
'Magazin',
'Magier',
'Magnet',
'mähen',
'Mahlzeit',
'Mahnmal',
'Maibaum',
'Maisbrei',
'Makel',
'malen',
'Mammut',
'Maniküre',
'Mantel',
'Marathon',
'Marder',
'Marine',
'Marke',
'Marmor',
'Märzluft',
'Maske',
'Maßanzug',
'Maßkrug',
'Mastkorb',
'Material',
'Matratze',
'Mauerba',
'Maulkorb',
'Mäuschen',
'Mäzen',
'Medium',
'Meinung',
'melden',
'Melodie',
'Mensch',
'Merkmal',
'Messe',
'Metall',
'Meteor',
'Methode',
'Metzger',
'Mieze',
'Milchkuh',
'Mimose',
'Minirock',
'Minute',
'mischen',
'Missetat',
'mitgehen',
'Mittag',
'Mixtape',
'Möbel',
'Modul',
'mögen',
'Möhre',
'Molch',
'Moment',
'Monat',
'Mondflug',
'Monitor',
'Monokini',
'Monster',
'Monument',
'Moorhuhn',
'Moos',
'Möpse',
'Moral',
'Mörtel',
'Motiv',
'Motorrad',
'Möwe',
'Mühe',
'Mulatte',
'Müller',
'Mumie',
'Mund',
'Münze',
'Muschel',
'Muster',
'Mythos',
'Nabel',
'Nachtzug',
'Nackedei',
'Nagel',
'Nähe',
'Nähnadel',
'Namen',
'Narbe',
'Narwal',
'Nasenbär',
'Natur',
'Nebel',
'necken',
'Neffe',
'Neigung',
'Nektar',
'Nenner',
'Neptun',
'Nerz',
'Nessel',
'Nestba',
'Netz',
'Neuba',
'Neuerung',
'Neugier',
'nicken',
'Niere',
'Nilpferd',
'nisten',
'Nocke',
'Nomade',
'Nordmeer',
'Notdurft',
'Notstand',
'Notwehr',
'Nudismus',
'Nuss',
'Nutzhanf',
'Oase',
'Obdach',
'Oberarzt',
'Objekt',
'Oboe',
'Obsthain',
'Ochse',
'Odyssee',
'Ofenholz',
'öffnen',
'Ohnmacht',
'Ohrfeige',
'Ohrwurm',
'Ökologie',
'Oktave',
'Ölberg',
'Olive',
'Ölkrise',
'Omelett',
'Onkel',
'Oper',
'Optiker',
'Orange',
'Orchidee',
'ordnen',
'Orgasmus',
'Orkan',
'Ortskern',
'Ortung',
'Ostasien',
'Ozean',
'Paarlauf',
'Packeis',
'paddeln',
'Paket',
'Palast',
'Pandabär',
'Panik',
'Panorama',
'Panther',
'Papagei',
'Papier',
'Paprika',
'Paradies',
'Parka',
'Parodie',
'Partner',
'Passant',
'Patent',
'Patzer',
'Pause',
'Pavian',
'Pedal',
'Pegel',
'peilen',
'Perle',
'Person',
'Pfad',
'Pfa',
'Pferd',
'Pfleger',
'Physik',
'Pier',
'Pilotwal',
'Pinzette',
'Piste',
'Plakat',
'Plankton',
'Platin',
'Plombe',
'plündern',
'Pobacke',
'Pokal',
'polieren',
'Popmusik',
'Porträt',
'Posaune',
'Postamt',
'Pottwal',
'Pracht',
'Pranke',
'Preis',
'Primat',
'Prinzip',
'Protest',
'Proviant',
'Prüfung',
'Pubertät',
'Pudding',
'Pullover',
'Pulsader',
'Punkt',
'Pute',
'Putsch',
'Puzzle',
'Python',
'quaken',
'Qualle',
'Quark',
'Quellsee',
'Querkopf',
'Quitte',
'Quote',
'Rabauke',
'Rache',
'Radclub',
'Radhose',
'Radio',
'Radtour',
'Rahmen',
'Rampe',
'Randlage',
'Ranzen',
'Rapsöl',
'Raserei',
'rasten',
'Rasur',
'Rätsel',
'Raubtier',
'Raumzeit',
'Rausch',
'Reaktor',
'Realität',
'Rebell',
'Rede',
'Reetdach',
'Regatta',
'Regen',
'Rehkitz',
'Reifen',
'Reim',
'Reise',
'Reizung',
'Rekord',
'Relevanz',
'Rennboot',
'Respekt',
'Restmüll',
'retten',
'Reue',
'Revolte',
'Rhetorik',
'Rhythmus',
'Richtung',
'Riegel',
'Rindvieh',
'Rippchen',
'Ritter',
'Robbe',
'Roboter',
'Rockband',
'Rohdaten',
'Roller',
'Roman',
'röntgen',
'Rose',
'Rosskur',
'Rost',
'Rotahorn',
'Rotglut',
'Rotznase',
'Rubrik',
'Rückweg',
'Rufmord',
'Ruhe',
'Ruine',
'Rumpf',
'Runde',
'Rüstung',
'rütteln',
'Saaltür',
'Saatguts',
'Säbel',
'Sachbuch',
'Sack',
'Saft',
'sagen',
'Sahneeis',
'Salat',
'Salbe',
'Salz',
'Sammlung',
'Samt',
'Sandbank',
'Sanftmut',
'Sardine',
'Satire',
'Sattel',
'Satzba',
'Sauerei',
'Saum',
'Säure',
'Schall',
'Scheitel',
'Schiff',
'Schlager',
'Schmied',
'Schnee',
'Scholle',
'Schrank',
'Schulbus',
'Schwan',
'Seeadler',
'Seefahrt',
'Seehund',
'Seeufer',
'segeln',
'Sehnerv',
'Seide',
'Seilzug',
'Senf',
'Sessel',
'Seufzer',
'Sexgott',
'Sichtung',
'Signal',
'Silber',
'singen',
'Sinn',
'Sirup',
'Sitzbank',
'Skandal',
'Skikurs',
'Skipper',
'Skizze',
'Smaragd',
'Socke',
'Sohn',
'Sommer',
'Songtext',
'Sorte',
'Spagat',
'Spannung',
'Spargel',
'Specht',
'Speiseöl',
'Spiegel',
'Sport',
'spülen',
'Stadtbus',
'Stall',
'Stärke',
'Stativ',
'staunen',
'Stern',
'Stiftung',
'Stollen',
'Strömung',
'Sturm',
'Substanz',
'Südalpen',
'Sumpf',
'surfen',
'Tabak',
'Tafel',
'Tageba',
'takeln',
'Taktung',
'Talsohle',
'Tand',
'Tanzbär',
'Tapir',
'Tarantel',
'Tarnname',
'Tasse',
'Tatnacht',
'Tatsache',
'Tatze',
'Taube',
'tauchen',
'Taufpate',
'Taumel',
'Teelicht',
'Teich',
'teilen',
'Tempo',
'Tenor',
'Terrasse',
'Testflug',
'Theater',
'Thermik',
'ticken',
'Tiefflug',
'Tierart',
'Tigerhai',
'Tinte',
'Tischler',
'toben',
'Toleranz',
'Tölpel',
'Tonband',
'Topf',
'Topmodel',
'Torbogen',
'Torlinie',
'Torte',
'Tourist',
'Tragesel',
'trampeln',
'Trapez',
'Traum',
'treffen',
'Trennung',
'Treue',
'Trick',
'trimmen',
'Trödel',
'Trost',
'Trumpf',
'tüfteln',
'Turban',
'Turm',
'Übermut',
'Ufer',
'Uhrwerk',
'umarmen',
'Umba',
'Umfeld',
'Umgang',
'Umsturz',
'Unart',
'Unfug',
'Unimog',
'Unruhe',
'Unwucht',
'Uranerz',
'Urlaub',
'Urmensch',
'Utopie',
'Vakuum',
'Valuta',
'Vandale',
'Vase',
'Vektor',
'Ventil',
'Verb',
'Verdeck',
'Verfall',
'Vergaser',
'verhexen',
'Verlag',
'Vers',
'Vesper',
'Vieh',
'Viereck',
'Vinyl',
'Virus',
'Vitrine',
'Vollblut',
'Vorbote',
'Vorrat',
'Vorsicht',
'Vulkan',
'Wachstum',
'Wade',
'Wagemut',
'Wahlen',
'Wahrheit',
'Wald',
'Walhai',
'Wallach',
'Walnuss',
'Walzer',
'wandeln',
'Wanze',
'wärmen',
'Warnruf',
'Wäsche',
'Wasser',
'Weberei',
'wechseln',
'Wegegeld',
'wehren',
'Weiher',
'Weinglas',
'Weißbier',
'Weitwurf',
'Welle',
'Weltall',
'Werkbank',
'Werwolf',
'Wetter',
'wiehern',
'Wildgans',
'Wind',
'Wohl',
'Wohnort',
'Wolf',
'Wollust',
'Wortlaut',
'Wrack',
'Wunder',
'Wurfaxt',
'Wurst',
'Yacht',
'Yeti',
'Zacke',
'Zahl',
'zähmen',
'Zahnfee',
'Zäpfchen',
'Zaster',
'Zaumzeug',
'Zebra',
'zeigen',
'Zeitlupe',
'Zellkern',
'Zeltdach',
'Zensor',
'Zerfall',
'Zeug',
'Ziege',
'Zielfoto',
'Zimteis',
'Zobel',
'Zollhund',
'Zombie',
'Zöpfe',
'Zucht',
'Zufahrt',
'Zugfahrt',
'Zugvogel',
'Zündung',
'Zweck',
'Zyklop'
];
// SPDX-License-Identifier: MIT
const WORDLIST$4 = [
'abbinare',
'abbonato',
'abisso',
'abitare',
'abominio',
'accadere',
'accesso',
'acciaio',
'accordo',
'accumulo',
'acido',
'acqua',
'acrobata',
'acustico',
'adattare',
'addetto',
'addio',
'addome',
'adeguato',
'aderire',
'adorare',
'adottare',
'adozione',
'adulto',
'aereo',
'aerobica',
'affare',
'affetto',
'affidare',
'affogato',
'affronto',
'africano',
'afrodite',
'agenzia',
'aggancio',
'aggeggio',
'aggiunta',
'agio',
'agire',
'agitare',
'aglio',
'agnello',
'agosto',
'aiutare',
'albero',
'albo',
'alce',
'alchimia',
'alcool',
'alfabeto',
'algebra',
'alimento',
'allarme',
'alleanza',
'allievo',
'alloggio',
'alluce',
'alpi',
'alterare',
'altro',
'aluminio',
'amante',
'amarezza',
'ambiente',
'ambrosia',
'america',
'amico',
'ammalare',
'ammirare',
'amnesia',
'amnistia',
'amore',
'ampliare',
'amputare',
'analisi',
'anamnesi',
'ananas',
'anarchia',
'anatra',
'anca',
'ancorato',
'andare',
'androide',
'aneddoto',
'anello',
'angelo',
'angolino',
'anguilla',
'anidride',
'anima',
'annegare',
'anno',
'annuncio',
'anomalia',
'antenna',
'anticipo',
'aperto',
'apostolo',
'appalto',
'appello',
'appiglio',
'applauso',
'appoggio',
'appurare',
'aprile',
'aquila',
'arabo',
'arachidi',
'aragosta',
'arancia',
'arbitrio',
'archivio',
'arco',
'argento',
'argilla',
'aria',
'ariete',
'arma',
'armonia',
'aroma',
'arrivare',
'arrosto',
'arsenale',
'arte',
'artiglio',
'asfalto',
'asfissia',
'asino',
'asparagi',
'aspirina',
'assalire',
'assegno',
'assolto',
'assurdo',
'asta',
'astratto',
'atlante',
'atletica',
'atomo',
'atropina',
'attacco',
'attesa',
'attico',
'atto',
'attrarre',
'auguri',
'aula',
'aumento',
'aurora',
'auspicio',
'autista',
'auto',
'autunno',
'avanzare',
'avarizia',
'avere',
'aviatore',
'avido',
'avorio',
'avvenire',
'avviso',
'avvocato',
'azienda',
'azione',
'azzardo',
'azzurro',
'babbuino',
'bacio',
'badante',
'baffi',
'bagaglio',
'bagliore',
'bagno',
'balcone',
'balena',
'ballare',
'balordo',
'balsamo',
'bambola',
'bancomat',
'banda',
'barato',
'barba',
'barista',
'barriera',
'basette',
'basilico',
'bassista',
'bastare',
'battello',
'bavaglio',
'beccare',
'beduino',
'bellezza',
'bene',
'benzina',
'berretto',
'bestia',
'bevitore',
'bianco',
'bibbia',
'biberon',
'bibita',
'bici',
'bidone',
'bilancia',
'biliardo',
'binario',
'binocolo',
'biologia',
'biondina',
'biopsia',
'biossido',
'birbante',
'birra',
'biscotto',
'bisogno',
'bistecca',
'bivio',
'blindare',
'bloccare',
'bocca',
'bollire',
'bombola',
'bonifico',
'borghese',
'borsa',
'bottino',
'botulino',
'braccio',
'bradipo',
'branco',
'bravo',
'bresaola',
'bretelle',
'brevetto',
'briciola',
'brigante',
'brillare',
'brindare',
'brivido',
'broccoli',
'brontolo',
'bruciare',
'brufolo',
'bucare',
'buddista',
'budino',
'bufera',
'buffo',
'bugiardo',
'buio',
'buono',
'burrone',
'bussola',
'bustina',
'buttare',
'cabernet',
'cabina',
'cacao',
'cacciare',
'cactus',
'cadavere',
'caffe',
'calamari',
'calcio',
'caldaia',
'calmare',
'calunnia',
'calvario',
'calzone',
'cambiare',
'camera',
'camion',
'cammello',
'campana',
'canarino',
'cancello',
'candore',
'cane',
'canguro',
'cannone',
'canoa',
'cantare',
'canzone',
'caos',
'capanna',
'capello',
'capire',
'capo',
'capperi',
'capra',
'capsula',
'caraffa',
'carbone',
'carciofo',
'cardigan',
'carenza',
'caricare',
'carota',
'carrello',
'carta',
'casa',
'cascare',
'caserma',
'cashmere',
'casino',
'cassetta',
'castello',
'catalogo',
'catena',
'catorcio',
'cattivo',
'causa',
'cauzione',
'cavallo',
'caverna',
'caviglia',
'cavo',
'cazzotto',
'celibato',
'cemento',
'cenare',
'centrale',
'ceramica',
'cercare',
'ceretta',
'cerniera',
'certezza',
'cervello',
'cessione',
'cestino',
'cetriolo',
'chiave',
'chiedere',
'chilo',
'chimera',
'chiodo',
'chirurgo',
'chitarra',
'chiudere',
'ciabatta',
'ciao',
'cibo',
'ciccia',
'cicerone',
'ciclone',
'cicogna',
'cielo',
'cifra',
'cigno',
'ciliegia',
'cimitero',
'cinema',
'cinque',
'cintura',
'ciondolo',
'ciotola',
'cipolla',
'cippato',
'circuito',
'cisterna',
'citofono',
'ciuccio',
'civetta',
'civico',
'clausola',
'cliente',
'clima',
'clinica',
'cobra',
'coccole',
'cocktail',
'cocomero',
'codice',
'coesione',
'cogliere',
'cognome',
'colla',
'colomba',
'colpire',
'coltello',
'comando',
'comitato',
'commedia',
'comodino',
'compagna',
'comune',
'concerto',
'condotto',
'conforto',
'congiura',
'coniglio',
'consegna',
'conto',
'convegno',
'coperta',
'copia',
'coprire',
'corazza',
'corda',
'corleone',
'cornice',
'corona',
'corpo',
'corrente',
'corsa',
'cortesia',
'corvo',
'coso',
'costume',
'cotone',
'cottura',
'cozza',
'crampo',
'cratere',
'cravatta',
'creare',
'credere',
'crema',
'crescere',
'crimine',
'criterio',
'croce',
'crollare',
'cronaca',
'crostata',
'croupier',
'cubetto',
'cucciolo',
'cucina',
'cultura',
'cuoco',
'cuore',
'cupido',
'cupola',
'cura',
'curva',
'cuscino',
'custode',
'danzare',
'data',
'decennio',
'decidere',
'decollo',
'dedicare',
'dedurre',
'definire',
'delegare',
'delfino',
'delitto',
'demone',
'dentista',
'denuncia',
'deposito',
'derivare',
'deserto',
'designer',
'destino',
'detonare',
'dettagli',
'diagnosi',
'dialogo',
'diamante',
'diario',
'diavolo',
'dicembre',
'difesa',
'digerire',
'digitare',
'diluvio',
'dinamica',
'dipinto',
'diploma',
'diramare',
'dire',
'dirigere',
'dirupo',
'discesa',
'disdetta',
'disegno',
'disporre',
'dissenso',
'distacco',
'dito',
'ditta',
'diva',
'divenire',
'dividere',
'divorare',
'docente',
'dolcetto',
'dolore',
'domatore',
'domenica',
'dominare',
'donatore',
'donna',
'dorato',
'dormire',
'dorso',
'dosaggio',
'dottore',
'dovere',
'download',
'dragone',
'dramma',
'dubbio',
'dubitare',
'duetto',
'durata',
'ebbrezza',
'eccesso',
'eccitare',
'eclissi',
'economia',
'edera',
'edificio',
'editore',
'edizione',
'educare',
'effetto',
'egitto',
'egiziano',
'elastico',
'elefante',
'eleggere',
'elemento',
'elenco',
'elezione',
'elmetto',
'elogio',
'embrione',
'emergere',
'emettere',
'eminenza',
'emisfero',
'emozione',
'empatia',
'energia',
'enfasi',
'enigma',
'entrare',
'enzima',
'epidemia',
'epilogo',
'episodio',
'epoca',
'equivoco',
'erba',
'erede',
'eroe',
'erotico',
'errore',
'eruzione',
'esaltare',
'esame',
'esaudire',
'eseguire',
'esempio',
'esigere',
'esistere',
'esito',
'esperto',
'espresso',
'essere',
'estasi',
'esterno',
'estrarre',
'eterno',
'etica',
'euforico',
'europa',
'evacuare',
'evasione',
'evento',
'evidenza',
'evitare',
'evolvere',
'fabbrica',
'facciata',
'fagiano',
'fagotto',
'falco',
'fame',
'famiglia',
'fanale',
'fango',
'fantasia',
'farfalla',
'farmacia',
'faro',
'fase',
'fastidio',
'faticare',
'fatto',
'favola',
'febbre',
'femmina',
'femore',
'fenomeno',
'fermata',
'feromoni',
'ferrari',
'fessura',
'festa',
'fiaba',
'fiamma',
'fianco',
'fiat',
'fibbia',
'fidare',
'fieno',
'figa',
'figlio',
'figura',
'filetto',
'filmato',
'filosofo',
'filtrare',
'finanza',
'finestra',
'fingere',
'finire',
'finta',
'finzione',
'fiocco',
'fioraio',
'firewall',
'firmare',
'fisico',
'fissare',
'fittizio',
'fiume',
'flacone',
'flagello',
'flirtare',
'flusso',
'focaccia',
'foglio',
'fognario',
'follia',
'fonderia',
'fontana',
'forbici',
'forcella',
'foresta',
'forgiare',
'formare',
'fornace',
'foro',
'fortuna',
'forzare',
'fosforo',
'fotoni',
'fracasso',
'fragola',
'frantumi',
'fratello',
'frazione',
'freccia',
'freddo',
'frenare',
'fresco',
'friggere',
'frittata',
'frivolo',
'frizione',
'fronte',
'frullato',
'frumento',
'frusta',
'frutto',
'fucile',
'fuggire',
'fulmine',
'fumare',
'funzione',
'fuoco',
'furbizia',
'furgone',
'furia',
'furore',
'fusibile',
'fuso',
'futuro',
'gabbiano',
'galassia',
'gallina',
'gamba',
'gancio',
'garanzia',
'garofano',
'gasolio',
'gatto',
'gazebo',
'gazzetta',
'gelato',
'gemelli',
'generare',
'genitori',
'gennaio',
'geologia',
'germania',
'gestire',
'gettare',
'ghepardo',
'ghiaccio',
'giaccone',
'giaguaro',
'giallo',
'giappone',
'giardino',
'gigante',
'gioco',
'gioiello',
'giorno',
'giovane',
'giraffa',
'giudizio',
'giurare',
'giusto',
'globo',
'gloria',
'glucosio',
'gnocca',
'gocciola',
'godere',
'gomito',
'gomma',
'gonfiare',
'gorilla',
'governo',
'gradire',
'graffiti',
'granchio',
'grappolo',
'grasso',
'grattare',
'gridare',
'grissino',
'grondaia',
'grugnito',
'gruppo',
'guadagno',
'guaio',
'guancia',
'guardare',
'gufo',
'guidare',
'guscio',
'gusto',
'icona',
'idea',
'identico',
'idolo',
'idoneo',
'idrante',
'idrogeno',
'igiene',
'ignoto',
'imbarco',
'immagine',
'immobile',
'imparare',
'impedire',
'impianto',
'importo',
'impresa',
'impulso',
'incanto',
'incendio',
'incidere',
'incontro',
'incrocia',
'incubo',
'indagare',
'indice',
'indotto',
'infanzia',
'inferno',
'infinito',
'infranto',
'ingerire',
'inglese',
'ingoiare',
'ingresso',
'iniziare',
'innesco',
'insalata',
'inserire',
'insicuro',
'insonnia',
'insulto',
'interno',
'introiti',
'invasori',
'inverno',
'invito',
'invocare',
'ipnosi',
'ipocrita',
'ipotesi',
'ironia',
'irrigare',
'iscritto',
'isola',
'ispirare',
'isterico',
'istinto',
'istruire',
'italiano',
'jazz',
'labbra',
'labrador',
'ladro',
'lago',
'lamento',
'lampone',
'lancetta',
'lanterna',
'lapide',
'larva',
'lasagne',
'lasciare',
'lastra',
'latte',
'laurea',
'lavagna',
'lavorare',
'leccare',
'legare',
'leggere',
'lenzuolo',
'leone',
'lepre',
'letargo',
'lettera',
'levare',
'levitare',
'lezione',
'liberare',
'libidine',
'libro',
'licenza',
'lievito',
'limite',
'lince',
'lingua',
'liquore',
'lire',
'listino',
'litigare',
'litro',
'locale',
'lottare',
'lucciola',
'lucidare',
'luglio',
'luna',
'macchina',
'madama',
'madre',
'maestro',
'maggio',
'magico',
'maglione',
'magnolia',
'mago',
'maialino',
'maionese',
'malattia',
'male',
'malloppo',
'mancare',
'mandorla',
'mangiare',
'manico',
'manopola',
'mansarda',
'mantello',
'manubrio',
'manzo',
'mappa',
'mare',
'margine',
'marinaio',
'marmotta',
'marocco',
'martello',
'marzo',
'maschera',
'matrice',
'maturare',
'mazzetta',
'meandri',
'medaglia',
'medico',
'medusa',
'megafono',
'melone',
'membrana',
'menta',
'mercato',
'meritare',
'merluzzo',
'mese',
'mestiere',
'metafora',
'meteo',
'metodo',
'mettere',
'miele',
'miglio',
'miliardo',
'mimetica',
'minatore',
'minuto',
'miracolo',
'mirtillo',
'missile',
'mistero',
'misura',
'mito',
'mobile',
'moda',
'moderare',
'moglie',
'molecola',
'molle',
'momento',
'moneta',
'mongolia',
'monologo',
'montagna',
'morale',
'morbillo',
'mordere',
'mosaico',
'mosca',
'mostro',
'motivare',
'moto',
'mulino',
'mulo',
'muovere',
'muraglia',
'muscolo',
'museo',
'musica',
'mutande',
'nascere',
'nastro',
'natale',
'natura',
'nave',
'navigare',
'negare',
'negozio',
'nemico',
'nero',
'nervo',
'nessuno',
'nettare',
'neutroni',
'neve',
'nevicare',
'nicotina',
'nido',
'nipote',
'nocciola',
'noleggio',
'nome',
'nonno',
'norvegia',
'notare',
'notizia',
'nove',
'nucleo',
'nuda',
'nuotare',
'nutrire',
'obbligo',
'occhio',
'occupare',
'oceano',
'odissea',
'odore',
'offerta',
'officina',
'offrire',
'oggetto',
'oggi',
'olfatto',
'olio',
'oliva',
'ombelico',
'ombrello',
'omuncolo',
'ondata',
'onore',
'opera',
'opinione',
'opuscolo',
'opzione',
'orario',
'orbita',
'orchidea',
'ordine',
'orecchio',
'orgasmo',
'orgoglio',
'origine',
'orologio',
'oroscopo',
'orso',
'oscurare',
'ospedale',
'ospite',
'ossigeno',
'ostacolo',
'ostriche',
'ottenere',
'ottimo',
'ottobre',
'ovest',
'pacco',
'pace',
'pacifico',
'padella',
'pagare',
'pagina',
'pagnotta',
'palazzo',
'palestra',
'palpebre',
'pancetta',
'panfilo',
'panino',
'pannello',
'panorama',
'papa',
'paperino',
'paradiso',
'parcella',
'parente',
'parlare',
'parodia',
'parrucca',
'partire',
'passare',
'pasta',
'patata',
'patente',
'patogeno',
'patriota',
'pausa',
'pazienza',
'peccare',
'pecora',
'pedalare',
'pelare',
'pena',
'pendenza',
'penisola',
'pennello',
'pensare',
'pentirsi',
'percorso',
'perdono',
'perfetto',
'perizoma',
'perla',
'permesso',
'persona',
'pesare',
'pesce',
'peso',
'petardo',
'petrolio',
'pezzo',
'piacere',
'pianeta',
'piastra',
'piatto',
'piazza',
'piccolo',
'piede',
'piegare',
'pietra',
'pigiama',
'pigliare',
'pigrizia',
'pilastro',
'pilota',
'pinguino',
'pioggia',
'piombo',
'pionieri',
'piovra',
'pipa',
'pirata',
'pirolisi',
'piscina',
'pisolino',
'pista',
'pitone',
'piumino',
'pizza',
'plastica',
'platino',
'poesia',
'poiana',
'polaroid',
'polenta',
'polimero',
'pollo',
'polmone',
'polpetta',
'poltrona',
'pomodoro',
'pompa',
'popolo',
'porco',
'porta',
'porzione',
'possesso',
'postino',
'potassio',
'potere',
'poverino',
'pranzo',
'prato',
'prefisso',
'prelievo',
'premio',
'prendere',
'prestare',
'pretesa',
'prezzo',
'primario',
'privacy',
'problema',
'processo',
'prodotto',
'profeta',
'progetto',
'promessa',
'pronto',
'proposta',
'proroga',
'prossimo',
'proteina',
'prova',
'prudenza',
'pubblico',
'pudore',
'pugilato',
'pulire',
'pulsante',
'puntare',
'pupazzo',
'puzzle',
'quaderno',
'qualcuno',
'quarzo',
'quercia',
'quintale',
'rabbia',
'racconto',
'radice',
'raffica',
'ragazza',
'ragione',
'rammento',
'ramo',
'rana',
'randagio',
'rapace',
'rapinare',
'rapporto',
'rasatura',
'ravioli',
'reagire',
'realista',
'reattore',
'reazione',
'recitare',
'recluso',
'record',
'recupero',
'redigere',
'regalare',
'regina',
'regola',
'relatore',
'reliquia',
'remare',
'rendere',
'reparto',
'resina',
'resto',
'rete',
'retorica',
'rettile',
'revocare',
'riaprire',
'ribadire',
'ribelle',
'ricambio',
'ricetta',
'richiamo',
'ricordo',
'ridurre',
'riempire',
'riferire',
'riflesso',
'righello',
'rilancio',
'rilevare',
'rilievo',
'rimanere',
'rimborso',
'rinforzo',
'rinuncia',
'riparo',
'ripetere',
'riposare',
'ripulire',
'risalita',
'riscatto',
'riserva',
'riso',
'rispetto',
'ritaglio',
'ritmo',
'ritorno',
'ritratto',
'rituale',
'riunione',
'riuscire',
'riva',
'robotica',
'rondine',
'rosa',
'rospo',
'rosso',
'rotonda',
'rotta',
'roulotte',
'rubare',
'rubrica',
'ruffiano',
'rumore',
'ruota',
'ruscello',
'sabbia',
'sacco',
'saggio',
'sale',
'salire',
'salmone',
'salto',
'salutare',
'salvia',
'sangue',
'sanzioni',
'sapere',
'sapienza',
'sarcasmo',
'sardine',
'sartoria',
'sbalzo',
'sbarcare',
'sberla',
'sborsare',
'scadenza',
'scafo',
'scala',
'scambio',
'scappare',
'scarpa',
'scatola',
'scelta',
'scena',
'sceriffo',
'scheggia',
'schiuma',
'sciarpa',
'scienza',
'scimmia',
'sciopero',
'scivolo',
'sclerare',
'scolpire',
'sconto',
'scopa',
'scordare',
'scossa',
'scrivere',
'scrupolo',
'scuderia',
'scultore',
'scuola',
'scusare',
'sdraiare',
'secolo',
'sedativo',
'sedere',
'sedia',
'segare',
'segreto',
'seguire',
'semaforo',
'seme',
'senape',
'seno',
'sentiero',
'separare',
'sepolcro',
'sequenza',
'serata',
'serpente',
'servizio',
'sesso',
'seta',
'settore',
'sfamare',
'sfera',
'sfidare',
'sfiorare',
'sfogare',
'sgabello',
'sicuro',
'siepe',
'sigaro',
'silenzio',
'silicone',
'simbiosi',
'simpatia',
'simulare',
'sinapsi',
'sindrome',
'sinergia',
'sinonimo',
'sintonia',
'sirena',
'siringa',
'sistema',
'sito',
'smalto',
'smentire',
'smontare',
'soccorso',
'socio',
'soffitto',
'software',
'soggetto',
'sogliola',
'sognare',
'soldi',
'sole',
'sollievo',
'solo',
'sommario',
'sondare',
'sonno',
'sorpresa',
'sorriso',
'sospiro',
'sostegno',
'sovrano',
'spaccare',
'spada',
'spagnolo',
'spalla',
'sparire',
'spavento',
'spazio',
'specchio',
'spedire',
'spegnere',
'spendere',
'speranza',
'spessore',
'spezzare',
'spiaggia',
'spiccare',
'spiegare',
'spiffero',
'spingere',
'sponda',
'sporcare',
'spostare',
'spremuta',
'spugna',
'spumante',
'spuntare',
'squadra',
'squillo',
'staccare',
'stadio',
'stagione',
'stallone',
'stampa',
'stancare',
'starnuto',
'statura',
'stella',
'stendere',
'sterzo',
'stilista',
'stimolo',
'stinco',
'stiva',
'stoffa',
'storia',
'strada',
'stregone',
'striscia',
'studiare',
'stufa',
'stupendo',
'subire',
'successo',
'sudare',
'suono',
'superare',
'supporto',
'surfista',
'sussurro',
'svelto',
'svenire',
'sviluppo',
'svolta',
'svuotare',
'tabacco',
'tabella',
'tabu',
'tacchino',
'tacere',
'taglio',
'talento',
'tangente',
'tappeto',
'tartufo',
'tassello',
'tastiera',
'tavolo',
'tazza',
'teatro',
'tedesco',
'telaio',
'telefono',
'tema',
'temere',
'tempo',
'tendenza',
'tenebre',
'tensione',
'tentare',
'teologia',
'teorema',
'termica',
'terrazzo',
'teschio',
'tesi',
'tesoro',
'tessera',
'testa',
'thriller',
'tifoso',
'tigre',
'timbrare',
'timido',
'tinta',
'tirare',
'tisana',
'titano',
'titolo',
'toccare',
'togliere',
'topolino',
'torcia',
'torrente',
'tovaglia',
'traffico',
'tragitto',
'training',
'tramonto',
'transito',
'trapezio',
'trasloco',
'trattore',
'trazione',
'treccia',
'tregua',
'treno',
'triciclo',
'tridente',
'trilogia',
'tromba',
'troncare',
'trota',
'trovare',
'trucco',
'tubo',
'tulipano',
'tumulto',
'tunisia',
'tuono',
'turista',
'tuta',
'tutelare',
'tutore',
'ubriaco',
'uccello',
'udienza',
'udito',
'uffa',
'umanoide',
'umore',
'unghia',
'unguento',
'unicorno',
'unione',
'universo',
'uomo',
'uragano',
'uranio',
'urlare',
'uscire',
'utente',
'utilizzo',
'vacanza',
'vacca',
'vaglio',
'vagonata',
'valle',
'valore',
'valutare',
'valvola',
'vampiro',
'vaniglia',
'vanto',
'vapore',
'variante',
'vasca',
'vaselina',
'vassoio',
'vedere',
'vegetale',
'veglia',
'veicolo',
'vela',
'veleno',
'velivolo',
'velluto',
'vendere',
'venerare',
'venire',
'vento',
'veranda',
'verbo',
'verdura',
'vergine',
'verifica',
'vernice',
'vero',
'verruca',
'versare',
'vertebra',
'vescica',
'vespaio',
'vestito',
'vesuvio',
'veterano',
'vetro',
'vetta',
'viadotto',
'viaggio',
'vibrare',
'vicenda',
'vichingo',
'vietare',
'vigilare',
'vigneto',
'villa',
'vincere',
'violino',
'vipera',
'virgola',
'virtuoso',
'visita',
'vita',
'vitello',
'vittima',
'vivavoce',
'vivere',
'viziato',
'voglia',
'volare',
'volpe',
'volto',
'volume',
'vongole',
'voragine',
'vortice',
'votare',
'vulcano',
'vuotare',
'zabaione',
'zaffiro',
'zainetto',
'zampa',
'zanzara',
'zattera',
'zavorra',
'zenzero',
'zero',
'zingaro',
'zittire',
'zoccolo',
'zolfo',
'zombie',
'zucchero'
];
// SPDX-License-Identifier: MIT
const WORDLIST$3 = [
'あいこくしん',
'あいさつ',
'あいだ',
'あおぞら',
'あかちゃん',
'あきる',
'あけがた',
'あける',
'あこがれる',
'あさい',
'あさひ',
'あしあと',
'あじわう',
'あずかる',
'あずき',
'あそぶ',
'あたえる',
'あたためる',
'あたりまえ',
'あたる',
'あつい',
'あつかう',
'あっしゅく',
'あつまり',
'あつめる',
'あてな',
'あてはまる',
'あひる',
'あぶら',
'あぶる',
'あふれる',
'あまい',
'あまど',
'あまやかす',
'あまり',
'あみもの',
'あめりか',
'あやまる',
'あゆむ',
'あらいぐま',
'あらし',
'あらすじ',
'あらためる',
'あらゆる',
'あらわす',
'ありがとう',
'あわせる',
'あわてる',
'あんい',
'あんがい',
'あんこ',
'あんぜん',
'あんてい',
'あんない',
'あんまり',
'いいだす',
'いおん',
'いがい',
'いがく',
'いきおい',
'いきなり',
'いきもの',
'いきる',
'いくじ',
'いくぶん',
'いけばな',
'いけん',
'いこう',
'いこく',
'いこつ',
'いさましい',
'いさん',
'いしき',
'いじゅう',
'いじょう',
'いじわる',
'いずみ',
'いずれ',
'いせい',
'いせえび',
'いせかい',
'いせき',
'いぜん',
'いそうろう',
'いそがしい',
'いだい',
'いだく',
'いたずら',
'いたみ',
'いたりあ',
'いちおう',
'いちじ',
'いちど',
'いちば',
'いちぶ',
'いちりゅう',
'いつか',
'いっしゅん',
'いっせい',
'いっそう',
'いったん',
'いっち',
'いってい',
'いっぽう',
'いてざ',
'いてん',
'いどう',
'いとこ',
'いない',
'いなか',
'いねむり',
'いのち',
'いのる',
'いはつ',
'いばる',
'いはん',
'いびき',
'いひん',
'いふく',
'いへん',
'いほう',
'いみん',
'いもうと',
'いもたれ',
'いもり',
'いやがる',
'いやす',
'いよかん',
'いよく',
'いらい',
'いらすと',
'いりぐち',
'いりょう',
'いれい',
'いれもの',
'いれる',
'いろえんぴつ',
'いわい',
'いわう',
'いわかん',
'いわば',
'いわゆる',
'いんげんまめ',
'いんさつ',
'いんしょう',
'いんよう',
'うえき',
'うえる',
'うおざ',
'うがい',
'うかぶ',
'うかべる',
'うきわ',
'うくらいな',
'うくれれ',
'うけたまわる',
'うけつけ',
'うけとる',
'うけもつ',
'うける',
'うごかす',
'うごく',
'うこん',
'うさぎ',
'うしなう',
'うしろがみ',
'うすい',
'うすぎ',
'うすぐらい',
'うすめる',
'うせつ',
'うちあわせ',
'うちがわ',
'うちき',
'うちゅう',
'うっかり',
'うつくしい',
'うったえる',
'うつる',
'うどん',
'うなぎ',
'うなじ',
'うなずく',
'うなる',
'うねる',
'うのう',
'うぶげ',
'うぶごえ',
'うまれる',
'うめる',
'うもう',
'うやまう',
'うよく',
'うらがえす',
'うらぐち',
'うらない',
'うりあげ',
'うりきれ',
'うるさい',
'うれしい',
'うれゆき',
'うれる',
'うろこ',
'うわき',
'うわさ',
'うんこう',
'うんちん',
'うんてん',
'うんどう',
'えいえん',
'えいが',
'えいきょう',
'えいご',
'えいせい',
'えいぶん',
'えいよう',
'えいわ',
'えおり',
'えがお',
'えがく',
'えきたい',
'えくせる',
'えしゃく',
'えすて',
'えつらん',
'えのぐ',
'えほうまき',
'えほん',
'えまき',
'えもじ',
'えもの',
'えらい',
'えらぶ',
'えりあ',
'えんえん',
'えんかい',
'えんぎ',
'えんげき',
'えんしゅう',
'えんぜつ',
'えんそく',
'えんちょう',
'えんとつ',
'おいかける',
'おいこす',
'おいしい',
'おいつく',
'おうえん',
'おうさま',
'おうじ',
'おうせつ',
'おうたい',
'おうふく',
'おうべい',
'おうよう',
'おえる',
'おおい',
'おおう',
'おおどおり',
'おおや',
'おおよそ',
'おかえり',
'おかず',
'おがむ',
'おかわり',
'おぎなう',
'おきる',
'おくさま',
'おくじょう',
'おくりがな',
'おくる',
'おくれる',
'おこす',
'おこなう',
'おこる',
'おさえる',
'おさない',
'おさめる',
'おしいれ',
'おしえる',
'おじぎ',
'おじさん',
'おしゃれ',
'おそらく',
'おそわる',
'おたがい',
'おたく',
'おだやか',
'おちつく',
'おっと',
'おつり',
'おでかけ',
'おとしもの',
'おとなしい',
'おどり',
'おどろかす',
'おばさん',
'おまいり',
'おめでとう',
'おもいで',
'おもう',
'おもたい',
'おもちゃ',
'おやつ',
'おやゆび',
'およぼす',
'おらんだ',
'おろす',
'おんがく',
'おんけい',
'おんしゃ',
'おんせん',
'おんだん',
'おんちゅう',
'おんどけい',
'かあつ',
'かいが',
'がいき',
'がいけん',
'がいこう',
'かいさつ',
'かいしゃ',
'かいすいよく',
'かいぜん',
'かいぞうど',
'かいつう',
'かいてん',
'かいとう',
'かいふく',
'がいへき',
'かいほう',
'かいよう',
'がいらい',
'かいわ',
'かえる',
'かおり',
'かかえる',
'かがく',
'かがし',
'かがみ',
'かくご',
'かくとく',
'かざる',
'がぞう',
'かたい',
'かたち',
'がちょう',
'がっきゅう',
'がっこう',
'がっさん',
'がっしょう',
'かなざわし',
'かのう',
'がはく',
'かぶか',
'かほう',
'かほご',
'かまう',
'かまぼこ',
'かめれおん',
'かゆい',
'かようび',
'からい',
'かるい',
'かろう',
'かわく',
'かわら',
'がんか',
'かんけい',
'かんこう',
'かんしゃ',
'かんそう',
'かんたん',
'かんち',
'がんばる',
'きあい',
'きあつ',
'きいろ',
'ぎいん',
'きうい',
'きうん',
'きえる',
'きおう',
'きおく',
'きおち',
'きおん',
'きかい',
'きかく',
'きかんしゃ',
'ききて',
'きくばり',
'きくらげ',
'きけんせい',
'きこう',
'きこえる',
'きこく',
'きさい',
'きさく',
'きさま',
'きさらぎ',
'ぎじかがく',
'ぎしき',
'ぎじたいけん',
'ぎじにってい',
'ぎじゅつしゃ',
'きすう',
'きせい',
'きせき',
'きせつ',
'きそう',
'きぞく',
'きぞん',
'きたえる',
'きちょう',
'きつえん',
'ぎっちり',
'きつつき',
'きつね',
'きてい',
'きどう',
'きどく',
'きない',
'きなが',
'きなこ',
'きぬごし',
'きねん',
'きのう',
'きのした',
'きはく',
'きびしい',
'きひん',
'きふく',
'きぶん',
'きぼう',
'きほん',
'きまる',
'きみつ',
'きむずかしい',
'きめる',
'きもだめし',
'きもち',
'きもの',
'きゃく',
'きやく',
'ぎゅうにく',
'きよう',
'きょうりゅう',
'きらい',
'きらく',
'きりん',
'きれい',
'きれつ',
'きろく',
'ぎろん',
'きわめる',
'ぎんいろ',
'きんかくじ',
'きんじょ',
'きんようび',
'ぐあい',
'くいず',
'くうかん',
'くうき',
'くうぐん',
'くうこう',
'ぐうせい',
'くうそう',
'ぐうたら',
'くうふく',
'くうぼ',
'くかん',
'くきょう',
'くげん',
'ぐこう',
'くさい',
'くさき',
'くさばな',
'くさる',
'くしゃみ',
'くしょう',
'くすのき',
'くすりゆび',
'くせげ',
'くせん',
'ぐたいてき',
'くださる',
'くたびれる',
'くちこみ',
'くちさき',
'くつした',
'ぐっすり',
'くつろぐ',
'くとうてん',
'くどく',
'くなん',
'くねくね',
'くのう',
'くふう',
'くみあわせ',
'くみたてる',
'くめる',
'くやくしょ',
'くらす',
'くらべる',
'くるま',
'くれる',
'くろう',
'くわしい',
'ぐんかん',
'ぐんしょく',
'ぐんたい',
'ぐんて',
'けあな',
'けいかく',
'けいけん',
'けいこ',
'けいさつ',
'げいじゅつ',
'けいたい',
'げいのうじん',
'けいれき',
'けいろ',
'けおとす',
'けおりもの',
'げきか',
'げきげん',
'げきだん',
'げきちん',
'げきとつ',
'げきは',
'げきやく',
'げこう',
'げこくじょう',
'げざい',
'けさき',
'げざん',
'けしき',
'けしごむ',
'けしょう',
'げすと',
'けたば',
'けちゃっぷ',
'けちらす',
'けつあつ',
'けつい',
'けつえき',
'けっこん',
'けつじょ',
'けっせき',
'けってい',
'けつまつ',
'げつようび',
'げつれい',
'けつろん',
'げどく',
'けとばす',
'けとる',
'けなげ',
'けなす',
'けなみ',
'けぬき',
'げねつ',
'けねん',
'けはい',
'げひん',
'けぶかい',
'げぼく',
'けまり',
'けみかる',
'けむし',
'けむり',
'けもの',
'けらい',
'けろけろ',
'けわしい',
'けんい',
'けんえつ',
'けんお',
'けんか',
'げんき',
'けんげん',
'けんこう',
'けんさく',
'けんしゅう',
'けんすう',
'げんそう',
'けんちく',
'けんてい',
'けんとう',
'けんない',
'けんにん',
'げんぶつ',
'けんま',
'けんみん',
'けんめい',
'けんらん',
'けんり',
'こあくま',
'こいぬ',
'こいびと',
'ごうい',
'こうえん',
'こうおん',
'こうかん',
'ごうきゅう',
'ごうけい',
'こうこう',
'こうさい',
'こうじ',
'こうすい',
'ごうせい',
'こうそく',
'こうたい',
'こうちゃ',
'こうつう',
'こうてい',
'こうどう',
'こうない',
'こうはい',
'ごうほう',
'ごうまん',
'こうもく',
'こうりつ',
'こえる',
'こおり',
'ごかい',
'ごがつ',
'ごかん',
'こくご',
'こくさい',
'こくとう',
'こくない',
'こくはく',
'こぐま',
'こけい',
'こける',
'ここのか',
'こころ',
'こさめ',
'こしつ',
'こすう',
'こせい',
'こせき',
'こぜん',
'こそだて',
'こたい',
'こたえる',
'こたつ',
'こちょう',
'こっか',
'こつこつ',
'こつばん',
'こつぶ',
'こてい',
'こてん',
'ことがら',
'ことし',
'ことば',
'ことり',
'こなごな',
'こねこね',
'このまま',
'このみ',
'このよ',
'ごはん',
'こひつじ',
'こふう',
'こふん',
'こぼれる',
'ごまあぶら',
'こまかい',
'ごますり',
'こまつな',
'こまる',
'こむぎこ',
'こもじ',
'こもち',
'こもの',
'こもん',
'こやく',
'こやま',
'こゆう',
'こゆび',
'こよい',
'こよう',
'こりる',
'これくしょん',
'ころっけ',
'こわもて',
'こわれる',
'こんいん',
'こんかい',
'こんき',
'こんしゅう',
'こんすい',
'こんだて',
'こんとん',
'こんなん',
'こんびに',
'こんぽん',
'こんまけ',
'こんや',
'こんれい',
'こんわく',
'ざいえき',
'さいかい',
'さいきん',
'ざいげん',
'ざいこ',
'さいしょ',
'さいせい',
'ざいたく',
'ざいちゅう',
'さいてき',
'ざいりょう',
'さうな',
'さかいし',
'さがす',
'さかな',
'さかみち',
'さがる',
'さぎょう',
'さくし',
'さくひん',
'さくら',
'さこく',
'さこつ',
'さずかる',
'ざせき',
'さたん',
'さつえい',
'ざつおん',
'ざっか',
'ざつがく',
'さっきょく',
'ざっし',
'さつじん',
'ざっそう',
'さつたば',
'さつまいも',
'さてい',
'さといも',
'さとう',
'さとおや',
'さとし',
'さとる',
'さのう',
'さばく',
'さびしい',
'さべつ',
'さほう',
'さほど',
'さます',
'さみしい',
'さみだれ',
'さむけ',
'さめる',
'さやえんどう',
'さゆう',
'さよう',
'さよく',
'さらだ',
'ざるそば',
'さわやか',
'さわる',
'さんいん',
'さんか',
'さんきゃく',
'さんこう',
'さんさい',
'ざんしょ',
'さんすう',
'さんせい',
'さんそ',
'さんち',
'さんま',
'さんみ',
'さんらん',
'しあい',
'しあげ',
'しあさって',
'しあわせ',
'しいく',
'しいん',
'しうち',
'しえい',
'しおけ',
'しかい',
'しかく',
'じかん',
'しごと',
'しすう',
'じだい',
'したうけ',
'したぎ',
'したて',
'したみ',
'しちょう',
'しちりん',
'しっかり',
'しつじ',
'しつもん',
'してい',
'してき',
'してつ',
'じてん',
'じどう',
'しなぎれ',
'しなもの',
'しなん',
'しねま',
'しねん',
'しのぐ',
'しのぶ',
'しはい',
'しばかり',
'しはつ',
'しはらい',
'しはん',
'しひょう',
'しふく',
'じぶん',
'しへい',
'しほう',
'しほん',
'しまう',
'しまる',
'しみん',
'しむける',
'じむしょ',
'しめい',
'しめる',
'しもん',
'しゃいん',
'しゃうん',
'しゃおん',
'じゃがいも',
'しやくしょ',
'しゃくほう',
'しゃけん',
'しゃこ',
'しゃざい',
'しゃしん',
'しゃせん',
'しゃそう',
'しゃたい',
'しゃちょう',
'しゃっきん',
'じゃま',
'しゃりん',
'しゃれい',
'じゆう',
'じゅうしょ',
'しゅくはく',
'じゅしん',
'しゅっせき',
'しゅみ',
'しゅらば',
'じゅんばん',
'しょうかい',
'しょくたく',
'しょっけん',
'しょどう',
'しょもつ',
'しらせる',
'しらべる',
'しんか',
'しんこう',
'じんじゃ',
'しんせいじ',
'しんちく',
'しんりん',
'すあげ',
'すあし',
'すあな',
'ずあん',
'すいえい',
'すいか',
'すいとう',
'ずいぶん',
'すいようび',
'すうがく',
'すうじつ',
'すうせん',
'すおどり',
'すきま',
'すくう',
'すくない',
'すける',
'すごい',
'すこし',
'ずさん',
'すずしい',
'すすむ',
'すすめる',
'すっかり',
'ずっしり',
'ずっと',
'すてき',
'すてる',
'すねる',
'すのこ',
'すはだ',
'すばらしい',
'ずひょう',
'ずぶぬれ',
'すぶり',
'すふれ',
'すべて',
'すべる',
'ずほう',
'すぼん',
'すまい',
'すめし',
'すもう',
'すやき',
'すらすら',
'するめ',
'すれちがう',
'すろっと',
'すわる',
'すんぜん',
'すんぽう',
'せあぶら',
'せいかつ',
'せいげん',
'せいじ',
'せいよう',
'せおう',
'せかいかん',
'せきにん',
'せきむ',
'せきゆ',
'せきらんうん',
'せけん',
'せこう',
'せすじ',
'せたい',
'せたけ',
'せっかく',
'せっきゃく',
'ぜっく',
'せっけん',
'せっこつ',
'せっさたくま',
'せつぞく',
'せつだん',
'せつでん',
'せっぱん',
'せつび',
'せつぶん',
'せつめい',
'せつりつ',
'せなか',
'せのび',
'せはば',
'せびろ',
'せぼね',
'せまい',
'せまる',
'せめる',
'せもたれ',
'せりふ',
'ぜんあく',
'せんい',
'せんえい',
'せんか',
'せんきょ',
'せんく',
'せんげん',
'ぜんご',
'せんさい',
'せんしゅ',
'せんすい',
'せんせい',
'せんぞ',
'せんたく',
'せんちょう',
'せんてい',
'せんとう',
'せんぬき',
'せんねん',
'せんぱい',
'ぜんぶ',
'ぜんぽう',
'せんむ',
'せんめんじょ',
'せんもん',
'せんやく',
'せんゆう',
'せんよう',
'ぜんら',
'ぜんりゃく',
'せんれい',
'せんろ',
'そあく',
'そいとげる',
'そいね',
'そうがんきょう',
'そうき',
'そうご',
'そうしん',
'そうだん',
'そうなん',
'そうび',
'そうめん',
'そうり',
'そえもの',
'そえん',
'そがい',
'そげき',
'そこう',
'そこそこ',
'そざい',
'そしな',
'そせい',
'そせん',
'そそぐ',
'そだてる',
'そつう',
'そつえん',
'そっかん',
'そつぎょう',
'そっけつ',
'そっこう',
'そっせん',
'そっと',
'そとがわ',
'そとづら',
'そなえる',
'そなた',
'そふぼ',
'そぼく',
'そぼろ',
'そまつ',
'そまる',
'そむく',
'そむりえ',
'そめる',
'そもそも',
'そよかぜ',
'そらまめ',
'そろう',
'そんかい',
'そんけい',
'そんざい',
'そんしつ',
'そんぞく',
'そんちょう',
'ぞんび',
'ぞんぶん',
'そんみん',
'たあい',
'たいいん',
'たいうん',
'たいえき',
'たいおう',
'だいがく',
'たいき',
'たいぐう',
'たいけん',
'たいこ',
'たいざい',
'だいじょうぶ',
'だいすき',
'たいせつ',
'たいそう',
'だいたい',
'たいちょう',
'たいてい',
'だいどころ',
'たいない',
'たいねつ',
'たいのう',
'たいはん',
'だいひょう',
'たいふう',
'たいへん',
'たいほ',
'たいまつばな',
'たいみんぐ',
'たいむ',
'たいめん',
'たいやき',
'たいよう',
'たいら',
'たいりょく',
'たいる',
'たいわん',
'たうえ',
'たえる',
'たおす',
'たおる',
'たおれる',
'たかい',
'たかね',
'たきび',
'たくさん',
'たこく',
'たこやき',
'たさい',
'たしざん',
'だじゃれ',
'たすける',
'たずさわる',
'たそがれ',
'たたかう',
'たたく',
'ただしい',
'たたみ',
'たちばな',
'だっかい',
'だっきゃく',
'だっこ',
'だっしゅつ',
'だったい',
'たてる',
'たとえる',
'たなばた',
'たにん',
'たぬき',
'たのしみ',
'たはつ',
'たぶん',
'たべる',
'たぼう',
'たまご',
'たまる',
'だむる',
'ためいき',
'ためす',
'ためる',
'たもつ',
'たやすい',
'たよる',
'たらす',
'たりきほんがん',
'たりょう',
'たりる',
'たると',
'たれる',
'たれんと',
'たろっと',
'たわむれる',
'だんあつ',
'たんい',
'たんおん',
'たんか',
'たんき',
'たんけん',
'たんご',
'たんさん',
'たんじょうび',
'だんせい',
'たんそく',
'たんたい',
'だんち',
'たんてい',
'たんとう',
'だんな',
'たんにん',
'だんねつ',
'たんのう',
'たんぴん',
'だんぼう',
'たんまつ',
'たんめい',
'だんれつ',
'だんろ',
'だんわ',
'ちあい',
'ちあん',
'ちいき',
'ちいさい',
'ちえん',
'ちかい',
'ちから',
'ちきゅう',
'ちきん',
'ちけいず',
'ちけん',
'ちこく',
'ちさい',
'ちしき',
'ちしりょう',
'ちせい',
'ちそう',
'ちたい',
'ちたん',
'ちちおや',
'ちつじょ',
'ちてき',
'ちてん',
'ちぬき',
'ちぬり',
'ちのう',
'ちひょう',
'ちへいせん',
'ちほう',
'ちまた',
'ちみつ',
'ちみどろ',
'ちめいど',
'ちゃんこなべ',
'ちゅうい',
'ちゆりょく',
'ちょうし',
'ちょさくけん',
'ちらし',
'ちらみ',
'ちりがみ',
'ちりょう',
'ちるど',
'ちわわ',
'ちんたい',
'ちんもく',
'ついか',
'ついたち',
'つうか',
'つうじょう',
'つうはん',
'つうわ',
'つかう',
'つかれる',
'つくね',
'つくる',
'つけね',
'つける',
'つごう',
'つたえる',
'つづく',
'つつじ',
'つつむ',
'つとめる',
'つながる',
'つなみ',
'つねづね',
'つのる',
'つぶす',
'つまらない',
'つまる',
'つみき',
'つめたい',
'つもり',
'つもる',
'つよい',
'つるぼ',
'つるみく',
'つわもの',
'つわり',
'てあし',
'てあて',
'てあみ',
'ていおん',
'ていか',
'ていき',
'ていけい',
'ていこく',
'ていさつ',
'ていし',
'ていせい',
'ていたい',
'ていど',
'ていねい',
'ていひょう',
'ていへん',
'ていぼう',
'てうち',
'ておくれ',
'てきとう',
'てくび',
'でこぼこ',
'てさぎょう',
'てさげ',
'てすり',
'てそう',
'てちがい',
'てちょう',
'てつがく',
'てつづき',
'でっぱ',
'てつぼう',
'てつや',
'でぬかえ',
'てぬき',
'てぬぐい',
'てのひら',
'てはい',
'てぶくろ',
'てふだ',
'てほどき',
'てほん',
'てまえ',
'てまきずし',
'てみじか',
'てみやげ',
'てらす',
'てれび',
'てわけ',
'てわたし',
'でんあつ',
'てんいん',
'てんかい',
'てんき',
'てんぐ',
'てんけん',
'てんごく',
'てんさい',
'てんし',
'てんすう',
'でんち',
'てんてき',
'てんとう',
'てんない',
'てんぷら',
'てんぼうだい',
'てんめつ',
'てんらんかい',
'でんりょく',
'でんわ',
'どあい',
'といれ',
'どうかん',
'とうきゅう',
'どうぐ',
'とうし',
'とうむぎ',
'とおい',
'とおか',
'とおく',
'とおす',
'とおる',
'とかい',
'とかす',
'ときおり',
'ときどき',
'とくい',
'とくしゅう',
'とくてん',
'とくに',
'とくべつ',
'とけい',
'とける',
'とこや',
'とさか',
'としょかん',
'とそう',
'とたん',
'とちゅう',
'とっきゅう',
'とっくん',
'とつぜん',
'とつにゅう',
'とどける',
'ととのえる',
'とない',
'となえる',
'となり',
'とのさま',
'とばす',
'どぶがわ',
'とほう',
'とまる',
'とめる',
'ともだち',
'ともる',
'どようび',
'とらえる',
'とんかつ',
'どんぶり',
'ないかく',
'ないこう',
'ないしょ',
'ないす',
'ないせん',
'ないそう',
'なおす',
'ながい',
'なくす',
'なげる',
'なこうど',
'なさけ',
'なたでここ',
'なっとう',
'なつやすみ',
'ななおし',
'なにごと',
'なにもの',
'なにわ',
'なのか',
'なふだ',
'なまいき',
'なまえ',
'なまみ',
'なみだ',
'なめらか',
'なめる',
'なやむ',
'ならう',
'ならび',
'ならぶ',
'なれる',
'なわとび',
'なわばり',
'にあう',
'にいがた',
'にうけ',
'におい',
'にかい',
'にがて',
'にきび',
'にくしみ',
'にくまん',
'にげる',
'にさんかたんそ',
'にしき',
'にせもの',
'にちじょう',
'にちようび',
'にっか',
'にっき',
'にっけい',
'にっこう',
'にっさん',
'にっしょく',
'にっすう',
'にっせき',
'にってい',
'になう',
'にほん',
'にまめ',
'にもつ',
'にやり',
'にゅういん',
'にりんしゃ',
'にわとり',
'にんい',
'にんか',
'にんき',
'にんげん',
'にんしき',
'にんずう',
'にんそう',
'にんたい',
'にんち',
'にんてい',
'にんにく',
'にんぷ',
'にんまり',
'にんむ',
'にんめい',
'にんよう',
'ぬいくぎ',
'ぬかす',
'ぬぐいとる',
'ぬぐう',
'ぬくもり',
'ぬすむ',
'ぬまえび',
'ぬめり',
'ぬらす',
'ぬんちゃく',
'ねあげ',
'ねいき',
'ねいる',
'ねいろ',
'ねぐせ',
'ねくたい',
'ねくら',
'ねこぜ',
'ねこむ',
'ねさげ',
'ねすごす',
'ねそべる',
'ねだん',
'ねつい',
'ねっしん',
'ねつぞう',
'ねったいぎょ',
'ねぶそく',
'ねふだ',
'ねぼう',
'ねほりはほり',
'ねまき',
'ねまわし',
'ねみみ',
'ねむい',
'ねむたい',
'ねもと',
'ねらう',
'ねわざ',
'ねんいり',
'ねんおし',
'ねんかん',
'ねんきん',
'ねんぐ',
'ねんざ',
'ねんし',
'ねんちゃく',
'ねんど',
'ねんぴ',
'ねんぶつ',
'ねんまつ',
'ねんりょう',
'ねんれい',
'のいず',
'のおづま',
'のがす',
'のきなみ',
'のこぎり',
'のこす',
'のこる',
'のせる',
'のぞく',
'のぞむ',
'のたまう',
'のちほど',
'のっく',
'のばす',
'のはら',
'のべる',
'のぼる',
'のみもの',
'のやま',
'のらいぬ',
'のらねこ',
'のりもの',
'のりゆき',
'のれん',
'のんき',
'ばあい',
'はあく',
'ばあさん',
'ばいか',
'ばいく',
'はいけん',
'はいご',
'はいしん',
'はいすい',
'はいせん',
'はいそう',
'はいち',
'ばいばい',
'はいれつ',
'はえる',
'はおる',
'はかい',
'ばかり',
'はかる',
'はくしゅ',
'はけん',
'はこぶ',
'はさみ',
'はさん',
'はしご',
'ばしょ',
'はしる',
'はせる',
'ぱそこん',
'はそん',
'はたん',
'はちみつ',
'はつおん',
'はっかく',
'はづき',
'はっきり',
'はっくつ',
'はっけん',
'はっこう',
'はっさん',
'はっしん',
'はったつ',
'はっちゅう',
'はってん',
'はっぴょう',
'はっぽう',
'はなす',
'はなび',
'はにかむ',
'はぶらし',
'はみがき',
'はむかう',
'はめつ',
'はやい',
'はやし',
'はらう',
'はろうぃん',
'はわい',
'はんい',
'はんえい',
'はんおん',
'はんかく',
'はんきょう',
'ばんぐみ',
'はんこ',
'はんしゃ',
'はんすう',
'はんだん',
'ぱんち',
'ぱんつ',
'はんてい',
'はんとし',
'はんのう',
'はんぱ',
'はんぶん',
'はんぺん',
'はんぼうき',
'はんめい',
'はんらん',
'はんろん',
'ひいき',
'ひうん',
'ひえる',
'ひかく',
'ひかり',
'ひかる',
'ひかん',
'ひくい',
'ひけつ',
'ひこうき',
'ひこく',
'ひさい',
'ひさしぶり',
'ひさん',
'びじゅつかん',
'ひしょ'
];
// SPDX-License-Identifier: MIT
const WORDLIST$2 = [
'abaular',
'abdominal',
'abeto',
'abissinio',
'abjeto',
'ablucao',
'abnegar',
'abotoar',
'abrutalhar',
'absurdo',
'abutre',
'acautelar',
'accessorios',
'acetona',
'achocolatado',
'acirrar',
'acne',
'acovardar',
'acrostico',
'actinomicete',
'acustico',
'adaptavel',
'adeus',
'adivinho',
'adjunto',
'admoestar',
'adnominal',
'adotivo',
'adquirir',
'adriatico',
'adsorcao',
'adutora',
'advogar',
'aerossol',
'afazeres',
'afetuoso',
'afixo',
'afluir',
'afortunar',
'afrouxar',
'aftosa',
'afunilar',
'agentes',
'agito',
'aglutinar',
'aiatola',
'aimore',
'aino',
'aipo',
'airoso',
'ajeitar',
'ajoelhar',
'ajudante',
'ajuste',
'alazao',
'albumina',
'alcunha',
'alegria',
'alexandre',
'alforriar',
'alguns',
'alhures',
'alivio',
'almoxarife',
'alotropico',
'alpiste',
'alquimista',
'alsaciano',
'altura',
'aluviao',
'alvura',
'amazonico',
'ambulatorio',
'ametodico',
'amizades',
'amniotico',
'amovivel',
'amurada',
'anatomico',
'ancorar',
'anexo',
'anfora',
'aniversario',
'anjo',
'anotar',
'ansioso',
'anturio',
'anuviar',
'anverso',
'anzol',
'aonde',
'apaziguar',
'apito',
'aplicavel',
'apoteotico',
'aprimorar',
'aprumo',
'apto',
'apuros',
'aquoso',
'arauto',
'arbusto',
'arduo',
'aresta',
'arfar',
'arguto',
'aritmetico',
'arlequim',
'armisticio',
'aromatizar',
'arpoar',
'arquivo',
'arrumar',
'arsenio',
'arturiano',
'aruaque',
'arvores',
'asbesto',
'ascorbico',
'aspirina',
'asqueroso',
'assustar',
'astuto',
'atazanar',
'ativo',
'atletismo',
'atmosferico',
'atormentar',
'atroz',
'aturdir',
'audivel',
'auferir',
'augusto',
'aula',
'aumento',
'aurora',
'autuar',
'avatar',
'avexar',
'avizinhar',
'avolumar',
'avulso',
'axiomatico',
'azerbaijano',
'azimute',
'azoto',
'azulejo',
'bacteriologista',
'badulaque',
'baforada',
'baixote',
'bajular',
'balzaquiana',
'bambuzal',
'banzo',
'baoba',
'baqueta',
'barulho',
'bastonete',
'batuta',
'bauxita',
'bavaro',
'bazuca',
'bcrepuscular',
'beato',
'beduino',
'begonia',
'behaviorista',
'beisebol',
'belzebu',
'bemol',
'benzido',
'beocio',
'bequer',
'berro',
'besuntar',
'betume',
'bexiga',
'bezerro',
'biatlon',
'biboca',
'bicuspide',
'bidirecional',
'bienio',
'bifurcar',
'bigorna',
'bijuteria',
'bimotor',
'binormal',
'bioxido',
'bipolarizacao',
'biquini',
'birutice',
'bisturi',
'bituca',
'biunivoco',
'bivalve',
'bizarro',
'blasfemo',
'blenorreia',
'blindar',
'bloqueio',
'blusao',
'boazuda',
'bofete',
'bojudo',
'bolso',
'bombordo',
'bonzo',
'botina',
'boquiaberto',
'bostoniano',
'botulismo',
'bourbon',
'bovino',
'boximane',
'bravura',
'brevidade',
'britar',
'broxar',
'bruno',
'bruxuleio',
'bubonico',
'bucolico',
'buda',
'budista',
'bueiro',
'buffer',
'bugre',
'bujao',
'bumerangue',
'burundines',
'busto',
'butique',
'buzios',
'caatinga',
'cabuqui',
'cacunda',
'cafuzo',
'cajueiro',
'camurca',
'canudo',
'caquizeiro',
'carvoeiro',
'casulo',
'catuaba',
'cauterizar',
'cebolinha',
'cedula',
'ceifeiro',
'celulose',
'cerzir',
'cesto',
'cetro',
'ceus',
'cevar',
'chavena',
'cheroqui',
'chita',
'chovido',
'chuvoso',
'ciatico',
'cibernetico',
'cicuta',
'cidreira',
'cientistas',
'cifrar',
'cigarro',
'cilio',
'cimo',
'cinzento',
'cioso',
'cipriota',
'cirurgico',
'cisto',
'citrico',
'ciumento',
'civismo',
'clavicula',
'clero',
'clitoris',
'cluster',
'coaxial',
'cobrir',
'cocota',
'codorniz',
'coexistir',
'cogumelo',
'coito',
'colusao',
'compaixao',
'comutativo',
'contentamento',
'convulsivo',
'coordenativa',
'coquetel',
'correto',
'corvo',
'costureiro',
'cotovia',
'covil',
'cozinheiro',
'cretino',
'cristo',
'crivo',
'crotalo',
'cruzes',
'cubo',
'cucuia',
'cueiro',
'cuidar',
'cujo',
'cultural',
'cunilingua',
'cupula',
'curvo',
'custoso',
'cutucar',
'czarismo',
'dablio',
'dacota',
'dados',
'daguerreotipo',
'daiquiri',
'daltonismo',
'damista',
'dantesco',
'daquilo',
'darwinista',
'dasein',
'dativo',
'deao',
'debutantes',
'decurso',
'deduzir',
'defunto',
'degustar',
'dejeto',
'deltoide',
'demover',
'denunciar',
'deputado',
'deque',
'dervixe',
'desvirtuar',
'deturpar',
'deuteronomio',
'devoto',
'dextrose',
'dezoito',
'diatribe',
'dicotomico',
'didatico',
'dietista',
'difuso',
'digressao',
'diluvio',
'diminuto',
'dinheiro',
'dinossauro',
'dioxido',
'diplomatico',
'dique',
'dirimivel',
'disturbio',
'diurno',
'divulgar',
'dizivel',
'doar',
'dobro',
'docura',
'dodoi',
'doer',
'dogue',
'doloso',
'domo',
'donzela',
'doping',
'dorsal',
'dossie',
'dote',
'doutro',
'doze',
'dravidico',
'dreno',
'driver',
'dropes',
'druso',
'dubnio',
'ducto',
'dueto',
'dulija',
'dundum',
'duodeno',
'duquesa',
'durou',
'duvidoso',
'duzia',
'ebano',
'ebrio',
'eburneo',
'echarpe',
'eclusa',
'ecossistema',
'ectoplasma',
'ecumenismo',
'eczema',
'eden',
'editorial',
'edredom',
'edulcorar',
'efetuar',
'efigie',
'efluvio',
'egiptologo',
'egresso',
'egua',
'einsteiniano',
'eira',
'eivar',
'eixos',
'ejetar',
'elastomero',
'eldorado',
'elixir',
'elmo',
'eloquente',
'elucidativo',
'emaranhar',
'embutir',
'emerito',
'emfa',
'emitir',
'emotivo',
'empuxo',
'emulsao',
'enamorar',
'encurvar',
'enduro',
'enevoar',
'enfurnar',
'enguico',
'enho',
'enigmista',
'enlutar',
'enormidade',
'enpreendimento',
'enquanto',
'enriquecer',
'enrugar',
'entusiastico',
'enunciar',
'envolvimento',
'enxuto',
'enzimatico',
'eolico',
'epiteto',
'epoxi',
'epura',
'equivoco',
'erario',
'erbio',
'ereto',
'erguido',
'erisipela',
'ermo',
'erotizar',
'erros',
'erupcao',
'ervilha',
'esburacar',
'escutar',
'esfuziante',
'esguio',
'esloveno',
'esmurrar',
'esoterismo',
'esperanca',
'espirito',
'espurio',
'essencialmente',
'esturricar',
'esvoacar',
'etario',
'eterno',
'etiquetar',
'etnologo',
'etos',
'etrusco',
'euclidiano',
'euforico',
'eugenico',
'eunuco',
'europio',
'eustaquio',
'eutanasia',
'evasivo',
'eventualidade',
'evitavel',
'evoluir',
'exaustor',
'excursionista',
'exercito',
'exfoliado',
'exito',
'exotico',
'expurgo',
'exsudar',
'extrusora',
'exumar',
'fabuloso',
'facultativo',
'fado',
'fagulha',
'faixas',
'fajuto',
'faltoso',
'famoso',
'fanzine',
'fapesp',
'faquir',
'fartura',
'fastio',
'faturista',
'fausto',
'favorito',
'faxineira',
'fazer',
'fealdade',
'febril',
'fecundo',
'fedorento',
'feerico',
'feixe',
'felicidade',
'felpudo',
'feltro',
'femur',
'fenotipo',
'fervura',
'festivo',
'feto',
'feudo',
'fevereiro',
'fezinha',
'fiasco',
'fibra',
'ficticio',
'fiduciario',
'fiesp',
'fifa',
'figurino',
'fijiano',
'filtro',
'finura',
'fiorde',
'fiquei',
'firula',
'fissurar',
'fitoteca',
'fivela',
'fixo',
'flavio',
'flexor',
'flibusteiro',
'flotilha',
'fluxograma',
'fobos',
'foco',
'fofura',
'foguista',
'foie',
'foliculo',
'fominha',
'fonte',
'forum',
'fosso',
'fotossintese',
'foxtrote',
'fraudulento',
'frevo',
'frivolo',
'frouxo',
'frutose',
'fuba',
'fucsia',
'fugitivo',
'fuinha',
'fujao',
'fulustreco',
'fumo',
'funileiro',
'furunculo',
'fustigar',
'futurologo',
'fuxico',
'fuzue',
'gabriel',
'gado',
'gaelico',
'gafieira',
'gaguejo',
'gaivota',
'gajo',
'galvanoplastico',
'gamo',
'ganso',
'garrucha',
'gastronomo',
'gatuno',
'gaussiano',
'gaviao',
'gaxeta',
'gazeteiro',
'gear',
'geiser',
'geminiano',
'generoso',
'genuino',
'geossinclinal',
'gerundio',
'gestual',
'getulista',
'gibi',
'gigolo',
'gilete',
'ginseng',
'giroscopio',
'glaucio',
'glacial',
'gleba',
'glifo',
'glote',
'glutonia',
'gnostico',
'goela',
'gogo',
'goitaca',
'golpista',
'gomo',
'gonzo',
'gorro',
'gostou',
'goticula',
'gourmet',
'governo',
'gozo',
'graxo',
'grevista',
'grito',
'grotesco',
'gruta',
'guaxinim',
'gude',
'gueto',
'guizo',
'guloso',
'gume',
'guru',
'gustativo',
'grelhado',
'gutural',
'habitue',
'haitiano',
'halterofilista',
'hamburguer',
'hanseniase',
'happening',
'harpista',
'hastear',
'haveres',
'hebreu',
'hectometro',
'hedonista',
'hegira',
'helena',
'helminto',
'hemorroidas',
'henrique',
'heptassilabo',
'hertziano',
'hesitar',
'heterossexual',
'heuristico',
'hexagono',
'hiato',
'hibrido',
'hidrostatico',
'hieroglifo',
'hifenizar',
'higienizar',
'hilario',
'himen',
'hino',
'hippie',
'hirsuto',
'historiografia',
'hitlerista',
'hodometro',
'hoje',
'holograma',
'homus',
'honroso',
'hoquei',
'horto',
'hostilizar',
'hotentote',
'huguenote',
'humilde',
'huno',
'hurra',
'hutu',
'iaia',
'ialorixa',
'iambico',
'iansa',
'iaque',
'iara',
'iatista',
'iberico',
'ibis',
'icar',
'iceberg',
'icosagono',
'idade',
'ideologo',
'idiotice',
'idoso',
'iemenita',
'iene',
'igarape',
'iglu',
'ignorar',
'igreja',
'iguaria',
'iidiche',
'ilativo',
'iletrado',
'ilharga',
'ilimitado',
'ilogismo',
'ilustrissimo',
'imaturo',
'imbuzeiro',
'imerso',
'imitavel',
'imovel',
'imputar',
'imutavel',
'inaveriguavel',
'incutir',
'induzir',
'inextricavel',
'infusao',
'ingua',
'inhame',
'iniquo',
'injusto',
'inning',
'inoxidavel',
'inquisitorial',
'insustentavel',
'intumescimento',
'inutilizavel',
'invulneravel',
'inzoneiro',
'iodo',
'iogurte',
'ioio',
'ionosfera',
'ioruba',
'iota',
'ipsilon',
'irascivel',
'iris',
'irlandes',
'irmaos',
'iroques',
'irrupcao',
'isca',
'isento',
'islandes',
'isotopo',
'isqueiro',
'israelita',
'isso',
'isto',
'iterbio',
'itinerario',
'itrio',
'iuane',
'iugoslavo',
'jabuticabeira',
'jacutinga',
'jade',
'jagunco',
'jainista',
'jaleco',
'jambo',
'jantarada',
'japones',
'jaqueta',
'jarro',
'jasmim',
'jato',
'jaula',
'javel',
'jazz',
'jegue',
'jeitoso',
'jejum',
'jenipapo',
'jeova',
'jequitiba',
'jersei',
'jesus',
'jetom',
'jiboia',
'jihad',
'jilo',
'jingle',
'jipe',
'jocoso',
'joelho',
'joguete',
'joio',
'jojoba',
'jorro',
'jota',
'joule',
'joviano',
'jubiloso',
'judoca',
'jugular',
'juizo',
'jujuba',
'juliano',
'jumento',
'junto',
'jururu',
'justo',
'juta',
'juventude',
'labutar',
'laguna',
'laico',
'lajota',
'lanterninha',
'lapso',
'laquear',
'lastro',
'lauto',
'lavrar',
'laxativo',
'lazer',
'leasing',
'lebre',
'lecionar',
'ledo',
'leguminoso',
'leitura',
'lele',
'lemure',
'lento',
'leonardo',
'leopardo',
'lepton',
'leque',
'leste',
'letreiro',
'leucocito',
'levitico',
'lexicologo',
'lhama',
'lhufas',
'liame',
'licoroso',
'lidocaina',
'liliputiano',
'limusine',
'linotipo',
'lipoproteina',
'liquidos',
'lirismo',
'lisura',
'liturgico',
'livros',
'lixo',
'lobulo',
'locutor',
'lodo',
'logro',
'lojista',
'lombriga',
'lontra',
'loop',
'loquaz',
'lorota',
'losango',
'lotus',
'louvor',
'luar',
'lubrificavel',
'lucros',
'lugubre',
'luis',
'luminoso',
'luneta',
'lustroso',
'luto',
'luvas',
'luxuriante',
'luzeiro',
'maduro',
'maestro',
'mafioso',
'magro',
'maiuscula',
'majoritario',
'malvisto',
'mamute',
'manutencao',
'mapoteca',
'maquinista',
'marzipa',
'masturbar',
'matuto',
'mausoleu',
'mavioso',
'maxixe',
'mazurca',
'meandro',
'mecha',
'medusa',
'mefistofelico',
'megera',
'meirinho',
'melro',
'memorizar',
'menu',
'mequetrefe',
'mertiolate',
'mestria',
'metroviario',
'mexilhao',
'mezanino',
'miau',
'microssegundo',
'midia',
'migratorio',
'mimosa',
'minuto',
'miosotis',
'mirtilo',
'misturar',
'mitzvah',
'miudos',
'mixuruca',
'mnemonico',
'moagem',
'mobilizar',
'modulo',
'moer',
'mofo',
'mogno',
'moita',
'molusco',
'monumento',
'moqueca',
'morubixaba',
'mostruario',
'motriz',
'mouse',
'movivel',
'mozarela',
'muarra',
'muculmano',
'mudo',
'mugir',
'muitos',
'mumunha',
'munir',
'muon',
'muquira',
'murros',
'musselina',
'nacoes',
'nado',
'naftalina',
'nago',
'naipe',
'naja',
'nalgum',
'namoro',
'nanquim',
'napolitano',
'naquilo',
'nascimento',
'nautilo',
'navios',
'nazista',
'nebuloso',
'nectarina',
'nefrologo',
'negus',
'nelore',
'nenufar',
'nepotismo',
'nervura',
'neste',
'netuno',
'neutron',
'nevoeiro',
'newtoniano',
'nexo',
'nhenhenhem',
'nhoque',
'nigeriano',
'niilista',
'ninho',
'niobio',
'niponico',
'niquelar',
'nirvana',
'nisto',
'nitroglicerina',
'nivoso',
'nobreza',
'nocivo',
'noel',
'nogueira',
'noivo',
'nojo',
'nominativo',
'nonuplo',
'noruegues',
'nostalgico',
'noturno',
'nouveau',
'nuanca',
'nublar',
'nucleotideo',
'nudista',
'nulo',
'numismatico',
'nunquinha',
'nupcias',
'nutritivo',
'nuvens',
'oasis',
'obcecar',
'obeso',
'obituario',
'objetos',
'oblongo',
'obnoxio',
'obrigatorio',
'obstruir',
'obtuso',
'obus',
'obvio',
'ocaso',
'occipital',
'oceanografo',
'ocioso',
'oclusivo',
'ocorrer',
'ocre',
'octogono',
'odalisca',
'odisseia',
'odorifico',
'oersted',
'oeste',
'ofertar',
'ofidio',
'oftalmologo',
'ogiva',
'ogum',
'oigale',
'oitavo',
'oitocentos',
'ojeriza',
'olaria',
'oleoso',
'olfato',
'olhos',
'oliveira',
'olmo',
'olor',
'olvidavel',
'ombudsman',
'omeleteira',
'omitir',
'omoplata',
'onanismo',
'ondular',
'oneroso',
'onomatopeico',
'ontologico',
'onus',
'onze',
'opalescente',
'opcional',
'operistico',
'opio',
'oposto',
'oprobrio',
'optometrista',
'opusculo',
'oratorio',
'orbital',
'orcar',
'orfao',
'orixa',
'orla',
'ornitologo',
'orquidea',
'ortorrombico',
'orvalho',
'osculo',
'osmotico',
'ossudo',
'ostrogodo',
'otario',
'otite',
'ouro',
'ousar',
'outubro',
'ouvir',
'ovario',
'overnight',
'oviparo',
'ovni',
'ovoviviparo',
'ovulo',
'oxala',
'oxente',
'oxiuro',
'oxossi',
'ozonizar',
'paciente',
'pactuar',
'padronizar',
'paete',
'pagodeiro',
'paixao',
'pajem',
'paludismo',
'pampas',
'panturrilha',
'papudo',
'paquistanes',
'pastoso',
'patua',
'paulo',
'pauzinhos',
'pavoroso',
'paxa',
'pazes',
'peao',
'pecuniario',
'pedunculo',
'pegaso',
'peixinho',
'pejorativo',
'pelvis',
'penuria',
'pequno',
'petunia',
'pezada',
'piauiense',
'pictorico',
'pierro',
'pigmeu',
'pijama',
'pilulas',
'pimpolho',
'pintura',
'piorar',
'pipocar',
'piqueteiro',
'pirulito',
'pistoleiro',
'pituitaria',
'pivotar',
'pixote',
'pizzaria',
'plistoceno',
'plotar',
'pluviometrico',
'pneumonico',
'poco',
'podridao',
'poetisa',
'pogrom',
'pois',
'polvorosa',
'pomposo',
'ponderado',
'pontudo',
'populoso',
'poquer',
'porvir',
'posudo',
'potro',
'pouso',
'povoar',
'prazo',
'prezar',
'privilegios',
'proximo',
'prussiano',
'pseudopode',
'psoriase',
'pterossauros',
'ptialina',
'ptolemaico',
'pudor',
'pueril',
'pufe',
'pugilista',
'puir',
'pujante',
'pulverizar',
'pumba',
'punk',
'purulento',
'pustula',
'putsch',
'puxe',
'quatrocentos',
'quetzal',
'quixotesco',
'quotizavel',
'rabujice',
'racista',
'radonio',
'rafia',
'ragu',
'rajado',
'ralo',
'rampeiro',
'ranzinza',
'raptor',
'raquitismo',
'raro',
'rasurar',
'ratoeira',
'ravioli',
'razoavel',
'reavivar',
'rebuscar',
'recusavel',
'reduzivel',
'reexposicao',
'refutavel',
'regurgitar',
'reivindicavel',
'rejuvenescimento',
'relva',
'remuneravel',
'renunciar',
'reorientar',
'repuxo',
'requisito',
'resumo',
'returno',
'reutilizar',
'revolvido',
'rezonear',
'riacho',
'ribossomo',
'ricota',
'ridiculo',
'rifle',
'rigoroso',
'rijo',
'rimel',
'rins',
'rios',
'riqueza',
'respeito',
'rissole',
'ritualistico',
'rivalizar',
'rixa',
'robusto',
'rococo',
'rodoviario',
'roer',
'rogo',
'rojao',
'rolo',
'rompimento',
'ronronar',
'roqueiro',
'rorqual',
'rosto',
'rotundo',
'rouxinol',
'roxo',
'royal',
'ruas',
'rucula',
'rudimentos',
'ruela',
'rufo',
'rugoso',
'ruivo',
'rule',
'rumoroso',
'runico',
'ruptura',
'rural',
'rustico',
'rutilar',
'saariano',
'sabujo',
'sacudir',
'sadomasoquista',
'safra',
'sagui',
'sais',
'samurai',
'santuario',
'sapo',
'saquear',
'sartriano',
'saturno',
'saude',
'sauva',
'saveiro',
'saxofonista',
'sazonal',
'scherzo',
'script',
'seara',
'seborreia',
'secura',
'seduzir',
'sefardim',
'seguro',
'seja',
'selvas',
'sempre',
'senzala',
'sepultura',
'sequoia',
'sestercio',
'setuplo',
'seus',
'seviciar',
'sezonismo',
'shalom',
'siames',
'sibilante',
'sicrano',
'sidra',
'sifilitico',
'signos',
'silvo',
'simultaneo',
'sinusite',
'sionista',
'sirio',
'sisudo',
'situar',
'sivan',
'slide',
'slogan',
'soar',
'sobrio',
'socratico',
'sodomizar',
'soerguer',
'software',
'sogro',
'soja',
'solver',
'somente',
'sonso',
'sopro',
'soquete',
'sorveteiro',
'sossego',
'soturno',
'sousafone',
'sovinice',
'sozinho',
'suavizar',
'subverter',
'sucursal',
'sudoriparo',
'sufragio',
'sugestoes',
'suite',
'sujo',
'sultao',
'sumula',
'suntuoso',
'suor',
'supurar',
'suruba',
'susto',
'suturar',
'suvenir',
'tabuleta',
'taco',
'tadjique',
'tafeta',
'tagarelice',
'taitiano',
'talvez',
'tampouco',
'tanzaniano',
'taoista',
'tapume',
'taquion',
'tarugo',
'tascar',
'tatuar',
'tautologico',
'tavola',
'taxionomista',
'tchecoslovaco',
'teatrologo',
'tectonismo',
'tedioso',
'teflon',
'tegumento',
'teixo',
'telurio',
'temporas',
'tenue',
'teosofico',
'tepido',
'tequila',
'terrorista',
'testosterona',
'tetrico',
'teutonico',
'teve',
'texugo',
'tiara',
'tibia',
'tiete',
'tifoide',
'tigresa',
'tijolo',
'tilintar',
'timpano',
'tintureiro',
'tiquete',
'tiroteio',
'tisico',
'titulos',
'tive',
'toar',
'toboga',
'tofu',
'togoles',
'toicinho',
'tolueno',
'tomografo',
'tontura',
'toponimo',
'toquio',
'torvelinho',
'tostar',
'toto',
'touro',
'toxina',
'trazer',
'trezentos',
'trivialidade',
'trovoar',
'truta',
'tuaregue',
'tubular',
'tucano',
'tudo',
'tufo',
'tuiste',
'tulipa',
'tumultuoso',
'tunisino',
'tupiniquim',
'turvo',
'tutu',
'ucraniano',
'udenista',
'ufanista',
'ufologo',
'ugaritico',
'uiste',
'uivo',
'ulceroso',
'ulema',
'ultravioleta',
'umbilical',
'umero',
'umido',
'umlaut',
'unanimidade',
'unesco',
'ungulado',
'unheiro',
'univoco',
'untuoso',
'urano',
'urbano',
'urdir',
'uretra',
'urgente',
'urinol',
'urna',
'urologo',
'urro',
'ursulina',
'urtiga',
'urupe',
'usavel',
'usbeque',
'usei',
'usineiro',
'usurpar',
'utero',
'utilizar',
'utopico',
'uvular',
'uxoricidio',
'vacuo',
'vadio',
'vaguear',
'vaivem',
'valvula',
'vampiro',
'vantajoso',
'vaporoso',
'vaquinha',
'varziano',
'vasto',
'vaticinio',
'vaudeville',
'vazio',
'veado',
'vedico',
'veemente',
'vegetativo',
'veio',
'veja',
'veludo',
'venusiano',
'verdade',
'verve',
'vestuario',
'vetusto',
'vexatorio',
'vezes',
'viavel',
'vibratorio',
'victor',
'vicunha',
'vidros',
'vietnamita',
'vigoroso',
'vilipendiar',
'vime',
'vintem',
'violoncelo',
'viquingue',
'virus',
'visualizar',
'vituperio',
'viuvo',
'vivo',
'vizir',
'voar',
'vociferar',
'vodu',
'vogar',
'voile',
'volver',
'vomito',
'vontade',
'vortice',
'vosso',
'voto',
'vovozinha',
'voyeuse',
'vozes',
'vulva',
'vupt',
'western',
'xadrez',
'xale',
'xampu',
'xango',
'xarope',
'xaual',
'xavante',
'xaxim',
'xenonio',
'xepa',
'xerox',
'xicara',
'xifopago',
'xiita',
'xilogravura',
'xinxim',
'xistoso',
'xixi',
'xodo',
'xogum',
'xucro',
'zabumba',
'zagueiro',
'zambiano',
'zanzar',
'zarpar',
'zebu',
'zefiro',
'zeloso',
'zenite',
'zumbi'
];
// SPDX-License-Identifier: MIT
const WORDLIST$1 = [
'абажур',
'абзац',
'абонент',
'абрикос',
'абсурд',
'авангард',
'август',
'авиация',
'авоська',
'автор',
'агат',
'агент',
'агитатор',
'агнец',
'агония',
'агрегат',
'адвокат',
'адмирал',
'адрес',
'ажиотаж',
'азарт',
'азбука',
'азот',
'аист',
'айсберг',
'академия',
'аквариум',
'аккорд',
'акробат',
'аксиома',
'актер',
'акула',
'акция',
'алгоритм',
'алебарда',
'аллея',
'алмаз',
'алтарь',
'алфавит',
'алхимик',
'алый',
'альбом',
'алюминий',
'амбар',
'аметист',
'амнезия',
'ампула',
'амфора',
'анализ',
'ангел',
'анекдот',
'анимация',
'анкета',
'аномалия',
'ансамбль',
'антенна',
'апатия',
'апельсин',
'апофеоз',
'аппарат',
'апрель',
'аптека',
'арабский',
'арбуз',
'аргумент',
'арест',
'ария',
'арка',
'армия',
'аромат',
'арсенал',
'артист',
'архив',
'аршин',
'асбест',
'аскетизм',
'аспект',
'ассорти',
'астроном',
'асфальт',
'атака',
'ателье',
'атлас',
'атом',
'атрибут',
'аудитор',
'аукцион',
'аура',
'афера',
'афиша',
'ахинея',
'ацетон',
'аэропорт',
'бабушка',
'багаж',
'бадья',
'база',
'баклажан',
'балкон',
'бампер',
'банк',
'барон',
'бассейн',
'батарея',
'бахрома',
'башня',
'баян',
'бегство',
'бедро',
'бездна',
'бекон',
'белый',
'бензин',
'берег',
'беседа',
'бетонный',
'биатлон',
'библия',
'бивень',
'бигуди',
'бидон',
'бизнес',
'бикини',
'билет',
'бинокль',
'биология',
'биржа',
'бисер',
'битва',
'бицепс',
'благо',
'бледный',
'близкий',
'блок',
'блуждать',
'блюдо',
'бляха',
'бобер',
'богатый',
'бодрый',
'боевой',
'бокал',
'большой',
'борьба',
'босой',
'ботинок',
'боцман',
'бочка',
'боярин',
'брать',
'бревно',
'бригада',
'бросать',
'брызги',
'брюки',
'бублик',
'бугор',
'будущее',
'буква',
'бульвар',
'бумага',
'бунт',
'бурный',
'бусы',
'бутылка',
'буфет',
'бухта',
'бушлат',
'бывалый',
'быль',
'быстрый',
'быть',
'бюджет',
'бюро',
'бюст',
'вагон',
'важный',
'ваза',
'вакцина',
'валюта',
'вампир',
'ванная',
'вариант',
'вассал',
'вата',
'вафля',
'вахта',
'вдова',
'вдыхать',
'ведущий',
'веер',
'вежливый',
'везти',
'веко',
'великий',
'вена',
'верить',
'веселый',
'ветер',
'вечер',
'вешать',
'вещь',
'веяние',
'взаимный',
'взбучка',
'взвод',
'взгляд',
'вздыхать',
'взлетать',
'взмах',
'взнос',
'взор',
'взрыв',
'взывать',
'взятка',
'вибрация',
'визит',
'вилка',
'вино',
'вирус',
'висеть',
'витрина',
'вихрь',
'вишневый',
'включать',
'вкус',
'власть',
'влечь',
'влияние',
'влюблять',
'внешний',
'внимание',
'внук',
'внятный',
'вода',
'воевать',
'вождь',
'воздух',
'войти',
'вокзал',
'волос',
'вопрос',
'ворота',
'восток',
'впадать',
'впускать',
'врач',
'время',
'вручать',
'всадник',
'всеобщий',
'вспышка',
'встреча',
'вторник',
'вулкан',
'вурдалак',
'входить',
'въезд',
'выбор',
'вывод',
'выгодный',
'выделять',
'выезжать',
'выживать',
'вызывать',
'выигрыш',
'вылезать',
'выносить',
'выпивать',
'высокий',
'выходить',
'вычет',
'вышка',
'выяснять',
'вязать',
'вялый',
'гавань',
'гадать',
'газета',
'гаишник',
'галстук',
'гамма',
'гарантия',
'гастроли',
'гвардия',
'гвоздь',
'гектар',
'гель',
'генерал',
'геолог',
'герой',
'гешефт',
'гибель',
'гигант',
'гильза',
'гимн',
'гипотеза',
'гитара',
'глаз',
'глина',
'глоток',
'глубокий',
'глыба',
'глядеть',
'гнать',
'гнев',
'гнить',
'гном',
'гнуть',
'говорить',
'годовой',
'голова',
'гонка',
'город',
'гость',
'готовый',
'граница',
'грех',
'гриб',
'громкий',
'группа',
'грызть',
'грязный',
'губа',
'гудеть',
'гулять',
'гуманный',
'густой',
'гуща',
'давать',
'далекий',
'дама',
'данные',
'дарить',
'дать',
'дача',
'дверь',
'движение',
'двор',
'дебют',
'девушка',
'дедушка',
'дежурный',
'дезертир',
'действие',
'декабрь',
'дело',
'демократ',
'день',
'депутат',
'держать',
'десяток',
'детский',
'дефицит',
'дешевый',
'деятель',
'джаз',
'джинсы',
'джунгли',
'диалог',
'диван',
'диета',
'дизайн',
'дикий',
'динамика',
'диплом',
'директор',
'диск',
'дитя',
'дичь',
'длинный',
'дневник',
'добрый',
'доверие',
'договор',
'дождь',
'доза',
'документ',
'должен',
'домашний',
'допрос',
'дорога',
'доход',
'доцент',
'дочь',
'дощатый',
'драка',
'древний',
'дрожать',
'друг',
'дрянь',
'дубовый',
'дуга',
'дудка',
'дукат',
'дуло',
'думать',
'дупло',
'дурак',
'дуть',
'духи',
'душа',
'дуэт',
'дымить',
'дыня',
'дыра',
'дыханье',
'дышать',
'дьявол',
'дюжина',
'дюйм',
'дюна',
'дядя',
'дятел',
'егерь',
'единый',
'едкий',
'ежевика',
'ежик',
'езда',
'елка',
'емкость',
'ерунда',
'ехать',
'жадный',
'жажда',
'жалеть',
'жанр',
'жара',
'жать',
'жгучий',
'ждать',
'жевать',
'желание',
'жемчуг',
'женщина',
'жертва',
'жесткий',
'жечь',
'живой',
'жидкость',
'жизнь',
'жилье',
'жирный',
'житель',
'журнал',
'жюри',
'забывать',
'завод',
'загадка',
'задача',
'зажечь',
'зайти',
'закон',
'замечать',
'занимать',
'западный',
'зарплата',
'засыпать',
'затрата',
'захват',
'зацепка',
'зачет',
'защита',
'заявка',
'звать',
'звезда',
'звонить',
'звук',
'здание',
'здешний',
'здоровье',
'зебра',
'зевать',
'зеленый',
'земля',
'зенит',
'зеркало',
'зефир',
'зигзаг',
'зима',
'зиять',
'злак',
'злой',
'змея',
'знать',
'зной',
'зодчий',
'золотой',
'зомби',
'зона',
'зоопарк',
'зоркий',
'зрачок',
'зрение',
'зритель',
'зубной',
'зыбкий',
'зять',
'игла',
'иголка',
'играть',
'идея',
'идиот',
'идол',
'идти',
'иерархия',
'избрать',
'известие',
'изгонять',
'издание',
'излагать',
'изменять',
'износ',
'изоляция',
'изрядный',
'изучать',
'изымать',
'изящный',
'икона',
'икра',
'иллюзия',
'имбирь',
'иметь',
'имидж',
'иммунный',
'империя',
'инвестор',
'индивид',
'инерция',
'инженер',
'иномарка',
'институт',
'интерес',
'инфекция',
'инцидент',
'ипподром',
'ирис',
'ирония',
'искать',
'история',
'исходить',
'исчезать',
'итог',
'июль',
'июнь',
'кабинет',
'кавалер',
'кадр',
'казарма',
'кайф',
'кактус',
'калитка',
'камень',
'канал',
'капитан',
'картина',
'касса',
'катер',
'кафе',
'качество',
'каша',
'каюта',
'квартира',
'квинтет',
'квота',
'кедр',
'кекс',
'кенгуру',
'кепка',
'керосин',
'кетчуп',
'кефир',
'кибитка',
'кивнуть',
'кидать',
'километр',
'кино',
'киоск',
'кипеть',
'кирпич',
'кисть',
'китаец',
'класс',
'клетка',
'клиент',
'клоун',
'клуб',
'клык',
'ключ',
'клятва',
'книга',
'кнопка',
'кнут',
'князь',
'кобура',
'ковер',
'коготь',
'кодекс',
'кожа',
'козел',
'койка',
'коктейль',
'колено',
'компания',
'конец',
'копейка',
'короткий',
'костюм',
'котел',
'кофе',
'кошка',
'красный',
'кресло',
'кричать',
'кровь',
'крупный',
'крыша',
'крючок',
'кубок',
'кувшин',
'кудрявый',
'кузов',
'кукла',
'культура',
'кумир',
'купить',
'курс',
'кусок',
'кухня',
'куча',
'кушать',
'кювет',
'лабиринт',
'лавка',
'лагерь',
'ладонь',
'лазерный',
'лайнер',
'лакей',
'лампа',
'ландшафт',
'лапа',
'ларек',
'ласковый',
'лауреат',
'лачуга',
'лаять',
'лгать',
'лебедь',
'левый',
'легкий',
'ледяной',
'лежать',
'лекция',
'лента',
'лепесток',
'лесной',
'лето',
'лечь',
'леший',
'лживый',
'либерал',
'ливень',
'лига',
'лидер',
'ликовать',
'лиловый',
'лимон',
'линия',
'липа',
'лирика',
'лист',
'литр',
'лифт',
'лихой',
'лицо',
'личный',
'лишний',
'лобовой',
'ловить',
'логика',
'лодка',
'ложка',
'лозунг',
'локоть',
'ломать',
'лоно',
'лопата',
'лорд',
'лось',
'лоток',
'лохматый',
'лошадь',
'лужа',
'лукавый',
'луна',
'лупить',
'лучший',
'лыжный',
'лысый',
'львиный',
'льгота',
'льдина',
'любить',
'людской',
'люстра',
'лютый',
'лягушка',
'магазин',
'мадам',
'мазать',
'майор',
'максимум',
'мальчик',
'манера',
'март',
'масса',
'мать',
'мафия',
'махать',
'мачта',
'машина',
'маэстро',
'маяк',
'мгла',
'мебель',
'медведь',
'мелкий',
'мемуары',
'менять',
'мера',
'место',
'метод',
'механизм',
'мечтать',
'мешать',
'миграция',
'мизинец',
'микрофон',
'миллион',
'минута',
'мировой',
'миссия',
'митинг',
'мишень',
'младший',
'мнение',
'мнимый',
'могила',
'модель',
'мозг',
'мойка',
'мокрый',
'молодой',
'момент',
'монах',
'море',
'мост',
'мотор',
'мохнатый',
'мочь',
'мошенник',
'мощный',
'мрачный',
'мстить',
'мудрый',
'мужчина',
'музыка',
'мука',
'мумия',
'мундир',
'муравей',
'мусор',
'мутный',
'муфта',
'муха',
'мучить',
'мушкетер',
'мыло',
'мысль',
'мыть',
'мычать',
'мышь',
'мэтр',
'мюзикл',
'мягкий',
'мякиш',
'мясо',
'мятый',
'мячик',
'набор',
'навык',
'нагрузка',
'надежда',
'наемный',
'нажать',
'называть',
'наивный',
'накрыть',
'налог',
'намерен',
'наносить',
'написать',
'народ',
'натура',
'наука',
'нация',
'начать',
'небо',
'невеста',
'негодяй',
'неделя',
'нежный',
'незнание',
'нелепый',
'немалый',
'неправда',
'нервный',
'нести',
'нефть',
'нехватка',
'нечистый',
'неясный',
'нива',
'нижний',
'низкий',
'никель',
'нирвана',
'нить',
'ничья',
'ниша',
'нищий',
'новый',
'нога',
'ножницы',
'ноздря',
'ноль',
'номер',
'норма',
'нота',
'ночь',
'ноша',
'ноябрь',
'нрав',
'нужный',
'нутро',
'нынешний',
'нырнуть',
'ныть',
'нюанс',
'нюхать',
'няня',
'оазис',
'обаяние',
'обвинять',
'обгонять',
'обещать',
'обжигать',
'обзор',
'обида',
'область',
'обмен',
'обнимать',
'оборона',
'образ',
'обучение',
'обходить',
'обширный',
'общий',
'объект',
'обычный',
'обязать',
'овальный',
'овес',
'овощи',
'овраг',
'овца',
'овчарка',
'огненный',
'огонь',
'огромный',
'огурец',
'одежда',
'одинокий',
'одобрить',
'ожидать',
'ожог',
'озарение',
'озеро',
'означать',
'оказать',
'океан',
'оклад',
'окно',
'округ',
'октябрь',
'окурок',
'олень',
'опасный',
'операция',
'описать',
'оплата',
'опора',
'оппонент',
'опрос',
'оптимизм',
'опускать',
'опыт',
'орать',
'орбита',
'орган',
'орден',
'орел',
'оригинал',
'оркестр',
'орнамент',
'оружие',
'осадок',
'освещать',
'осень',
'осина',
'осколок',
'осмотр',
'основной',
'особый',
'осуждать',
'отбор',
'отвечать',
'отдать',
'отец',
'отзыв',
'открытие',
'отмечать',
'относить',
'отпуск',
'отрасль',
'отставка',
'оттенок',
'отходить',
'отчет',
'отъезд',
'офицер',
'охапка',
'охота',
'охрана',
'оценка',
'очаг',
'очередь',
'очищать',
'очки',
'ошейник',
'ошибка',
'ощущение',
'павильон',
'падать',
'паек',
'пакет',
'палец',
'память',
'панель',
'папка',
'партия',
'паспорт',
'патрон',
'пауза',
'пафос',
'пахнуть',
'пациент',
'пачка',
'пашня',
'певец',
'педагог',
'пейзаж',
'пельмень',
'пенсия',
'пепел',
'период',
'песня',
'петля',
'пехота',
'печать',
'пешеход',
'пещера',
'пианист',
'пиво',
'пиджак',
'пиковый',
'пилот',
'пионер',
'пирог',
'писать',
'пить',
'пицца',
'пишущий',
'пища',
'план',
'плечо',
'плита',
'плохой',
'плыть',
'плюс',
'пляж',
'победа',
'повод',
'погода',
'подумать',
'поехать',
'пожимать',
'позиция',
'поиск',
'покой',
'получать',
'помнить',
'пони',
'поощрять',
'попадать',
'порядок',
'пост',
'поток',
'похожий',
'поцелуй',
'почва',
'пощечина',
'поэт',
'пояснить',
'право',
'предмет',
'проблема',
'пруд',
'прыгать',
'прямой',
'психолог',
'птица',
'публика',
'пугать',
'пудра',
'пузырь',
'пуля',
'пункт',
'пурга',
'пустой',
'путь',
'пухлый',
'пучок',
'пушистый',
'пчела',
'пшеница',
'пыль',
'пытка',
'пыхтеть',
'пышный',
'пьеса',
'пьяный',
'пятно',
'работа',
'равный',
'радость',
'развитие',
'район',
'ракета',
'рамка',
'ранний',
'рапорт',
'рассказ',
'раунд',
'рация',
'рвать',
'реальный',
'ребенок',
'реветь',
'регион',
'редакция',
'реестр',
'режим',
'резкий',
'рейтинг',
'река',
'религия',
'ремонт',
'рента',
'реплика',
'ресурс',
'реформа',
'рецепт',
'речь',
'решение',
'ржавый',
'рисунок',
'ритм',
'рифма',
'робкий',
'ровный',
'рогатый',
'родитель',
'рождение',
'розовый',
'роковой',
'роль',
'роман',
'ронять',
'рост',
'рота',
'роща',
'рояль',
'рубль',
'ругать',
'руда',
'ружье',
'руины',
'рука',
'руль',
'румяный',
'русский',
'ручка',
'рыба',
'рывок',
'рыдать',
'рыжий',
'рынок',
'рысь',
'рыть',
'рыхлый',
'рыцарь',
'рычаг',
'рюкзак',
'рюмка',
'рябой',
'рядовой',
'сабля',
'садовый',
'сажать',
'салон',
'самолет',
'сани',
'сапог',
'сарай',
'сатира',
'сауна',
'сахар',
'сбегать',
'сбивать',
'сбор',
'сбыт',
'свадьба',
'свет',
'свидание',
'свобода',
'связь',
'сгорать',
'сдвигать',
'сеанс',
'северный',
'сегмент',
'седой',
'сезон',
'сейф',
'секунда',
'сельский',
'семья',
'сентябрь',
'сердце',
'сеть',
'сечение',
'сеять',
'сигнал',
'сидеть',
'сизый',
'сила',
'символ',
'синий',
'сирота',
'система',
'ситуация',
'сиять',
'сказать',
'скважина',
'скелет',
'скидка',
'склад',
'скорый',
'скрывать',
'скучный',
'слава',
'слеза',
'слияние',
'слово',
'случай',
'слышать',
'слюна',
'смех',
'смирение',
'смотреть',
'смутный',
'смысл',
'смятение',
'снаряд',
'снег',
'снижение',
'сносить',
'снять',
'событие',
'совет',
'согласие',
'сожалеть',
'сойти',
'сокол',
'солнце',
'сомнение',
'сонный',
'сообщать',
'соперник',
'сорт',
'состав',
'сотня',
'соус',
'социолог',
'сочинять',
'союз',
'спать',
'спешить',
'спина',
'сплошной',
'способ',
'спутник',
'средство',
'срок',
'срывать',
'стать',
'ствол',
'стена',
'стихи',
'сторона',
'страна',
'студент',
'стыд',
'субъект',
'сувенир',
'сугроб',
'судьба',
'суета',
'суждение',
'сукно',
'сулить',
'сумма',
'сунуть',
'супруг',
'суровый',
'сустав',
'суть',
'сухой',
'суша',
'существо',
'сфера',
'схема',
'сцена',
'счастье',
'счет',
'считать',
'сшивать',
'съезд',
'сынок',
'сыпать',
'сырье',
'сытый',
'сыщик',
'сюжет',
'сюрприз',
'таблица',
'таежный',
'таинство',
'тайна',
'такси',
'талант',
'таможня',
'танец',
'тарелка',
'таскать',
'тахта',
'тачка',
'таять',
'тварь',
'твердый',
'творить',
'театр',
'тезис',
'текст',
'тело',
'тема',
'тень',
'теория',
'теплый',
'терять',
'тесный',
'тетя',
'техника',
'течение',
'тигр',
'типичный',
'тираж',
'титул',
'тихий',
'тишина',
'ткань',
'товарищ',
'толпа',
'тонкий',
'топливо',
'торговля',
'тоска',
'точка',
'тощий',
'традиция',
'тревога',
'трибуна',
'трогать',
'труд',
'трюк',
'тряпка',
'туалет',
'тугой',
'туловище',
'туман',
'тундра',
'тупой',
'турнир',
'тусклый',
'туфля',
'туча',
'туша',
'тыкать',
'тысяча',
'тьма',
'тюльпан',
'тюрьма',
'тяга',
'тяжелый',
'тянуть',
'убеждать',
'убирать',
'убогий',
'убыток',
'уважение',
'уверять',
'увлекать',
'угнать',
'угол',
'угроза',
'удар',
'удивлять',
'удобный',
'уезд',
'ужас',
'ужин',
'узел',
'узкий',
'узнавать',
'узор',
'уйма',
'уклон',
'укол',
'уксус',
'улетать',
'улица',
'улучшать',
'улыбка',
'уметь',
'умиление',
'умный',
'умолять',
'умысел',
'унижать',
'уносить',
'уныние',
'упасть',
'уплата',
'упор',
'упрекать',
'упускать',
'уран',
'урна',
'уровень',
'усадьба',
'усердие',
'усилие',
'ускорять',
'условие',
'усмешка',
'уснуть',
'успеть',
'усыпать',
'утешать',
'утка',
'уточнять',
'утро',
'утюг',
'уходить',
'уцелеть',
'участие',
'ученый',
'учитель',
'ушко',
'ущерб',
'уютный',
'уяснять',
'фабрика',
'фаворит',
'фаза',
'файл',
'факт',
'фамилия',
'фантазия',
'фара',
'фасад',
'февраль',
'фельдшер',
'феномен',
'ферма',
'фигура',
'физика',
'фильм',
'финал',
'фирма',
'фишка',
'флаг',
'флейта',
'флот',
'фокус',
'фольклор',
'фонд',
'форма',
'фото',
'фраза',
'фреска',
'фронт',
'фрукт',
'функция',
'фуражка',
'футбол',
'фыркать',
'халат',
'хамство',
'хаос',
'характер',
'хата',
'хватать',
'хвост',
'хижина',
'хилый',
'химия',
'хирург',
'хитрый',
'хищник',
'хлам',
'хлеб',
'хлопать',
'хмурый',
'ходить',
'хозяин',
'хоккей',
'холодный',
'хороший',
'хотеть',
'хохотать',
'храм',
'хрен',
'хриплый',
'хроника',
'хрупкий',
'художник',
'хулиган',
'хутор',
'царь',
'цвет',
'цель',
'цемент',
'центр',
'цепь',
'церковь',
'цикл',
'цилиндр',
'циничный',
'цирк',
'цистерна',
'цитата',
'цифра',
'цыпленок',
'чадо',
'чайник',
'часть',
'чашка',
'человек',
'чемодан',
'чепуха',
'черный',
'честь',
'четкий',
'чехол',
'чиновник',
'число',
'читать',
'членство',
'чреватый',
'чтение',
'чувство',
'чугунный',
'чудо',
'чужой',
'чукча',
'чулок',
'чума',
'чуткий',
'чучело',
'чушь',
'шаблон',
'шагать',
'шайка',
'шакал',
'шалаш',
'шампунь',
'шанс',
'шапка',
'шарик',
'шасси',
'шатер',
'шахта',
'шашлык',
'швейный',
'швырять',
'шевелить',
'шедевр',
'шейка',
'шелковый',
'шептать',
'шерсть',
'шестерка',
'шикарный',
'шинель',
'шипеть',
'широкий',
'шить',
'шишка',
'шкаф',
'школа',
'шкура',
'шланг',
'шлем',
'шлюпка',
'шляпа',
'шнур',
'шоколад',
'шорох',
'шоссе',
'шофер',
'шпага',
'шпион',
'шприц',
'шрам',
'шрифт',
'штаб',
'штора',
'штраф',
'штука',
'штык',
'шуба',
'шуметь',
'шуршать',
'шутка',
'щадить',
'щедрый',
'щека',
'щель',
'щенок',
'щепка',
'щетка',
'щука',
'эволюция',
'эгоизм',
'экзамен',
'экипаж',
'экономия',
'экран',
'эксперт',
'элемент',
'элита',
'эмблема',
'эмигрант',
'эмоция',
'энергия',
'эпизод',
'эпоха',
'эскиз',
'эссе',
'эстрада',
'этап',
'этика',
'этюд',
'эфир',
'эффект',
'эшелон',
'юбилей',
'юбка',
'южный',
'юмор',
'юноша',
'юрист',
'яблоко',
'явление',
'ягода',
'ядерный',
'ядовитый',
'ядро',
'язва',
'язык',
'яйцо',
'якорь',
'январь',
'японец',
'яркий',
'ярмарка',
'ярость',
'ярус',
'ясный',
'яхта',
'ячейка',
'ящик'
];
// SPDX-License-Identifier: MIT
const WORDLIST = [
'ábaco',
'abdomen',
'abeja',
'abierto',
'abogado',
'abono',
'aborto',
'abrazo',
'abrir',
'abuelo',
'abuso',
'acabar',
'academia',
'acceso',
'acción',
'aceite',
'acelga',
'acento',
'aceptar',
'ácido',
'aclarar',
'acné',
'acoger',
'acoso',
'activo',
'acto',
'actriz',
'actuar',
'acudir',
'acuerdo',
'acusar',
'adicto',
'admitir',
'adoptar',
'adorno',
'aduana',
'adulto',
'aéreo',
'afectar',
'afición',
'afinar',
'afirmar',
'ágil',
'agitar',
'agonía',
'agosto',
'agotar',
'agregar',
'agrio',
'agua',
'agudo',
'águila',
'aguja',
'ahogo',
'ahorro',
'aire',
'aislar',
'ajedrez',
'ajeno',
'ajuste',
'alacrán',
'alambre',
'alarma',
'alba',
'álbum',
'alcalde',
'aldea',
'alegre',
'alejar',
'alerta',
'aleta',
'alfiler',
'alga',
'algodón',
'aliado',
'aliento',
'alivio',
'alma',
'almeja',
'almíbar',
'altar',
'alteza',
'altivo',
'alto',
'altura',
'alumno',
'alzar',
'amable',
'amante',
'amapola',
'amargo',
'amasar',
'ámbar',
'ámbito',
'ameno',
'amigo',
'amistad',
'amor',
'amparo',
'amplio',
'ancho',
'anciano',
'ancla',
'andar',
'andén',
'anemia',
'ángulo',
'anillo',
'ánimo',
'anís',
'anotar',
'antena',
'antiguo',
'antojo',
'anual',
'anular',
'anuncio',
'añadir',
'añejo',
'año',
'apagar',
'aparato',
'apetito',
'apio',
'aplicar',
'apodo',
'aporte',
'apoyo',
'aprender',
'aprobar',
'apuesta',
'apuro',
'arado',
'araña',
'arar',
'árbitro',
'árbol',
'arbusto',
'archivo',
'arco',
'arder',
'ardilla',
'arduo',
'área',
'árido',
'aries',
'armonía',
'arnés',
'aroma',
'arpa',
'arpón',
'arreglo',
'arroz',
'arruga',
'arte',
'artista',
'asa',
'asado',
'asalto',
'ascenso',
'asegurar',
'aseo',
'asesor',
'asiento',
'asilo',
'asistir',
'asno',
'asombro',
'áspero',
'astilla',
'astro',
'astuto',
'asumir',
'asunto',
'atajo',
'ataque',
'atar',
'atento',
'ateo',
'ático',
'atleta',
'átomo',
'atraer',
'atroz',
'atún',
'audaz',
'audio',
'auge',
'aula',
'aumento',
'ausente',
'autor',
'aval',
'avance',
'avaro',
'ave',
'avellana',
'avena',
'avestruz',
'avión',
'aviso',
'ayer',
'ayuda',
'ayuno',
'azafrán',
'azar',
'azote',
'azúcar',
'azufre',
'azul',
'baba',
'babor',
'bache',
'bahía',
'baile',
'bajar',
'balanza',
'balcón',
'balde',
'bambú',
'banco',
'banda',
'baño',
'barba',
'barco',
'barniz',
'barro',
'báscula',
'bastón',
'basura',
'batalla',
'batería',
'batir',
'batuta',
'baúl',
'bazar',
'bebé',
'bebida',
'bello',
'besar',
'beso',
'bestia',
'bicho',
'bien',
'bingo',
'blanco',
'bloque',
'blusa',
'boa',
'bobina',
'bobo',
'boca',
'bocina',
'boda',
'bodega',
'boina',
'bola',
'bolero',
'bolsa',
'bomba',
'bondad',
'bonito',
'bono',
'bonsái',
'borde',
'borrar',
'bosque',
'bote',
'botín',
'bóveda',
'bozal',
'bravo',
'brazo',
'brecha',
'breve',
'brillo',
'brinco',
'brisa',
'broca',
'broma',
'bronce',
'brote',
'bruja',
'brusco',
'bruto',
'buceo',
'bucle',
'bueno',
'buey',
'bufanda',
'bufón',
'búho',
'buitre',
'bulto',
'burbuja',
'burla',
'burro',
'buscar',
'butaca',
'buzón',
'caballo',
'cabeza',
'cabina',
'cabra',
'cacao',
'cadáver',
'cadena',
'caer',
'café',
'caída',
'caimán',
'caja',
'cajón',
'cal',
'calamar',
'calcio',
'caldo',
'calidad',
'calle',
'calma',
'calor',
'calvo',
'cama',
'cambio',
'camello',
'camino',
'campo',
'cáncer',
'candil',
'canela',
'canguro',
'canica',
'canto',
'caña',
'cañón',
'caoba',
'caos',
'capaz',
'capitán',
'capote',
'captar',
'capucha',
'cara',
'carbón',
'cárcel',
'careta',
'carga',
'cariño',
'carne',
'carpeta',
'carro',
'carta',
'casa',
'casco',
'casero',
'caspa',
'castor',
'catorce',
'catre',
'caudal',
'causa',
'cazo',
'cebolla',
'ceder',
'cedro',
'celda',
'célebre',
'celoso',
'célula',
'cemento',
'ceniza',
'centro',
'cerca',
'cerdo',
'cereza',
'cero',
'cerrar',
'certeza',
'césped',
'cetro',
'chacal',
'chaleco',
'champú',
'chancla',
'chapa',
'charla',
'chico',
'chiste',
'chivo',
'choque',
'choza',
'chuleta',
'chupar',
'ciclón',
'ciego',
'cielo',
'cien',
'cierto',
'cifra',
'cigarro',
'cima',
'cinco',
'cine',
'cinta',
'ciprés',
'circo',
'ciruela',
'cisne',
'cita',
'ciudad',
'clamor',
'clan',
'claro',
'clase',
'clave',
'cliente',
'clima',
'clínica',
'cobre',
'cocción',
'cochino',
'cocina',
'coco',
'código',
'codo',
'cofre',
'coger',
'cohete',
'cojín',
'cojo',
'cola',
'colcha',
'colegio',
'colgar',
'colina',
'collar',
'colmo',
'columna',
'combate',
'comer',
'comida',
'cómodo',
'compra',
'conde',
'conejo',
'conga',
'conocer',
'consejo',
'contar',
'copa',
'copia',
'corazón',
'corbata',
'corcho',
'cordón',
'corona',
'correr',
'coser',
'cosmos',
'costa',
'cráneo',
'cráter',
'crear',
'crecer',
'creído',
'crema',
'cría',
'crimen',
'cripta',
'crisis',
'cromo',
'crónica',
'croqueta',
'crudo',
'cruz',
'cuadro',
'cuarto',
'cuatro',
'cubo',
'cubrir',
'cuchara',
'cuello',
'cuento',
'cuerda',
'cuesta',
'cueva',
'cuidar',
'culebra',
'culpa',
'culto',
'cumbre',
'cumplir',
'cuna',
'cuneta',
'cuota',
'cupón',
'cúpula',
'curar',
'curioso',
'curso',
'curva',
'cutis',
'dama',
'danza',
'dar',
'dardo',
'dátil',
'deber',
'débil',
'década',
'decir',
'dedo',
'defensa',
'definir',
'dejar',
'delfín',
'delgado',
'delito',
'demora',
'denso',
'dental',
'deporte',
'derecho',
'derrota',
'desayuno',
'deseo',
'desfile',
'desnudo',
'destino',
'desvío',
'detalle',
'detener',
'deuda',
'día',
'diablo',
'diadema',
'diamante',
'diana',
'diario',
'dibujo',
'dictar',
'diente',
'dieta',
'diez',
'difícil',
'digno',
'dilema',
'diluir',
'dinero',
'directo',
'dirigir',
'disco',
'diseño',
'disfraz',
'diva',
'divino',
'doble',
'doce',
'dolor',
'domingo',
'don',
'donar',
'dorado',
'dormir',
'dorso',
'dos',
'dosis',
'dragón',
'droga',
'ducha',
'duda',
'duelo',
'dueño',
'dulce',
'dúo',
'duque',
'durar',
'dureza',
'duro',
'ébano',
'ebrio',
'echar',
'eco',
'ecuador',
'edad',
'edición',
'edificio',
'editor',
'educar',
'efecto',
'eficaz',
'eje',
'ejemplo',
'elefante',
'elegir',
'elemento',
'elevar',
'elipse',
'élite',
'elixir',
'elogio',
'eludir',
'embudo',
'emitir',
'emoción',
'empate',
'empeño',
'empleo',
'empresa',
'enano',
'encargo',
'enchufe',
'encía',
'enemigo',
'enero',
'enfado',
'enfermo',
'engaño',
'enigma',
'enlace',
'enorme',
'enredo',
'ensayo',
'enseñar',
'entero',
'entrar',
'envase',
'envío',
'época',
'equipo',
'erizo',
'escala',
'escena',
'escolar',
'escribir',
'escudo',
'esencia',
'esfera',
'esfuerzo',
'espada',
'espejo',
'espía',
'esposa',
'espuma',
'esquí',
'estar',
'este',
'estilo',
'estufa',
'etapa',
'eterno',
'ética',
'etnia',
'evadir',
'evaluar',
'evento',
'evitar',
'exacto',
'examen',
'exceso',
'excusa',
'exento',
'exigir',
'exilio',
'existir',
'éxito',
'experto',
'explicar',
'exponer',
'extremo',
'fábrica',
'fábula',
'fachada',
'fácil',
'factor',
'faena',
'faja',
'falda',
'fallo',
'falso',
'faltar',
'fama',
'familia',
'famoso',
'faraón',
'farmacia',
'farol',
'farsa',
'fase',
'fatiga',
'fauna',
'favor',
'fax',
'febrero',
'fecha',
'feliz',
'feo',
'feria',
'feroz',
'fértil',
'fervor',
'festín',
'fiable',
'fianza',
'fiar',
'fibra',
'ficción',
'ficha',
'fideo',
'fiebre',
'fiel',
'fiera',
'fiesta',
'figura',
'fijar',
'fijo',
'fila',
'filete',
'filial',
'filtro',
'fin',
'finca',
'fingir',
'finito',
'firma',
'flaco',
'flauta',
'flecha',
'flor',
'flota',
'fluir',
'flujo',
'flúor',
'fobia',
'foca',
'fogata',
'fogón',
'folio',
'folleto',
'fondo',
'forma',
'forro',
'fortuna',
'forzar',
'fosa',
'foto',
'fracaso',
'frágil',
'franja',
'frase',
'fraude',
'freír',
'freno',
'fresa',
'frío',
'frito',
'fruta',
'fuego',
'fuente',
'fuerza',
'fuga',
'fumar',
'función',
'funda',
'furgón',
'furia',
'fusil',
'fútbol',
'futuro',
'gacela',
'gafas',
'gaita',
'gajo',
'gala',
'galería',
'gallo',
'gamba',
'ganar',
'gancho',
'ganga',
'ganso',
'garaje',
'garza',
'gasolina',
'gastar',
'gato',
'gavilán',
'gemelo',
'gemir',
'gen',
'género',
'genio',
'gente',
'geranio',
'gerente',
'germen',
'gesto',
'gigante',
'gimnasio',
'girar',
'giro',
'glaciar',
'globo',
'gloria',
'gol',
'golfo',
'goloso',
'golpe',
'goma',
'gordo',
'gorila',
'gorra',
'gota',
'goteo',
'gozar',
'grada',
'gráfico',
'grano',
'grasa',
'gratis',
'grave',
'grieta',
'grillo',
'gripe',
'gris',
'grito',
'grosor',
'grúa',
'grueso',
'grumo',
'grupo',
'guante',
'guapo',
'guardia',
'guerra',
'guía',
'guiño',
'guion',
'guiso',
'guitarra',
'gusano',
'gustar',
'haber',
'hábil',
'hablar',
'hacer',
'hacha',
'hada',
'hallar',
'hamaca',
'harina',
'haz',
'hazaña',
'hebilla',
'hebra',
'hecho',
'helado',
'helio',
'hembra',
'herir',
'hermano',
'héroe',
'hervir',
'hielo',
'hierro',
'hígado',
'higiene',
'hijo',
'himno',
'historia',
'hocico',
'hogar',
'hoguera',
'hoja',
'hombre',
'hongo',
'honor',
'honra',
'hora',
'hormiga',
'horno',
'hostil',
'hoyo',
'hueco',
'huelga',
'huerta',
'hueso',
'huevo',
'huida',
'huir',
'humano',
'húmedo',
'humilde',
'humo',
'hundir',
'huracán',
'hurto',
'icono',
'ideal',
'idioma',
'ídolo',
'iglesia',
'iglú',
'igual',
'ilegal',
'ilusión',
'imagen',
'imán',
'imitar',
'impar',
'imperio',
'imponer',
'impulso',
'incapaz',
'índice',
'inerte',
'infiel',
'informe',
'ingenio',
'inicio',
'inmenso',
'inmune',
'innato',
'insecto',
'instante',
'interés',
'íntimo',
'intuir',
'inútil',
'invierno',
'ira',
'iris',
'ironía',
'isla',
'islote',
'jabalí',
'jabón',
'jamón',
'jarabe',
'jardín',
'jarra',
'jaula',
'jazmín',
'jefe',
'jeringa',
'jinete',
'jornada',
'joroba',
'joven',
'joya',
'juerga',
'jueves',
'juez',
'jugador',
'jugo',
'juguete',
'juicio',
'junco',
'jungla',
'junio',
'juntar',
'júpiter',
'jurar',
'justo',
'juvenil',
'juzgar',
'kilo',
'koala',
'labio',
'lacio',
'lacra',
'lado',
'ladrón',
'lagarto',
'lágrima',
'laguna',
'laico',
'lamer',
'lámina',
'lámpara',
'lana',
'lancha',
'langosta',
'lanza',
'lápiz',
'largo',
'larva',
'lástima',
'lata',
'látex',
'latir',
'laurel',
'lavar',
'lazo',
'leal',
'lección',
'leche',
'lector',
'leer',
'legión',
'legumbre',
'lejano',
'lengua',
'lento',
'leña',
'león',
'leopardo',
'lesión',
'letal',
'letra',
'leve',
'leyenda',
'libertad',
'libro',
'licor',
'líder',
'lidiar',
'lienzo',
'liga',
'ligero',
'lima',
'límite',
'limón',
'limpio',
'lince',
'lindo',
'línea',
'lingote',
'lino',
'linterna',
'líquido',
'liso',
'lista',
'litera',
'litio',
'litro',
'llaga',
'llama',
'llanto',
'llave',
'llegar',
'llenar',
'llevar',
'llorar',
'llover',
'lluvia',
'lobo',
'loción',
'loco',
'locura',
'lógica',
'logro',
'lombriz',
'lomo',
'lonja',
'lote',
'lucha',
'lucir',
'lugar',
'lujo',
'luna',
'lunes',
'lupa',
'lustro',
'luto',
'luz',
'maceta',
'macho',
'madera',
'madre',
'maduro',
'maestro',
'mafia',
'magia',
'mago',
'maíz',
'maldad',
'maleta',
'malla',
'malo',
'mamá',
'mambo',
'mamut',
'manco',
'mando',
'manejar',
'manga',
'maniquí',
'manjar',
'mano',
'manso',
'manta',
'mañana',
'mapa',
'máquina',
'mar',
'marco',
'marea',
'marfil',
'margen',
'marido',
'mármol',
'marrón',
'martes',
'marzo',
'masa',
'máscara',
'masivo',
'matar',
'materia',
'matiz',
'matriz',
'máximo',
'mayor',
'mazorca',
'mecha',
'medalla',
'medio',
'médula',
'mejilla',
'mejor',
'melena',
'melón',
'memoria',
'menor',
'mensaje',
'mente',
'menú',
'mercado',
'merengue',
'mérito',
'mes',
'mesón',
'meta',
'meter',
'método',
'metro',
'mezcla',
'miedo',
'miel',
'miembro',
'miga',
'mil',
'milagro',
'militar',
'millón',
'mimo',
'mina',
'minero',
'mínimo',
'minuto',
'miope',
'mirar',
'misa',
'miseria',
'misil',
'mismo',
'mitad',
'mito',
'mochila',
'moción',
'moda',
'modelo',
'moho',
'mojar',
'molde',
'moler',
'molino',
'momento',
'momia',
'monarca',
'moneda',
'monja',
'monto',
'moño',
'morada',
'morder',
'moreno',
'morir',
'morro',
'morsa',
'mortal',
'mosca',
'mostrar',
'motivo',
'mover',
'móvil',
'mozo',
'mucho',
'mudar',
'mueble',
'muela',
'muerte',
'muestra',
'mugre',
'mujer',
'mula',
'muleta',
'multa',
'mundo',
'muñeca',
'mural',
'muro',
'músculo',
'museo',
'musgo',
'música',
'muslo',
'nácar',
'nación',
'nadar',
'naipe',
'naranja',
'nariz',
'narrar',
'nasal',
'natal',
'nativo',
'natural',
'náusea',
'naval',
'nave',
'navidad',
'necio',
'néctar',
'negar',
'negocio',
'negro',
'neón',
'nervio',
'neto',
'neutro',
'nevar',
'nevera',
'nicho',
'nido',
'niebla',
'nieto',
'niñez',
'niño',
'nítido',
'nivel',
'nobleza',
'noche',
'nómina',
'noria',
'norma',
'norte',
'nota',
'noticia',
'novato',
'novela',
'novio',
'nube',
'nuca',
'núcleo',
'nudillo',
'nudo',
'nuera',
'nueve',
'nuez',
'nulo',
'número',
'nutria',
'oasis',
'obeso',
'obispo',
'objeto',
'obra',
'obrero',
'observar',
'obtener',
'obvio',
'oca',
'ocaso',
'océano',
'ochenta',
'ocho',
'ocio',
'ocre',
'octavo',
'octubre',
'oculto',
'ocupar',
'ocurrir',
'odiar',
'odio',
'odisea',
'oeste',
'ofensa',
'oferta',
'oficio',
'ofrecer',
'ogro',
'oído',
'oír',
'ojo',
'ola',
'oleada',
'olfato',
'olivo',
'olla',
'olmo',
'olor',
'olvido',
'ombligo',
'onda',
'onza',
'opaco',
'opción',
'ópera',
'opinar',
'oponer',
'optar',
'óptica',
'opuesto',
'oración',
'orador',
'oral',
'órbita',
'orca',
'orden',
'oreja',
'órgano',
'orgía',
'orgullo',
'oriente',
'origen',
'orilla',
'oro',
'orquesta',
'oruga',
'osadía',
'oscuro',
'osezno',
'oso',
'ostra',
'otoño',
'otro',
'oveja',
'óvulo',
'óxido',
'oxígeno',
'oyente',
'ozono',
'pacto',
'padre',
'paella',
'página',
'pago',
'país',
'pájaro',
'palabra',
'palco',
'paleta',
'pálido',
'palma',
'paloma',
'palpar',
'pan',
'panal',
'pánico',
'pantera',
'pañuelo',
'papá',
'papel',
'papilla',
'paquete',
'parar',
'parcela',
'pared',
'parir',
'paro',
'párpado',
'parque',
'párrafo',
'parte',
'pasar',
'paseo',
'pasión',
'paso',
'pasta',
'pata',
'patio',
'patria',
'pausa',
'pauta',
'pavo',
'payaso',
'peatón',
'pecado',
'pecera',
'pecho',
'pedal',
'pedir',
'pegar',
'peine',
'pelar',
'peldaño',
'pelea',
'peligro',
'pellejo',
'pelo',
'peluca',
'pena',
'pensar',
'peñón',
'peón',
'peor',
'pepino',
'pequeño',
'pera',
'percha',
'perder',
'pereza',
'perfil',
'perico',
'perla',
'permiso',
'perro',
'persona',
'pesa',
'pesca',
'pésimo',
'pestaña',
'pétalo',
'petróleo',
'pez',
'pezuña',
'picar',
'pichón',
'pie',
'piedra',
'pierna',
'pieza',
'pijama',
'pilar',
'piloto',
'pimienta',
'pino',
'pintor',
'pinza',
'piña',
'piojo',
'pipa',
'pirata',
'pisar',
'piscina',
'piso',
'pista',
'pitón',
'pizca',
'placa',
'plan',
'plata',
'playa',
'plaza',
'pleito',
'pleno',
'plomo',
'pluma',
'plural',
'pobre',
'poco',
'poder',
'podio',
'poema',
'poesía',
'poeta',
'polen',
'policía',
'pollo',
'polvo',
'pomada',
'pomelo',
'pomo',
'pompa',
'poner',
'porción',
'portal',
'posada',
'poseer',
'posible',
'poste',
'potencia',
'potro',
'pozo',
'prado',
'precoz',
'pregunta',
'premio',
'prensa',
'preso',
'previo',
'primo',
'príncipe',
'prisión',
'privar',
'proa',
'probar',
'proceso',
'producto',
'proeza',
'profesor',
'programa',
'prole',
'promesa',
'pronto',
'propio',
'próximo',
'prueba',
'público',
'puchero',
'pudor',
'pueblo',
'puerta',
'puesto',
'pulga',
'pulir',
'pulmón',
'pulpo',
'pulso',
'puma',
'punto',
'puñal',
'puño',
'pupa',
'pupila',
'puré',
'quedar',
'queja',
'quemar',
'querer',
'queso',
'quieto',
'química',
'quince',
'quitar',
'rábano',
'rabia',
'rabo',
'ración',
'radical',
'raíz',
'rama',
'rampa',
'rancho',
'rango',
'rapaz',
'rápido',
'rapto',
'rasgo',
'raspa',
'rato',
'rayo',
'raza',
'razón',
'reacción',
'realidad',
'rebaño',
'rebote',
'recaer',
'receta',
'rechazo',
'recoger',
'recreo',
'recto',
'recurso',
'red',
'redondo',
'reducir',
'reflejo',
'reforma',
'refrán',
'refugio',
'regalo',
'regir',
'regla',
'regreso',
'rehén',
'reino',
'reír',
'reja',
'relato',
'relevo',
'relieve',
'relleno',
'reloj',
'remar',
'remedio',
'remo',
'rencor',
'rendir',
'renta',
'reparto',
'repetir',
'reposo',
'reptil',
'res',
'rescate',
'resina',
'respeto',
'resto',
'resumen',
'retiro',
'retorno',
'retrato',
'reunir',
'revés',
'revista',
'rey',
'rezar',
'rico',
'riego',
'rienda',
'riesgo',
'rifa',
'rígido',
'rigor',
'rincón',
'riñón',
'río',
'riqueza',
'risa',
'ritmo',
'rito'
];
// SPDX-License-Identifier: MIT
const MONERO_MNEMONIC_WORDS = {
TWELVE: 12,
THIRTEEN: 13,
TWENTY_FOUR: 24,
TWENTY_FIVE: 25,
};
const MONERO_MNEMONIC_LANGUAGES = {
CHINESE_SIMPLIFIED: 'chinese-simplified',
DUTCH: 'dutch',
ENGLISH: 'english',
FRENCH: 'french',
GERMAN: 'german',
ITALIAN: 'italian',
JAPANESE: 'japanese',
PORTUGUESE: 'portuguese',
RUSSIAN: 'russian',
SPANISH: 'spanish',
};
class MoneroMnemonic extends Mnemonic {
static wordBitLength = 11;
static wordsList = [
MONERO_MNEMONIC_WORDS.TWELVE,
MONERO_MNEMONIC_WORDS.THIRTEEN,
MONERO_MNEMONIC_WORDS.TWENTY_FOUR,
MONERO_MNEMONIC_WORDS.TWENTY_FIVE
];
static wordsToStrength = {
12: MONERO_ENTROPY_STRENGTHS.ONE_HUNDRED_TWENTY_EIGHT,
13: MONERO_ENTROPY_STRENGTHS.ONE_HUNDRED_TWENTY_EIGHT,
24: MONERO_ENTROPY_STRENGTHS.TWO_HUNDRED_FIFTY_SIX,
25: MONERO_ENTROPY_STRENGTHS.TWO_HUNDRED_FIFTY_SIX
};
static checksumWordCounts = [
MONERO_MNEMONIC_WORDS.THIRTEEN,
MONERO_MNEMONIC_WORDS.TWENTY_FIVE
];
static languages = Object.values(MONERO_MNEMONIC_LANGUAGES);
static languageUniquePrefixLengths = {
[MONERO_MNEMONIC_LANGUAGES.CHINESE_SIMPLIFIED]: 1,
[MONERO_MNEMONIC_LANGUAGES.DUTCH]: 4,
[MONERO_MNEMONIC_LANGUAGES.ENGLISH]: 3,
[MONERO_MNEMONIC_LANGUAGES.FRENCH]: 4,
[MONERO_MNEMONIC_LANGUAGES.GERMAN]: 4,
[MONERO_MNEMONIC_LANGUAGES.ITALIAN]: 4,
[MONERO_MNEMONIC_LANGUAGES.JAPANESE]: 4,
[MONERO_MNEMONIC_LANGUAGES.PORTUGUESE]: 4,
[MONERO_MNEMONIC_LANGUAGES.RUSSIAN]: 4,
[MONERO_MNEMONIC_LANGUAGES.SPANISH]: 4,
};
static wordLists = {
[MONERO_MNEMONIC_LANGUAGES.CHINESE_SIMPLIFIED]: WORDLIST$9,
[MONERO_MNEMONIC_LANGUAGES.DUTCH]: WORDLIST$8,
[MONERO_MNEMONIC_LANGUAGES.ENGLISH]: WORDLIST$7,
[MONERO_MNEMONIC_LANGUAGES.FRENCH]: WORDLIST$6,
[MONERO_MNEMONIC_LANGUAGES.GERMAN]: WORDLIST$5,
[MONERO_MNEMONIC_LANGUAGES.ITALIAN]: WORDLIST$4,
[MONERO_MNEMONIC_LANGUAGES.JAPANESE]: WORDLIST$3,
[MONERO_MNEMONIC_LANGUAGES.PORTUGUESE]: WORDLIST$2,
[MONERO_MNEMONIC_LANGUAGES.RUSSIAN]: WORDLIST$1,
[MONERO_MNEMONIC_LANGUAGES.SPANISH]: WORDLIST
};
static getName() {
return 'Monero';
}
static fromWords(count, language) {
if (!this.wordsList.includes(count)) {
throw new MnemonicError('Invalid word count', { expected: this.wordsList, got: count });
}
let options = {};
if (this.checksumWordCounts.includes(count)) {
options = { checksum: true };
}
const strength = this.wordsToStrength[count];
const entropyBytes = MoneroEntropy.generate(strength);
return this.encode(entropyBytes, language, options);
}
static fromEntropy(entropy, language, options = {}) {
let raw;
if (typeof entropy === 'string') {
raw = hexToBytes(entropy);
}
else if (entropy instanceof Uint8Array) {
raw = entropy;
}
else {
raw = hexToBytes(entropy.getEntropy());
}
return this.encode(raw, language, options);
}
static encode(entropy, language, options = {}) {
const entropyBytes = getBytes(entropy);
if (!MoneroEntropy.isValidBytesStrength(entropyBytes.length)) {
throw new EntropyError('Wrong entropy strength', { expected: MoneroEntropy.strengths, got: entropyBytes.length * 8 });
}
const rawList = this.getWordsListByLanguage(language, this.wordLists);
const wordList = this.normalize(rawList);
if (wordList.length !== 1626) {
throw new Error(`Expected 1626 words in list for '${language}', got ${wordList.length}`);
}
const mnemonic = [];
for (let i = 0; i < entropyBytes.length; i += 4) {
const chunk = entropyBytes.slice(i, i + 4);
mnemonic.push(...bytesChunkToWords(chunk, wordList, 'little'));
}
if (options.checksum) {
const prefixLen = this.languageUniquePrefixLengths[language];
const prefixes = mnemonic.map(w => w.slice(0, prefixLen)).join('');
const lenBig = BigInt(mnemonic.length);
const idxBig = bytesToInteger(crc32(prefixes)) % lenBig;
const idx = Number(idxBig);
mnemonic.push(mnemonic[idx]);
}
return this.normalize(mnemonic).join(' ');
}
static decode(input, options = {}) {
const words = this.normalize(input);
const count = words.length;
if (!this.wordsList.includes(count)) {
throw new MnemonicError('Invalid word count', { expected: this.wordsList, got: count });
}
const [wordsList, language] = this.findLanguage(words, this.wordLists);
if (wordsList.length !== 1626) {
throw new Error(`Expected 1626 words in list for '${language}', got ${wordsList.length}`);
}
const phraseWords = [...words];
if (this.checksumWordCounts.includes(count)) {
const last = phraseWords.pop();
const prefixLen = this.languageUniquePrefixLengths[language];
const prefixes = phraseWords.map(w => w.slice(0, prefixLen)).join('');
const lenBig = BigInt(phraseWords.length);
const idxBig = bytesToInteger(crc32(prefixes)) % lenBig;
const idx = Number(idxBig);
const expected = phraseWords[idx];
if (last !== expected) {
throw new ChecksumError('Invalid checksum', { expected, got: last });
}
}
const buffers = [];
for (let i = 0; i < phraseWords.length; i += 3) {
const [w1, w2, w3] = phraseWords.slice(i, i + 3);
const chunk = wordsToBytesChunk(w1, w2, w3, wordsList, 'little');
buffers.push(getBytes(chunk));
}
return bytesToHex(concatBytes(...buffers), false);
}
static normalize(input) {
const arr = typeof input === 'string' ? input.trim().split(/\s+/) : input;
return arr.map(w => w.normalize('NFKD').toLowerCase());
}
}
// SPDX-License-Identifier: MIT
class MNEMONICS {
static dictionary = {
[AlgorandMnemonic.getName()]: AlgorandMnemonic,
[BIP39Mnemonic.getName()]: BIP39Mnemonic,
[ElectrumV1Mnemonic.getName()]: ElectrumV1Mnemonic,
[ElectrumV2Mnemonic.getName()]: ElectrumV2Mnemonic,
[MoneroMnemonic.getName()]: MoneroMnemonic
};
static getNames() {
return Object.keys(this.dictionary);
}
static getClasses() {
return Object.values(this.dictionary);
}
static getMnemonicClass(name) {
if (!this.isMnemonic(name)) {
throw new MnemonicError('Invalid Mnemonic name', { expected: this.getNames(), got: name });
}
return this.dictionary[name];
}
static isMnemonic(name) {
return this.getNames().includes(name);
}
}
var mnemonics = /*#__PURE__*/Object.freeze({
__proto__: null,
MNEMONICS: MNEMONICS,
Mnemonic: Mnemonic,
AlgorandMnemonic: AlgorandMnemonic,
ALGORAND_MNEMONIC_WORDS: ALGORAND_MNEMONIC_WORDS,
ALGORAND_MNEMONIC_LANGUAGES: ALGORAND_MNEMONIC_LANGUAGES,
BIP39Mnemonic: BIP39Mnemonic,
BIP39_MNEMONIC_WORDS: BIP39_MNEMONIC_WORDS,
BIP39_MNEMONIC_LANGUAGES: BIP39_MNEMONIC_LANGUAGES,
ElectrumV1Mnemonic: ElectrumV1Mnemonic,
ELECTRUM_V1_MNEMONIC_WORDS: ELECTRUM_V1_MNEMONIC_WORDS,
ELECTRUM_V1_MNEMONIC_LANGUAGES: ELECTRUM_V1_MNEMONIC_LANGUAGES,
ElectrumV2Mnemonic: ElectrumV2Mnemonic,
ELECTRUM_V2_MNEMONIC_WORDS: ELECTRUM_V2_MNEMONIC_WORDS,
ELECTRUM_V2_MNEMONIC_LANGUAGES: ELECTRUM_V2_MNEMONIC_LANGUAGES,
ELECTRUM_V2_MNEMONIC_TYPES: ELECTRUM_V2_MNEMONIC_TYPES,
MoneroMnemonic: MoneroMnemonic,
MONERO_MNEMONIC_WORDS: MONERO_MNEMONIC_WORDS,
MONERO_MNEMONIC_LANGUAGES: MONERO_MNEMONIC_LANGUAGES
});
// SPDX-License-Identifier: MIT
class Seed {
seed;
options;
constructor(seed, options = {}) {
this.seed = seed;
this.options = options;
}
static getName() {
throw new Error("Must override getName()");
}
getName() {
return this.constructor.getName();
}
getSeed() {
return this.seed;
}
static fromMnemonic(mnemonic, options = {}) {
throw new Error("Must override fromMnemonic()");
}
}
// SPDX-License-Identifier: MIT
class AlgorandSeed extends Seed {
static getName() {
return 'Algorand';
}
static fromMnemonic(mnemonic) {
const phrase = typeof mnemonic === 'string' ? mnemonic : mnemonic.getMnemonic();
if (!AlgorandMnemonic.isValid(phrase)) {
throw new MnemonicError(`Invalid ${this.getName()} mnemonic words`);
}
return AlgorandMnemonic.decode(phrase);
}
}
// SPDX-License-Identifier: MIT
class BIP39Seed extends Seed {
static seedSaltModifier = 'mnemonic';
static seedPbkdf2Rounds = 2048;
static getName() {
return 'BIP39';
}
static fromMnemonic(mnemonic, options = {}) {
const phrase = typeof mnemonic === 'string' ? mnemonic : mnemonic.getMnemonic();
if (!BIP39Mnemonic.isValid(phrase)) {
throw new MnemonicError(`Invalid ${this.getName()} mnemonic words`);
}
const saltBase = this.seedSaltModifier + (options.passphrase ?? '');
const salt = saltBase.normalize('NFKD');
const seedBytes = pbkdf2HmacSha512(phrase, salt, this.seedPbkdf2Rounds);
return bytesToString(seedBytes);
}
}
const f$4={POS_INT:0,NEG_INT:1,BYTE_STRING:2,UTF8_STRING:3,ARRAY:4,MAP:5,TAG:6,SIMPLE_FLOAT:7},I={DATE_STRING:0,DATE_EPOCH:1,POS_BIGINT:2,NEG_BIGINT:3,DECIMAL_FRAC:4,BIGFLOAT:5,BASE64URL_EXPECTED:21,BASE64_EXPECTED:22,BASE16_EXPECTED:23,CBOR:24,URI:32,BASE64URL:33,BASE64:34,MIME:36,SET:258,JSON:262,WTF8:273,REGEXP:21066,SELF_DESCRIBED:55799,INVALID_16:65535,INVALID_32:4294967295,INVALID_64:0xffffffffffffffffn},o$2={ZERO:0,ONE:24,TWO:25,FOUR:26,EIGHT:27,INDEFINITE:31},T$2={FALSE:20,TRUE:21,NULL:22,UNDEFINED:23};class N$2{static BREAK=Symbol.for("github.com/hildjj/cbor2/break");static ENCODED=Symbol.for("github.com/hildjj/cbor2/cbor-encoded");static LENGTH=Symbol.for("github.com/hildjj/cbor2/length")}const S$1={MIN:-(2n**63n),MAX:2n**64n-1n};
class i$1{static#e=new Map;tag;contents;constructor(e,t=void 0){this.tag=e,this.contents=t;}get noChildren(){return !!i$1.#e.get(this.tag)?.noChildren}static registerDecoder(e,t,n){const o=this.#e.get(e);return this.#e.set(e,t),o&&("comment"in t||(t.comment=o.comment),"noChildren"in t||(t.noChildren=o.noChildren)),n&&!t.comment&&(t.comment=()=>`(${n})`),o}static clearDecoder(e){const t=this.#e.get(e);return this.#e.delete(e),t}static getDecoder(e){return this.#e.get(e)}static getAllDecoders(){return new Map(this.#e)}*[Symbol.iterator](){yield this.contents;}push(e){return this.contents=e,1}decode(e){const t=e?.tags?.get(this.tag)??i$1.#e.get(this.tag);return t?t(this,e):this}comment(e,t){const n=e?.tags?.get(this.tag)??i$1.#e.get(this.tag);if(n?.comment)return n.comment(this,e,t)}toCBOR(){return [this.tag,this.contents]}[Symbol.for("nodejs.util.inspect.custom")](e,t,n){return `${this.tag}(${n(this.contents,t)})`}}
function f$3(n){if(n!=null&&typeof n=="object")return n[N$2.ENCODED]}function s$2(n){if(n!=null&&typeof n=="object")return n[N$2.LENGTH]}function u(n,e){Object.defineProperty(n,N$2.ENCODED,{configurable:!0,enumerable:!1,value:e});}function d$2(n,e){const r=Object(n);return u(r,e),r}
const g$2=Symbol("CBOR_RANGES");function c$2(r,n){Object.defineProperty(r,g$2,{configurable:!1,enumerable:!1,writable:!1,value:n});}function f$2(r){return r[g$2]}function l$3(r){return f$2(r)!==void 0}function R$1(r,n=0,t=r.length-1){const o=r.subarray(n,t),a=f$2(r);if(a){const s=[];for(const e of a)if(e[0]>=n&&e[0]+e[1]<=t){const i=[...e];i[0]-=n,s.push(i);}s.length&&c$2(o,s);}return o}function b$1(r){let n=Math.ceil(r.length/2);const t=new Uint8Array(n);n--;for(let o=r.length,a=o-2;o>=0;o=a,a-=2,n--)t[n]=parseInt(r.substring(a,o),16);return t}function A$2(r){return r.reduce((n,t)=>n+t.toString(16).padStart(2,"0"),"")}function d$1(r){const n=r.reduce((e,i)=>e+i.length,0),t=r.some(e=>l$3(e)),o=[],a=new Uint8Array(n);let s=0;for(const e of r){if(!(e instanceof Uint8Array))throw new TypeError(`Invalid array: ${e}`);if(a.set(e,s),t){const i=e[g$2]??[[0,e.length]];for(const u of i)u[0]+=s;o.push(...i);}s+=e.length;}return t&&c$2(a,o),a}function y$4(r){const n=atob(r);return Uint8Array.from(n,t=>t.codePointAt(0))}const p$2={"-":"+",_:"/"};function x$2(r){const n=r.replace(/[_-]/g,t=>p$2[t]);return y$4(n.padEnd(Math.ceil(n.length/4)*4,"="))}function h$2(){const r=new Uint8Array(4),n=new Uint32Array(r.buffer);return !((n[0]=1)&r[0])}function U$2(r){let n="";for(const t of r){const o=t.codePointAt(0)?.toString(16).padStart(4,"0");n&&(n+=", "),n+=`U+${o}`;}return n}
class s$1{#e=new Map;registerEncoder(e,t){const n=this.#e.get(e);return this.#e.set(e,t),n}get(e){return this.#e.get(e)}delete(e){return this.#e.delete(e)}clear(){this.#e.clear();}}
function f$1(c,d){const[u,a,n]=c,[l,s,t]=d,r=Math.min(n.length,t.length);for(let o=0;o<r;o++){const e=n[o]-t[o];if(e!==0)return e}return 0}
class e{static defaultOptions={chunkSize:4096};#r;#i=[];#s=null;#t=0;#a=0;constructor(t={}){if(this.#r={...e.defaultOptions,...t},this.#r.chunkSize<8)throw new RangeError(`Expected size >= 8, got ${this.#r.chunkSize}`);this.#n();}get length(){return this.#a}read(){this.#o();const t=new Uint8Array(this.#a);let i=0;for(const s of this.#i)t.set(s,i),i+=s.length;return this.#n(),t}write(t){const i=t.length;i>this.#l()?(this.#o(),i>this.#r.chunkSize?(this.#i.push(t),this.#n()):(this.#n(),this.#i[this.#i.length-1].set(t),this.#t=i)):(this.#i[this.#i.length-1].set(t,this.#t),this.#t+=i),this.#a+=i;}writeUint8(t){this.#e(1),this.#s.setUint8(this.#t,t),this.#h(1);}writeUint16(t,i=!1){this.#e(2),this.#s.setUint16(this.#t,t,i),this.#h(2);}writeUint32(t,i=!1){this.#e(4),this.#s.setUint32(this.#t,t,i),this.#h(4);}writeBigUint64(t,i=!1){this.#e(8),this.#s.setBigUint64(this.#t,t,i),this.#h(8);}writeInt16(t,i=!1){this.#e(2),this.#s.setInt16(this.#t,t,i),this.#h(2);}writeInt32(t,i=!1){this.#e(4),this.#s.setInt32(this.#t,t,i),this.#h(4);}writeBigInt64(t,i=!1){this.#e(8),this.#s.setBigInt64(this.#t,t,i),this.#h(8);}writeFloat32(t,i=!1){this.#e(4),this.#s.setFloat32(this.#t,t,i),this.#h(4);}writeFloat64(t,i=!1){this.#e(8),this.#s.setFloat64(this.#t,t,i),this.#h(8);}clear(){this.#a=0,this.#i=[],this.#n();}#n(){const t=new Uint8Array(this.#r.chunkSize);this.#i.push(t),this.#t=0,this.#s=new DataView(t.buffer,t.byteOffset,t.byteLength);}#o(){if(this.#t===0){this.#i.pop();return}const t=this.#i.length-1;this.#i[t]=this.#i[t].subarray(0,this.#t),this.#t=0,this.#s=null;}#l(){const t=this.#i.length-1;return this.#i[t].length-this.#t}#e(t){this.#l()<t&&(this.#o(),this.#n());}#h(t){this.#t+=t,this.#a+=t;}}
function o$1(e,n=0,t=!1){const r=e[n]&128?-1:1,f=(e[n]&124)>>2,a=(e[n]&3)<<8|e[n+1];if(f===0){if(t&&a!==0)throw new Error(`Unwanted subnormal: ${r*5960464477539063e-23*a}`);return r*5960464477539063e-23*a}else if(f===31)return a?NaN:r*(1/0);return r*2**(f-25)*(1024+a)}function s(e){const n=new DataView(new ArrayBuffer(4));n.setFloat32(0,e,!1);const t=n.getUint32(0,!1);if((t&8191)!==0)return null;let r=t>>16&32768;const f=t>>23&255,a=t&8388607;if(!(f===0&&a===0))if(f>=113&&f<=142)r+=(f-112<<10)+(a>>13);else if(f>=103&&f<113){if(a&(1<<126-f)-1)return null;r+=a+8388608>>126-f;}else if(f===255)r|=31744,r|=a>>13;else return null;return r}function i(e){if(e!==0){const n=new ArrayBuffer(8),t=new DataView(n);t.setFloat64(0,e,!1);const r=t.getBigUint64(0,!1);if((r&0x7ff0000000000000n)===0n)return r&0x8000000000000000n?-0:0}return e}function l$2(e){switch(e.length){case 2:o$1(e,0,!0);break;case 4:{const n=new DataView(e.buffer,e.byteOffset,e.byteLength),t=n.getUint32(0,!1);if((t&2139095040)===0&&t&8388607)throw new Error(`Unwanted subnormal: ${n.getFloat32(0,!1)}`);break}case 8:{const n=new DataView(e.buffer,e.byteOffset,e.byteLength),t=n.getBigUint64(0,!1);if((t&0x7ff0000000000000n)===0n&&t&0x000fffffffffffn)throw new Error(`Unwanted subnormal: ${n.getFloat64(0,!1)}`);break}default:throw new TypeError(`Bad input to isSubnormal: ${e}`)}}
class DecodeError extends TypeError {
code = 'ERR_ENCODING_INVALID_ENCODED_DATA';
constructor() {
super('The encoded data was not valid for encoding wtf-8');
}
}
class InvalidEncodingError extends RangeError {
code = 'ERR_ENCODING_NOT_SUPPORTED';
constructor(label) {
super(`Invalid encoding: "${label}"`);
}
}
const BOM = 0xfeff;
const EMPTY = new Uint8Array(0);
const MIN_HIGH_SURROGATE = 0xd800;
const MIN_LOW_SURROGATE = 0xdc00;
const REPLACEMENT = 0xfffd;
const WTF8 = 'wtf-8';
function isArrayBufferView(input) {
return (input &&
!(input instanceof ArrayBuffer) &&
input.buffer instanceof ArrayBuffer);
}
function getUint8(input) {
if (!input) {
return EMPTY;
}
if (input instanceof Uint8Array) {
return input;
}
if (isArrayBufferView(input)) {
return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
}
return new Uint8Array(input);
}
const REMAINDER = [
0,
0,
0,
0,
0,
0,
0,
0,
-1,
-1,
-1,
-1,
1,
1,
2,
3,
];
class Wtf8Decoder {
static DEFAULT_BUFFERSIZE = 0x1000;
encoding = WTF8;
fatal;
ignoreBOM;
bufferSize;
#left = 0;
#cur = 0;
#pending = 0;
#first = true;
#buf;
constructor(label = 'wtf8', options = undefined) {
if (label.toLowerCase().replace('-', '') !== 'wtf8') {
throw new InvalidEncodingError(label);
}
this.fatal = Boolean(options?.fatal);
this.ignoreBOM = Boolean(options?.ignoreBOM);
this.bufferSize = Math.floor(options?.bufferSize ?? Wtf8Decoder.DEFAULT_BUFFERSIZE);
if (isNaN(this.bufferSize) || (this.bufferSize < 1)) {
throw new RangeError(`Invalid buffer size: ${options?.bufferSize}`);
}
this.#buf = new Uint16Array(this.bufferSize);
}
decode(input, options) {
const streaming = Boolean(options?.stream);
const bytes = getUint8(input);
const res = [];
const out = this.#buf;
const maxSize = this.bufferSize - 3;
let pos = 0;
const fatal = () => {
this.#cur = 0;
this.#left = 0;
this.#pending = 0;
if (this.fatal) {
throw new DecodeError();
}
out[pos++] = REPLACEMENT;
};
const fatals = () => {
const p = this.#pending;
for (let i = 0; i < p; i++) {
fatal();
}
};
const oneByte = (b) => {
if (this.#left === 0) {
const n = REMAINDER[b >> 4];
switch (n) {
case -1:
fatal();
break;
case 0:
out[pos++] = b;
break;
case 1:
this.#cur = b & 0x1f;
if ((this.#cur & 0x1e) === 0) {
fatal();
}
else {
this.#left = 1;
this.#pending = 1;
}
break;
case 2:
this.#cur = b & 0x0f;
this.#left = 2;
this.#pending = 1;
break;
case 3:
if (b & 0x08) {
fatal();
}
else {
this.#cur = b & 0x07;
this.#left = 3;
this.#pending = 1;
}
break;
}
}
else {
if ((b & 0xc0) !== 0x80) {
fatals();
return oneByte(b);
}
if ((this.#pending === 1) &&
(this.#left === 2) &&
(this.#cur === 0) &&
((b & 0x20) === 0)) {
fatals();
return oneByte(b);
}
if ((this.#left === 3) && (this.#cur === 0) && ((b & 0x30) === 0)) {
fatals();
return oneByte(b);
}
this.#cur = (this.#cur << 6) | (b & 0x3f);
this.#pending++;
if (--this.#left === 0) {
if (this.ignoreBOM || !this.#first || (this.#cur !== BOM)) {
if (this.#cur < 0x10000) {
out[pos++] = this.#cur;
}
else {
const cp = this.#cur - 0x10000;
out[pos++] = ((cp >>> 10) & 0x3ff) | MIN_HIGH_SURROGATE;
out[pos++] = (cp & 0x3ff) | MIN_LOW_SURROGATE;
}
}
this.#cur = 0;
this.#pending = 0;
this.#first = false;
}
}
};
for (const b of bytes) {
if (pos >= maxSize) {
res.push(String.fromCharCode.apply(null, out.subarray(0, pos)));
pos = 0;
}
oneByte(b);
}
if (!streaming) {
this.#first = true;
if (this.#cur || this.#left) {
fatals();
}
}
if (pos > 0) {
res.push(String.fromCharCode.apply(null, out.subarray(0, pos)));
}
return res.join('');
}
}
function utf8length(str) {
let len = 0;
for (const s of str) {
const cp = s.codePointAt(0);
if (cp < 0x80) {
len++;
}
else if (cp < 0x800) {
len += 2;
}
else if (cp < 0x10000) {
len += 3;
}
else {
len += 4;
}
}
return len;
}
class Wtf8Encoder {
encoding = WTF8;
encode(input) {
if (!input) {
return EMPTY;
}
const buf = new Uint8Array(utf8length(String(input)));
this.encodeInto(input, buf);
return buf;
}
encodeInto(source, destination) {
const str = String(source);
const len = str.length;
const outLen = destination.length;
let written = 0;
let read = 0;
for (read = 0; read < len; read++) {
const c = str.codePointAt(read);
if (c < 0x80) {
if (written >= outLen) {
break;
}
destination[written++] = c;
}
else if (c < 0x800) {
if (written >= outLen - 1) {
break;
}
destination[written++] = 0xc0 | (c >> 6);
destination[written++] = 0x80 | (c & 0x3f);
}
else if (c < 0x10000) {
if (written >= outLen - 2) {
break;
}
destination[written++] = 0xe0 | (c >> 12);
destination[written++] = 0x80 | ((c >> 6) & 0x3f);
destination[written++] = 0x80 | (c & 0x3f);
}
else {
if (written >= outLen - 3) {
break;
}
destination[written++] = 0xf0 | (c >> 18);
destination[written++] = 0x80 | ((c >> 12) & 0x3f);
destination[written++] = 0x80 | ((c >> 6) & 0x3f);
destination[written++] = 0x80 | (c & 0x3f);
read++;
}
}
return {
read,
written,
};
}
}
const U$1=f$4.SIMPLE_FLOAT<<5|o$2.TWO,h$1=f$4.SIMPLE_FLOAT<<5|o$2.FOUR,B=f$4.SIMPLE_FLOAT<<5|o$2.EIGHT,j=f$4.SIMPLE_FLOAT<<5|T$2.TRUE,P=f$4.SIMPLE_FLOAT<<5|T$2.FALSE,$$1=f$4.SIMPLE_FLOAT<<5|T$2.UNDEFINED,q$1=f$4.SIMPLE_FLOAT<<5|T$2.NULL,z=new TextEncoder,K=new Wtf8Encoder,k$2={...e.defaultOptions,avoidInts:!1,cde:!1,collapseBigInts:!0,dcbor:!1,float64:!1,flushToZero:!1,forceEndian:null,ignoreOriginalEncoding:!1,largeNegativeAsBigInt:!1,reduceUnsafeNumbers:!1,rejectBigInts:!1,rejectCustomSimples:!1,rejectDuplicateKeys:!1,rejectFloats:!1,rejectUndefined:!1,simplifyNegativeZero:!1,sortKeys:null,stringNormalization:null,types:null,wtf8:!1},F={cde:!0,ignoreOriginalEncoding:!0,sortKeys:f$1},H$1={...F,dcbor:!0,largeNegativeAsBigInt:!0,reduceUnsafeNumbers:!0,rejectCustomSimples:!0,rejectDuplicateKeys:!0,rejectUndefined:!0,simplifyNegativeZero:!0,stringNormalization:"NFC"};function y$3(e){const n=e<0;return typeof e=="bigint"?[n?-e-1n:e,n]:[n?-e-1:e,n]}function T$1(e,n,t){if(t.rejectFloats)throw new Error(`Attempt to encode an unwanted floating point number: ${e}`);if(isNaN(e))n.writeUint8(U$1),n.writeUint16(32256);else if(!t.float64&&Math.fround(e)===e){const r=s(e);r===null?(n.writeUint8(h$1),n.writeFloat32(e)):(n.writeUint8(U$1),n.writeUint16(r));}else n.writeUint8(B),n.writeFloat64(e);}function a$1(e,n,t){const[r,i]=y$3(e);if(i&&t)throw new TypeError(`Negative size: ${e}`);t??=i?f$4.NEG_INT:f$4.POS_INT,t<<=5,r<24?n.writeUint8(t|r):r<=255?(n.writeUint8(t|o$2.ONE),n.writeUint8(r)):r<=65535?(n.writeUint8(t|o$2.TWO),n.writeUint16(r)):r<=4294967295?(n.writeUint8(t|o$2.FOUR),n.writeUint32(r)):(n.writeUint8(t|o$2.EIGHT),n.writeBigUint64(BigInt(r)));}function p$1(e,n,t){typeof e=="number"?a$1(e,n,f$4.TAG):typeof e=="object"&&!t.ignoreOriginalEncoding&&N$2.ENCODED in e?n.write(e[N$2.ENCODED]):e<=Number.MAX_SAFE_INTEGER?a$1(Number(e),n,f$4.TAG):(n.writeUint8(f$4.TAG<<5|o$2.EIGHT),n.writeBigUint64(BigInt(e)));}function N$1(e,n,t){const[r,i]=y$3(e);if(t.collapseBigInts&&(!t.largeNegativeAsBigInt||e>=-0x8000000000000000n)){if(r<=0xffffffffn){a$1(Number(e),n);return}if(r<=0xffffffffffffffffn){const E=(i?f$4.NEG_INT:f$4.POS_INT)<<5;n.writeUint8(E|o$2.EIGHT),n.writeBigUint64(r);return}}if(t.rejectBigInts)throw new Error(`Attempt to encode unwanted bigint: ${e}`);const o=i?I.NEG_BIGINT:I.POS_BIGINT,c=r.toString(16),s=c.length%2?"0":"";p$1(o,n,t);const u=b$1(s+c);a$1(u.length,n,f$4.BYTE_STRING),n.write(u);}function Y(e,n,t){t.flushToZero&&(e=i(e)),Object.is(e,-0)?t.simplifyNegativeZero?t.avoidInts?T$1(0,n,t):a$1(0,n):T$1(e,n,t):!t.avoidInts&&Number.isSafeInteger(e)?a$1(e,n):t.reduceUnsafeNumbers&&Math.floor(e)===e&&e>=S$1.MIN&&e<=S$1.MAX?N$1(BigInt(e),n,t):T$1(e,n,t);}function Z(e,n,t){const r=t.stringNormalization?e.normalize(t.stringNormalization):e;if(t.wtf8&&!e.isWellFormed()){const i=K.encode(r);p$1(I.WTF8,n,t),a$1(i.length,n,f$4.BYTE_STRING),n.write(i);}else {const i=z.encode(r);a$1(i.length,n,f$4.UTF8_STRING),n.write(i);}}function J(e,n,t){const r=e;R(r,r.length,f$4.ARRAY,n,t);for(const i of r)g$1(i,n,t);}function V(e,n){a$1(e.length,n,f$4.BYTE_STRING),n.write(e);}const b=new s$1;b.registerEncoder(Array,J),b.registerEncoder(Uint8Array,V);function ce(e,n){return b.registerEncoder(e,n)}function R(e,n,t,r,i){const o=s$2(e);o&&!i.ignoreOriginalEncoding?r.write(o):a$1(n,r,t);}function X(e,n,t){if(e===null){n.writeUint8(q$1);return}if(!t.ignoreOriginalEncoding&&N$2.ENCODED in e){n.write(e[N$2.ENCODED]);return}const r=e.constructor;if(r){const o=t.types?.get(r)??b.get(r);if(o){const c=o(e,n,t);if(c!==void 0){if(!Array.isArray(c)||c.length!==2)throw new Error("Invalid encoder return value");(typeof c[0]=="bigint"||isFinite(Number(c[0])))&&p$1(c[0],n,t),g$1(c[1],n,t);}return}}if(typeof e.toCBOR=="function"){const o=e.toCBOR(n,t);o&&((typeof o[0]=="bigint"||isFinite(Number(o[0])))&&p$1(o[0],n,t),g$1(o[1],n,t));return}if(typeof e.toJSON=="function"){g$1(e.toJSON(),n,t);return}const i=Object.entries(e).map(o=>[o[0],o[1],Q(o[0],t)]);t.sortKeys&&i.sort(t.sortKeys),R(e,i.length,f$4.MAP,n,t);for(const[o,c,s]of i)n.write(s),g$1(c,n,t);}function g$1(e,n,t){switch(typeof e){case"number":Y(e,n,t);break;case"bigint":N$1(e,n,t);break;case"string":Z(e,n,t);break;case"boolean":n.writeUint8(e?j:P);break;case"undefined":if(t.rejectUndefined)throw new Error("Attempt to encode unwanted undefined.");n.writeUint8($$1);break;case"object":X(e,n,t);break;case"symbol":throw new TypeError(`Unknown symbol: ${e.toString()}`);default:throw new TypeError(`Unknown type: ${typeof e}, ${String(e)}`)}}function Q(e$1,n={}){const t={...k$2};n.dcbor?Object.assign(t,H$1):n.cde&&Object.assign(t,F),Object.assign(t,n);const r=new e(t);return g$1(e$1,r,t),r.read()}
var o=(e=>(e[e.NEVER=-1]="NEVER",e[e.PREFERRED=0]="PREFERRED",e[e.ALWAYS=1]="ALWAYS",e))(o||{});
class t{static KnownSimple=new Map([[T$2.FALSE,!1],[T$2.TRUE,!0],[T$2.NULL,null],[T$2.UNDEFINED,void 0]]);value;constructor(e){this.value=e;}static create(e){return t.KnownSimple.has(e)?t.KnownSimple.get(e):new t(e)}toCBOR(e,i){if(i.rejectCustomSimples)throw new Error(`Cannot encode non-standard Simple value: ${this.value}`);a$1(this.value,e,f$4.SIMPLE_FLOAT);}toString(){return `simple(${this.value})`}decode(){return t.KnownSimple.has(this.value)?t.KnownSimple.get(this.value):this}[Symbol.for("nodejs.util.inspect.custom")](e,i,r){return `simple(${r(this.value,i)})`}}
const p=new TextDecoder("utf8",{fatal:!0,ignoreBOM:!0});class y$2{static defaultOptions={maxDepth:1024,encoding:"hex",requirePreferred:!1};#t;#r;#e=0;#i;constructor(t,r){if(this.#i={...y$2.defaultOptions,...r},typeof t=="string")switch(this.#i.encoding){case"hex":this.#t=b$1(t);break;case"base64":this.#t=y$4(t);break;default:throw new TypeError(`Encoding not implemented: "${this.#i.encoding}"`)}else this.#t=t;this.#r=new DataView(this.#t.buffer,this.#t.byteOffset,this.#t.byteLength);}toHere(t){return R$1(this.#t,t,this.#e)}*[Symbol.iterator](){if(yield*this.#n(0),this.#e!==this.#t.length)throw new Error("Extra data in input")}*seq(){for(;this.#e<this.#t.length;)yield*this.#n(0);}*#n(t$1){if(t$1++>this.#i.maxDepth)throw new Error(`Maximum depth ${this.#i.maxDepth} exceeded`);const r=this.#e,c=this.#r.getUint8(this.#e++),i=c>>5,n=c&31;let e=n,f=!1,a=0;switch(n){case o$2.ONE:if(a=1,e=this.#r.getUint8(this.#e),i===f$4.SIMPLE_FLOAT){if(e<32)throw new Error(`Invalid simple encoding in extra byte: ${e}`);f=!0;}else if(this.#i.requirePreferred&&e<24)throw new Error(`Unexpectedly long integer encoding (1) for ${e}`);break;case o$2.TWO:if(a=2,i===f$4.SIMPLE_FLOAT)e=o$1(this.#t,this.#e);else if(e=this.#r.getUint16(this.#e,!1),this.#i.requirePreferred&&e<=255)throw new Error(`Unexpectedly long integer encoding (2) for ${e}`);break;case o$2.FOUR:if(a=4,i===f$4.SIMPLE_FLOAT)e=this.#r.getFloat32(this.#e,!1);else if(e=this.#r.getUint32(this.#e,!1),this.#i.requirePreferred&&e<=65535)throw new Error(`Unexpectedly long integer encoding (4) for ${e}`);break;case o$2.EIGHT:{if(a=8,i===f$4.SIMPLE_FLOAT)e=this.#r.getFloat64(this.#e,!1);else if(e=this.#r.getBigUint64(this.#e,!1),e<=Number.MAX_SAFE_INTEGER&&(e=Number(e)),this.#i.requirePreferred&&e<=4294967295)throw new Error(`Unexpectedly long integer encoding (8) for ${e}`);break}case 28:case 29:case 30:throw new Error(`Additional info not implemented: ${n}`);case o$2.INDEFINITE:switch(i){case f$4.POS_INT:case f$4.NEG_INT:case f$4.TAG:throw new Error(`Invalid indefinite encoding for MT ${i}`);case f$4.SIMPLE_FLOAT:yield [i,n,N$2.BREAK,r,0];return}e=1/0;break;default:f=!0;}switch(this.#e+=a,i){case f$4.POS_INT:yield [i,n,e,r,a];break;case f$4.NEG_INT:yield [i,n,typeof e=="bigint"?-1n-e:-1-Number(e),r,a];break;case f$4.BYTE_STRING:e===1/0?yield*this.#s(i,t$1,r):yield [i,n,this.#a(e),r,e];break;case f$4.UTF8_STRING:e===1/0?yield*this.#s(i,t$1,r):yield [i,n,p.decode(this.#a(e)),r,e];break;case f$4.ARRAY:if(e===1/0)yield*this.#s(i,t$1,r,!1);else {const o=Number(e);yield [i,n,o,r,a];for(let h=0;h<o;h++)yield*this.#n(t$1+1);}break;case f$4.MAP:if(e===1/0)yield*this.#s(i,t$1,r,!1);else {const o=Number(e);yield [i,n,o,r,a];for(let h=0;h<o;h++)yield*this.#n(t$1),yield*this.#n(t$1);}break;case f$4.TAG:yield [i,n,e,r,a],yield*this.#n(t$1);break;case f$4.SIMPLE_FLOAT:{const o=e;f&&(e=t.create(Number(e))),yield [i,n,e,r,o];break}}}#a(t){const r=R$1(this.#t,this.#e,this.#e+=t);if(r.length!==t)throw new Error(`Unexpected end of stream reading ${t} bytes, got ${r.length}`);return r}*#s(t,r,c,i=!0){for(yield [t,o$2.INDEFINITE,1/0,c,1/0];;){const n=this.#n(r),e=n.next(),[f,a,o]=e.value;if(o===N$2.BREAK){yield e.value,n.next();return}if(i){if(f!==t)throw new Error(`Unmatched major type. Expected ${t}, got ${f}.`);if(a===o$2.INDEFINITE)throw new Error("New stream started in typed stream")}yield e.value,yield*n;}}}
const v=new Map([[o$2.ZERO,1],[o$2.ONE,2],[o$2.TWO,3],[o$2.FOUR,5],[o$2.EIGHT,9]]),A$1=new Uint8Array(0);function k$1(d,r){return !r.boxed&&!r.preferMap&&d.every(([i])=>typeof i=="string")?Object.fromEntries(d):new Map(d)}class w$1{static defaultDecodeOptions={...y$2.defaultOptions,ParentType:w$1,boxed:!1,cde:!1,dcbor:!1,diagnosticSizes:o.PREFERRED,convertUnsafeIntsToFloat:!1,createObject:k$1,pretty:!1,preferMap:!1,rejectLargeNegatives:!1,rejectBigInts:!1,rejectDuplicateKeys:!1,rejectFloats:!1,rejectInts:!1,rejectLongLoundNaN:!1,rejectLongFloats:!1,rejectNegativeZero:!1,rejectSimple:!1,rejectStreaming:!1,rejectStringsNotNormalizedAs:null,rejectSubnormals:!1,rejectUndefined:!1,rejectUnsafeFloatInts:!1,saveOriginal:!1,sortKeys:null,tags:null};static cdeDecodeOptions={cde:!0,rejectStreaming:!0,requirePreferred:!0,sortKeys:f$1};static dcborDecodeOptions={...this.cdeDecodeOptions,dcbor:!0,convertUnsafeIntsToFloat:!0,rejectDuplicateKeys:!0,rejectLargeNegatives:!0,rejectLongLoundNaN:!0,rejectLongFloats:!0,rejectNegativeZero:!0,rejectSimple:!0,rejectUndefined:!0,rejectUnsafeFloatInts:!0,rejectStringsNotNormalizedAs:"NFC"};parent;mt;ai;left;offset;count=0;children=[];depth=0;#e;#t=null;constructor(r,i,e,t){if([this.mt,this.ai,,this.offset]=r,this.left=i,this.parent=e,this.#e=t,e&&(this.depth=e.depth+1),this.mt===f$4.MAP&&(this.#e.sortKeys||this.#e.rejectDuplicateKeys)&&(this.#t=[]),this.#e.rejectStreaming&&this.ai===o$2.INDEFINITE)throw new Error("Streaming not supported")}get isStreaming(){return this.left===1/0}get done(){return this.left===0}static create(r,i,e,t$1){const[s,l,n,c]=r;switch(s){case f$4.POS_INT:case f$4.NEG_INT:{if(e.rejectInts)throw new Error(`Unexpected integer: ${n}`);if(e.rejectLargeNegatives&&n<-0x8000000000000000n)throw new Error(`Invalid 65bit negative number: ${n}`);let o=n;return e.convertUnsafeIntsToFloat&&o>=S$1.MIN&&o<=S$1.MAX&&(o=Number(n)),e.boxed?d$2(o,t$1.toHere(c)):o}case f$4.SIMPLE_FLOAT:if(l>o$2.ONE){if(e.rejectFloats)throw new Error(`Decoding unwanted floating point number: ${n}`);if(e.rejectNegativeZero&&Object.is(n,-0))throw new Error("Decoding negative zero");if(e.rejectLongLoundNaN&&isNaN(n)){const o=t$1.toHere(c);if(o.length!==3||o[1]!==126||o[2]!==0)throw new Error(`Invalid NaN encoding: "${A$2(o)}"`)}if(e.rejectSubnormals&&l$2(t$1.toHere(c+1)),e.rejectLongFloats){const o=Q(n,{chunkSize:9,reduceUnsafeNumbers:e.rejectUnsafeFloatInts});if(o[0]>>5!==s)throw new Error(`Should have been encoded as int, not float: ${n}`);if(o.length<v.get(l))throw new Error(`Number should have been encoded shorter: ${n}`)}if(typeof n=="number"&&e.boxed)return d$2(n,t$1.toHere(c))}else {if(e.rejectSimple&&n instanceof t)throw new Error(`Invalid simple value: ${n}`);if(e.rejectUndefined&&n===void 0)throw new Error("Unexpected undefined")}return n;case f$4.BYTE_STRING:case f$4.UTF8_STRING:if(n===1/0)return new e.ParentType(r,1/0,i,e);if(e.rejectStringsNotNormalizedAs&&typeof n=="string"){const o=n.normalize(e.rejectStringsNotNormalizedAs);if(n!==o)throw new Error(`String not normalized as "${e.rejectStringsNotNormalizedAs}", got [${U$2(n)}] instead of [${U$2(o)}]`)}return e.boxed?d$2(n,t$1.toHere(c)):n;case f$4.ARRAY:return new e.ParentType(r,n,i,e);case f$4.MAP:return new e.ParentType(r,n*2,i,e);case f$4.TAG:{const o=new e.ParentType(r,1,i,e);return o.children=new i$1(n),o}}throw new TypeError(`Invalid major type: ${s}`)}static decodeToEncodeOpts(r){return {...k$2,avoidInts:r.rejectInts,float64:!r.rejectLongFloats,flushToZero:r.rejectSubnormals,largeNegativeAsBigInt:r.rejectLargeNegatives,sortKeys:r.sortKeys}}push(r,i,e){if(this.children.push(r),this.#t){const t=f$3(r)||i.toHere(e);this.#t.push(t);}return --this.left}replaceLast(r,i,e){let t,s=-1/0;if(this.children instanceof i$1?(s=0,t=this.children.contents,this.children.contents=r):(s=this.children.length-1,t=this.children[s],this.children[s]=r),this.#t){const l=f$3(r)||e.toHere(i.offset);this.#t[s]=l;}return t}convert(r){let i;switch(this.mt){case f$4.ARRAY:i=this.children;break;case f$4.MAP:{const e=this.#r();if(this.#e.sortKeys){let t;for(const s of e){if(t&&this.#e.sortKeys(t,s)>=0)throw new Error(`Duplicate or out of order key: "0x${s[2]}"`);t=s;}}else if(this.#e.rejectDuplicateKeys){const t=new Set;for(const[s,l,n]of e){const c=A$2(n);if(t.has(c))throw new Error(`Duplicate key: "0x${c}"`);t.add(c);}}i=this.#e.createObject(e,this.#e);break}case f$4.BYTE_STRING:return d$1(this.children);case f$4.UTF8_STRING:{const e=this.children.join("");i=this.#e.boxed?d$2(e,r.toHere(this.offset)):e;break}case f$4.TAG:i=this.children.decode(this.#e);break;default:throw new TypeError(`Invalid mt on convert: ${this.mt}`)}return this.#e.saveOriginal&&i&&typeof i=="object"&&u(i,r.toHere(this.offset)),i}#r(){const r=this.children,i=r.length;if(i%2)throw new Error("Missing map value");const e=new Array(i/2);if(this.#t)for(let t=0;t<i;t+=2)e[t>>1]=[r[t],r[t+1],this.#t[t]];else for(let t=0;t<i;t+=2)e[t>>1]=[r[t],r[t+1],A$1];return e}}
const O$2=" ",y$1=new TextEncoder;class g extends w$1{close="";quote='"';get isEmptyStream(){return (this.mt===f$4.UTF8_STRING||this.mt===f$4.BYTE_STRING)&&this.count===0}}function a(m,l,n,p){let t="";if(l===o$2.INDEFINITE)t+="_";else {if(p.diagnosticSizes===o.NEVER)return "";{let r=p.diagnosticSizes===o.ALWAYS;if(!r){let e=o$2.ZERO;if(Object.is(n,-0))e=o$2.TWO;else if(m===f$4.POS_INT||m===f$4.NEG_INT){const T=n<0,u=typeof n=="bigint"?1n:1,o=T?-n-u:n;o<=23?e=Number(o):o<=255?e=o$2.ONE:o<=65535?e=o$2.TWO:o<=4294967295?e=o$2.FOUR:e=o$2.EIGHT;}else isFinite(n)?Math.fround(n)===n?s(n)==null?e=o$2.FOUR:e=o$2.TWO:e=o$2.EIGHT:e=o$2.TWO;r=e!==l;}r&&(t+="_",l<o$2.ONE?t+="i":t+=String(l-24));}}return t}function M(m,l){const n={...w$1.defaultDecodeOptions,...l,ParentType:g},p=new y$2(m,n);let t$1,r,e="";for(const T of p){const[u,o,i]=T;switch(t$1&&(t$1.count>0&&i!==N$2.BREAK&&(t$1.mt===f$4.MAP&&t$1.count%2?e+=": ":(e+=",",n.pretty||(e+=" "))),n.pretty&&(t$1.mt!==f$4.MAP||t$1.count%2===0)&&(e+=`
${O$2.repeat(t$1.depth+1)}`)),r=w$1.create(T,t$1,n,p),u){case f$4.POS_INT:case f$4.NEG_INT:e+=String(i),e+=a(u,o,i,n);break;case f$4.SIMPLE_FLOAT:if(i!==N$2.BREAK)if(typeof i=="number"){const c=Object.is(i,-0)?"-0.0":String(i);e+=c,isFinite(i)&&!/[.e]/.test(c)&&(e+=".0"),e+=a(u,o,i,n);}else i instanceof t?(e+="simple(",e+=String(i.value),e+=a(f$4.POS_INT,o,i.value,n),e+=")"):e+=String(i);break;case f$4.BYTE_STRING:i===1/0?(e+="(_ ",r.close=")",r.quote="'"):(e+="h'",e+=A$2(i),e+="'",e+=a(f$4.POS_INT,o,i.length,n));break;case f$4.UTF8_STRING:i===1/0?(e+="(_ ",r.close=")"):(e+=JSON.stringify(i),e+=a(f$4.POS_INT,o,y$1.encode(i).length,n));break;case f$4.ARRAY:{e+="[";const c=a(f$4.POS_INT,o,i,n);e+=c,c&&(e+=" "),n.pretty&&i?r.close=`
${O$2.repeat(r.depth)}]`:r.close="]";break}case f$4.MAP:{e+="{";const c=a(f$4.POS_INT,o,i,n);e+=c,c&&(e+=" "),n.pretty&&i?r.close=`
${O$2.repeat(r.depth)}}`:r.close="}";break}case f$4.TAG:e+=String(i),e+=a(f$4.POS_INT,o,i,n),e+="(",r.close=")";break}if(r===N$2.BREAK)if(t$1?.isStreaming)t$1.left=0;else throw new Error("Unexpected BREAK");else t$1&&(t$1.count++,t$1.left--);for(r instanceof g&&(t$1=r);t$1?.done;){if(t$1.isEmptyStream)e=e.slice(0,-3),e+=`${t$1.quote}${t$1.quote}_`;else {if(t$1.mt===f$4.MAP&&t$1.count%2!==0)throw new Error(`Odd streaming map size: ${t$1.count}`);e+=t$1.close;}t$1=t$1.parent;}}return e}
const H=new TextDecoder;class A extends w$1{depth=0;leaf=!1;value;length;[N$2.ENCODED];constructor(a,f,e,n){super(a,f,e,n),this.parent?this.depth=this.parent.depth+1:this.depth=n.initialDepth,[,,this.value,,this.length]=a;}numBytes(){switch(this.ai){case o$2.ONE:return 1;case o$2.TWO:return 2;case o$2.FOUR:return 4;case o$2.EIGHT:return 8}return 0}}function k(t){return t instanceof A}function O$1(t,a){return t===1/0?"Indefinite":a?`${t} ${a}${t!==1&&t!==1n?"s":""}`:String(t)}function y(t){return "".padStart(t," ")}function x$1(t$1,a,f){let e="";e+=y(t$1.depth*2);const n=f$3(t$1);e+=A$2(n.subarray(0,1));const r=t$1.numBytes();r&&(e+=" ",e+=A$2(n.subarray(1,r+1))),e=e.padEnd(a.minCol+1," "),e+="-- ",f!==void 0&&(e+=y(t$1.depth*2),f!==""&&(e+=`[${f}] `));let p=!1;const[s]=t$1.children;switch(t$1.mt){case f$4.POS_INT:e+=`Unsigned: ${s}`,typeof s=="bigint"&&(e+="n");break;case f$4.NEG_INT:e+=`Negative: ${s}`,typeof s=="bigint"&&(e+="n");break;case f$4.BYTE_STRING:e+=`Bytes (Length: ${O$1(t$1.length)})`;break;case f$4.UTF8_STRING:e+=`UTF8 (Length: ${O$1(t$1.length)})`,t$1.length!==1/0&&(e+=`: ${JSON.stringify(s)}`);break;case f$4.ARRAY:e+=`Array (Length: ${O$1(t$1.value,"item")})`;break;case f$4.MAP:e+=`Map (Length: ${O$1(t$1.value,"pair")})`;break;case f$4.TAG:{e+=`Tag #${t$1.value}`;const o=t$1.children,[m]=o.contents.children,i=new i$1(o.tag,m);u(i,n);const l=i.comment(a,t$1.depth);l&&(e+=": ",e+=l),p||=i.noChildren;break}case f$4.SIMPLE_FLOAT:s===N$2.BREAK?e+="BREAK":t$1.ai>o$2.ONE?Object.is(s,-0)?e+="Float: -0":e+=`Float: ${s}`:(e+="Simple: ",s instanceof t?e+=s.value:e+=s);break}if(!p)if(t$1.leaf){if(e+=`
`,n.length>r+1){const o=y((t$1.depth+1)*2),m=f$2(n);if(m?.length){m.sort((l,c)=>{const g=l[0]-c[0];return g||c[1]-l[1]});let i=0;for(const[l,c,g]of m)if(!(l<i)){if(i=l+c,g==="<<"){e+=y(a.minCol+1),e+="--",e+=o,e+="<< ";const d=R$1(n,l,l+c),h=f$2(d);if(h){const $=h.findIndex(([w,D,v])=>w===0&&D===c&&v==="<<");$>=0&&h.splice($,1);}e+=M(d),e+=` >>
`,e+=L(d,{initialDepth:t$1.depth+1,minCol:a.minCol,noPrefixHex:!0});continue}else g==="'"&&(e+=y(a.minCol+1),e+="--",e+=o,e+="'",e+=H.decode(n.subarray(l,l+c)),e+=`'
`);if(l>r)for(let d=l;d<l+c;d+=8){const h=Math.min(d+8,l+c);e+=o,e+=A$2(n.subarray(d,h)),e+=`
`;}}}else for(let i=r+1;i<n.length;i+=8)e+=o,e+=A$2(n.subarray(i,i+8)),e+=`
`;}}else {e+=`
`;let o=0;for(const m of t$1.children){if(k(m)){let i=String(o);t$1.mt===f$4.MAP?i=o%2?`val ${(o-1)/2}`:`key ${o/2}`:t$1.mt===f$4.TAG&&(i=""),e+=x$1(m,a,i);}o++;}}return e}const q={...w$1.defaultDecodeOptions,initialDepth:0,noPrefixHex:!1,minCol:0};function L(t,a){const f={...q,...a,ParentType:A,saveOriginal:!0},e=new y$2(t,f);let n,r;for(const s of e){if(r=w$1.create(s,n,f,e),s[2]===N$2.BREAK)if(n?.isStreaming)n.left=1;else throw new Error("Unexpected BREAK");if(!k(r)){const i=new A(s,0,n,f);i.leaf=!0,i.children.push(r),u(i,e.toHere(s[3])),r=i;}let o=(r.depth+1)*2;const m=r.numBytes();for(m&&(o+=1,o+=m*2),f.minCol=Math.max(f.minCol,o),n&&n.push(r,e,s[3]),n=r;n?.done;)r=n,r.leaf||u(r,e.toHere(r.offset)),{parent:n}=n;}a&&(a.minCol=f.minCol);let p=f.noPrefixHex?"":`0x${A$2(e.toHere(0))}
`;return p+=x$1(r,f),p}
const S=!h$2();function O(e){if(typeof e=="object"&&e){if(e.constructor!==Number)throw new Error(`Expected number: ${e}`)}else if(typeof e!="number")throw new Error(`Expected number: ${e}`)}function E(e){if(typeof e=="object"&&e){if(e.constructor!==String)throw new Error(`Expected string: ${e}`)}else if(typeof e!="string")throw new Error(`Expected string: ${e}`)}function f(e){if(!(e instanceof Uint8Array))throw new Error(`Expected Uint8Array: ${e}`)}function U(e){if(!Array.isArray(e))throw new Error(`Expected Array: ${e}`)}ce(Map,(e,r,n)=>{const t=[...e.entries()].map(o=>[o[0],o[1],Q(o[0],n)]);if(n.rejectDuplicateKeys){const o=new Set;for(const[d,u,y]of t){const g=A$2(y);if(o.has(g))throw new Error(`Duplicate map key: 0x${g}`);o.add(g);}}n.sortKeys&&t.sort(n.sortKeys),R(e,e.size,f$4.MAP,r,n);for(const[o,d,u]of t)r.write(u),g$1(d,r,n);});function h(e){return E(e.contents),new Date(e.contents)}h.comment=e=>(E(e.contents),`(String Date) ${new Date(e.contents).toISOString()}`),i$1.registerDecoder(I.DATE_STRING,h);function N(e){return O(e.contents),new Date(e.contents*1e3)}N.comment=e=>(O(e.contents),`(Epoch Date) ${new Date(e.contents*1e3).toISOString()}`),i$1.registerDecoder(I.DATE_EPOCH,N),ce(Date,e=>[I.DATE_EPOCH,e.valueOf()/1e3]);function T(e,r,n){if(f(r.contents),n.rejectBigInts)throw new Error(`Decoding unwanted big integer: ${r}(h'${A$2(r.contents)}')`);if(n.requirePreferred&&r.contents[0]===0)throw new Error(`Decoding overly-large bigint: ${r.tag}(h'${A$2(r.contents)})`);let t=r.contents.reduce((o,d)=>o<<8n|BigInt(d),0n);if(e&&(t=-1n-t),n.requirePreferred&&t>=Number.MIN_SAFE_INTEGER&&t<=Number.MAX_SAFE_INTEGER)throw new Error(`Decoding bigint that could have been int: ${t}n`);return n.boxed?d$2(t,r.contents):t}const _=T.bind(null,!1),$=T.bind(null,!0);_.comment=(e,r)=>`(Positive BigInt) ${T(!1,e,r)}n`,$.comment=(e,r)=>`(Negative BigInt) ${T(!0,e,r)}n`,i$1.registerDecoder(I.POS_BIGINT,_),i$1.registerDecoder(I.NEG_BIGINT,$);function D(e,r){return f(e.contents),e}D.comment=(e,r,n)=>{f(e.contents);const t={...r,initialDepth:n+2,noPrefixHex:!0},o=f$3(e);let u=2**((o[0]&31)-24)+1;const y=o[u]&31;let g=A$2(o.subarray(u,++u));y>=24&&(g+=" ",g+=A$2(o.subarray(u,u+2**(y-24)))),t.minCol=Math.max(t.minCol,(n+1)*2+g.length);const p=L(e.contents,t);let I=`Embedded CBOR
`;return I+=`${"".padStart((n+1)*2," ")}${g}`.padEnd(t.minCol+1," "),I+=`-- Bytes (Length: ${e.contents.length})
`,I+=p,I},D.noChildren=!0,i$1.registerDecoder(I.CBOR,D),i$1.registerDecoder(I.URI,e=>(E(e.contents),new URL(e.contents)),"URI"),ce(URL,e=>[I.URI,e.toString()]),i$1.registerDecoder(I.BASE64URL,e=>(E(e.contents),x$2(e.contents)),"Base64url-encoded"),i$1.registerDecoder(I.BASE64,e=>(E(e.contents),y$4(e.contents)),"Base64-encoded"),i$1.registerDecoder(35,e=>(E(e.contents),new RegExp(e.contents)),"RegExp"),i$1.registerDecoder(21065,e=>{E(e.contents);const r=`^(?:${e.contents})$`;return new RegExp(r,"u")},"I-RegExp"),i$1.registerDecoder(I.REGEXP,e=>{if(U(e.contents),e.contents.length<1||e.contents.length>2)throw new Error(`Invalid RegExp Array: ${e.contents}`);return new RegExp(e.contents[0],e.contents[1])},"RegExp"),ce(RegExp,e=>[I.REGEXP,[e.source,e.flags]]),i$1.registerDecoder(64,e=>(f(e.contents),e.contents),"uint8 Typed Array");function c$1(e,r,n){f(e.contents);let t=e.contents.length;if(t%r.BYTES_PER_ELEMENT!==0)throw new Error(`Number of bytes must be divisible by ${r.BYTES_PER_ELEMENT}, got: ${t}`);t/=r.BYTES_PER_ELEMENT;const o=new r(t),d=new DataView(e.contents.buffer,e.contents.byteOffset,e.contents.byteLength),u=d[`get${r.name.replace(/Array/,"")}`].bind(d);for(let y=0;y<t;y++)o[y]=u(y*r.BYTES_PER_ELEMENT,n);return o}function l$1(e,r,n,t,o){const d=o.forceEndian??S;if(p$1(d?r:n,e,o),a$1(t.byteLength,e,f$4.BYTE_STRING),S===d)e.write(new Uint8Array(t.buffer,t.byteOffset,t.byteLength));else {const y=`write${t.constructor.name.replace(/Array/,"")}`,g=e[y].bind(e);for(const p of t)g(p,d);}}i$1.registerDecoder(65,e=>c$1(e,Uint16Array,!1),"uint16, big endian, Typed Array"),i$1.registerDecoder(66,e=>c$1(e,Uint32Array,!1),"uint32, big endian, Typed Array"),i$1.registerDecoder(67,e=>c$1(e,BigUint64Array,!1),"uint64, big endian, Typed Array"),i$1.registerDecoder(68,e=>(f(e.contents),new Uint8ClampedArray(e.contents)),"uint8 Typed Array, clamped arithmetic"),ce(Uint8ClampedArray,e=>[68,new Uint8Array(e.buffer,e.byteOffset,e.byteLength)]),i$1.registerDecoder(69,e=>c$1(e,Uint16Array,!0),"uint16, little endian, Typed Array"),ce(Uint16Array,(e,r,n)=>l$1(r,69,65,e,n)),i$1.registerDecoder(70,e=>c$1(e,Uint32Array,!0),"uint32, little endian, Typed Array"),ce(Uint32Array,(e,r,n)=>l$1(r,70,66,e,n)),i$1.registerDecoder(71,e=>c$1(e,BigUint64Array,!0),"uint64, little endian, Typed Array"),ce(BigUint64Array,(e,r,n)=>l$1(r,71,67,e,n)),i$1.registerDecoder(72,e=>(f(e.contents),new Int8Array(e.contents)),"sint8 Typed Array"),ce(Int8Array,e=>[72,new Uint8Array(e.buffer,e.byteOffset,e.byteLength)]),i$1.registerDecoder(73,e=>c$1(e,Int16Array,!1),"sint16, big endian, Typed Array"),i$1.registerDecoder(74,e=>c$1(e,Int32Array,!1),"sint32, big endian, Typed Array"),i$1.registerDecoder(75,e=>c$1(e,BigInt64Array,!1),"sint64, big endian, Typed Array"),i$1.registerDecoder(77,e=>c$1(e,Int16Array,!0),"sint16, little endian, Typed Array"),ce(Int16Array,(e,r,n)=>l$1(r,77,73,e,n)),i$1.registerDecoder(78,e=>c$1(e,Int32Array,!0),"sint32, little endian, Typed Array"),ce(Int32Array,(e,r,n)=>l$1(r,78,74,e,n)),i$1.registerDecoder(79,e=>c$1(e,BigInt64Array,!0),"sint64, little endian, Typed Array"),ce(BigInt64Array,(e,r,n)=>l$1(r,79,75,e,n)),i$1.registerDecoder(81,e=>c$1(e,Float32Array,!1),"IEEE 754 binary32, big endian, Typed Array"),i$1.registerDecoder(82,e=>c$1(e,Float64Array,!1),"IEEE 754 binary64, big endian, Typed Array"),i$1.registerDecoder(85,e=>c$1(e,Float32Array,!0),"IEEE 754 binary32, little endian, Typed Array"),ce(Float32Array,(e,r,n)=>l$1(r,85,81,e,n)),i$1.registerDecoder(86,e=>c$1(e,Float64Array,!0),"IEEE 754 binary64, big endian, Typed Array"),ce(Float64Array,(e,r,n)=>l$1(r,86,82,e,n)),i$1.registerDecoder(I.SET,(e,r)=>{if(U(e.contents),r.sortKeys){const n=w$1.decodeToEncodeOpts(r);let t=null;for(const o of e.contents){const d=[o,void 0,Q(o,n)];if(t&&r.sortKeys(t,d)>=0)throw new Error(`Set items out of order in tag #${I.SET}`);t=d;}}return new Set(e.contents)},"Set"),ce(Set,(e,r,n)=>{let t=[...e];if(n.sortKeys){const o=t.map(d=>[d,void 0,Q(d,n)]);o.sort(n.sortKeys),t=o.map(([d])=>d);}return [I.SET,t]}),i$1.registerDecoder(I.JSON,e=>(E(e.contents),JSON.parse(e.contents)),"JSON-encoded");function x(e){return f(e.contents),new Wtf8Decoder().decode(e.contents)}x.comment=e=>{f(e.contents);const r=new Wtf8Decoder;return `(WTF8 string): ${JSON.stringify(r.decode(e.contents))}`},i$1.registerDecoder(I.WTF8,x),i$1.registerDecoder(I.SELF_DESCRIBED,e=>e.contents,"Self-Described"),i$1.registerDecoder(I.INVALID_16,()=>{throw new Error(`Tag always invalid: ${I.INVALID_16}`)},"Invalid"),i$1.registerDecoder(I.INVALID_32,()=>{throw new Error(`Tag always invalid: ${I.INVALID_32}`)},"Invalid"),i$1.registerDecoder(I.INVALID_64,()=>{throw new Error(`Tag always invalid: ${I.INVALID_64}`)},"Invalid");function w(e){throw new Error(`Encoding ${e.constructor.name} intentionally unimplmented. It is not concrete enough to interoperate. Convert to Uint8Array first.`)}ce(ArrayBuffer,w),ce(DataView,w),typeof SharedArrayBuffer<"u"&&ce(SharedArrayBuffer,w);function m(e){return [NaN,e.valueOf()]}ce(Boolean,m),ce(Number,m),ce(String,m),ce(BigInt,m);
function c(i){const e={...w$1.defaultDecodeOptions};if(i.dcbor?Object.assign(e,w$1.dcborDecodeOptions):i.cde&&Object.assign(e,w$1.cdeDecodeOptions),Object.assign(e,i),Object.hasOwn(e,"rejectLongNumbers"))throw new TypeError("rejectLongNumbers has changed to requirePreferred");return e.boxed&&(e.saveOriginal=!0),e}class d{parent=void 0;ret=void 0;step(e,n,t){if(this.ret=w$1.create(e,this.parent,n,t),e[2]===N$2.BREAK)if(this.parent?.isStreaming)this.parent.left=0;else throw new Error("Unexpected BREAK");else this.parent&&this.parent.push(this.ret,t,e[3]);for(this.ret instanceof w$1&&(this.parent=this.ret);this.parent?.done;){this.ret=this.parent.convert(t);const r=this.parent.parent;r?.replaceLast(this.ret,this.parent,t),this.parent=r;}}}function l(i,e={}){const n=c(e),t=new y$2(i,n),r=new d;for(const o of t)r.step(o,n,t);return r.ret}
// SPDX-License-Identifier: MIT
class CardanoSeed extends Seed {
constructor(seed, options = {
cardanoType: Cardano.TYPES.BYRON_ICARUS
}) {
if (options.cardanoType && !Cardano.TYPES.isCardanoType(options.cardanoType)) {
throw new SeedError('Invalid Cardano type', {
expected: Cardano.TYPES.getCardanoTypes(), got: options.cardanoType
});
}
super(seed, options);
}
static getName() {
return 'Cardano';
}
getCardanoType() {
if (!this.options?.cardanoType) {
throw new SeedError('cardanoType is not found');
}
return this.options?.cardanoType;
}
static fromMnemonic(mnemonic, options = {
cardanoType: Cardano.TYPES.BYRON_ICARUS
}) {
switch (options.cardanoType) {
case Cardano.TYPES.BYRON_ICARUS:
return this.generateByronIcarus(mnemonic);
case Cardano.TYPES.BYRON_LEDGER:
return this.generateByronLedger(mnemonic, options.passphrase);
case Cardano.TYPES.BYRON_LEGACY:
return this.generateByronLegacy(mnemonic);
case Cardano.TYPES.SHELLEY_ICARUS:
return this.generateShelleyIcarus(mnemonic);
case Cardano.TYPES.SHELLEY_LEDGER:
return this.generateShelleyLedger(mnemonic, options.passphrase);
default:
throw new SeedError('Invalid Cardano type', {
expected: Cardano.TYPES.getCardanoTypes(), got: options.cardanoType
});
}
}
static generateByronIcarus(mnemonic) {
const phrase = typeof mnemonic === 'string' ? mnemonic : mnemonic.getMnemonic();
if (!BIP39Mnemonic.isValid(phrase)) {
throw new MnemonicError(`Invalid Cardano mnemonic words`);
}
return BIP39Mnemonic.decode(phrase);
}
static generateByronLedger(mnemonic, passphrase) {
const phrase = typeof mnemonic === 'string' ? mnemonic : mnemonic.getMnemonic();
return BIP39Seed.fromMnemonic(phrase, { passphrase: passphrase });
}
static generateByronLegacy(mnemonic) {
const phrase = typeof mnemonic === 'string' ? mnemonic : mnemonic.getMnemonic();
if (!BIP39Mnemonic.isValid(phrase)) {
throw new MnemonicError(`Invalid Cardano mnemonic words`);
}
const decoded = BIP39Mnemonic.decode(phrase);
const rawBytes = hexToBytes(decoded);
const cborBytes = Q(rawBytes);
const hash = blake2b256(cborBytes);
return bytesToString(hash);
}
static generateShelleyIcarus(mnemonic) {
return this.generateByronIcarus(mnemonic);
}
static generateShelleyLedger(mnemonic, passphrase) {
return this.generateByronLedger(mnemonic, passphrase);
}
}
// SPDX-License-Identifier: MIT
class ElectrumV1Seed extends Seed {
static hashIterationNumber = 10 ** 5;
static getName() {
return 'Electrum-V1';
}
static fromMnemonic(mnemonic) {
const phrase = typeof mnemonic === 'string' ? mnemonic : mnemonic.getMnemonic();
if (!ElectrumV1Mnemonic.isValid(phrase)) {
throw new MnemonicError(`Invalid ${this.getName()} mnemonic words`);
}
const entropy = ElectrumV1Mnemonic.decode(phrase);
const entropyBuffer = toBuffer(entropy, 'utf8');
let entropyHash = entropyBuffer;
for (let i = 0; i < this.hashIterationNumber; i++) {
entropyHash = sha256(concatBytes(entropyHash, entropyBuffer));
}
return bytesToString(entropyHash);
}
}
// SPDX-License-Identifier: MIT
class ElectrumV2Seed extends Seed {
static seedSaltModifier = 'electrum';
static seedPbkdf2Rounds = 2048;
static getName() {
return 'Electrum-V2';
}
static fromMnemonic(mnemonic, options = {
mnemonicType: ELECTRUM_V2_MNEMONIC_TYPES.STANDARD
}) {
const phrase = typeof mnemonic === 'string' ? mnemonic : mnemonic.getMnemonic();
if (!ElectrumV2Mnemonic.isValid(phrase, { mnemonicType: options.mnemonicType })) {
throw new MnemonicError(`Invalid ${this.getName()} mnemonic words`);
}
const saltBase = (this.seedSaltModifier + (options.passphrase ?? '')).normalize('NFKD');
const seedBytes = pbkdf2HmacSha512(phrase, saltBase, this.seedPbkdf2Rounds);
return bytesToString(seedBytes);
}
getMnemonicType() {
if (!this.options?.mnemonicType) {
throw new SeedError('mnemonicType is not found');
}
return this.options?.mnemonicType;
}
}
// SPDX-License-Identifier: MIT
class MoneroSeed extends Seed {
static getName() {
return 'Monero';
}
static fromMnemonic(mnemonic) {
const phrase = typeof mnemonic === 'string' ? mnemonic : mnemonic.getMnemonic();
if (!MoneroMnemonic.isValid(phrase)) {
throw new MnemonicError(`Invalid ${this.getName()} mnemonic words`);
}
return MoneroMnemonic.decode(phrase);
}
}
// SPDX-License-Identifier: MIT
class SEEDS {
static dictionary = {
[AlgorandSeed.getName()]: AlgorandSeed,
[BIP39Seed.getName()]: BIP39Seed,
[CardanoSeed.getName()]: CardanoSeed,
[ElectrumV1Seed.getName()]: ElectrumV1Seed,
[ElectrumV2Seed.getName()]: ElectrumV2Seed,
[MoneroSeed.getName()]: MoneroSeed
};
static getNames() {
return Object.keys(this.dictionary);
}
static getClasses() {
return Object.values(this.dictionary);
}
static getSeedClass(name) {
if (!this.isSeed(name)) {
throw new SeedError('Invalid seed name', { expected: this.getNames(), got: name });
}
return this.dictionary[name];
}
static isSeed(name) {
return this.getNames().includes(name);
}
}
var seeds = /*#__PURE__*/Object.freeze({
__proto__: null,
SEEDS: SEEDS,
Seed: Seed,
AlgorandSeed: AlgorandSeed,
BIP39Seed: BIP39Seed,
CardanoSeed: CardanoSeed,
ElectrumV1Seed: ElectrumV1Seed,
ElectrumV2Seed: ElectrumV2Seed,
MoneroSeed: MoneroSeed
});
// SPDX-License-Identifier: MIT
class Derivation {
path;
indexes;
derivations;
purpose = [0, true];
constructor(options = {}) {
const [path, indexes, derivations] = normalizeDerivation(options?.path, options?.indexes);
this.derivations = derivations;
this.indexes = indexes;
this.path = path;
}
static getName() {
throw new Error('Must override getName()');
}
getName() {
return this.constructor.getName();
}
clean() {
throw new Error('Must override clean()');
}
getPath() {
return this.path;
}
getIndexes() {
return this.indexes;
}
getDerivations() {
return this.derivations;
}
getDepth() {
return this.derivations.length;
}
getPurpose() {
throw new Error('Must override getPurpose()');
}
getCoinType() {
throw new Error('Must override getCoinType()');
}
getAccount() {
throw new Error('Must override getAccount()');
}
getChange(...args) {
throw new Error('Must override getChange()');
}
getRole(...args) {
throw new Error('Must override getRole()');
}
getAddress() {
throw new Error('Must override getAddress()');
}
getMinor() {
throw new Error('Must override getMinor()');
}
getMajor() {
throw new Error('Must override getMajor()');
}
}
// SPDX-License-Identifier: MIT
class CustomDerivation extends Derivation {
static getName() {
return 'Custom';
}
fromPath(path) {
if (!path.startsWith('m/')) {
throw new DerivationError('Bad path format', { expected: "like this type of path \'m/0'/0\'", got: path });
}
const [_path, indexes, derivations] = normalizeDerivation(path, undefined);
this.derivations = derivations;
this.indexes = indexes;
this.path = _path;
return this;
}
fromIndexes(indexes) {
const [path, _indexes, derivations] = normalizeDerivation(undefined, indexes);
this.derivations = derivations;
this.indexes = _indexes;
this.path = path;
return this;
}
fromIndex(index, hardened = false) {
const path = hardened ? `${index}'` : `${index}`;
return this.fromPath(this.path === 'm/' ? `${this.path}${path}` : `${this.path}/${path}`);
}
clean() {
const [path, indexes, derivations] = normalizeDerivation(undefined, undefined);
this.derivations = derivations;
this.indexes = indexes;
this.path = path;
return this;
}
}
// SPDX-License-Identifier: MIT
const CHANGES = {
EXTERNAL_CHAIN: 'external-chain',
INTERNAL_CHAIN: 'internal-chain'
};
class BIP44Derivation extends Derivation {
purpose = [44, true];
coinType;
account;
change;
address;
constructor(options = {
coinType: Bitcoin.COIN_TYPE, account: 0, change: CHANGES.EXTERNAL_CHAIN, address: 0
}) {
super(options);
this.coinType = normalizeIndex(options.coinType ?? Bitcoin.COIN_TYPE, true);
this.account = normalizeIndex(options.account ?? 0, true);
this.change = normalizeIndex(this.getChangeValue(options.change ?? CHANGES.EXTERNAL_CHAIN), false);
this.address = normalizeIndex(options.address ?? 0, false);
this.updateDerivation();
}
static getName() {
return 'BIP44';
}
getChangeValue(change, nameOnly = false) {
if (Array.isArray(change)) {
throw new DerivationError('Bad change instance', {
expected: 'number | string', got: typeof change
});
}
const externalChange = [CHANGES.EXTERNAL_CHAIN, 0, '0'];
const internalChange = [CHANGES.INTERNAL_CHAIN, 1, '1'];
const exceptedChange = [
...externalChange, ...internalChange
];
if (!exceptedChange.includes(change)) {
throw new DerivationError(`Bad ${this.getName()} change index`, {
expected: exceptedChange, got: change
});
}
if (externalChange.includes(change))
return nameOnly ? CHANGES.EXTERNAL_CHAIN : 0;
if (internalChange.includes(change))
return nameOnly ? CHANGES.INTERNAL_CHAIN : 1;
}
updateDerivation() {
const [path, indexes, derivations] = normalizeDerivation(`m/${indexTupleToString(this.purpose)}/` +
`${indexTupleToString(this.coinType)}/` +
`${indexTupleToString(this.account)}/` +
`${indexTupleToString(this.change)}/` +
`${indexTupleToString(this.address)}`);
this.derivations = derivations;
this.indexes = indexes;
this.path = path;
}
fromCoinType(coinType) {
this.coinType = normalizeIndex(coinType, true);
this.updateDerivation();
return this;
}
fromAccount(account) {
this.account = normalizeIndex(account, true);
this.updateDerivation();
return this;
}
fromChange(change) {
this.change = normalizeIndex(this.getChangeValue(change), false);
this.updateDerivation();
return this;
}
fromAddress(address) {
this.address = normalizeIndex(address, false);
this.updateDerivation();
return this;
}
clean() {
this.account = normalizeIndex(0, true);
this.change = normalizeIndex(this.getChangeValue(CHANGES.EXTERNAL_CHAIN), false);
this.address = normalizeIndex(0, false);
this.updateDerivation();
return this;
}
getPurpose() {
return this.purpose[0];
}
getCoinType() {
return this.coinType[0];
}
getAccount() {
return this.account.length === 3 ? this.account[1] : this.account[0];
}
getChange(nameOnly = true) {
return this.getChangeValue(this.change[0], nameOnly);
}
getAddress() {
return this.address.length === 3 ? this.address[1] : this.address[0];
}
}
// SPDX-License-Identifier: MIT
class BIP49Derivation extends BIP44Derivation {
purpose = [49, true];
constructor(options = {
coinType: Bitcoin.COIN_TYPE, account: 0, change: CHANGES.EXTERNAL_CHAIN, address: 0
}) {
super(options);
this.updateDerivation();
}
static getName() {
return 'BIP49';
}
}
// SPDX-License-Identifier: MIT
class BIP84Derivation extends BIP44Derivation {
purpose = [84, true];
constructor(options = {
coinType: Bitcoin.COIN_TYPE, account: 0, change: CHANGES.EXTERNAL_CHAIN, address: 0
}) {
super(options);
this.updateDerivation();
}
static getName() {
return 'BIP84';
}
}
// SPDX-License-Identifier: MIT
class BIP86Derivation extends BIP44Derivation {
purpose = [86, true];
constructor(options = {
coinType: Bitcoin.COIN_TYPE, account: 0, change: CHANGES.EXTERNAL_CHAIN, address: 0
}) {
super(options);
this.updateDerivation();
}
static getName() {
return 'BIP86';
}
}
// SPDX-License-Identifier: MIT
const ROLES = {
EXTERNAL_CHAIN: 'external-chain',
INTERNAL_CHAIN: 'internal-chain',
STAKING_KEY: 'staking-key'
};
class CIP1852Derivation extends Derivation {
purpose = [1852, true];
coinType;
account;
role;
address;
constructor(options = {
coinType: Cardano.COIN_TYPE, account: 0, role: ROLES.EXTERNAL_CHAIN, address: 0
}) {
super(options);
this.coinType = normalizeIndex(options.coinType ?? Cardano.COIN_TYPE, true);
this.account = normalizeIndex(options.account ?? 0, true);
this.role = normalizeIndex(this.getRoleValue(options.role ?? ROLES.EXTERNAL_CHAIN), false);
this.address = normalizeIndex(options.address ?? 0, false);
this.updateDerivation();
}
static getName() {
return 'CIP1852';
}
getRoleValue(role, nameOnly = false) {
if (Array.isArray(role)) {
throw new DerivationError('Bad role instance', {
expected: 'number | string', got: typeof role
});
}
const externalChange = [ROLES.EXTERNAL_CHAIN, 0, '0'];
const internalChange = [ROLES.INTERNAL_CHAIN, 1, '1'];
const stakingKey = [ROLES.STAKING_KEY, 2, '2'];
const exceptedRole = [
...externalChange, ...internalChange, ...stakingKey
];
if (!exceptedRole.includes(role)) {
throw new DerivationError(`Bad ${this.getName()} role index`, {
expected: exceptedRole, got: role
});
}
if (externalChange.includes(role))
return nameOnly ? ROLES.EXTERNAL_CHAIN : 0;
if (internalChange.includes(role))
return nameOnly ? ROLES.INTERNAL_CHAIN : 1;
if (stakingKey.includes(role))
return nameOnly ? ROLES.STAKING_KEY : 2;
}
updateDerivation() {
const [path, indexes, derivations] = normalizeDerivation(`m/${indexTupleToString(this.purpose)}/` +
`${indexTupleToString(this.coinType)}/` +
`${indexTupleToString(this.account)}/` +
`${indexTupleToString(this.role)}/` +
`${indexTupleToString(this.address)}`);
this.derivations = derivations;
this.indexes = indexes;
this.path = path;
}
fromCoinType(coinType) {
this.coinType = normalizeIndex(coinType, true);
this.updateDerivation();
return this;
}
fromAccount(account) {
this.account = normalizeIndex(account, true);
this.updateDerivation();
return this;
}
fromRole(role) {
this.role = normalizeIndex(this.getRoleValue(role), false);
this.updateDerivation();
return this;
}
fromAddress(address) {
this.address = normalizeIndex(address, false);
this.updateDerivation();
return this;
}
clean() {
this.coinType = normalizeIndex(Cardano.COIN_TYPE, true);
this.account = normalizeIndex(0, true);
this.role = normalizeIndex(this.getRoleValue(ROLES.EXTERNAL_CHAIN), false);
this.address = normalizeIndex(0, false);
this.updateDerivation();
return this;
}
getPurpose() {
return this.purpose[0];
}
getCoinType() {
return this.coinType[0];
}
getAccount() {
return this.account.length === 3 ? this.account[1] : this.account[0];
}
getRole(nameOnly = true) {
return this.getRoleValue(this.role[0], nameOnly);
}
getAddress() {
return this.address.length === 3 ? this.address[1] : this.address[0];
}
}
// SPDX-License-Identifier: MIT
class ElectrumDerivation extends Derivation {
change;
address;
constructor(options = {
change: 0, address: 0
}) {
super(options);
this.change = normalizeIndex(options.change ?? 0, false);
this.address = normalizeIndex(options.address ?? 0, false);
this.updateDerivation();
}
static getName() {
return 'Electrum';
}
updateDerivation() {
const [path, indexes, derivations] = normalizeDerivation(`m/${indexTupleToString(this.change)}/` +
`${indexTupleToString(this.address)}`);
this.derivations = derivations;
this.indexes = indexes;
this.path = path;
}
fromChange(change) {
this.change = normalizeIndex(change, false);
this.updateDerivation();
return this;
}
fromAddress(address) {
this.address = normalizeIndex(address, false);
this.updateDerivation();
return this;
}
clean() {
this.change = normalizeIndex(0, false);
this.address = normalizeIndex(0, false);
this.updateDerivation();
return this;
}
getChange() {
return this.change.length === 3 ? this.change[1] : this.change[0];
}
getAddress() {
return this.address.length === 3 ? this.address[1] : this.address[0];
}
}
// SPDX-License-Identifier: MIT
class MoneroDerivation extends Derivation {
minor;
major;
constructor(options = {
minor: 1, major: 0
}) {
super(options);
this.minor = normalizeIndex(options.minor ?? 0, false);
this.major = normalizeIndex(options.major ?? 0, false);
this.updateDerivation();
}
static getName() {
return 'Monero';
}
updateDerivation() {
const [path, indexes, derivations] = normalizeDerivation(`m/${indexTupleToString(this.minor)}/` +
`${indexTupleToString(this.major)}`);
this.derivations = derivations;
this.indexes = indexes;
this.path = path;
}
fromMinor(minor) {
this.minor = normalizeIndex(minor, false);
this.updateDerivation();
return this;
}
fromMajor(major) {
this.major = normalizeIndex(major, false);
this.updateDerivation();
return this;
}
clean() {
this.minor = normalizeIndex(1, false);
this.major = normalizeIndex(0, false);
this.updateDerivation();
return this;
}
getMinor() {
return this.minor.length === 3 ? this.minor[1] : this.minor[0];
}
getMajor() {
return this.major.length === 3 ? this.major[1] : this.major[0];
}
}
// SPDX-License-Identifier: MIT
class HDWDerivation extends Derivation {
account;
ecc;
address;
constructor(options = {
account: 0, ecc: SLIP10Secp256k1ECC, address: 0
}) {
super(options);
this.account = normalizeIndex(options.account ?? 0, true);
this.ecc = normalizeIndex(this.getECCValue(options.ecc ?? SLIP10Secp256k1ECC), false);
this.address = normalizeIndex(options.address ?? 0, false);
this.updateDerivation();
}
static getName() {
return 'HDW';
}
getECCValue(ecc, nameOnly = false) {
const { value, isValid } = ensureTypeMatch(ecc, EllipticCurveCryptography, { otherTypes: ['string', 'number'] });
const curve = isValid ? value.NAME : ecc;
const slip10Secp256k1 = [SLIP10Secp256k1ECC.NAME, 0, '0'];
const slip10Ed25519 = [SLIP10Ed25519ECC.NAME, 1, '1'];
const slip10Nist256p1 = [SLIP10Nist256p1ECC.NAME, 2, '2'];
const kholawEd25519 = [KholawEd25519ECC.NAME, 3, '3'];
const slip10Ed25519Blake2b = [SLIP10Ed25519Blake2bECC.NAME, 4, '4'];
const slip10Ed25519Monero = [SLIP10Ed25519MoneroECC.NAME, 5, '5'];
const exceptedECC = [
...slip10Secp256k1, ...slip10Ed25519, ...slip10Nist256p1,
...kholawEd25519, ...slip10Ed25519Blake2b, ...slip10Ed25519Monero
];
if (!exceptedECC.includes(curve)) {
throw new DerivationError(`Bad ${this.getName()} ECC index`, {
expected: exceptedECC, got: curve
});
}
if (slip10Secp256k1.includes(curve))
return nameOnly ? SLIP10Secp256k1ECC.NAME : 0;
if (slip10Ed25519.includes(curve))
return nameOnly ? SLIP10Ed25519ECC.NAME : 1;
if (slip10Nist256p1.includes(curve))
return nameOnly ? SLIP10Nist256p1ECC.NAME : 2;
if (kholawEd25519.includes(curve))
return nameOnly ? KholawEd25519ECC.NAME : 3;
if (slip10Ed25519Blake2b.includes(curve))
return nameOnly ? SLIP10Ed25519Blake2bECC.NAME : 4;
if (slip10Ed25519Monero.includes(curve))
return nameOnly ? SLIP10Ed25519MoneroECC.NAME : 5;
}
updateDerivation() {
const [path, indexes, derivations] = normalizeDerivation(`m/${indexTupleToString(this.account)}/` +
`${indexTupleToString(this.ecc)}/` +
`${indexTupleToString(this.address)}`);
this.derivations = derivations;
this.indexes = indexes;
this.path = path;
}
fromAccount(account) {
this.account = normalizeIndex(account, true);
this.updateDerivation();
return this;
}
fromECC(ecc) {
this.ecc = normalizeIndex(this.getECCValue(ecc), false);
this.updateDerivation();
return this;
}
fromAddress(address) {
this.address = normalizeIndex(address, false);
this.updateDerivation();
return this;
}
clean() {
this.account = normalizeIndex(0, true);
this.ecc = normalizeIndex(this.getECCValue(SLIP10Secp256k1ECC), false);
this.address = normalizeIndex(0, false);
this.updateDerivation();
return this;
}
getAccount() {
return this.account.length === 3 ? this.account[1] : this.account[0];
}
getECC(nameOnly = true) {
return this.getECCValue(this.ecc[0], nameOnly);
}
getAddress() {
return this.address.length === 3 ? this.address[1] : this.address[0];
}
}
// SPDX-License-Identifier: MIT
class DERIVATIONS {
static dictionary = {
[CustomDerivation.getName()]: CustomDerivation,
[BIP44Derivation.getName()]: BIP44Derivation,
[BIP49Derivation.getName()]: BIP49Derivation,
[BIP84Derivation.getName()]: BIP84Derivation,
[BIP86Derivation.getName()]: BIP86Derivation,
[CIP1852Derivation.getName()]: CIP1852Derivation,
[ElectrumDerivation.getName()]: ElectrumDerivation,
[MoneroDerivation.getName()]: MoneroDerivation,
[HDWDerivation.getName()]: HDWDerivation
};
static getNames() {
return Object.keys(this.dictionary);
}
static getClasses() {
return Object.values(this.dictionary);
}
static getDerivationClass(name) {
if (!this.isDerivation(name)) {
throw new DerivationError('Invalid derivation name', { expected: this.getNames(), got: name });
}
return this.dictionary[name];
}
static isDerivation(name) {
return this.dictionary.hasOwnProperty(name);
}
}
var derivations = /*#__PURE__*/Object.freeze({
__proto__: null,
DERIVATIONS: DERIVATIONS,
Derivation: Derivation,
CustomDerivation: CustomDerivation,
BIP44Derivation: BIP44Derivation,
CHANGES: CHANGES,
BIP49Derivation: BIP49Derivation,
BIP84Derivation: BIP84Derivation,
BIP86Derivation: BIP86Derivation,
CIP1852Derivation: CIP1852Derivation,
ROLES: ROLES,
ElectrumDerivation: ElectrumDerivation,
MoneroDerivation: MoneroDerivation,
HDWDerivation: HDWDerivation
});
// SPDX-License-Identifier: MIT
class HD {
ecc;
derivation;
constructor(options = {}) {
if (!options.ecc) {
throw new ECCError('Elliptic Curve Cryptography (ECC) is required');
}
this.ecc = options.ecc;
}
static getName() {
throw new Error('Must override getName()');
}
getName() {
return this.constructor.getName();
}
fromSeed(...args) {
throw new Error('Not implemented');
}
fromXPrivateKey(...args) {
throw new Error('Not implemented');
}
fromXPublicKey(...args) {
throw new Error('Not implemented');
}
fromWIF(wif) {
throw new Error('Not implemented');
}
fromPrivateKey(privateKey) {
throw new Error('Not implemented');
}
fromSpendPrivateKey(spendPrivateKey) {
throw new Error('Not implemented');
}
fromPublicKey(publicKey) {
throw new Error('Not implemented');
}
fromWatchOnly(viewPrivateKey, spendPublicKey) {
throw new Error('Not implemented');
}
fromDerivation(derivation) {
throw new Error('Not implemented');
}
updateDerivation(derivation) {
throw new Error('Not implemented');
}
cleanDerivation() {
throw new Error('Not implemented');
}
getDerivation() {
return this.derivation;
}
getSeed() {
throw new Error('Not implemented');
}
getSemantic() {
return null;
}
getRootXPrivateKey(...args) {
throw new Error('Not implemented');
}
getRootXPublicKey(...args) {
throw new Error('Not implemented');
}
getMasterXPrivateKey(...args) {
return this.getRootXPrivateKey(...args);
}
getMasterXPublicKey(...args) {
return this.getRootXPublicKey(...args);
}
getRootPrivateKey(...args) {
throw new Error('Not implemented');
}
getRootWIF(...args) {
throw new Error('Not implemented');
}
getRootChainCode() {
throw new Error('Not implemented');
}
getRootPublicKey(...args) {
throw new Error('Not implemented');
}
getMasterPrivateKey(...args) {
throw new Error('Not implemented');
}
getMasterWIF(...args) {
throw new Error('Not implemented');
}
getMasterChainCode(...args) {
return this.getRootChainCode();
}
getMasterPublicKey(...args) {
throw new Error('Not implemented');
}
getXPrivateKey(...args) {
throw new Error('Not implemented');
}
getXPublicKey(...args) {
throw new Error('Not implemented');
}
getPrivateKey(...args) {
throw new Error('Not implemented');
}
getStrict() {
throw new Error('Not implemented');
}
getSpendPrivateKey() {
throw new Error('Not implemented');
}
getViewPrivateKey() {
throw new Error('Not implemented');
}
getWIF(..._args) {
throw new Error('Not implemented');
}
getWIFType() {
throw new Error('Not implemented');
}
getChainCode() {
throw new Error('Not implemented');
}
getPublicKey(...args) {
throw new Error('Not implemented');
}
getCompressed() {
throw new Error('Not implemented');
}
getUncompressed() {
throw new Error('Not implemented');
}
getSpendPublicKey() {
throw new Error('Not implemented');
}
getViewPublicKey() {
throw new Error('Not implemented');
}
getPublicKeyType() {
throw new Error('Not implemented');
}
getMode() {
throw new Error('Not implemented');
}
getHash() {
throw new Error('Not implemented');
}
getFingerprint() {
throw new Error('Not implemented');
}
getParentFingerprint() {
throw new Error('Not implemented');
}
getDepth() {
throw new Error('Not implemented');
}
getPath() {
throw new Error('Not implemented');
}
getPathKey() {
return null;
}
getIndex() {
throw new Error('Not implemented');
}
getIndexes() {
throw new Error('Not implemented');
}
getIntegratedAddress(...args) {
throw new Error('Not implemented');
}
getPrimaryAddress(...args) {
throw new Error('Not implemented');
}
getSubAddress(...args) {
throw new Error('Not implemented');
}
getAddress(...args) {
throw new Error('Not implemented');
}
}
// SPDX-License-Identifier: MIT
class Address {
static getName() {
throw new Error('Address.getName() not implemented');
}
static encode(publicKey, options) {
throw new Error('Address.encode() not implemented');
}
static decode(address, options) {
throw new Error('Address.decode() not implemented');
}
}
// SPDX-License-Identifier: MIT
function encode$1(data, alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz') {
const buf = typeof data === 'string' ? hexToBytes(data) : data;
let val = stringToInteger(buf);
const base = BigInt(alphabet.length);
let enc = '';
// convert to Base58 digits
while (val >= base) {
const mod = Number(val % base);
enc = alphabet[mod] + enc;
val = val / base;
}
if (val > BigInt(0)) {
enc = alphabet[Number(val)] + enc;
}
// preserve leading zero bytes
let leading = 0;
for (const b of buf) {
if (b === 0)
leading++;
else
break;
}
return alphabet[0].repeat(leading) + enc;
}
function checkEncode(raw, alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz') {
const buf = typeof raw === 'string' ? hexToBytes(raw) : raw;
const hash1 = sha256(buf);
const hash2 = sha256(hash1);
const chk = hash2.slice(0, 4); // first 4 bytes
const payload = concatBytes(buf, chk);
return encode$1(payload, alphabet);
}
function decode$1(input, alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz') {
let val = BigInt(0);
let prefixZeros = 0;
// for each Base58 character, accumulate into a big integer
for (const char of input) {
const idx = alphabet.indexOf(char);
if (idx < 0) {
throw new Error(`Invalid Base58 character '${char}'`);
}
val = val * BigInt(alphabet.length) + BigInt(idx);
if (val === BigInt(0)) {
prefixZeros++;
}
}
// convert big integer into bytes (big-endian)
const outBytes = [];
while (val > BigInt(0)) {
const mod = Number(val % BigInt(256));
outBytes.push(mod);
val = val / BigInt(256);
}
// restore leading zero bytes
for (let i = 0; i < prefixZeros; i++) {
outBytes.push(0);
}
return new Uint8Array(outBytes.reverse());
}
function checkDecode(enc, alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz') {
const full = decode$1(enc, alphabet);
if (full.length < 5) {
throw new Error('Input too short for Base58Check');
}
const raw = full.slice(0, full.length - 4);
const chk = full.slice(full.length - 4);
const hash1 = sha256(raw);
const hash2 = sha256(hash1);
const expected = hash2.slice(0, 4);
if (!equalBytes(chk, expected)) {
throw new Error('Base58Check checksum failed');
}
return raw;
}
function pad$1(enc, padLen, alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz') {
return enc.padStart(padLen, alphabet[0]);
}
function encodeMonero(data) {
const blockEncLen = 11;
const blockDecLen = 8;
// sizes[k] = encoded length for a k-byte block
const sizes = [0, 2, 3, 5, 6, 7, 9, 10, 11];
const buf = data;
const fullBlocks = Math.floor(buf.length / blockDecLen);
const lastLen = buf.length % blockDecLen;
let out = '';
for (let i = 0; i < fullBlocks; i++) {
const block = buf.slice(i * blockDecLen, (i + 1) * blockDecLen);
out += pad$1(encode$1(block), blockEncLen);
}
if (lastLen > 0) {
const block = buf.slice(fullBlocks * blockDecLen);
out += pad$1(encode$1(block), sizes[lastLen]);
}
return out;
}
function unpad(dec, unpadLen) {
return dec.slice(dec.length - unpadLen);
}
function decodeMonero(data) {
const blockEncLen = 11;
const blockDecLen = 8;
const sizes = [0, 2, 3, 5, 6, 7, 9, 10, 11];
const fullBlocks = Math.floor(data.length / blockEncLen);
const lastEncLen = data.length % blockEncLen;
const lastDecLen = sizes.indexOf(lastEncLen);
const out = [];
for (let i = 0; i < fullBlocks; i++) {
const chunk = data.slice(i * blockEncLen, (i + 1) * blockEncLen);
const dec = decode$1(chunk);
out.push(...unpad(dec, blockDecLen));
}
if (lastEncLen > 0) {
const chunk = data.slice(fullBlocks * blockEncLen);
const dec = decode$1(chunk);
out.push(...unpad(dec, lastDecLen));
}
return new Uint8Array(out);
}
// SPDX-License-Identifier: MIT
class P2PKHAddress extends Address {
static publicKeyAddressPrefix = Bitcoin.NETWORKS.MAINNET.PUBLIC_KEY_ADDRESS_PREFIX;
static alphabet = Bitcoin.PARAMS.ALPHABET;
static getName() {
return 'P2PKH';
}
static encode(publicKey, options = {
publicKeyAddressPrefix: this.publicKeyAddressPrefix,
publicKeyType: PUBLIC_KEY_TYPES.COMPRESSED,
alphabet: this.alphabet
}) {
const prefixValue = options.publicKeyAddressPrefix ?? this.publicKeyAddressPrefix;
const prefixBytes = integerToBytes(prefixValue);
const pk = validateAndGetPublicKey(publicKey, SLIP10Secp256k1PublicKey);
const rawPubBytes = options.publicKeyType === PUBLIC_KEY_TYPES.UNCOMPRESSED
? pk.getRawUncompressed() : pk.getRawCompressed();
const pubKeyHash = hash160(getBytes(rawPubBytes));
const payload = concatBytes(prefixBytes, pubKeyHash);
const alphabet = options.alphabet ?? this.alphabet;
return ensureString(checkEncode(payload, alphabet));
}
static decode(address, options = {
publicKeyAddressPrefix: this.publicKeyAddressPrefix,
alphabet: this.alphabet
}) {
const prefixValue = options.publicKeyAddressPrefix ?? this.publicKeyAddressPrefix;
const prefixBytes = getBytes(integerToBytes(prefixValue));
const alphabet = options.alphabet ?? this.alphabet;
const decoded = checkDecode(address, alphabet);
const expectedLen = prefixBytes.length + 20;
if (decoded.length !== expectedLen) {
throw new AddressError('Invalid length', { expected: expectedLen, got: decoded.length });
}
const gotPrefix = decoded.slice(0, prefixBytes.length);
if (!equalBytes(prefixBytes, gotPrefix)) {
throw new AddressError('Invalid prefix', { expected: bytesToHex(prefixBytes), got: bytesToHex(gotPrefix) });
}
const pubKeyHash = decoded.slice(prefixBytes.length);
return bytesToString(pubKeyHash);
}
}
// SPDX-License-Identifier: MIT
class P2SHAddress extends Address {
static scriptAddressPrefix = Bitcoin.NETWORKS.MAINNET.SCRIPT_ADDRESS_PREFIX;
static alphabet = Bitcoin.PARAMS.ALPHABET;
static getName() {
return 'P2SH';
}
static encode(publicKey, options = {
scriptAddressPrefix: this.scriptAddressPrefix,
publicKeyType: PUBLIC_KEY_TYPES.COMPRESSED,
alphabet: this.alphabet
}) {
const prefixValue = options.scriptAddressPrefix ?? this.scriptAddressPrefix;
const prefixBytes = integerToBytes(prefixValue);
const pk = validateAndGetPublicKey(publicKey, SLIP10Secp256k1PublicKey);
const rawBytes = options.publicKeyType === PUBLIC_KEY_TYPES.UNCOMPRESSED
? pk.getRawUncompressed() : pk.getRawCompressed();
const pubKeyHash = hash160(rawBytes);
const redeemScriptHex = '76a914' + bytesToString(pubKeyHash) + '88ac';
const redeemScript = getBytes(redeemScriptHex);
const scriptHash = hash160(redeemScript);
const payload = concatBytes(prefixBytes, scriptHash);
const alphabet = options.alphabet ?? this.alphabet;
return ensureString(checkEncode(payload, alphabet));
}
static decode(address, options = {
scriptAddressPrefix: this.scriptAddressPrefix,
alphabet: this.alphabet
}) {
const prefixValue = options.scriptAddressPrefix ?? this.scriptAddressPrefix;
const prefixBytes = getBytes(integerToBytes(prefixValue));
const alphabet = options.alphabet ?? this.alphabet;
const decoded = checkDecode(address, alphabet);
const expectedLen = prefixBytes.length + 20;
if (decoded.length !== expectedLen) {
throw new AddressError('Invalid length', { expected: expectedLen, got: decoded.length });
}
const gotPrefix = decoded.slice(0, prefixBytes.length);
if (!equalBytes(prefixBytes, gotPrefix)) {
throw new AddressError('Invalid prefix', { expected: bytesToHex(prefixBytes), got: bytesToHex(gotPrefix) });
}
const scriptHash = decoded.slice(prefixBytes.length);
return bytesToString(scriptHash);
}
}
// SPDX-License-Identifier: MIT
const CHARSET$1 = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';
const CHARSET_REV$1 = CHARSET$1
.split('')
.reduce((map, char, i) => ((map[char] = i), map), {});
function bech32Polymod$1(values) {
const GENERATOR = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3];
let chk = 1;
for (const value of values) {
const top = chk >>> 25;
chk = ((chk & 0x1ffffff) << 5) ^ value;
for (let i = 0; i < 5; i++) {
if ((top >>> i) & 1)
chk ^= GENERATOR[i];
}
}
return chk;
}
function bech32HrpExpand$1(hrp) {
return [
...hrp.split('').map(c => c.charCodeAt(0) >>> 5),
0,
...hrp.split('').map(c => c.charCodeAt(0) & 31)
];
}
function bech32CreateChecksum$1(hrp, data) {
const encoding = data[0] === 0 ? 1 : 0x2bc830a3;
const values = [...bech32HrpExpand$1(hrp), ...data];
const polymod = bech32Polymod$1([...values, 0, 0, 0, 0, 0, 0]) ^ encoding;
return Array.from({ length: 6 }, (_, i) => (polymod >>> (5 * (5 - i))) & 31);
}
function bech32VerifyChecksum$1(hrp, data) {
const encoding = data[0] === 0 ? 1 : 0x2bc830a3;
return bech32Polymod$1([...bech32HrpExpand$1(hrp), ...data]) === encoding;
}
function convertBits$1(data, fromBits, toBits, pad = true) {
let acc = 0;
let bits = 0;
const ret = [];
const maxv = (1 << toBits) - 1;
const maxAcc = (1 << (fromBits + toBits - 1)) - 1;
for (const value of data) {
if (value < 0 || (value >>> fromBits))
return null;
acc = ((acc << fromBits) | value) & maxAcc;
bits += fromBits;
while (bits >= toBits) {
bits -= toBits;
ret.push((acc >>> bits) & maxv);
}
}
if (pad) {
if (bits)
ret.push((acc << (toBits - bits)) & maxv);
}
else if (bits >= fromBits || ((acc << (toBits - bits)) & maxv)) {
return null;
}
return ret;
}
function baseBech32Encode$1(hrp, data) {
const combined = [...data, ...bech32CreateChecksum$1(hrp, data)];
return hrp + '1' + combined.map(d => CHARSET$1[d]).join('');
}
function baseBech32Decode$1(bech) {
if (bech.length > 90 ||
[...bech].some(x => x.charCodeAt(0) < 33 || x.charCodeAt(0) > 126) ||
(bech !== bech.toLowerCase() && bech !== bech.toUpperCase()))
return [null, null];
const lowered = bech.toLowerCase();
const pos = lowered.lastIndexOf('1');
if (pos < 1 || pos + 7 > lowered.length)
return [null, null];
const hrp = lowered.slice(0, pos);
const data = lowered.slice(pos + 1).split('').map(c => CHARSET_REV$1[c]);
// @ts-ignore
if (data.includes(undefined))
return [null, null];
if (!bech32VerifyChecksum$1(hrp, data))
return [null, null];
return [hrp, data.slice(0, -6)];
}
function segwitEncode(hrp, witver, witprog) {
const data = [witver, ...(convertBits$1([...witprog], 8, 5) ?? [])];
const ret = baseBech32Encode$1(hrp, data);
return segwitDecode(hrp, ret)[0] === null ? '' : ret;
}
function segwitDecode(hrp, addr) {
const [gotHrp, data] = baseBech32Decode$1(addr);
if (gotHrp !== hrp || !data || data.length < 1 || data[0] > 16)
return [null, null];
const decoded = convertBits$1(data.slice(1), 5, 8, false);
if (!decoded || decoded.length < 2 || decoded.length > 40)
return [null, null];
if (data[0] === 0 && decoded.length !== 20 && decoded.length !== 32)
return [null, null];
return [data[0], Uint8Array.from(decoded)];
}
// SPDX-License-Identifier: MIT
class P2TRAddress extends Address {
static hrp = Bitcoin.NETWORKS.MAINNET.HRP;
static fieldSize = BigInt(Bitcoin.PARAMS.FIELD_SIZE);
static tapTweakTagHash = getBytes(Bitcoin.PARAMS.TAP_TWEAK_SHA256);
static witnessVersion = Bitcoin.NETWORKS.MAINNET.WITNESS_VERSIONS.P2TR;
static getName() {
return 'P2TR';
}
static taggedHash(tag, data) {
const tagHash = typeof tag === 'string' ? sha256(tag) : tag;
return sha256(new Uint8Array([...tagHash, ...tagHash, ...data]));
}
static hashTapTweak(pubKey) {
const x = BigInt(pubKey.getPoint().getX());
return this.taggedHash(this.tapTweakTagHash, integerToBytes(x));
}
static liftX(pubKey) {
const p = this.fieldSize;
const x = BigInt(pubKey.getPoint().getX());
if (x >= p)
throw new Error('Unable to compute LiftX point');
const xCubed = this.modPow(x, BigInt(3), p);
const c = (xCubed + BigInt(7)) % p;
const y = this.modularSqrt(c, p);
const ySquared = this.modPow(y, BigInt(2), p);
if (ySquared !== c)
throw new Error('Unable to compute LiftX point');
const evenY = y % BigInt(2) === BigInt(0) ? y : p - y;
return SLIP10Secp256k1Point.fromCoordinates(x, evenY);
}
static tweakPublicKey(pubKey) {
const tweak = BigInt(bytesToInteger(this.hashTapTweak(pubKey)));
const lifted = this.liftX(pubKey);
const tweaked = lifted.add(SLIP10Secp256k1ECC.GENERATOR.multiply(tweak));
return integerToBytes(BigInt(tweaked.getX()));
}
static encode(publicKey, options = {
hrp: this.hrp,
witnessVersion: this.witnessVersion
}) {
const pubKey = validateAndGetPublicKey(publicKey, SLIP10Secp256k1PublicKey);
return segwitEncode(options.hrp ?? this.hrp, options.witnessVersion ?? this.witnessVersion, this.tweakPublicKey(pubKey));
}
static decode(address, options = { hrp: this.hrp }) {
const [witnessVersion, data] = segwitDecode(options.hrp ?? this.hrp, address);
const expectedLength = SLIP10Secp256k1PublicKey.getCompressedLength() - 1;
if (data?.length !== expectedLength) {
throw new Error(`Invalid length (expected: ${expectedLength}, got: ${data?.length})`);
}
if (witnessVersion !== this.witnessVersion) {
throw new Error(`Invalid witness version (expected: ${this.witnessVersion}, got: ${witnessVersion})`);
}
return bytesToString(data);
}
static modPow(base, exponent, modulus) {
if (modulus === BigInt(1))
return BigInt(0);
let result = BigInt(1);
base = base % modulus;
while (exponent > BigInt(0)) {
if (exponent % BigInt(2) === BigInt(1)) {
result = (result * base) % modulus;
}
exponent = exponent >> BigInt(1);
base = (base * base) % modulus;
}
return result;
}
static modularSqrt(a, p) {
const exponent = (p + BigInt(1)) / BigInt(4);
return this.modPow(a, exponent, p);
}
}
// SPDX-License-Identifier: MIT
class P2WPKHAddress extends Address {
static hrp = Bitcoin.NETWORKS.MAINNET.HRP;
static witnessVersion = Bitcoin.NETWORKS.MAINNET.WITNESS_VERSIONS.P2WPKH;
static getName() {
return 'P2WPKH';
}
static encode(publicKey, options = {
hrp: this.hrp,
publicKeyType: PUBLIC_KEY_TYPES.COMPRESSED,
witnessVersion: this.witnessVersion
}) {
const pk = validateAndGetPublicKey(publicKey, SLIP10Secp256k1PublicKey);
const rawPubBytes = options.publicKeyType === PUBLIC_KEY_TYPES.UNCOMPRESSED
? pk.getRawUncompressed() : pk.getRawCompressed();
const pubKeyHash = hash160(rawPubBytes);
const hrp = options.hrp ?? this.hrp;
const witnessVersion = options.witnessVersion ?? this.witnessVersion;
return ensureString(segwitEncode(hrp, witnessVersion, pubKeyHash));
}
static decode(address, options = { hrp: this.hrp }) {
const hrp = options.hrp ?? this.hrp;
const [witnessVersion, decoded] = segwitDecode(hrp, address);
if (!decoded) {
throw new AddressError('Invalid address decoding');
}
return bytesToString(decoded);
}
}
// SPDX-License-Identifier: MIT
class P2WPKHInP2SHAddress extends P2SHAddress {
static getName() {
return 'P2WPKH-In-P2SH';
}
static encode(publicKey, options = {
scriptAddressPrefix: this.scriptAddressPrefix,
publicKeyType: PUBLIC_KEY_TYPES.COMPRESSED,
alphabet: this.alphabet
}) {
const prefixValue = options.scriptAddressPrefix ?? this.scriptAddressPrefix;
const prefixBytes = integerToBytes(prefixValue);
const pk = validateAndGetPublicKey(publicKey, SLIP10Secp256k1PublicKey);
const rawPubBytes = options.publicKeyType === PUBLIC_KEY_TYPES.UNCOMPRESSED
? pk.getRawUncompressed() : pk.getRawCompressed();
const pubKeyHash = hash160(rawPubBytes);
const redeemScript = getBytes('0014' + bytesToString(pubKeyHash));
const scriptHash = hash160(redeemScript);
const alphabet = options.alphabet ?? this.alphabet;
return ensureString(checkEncode(concatBytes(prefixBytes, scriptHash), alphabet));
}
}
// SPDX-License-Identifier: MIT
class P2WSHAddress extends P2WPKHAddress {
static witnessVersion = Bitcoin.NETWORKS.MAINNET.WITNESS_VERSIONS.P2WSH;
static getName() {
return 'P2WSH';
}
static encode(publicKey, options = {
hrp: this.hrp,
publicKeyType: PUBLIC_KEY_TYPES.COMPRESSED,
witnessVersion: this.witnessVersion
}) {
const pk = validateAndGetPublicKey(publicKey, SLIP10Secp256k1PublicKey);
const rawPubBytes = options.publicKeyType === PUBLIC_KEY_TYPES.UNCOMPRESSED
? pk.getRawUncompressed() : pk.getRawCompressed();
const script = '5121' + bytesToString(rawPubBytes) + '51ae';
const scriptHash = sha256(getBytes(script));
const hrp = options.hrp ?? this.hrp;
const version = options.witnessVersion ?? this.witnessVersion;
return ensureString(segwitEncode(hrp, version, scriptHash));
}
}
// SPDX-License-Identifier: MIT
class P2WSHInP2SHAddress extends P2SHAddress {
static getName() {
return 'P2WSH-In-P2SH';
}
static encode(publicKey, options = {
scriptAddressPrefix: this.scriptAddressPrefix,
publicKeyType: PUBLIC_KEY_TYPES.COMPRESSED,
alphabet: this.alphabet
}) {
const prefixValue = options.scriptAddressPrefix ?? this.scriptAddressPrefix;
const prefixBytes = integerToBytes(prefixValue);
const pk = validateAndGetPublicKey(publicKey, SLIP10Secp256k1PublicKey);
const rawPubBytes = options.publicKeyType === PUBLIC_KEY_TYPES.UNCOMPRESSED
? pk.getRawUncompressed() : pk.getRawCompressed();
const redeemScript = getBytes('5121' + bytesToString(rawPubBytes) + '51ae');
const sha = sha256(redeemScript);
const witnessScript = getBytes('0020' + bytesToString(sha));
const scriptHash = hash160(witnessScript);
const alphabet = options.alphabet ?? this.alphabet;
return ensureString(checkEncode(concatBytes(prefixBytes, scriptHash), alphabet));
}
}
// SPDX-License-Identifier: MIT
class EthereumAddress extends Address {
static addressPrefix = Ethereum.PARAMS.ADDRESS_PREFIX;
static getName() {
return 'Ethereum';
}
static checksumEncode(address) {
let output = '';
const addressHash = bytesToString(keccak256(new TextEncoder().encode(address.toLowerCase())));
for (let i = 0; i < address.length; i++) {
output += parseInt(addressHash[i], 16) >= 8
? address[i].toUpperCase()
: address[i];
}
return output;
}
static encode(publicKey, options = {
skipChecksumEncode: false
}) {
const pk = validateAndGetPublicKey(publicKey, SLIP10Secp256k1PublicKey);
const pubKeyHash = bytesToString(keccak256(pk.getRawUncompressed().slice(1))).slice(-40);
return this.addressPrefix + (options.skipChecksumEncode ? pubKeyHash : this.checksumEncode(pubKeyHash));
}
static decode(address, options = {
skipChecksumEncode: false
}) {
const prefix = address.slice(0, this.addressPrefix.length);
if (prefix !== this.addressPrefix) {
throw new AddressError('Invalid address prefix', {
expected: this.addressPrefix,
got: prefix
});
}
const addressPart = address.slice(this.addressPrefix.length);
if (addressPart.length !== 40) {
throw new AddressError('Invalid length', {
expected: 40,
got: addressPart.length
});
}
if (!options.skipChecksumEncode && addressPart !== this.checksumEncode(addressPart)) {
throw new AddressError('Invalid checksum encode', {
expected: this.checksumEncode(addressPart),
got: addressPart
});
}
return addressPart.toLowerCase();
}
}
// SPDX-License-Identifier: MIT
const CHARSET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';
const CHARSET_REV = Object.fromEntries(CHARSET.split('').map((c, i) => [c, i]));
function bech32Polymod(values) {
const GENERATOR = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3];
let chk = 1;
for (const value of values) {
const top = chk >>> 25;
chk = ((chk & 0x1ffffff) << 5) ^ value;
for (let i = 0; i < 5; i++) {
chk ^= (top >> i) & 1 ? GENERATOR[i] : 0;
}
}
return chk;
}
function bech32HrpExpand(hrp) {
const hrpChars = hrp.split('').map(c => c.charCodeAt(0));
return [
...hrpChars.map(c => c >> 5),
0,
...hrpChars.map(c => c & 31)
];
}
function bech32CreateChecksum(hrp, data) {
const values = [...bech32HrpExpand(hrp), ...data];
const polymod = bech32Polymod([...values, 0, 0, 0, 0, 0, 0]) ^ 1;
return Array.from({ length: 6 }, (_, i) => (polymod >> (5 * (5 - i))) & 31);
}
function bech32VerifyChecksum(hrp, data) {
return bech32Polymod([...bech32HrpExpand(hrp), ...data]) === 1;
}
function baseBech32Encode(hrp, data) {
const combined = [...data, ...bech32CreateChecksum(hrp, data)];
return hrp + '1' + combined.map(d => CHARSET[d]).join('');
}
function baseBech32Decode(bech) {
if ([...bech].some(c => c.charCodeAt(0) < 33 || c.charCodeAt(0) > 126) ||
(bech.toLowerCase() !== bech && bech.toUpperCase() !== bech)) {
return [null, null];
}
bech = bech.toLowerCase();
const pos = bech.lastIndexOf('1');
if (pos < 1 || pos + 7 > bech.length || pos + 1 >= bech.length) {
return [null, null];
}
const hrp = bech.slice(0, pos);
const dataPart = bech.slice(pos + 1);
const data = [];
for (const c of dataPart) {
const val = CHARSET_REV[c];
if (val === undefined)
return [null, null];
data.push(val);
}
if (!bech32VerifyChecksum(hrp, data)) {
return [null, null];
}
return [hrp, data.slice(0, -6)];
}
function convertBits(data, fromBits, toBits, pad = true) {
let acc = 0;
let bits = 0;
const ret = [];
const maxv = (1 << toBits) - 1;
const maxAcc = (1 << (fromBits + toBits - 1)) - 1;
for (const value of data) {
if (value < 0 || value >> fromBits)
return null;
acc = ((acc << fromBits) | value) & maxAcc;
bits += fromBits;
while (bits >= toBits) {
bits -= toBits;
ret.push((acc >> bits) & maxv);
}
}
if (pad) {
if (bits)
ret.push((acc << (toBits - bits)) & maxv);
}
else if (bits >= fromBits || ((acc << (toBits - bits)) & maxv)) {
return null;
}
return ret;
}
// Final export: exposed API for encoding/decoding Bech32
function bech32Encode(hrp, witprog) {
const data = convertBits([...witprog], 8, 5);
if (!data) {
throw new Error('bech32Encode: Failed to convert bits from 8 to 5');
}
const ret = baseBech32Encode(hrp, data);
const [decodedHrp, decodedData] = baseBech32Decode(ret);
if (decodedHrp !== hrp ||
decodedData === null ||
decodedData.length !== data.length ||
!decodedData.every((v, i) => v === data[i])) {
throw new Error('bech32Encode: Sanity check failed after encoding');
}
return ret;
}
function bech32Decode(expectedHrp, addr) {
const [hrp, data] = baseBech32Decode(addr);
if (hrp !== expectedHrp || !data || data.length === 0) {
throw new Error('bech32Decode: Invalid HRP or data format');
}
const decoded = convertBits(data, 5, 8, false);
if (!decoded) {
throw new Error('bech32Decode: Failed to convert bits from 5 to 8');
}
return [hrp, new Uint8Array(decoded)];
}
// SPDX-License-Identifier: MIT
class CosmosAddress extends Address {
static hrp = Cosmos.NETWORKS.MAINNET.HRP;
static getName() {
return 'Cosmos';
}
static encode(publicKey, options = {
hrp: this.hrp
}) {
const pk = validateAndGetPublicKey(publicKey, SLIP10Secp256k1PublicKey);
const hash = ripemd160(sha256(pk.getRawCompressed()));
const hrp = options.hrp ?? this.hrp;
const encoded = bech32Encode(hrp, hash);
if (encoded === null) {
throw new AddressError('Failed to encode Bech32 address');
}
return encoded;
}
static decode(address, options = {
hrp: this.hrp
}) {
const hrp = options.hrp ?? this.hrp;
const [gotHrp, decoded] = bech32Decode(hrp, address);
if (typeof gotHrp !== 'string' || gotHrp !== hrp) {
throw new AddressError('Invalid HRP prefix or decode failure', {
expected: hrp, got: gotHrp
});
}
return bytesToString(decoded);
}
}
// SPDX-License-Identifier: MIT
class XinFinAddress extends EthereumAddress {
static addressPrefix = XinFin.PARAMS.ADDRESS_PREFIX;
static getName() {
return 'XinFin';
}
}
// SPDX-License-Identifier: MIT
class TronAddress extends Address {
static publicKeyAddressPrefix = Tron.NETWORKS.MAINNET.PUBLIC_KEY_ADDRESS_PREFIX;
static alphabet = Tron.PARAMS.ALPHABET;
static getName() {
return 'Tron';
}
static encode(publicKey, options = {
publicKeyAddressPrefix: this.publicKeyAddressPrefix,
alphabet: this.alphabet
}) {
const pk = validateAndGetPublicKey(publicKey, SLIP10Secp256k1PublicKey);
const addressHash = bytesToString(keccak256(pk.getRawUncompressed().slice(1))).slice(-40); // last 20 bytes
const prefixBytes = integerToBytes(options.publicKeyAddressPrefix ?? this.publicKeyAddressPrefix);
const alphabet = options.alphabet ?? this.alphabet;
const payload = concatBytes(prefixBytes, hexToBytes(addressHash));
return ensureString(checkEncode(payload, alphabet));
}
static decode(address, options = {
publicKeyAddressPrefix: this.publicKeyAddressPrefix,
alphabet: this.alphabet
}) {
const alphabet = options.alphabet ?? this.alphabet;
const decoded = checkDecode(address, alphabet);
const prefixValue = integerToBytes(options.publicKeyAddressPrefix ?? this.publicKeyAddressPrefix);
const prefixBytes = getBytes(prefixValue);
const expectedLength = 20 + prefixBytes.length;
if (decoded.length !== expectedLength) {
throw new AddressError('Invalid length', {
expected: expectedLength, got: decoded.length
});
}
const prefixGot = decoded.slice(0, prefixBytes.length);
if (!equalBytes(prefixGot, prefixBytes)) {
throw new AddressError('Invalid prefix', {
expected: bytesToHex(prefixBytes), got: bytesToHex(prefixGot)
});
}
return bytesToString(decoded.slice(prefixBytes.length));
}
}
// SPDX-License-Identifier: MIT
class RippleAddress extends P2PKHAddress {
static alphabet = Ripple.PARAMS.ALPHABET;
static getName() {
return 'Ripple';
}
}
var base32 = {};
var hasRequiredBase32;
function requireBase32 () {
if (hasRequiredBase32) return base32;
hasRequiredBase32 = 1;
(function (exports) {
/**
* Generate a character map.
* @param {string} alphabet e.g. "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
* @param {object} mappings map overrides from key to value
* @method
*/
var charmap = function (alphabet, mappings) {
mappings || (mappings = {});
alphabet.split("").forEach(function (c, i) {
if (!(c in mappings)) mappings[c] = i;
});
return mappings;
};
/**
* The RFC 4648 base 32 alphabet and character map.
* @see {@link https://tools.ietf.org/html/rfc4648}
*/
var rfc4648 = {
alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
charmap: {
0: 14,
1: 8
}
};
rfc4648.charmap = charmap(rfc4648.alphabet, rfc4648.charmap);
/**
* The Crockford base 32 alphabet and character map.
* @see {@link http://www.crockford.com/wrmg/base32.html}
*/
var crockford = {
alphabet: "0123456789ABCDEFGHJKMNPQRSTVWXYZ",
charmap: {
O: 0,
I: 1,
L: 1
}
};
crockford.charmap = charmap(crockford.alphabet, crockford.charmap);
/**
* base32hex
* @see {@link https://en.wikipedia.org/wiki/Base32#base32hex}
*/
var base32hex = {
alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
charmap: {}
};
base32hex.charmap = charmap(base32hex.alphabet, base32hex.charmap);
/**
* Create a new `Decoder` with the given options.
*
* @param {object} [options]
* @param {string} [type] Supported Base-32 variants are "rfc4648" and
* "crockford".
* @param {object} [charmap] Override the character map used in decoding.
* @constructor
*/
function Decoder (options) {
this.buf = [];
this.shift = 8;
this.carry = 0;
if (options) {
switch (options.type) {
case "rfc4648":
this.charmap = exports.rfc4648.charmap;
break;
case "crockford":
this.charmap = exports.crockford.charmap;
break;
case "base32hex":
this.charmap = exports.base32hex.charmap;
break;
default:
throw new Error("invalid type");
}
if (options.charmap) this.charmap = options.charmap;
}
}
/**
* The default character map coresponds to RFC4648.
*/
Decoder.prototype.charmap = rfc4648.charmap;
/**
* Decode a string, continuing from the previous state.
*
* @param {string} str
* @return {Decoder} this
*/
Decoder.prototype.write = function (str) {
var charmap = this.charmap;
var buf = this.buf;
var shift = this.shift;
var carry = this.carry;
// decode string
str.toUpperCase().split("").forEach(function (char) {
// ignore padding
if (char == "=") return;
// lookup symbol
var symbol = charmap[char] & 0xff;
// 1: 00000 000
// 2: 00 00000 0
// 3: 0000 0000
// 4: 0 00000 00
// 5: 000 00000
// 6: 00000 000
// 7: 00 00000 0
shift -= 5;
if (shift > 0) {
carry |= symbol << shift;
} else if (shift < 0) {
buf.push(carry | (symbol >> -shift));
shift += 8;
carry = (symbol << shift) & 0xff;
} else {
buf.push(carry | symbol);
shift = 8;
carry = 0;
}
});
// save state
this.shift = shift;
this.carry = carry;
// for chaining
return this;
};
/**
* Finish decoding.
*
* @param {string} [str] The final string to decode.
* @return {Array} Decoded byte array.
*/
Decoder.prototype.finalize = function (str) {
if (str) {
this.write(str);
}
if (this.shift !== 8 && this.carry !== 0) {
this.buf.push(this.carry);
this.shift = 8;
this.carry = 0;
}
return this.buf;
};
/**
* Create a new `Encoder` with the given options.
*
* @param {object} [options]
* @param {string} [type] Supported Base-32 variants are "rfc4648" and
* "crockford".
* @param {object} [alphabet] Override the alphabet used in encoding.
* @constructor
*/
function Encoder (options) {
this.buf = "";
this.shift = 3;
this.carry = 0;
if (options) {
switch (options.type) {
case "rfc4648":
this.alphabet = exports.rfc4648.alphabet;
break;
case "crockford":
this.alphabet = exports.crockford.alphabet;
break;
case "base32hex":
this.alphabet = exports.base32hex.alphabet;
break;
default:
throw new Error("invalid type");
}
if (options.alphabet) this.alphabet = options.alphabet;
else if (options.lc) this.alphabet = this.alphabet.toLowerCase();
}
}
/**
* The default alphabet coresponds to RFC4648.
*/
Encoder.prototype.alphabet = rfc4648.alphabet;
/**
* Encode a byte array, continuing from the previous state.
*
* @param {byte[]} buf The byte array to encode.
* @return {Encoder} this
*/
Encoder.prototype.write = function (buf) {
var shift = this.shift;
var carry = this.carry;
var symbol;
var byte;
var i;
// encode each byte in buf
for (i = 0; i < buf.length; i++) {
byte = buf[i];
// 1: 00000 000
// 2: 00 00000 0
// 3: 0000 0000
// 4: 0 00000 00
// 5: 000 00000
// 6: 00000 000
// 7: 00 00000 0
symbol = carry | (byte >> shift);
this.buf += this.alphabet[symbol & 0x1f];
if (shift > 5) {
shift -= 5;
symbol = byte >> shift;
this.buf += this.alphabet[symbol & 0x1f];
}
shift = 5 - shift;
carry = byte << shift;
shift = 8 - shift;
}
// save state
this.shift = shift;
this.carry = carry;
// for chaining
return this;
};
/**
* Finish encoding.
*
* @param {byte[]} [buf] The final byte array to encode.
* @return {string} The encoded byte array.
*/
Encoder.prototype.finalize = function (buf) {
if (buf) {
this.write(buf);
}
if (this.shift !== 3) {
this.buf += this.alphabet[this.carry & 0x1f];
this.shift = 3;
this.carry = 0;
}
return this.buf;
};
/**
* Convenience encoder.
*
* @param {byte[]} buf The byte array to encode.
* @param {object} [options] Options to pass to the encoder.
* @return {string} The encoded string.
*/
exports.encode = function (buf, options) {
return new Encoder(options).finalize(buf);
};
/**
* Convenience decoder.
*
* @param {string} str The string to decode.
* @param {object} [options] Options to pass to the decoder.
* @return {byte[]} The decoded byte array.
*/
exports.decode = function (str, options) {
return new Decoder(options).finalize(str);
};
// Exports.
exports.Decoder = Decoder;
exports.Encoder = Encoder;
exports.charmap = charmap;
exports.crockford = crockford;
exports.rfc4648 = rfc4648;
exports.base32hex = base32hex;
} (base32));
return base32;
}
var base32Exports = requireBase32();
// SPDX-License-Identifier: MIT
const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
const translate = (s, from, to) => s.split('')
.map(c => {
const i = from.indexOf(c);
return i === -1 ? c : to[i];
})
.join('');
const pad = (s) => (s.length % 8 ? s + '='.repeat(8 - (s.length % 8)) : s);
function encode(hex, customAlphabet) {
const bytes = hexToBytes(hex);
const encoder = new base32Exports.Encoder({ type: 'rfc4648', alphabet: ALPHABET });
const b32 = encoder.write(bytes).finalize().toUpperCase(); // base32.js returns lower
return customAlphabet ? translate(b32, ALPHABET, customAlphabet) : b32;
}
const encodeNoPadding = (hex, alpha) => encode(hex, alpha).replace(/=+$/, '');
function decode(data, customAlphabet) {
try {
let inp = pad(data);
if (customAlphabet) {
inp = translate(inp, customAlphabet, ALPHABET);
}
const dec = new base32Exports.Decoder({ type: 'rfc4648', alphabet: ALPHABET });
const bytes = dec.write(inp).finalize();
return bytesToHex(bytes);
}
catch {
throw new Error('Invalid Base32 string');
}
}
// SPDX-License-Identifier: MIT
class FilecoinAddress extends Address {
static alphabet = Filecoin.PARAMS.ALPHABET;
static addressPrefix = Filecoin.PARAMS.ADDRESS_PREFIX;
static addressType = Filecoin.DEFAULT_ADDRESS_TYPE;
static addressTypes = {
secp256k1: Filecoin.PARAMS.ADDRESS_TYPES.SECP256K1,
bls: Filecoin.PARAMS.ADDRESS_TYPES.BLS
};
static getName() {
return 'Filecoin';
}
static computeChecksum(pubKeyHash, addressType) {
return blake2b32(concatBytes(integerToBytes(addressType), pubKeyHash));
}
static encode(publicKey, options = {
addressPrefix: this.addressPrefix,
addressType: this.addressType
}) {
const pk = validateAndGetPublicKey(publicKey, SLIP10Secp256k1PublicKey);
const pubKeyHash = blake2b160(pk.getRawUncompressed());
const typeKey = options.addressType ?? this.addressType;
const addressType = this.addressTypes[typeKey];
if (addressType === undefined) {
throw new AddressError('Invalid Filecoin address type', {
expected: Object.keys(FilecoinAddress.addressTypes),
got: typeKey
});
}
const checksum = FilecoinAddress.computeChecksum(pubKeyHash, addressType);
const base32Encoded = encodeNoPadding(bytesToString(concatBytes(pubKeyHash, checksum)), FilecoinAddress.alphabet);
return FilecoinAddress.addressPrefix + String.fromCharCode(addressType + '0'.charCodeAt(0)) + base32Encoded;
}
static decode(address, options = {
addressPrefix: this.addressPrefix,
addressType: this.addressType
}) {
const prefix = FilecoinAddress.addressPrefix;
if (!address.startsWith(prefix)) {
throw new AddressError('Invalid prefix', {
expected: prefix,
got: address.slice(0, prefix.length)
});
}
const addressBody = address.slice(prefix.length);
const typeKey = options.addressType ?? this.addressType;
const expectedType = FilecoinAddress.addressTypes[typeKey];
if (expectedType === undefined) {
throw new AddressError('Invalid Filecoin address type', {
expected: Object.keys(FilecoinAddress.addressTypes),
got: typeKey
});
}
const actualType = addressBody.charCodeAt(0) - '0'.charCodeAt(0);
if (expectedType !== actualType) {
throw new AddressError('Invalid address type', {
expected: expectedType,
got: actualType
});
}
const payloadBytes = getBytes(decode(addressBody.slice(1), FilecoinAddress.alphabet));
if (payloadBytes.length !== 24) {
throw new AddressError('Invalid length', {
expected: 24, got: payloadBytes.length
});
}
const publicKeyHash = payloadBytes.slice(0, 20);
const checksum = payloadBytes.slice(20);
const expectedChecksum = FilecoinAddress.computeChecksum(publicKeyHash, expectedType);
if (!equalBytes(checksum, expectedChecksum)) {
throw new AddressError('Invalid checksum', {
expected: bytesToHex(expectedChecksum), got: bytesToHex(checksum)
});
}
return bytesToString(publicKeyHash);
}
}
// SPDX-License-Identifier: MIT
class AvalancheAddress extends Address {
static hrp = Avalanche.NETWORKS.MAINNET.HRP;
static addressType = Avalanche.DEFAULT_ADDRESS_TYPE;
static addressTypes = {
'p-chain': Avalanche.PARAMS.ADDRESS_TYPES.P_CHAIN,
'x-chain': Avalanche.PARAMS.ADDRESS_TYPES.X_CHAIN
};
static getName() {
return 'Avalanche';
}
static encode(publicKey, options = {
hrp: this.hrp, addressType: this.addressType
}) {
const typeKey = options.addressType ?? this.addressType;
const addressType = AvalancheAddress.addressTypes[typeKey];
if (!addressType) {
throw new AddressError('Invalid Avalanche address type', {
expected: Object.keys(AvalancheAddress.addressTypes), got: typeKey
});
}
const base = CosmosAddress.encode(publicKey, {
hrp: options.hrp ?? this.hrp
});
return addressType + base;
}
static decode(address, options = {
addressType: this.addressType
}) {
const typeKey = options.addressType ?? this.addressType;
const addressType = AvalancheAddress.addressTypes[typeKey];
if (!addressType) {
throw new AddressError('Invalid Avalanche address type', {
expected: Object.keys(AvalancheAddress.addressTypes), got: typeKey
});
}
const prefix = address.slice(0, addressType.length);
if (prefix !== addressType) {
throw new AddressError('Invalid prefix', {
expected: addressType, got: prefix
});
}
const rest = address.slice(addressType.length);
return CosmosAddress.decode(rest, { hrp: options.hrp ?? this.hrp });
}
}
// SPDX-License-Identifier: MIT
class EOSAddress extends Address {
static addressPrefix = EOS.PARAMS.ADDRESS_PREFIX;
static checksumLength = EOS.PARAMS.CHECKSUM_LENGTH;
static getName() {
return 'EOS';
}
static computeChecksum(pubKeyBytes) {
return ripemd160(pubKeyBytes).slice(0, this.checksumLength);
}
static encode(publicKey, options = {
addressPrefix: this.addressPrefix
}) {
const pk = validateAndGetPublicKey(publicKey, SLIP10Secp256k1PublicKey);
const raw = getBytes(pk.getRawCompressed());
const checksum = this.computeChecksum(raw);
const prefix = options.addressPrefix ?? this.addressPrefix;
return prefix + ensureString(encode$1(concatBytes(raw, checksum)));
}
static decode(address, options = {
addressPrefix: this.addressPrefix
}) {
const prefix = options.addressPrefix ?? this.addressPrefix;
if (!address.startsWith(prefix)) {
throw new AddressError('Invalid prefix', {
expected: prefix, got: address.slice(0, prefix.length)
});
}
const withoutPrefix = address.slice(prefix.length);
const decoded = decode$1(withoutPrefix);
const expectedLength = SLIP10Secp256k1PublicKey.getCompressedLength() + this.checksumLength;
if (decoded.length !== expectedLength) {
throw new AddressError('Invalid length', {
expected: expectedLength, got: decoded.length
});
}
const publicKeyBytes = decoded.slice(0, -this.checksumLength);
const checksum = decoded.slice(-this.checksumLength);
const computedChecksum = this.computeChecksum(publicKeyBytes);
if (!equalBytes(checksum, computedChecksum)) {
throw new AddressError('Invalid checksum', {
expected: bytesToHex(computedChecksum), got: bytesToHex(checksum)
});
}
if (!SLIP10Secp256k1PublicKey.isValidBytes(publicKeyBytes)) {
throw new AddressError('Invalid public key bytes', {
got: bytesToHex(publicKeyBytes)
});
}
return bytesToString(publicKeyBytes);
}
}
// SPDX-License-Identifier: MIT
class ErgoAddress extends Address {
static checksumLength = Ergo.PARAMS.CHECKSUM_LENGTH;
static addressType = Ergo.DEFAULT_ADDRESS_TYPE;
static addressTypes = {
'p2pkh': Ergo.PARAMS.ADDRESS_TYPES.P2PKH,
'p2sh': Ergo.PARAMS.ADDRESS_TYPES.P2SH
};
static networkType = Ergo.DEFAULT_NETWORK;
static networkTypes = {
'mainnet': Ergo.NETWORKS.MAINNET.TYPE,
'testnet': Ergo.NETWORKS.TESTNET.TYPE
};
static getName() {
return 'Ergo';
}
static computeChecksum(data) {
return blake2b256(data).slice(0, this.checksumLength);
}
static encode(publicKey, options = {
addressType: this.addressType,
networkType: this.networkType
}) {
const network = options.networkType ?? this.networkType;
const resolvedNetwork = ensureTypeMatch(network, Network, { otherTypes: ['string'] });
const networkName = resolvedNetwork.isValid ? resolvedNetwork.value.NAME : network;
const networkType = this.networkTypes[networkName];
if (networkType === undefined) {
throw new NetworkError('Invalid Ergo network type', {
expected: Object.keys(this.networkTypes), got: network
});
}
const addressType = this.addressTypes[options.addressType ?? this.addressType];
if (addressType === undefined) {
throw new AddressError('Invalid Ergo address type', {
expected: Object.keys(this.addressTypes), got: options.addressType
});
}
const pk = validateAndGetPublicKey(publicKey, SLIP10Secp256k1PublicKey);
const prefix = integerToBytes(addressType + networkType);
const addressPayload = concatBytes(prefix, pk.getRawCompressed());
const checksum = this.computeChecksum(addressPayload);
return ensureString(encode$1(concatBytes(addressPayload, checksum)));
}
static decode(address, options = {
addressType: this.addressType,
networkType: this.networkType
}) {
const network = options.networkType ?? this.networkType;
const resolvedNetwork = ensureTypeMatch(network, Network, { otherTypes: ['string'] });
const networkName = resolvedNetwork.isValid ? resolvedNetwork.value.NAME : network;
const networkType = this.networkTypes[networkName];
if (networkType === undefined) {
throw new NetworkError('Invalid Ergo network type', {
expected: Object.keys(this.networkTypes), got: options.networkType
});
}
const addressType = this.addressTypes[options.addressType ?? this.addressType];
if (addressType === undefined) {
throw new AddressError('Invalid Ergo address type', {
expected: Object.keys(this.addressTypes), got: options.addressType
});
}
const prefix = getBytes(integerToBytes(addressType + networkType));
const decoded = decode$1(address);
const expectedLength = SLIP10Secp256k1PublicKey.getCompressedLength() + this.checksumLength + prefix.length;
if (decoded.length !== expectedLength) {
throw new AddressError('Invalid length', {
expected: expectedLength, got: decoded.length
});
}
const checksum = decoded.slice(-this.checksumLength);
const payload = decoded.slice(0, -this.checksumLength);
const checksumExpected = this.computeChecksum(payload);
if (!equalBytes(checksum, checksumExpected)) {
throw new AddressError('Invalid checksum', {
expected: bytesToHex(checksumExpected), got: bytesToHex(checksum)
});
}
const prefixGot = payload.slice(0, prefix.length);
if (!equalBytes(prefix, prefixGot)) {
throw new AddressError('Invalid prefix', {
expected: bytesToHex(prefix), got: bytesToHex(prefixGot)
});
}
const pubKey = payload.slice(prefix.length);
if (!SLIP10Secp256k1PublicKey.isValidBytes(pubKey)) {
throw new AddressError('Invalid public key', {
got: bytesToHex(pubKey)
});
}
return bytesToString(pubKey);
}
}
// SPDX-License-Identifier: MIT
class IconAddress extends Address {
static addressPrefix = Icon.PARAMS.ADDRESS_PREFIX;
static keyHashLength = Icon.PARAMS.KEY_HASH_LENGTH;
static getName() {
return 'Icon';
}
static encode(publicKey) {
const pk = validateAndGetPublicKey(publicKey, SLIP10Secp256k1PublicKey);
const raw = pk.getRawUncompressed().slice(1); // Remove prefix byte (0x04)
const hash = sha3_256(raw).slice(-this.keyHashLength);
return this.addressPrefix + bytesToString(hash);
}
static decode(address) {
const prefix = this.addressPrefix;
if (!address.startsWith(prefix)) {
throw new AddressError('Invalid prefix', {
expected: prefix, got: address.slice(0, prefix.length)
});
}
const withoutPrefix = address.slice(prefix.length);
const keyHash = getBytes(withoutPrefix);
if (keyHash.length !== this.keyHashLength) {
throw new AddressError('Invalid length', {
expected: this.keyHashLength, got: keyHash.length
});
}
return bytesToString(keyHash);
}
}
// SPDX-License-Identifier: MIT
class OKTChainAddress extends Address {
static hrp = OKTChain.NETWORKS.MAINNET.HRP;
static getName() {
return 'OKT-Chain';
}
static encode(publicKey, options = {
hrp: this.hrp
}) {
const baseEth = EthereumAddress.encode(publicKey, {
skipChecksumEncode: true
});
const ethHexWithoutPrefix = baseEth.slice(2); // strip "0x"
const bytes = getBytes(ethHexWithoutPrefix);
const hrp = options.hrp ?? this.hrp;
const encoded = bech32Encode(hrp, bytes);
if (!encoded) {
throw new AddressError('Failed to encode OKTChain Bech32 address');
}
return encoded;
}
static decode(address, options = {
hrp: this.hrp
}) {
const hrp = options.hrp ?? this.hrp;
const [decodedHrp, data] = bech32Decode(hrp, address);
if (!decodedHrp || !data) {
throw new AddressError('Failed to decode OKTChain Bech32 address');
}
const ethHex = EthereumAddress.addressPrefix + bytesToString(data);
return EthereumAddress.decode(ethHex, {
skipChecksumEncode: true
});
}
}
// SPDX-License-Identifier: MIT
class HarmonyAddress extends OKTChainAddress {
static hrp = Harmony.NETWORKS.MAINNET.HRP;
static getName() {
return 'Harmony';
}
}
// SPDX-License-Identifier: MIT
class ZilliqaAddress extends Address {
static hrp = Zilliqa.NETWORKS.MAINNET.HRP;
static getName() {
return 'Zilliqa';
}
static encode(publicKey, options = {
hrp: this.hrp
}) {
const pk = validateAndGetPublicKey(publicKey, SLIP10Secp256k1PublicKey);
const hash = sha256(pk.getRawCompressed()).slice(-20);
const hrp = options.hrp ?? this.hrp;
const encoded = bech32Encode(hrp, hash);
if (!encoded) {
throw new AddressError('Failed to encode Bech32 Zilliqa address');
}
return encoded;
}
static decode(address, options = {
hrp: this.hrp
}) {
const hrp = options.hrp ?? this.hrp;
const [gotHrp, data] = bech32Decode(hrp, address);
if (!gotHrp || !data) {
throw new AddressError('Failed to decode Bech32 Zilliqa address');
}
if (data.length !== 20) {
throw new AddressError('Invalid address length', {
expected: 20, got: data.length
});
}
return bytesToString(data);
}
}
// SPDX-License-Identifier: MIT
class InjectiveAddress extends Address {
static hrp = Injective.NETWORKS.MAINNET.HRP;
static getName() {
return 'Injective';
}
static encode(publicKey, options = {
hrp: this.hrp
}) {
const pk = validateAndGetPublicKey(publicKey, SLIP10Secp256k1PublicKey);
const ethEncoded = EthereumAddress.encode(pk, {
skipChecksumEncode: true
});
const rawBytes = getBytes(ethEncoded.slice(2)); // remove "0x"
const hrp = options.hrp ?? this.hrp;
const encoded = bech32Encode(hrp, rawBytes);
if (!encoded) {
throw new AddressError('Failed to encode Bech32 Injective address');
}
return encoded;
}
static decode(address, options = {
hrp: this.hrp
}) {
const hrp = options.hrp ?? this.hrp;
const [gotHrp, data] = bech32Decode(hrp, address);
if (!gotHrp || !data) {
throw new AddressError('Failed to decode Bech32 Injective address');
}
if (data.length !== 20) {
throw new AddressError('Invalid length', {
expected: 20, got: data.length
});
}
return bytesToString(data);
}
}
// SPDX-License-Identifier: MIT
class CardanoAddress extends Address {
static addressTypes = {
'public-key': Cardano.PARAMS.PUBLIC_KEY_ADDRESS,
'redemption': Cardano.PARAMS.REDEMPTION_ADDRESS
};
static networkTypes = {
'mainnet': Cardano.NETWORKS.MAINNET.TYPE,
'testnet': Cardano.NETWORKS.TESTNET.TYPE
};
static prefixTypes = {
'payment': Cardano.PARAMS.PAYMENT_PREFIX,
'reward': Cardano.PARAMS.REWARD_PREFIX
};
static paymentAddressHrp = {
'mainnet': Cardano.NETWORKS.MAINNET.PAYMENT_ADDRESS_HRP,
'testnet': Cardano.NETWORKS.TESTNET.PAYMENT_ADDRESS_HRP
};
static rewardAddressHrp = {
'mainnet': Cardano.NETWORKS.MAINNET.REWARD_ADDRESS_HRP,
'testnet': Cardano.NETWORKS.TESTNET.REWARD_ADDRESS_HRP
};
static chacha20Poly1305AssociatedData = new Uint8Array();
static chacha20Poly1305Nonce = getBytes('7365726f6b656c6c666f7265');
static payloadTag = 24;
static getName() {
return 'Cardano';
}
static encode(publicKey, options = {
encodeType: Cardano.ADDRESS_TYPES.PAYMENT
}) {
const encodeType = options.encodeType ?? Cardano.ADDRESS_TYPES.PAYMENT;
if (encodeType === Cardano.TYPES.BYRON_LEGACY) {
return this.encodeByronLegacy(publicKey, options.path, options.pathKey, options.chainCode, options.addressType ?? Cardano.ADDRESS_TYPES.PUBLIC_KEY);
}
else if (encodeType === Cardano.TYPES.BYRON_ICARUS) {
return this.encodeByronIcarus(publicKey, options.chainCode, options.addressType ?? Cardano.ADDRESS_TYPES.PUBLIC_KEY);
}
else if (encodeType === Cardano.ADDRESS_TYPES.PAYMENT) {
return this.encodeShelley(publicKey, options.stakingPublicKey, options.network ?? 'mainnet');
}
else if (encodeType === Cardano.ADDRESS_TYPES.STAKING ||
encodeType === Cardano.ADDRESS_TYPES.REWARD) {
return this.encodeShelleyStaking(publicKey, options.network ?? 'mainnet');
}
throw new AddressError('Invalid encode type');
}
static decode(address, options = {
decodeType: Cardano.ADDRESS_TYPES.PAYMENT
}) {
const decodeType = options.decodeType ?? Cardano.ADDRESS_TYPES.PAYMENT;
if (decodeType === Cardano.TYPES.BYRON_LEGACY ||
decodeType === Cardano.TYPES.BYRON_ICARUS) {
return this.decodeByron(address, options.addressType ?? Cardano.ADDRESS_TYPES.PUBLIC_KEY);
}
else if (decodeType === Cardano.ADDRESS_TYPES.PAYMENT) {
return this.decodeShelley(address, options.network ?? 'mainnet');
}
else if (decodeType === Cardano.ADDRESS_TYPES.STAKING ||
decodeType === Cardano.ADDRESS_TYPES.REWARD) {
return this.decodeShelleyStaking(address, options.network ?? 'mainnet');
}
throw new AddressError('Invalid decode type');
}
static encodeByron(publicKey, chainCode, addressAttributes, addressType = Cardano.ADDRESS_TYPES.PUBLIC_KEY) {
if (!(addressType in this.addressTypes)) {
throw new AddressError('Invalid address type');
}
const serialized = Q([
this.addressTypes[addressType],
[this.addressTypes[addressType], concatBytes(publicKey.getRawCompressed().slice(1), chainCode)],
addressAttributes
]);
const rootHash = blake2b224(sha3_256(serialized));
const payload = Q([
rootHash,
addressAttributes,
this.addressTypes[addressType]
]);
const full = Q([
new i$1(this.payloadTag, payload), bytesToInteger(crc32(payload))
]);
return ensureString(encode$1(full));
}
static encodeByronIcarus(publicKey, chainCode, addressType = Cardano.ADDRESS_TYPES.PUBLIC_KEY) {
const pk = validateAndGetPublicKey(publicKey, KholawEd25519PublicKey);
return this.encodeByron(pk, getBytes(chainCode), {}, addressType);
}
static encodeByronLegacy(publicKey, path, pathKey, chainCode, addressType = Cardano.ADDRESS_TYPES.PUBLIC_KEY) {
const pathK = getBytes(pathKey);
if (pathK.length !== 32) {
throw new BaseError('Invalid HD path key length', { expected: 32, got: pathK.length });
}
const pk = validateAndGetPublicKey(publicKey, KholawEd25519PublicKey);
const indexes = pathToIndexes(path);
const plain = concatBytes(integerToBytes(0x9f), ...indexes.map(i => Q(i)), integerToBytes(0xff));
const { cipherText, tag } = chacha20Poly1305Encrypt(pathK, this.chacha20Poly1305Nonce, this.chacha20Poly1305AssociatedData, plain);
const attributes = new Map();
attributes.set(1, Q(concatBytes(cipherText, tag)));
return this.encodeByron(pk, getBytes(chainCode), attributes, addressType);
}
static decodeByron(address, addressType = Cardano.ADDRESS_TYPES.PUBLIC_KEY) {
const decoded = decode$1(address);
const outer = l(decoded);
if (!Array.isArray(outer) || outer.length !== 2 || !(outer[0] instanceof i$1)) {
throw new AddressError('Invalid address encoding');
}
const tag = outer[0];
if (tag.tag !== this.payloadTag) {
throw new AddressError('Invalid CBOR tag');
}
const payload = tag.contents;
const crcExpected = outer[1];
const crcActual = bytesToInteger(crc32(payload));
if (Number(crcExpected) !== Number(crcActual)) {
throw new AddressError('Invalid CRC', { expected: crcExpected, got: crcActual });
}
const inner = l(payload);
const [rootHash, attrs, tagType] = inner;
if (tagType !== this.addressTypes[addressType]) {
throw new AddressError('Invalid address type', { expected: this.addressTypes[addressType], got: tagType });
}
if (rootHash.length !== 28) {
throw new AddressError('Invalid root hash length', { expected: 28, got: rootHash.length });
}
let extra = new Uint8Array(0);
if (attrs instanceof Map && attrs.has(1)) {
const attr1 = attrs.get(1);
const decrypted = l(attr1);
extra = typeof decrypted === 'string' ? getBytes(decrypted) : decrypted;
}
return bytesToString(concatBytes(rootHash, extra));
}
static decodeByronIcarus(address, addressType = Cardano.ADDRESS_TYPES.PUBLIC_KEY) {
return CardanoAddress.decodeByron(address, addressType);
}
static decodeByronLegacy(address, addressType = Cardano.ADDRESS_TYPES.PUBLIC_KEY) {
return CardanoAddress.decodeByron(address, addressType);
}
static encodeShelley(publicKey, stakingPublicKey, network) {
const pk = validateAndGetPublicKey(publicKey, KholawEd25519PublicKey);
const spk = validateAndGetPublicKey(stakingPublicKey, KholawEd25519PublicKey);
const prefix = integerToBytes((this.prefixTypes['payment'] << 4) + this.networkTypes[network]);
const hash1 = blake2b224(pk.getRawCompressed().slice(1));
const hash2 = blake2b224(spk.getRawCompressed().slice(1));
return bech32Encode(this.paymentAddressHrp[network], concatBytes(prefix, hash1, hash2));
}
static decodeShelley(address, network) {
const [hrp, data] = bech32Decode(this.paymentAddressHrp[network], address);
if (!data || data.length !== 57) {
throw new AddressError('Invalid length', { expected: 57, got: data?.length });
}
const prefix = integerToBytes((this.prefixTypes['payment'] << 4) + this.networkTypes[network]);
if (!equalBytes(data.slice(0, 1), prefix)) {
throw new AddressError('Invalid prefix');
}
return bytesToString(data.slice(1));
}
static encodeShelleyStaking(publicKey, network) {
const pk = validateAndGetPublicKey(publicKey, KholawEd25519PublicKey);
const prefix = integerToBytes((this.prefixTypes['reward'] << 4) + this.networkTypes[network]);
const hash = blake2b224(pk.getRawCompressed().slice(1));
return bech32Encode(this.rewardAddressHrp[network], concatBytes(prefix, hash));
}
static decodeShelleyStaking(address, network) {
const [hrp, data] = bech32Decode(this.rewardAddressHrp[network], address);
if (!data || data.length !== 29) {
throw new AddressError('Invalid length', { expected: 29, got: data?.length });
}
const prefix = integerToBytes((this.prefixTypes['reward'] << 4) + this.networkTypes[network]);
if (!equalBytes(data.slice(0, 1), prefix)) {
throw new AddressError('Invalid prefix');
}
return bytesToString(data.slice(1));
}
}
// SPDX-License-Identifier: MIT
class MoneroAddress extends Address {
static checksumLength = Monero.PARAMS.CHECKSUM_LENGTH;
static paymentIDLength = Monero.PARAMS.PAYMENT_ID_LENGTH;
static network = Monero.DEFAULT_NETWORK;
static addressType = Monero.DEFAULT_ADDRESS_TYPE;
static networks = {
mainnet: {
addressTypes: {
'standard': Monero.NETWORKS.MAINNET.STANDARD,
'integrated': Monero.NETWORKS.MAINNET.INTEGRATED,
'sub-address': Monero.NETWORKS.MAINNET.SUB_ADDRESS
}
},
stagenet: {
addressTypes: {
'standard': Monero.NETWORKS.STAGENET.STANDARD,
'integrated': Monero.NETWORKS.STAGENET.INTEGRATED,
'sub-address': Monero.NETWORKS.STAGENET.SUB_ADDRESS
}
},
testnet: {
addressTypes: {
'standard': Monero.NETWORKS.TESTNET.STANDARD,
'integrated': Monero.NETWORKS.TESTNET.INTEGRATED,
'sub-address': Monero.NETWORKS.TESTNET.SUB_ADDRESS
}
}
};
static getName() {
return 'Monero';
}
static computeChecksum(data) {
return keccak256(data).subarray(0, this.checksumLength);
}
static encode(publicKeys, options = {
network: this.network, addressType: this.addressType
}) {
const { spendPublicKey, viewPublicKey } = publicKeys;
const addressType = options.addressType ?? this.addressType;
const paymentID = options.paymentID ? getBytes(options.paymentID) : undefined;
const spend = validateAndGetPublicKey(spendPublicKey, SLIP10Ed25519MoneroPublicKey);
const view = validateAndGetPublicKey(viewPublicKey, SLIP10Ed25519MoneroPublicKey);
if (paymentID && paymentID.length !== this.paymentIDLength) {
throw new BaseError('Invalid payment ID length', {
expected: this.paymentIDLength, got: paymentID.length
});
}
const network = options.network ?? this.network;
const resolvedNetwork = ensureTypeMatch(network, Network, { otherTypes: ['string'] });
const networkName = resolvedNetwork.isValid ? resolvedNetwork.value.NAME : network;
const version = integerToBytes(this.networks[networkName].addressTypes[addressType]);
const payload = concatBytes(version, spend.getRawCompressed(), view.getRawCompressed(), getBytes(paymentID ?? new Uint8Array(0)));
const checksum = this.computeChecksum(getBytes(payload));
return encodeMonero(getBytes(concatBytes(payload, checksum)));
}
static decode(address, options = {
network: this.network, addressType: this.addressType
}) {
const addressType = options.addressType ?? this.addressType;
const paymentID = getBytes(options.paymentID ?? new Uint8Array(0));
const decoded = decodeMonero(address);
const checksum = decoded.subarray(-this.checksumLength);
const payloadWithPrefix = decoded.subarray(0, -this.checksumLength);
const computedChecksum = this.computeChecksum(payloadWithPrefix);
if (!equalBytes(checksum, computedChecksum)) {
throw new AddressError('Invalid checksum', {
expected: bytesToString(checksum), got: bytesToString(computedChecksum)
});
}
const network = options.network ?? this.network;
const resolvedNetwork = ensureTypeMatch(network, Network, { otherTypes: ['string'] });
const networkName = resolvedNetwork.isValid ? resolvedNetwork.value.NAME : network;
const version = integerToBytes(this.networks[networkName].addressTypes[addressType]);
const versionGot = payloadWithPrefix.subarray(0, version.length);
if (!equalBytes(versionGot, version)) {
throw new AddressError('Invalid version', { expected: version, got: versionGot });
}
const payload = payloadWithPrefix.subarray(version.length);
const pubkeyLen = SLIP10Ed25519MoneroPublicKey.getCompressedLength();
let spend;
let view;
if (payload.length === 2 * pubkeyLen) {
spend = payload.subarray(0, pubkeyLen);
view = payload.subarray(pubkeyLen);
}
else if (payload.length === 2 * pubkeyLen + this.paymentIDLength) {
if (!paymentID || paymentID.length !== this.paymentIDLength) {
throw new BaseError('Missing or invalid payment ID');
}
const paymentIDGot = payload.subarray(-this.paymentIDLength);
if (!equalBytes(paymentID, paymentIDGot)) {
throw new BaseError('Payment ID mismatch', {
expected: bytesToString(paymentIDGot), got: bytesToString(paymentID)
});
}
spend = payload.subarray(0, pubkeyLen);
view = payload.subarray(pubkeyLen, pubkeyLen * 2);
}
else {
throw new AddressError('Invalid payload length', {
expected: 2 * pubkeyLen, got: payload.length
});
}
if (!SLIP10Ed25519MoneroPublicKey.isValidBytes(spend)) {
throw new BaseError('Invalid spend public key');
}
if (!SLIP10Ed25519MoneroPublicKey.isValidBytes(view)) {
throw new BaseError('Invalid view public key');
}
return [bytesToString(spend), bytesToString(view)];
}
}
// SPDX-License-Identifier: MIT
class NanoAddress extends Address {
static addressPrefix = Nano.PARAMS.ADDRESS_PREFIX;
static alphabet = Nano.PARAMS.ALPHABET;
static payloadPaddingDecoded = getBytes(Nano.PARAMS.PAYLOAD_PADDING_DECODED);
static payloadPaddingEncoded = Nano.PARAMS.PAYLOAD_PADDING_ENCODED;
static getName() {
return 'Nano';
}
static computeChecksum(publicKey) {
return bytesReverse(blake2b40(publicKey));
}
static encode(publicKey) {
const pk = validateAndGetPublicKey(publicKey, SLIP10Ed25519Blake2bPublicKey);
const raw = pk.getRawCompressed().subarray(1);
const checksum = this.computeChecksum(getBytes(raw));
const payload = concatBytes(this.payloadPaddingDecoded, raw, checksum);
const b32 = encodeNoPadding(bytesToString(payload), this.alphabet);
return this.addressPrefix + b32.slice(this.payloadPaddingEncoded.length);
}
static decode(address) {
const prefix = address.slice(0, this.addressPrefix.length);
if (prefix !== this.addressPrefix) {
throw new AddressError('Invalid prefix', { expected: this.addressPrefix, got: prefix });
}
const body = address.slice(this.addressPrefix.length);
const fullEncoded = this.payloadPaddingEncoded + body;
const decoded = getBytes(decode(fullEncoded, this.alphabet));
const expectedLen = this.payloadPaddingDecoded.length + SLIP10Ed25519Blake2bPublicKey.getCompressedLength() - 1 + 5;
if (decoded.length !== expectedLen) {
throw new AddressError('Invalid decoded length', { expected: expectedLen, got: decoded.length });
}
const data = decoded.subarray(this.payloadPaddingDecoded.length);
const pubkey = data.subarray(0, data.length - 5);
const checksum = data.subarray(-5);
const gotChecksum = this.computeChecksum(pubkey);
if (!equalBytes(checksum, gotChecksum)) {
throw new AddressError('Invalid checksum', {
expected: bytesToString(checksum), got: bytesToString(gotChecksum)
});
}
if (!SLIP10Ed25519Blake2bPublicKey.isValidBytes(pubkey)) {
throw new AddressError('Invalid public key');
}
return bytesToString(pubkey);
}
}
// SPDX-License-Identifier: MIT
class NeoAddress extends Address {
static addressPrefix = integerToBytes(Neo.PARAMS.ADDRESS_PREFIX);
static addressSuffix = integerToBytes(Neo.PARAMS.ADDRESS_SUFFIX);
static addressVersion = integerToBytes(Neo.PARAMS.ADDRESS_VERSION);
static alphabet = Neo.PARAMS.ALPHABET;
static getName() {
return 'Neo';
}
static encode(publicKey, options = {
addressVersion: this.addressVersion, alphabet: this.alphabet
}) {
const pk = validateAndGetPublicKey(publicKey, SLIP10Nist256p1PublicKey);
const payload = concatBytes(this.addressPrefix, pk.getRawCompressed(), this.addressSuffix);
const hashed = hash160(payload);
const version = getBytes(options.addressVersion ?? this.addressVersion);
return ensureString(checkEncode(getBytes(concatBytes(version, hashed)), options.alphabet ?? this.alphabet));
}
static decode(address, options = {
addressVersion: this.addressVersion, alphabet: this.alphabet
}) {
const decoded = checkDecode(address, options.alphabet ?? this.alphabet);
const version = getBytes(options.addressVersion ?? this.addressVersion);
const expectedLength = 20 + version.length;
if (decoded.length !== expectedLength) {
throw new AddressError('Invalid length', {
expected: expectedLength, got: decoded.length
});
}
const versionGot = decoded.subarray(0, version.length);
if (!equalBytes(version, versionGot)) {
throw new AddressError('Invalid address version', {
expected: bytesToString(version), got: bytesToString(versionGot)
});
}
return bytesToString(decoded.subarray(version.length));
}
}
// SPDX-License-Identifier: MIT
class AlgorandAddress extends Address {
static checksumLength = Algorand.PARAMS.CHECKSUM_LENGTH;
static getName() {
return 'Algorand';
}
static computeChecksum(publicKey) {
return sha512_256(publicKey).subarray(-4);
}
static encode(publicKey) {
const pk = validateAndGetPublicKey(publicKey, SLIP10Ed25519PublicKey);
const raw = pk.getRawCompressed().subarray(1);
const checksum = this.computeChecksum(raw);
return encodeNoPadding(bytesToString(concatBytes(raw, checksum)));
}
static decode(address) {
const decoded = getBytes(decode(address));
const expectedLength = SLIP10Ed25519PublicKey.getCompressedLength() - 1 + this.checksumLength;
if (decoded.length !== expectedLength) {
throw new AddressError('Invalid decoded length', {
expected: expectedLength, got: decoded.length
});
}
const pubkey = decoded.subarray(0, decoded.length - this.checksumLength);
const checksum = decoded.subarray(-this.checksumLength);
const gotChecksum = this.computeChecksum(pubkey);
if (!equalBytes(checksum, gotChecksum)) {
throw new AddressError('Invalid checksum', {
expected: bytesToString(checksum), got: bytesToString(gotChecksum)
});
}
if (!SLIP10Ed25519PublicKey.isValidBytes(pubkey)) {
throw new AddressError('Invalid public key');
}
return bytesToString(pubkey);
}
}
// SPDX-License-Identifier: MIT
class MultiversXAddress extends Address {
static hrp = MultiversX.NETWORKS.MAINNET.HRP;
static getName() {
return 'MultiversX';
}
static encode(publicKey, options = {
hrp: this.hrp
}) {
const pk = validateAndGetPublicKey(publicKey, SLIP10Ed25519PublicKey);
const raw = pk.getRawCompressed().subarray(1);
return bech32Encode(options.hrp ?? this.hrp, getBytes(raw));
}
static decode(address, options = {
hrp: this.hrp
}) {
const [hrpGot, data] = bech32Decode(options.hrp ?? this.hrp, address);
if (!data) {
throw new AddressError('Invalid Bech32 decoding result');
}
return bytesToString(data);
}
}
// SPDX-License-Identifier: MIT
class SolanaAddress extends Address {
static alphabet = Solana.PARAMS.ALPHABET;
static getName() {
return 'Solana';
}
static encode(publicKey) {
const pk = validateAndGetPublicKey(publicKey, SLIP10Ed25519PublicKey);
return ensureString(encode$1(getBytes(pk.getRawCompressed().subarray(1))));
}
static decode(address) {
const publicKey = decode$1(address);
const expectedLength = SLIP10Ed25519PublicKey.getCompressedLength() - 1;
if (publicKey.length !== expectedLength) {
throw new AddressError('Invalid public key length', {
expected: expectedLength, got: publicKey.length
});
}
if (!SLIP10Ed25519PublicKey.isValidBytes(publicKey)) {
throw new AddressError(`Invalid SLIP10-Ed25519 public key`);
}
return bytesToString(publicKey);
}
}
// SPDX-License-Identifier: MIT
class StellarAddress extends Address {
static checksumLength = Stellar.PARAMS.CHECKSUM_LENGTH;
static addressType = Stellar.DEFAULT_ADDRESS_TYPE;
static addressTypes = {
privateKey: Stellar.PARAMS.ADDRESS_TYPES.PRIVATE_KEY,
publicKey: Stellar.PARAMS.ADDRESS_TYPES.PUBLIC_KEY
};
static getName() {
return 'Stellar';
}
static computeChecksum(payload) {
return bytesReverse(xmodemCrc(payload));
}
static encode(publicKey, options = {
addressType: this.addressType
}) {
const addressTypeName = options.addressType ?? this.addressType;
if (!(addressTypeName in this.addressTypes)) {
throw new AddressError('Invalid Stellar address type', {
expected: Object.keys(this.addressTypes), got: addressTypeName
});
}
const addressType = this.addressTypes[addressTypeName];
const pk = validateAndGetPublicKey(publicKey, SLIP10Ed25519PublicKey);
const payload = concatBytes(integerToBytes(addressType), pk.getRawCompressed().subarray(1));
const checksum = this.computeChecksum(payload);
return encodeNoPadding(bytesToString(concatBytes(payload, checksum)));
}
static decode(address, options = {
addressType: this.addressType
}) {
const addressTypeName = options.addressType ?? this.addressType;
if (!(addressTypeName in this.addressTypes)) {
throw new AddressError('Invalid Stellar address type', {
expected: Object.keys(this.addressTypes), got: addressTypeName
});
}
const addressType = this.addressTypes[addressTypeName];
const decoded = getBytes(decode(address));
const expectedLength = SLIP10Ed25519PublicKey.getCompressedLength() + this.checksumLength;
if (decoded.length !== expectedLength) {
throw new AddressError('Invalid length', {
expected: expectedLength, got: decoded.length
});
}
const checksum = decoded.subarray(-this.checksumLength);
const payload = decoded.subarray(0, -this.checksumLength);
const addressTypeGot = payload[0];
if (addressTypeGot !== addressType) {
throw new AddressError('Invalid address type', {
expected: addressType,
got: addressTypeGot
});
}
const checksumGot = this.computeChecksum(payload);
if (!equalBytes(checksum, checksumGot)) {
throw new AddressError('Invalid checksum', {
expected: bytesToString(checksum),
got: bytesToString(checksumGot)
});
}
const pubkey = payload.subarray(1);
if (!SLIP10Ed25519PublicKey.isValidBytes(pubkey)) {
throw new AddressError('Invalid public key');
}
return bytesToString(pubkey);
}
}
// SPDX-License-Identifier: MIT
class TezosAddress extends Address {
static addressPrefix = Tezos.DEFAULT_ADDRESS_PREFIX;
static addressPrefixes = {
tz1: Tezos.PARAMS.ADDRESS_PREFIXES.TZ1,
tz2: Tezos.PARAMS.ADDRESS_PREFIXES.TZ2,
tz3: Tezos.PARAMS.ADDRESS_PREFIXES.TZ3
};
static getName() {
return 'Tezos';
}
static encode(publicKey, options = {
addressPrefix: this.addressPrefix
}) {
const prefixKey = options.addressPrefix ?? this.addressPrefix;
if (!(prefixKey in this.addressPrefixes)) {
throw new AddressError('Invalid Tezos address prefix', {
expected: Object.keys(this.addressPrefixes), got: prefixKey
});
}
const prefix = getBytes(this.addressPrefixes[prefixKey]);
const pk = validateAndGetPublicKey(publicKey, SLIP10Ed25519PublicKey);
const hashed = blake2b160(pk.getRawCompressed().subarray(1));
return ensureString(checkEncode(getBytes(concatBytes(prefix, hashed))));
}
static decode(address, options = {
addressPrefix: this.addressPrefix
}) {
const prefixKey = options.addressPrefix ?? this.addressPrefix;
if (!(prefixKey in this.addressPrefixes)) {
throw new AddressError('Invalid Tezos address prefix', {
expected: Object.keys(this.addressPrefixes), got: prefixKey
});
}
const prefix = getBytes(this.addressPrefixes[prefixKey]);
const decoded = checkDecode(address);
const expectedLen = prefix.length + 20;
if (decoded.length !== expectedLen) {
throw new AddressError('Invalid length', {
expected: expectedLen, got: decoded.length
});
}
const prefixGot = decoded.subarray(0, prefix.length);
if (!equalBytes(prefixGot, prefix)) {
throw new AddressError('Invalid prefix', {
expected: bytesToString(prefix), got: bytesToString(prefixGot)
});
}
return bytesToString(decoded.subarray(prefix.length));
}
}
// SPDX-License-Identifier: MIT
class SuiAddress extends Address {
static keyType = integerToBytes(Sui.PARAMS.KEY_TYPE);
static addressPrefix = Sui.PARAMS.ADDRESS_PREFIX;
static getName() {
return 'Sui';
}
static encode(publicKey) {
const pk = validateAndGetPublicKey(publicKey, SLIP10Ed25519PublicKey);
const raw = pk.getRawCompressed().subarray(1);
const hash = blake2b256(getBytes(new Uint8Array([...this.keyType, ...raw])));
return this.addressPrefix + bytesToString(hash);
}
static decode(address) {
const prefix = address.slice(0, this.addressPrefix.length);
if (prefix !== this.addressPrefix) {
throw new AddressError('Invalid address prefix', {
expected: this.addressPrefix, got: prefix
});
}
const body = address.slice(this.addressPrefix.length);
if (body.length !== 64) {
throw new AddressError('Invalid address length', {
expected: 64, got: body.length
});
}
return body;
}
}
// SPDX-License-Identifier: MIT
class AptosAddress extends Address {
static suffix = integerToBytes(Aptos.PARAMS.SUFFIX);
static addressPrefix = Aptos.PARAMS.ADDRESS_PREFIX;
static getName() {
return 'Aptos';
}
static encode(publicKey) {
const pk = validateAndGetPublicKey(publicKey, SLIP10Ed25519PublicKey);
const raw = pk.getRawCompressed().subarray(1);
const payload = new Uint8Array([...raw, ...this.suffix]);
const hash = sha3_256(payload);
return this.addressPrefix + bytesToString(hash).replace(/^0+/, '');
}
static decode(address) {
const prefix = address.slice(0, this.addressPrefix.length);
if (prefix !== this.addressPrefix) {
throw new AddressError('Invalid address prefix', {
expected: this.addressPrefix, got: prefix
});
}
const body = address.slice(this.addressPrefix.length).padStart(64, '0');
if (body.length !== 64) {
throw new AddressError('Invalid address length', {
expected: 64, got: body.length
});
}
return body;
}
}
// SPDX-License-Identifier: MIT
class NearAddress extends Address {
static getName() {
return 'Near';
}
static encode(publicKey) {
const pk = validateAndGetPublicKey(publicKey, SLIP10Ed25519PublicKey);
return bytesToString(pk.getRawCompressed()).slice(2);
}
static decode(address) {
const bytes = getBytes(address);
const expectedLength = 32;
if (bytes.length !== expectedLength) {
throw new AddressError('Invalid address length', {
expected: expectedLength, got: bytes.length
});
}
validateAndGetPublicKey(bytes, SLIP10Ed25519PublicKey);
return address;
}
}
// SPDX-License-Identifier: MIT
class ADDRESSES {
static dictionary = {
[P2PKHAddress.getName()]: P2PKHAddress,
[P2SHAddress.getName()]: P2SHAddress,
[P2TRAddress.getName()]: P2TRAddress,
[P2WPKHAddress.getName()]: P2WPKHAddress,
[P2WPKHInP2SHAddress.getName()]: P2WPKHInP2SHAddress,
[P2WSHAddress.getName()]: P2WSHAddress,
[P2WSHInP2SHAddress.getName()]: P2WSHInP2SHAddress,
[EthereumAddress.getName()]: EthereumAddress,
[CosmosAddress.getName()]: CosmosAddress,
[XinFinAddress.getName()]: XinFinAddress,
[TronAddress.getName()]: TronAddress,
[RippleAddress.getName()]: RippleAddress,
[FilecoinAddress.getName()]: FilecoinAddress,
[AvalancheAddress.getName()]: AvalancheAddress,
[EOSAddress.getName()]: EOSAddress,
[ErgoAddress.getName()]: ErgoAddress,
[IconAddress.getName()]: IconAddress,
[OKTChainAddress.getName()]: OKTChainAddress,
[HarmonyAddress.getName()]: HarmonyAddress,
[ZilliqaAddress.getName()]: ZilliqaAddress,
[InjectiveAddress.getName()]: InjectiveAddress,
[CardanoAddress.getName()]: CardanoAddress,
[MoneroAddress.getName()]: MoneroAddress,
[NanoAddress.getName()]: NanoAddress,
[NeoAddress.getName()]: NeoAddress,
[AlgorandAddress.getName()]: AlgorandAddress,
[MultiversXAddress.getName()]: MultiversXAddress,
[SolanaAddress.getName()]: SolanaAddress,
[StellarAddress.getName()]: StellarAddress,
[TezosAddress.getName()]: TezosAddress,
[SuiAddress.getName()]: SuiAddress,
[AptosAddress.getName()]: AptosAddress,
[NearAddress.getName()]: NearAddress
};
static getNames() {
return Object.keys(this.dictionary);
}
static getClasses() {
return Object.values(this.dictionary);
}
static getAddressClass(name) {
if (!this.isAddress(name)) {
throw new AddressError('Invalid address name', { expected: this.getNames(), got: name });
}
return this.dictionary[name];
}
static isAddress(name) {
return name in this.dictionary;
}
}
var addresses = /*#__PURE__*/Object.freeze({
__proto__: null,
ADDRESSES: ADDRESSES,
Address: Address,
P2PKHAddress: P2PKHAddress,
P2SHAddress: P2SHAddress,
P2TRAddress: P2TRAddress,
P2WPKHAddress: P2WPKHAddress,
P2WPKHInP2SHAddress: P2WPKHInP2SHAddress,
P2WSHAddress: P2WSHAddress,
P2WSHInP2SHAddress: P2WSHInP2SHAddress,
EthereumAddress: EthereumAddress,
CosmosAddress: CosmosAddress,
XinFinAddress: XinFinAddress,
TronAddress: TronAddress,
RippleAddress: RippleAddress,
FilecoinAddress: FilecoinAddress,
AvalancheAddress: AvalancheAddress,
EOSAddress: EOSAddress,
ErgoAddress: ErgoAddress,
IconAddress: IconAddress,
OKTChainAddress: OKTChainAddress,
HarmonyAddress: HarmonyAddress,
ZilliqaAddress: ZilliqaAddress,
InjectiveAddress: InjectiveAddress,
CardanoAddress: CardanoAddress,
MoneroAddress: MoneroAddress,
NanoAddress: NanoAddress,
NeoAddress: NeoAddress,
AlgorandAddress: AlgorandAddress,
MultiversXAddress: MultiversXAddress,
SolanaAddress: SolanaAddress,
StellarAddress: StellarAddress,
TezosAddress: TezosAddress,
SuiAddress: SuiAddress,
AptosAddress: AptosAddress,
NearAddress: NearAddress
});
// SPDX-License-Identifier: MIT
function encodeWIF(privateKey, wifPrefix = Bitcoin.NETWORKS.MAINNET.WIF_PREFIX) {
const keyBytes = getBytes(privateKey);
if (keyBytes.length !== 32) {
throw new ECCError('Invalid private key length', { expected: 32, got: keyBytes.length });
}
const prefix = integerToBytes(wifPrefix, 1);
const compressedSuffix = integerToBytes(SLIP10_SECP256K1_CONST.PRIVATE_KEY_COMPRESSED_PREFIX, 1);
const uncompressedPayload = concatBytes(prefix, keyBytes);
const compressedPayload = concatBytes(prefix, keyBytes, compressedSuffix);
return [
encode$1(concatBytes(uncompressedPayload, getChecksum(uncompressedPayload))),
encode$1(concatBytes(compressedPayload, getChecksum(compressedPayload)))
];
}
function decodeWIF(wif, wifPrefix = Bitcoin.NETWORKS.MAINNET.WIF_PREFIX) {
const raw = decode$1(wif);
const prefix = integerToBytes(wifPrefix, 1);
if (!equalBytes(raw.subarray(0, prefix.length), prefix)) {
throw new WIFError('Invalid Wallet Import Format (WIF) prefix');
}
const rawWithoutPrefix = raw.subarray(prefix.length);
const checksum = rawWithoutPrefix.subarray(-4);
let privateKey = rawWithoutPrefix.subarray(0, -4);
let wifType = 'wif';
if (privateKey.length === 33) {
const compressedPrefix = integerToBytes(SLIP10_SECP256K1_CONST.PRIVATE_KEY_COMPRESSED_PREFIX, 1);
if (equalBytes(privateKey.subarray(-1), compressedPrefix)) {
privateKey = privateKey.subarray(0, -1);
wifType = 'wif-compressed';
}
}
else if (privateKey.length !== 32) {
throw new WIFError('Invalid WIF length');
}
return [privateKey, wifType, checksum];
}
function privateKeyToWIF(privateKey, wifType = 'wif-compressed', wifPrefix = Bitcoin.NETWORKS.MAINNET.WIF_PREFIX) {
if (!WIF_TYPES.getTypes().includes(wifType)) {
throw new WIFError('Wrong WIF type', {
expected: WIF_TYPES.getTypes(), got: wifType
});
}
const [wif, wifCompressed] = encodeWIF(privateKey, wifPrefix);
return wifType === 'wif' ? wif : wifCompressed;
}
function wifToPrivateKey(wif, wifPrefix = Bitcoin.NETWORKS.MAINNET.WIF_PREFIX) {
return bytesToString(decodeWIF(wif, wifPrefix)[0]);
}
function getWIFType(wif, wifPrefix = Bitcoin.NETWORKS.MAINNET.WIF_PREFIX) {
return decodeWIF(wif, wifPrefix)[1];
}
// SPDX-License-Identifier: MIT
function serialize(version, depth, parentFingerprint, index, chainCode, key, encoded = false) {
try {
const versionBytes = typeof version === 'number'
? integerToBytes(version, 4)
: getBytes(version);
if (depth < 0 || depth > 0xff) {
throw new ExtendedKeyError(`Depth must be 0–255; got ${depth}`);
}
const depthByte = integerToBytes(depth, 1);
const parentBytes = getBytes(parentFingerprint);
if (parentBytes.length !== 4) {
throw new ExtendedKeyError(`Parent fingerprint must be 4 bytes; got ${parentBytes.length}`);
}
if (!Number.isInteger(index) || index < 0 || index > 0xffffffff) {
throw new ExtendedKeyError(`Index must be 0–2^32-1; got ${index}`);
}
const indexBytes = integerToBytes(index, 4);
const chainBytes = getBytes(chainCode);
if (chainBytes.length !== 32) {
throw new ExtendedKeyError(`Chain code must be 32 bytes; got ${chainBytes.length}`);
}
const raw = concatBytes(versionBytes, depthByte, parentBytes, indexBytes, chainBytes, getBytes(key));
return encoded ? checkEncode(raw) : bytesToString(raw);
}
catch (err) {
return null;
}
}
function deserialize(key, encoded = true) {
const rawBytes = encoded ? checkDecode(key) : getBytes(key);
if (![78, 110].includes(rawBytes.length)) {
throw new ExtendedKeyError('Invalid extended key length', { expected: [78, 110], got: rawBytes.length });
}
const version = rawBytes.slice(0, 4);
const depth = rawBytes[4];
const parentFingerprint = rawBytes.slice(5, 9);
const indexView = new DataView(rawBytes.buffer, rawBytes.byteOffset + 9, 4);
const index = indexView.getUint32(0, false);
const chainCode = rawBytes.slice(13, 45);
const keyData = rawBytes.slice(45);
return [version, depth, parentFingerprint, index, chainCode, keyData];
}
function isValidKey(key, encoded = true) {
try {
deserialize(key, encoded);
return true;
}
catch {
return false;
}
}
function isRootKey(key, encoded = true) {
if (!isValidKey(key, encoded)) {
throw new ExtendedKeyError('Invalid extended(x) key');
}
const [_, depth, parentFingerprint, index] = deserialize(key, encoded);
// Check that depth === 0, parentFingerprint is all zero bytes, and index === 0
const zeroFingerprint = new Uint8Array(4); // [0,0,0,0]
return depth === 0 && equalBytes(parentFingerprint, zeroFingerprint) && index === 0;
}
// SPDX-License-Identifier: MIT
class BIP32HD extends HD {
seed;
rootPrivateKey;
rootChainCode;
rootPublicKey;
privateKey;
chainCode;
publicKey;
publicKeyType = PUBLIC_KEY_TYPES.COMPRESSED;
wifType = WIF_TYPES.WIF_COMPRESSED;
wifPrefix;
fingerprint;
parentFingerprint;
strict;
rootDepth = 0;
rootIndex = 0;
depth = 0;
index = 0;
constructor(options = {
publicKeyType: PUBLIC_KEY_TYPES.COMPRESSED
}) {
super(options);
this.publicKeyType = options.publicKeyType ?? PUBLIC_KEY_TYPES.COMPRESSED;
if (this.publicKeyType === PUBLIC_KEY_TYPES.UNCOMPRESSED) {
this.wifType = WIF_TYPES.WIF;
}
else if (this.publicKeyType === PUBLIC_KEY_TYPES.COMPRESSED) {
this.wifType = WIF_TYPES.WIF_COMPRESSED;
}
else {
throw new BaseError('Invalid public key type', {
expected: PUBLIC_KEY_TYPES.getTypes(), got: this.publicKeyType
});
}
this.wifPrefix = options.wifPrefix;
this.derivation = new CustomDerivation({
path: options.path, indexes: options.indexes
});
}
static getName() {
return 'BIP32';
}
fromSeed(seed) {
try {
this.seed = getBytes(seed instanceof Seed ? seed.getSeed() : seed);
}
catch {
throw new SeedError('Invalid seed data');
}
if (this.seed.length < 16) {
throw new BaseError('Invalid seed length', {
expected: '< 16',
got: this.seed.length,
});
}
const hmacHalfLength = 64 / 2;
let hmacData = this.seed;
let success = false;
let hmacResult = new Uint8Array(64);
while (!success) {
hmacResult = hmacSha512(getHmac(this.ecc.NAME), hmacData);
if (this.ecc.NAME === 'Kholaw-Ed25519') {
success = (hmacResult[31] & 0x20) === 0;
if (!success)
hmacData = hmacResult;
}
else {
const privClass = this.ecc.PRIVATE_KEY;
success = privClass.isValidBytes(hmacResult.slice(0, hmacHalfLength));
if (!success)
hmacData = hmacResult;
}
}
const tweakMasterKeyBits = (input) => {
const data = new Uint8Array(input);
data[0] = resetBits(data[0], 0x07);
data[31] = resetBits(data[31], 0x80);
data[31] = setBits(data[31], 0x40);
return data;
};
if (this.ecc.NAME === 'Kholaw-Ed25519') {
let kl = hmacResult.slice(0, hmacHalfLength);
const kr = hmacResult.slice(hmacHalfLength);
kl = tweakMasterKeyBits(kl);
const chainCode = hmacSha256(getHmac(this.ecc.NAME), concatBytes(integerToBytes(0x01), this.seed));
this.rootPrivateKey = this.ecc.PRIVATE_KEY.fromBytes(concatBytes(kl, kr));
this.rootChainCode = getBytes(chainCode);
}
else {
const privBytes = hmacResult.slice(0, hmacHalfLength);
const chainBytes = hmacResult.slice(hmacHalfLength);
this.rootPrivateKey = this.ecc.PRIVATE_KEY.fromBytes(privBytes);
this.rootChainCode = chainBytes;
}
this.privateKey = this.rootPrivateKey;
this.chainCode = this.rootChainCode;
this.parentFingerprint = integerToBytes(0x00, 4);
this.rootPublicKey = this.rootPrivateKey.getPublicKey();
this.publicKey = this.rootPublicKey;
this.strict = true;
this.fromDerivation(this.derivation);
return this;
}
fromXPrivateKey(xprv, encoded = true, strict = false) {
if (!isValidKey(xprv, encoded)) {
throw new XPrivateKeyError('Invalid extended(x) private key');
}
const raw = encoded ? checkDecode(xprv) : hexToBytes(xprv);
if (![78, 110].includes(raw.length)) {
throw new XPrivateKeyError('Invalid extended(x) private key');
}
if (strict && !isRootKey(xprv, encoded)) {
throw new XPrivateKeyError('Invalid root extended(x) private key');
}
const [version, depth, parentFingerprint, index, chainCode, key] = deserialize(xprv, encoded);
this.rootChainCode = chainCode;
this.rootPrivateKey = this.ecc.PRIVATE_KEY.fromBytes(key.slice(1));
this.rootPublicKey = this.rootPrivateKey.getPublicKey();
this.rootDepth = depth;
this.parentFingerprint = parentFingerprint;
this.rootIndex = index;
this.chainCode = this.rootChainCode;
this.privateKey = this.rootPrivateKey;
this.publicKey = this.rootPublicKey;
this.depth = this.rootDepth;
this.index = this.rootIndex;
this.strict = isRootKey(xprv, encoded);
this.fromDerivation(this.derivation);
return this;
}
fromXPublicKey(xpub, encoded = true, strict = false) {
if (!isValidKey(xpub, encoded)) {
throw new XPublicKeyError('Invalid extended(x) public key');
}
const raw = encoded ? checkDecode(xpub) : hexToBytes(xpub);
if (raw.length !== 78) {
throw new XPublicKeyError('Invalid extended(x) public key');
}
if (strict && !isRootKey(xpub, encoded)) {
throw new XPublicKeyError('Invalid root extended(x) public key');
}
const [version, depth, parentFingerprint, index, chainCode, key] = deserialize(xpub, encoded);
this.rootChainCode = chainCode;
this.rootPublicKey = this.ecc.PUBLIC_KEY.fromBytes(key);
this.rootDepth = depth;
this.parentFingerprint = parentFingerprint;
this.rootIndex = index;
this.chainCode = this.rootChainCode;
this.publicKey = this.rootPublicKey;
this.depth = this.rootDepth;
this.index = this.rootIndex;
this.strict = isRootKey(xpub, encoded);
this.fromDerivation(this.derivation);
return this;
}
fromWIF(wif) {
if (!this.wifPrefix) {
throw new WIFError('WIF prefix is required');
}
const wifType = getWIFType(wif, this.wifPrefix);
if (wifType === 'wif-compressed') {
this.publicKeyType = PUBLIC_KEY_TYPES.COMPRESSED;
this.wifType = WIF_TYPES.WIF_COMPRESSED;
}
else {
this.publicKeyType = PUBLIC_KEY_TYPES.UNCOMPRESSED;
this.wifType = WIF_TYPES.WIF;
}
const privKey = wifToPrivateKey(wif, this.wifPrefix);
this.fromPrivateKey(privKey);
this.strict = null;
return this;
}
fromPrivateKey(privateKey) {
try {
const bytes = getBytes(privateKey);
this.privateKey = this.ecc.PRIVATE_KEY.fromBytes(bytes);
this.publicKey = this.privateKey.getPublicKey();
this.strict = null;
return this;
}
catch {
throw new PrivateKeyError('Invalid private key data');
}
}
fromPublicKey(publicKey) {
try {
const bytes = getBytes(publicKey);
this.publicKey = this.ecc.PUBLIC_KEY.fromBytes(bytes);
this.strict = null;
return this;
}
catch {
throw new PublicKeyError('Invalid public key data');
}
}
fromDerivation(derivation) {
this.derivation = ensureTypeMatch(derivation, Derivation, { errorClass: DerivationError });
for (const index of this.derivation.getIndexes()) {
this.drive(index);
}
return this;
}
updateDerivation(derivation) {
this.cleanDerivation();
this.fromDerivation(derivation);
return this;
}
cleanDerivation() {
if (this.rootPrivateKey) {
this.privateKey = this.rootPrivateKey;
this.chainCode = this.rootChainCode;
this.parentFingerprint = integerToBytes(0, 4);
this.publicKey = this.privateKey.getPublicKey();
this.derivation.clean();
this.depth = 0;
}
else if (this.rootPublicKey) {
this.publicKey = this.rootPublicKey;
this.chainCode = this.rootChainCode;
this.parentFingerprint = integerToBytes(0, 4);
this.derivation.clean();
this.depth = 0;
}
return this;
}
drive(index) {
const hmacHalfLength = 64 / 2; // sha512 output is 64 bytes
if (this.ecc.NAME === 'Kholaw-Ed25519') {
const indexBytes = integerToBytes(index, 4, 'little');
if (this.privateKey) {
if (index & 0x80000000) {
const zHmac = hmacSha512(this.chainCode, concatBytes(integerToBytes(0x00, 1), this.privateKey.getRaw(), indexBytes));
const hmac = hmacSha512(this.chainCode, concatBytes(integerToBytes(0x01, 1), this.privateKey.getRaw(), indexBytes));
const zl = zHmac.slice(0, hmacHalfLength);
const zr = zHmac.slice(hmacHalfLength);
const kl = this.privateKey.getRaw().slice(0, hmacHalfLength);
const kr = this.privateKey.getRaw().slice(hmacHalfLength);
const klInt = bytesToInteger(kl, true);
const zlInt = bytesToInteger(zl.slice(0, 28), true);
const left = zlInt * BigInt(8) + klInt;
if (left % this.ecc.ORDER === BigInt(0)) {
throw new BaseError('Computed child key is not valid, very unlucky index');
}
const TWO_POW_256 = BigInt(1) << BigInt(256);
const krInt = (bytesToInteger(zr, true) + bytesToInteger(kr, true)) % TWO_POW_256;
const newPrivate = KholawEd25519PrivateKey.fromBytes(concatBytes(integerToBytes(left, KholawEd25519PrivateKey.getLength() / 2, 'little'), integerToBytes(krInt, KholawEd25519PrivateKey.getLength() / 2, 'little')));
this.privateKey = newPrivate;
this.chainCode = hmac.slice(hmacHalfLength);
this.publicKey = newPrivate.getPublicKey();
}
else {
const zHmac = hmacSha512(this.chainCode, concatBytes(integerToBytes(0x02, 1), this.publicKey.getRawCompressed().slice(1), indexBytes));
const hmac = hmacSha512(this.chainCode, concatBytes(integerToBytes(0x03, 1), this.publicKey.getRawCompressed().slice(1), indexBytes));
const zlInt = bytesToInteger(zHmac.slice(0, 28), true);
const tweak = zlInt * BigInt(8);
const newPoint = this.publicKey.getPoint().add(this.ecc.GENERATOR.multiply(tweak));
if (newPoint.getX() === BigInt(0) && newPoint.getY() === BigInt(1)) {
throw new BaseError('Computed public child key is not valid, very unlucky index');
}
this.publicKey = this.ecc.PUBLIC_KEY.fromPoint(newPoint);
this.chainCode = hmac.slice(hmacHalfLength);
}
}
else {
if (index & 0x80000000) {
throw new DerivationError('Hardened derivation path is invalid for xpublic key');
}
const zHmac = hmacSha512(this.chainCode, concatBytes(integerToBytes(0x02, 1), this.publicKey.getRawCompressed().slice(1), indexBytes));
const hmac = hmacSha512(this.chainCode, concatBytes(integerToBytes(0x03, 1), this.publicKey.getRawCompressed().slice(1), indexBytes));
const zlInt = bytesToInteger(zHmac.slice(0, 28), true);
const tweak = zlInt * BigInt(8);
const newPoint = this.publicKey.getPoint().add(this.ecc.GENERATOR.multiply(tweak));
if (newPoint.getX() === BigInt(0) && newPoint.getY() === BigInt(1)) {
throw new BaseError('Computed public child key is not valid, very unlucky index');
}
this.publicKey = this.ecc.PUBLIC_KEY.fromPoint(newPoint);
this.chainCode = hmac.slice(hmacHalfLength);
}
this.parentFingerprint = getBytes(this.getFingerprint());
this.depth += 1;
this.index = index;
this.fingerprint = getBytes(this.getFingerprint());
return this;
}
else if (['SLIP10-Ed25519', 'SLIP10-Ed25519-Blake2b', 'SLIP10-Ed25519-Monero'].includes(this.ecc.NAME)) {
if (!this.privateKey) {
throw new DerivationError(`On ${this.ecc.NAME} ECC, public key derivation is not supported`);
}
const indexBytes = integerToBytes(index, 4, 'big'); // struct.pack(">L", index)
const data = concatBytes(integerToBytes(0x00, 1), this.privateKey.getRaw(), indexBytes);
const hmac = hmacSha512(this.chainCode, data);
const hmacL = hmac.slice(0, hmacHalfLength);
const hmacR = hmac.slice(hmacHalfLength);
const newPrivateKey = this.ecc.PRIVATE_KEY.fromBytes(hmacL);
this.privateKey = newPrivateKey;
this.chainCode = hmacR;
this.publicKey = newPrivateKey.getPublicKey();
this.parentFingerprint = getBytes(this.getFingerprint());
this.depth += 1;
this.index = index;
this.fingerprint = getBytes(this.getFingerprint());
return this;
}
else if (['SLIP10-Nist256p1', 'SLIP10-Secp256k1'].includes(this.ecc.NAME)) {
const indexBytes = integerToBytes(index, 4, 'big');
if (!this.rootPrivateKey && !this.rootPublicKey) {
throw new DerivationError('You can\'t drive this, root/master key are required');
}
if (!this.chainCode) {
throw new DerivationError('You can\'t drive private_key and private_key');
}
let data;
if (index & 0x80000000) {
if (!this.privateKey) {
throw new DerivationError('Hardened derivation path is invalid for xpublic key');
}
data = concatBytes(integerToBytes(0x00, 1), this.privateKey.getRaw(), indexBytes);
}
else {
data = concatBytes(this.publicKey.getRawCompressed(), indexBytes);
}
const hmac = hmacSha512(this.chainCode, data);
const hmacL = hmac.slice(0, hmacHalfLength);
const hmacR = hmac.slice(hmacHalfLength);
const hmacLInt = bytesToInteger(hmacL);
if (hmacLInt > this.ecc.ORDER) {
return null;
}
if (this.privateKey) {
const privInt = bytesToInteger(this.privateKey.getRaw());
const keyInt = (hmacLInt + privInt) % this.ecc.ORDER;
if (keyInt === BigInt(0)) {
return null;
}
const newPriv = this.ecc.PRIVATE_KEY.fromBytes(integerToBytes(keyInt, 32));
this.parentFingerprint = getBytes(this.getFingerprint());
this.privateKey = newPriv;
this.chainCode = hmacR;
this.publicKey = newPriv.getPublicKey();
}
else {
const tweak = bytesToInteger(hmacL);
const newPoint = this.publicKey.getPoint().add(this.ecc.GENERATOR.multiply(tweak));
const newPub = this.ecc.PUBLIC_KEY.fromPoint(newPoint);
this.parentFingerprint = getBytes(this.getFingerprint());
this.chainCode = hmacR;
this.publicKey = newPub;
}
this.depth += 1;
this.index = index;
this.fingerprint = getBytes(this.getFingerprint());
return this;
}
}
getSeed() {
return this.seed ? bytesToString(this.seed) : null;
}
getRootXPrivateKey(version = Bitcoin.NETWORKS.MAINNET.XPRIVATE_KEY_VERSIONS.P2PKH, encoded = true) {
if (!this.getRootPrivateKey() || !this.getRootChainCode())
return null;
return serialize(typeof version === 'number' ? integerToBytes(version) : version, this.rootDepth, new Uint8Array(4), this.rootIndex, this.getRootChainCode(), '00' + this.getRootPrivateKey(), encoded);
}
getRootXPublicKey(version = Bitcoin.NETWORKS.MAINNET.XPUBLIC_KEY_VERSIONS.P2PKH, encoded = true) {
if (!this.getRootChainCode())
return null;
return serialize(typeof version === 'number' ? integerToBytes(version) : version, this.rootDepth, new Uint8Array(4), this.rootIndex, this.getRootChainCode(), this.getRootPublicKey(PUBLIC_KEY_TYPES.COMPRESSED), encoded);
}
getRootPrivateKey() {
return this.rootPrivateKey ? bytesToString(this.rootPrivateKey.getRaw()) : null;
}
getRootWIF(wifType) {
if (!this.wifPrefix || !this.getRootPrivateKey())
return null;
const type = wifType ?? this.wifType;
if (!Object.values(WIF_TYPES).includes(type)) {
throw new BaseError(`Invalid ${this.getName()} WIF type`, {
expected: Object.values(WIF_TYPES),
got: type
});
}
return privateKeyToWIF(this.getRootPrivateKey(), type, this.wifPrefix);
}
getRootChainCode() {
return this.rootChainCode ? bytesToString(this.rootChainCode) : null;
}
getRootPublicKey(publicKeyType = this.publicKeyType) {
if (!this.rootPublicKey)
return null;
if (publicKeyType === PUBLIC_KEY_TYPES.UNCOMPRESSED) {
return bytesToString(this.rootPublicKey.getRawUncompressed());
}
else if (publicKeyType === PUBLIC_KEY_TYPES.COMPRESSED) {
return bytesToString(this.rootPublicKey.getRawCompressed());
}
throw new BaseError(`Invalid ${this.getName()} public key type`, {
expected: Object.values(PUBLIC_KEY_TYPES),
got: publicKeyType
});
}
getXPrivateKey(version = Bitcoin.NETWORKS.MAINNET.XPRIVATE_KEY_VERSIONS.P2PKH, encoded = true) {
if (!this.getPrivateKey() || !this.getChainCode())
return null;
return serialize(typeof version === 'number' ? integerToBytes(version) : version, this.depth, this.getParentFingerprint(), this.index, this.getChainCode(), '00' + this.getPrivateKey(), encoded);
}
getXPublicKey(version = Bitcoin.NETWORKS.MAINNET.XPUBLIC_KEY_VERSIONS.P2PKH, encoded = true) {
if (!this.getChainCode())
return null;
return serialize(typeof version === 'number' ? integerToBytes(version) : version, this.depth, this.getParentFingerprint(), this.index, this.getChainCode(), this.getPublicKey(PUBLIC_KEY_TYPES.COMPRESSED), encoded);
}
getPrivateKey() {
return this.privateKey ? bytesToString(this.privateKey.getRaw()) : null;
}
getWIF(wifType) {
if (!this.wifPrefix || !this.getPrivateKey())
return null;
const type = wifType ?? this.wifType;
if (!Object.values(WIF_TYPES).includes(type)) {
throw new BaseError(`Invalid WIF type`, {
expected: Object.values(WIF_TYPES), got: type
});
}
return privateKeyToWIF(this.getPrivateKey(), type, this.wifPrefix);
}
getWIFType() {
return this.getWIF() ? this.wifType : null;
}
getChainCode() {
return this.chainCode ? bytesToString(this.chainCode) : null;
}
getPublicKey(publicKeyType = this.publicKeyType) {
const type = publicKeyType ?? this.publicKeyType;
if (!Object.values(PUBLIC_KEY_TYPES).includes(type)) {
throw new BaseError(`Invalid public key type`, {
expected: Object.values(PUBLIC_KEY_TYPES), got: type
});
}
return type === PUBLIC_KEY_TYPES.UNCOMPRESSED
? this.getUncompressed() : this.getCompressed();
}
getPublicKeyType() {
return this.publicKeyType;
}
getCompressed() {
return bytesToString(this.publicKey.getRawCompressed());
}
getUncompressed() {
return bytesToString(this.publicKey.getRawUncompressed());
}
getHash() {
return bytesToString(ripemd160(sha256(this.getPublicKey())));
}
getFingerprint() {
return this.getHash().slice(0, 8);
}
getParentFingerprint() {
return this.parentFingerprint ? bytesToString(this.parentFingerprint) : null;
}
getDepth() {
return this.depth;
}
getPath() {
return this.derivation.getPath();
}
getIndex() {
return this.index;
}
getIndexes() {
return this.derivation.getIndexes();
}
getStrict() {
return this.strict ?? null;
}
getAddress(options = {
address: Bitcoin.ADDRESSES.P2PKH,
publicKeyAddressPrefix: Bitcoin.NETWORKS.MAINNET.PUBLIC_KEY_ADDRESS_PREFIX,
scriptAddressPrefix: Bitcoin.NETWORKS.MAINNET.SCRIPT_ADDRESS_PREFIX,
hrp: Bitcoin.NETWORKS.MAINNET.HRP,
witnessVersion: Bitcoin.NETWORKS.MAINNET.WITNESS_VERSIONS.P2WPKH
}) {
const address = options.address ?? Bitcoin.ADDRESSES.P2PKH;
const publicKeyAddressPrefix = options.publicKeyAddressPrefix ?? Bitcoin.NETWORKS.MAINNET.PUBLIC_KEY_ADDRESS_PREFIX;
const scriptAddressPrefix = options.scriptAddressPrefix ?? Bitcoin.NETWORKS.MAINNET.SCRIPT_ADDRESS_PREFIX;
const hrp = options.hrp ?? Bitcoin.NETWORKS.MAINNET.HRP;
const witnessVersion = options.witnessVersion ?? Bitcoin.NETWORKS.MAINNET.WITNESS_VERSIONS.P2WPKH;
if (address === P2PKHAddress.getName()) {
return P2PKHAddress.encode(this.publicKey, {
publicKeyAddressPrefix: publicKeyAddressPrefix,
publicKeyType: this.publicKeyType
});
}
else if (address === P2SHAddress.getName()) {
return P2SHAddress.encode(this.publicKey, {
scriptAddressPrefix: scriptAddressPrefix,
publicKeyType: this.publicKeyType
});
}
else if (address === P2TRAddress.getName()) {
return P2TRAddress.encode(this.publicKey, {
hrp: hrp,
witnessVersion: witnessVersion,
publicKeyType: this.publicKeyType
});
}
else if (address === P2WPKHAddress.getName()) {
return P2WPKHAddress.encode(this.publicKey, {
hrp: hrp,
witnessVersion: witnessVersion,
publicKeyType: this.publicKeyType
});
}
else if (address === P2WPKHInP2SHAddress.getName()) {
return P2WPKHInP2SHAddress.encode(this.publicKey, {
scriptAddressPrefix: scriptAddressPrefix,
publicKeyType: this.publicKeyType
});
}
else if (address === P2WSHAddress.getName()) {
return P2WSHAddress.encode(this.publicKey, {
hrp: hrp,
witnessVersion: witnessVersion,
publicKeyType: this.publicKeyType
});
}
else if (address === P2WSHInP2SHAddress.getName()) {
return P2WSHInP2SHAddress.encode(this.publicKey, {
scriptAddressPrefix: scriptAddressPrefix,
publicKeyType: this.publicKeyType
});
}
throw new AddressError(`Invalid ${this.getName()} address`, {
expected: [
P2PKHAddress.getName(),
P2SHAddress.getName(),
P2TRAddress.getName(),
P2WPKHAddress.getName(),
P2WPKHInP2SHAddress.getName(),
P2WSHAddress.getName(),
P2WSHInP2SHAddress.getName()
],
got: address
});
}
}
// SPDX-License-Identifier: MIT
class AlgorandHD extends BIP32HD {
constructor() {
super({ ecc: KholawEd25519ECC });
}
static getName() {
return 'Algorand';
}
fromSeed(seed) {
const rawSeed = getBytes(seed.getSeed?.() ?? seed);
if (rawSeed.length < 16) {
throw new SeedError('Invalid seed length: expected >= 16 bytes');
}
const k = sha512(rawSeed);
let kL = new Uint8Array(k.slice(0, 32));
let kR = k.slice(32, 64);
const clampKL = (kL) => {
kL[0] &= 0b11111000;
kL[31] &= 0b01111111;
kL[31] |= 0b01000000;
return kL;
};
while ((kL[31] & 0b00100000) !== 0) {
const updated = hmacSha512(kL, kR);
kL = new Uint8Array(updated.slice(0, 32));
kR = updated.slice(32, 64);
}
kL = clampKL(kL);
const chainCode = sha256(Uint8Array.from([0x01, ...rawSeed]));
this.seed = rawSeed;
this.rootPrivateKey = this.ecc.PRIVATE_KEY.fromBytes(new Uint8Array([...kL, ...kR]));
this.rootChainCode = chainCode;
this.privateKey = this.rootPrivateKey;
this.chainCode = chainCode;
this.parentFingerprint = new Uint8Array(4); // 0x00000000
this.rootPublicKey = this.privateKey.getPublicKey();
this.publicKey = this.rootPublicKey;
this.strict = true;
return this;
}
drive(index) {
const G = 9;
const indexBytes = integerToBytes(index, 4, 'little');
const cc = this.chainCode;
if (!cc)
throw new DerivationError('Chain code is not set');
const trunc256MinusGBits = (buf, g) => {
const out = buf.slice();
let remaining = g;
for (let i = out.length - 1; i >= 0 && remaining > 0; i--) {
if (remaining >= 8) {
out[i] = 0;
remaining -= 8;
}
else {
out[i] &= 0xff >> remaining;
break;
}
}
return out;
};
let childCC;
// Hardened
if (index & 0x80000000) {
if (!this.privateKey)
throw new DerivationError('Private key required for hardened derivation');
const rawKey = this.privateKey.getRaw();
const kL = rawKey.slice(0, 32);
const kR = rawKey.slice(32);
const z = hmacSha512(cc, Uint8Array.from([0x00, ...kL, ...kR, ...indexBytes]));
const zL = trunc256MinusGBits(z.slice(0, 32), G);
const zR = z.slice(32);
childCC = hmacSha512(cc, Uint8Array.from([0x01, ...kL, ...kR, ...indexBytes])).slice(32);
const kLInt = bytesToInteger(kL, true);
const zLInt = bytesToInteger(zL, true);
const newKL = integerToBytes(kLInt + BigInt(8) * zLInt, 32, 'little');
const newKR = integerToBytes((bytesToInteger(kR, true) + bytesToInteger(zR, true)) % BigInt(2 ** 256), 32, 'little');
if (bytesToInteger(newKL, true) >= 2 ** 255) {
throw new DerivationError('zL * 8 + kL exceeds Ed25519 scalar limit');
}
const childKey = this.ecc.PRIVATE_KEY.fromBytes(new Uint8Array([...newKL, ...newKR]));
this.privateKey = childKey;
this.parentFingerprint = getBytes(this.getFingerprint());
this.publicKey = childKey.getPublicKey();
}
else {
if (!this.publicKey)
throw new DerivationError('Public key required for non-hardened derivation');
const A = this.publicKey.getRawCompressed().slice(1);
const z = hmacSha512(cc, Uint8Array.from([0x02, ...A, ...indexBytes]));
const zL = trunc256MinusGBits(z.slice(0, 32), G);
childCC = hmacSha512(cc, Uint8Array.from([0x03, ...A, ...indexBytes])).slice(32);
const scalar = BigInt(8) * bytesToInteger(zL, true);
const point = this.publicKey.getPoint().add(this.ecc.GENERATOR.multiply(scalar));
this.parentFingerprint = getBytes(this.getFingerprint());
this.publicKey = this.ecc.PUBLIC_KEY.fromPoint(point);
}
this.chainCode = childCC;
this.depth += 1;
this.index = index;
this.fingerprint = getBytes(this.getFingerprint());
return this;
}
getRootXPrivateKey(version = Algorand.NETWORKS.MAINNET.XPRIVATE_KEY_VERSIONS.P2PKH, encoded = true) {
return super.getRootXPrivateKey(version, encoded);
}
getXPrivateKey(version = Algorand.NETWORKS.MAINNET.XPRIVATE_KEY_VERSIONS.P2PKH, encoded = true) {
return super.getXPrivateKey(version, encoded);
}
getAddress() {
return AlgorandAddress.encode(this.publicKey);
}
}
// SPDX-License-Identifier: MIT
class BIP44HD extends BIP32HD {
coinType;
constructor(options = {
publicKeyType: PUBLIC_KEY_TYPES.COMPRESSED
}) {
super(options);
this.coinType = options.coinType ?? Bitcoin.COIN_TYPE;
this.derivation = new BIP44Derivation({
coinType: this.coinType,
account: options.account ?? 0,
change: options.change ?? CHANGES.EXTERNAL_CHAIN,
address: options.address ?? 0
});
}
static getName() {
return 'BIP44';
}
fromCoinType(coinType) {
this.cleanDerivation();
this.derivation.fromCoinType(coinType);
this.fromDerivation(this.derivation);
return this;
}
fromAccount(account) {
this.cleanDerivation();
this.derivation.fromAccount(account);
this.fromDerivation(this.derivation);
return this;
}
fromChange(change) {
this.cleanDerivation();
this.derivation.fromChange(change);
this.fromDerivation(this.derivation);
return this;
}
fromAddress(address) {
this.cleanDerivation();
this.derivation.fromAddress(address);
this.fromDerivation(this.derivation);
return this;
}
fromDerivation(derivation) {
this.cleanDerivation();
this.derivation = ensureTypeMatch(derivation, BIP44Derivation, { errorClass: DerivationError });
for (const index of this.derivation.getIndexes()) {
this.drive(index);
}
return this;
}
getAddress(options = {
publicKeyAddressPrefix: Bitcoin.NETWORKS.MAINNET.PUBLIC_KEY_ADDRESS_PREFIX
}) {
return P2PKHAddress.encode(this.publicKey, {
publicKeyAddressPrefix: options.publicKeyAddressPrefix ?? Bitcoin.NETWORKS.MAINNET.PUBLIC_KEY_ADDRESS_PREFIX,
publicKeyType: this.publicKeyType
});
}
}
// SPDX-License-Identifier: MIT
class BIP49HD extends BIP44HD {
constructor(options = {
publicKeyType: PUBLIC_KEY_TYPES.COMPRESSED
}) {
super(options);
this.coinType = options.coinType ?? Bitcoin.COIN_TYPE;
this.derivation = new BIP49Derivation({
coinType: this.coinType,
account: options.account ?? 0,
change: options.change ?? CHANGES.EXTERNAL_CHAIN,
address: options.address ?? 0
});
}
static getName() {
return 'BIP49';
}
fromDerivation(derivation) {
this.cleanDerivation();
this.derivation = ensureTypeMatch(derivation, BIP49Derivation, { errorClass: DerivationError });
for (const index of this.derivation.getIndexes()) {
this.drive(index);
}
return this;
}
getRootXPrivateKey(version = Bitcoin.NETWORKS.MAINNET.XPRIVATE_KEY_VERSIONS.P2WPKH_IN_P2SH, encoded = true) {
if (!this.getRootPrivateKey() || !this.getRootChainCode())
return null;
return serialize(typeof version === 'number' ? integerToBytes(version) : version, this.rootDepth, new Uint8Array(4), this.rootIndex, this.getRootChainCode(), '00' + this.getRootPrivateKey(), encoded);
}
getRootXPublicKey(version = Bitcoin.NETWORKS.MAINNET.XPUBLIC_KEY_VERSIONS.P2WPKH_IN_P2SH, encoded = true) {
if (!this.getRootChainCode())
return null;
return serialize(typeof version === 'number' ? integerToBytes(version) : version, this.rootDepth, new Uint8Array(4), this.rootIndex, this.getRootChainCode(), this.getRootPublicKey(PUBLIC_KEY_TYPES.COMPRESSED), encoded);
}
getXPrivateKey(version = Bitcoin.NETWORKS.MAINNET.XPRIVATE_KEY_VERSIONS.P2WPKH_IN_P2SH, encoded = true) {
if (!this.getPrivateKey() || !this.getChainCode())
return null;
return serialize(typeof version === 'number' ? integerToBytes(version) : version, this.depth, this.getParentFingerprint(), this.index, this.getChainCode(), '00' + this.getPrivateKey(), encoded);
}
getXPublicKey(version = Bitcoin.NETWORKS.MAINNET.XPUBLIC_KEY_VERSIONS.P2WPKH_IN_P2SH, encoded = true) {
if (!this.getChainCode())
return null;
return serialize(typeof version === 'number' ? integerToBytes(version) : version, this.depth, this.getParentFingerprint(), this.index, this.getChainCode(), this.getPublicKey(PUBLIC_KEY_TYPES.COMPRESSED), encoded);
}
getAddress(options = {
scriptAddressPrefix: Bitcoin.NETWORKS.MAINNET.SCRIPT_ADDRESS_PREFIX
}) {
return P2WPKHInP2SHAddress.encode(this.publicKey, {
scriptAddressPrefix: options.scriptAddressPrefix ?? Bitcoin.NETWORKS.MAINNET.SCRIPT_ADDRESS_PREFIX,
publicKeyType: this.publicKeyType
});
}
}
// SPDX-License-Identifier: MIT
class BIP84HD extends BIP44HD {
constructor(options = {
publicKeyType: PUBLIC_KEY_TYPES.COMPRESSED
}) {
super(options);
this.coinType = options.coinType ?? Bitcoin.COIN_TYPE;
this.derivation = new BIP84Derivation({
coinType: this.coinType,
account: options.account ?? 0,
change: options.change ?? CHANGES.EXTERNAL_CHAIN,
address: options.address ?? 0
});
}
static getName() {
return 'BIP84';
}
fromDerivation(derivation) {
this.cleanDerivation();
this.derivation = ensureTypeMatch(derivation, BIP84Derivation, { errorClass: DerivationError });
for (const index of this.derivation.getIndexes()) {
this.drive(index);
}
return this;
}
getRootXPrivateKey(version = Bitcoin.NETWORKS.MAINNET.XPRIVATE_KEY_VERSIONS.P2WPKH, encoded = true) {
if (!this.getRootPrivateKey() || !this.getRootChainCode())
return null;
return serialize(typeof version === 'number' ? integerToBytes(version) : version, this.rootDepth, new Uint8Array(4), this.rootIndex, this.getRootChainCode(), '00' + this.getRootPrivateKey(), encoded);
}
getRootXPublicKey(version = Bitcoin.NETWORKS.MAINNET.XPUBLIC_KEY_VERSIONS.P2WPKH, encoded = true) {
if (!this.getRootChainCode())
return null;
return serialize(typeof version === 'number' ? integerToBytes(version) : version, this.rootDepth, new Uint8Array(4), this.rootIndex, this.getRootChainCode(), this.getRootPublicKey(PUBLIC_KEY_TYPES.COMPRESSED), encoded);
}
getXPrivateKey(version = Bitcoin.NETWORKS.MAINNET.XPRIVATE_KEY_VERSIONS.P2WPKH, encoded = true) {
if (!this.getPrivateKey() || !this.getChainCode())
return null;
return serialize(typeof version === 'number' ? integerToBytes(version) : version, this.depth, this.getParentFingerprint(), this.index, this.getChainCode(), '00' + this.getPrivateKey(), encoded);
}
getXPublicKey(version = Bitcoin.NETWORKS.MAINNET.XPUBLIC_KEY_VERSIONS.P2WPKH, encoded = true) {
if (!this.getChainCode())
return null;
return serialize(typeof version === 'number' ? integerToBytes(version) : version, this.depth, this.getParentFingerprint(), this.index, this.getChainCode(), this.getPublicKey(PUBLIC_KEY_TYPES.COMPRESSED), encoded);
}
getAddress(options = {
hrp: Bitcoin.NETWORKS.MAINNET.HRP,
witnessVersion: Bitcoin.NETWORKS.MAINNET.WITNESS_VERSIONS.P2WPKH
}) {
return P2WPKHAddress.encode(this.publicKey, {
hrp: options.hrp ?? Bitcoin.NETWORKS.MAINNET.HRP,
witnessVersion: options.witnessVersion ?? Bitcoin.NETWORKS.MAINNET.WITNESS_VERSIONS.P2WPKH,
publicKeyType: this.publicKeyType
});
}
}
// SPDX-License-Identifier: MIT
class BIP141HD extends BIP32HD {
address;
xprivateKeyVersion;
xpublicKeyVersion;
semantic;
constructor(options = {
publicKeyType: PUBLIC_KEY_TYPES.COMPRESSED
}) {
super(options);
if (!options.semantic) {
throw new SemanticError('Semantic is required');
}
this.fromSemantic(options.semantic, options);
}
static getName() {
return 'BIP141';
}
getSemantic() {
return this.semantic;
}
fromSemantic(semantic, options = {}) {
if (!SEMANTICS.getTypes().includes(semantic)) {
throw new SemanticError(`Invalid semantic type`, {
expected: SEMANTICS.getTypes(), got: semantic
});
}
this.semantic = semantic;
if (semantic === SEMANTICS.P2WPKH) {
this.address = P2WPKHAddress.getName();
this.xprivateKeyVersion = options.p2wpkhXPrivateKeyVersion ?? Bitcoin.NETWORKS.MAINNET.XPRIVATE_KEY_VERSIONS.P2WPKH;
this.xpublicKeyVersion = options.p2wpkhXPublicKeyVersion ?? Bitcoin.NETWORKS.MAINNET.XPUBLIC_KEY_VERSIONS.P2WPKH;
}
else if (semantic === SEMANTICS.P2WPKH_IN_P2SH) {
this.address = P2WPKHInP2SHAddress.getName();
this.xprivateKeyVersion = options.p2wpkhInP2SHXPrivateKeyVersion ?? Bitcoin.NETWORKS.MAINNET.XPRIVATE_KEY_VERSIONS.P2WPKH_IN_P2SH;
this.xpublicKeyVersion = options.p2wpkhInP2SHXPublicKeyVersion ?? Bitcoin.NETWORKS.MAINNET.XPUBLIC_KEY_VERSIONS.P2WPKH_IN_P2SH;
}
else if (semantic === SEMANTICS.P2WSH) {
this.address = P2WSHAddress.getName();
this.xprivateKeyVersion = options.p2wshXPrivateKeyVersion ?? Bitcoin.NETWORKS.MAINNET.XPRIVATE_KEY_VERSIONS.P2WSH;
this.xpublicKeyVersion = options.p2wshXPublicKeyVersion ?? Bitcoin.NETWORKS.MAINNET.XPUBLIC_KEY_VERSIONS.P2WSH;
}
else if (semantic === SEMANTICS.P2WSH_IN_P2SH) {
this.address = P2WSHInP2SHAddress.getName();
this.xprivateKeyVersion = options.p2wshInP2SHXPrivateKeyVersion ?? Bitcoin.NETWORKS.MAINNET.XPRIVATE_KEY_VERSIONS.P2WSH_IN_P2SH;
this.xpublicKeyVersion = options.p2wshInP2SHXPublicKeyVersion ?? Bitcoin.NETWORKS.MAINNET.XPUBLIC_KEY_VERSIONS.P2WSH_IN_P2SH;
}
return this;
}
getRootXPrivateKey(version, encoded = true) {
return super.getRootXPrivateKey(version ?? this.xprivateKeyVersion, encoded);
}
getRootXPublicKey(version, encoded = true) {
return super.getRootXPublicKey(version ?? this.xpublicKeyVersion, encoded);
}
getXPrivateKey(version, encoded = true) {
return super.getXPrivateKey(version ?? this.xprivateKeyVersion, encoded);
}
getXPublicKey(version, encoded = true) {
return super.getXPublicKey(version ?? this.xpublicKeyVersion, encoded);
}
getAddress(options = {
address: this.address,
scriptAddressPrefix: Bitcoin.NETWORKS.MAINNET.SCRIPT_ADDRESS_PREFIX,
hrp: Bitcoin.NETWORKS.MAINNET.HRP,
witnessVersion: Bitcoin.NETWORKS.MAINNET.WITNESS_VERSIONS.P2WPKH
}) {
const address = options?.address ?? this.address;
const scriptAddressPrefix = options.scriptAddressPrefix ?? Bitcoin.NETWORKS.MAINNET.SCRIPT_ADDRESS_PREFIX;
const hrp = options.hrp ?? Bitcoin.NETWORKS.MAINNET.HRP;
const witnessVersion = options.witnessVersion ?? Bitcoin.NETWORKS.MAINNET.WITNESS_VERSIONS.P2WPKH;
if (address === P2WPKHAddress.getName()) {
return P2WPKHAddress.encode(this.publicKey, {
hrp: hrp,
witnessVersion: witnessVersion,
publicKeyType: this.publicKeyType
});
}
else if (address === P2WPKHInP2SHAddress.getName()) {
return P2WPKHInP2SHAddress.encode(this.publicKey, {
scriptAddressPrefix: scriptAddressPrefix,
publicKeyType: this.publicKeyType
});
}
else if (address === P2WSHAddress.getName()) {
return P2WSHAddress.encode(this.publicKey, {
hrp: hrp,
witnessVersion: witnessVersion,
publicKeyType: this.publicKeyType
});
}
else if (address === P2WSHInP2SHAddress.getName()) {
return P2WSHInP2SHAddress.encode(this.publicKey, {
scriptAddressPrefix: scriptAddressPrefix,
publicKeyType: this.publicKeyType
});
}
throw new AddressError(`Invalid ${BIP141HD.getName()} address`, {
expected: [
P2WPKHAddress.getName(),
P2WPKHInP2SHAddress.getName(),
P2WSHAddress.getName(),
P2WSHInP2SHAddress.getName()
],
got: address
});
}
}
// SPDX-License-Identifier: MIT
class BIP86HD extends BIP44HD {
constructor(options = {
publicKeyType: PUBLIC_KEY_TYPES.COMPRESSED
}) {
super(options);
this.coinType = options.coinType ?? Bitcoin.COIN_TYPE;
this.derivation = new BIP86Derivation({
coinType: this.coinType,
account: options.account ?? 0,
change: options.change ?? CHANGES.EXTERNAL_CHAIN,
address: options.address ?? 0
});
}
static getName() {
return 'BIP86';
}
fromDerivation(derivation) {
this.cleanDerivation();
this.derivation = ensureTypeMatch(derivation, BIP86Derivation, { errorClass: DerivationError });
for (const index of this.derivation.getIndexes()) {
this.drive(index);
}
return this;
}
getRootXPrivateKey(version = Bitcoin.NETWORKS.MAINNET.XPRIVATE_KEY_VERSIONS.P2TR, encoded = true) {
if (!this.getRootPrivateKey() || !this.getRootChainCode())
return null;
return serialize(typeof version === 'number' ? integerToBytes(version) : version, this.rootDepth, new Uint8Array(4), this.rootIndex, this.getRootChainCode(), '00' + this.getRootPrivateKey(), encoded);
}
getRootXPublicKey(version = Bitcoin.NETWORKS.MAINNET.XPUBLIC_KEY_VERSIONS.P2TR, encoded = true) {
if (!this.getRootChainCode())
return null;
return serialize(typeof version === 'number' ? integerToBytes(version) : version, this.rootDepth, new Uint8Array(4), this.rootIndex, this.getRootChainCode(), this.getRootPublicKey(PUBLIC_KEY_TYPES.COMPRESSED), encoded);
}
getXPrivateKey(version = Bitcoin.NETWORKS.MAINNET.XPRIVATE_KEY_VERSIONS.P2TR, encoded = true) {
if (!this.getPrivateKey() || !this.getChainCode())
return null;
return serialize(typeof version === 'number' ? integerToBytes(version) : version, this.depth, this.getParentFingerprint(), this.index, this.getChainCode(), '00' + this.getPrivateKey(), encoded);
}
getXPublicKey(version = Bitcoin.NETWORKS.MAINNET.XPUBLIC_KEY_VERSIONS.P2TR, encoded = true) {
if (!this.getChainCode())
return null;
return serialize(typeof version === 'number' ? integerToBytes(version) : version, this.depth, this.getParentFingerprint(), this.index, this.getChainCode(), this.getPublicKey(PUBLIC_KEY_TYPES.COMPRESSED), encoded);
}
getAddress(options = {
hrp: Bitcoin.NETWORKS.MAINNET.HRP,
witnessVersion: Bitcoin.NETWORKS.MAINNET.WITNESS_VERSIONS.P2TR
}) {
return P2TRAddress.encode(this.publicKey, {
hrp: options.hrp ?? Bitcoin.NETWORKS.MAINNET.HRP,
witnessVersion: options.witnessVersion ?? Bitcoin.NETWORKS.MAINNET.WITNESS_VERSIONS.P2TR,
publicKeyType: this.publicKeyType
});
}
}
// SPDX-License-Identifier: MIT
class CardanoHD extends BIP32HD {
cardanoType;
constructor(options = {
publicKeyType: PUBLIC_KEY_TYPES.COMPRESSED
}) {
options.ecc = KholawEd25519ECC;
super(options);
if (!options.cardanoType || !Cardano.TYPES.getCardanoTypes().includes(options.cardanoType)) {
throw new BaseError('Invalid Cardano type', {
expected: Cardano.TYPES.getCardanoTypes(), got: options.cardanoType
});
}
this.cardanoType = options.cardanoType;
}
static getName() {
return 'Cardano';
}
fromSeed(seed, passphrase) {
try {
this.seed = getBytes(seed instanceof Seed ? seed.getSeed() : seed);
}
catch {
throw new SeedError('Invalid seed data');
}
const digestSize = 64;
const hmacHalfLength = digestSize / 2;
const tweakMasterKeyBits = (data) => {
const d = new Uint8Array(data);
d[0] = resetBits(d[0], 0x07);
d[31] = resetBits(d[31], this.cardanoType === Cardano.TYPES.BYRON_ICARUS || this.cardanoType === Cardano.TYPES.SHELLEY_ICARUS ? 0xE0 : 0x80);
d[31] = setBits(d[31], 0x40);
return d;
};
if (this.cardanoType === Cardano.TYPES.BYRON_LEGACY) {
if (this.seed.length !== 32) {
throw new BaseError('Invalid seed length', {
expected: 32, got: this.seed.length
});
}
const digestSize = 64;
const data = Q(this.seed);
let iteration = 1;
while (true) {
const label = toBuffer(`Root Seed Chain ${iteration}`);
const i = hmacSha512(data, label);
let il = sha512(i.slice(0, digestSize / 2));
const ir = i.slice(digestSize / 2);
il = toBuffer(tweakMasterKeyBits(il));
if (!areBitsSet(il[31], 0x20)) {
this.rootPrivateKey = this.ecc.PRIVATE_KEY.fromBytes(il);
this.rootChainCode = ir;
break;
}
iteration++;
}
}
else if ([Cardano.TYPES.BYRON_ICARUS, Cardano.TYPES.SHELLEY_ICARUS].includes(this.cardanoType)) {
if (this.seed.length < 16) {
throw new BaseError('Invalid seed length', { expected: '>= 16', got: this.seed.length });
}
const k = tweakMasterKeyBits(pbkdf2HmacSha512(passphrase ?? '', this.seed, 4096, 96));
this.rootPrivateKey = this.ecc.PRIVATE_KEY.fromBytes(k.slice(0, KholawEd25519PrivateKey.getLength()));
this.rootChainCode = k.slice(KholawEd25519PrivateKey.getLength());
}
else if ([Cardano.TYPES.BYRON_LEDGER, Cardano.TYPES.SHELLEY_LEDGER].includes(this.cardanoType)) {
if (this.seed.length < 16) {
throw new BaseError('Invalid seed length', { expected: '>= 16', got: this.seed.length });
}
let hmacData = this.seed;
let hmac;
while (true) {
hmac = hmacSha512(getHmac(this.ecc.NAME), hmacData);
if ((hmac[31] & 0x20) === 0)
break;
hmacData = hmac;
}
let kl = tweakMasterKeyBits(hmac.slice(0, hmacHalfLength));
const kr = hmac.slice(hmacHalfLength);
const chainCode = hmacSha256(getHmac(this.ecc.NAME), concatBytes(toBuffer([0x01]), this.seed));
this.rootPrivateKey = this.ecc.PRIVATE_KEY.fromBytes(concatBytes(kl, kr));
this.rootChainCode = chainCode;
}
this.rootPublicKey = this.rootPrivateKey.getPublicKey();
this.privateKey = this.rootPrivateKey;
this.chainCode = this.rootChainCode;
this.parentFingerprint = new Uint8Array(4);
this.publicKey = this.privateKey.getPublicKey();
this.strict = true;
return this;
}
fromPrivateKey(privateKey) {
if ([Cardano.TYPES.BYRON_ICARUS, Cardano.TYPES.BYRON_LEGACY, Cardano.TYPES.BYRON_LEDGER].includes(this.cardanoType)) {
throw new BaseError(`From private key not supported for ${this.cardanoType}`);
}
try {
this.privateKey = this.ecc.PRIVATE_KEY.fromBytes(getBytes(privateKey));
this.publicKey = this.privateKey.getPublicKey();
this.strict = null;
return this;
}
catch {
throw new PrivateKeyError('Invalid private key data');
}
}
fromPublicKey(publicKey) {
if ([Cardano.TYPES.BYRON_ICARUS, Cardano.TYPES.BYRON_LEGACY, Cardano.TYPES.BYRON_LEDGER].includes(this.cardanoType)) {
throw new BaseError(`From public key not supported for ${this.cardanoType}`);
}
try {
this.publicKey = this.ecc.PUBLIC_KEY.fromBytes(getBytes(publicKey));
this.strict = null;
return this;
}
catch {
throw new PublicKeyError('Invalid public key data');
}
}
drive(index) {
const digestHalf = 32; // sha512().digest_size / 2
const isLegacy = this.cardanoType === Cardano.TYPES.BYRON_LEGACY;
const indexBytes = integerToBytes(index, 4, isLegacy ? 'big' : 'little');
if (this.privateKey) {
let zHmac, hmac;
if (index & 0x80000000) {
zHmac = hmacSha512(this.chainCode, concatBytes(toBuffer([0x00]), this.privateKey.getRaw(), indexBytes));
hmac = hmacSha512(this.chainCode, concatBytes(toBuffer([0x01]), this.privateKey.getRaw(), indexBytes));
}
else {
const pubRaw = this.publicKey.getRawCompressed().slice(1);
zHmac = hmacSha512(this.chainCode, concatBytes(toBuffer([0x02]), pubRaw, indexBytes));
hmac = hmacSha512(this.chainCode, concatBytes(toBuffer([0x03]), pubRaw, indexBytes));
}
const zl = zHmac.slice(0, digestHalf);
const zr = zHmac.slice(digestHalf);
const kl = this.privateKey.getRaw().slice(0, digestHalf);
const kr = this.privateKey.getRaw().slice(digestHalf);
const _hmacr = hmac.slice(digestHalf);
const left = isLegacy
? integerToBytes((bytesToInteger(multiplyScalarNoCarry(toBuffer(zl), 8), true) + bytesToInteger(kl, true)) % this.ecc.ORDER, 32, 'little')
: (() => {
const zlInt = bytesToInteger(zl.slice(0, 28), true);
const klInt = bytesToInteger(kl, true);
const leftInt = zlInt * BigInt(8) + klInt;
if (leftInt % this.ecc.ORDER === BigInt(0))
throw new BaseError('Invalid child private key');
return integerToBytes(leftInt, KholawEd25519PrivateKey.getLength() / 2, 'little');
})();
const right = isLegacy
? addNoCarry(toBuffer(zr), toBuffer(kr))
: (() => {
const zrInt = bytesToInteger(zr, true);
const krInt = bytesToInteger(kr, true);
const sum = (zrInt + krInt) % (BigInt(1) << BigInt(256));
return integerToBytes(sum, KholawEd25519PrivateKey.getLength() / 2, 'little');
})();
this.parentFingerprint = getBytes(this.getFingerprint());
const newPrivateKey = this.ecc.PRIVATE_KEY.fromBytes(concatBytes(left, right));
this.privateKey = newPrivateKey;
this.chainCode = _hmacr;
this.publicKey = newPrivateKey.getPublicKey();
}
else {
if (index & 0x80000000) {
throw new DerivationError('Hardened derivation path is invalid for xpublic key');
}
const pubRaw = this.publicKey.getRawCompressed().slice(1);
const zHmac = hmacSha512(this.chainCode, concatBytes(toBuffer([0x02]), pubRaw, indexBytes));
const hmac = hmacSha512(this.chainCode, concatBytes(toBuffer([0x03]), pubRaw, indexBytes));
const zl = zHmac.slice(0, digestHalf);
const tweak = isLegacy
? bytesToInteger(multiplyScalarNoCarry(zl, 8), true)
: bytesToInteger(zl.slice(0, 28), true) * BigInt(8);
const newPoint = this.publicKey.getPoint().add(this.ecc.GENERATOR.multiply(tweak));
if (newPoint.getX() === BigInt(0) && newPoint.getY() === BigInt(1)) {
throw new BaseError('Computed public child key is not valid, very unlucky index');
}
this.parentFingerprint = getBytes(this.getFingerprint());
this.publicKey = this.ecc.PUBLIC_KEY.fromPoint(newPoint);
this.chainCode = hmac.slice(digestHalf);
}
this.depth += 1;
this.index = index;
this.fingerprint = getBytes(this.getFingerprint());
return this;
}
getRootXPrivateKey(version = Cardano.NETWORKS.MAINNET.XPRIVATE_KEY_VERSIONS.P2PKH, encoded = true) {
return super.getRootXPrivateKey(version, encoded);
}
getXPrivateKey(version = Cardano.NETWORKS.MAINNET.XPRIVATE_KEY_VERSIONS.P2PKH, encoded = true) {
return super.getXPrivateKey(version, encoded);
}
getPathKey() {
if (this.cardanoType === Cardano.TYPES.BYRON_LEGACY) {
return bytesToString(pbkdf2HmacSha512(concatBytes(this.rootPublicKey.getRawCompressed().slice(1), this.rootChainCode), 'address-hashing', 500, 32));
}
return null;
}
getAddress(options = {
network: 'mainnet'
}) {
if (this.cardanoType === Cardano.TYPES.BYRON_LEGACY) {
return CardanoAddress.encodeByronLegacy(this.publicKey, this.getPath(), this.getPathKey(), this.chainCode, options.addressType ?? Cardano.ADDRESS_TYPES.PUBLIC_KEY);
}
else if ([Cardano.TYPES.BYRON_ICARUS, Cardano.TYPES.BYRON_LEDGER].includes(this.cardanoType)) {
return CardanoAddress.encodeByronIcarus(this.publicKey, this.chainCode, options.addressType ?? Cardano.ADDRESS_TYPES.PUBLIC_KEY);
}
else if ([Cardano.TYPES.SHELLEY_ICARUS, Cardano.TYPES.SHELLEY_LEDGER].includes(this.cardanoType)) {
const addressType = options.addressType ?? Cardano.ADDRESS_TYPES.PAYMENT;
if (addressType === Cardano.ADDRESS_TYPES.PAYMENT) {
if (!options.stakingPublicKey) {
throw new BaseError('stakingPublicKey is required for Payment address type');
}
return CardanoAddress.encodeShelley(this.publicKey, options.stakingPublicKey, options.network ?? 'mainnet');
}
else if ([Cardano.ADDRESS_TYPES.STAKING, Cardano.ADDRESS_TYPES.REWARD].includes(addressType)) {
return CardanoAddress.encodeShelleyStaking(this.publicKey, options.network ?? 'mainnet');
}
throw new AddressError(`Invalid ${this.cardanoType} address type`, {
expected: [
Cardano.ADDRESS_TYPES.PAYMENT,
Cardano.ADDRESS_TYPES.STAKING,
Cardano.ADDRESS_TYPES.REWARD
],
got: addressType
});
}
throw new AddressError(`Invalid Cardano type`, {
expected: Cardano.TYPES.getCardanoTypes(), got: this.cardanoType
});
}
}
// SPDX-License-Identifier: MIT
class ElectrumV1HD extends HD {
seed;
masterPrivateKey;
masterPublicKey;
privateKey;
publicKey;
publicKeyType;
wifType;
wifPrefix;
constructor(options = {
publicKeyType: PUBLIC_KEY_TYPES.UNCOMPRESSED
}) {
super({ ecc: SLIP10Secp256k1ECC, ...options });
this.publicKeyType = options.publicKeyType ?? PUBLIC_KEY_TYPES.UNCOMPRESSED;
if (this.publicKeyType === PUBLIC_KEY_TYPES.UNCOMPRESSED) {
this.wifType = WIF_TYPES.WIF;
}
else if (this.publicKeyType === PUBLIC_KEY_TYPES.COMPRESSED) {
this.wifType = WIF_TYPES.WIF_COMPRESSED;
}
else {
throw new BaseError('Invalid public key type', {
expected: PUBLIC_KEY_TYPES.getTypes(), got: this.publicKeyType
});
}
this.wifPrefix = options.wifPrefix ?? Bitcoin.NETWORKS.MAINNET.WIF_PREFIX;
this.derivation = new ElectrumDerivation({
change: options.change, address: options.address
});
}
static getName() {
return 'Electrum-V1';
}
fromSeed(seed) {
try {
this.seed = getBytes(seed instanceof Seed ? seed.getSeed() : seed);
return this.fromPrivateKey(this.seed);
}
catch {
throw new SeedError('Invalid seed data');
}
}
fromPrivateKey(key) {
try {
this.masterPrivateKey = SLIP10Secp256k1PrivateKey.fromBytes(getBytes(key));
this.masterPublicKey = this.masterPrivateKey.getPublicKey();
this.fromDerivation(this.derivation);
return this;
}
catch {
throw new PrivateKeyError('Invalid private key data');
}
}
fromWIF(wif) {
if (this.wifPrefix == null)
throw new WIFError('WIF prefix is required');
return this.fromPrivateKey(wifToPrivateKey(wif, this.wifPrefix));
}
fromPublicKey(key) {
try {
this.masterPublicKey = SLIP10Secp256k1PublicKey.fromBytes(getBytes(key));
this.fromDerivation(this.derivation);
return this;
}
catch {
throw new PublicKeyError('Invalid public key error');
}
}
fromDerivation(derivation) {
this.derivation = ensureTypeMatch(derivation, ElectrumDerivation, { errorClass: DerivationError });
this.drive(derivation.getChange(), derivation.getAddress());
return this;
}
updateDerivation(derivation) {
this.cleanDerivation();
return this.fromDerivation(derivation);
}
cleanDerivation() {
this.derivation.clean();
this.fromDerivation(this.derivation);
return this;
}
drive(changeIndex, addressIndex) {
const sequence = doubleSha256(concatBytes(new TextEncoder().encode(`${addressIndex}:${changeIndex}:`), this.masterPublicKey.getRawUncompressed().slice(1)));
if (this.masterPrivateKey) {
const privateKeyInt = (bytesToInteger(this.masterPrivateKey.getRaw()) + bytesToInteger(sequence)) % SLIP10Secp256k1ECC.ORDER;
this.privateKey = SLIP10Secp256k1PrivateKey.fromBytes(integerToBytes(privateKeyInt, SLIP10Secp256k1PrivateKey.getLength()));
this.publicKey = this.privateKey.getPublicKey();
}
else {
this.publicKey = SLIP10Secp256k1PublicKey.fromPoint(this.masterPublicKey.getPoint().add(SLIP10Secp256k1ECC.GENERATOR.multiply(bytesToInteger(sequence))));
}
return this;
}
getSeed() {
return this.seed ? bytesToString(this.seed) : null;
}
getMasterPrivateKey() {
return this.masterPrivateKey ? bytesToString(this.masterPrivateKey.getRaw()) : null;
}
getMasterWIF(wifType) {
if (!this.masterPrivateKey || this.wifPrefix == null)
return null;
const type = wifType ?? this.wifType;
return privateKeyToWIF(this.getMasterPrivateKey(), type, this.wifPrefix);
}
getMasterPublicKey(publicKeyType = this.publicKeyType) {
if (publicKeyType === PUBLIC_KEY_TYPES.UNCOMPRESSED) {
return bytesToString(this.masterPublicKey.getRawUncompressed());
}
else if (publicKeyType === PUBLIC_KEY_TYPES.COMPRESSED) {
return bytesToString(this.masterPublicKey.getRawCompressed());
}
throw new BaseError(`Invalid ${this.getName()} public key type`, {
expected: Object.values(PUBLIC_KEY_TYPES), got: publicKeyType
});
}
getPrivateKey() {
return this.privateKey ? bytesToString(this.privateKey.getRaw()) : null;
}
getWIF(wifType) {
if (!this.privateKey || this.wifPrefix == null)
return null;
const type = wifType ?? this.wifType;
return privateKeyToWIF(this.getPrivateKey(), type, this.wifPrefix);
}
getWIFType() {
return this.wifType;
}
getPublicKey(publicKeyType = this.publicKeyType) {
if (publicKeyType === PUBLIC_KEY_TYPES.UNCOMPRESSED) {
return bytesToString(this.publicKey.getRawUncompressed());
}
else if (publicKeyType === PUBLIC_KEY_TYPES.COMPRESSED) {
return bytesToString(this.publicKey.getRawCompressed());
}
throw new BaseError(`Invalid ${this.getName()} public key type`, {
expected: Object.values(PUBLIC_KEY_TYPES), got: publicKeyType
});
}
getPublicKeyType() {
return this.publicKeyType;
}
getCompressed() {
return bytesToString(this.publicKey.getRawCompressed());
}
getUncompressed() {
return bytesToString(this.publicKey.getRawUncompressed());
}
getAddress(options = {
publicKeyAddressPrefix: Bitcoin.NETWORKS.MAINNET.PUBLIC_KEY_ADDRESS_PREFIX
}) {
return P2PKHAddress.encode(this.publicKey, {
publicKeyAddressPrefix: options.publicKeyAddressPrefix ?? Bitcoin.NETWORKS.MAINNET.PUBLIC_KEY_ADDRESS_PREFIX,
publicKeyType: this.publicKeyType
});
}
}
// SPDX-License-Identifier: MIT
class ElectrumV2HD extends HD {
mode;
wifType;
publicKeyType;
wifPrefix;
bip32HD;
constructor(options = {
publicKeyType: PUBLIC_KEY_TYPES.UNCOMPRESSED,
mode: MODES.STANDARD
}) {
super({ ecc: SLIP10Secp256k1ECC, ...options });
this.mode = options.mode ?? MODES.STANDARD;
if (!MODES.getTypes().includes(this.mode)) {
throw new BaseError(`Invalid ${this.getName()} mode`, {
expected: MODES.getTypes(),
got: this.mode
});
}
this.publicKeyType = options.publicKeyType ?? PUBLIC_KEY_TYPES.UNCOMPRESSED;
if (this.publicKeyType === PUBLIC_KEY_TYPES.UNCOMPRESSED) {
this.wifType = WIF_TYPES.WIF;
}
else if (this.publicKeyType === PUBLIC_KEY_TYPES.COMPRESSED) {
this.wifType = WIF_TYPES.WIF_COMPRESSED;
}
else {
throw new BaseError('Invalid public key type', {
expected: PUBLIC_KEY_TYPES.getTypes(), got: this.publicKeyType
});
}
this.wifPrefix = options.wifPrefix ?? Bitcoin.NETWORKS.MAINNET.WIF_PREFIX;
this.derivation = new ElectrumDerivation({
change: options.change, address: options.address
});
this.bip32HD = new BIP32HD({
ecc: Bitcoin.ECC, publicKeyType: this.publicKeyType
});
}
static getName() {
return 'Electrum-V2';
}
fromSeed(seed) {
this.bip32HD.fromSeed(seed);
this.fromDerivation(this.derivation);
return this;
}
fromDerivation(derivation) {
this.derivation = ensureTypeMatch(derivation, ElectrumDerivation, { errorClass: DerivationError });
this.drive(derivation.getChange(), derivation.getAddress());
return this;
}
updateDerivation(derivation) {
this.cleanDerivation();
return this.fromDerivation(derivation);
}
cleanDerivation() {
this.derivation.clean();
this.fromDerivation(this.derivation);
return this;
}
drive(changeIndex, addressIndex) {
const custom = new CustomDerivation();
if (this.mode === MODES.SEGWIT) {
custom.fromIndex(0, true); // Hardened
}
custom.fromIndex(changeIndex);
custom.fromIndex(addressIndex);
this.bip32HD.updateDerivation(custom);
return this;
}
getMode() {
return this.mode;
}
getSeed() {
return this.bip32HD.getSeed();
}
getMasterPrivateKey() {
return this.bip32HD.getRootPrivateKey();
}
getMasterWIF(wifType) {
if (this.wifPrefix == null)
return null;
const type = wifType ?? this.wifType;
return privateKeyToWIF(this.getMasterPrivateKey(), type, this.wifPrefix);
}
getMasterPublicKey(publicKeyType) {
return this.bip32HD.getRootPublicKey(publicKeyType ?? this.publicKeyType);
}
getPrivateKey() {
return this.bip32HD.getPrivateKey();
}
getWIF(wifType) {
if (this.wifPrefix == null)
return null;
const type = wifType ?? this.wifType;
return privateKeyToWIF(this.getPrivateKey(), type, this.wifPrefix);
}
getWIFType() {
return this.wifType;
}
getPublicKey(publicKeyType) {
return this.bip32HD.getPublicKey(publicKeyType ?? this.publicKeyType);
}
getPublicKeyType() {
return this.publicKeyType;
}
getUncompressed() {
return this.bip32HD.getUncompressed();
}
getCompressed() {
return this.bip32HD.getCompressed();
}
getAddress(options = {
publicKeyAddressPrefix: Bitcoin.NETWORKS.MAINNET.PUBLIC_KEY_ADDRESS_PREFIX,
hrp: Bitcoin.NETWORKS.MAINNET.HRP,
witnessVersion: Bitcoin.NETWORKS.MAINNET.WITNESS_VERSIONS.P2WPKH
}) {
if (this.mode === MODES.STANDARD) {
return P2PKHAddress.encode(this.getPublicKey(), {
publicKeyAddressPrefix: options.publicKeyAddressPrefix ?? Bitcoin.NETWORKS.MAINNET.PUBLIC_KEY_ADDRESS_PREFIX,
publicKeyType: this.publicKeyType
});
}
else if (this.mode === MODES.SEGWIT) {
return P2WPKHAddress.encode(this.getPublicKey(), {
hrp: options.hrp ?? Bitcoin.NETWORKS.MAINNET.HRP,
witnessVersion: options.witnessVersion ?? Bitcoin.NETWORKS.MAINNET.WITNESS_VERSIONS.P2WPKH,
publicKeyType: this.publicKeyType
});
}
throw new AddressError(`Invalid ${this.getName()} mode`, {
expected: MODES.getTypes(), got: this.mode
});
}
}
// SPDX-License-Identifier: MIT
class MoneroHD extends HD {
network;
seed;
privateKeyRaw;
paymentID;
spendPrivateKey;
viewPrivateKey;
spendPublicKey;
viewPublicKey;
constructor(options = {
minor: 1, major: 0
}) {
super({ ecc: SLIP10Ed25519MoneroECC, ...options });
const network = ensureTypeMatch(options.network, Network, { otherTypes: ['string'] });
const networkType = network.isValid ? network.value.NAME : options.network;
if (!Monero.NETWORKS.isNetwork(networkType)) {
throw new NetworkError(`Wrong Monero network`, {
expected: Monero.NETWORKS.getNetworks(), got: options.network
});
}
this.paymentID = options.paymentID;
this.network = Monero.NETWORKS.getNetwork(networkType);
this.derivation = new MoneroDerivation({
minor: options.minor ?? 1,
major: options.major ?? 0
});
}
static getName() {
return 'Monero';
}
fromSeed(seed) {
try {
this.seed = getBytes(seed instanceof Seed ? seed.getSeed() : seed);
const spendPrivateKey = this.seed.length === SLIP10Ed25519MoneroPrivateKey.getLength()
? this.seed : keccak256(this.seed);
return this.fromSpendPrivateKey(scalarReduce(spendPrivateKey));
}
catch {
throw new SeedError('Invalid seed data');
}
}
fromPrivateKey(privateKey) {
try {
this.privateKeyRaw = getBytes(privateKey);
return this.fromSpendPrivateKey(scalarReduce(keccak256(this.privateKeyRaw)));
}
catch {
throw new PrivateKeyError('Invalid private key data');
}
}
fromDerivation(derivation) {
this.derivation = ensureTypeMatch(derivation, MoneroDerivation, { errorClass: DerivationError });
return this;
}
updateDerivation(derivation) {
this.cleanDerivation();
return this.fromDerivation(derivation);
}
cleanDerivation() {
this.derivation.clean();
return this.fromDerivation(this.derivation);
}
fromSpendPrivateKey(spendPrivateKey) {
const spendKey = SLIP10Ed25519MoneroPrivateKey.fromBytes(getBytes(spendPrivateKey));
const viewKey = SLIP10Ed25519MoneroPrivateKey.fromBytes(scalarReduce(keccak256(spendKey.getRaw())));
this.spendPrivateKey = spendKey;
this.viewPrivateKey = viewKey;
this.spendPublicKey = spendKey.getPublicKey();
this.viewPublicKey = viewKey.getPublicKey();
return this;
}
fromWatchOnly(viewPrivateKey, spendPublicKey) {
let viewKey;
let spendKey;
try {
viewKey = SLIP10Ed25519MoneroPrivateKey.fromBytes(getBytes(viewPrivateKey));
}
catch {
throw new PrivateKeyError('Invalid view private key data');
}
try {
spendKey = SLIP10Ed25519MoneroPublicKey.fromBytes(getBytes(spendPublicKey));
}
catch {
throw new PublicKeyError('Invalid spend public key data');
}
this.spendPrivateKey = null;
this.viewPrivateKey = viewKey;
this.spendPublicKey = spendKey;
this.viewPublicKey = viewKey.getPublicKey();
return this;
}
drive(minorIndex, majorIndex) {
const max = 2 ** 32 - 1;
if (minorIndex < 0 || minorIndex > max) {
throw new DerivationError(`Invalid minor index range`, {
expected: `0-${max}`, got: minorIndex
});
}
if (majorIndex < 0 || majorIndex > max) {
throw new DerivationError(`Invalid major index range`, {
expected: `0-${max}`, got: majorIndex
});
}
if (minorIndex === 0 && majorIndex === 0) {
return [this.spendPublicKey, this.viewPublicKey];
}
const m = intDecode(scalarReduce(keccak256(concatBytes(toBuffer('SubAddr\x00', 'utf8'), this.viewPrivateKey.getRaw(), integerToBytes(majorIndex, 4, 'little'), integerToBytes(minorIndex, 4, 'little')))));
const subAddressSpendPoint = this.spendPublicKey.getPoint().add(SLIP10Ed25519MoneroECC.GENERATOR.multiply(m));
const subAddressViewPoint = subAddressSpendPoint.multiply(bytesToInteger(this.viewPrivateKey.getRaw(), true));
return [
SLIP10Ed25519MoneroPublicKey.fromPoint(subAddressSpendPoint),
SLIP10Ed25519MoneroPublicKey.fromPoint(subAddressViewPoint)
];
}
getSeed() {
return this.seed ? bytesToString(this.seed) : null;
}
getPrivateKey() {
return this.privateKeyRaw ? bytesToString(this.privateKeyRaw) : null;
}
getSpendPrivateKey() {
return this.spendPrivateKey ? bytesToString(this.spendPrivateKey.getRaw()) : null;
}
getViewPrivateKey() {
return bytesToString(this.viewPrivateKey.getRaw());
}
getSpendPublicKey() {
return bytesToString(this.spendPublicKey.getRawCompressed());
}
getViewPublicKey() {
return bytesToString(this.viewPublicKey.getRawCompressed());
}
getPrimaryAddress() {
return MoneroAddress.encode({
spendPublicKey: this.spendPublicKey,
viewPublicKey: this.viewPublicKey
}, {
network: this.network.NAME,
addressType: Monero.ADDRESS_TYPES.STANDARD
});
}
getIntegratedAddress(paymentID) {
if (!paymentID && !this.paymentID)
return null;
return MoneroAddress.encode({
spendPublicKey: this.spendPublicKey,
viewPublicKey: this.viewPublicKey
}, {
network: this.network.NAME,
addressType: Monero.ADDRESS_TYPES.INTEGRATED,
paymentID: paymentID ?? this.paymentID
});
}
getSubAddress(minor = this.derivation.getMinor(), major = this.derivation.getMajor()) {
if (minor === 0 && major === 0) {
return this.getPrimaryAddress();
}
const [spendPublicKey, viewPublicKey] = this.drive(minor, major);
return MoneroAddress.encode({
spendPublicKey: spendPublicKey,
viewPublicKey: viewPublicKey
}, {
network: this.network.NAME,
addressType: Monero.ADDRESS_TYPES.SUB_ADDRESS
});
}
getAddress(options = {
addressType: Monero.ADDRESS_TYPES.STANDARD
}) {
if (options.addressType === Monero.ADDRESS_TYPES.STANDARD) {
return this.getPrimaryAddress();
}
else if (options.addressType === Monero.ADDRESS_TYPES.INTEGRATED) {
return this.getIntegratedAddress(options.paymentID);
}
else if (options.addressType === Monero.ADDRESS_TYPES.SUB_ADDRESS) {
return this.getSubAddress(options.minor ?? this.derivation.getMinor(), options.major ?? this.derivation.getMajor());
}
throw new AddressError(`Invalid ${this.getName()} address type`, {
expected: Monero.ADDRESS_TYPES.getAddressTypes(),
got: options.addressType
});
}
}
// SPDX-License-Identifier: MIT
class HDS {
static dictionary = {
[AlgorandHD.getName()]: AlgorandHD,
[BIP32HD.getName()]: BIP32HD,
[BIP44HD.getName()]: BIP44HD,
[BIP49HD.getName()]: BIP49HD,
[BIP84HD.getName()]: BIP84HD,
[BIP86HD.getName()]: BIP86HD,
[BIP141HD.getName()]: BIP141HD,
[CardanoHD.getName()]: CardanoHD,
[ElectrumV1HD.getName()]: ElectrumV1HD,
[ElectrumV2HD.getName()]: ElectrumV2HD,
[MoneroHD.getName()]: MoneroHD
};
static getNames() {
return Object.keys(this.dictionary);
}
static getClasses() {
return Object.values(this.dictionary);
}
static getHDClass(name) {
if (!this.isHD(name)) {
throw new BaseError('Invalid HD name', { expected: this.getNames(), got: name });
}
return this.dictionary[name];
}
static isHD(name) {
return this.getNames().includes(name);
}
}
var hds = /*#__PURE__*/Object.freeze({
__proto__: null,
HDS: HDS,
HD: HD,
AlgorandHD: AlgorandHD,
BIP32HD: BIP32HD,
BIP44HD: BIP44HD,
BIP49HD: BIP49HD,
BIP84HD: BIP84HD,
BIP86HD: BIP86HD,
BIP141HD: BIP141HD,
CardanoHD: CardanoHD,
ElectrumV1HD: ElectrumV1HD,
ElectrumV2HD: ElectrumV2HD,
MoneroHD: MoneroHD
});
// SPDX-License-Identifier: MIT
class HDWallet {
ecc;
cryptocurrency;
network;
address;
hd;
addressType;
addressPrefix;
entropy;
language;
passphrase;
mnemonic;
seed;
derivation;
semantic;
mode;
mnemonicType;
publicKeyType;
cardanoType;
useDefaultPath = true;
checksum = true;
stakingPublicKey;
paymentID;
constructor(cryptocurrency, options = {}) {
this.cryptocurrency = ensureTypeMatch(cryptocurrency, Cryptocurrency, { errorClass: CryptocurrencyError });
this.ecc = options.ecc ?? this.cryptocurrency.ECC;
const _hd = options.hd ?? this.cryptocurrency.DEFAULT_HD;
const resolvedHD = ensureTypeMatch(_hd, HD, { otherTypes: ['string'] });
const hdName = resolvedHD.isValid ? resolvedHD.value.getName() : _hd;
if (!this.cryptocurrency.HDS.isHD(hdName)) {
throw new HDError(`${this.cryptocurrency.NAME} doesn't support HD type`, {
expected: this.cryptocurrency.HDS.getHDS(), got: hdName
});
}
const hdClass = HDS.getHDClass(hdName);
const _network = options.network ?? this.cryptocurrency.DEFAULT_NETWORK.NAME;
const resolvedNetwork = ensureTypeMatch(_network, Network, { otherTypes: ['string'] });
const networkName = resolvedNetwork.isValid ? resolvedNetwork.value.NAME : _network;
if (!this.cryptocurrency.NETWORKS.isNetwork(networkName)) {
throw new NetworkError(`${this.cryptocurrency.NAME} doesn't support network type`, {
expected: this.cryptocurrency.NETWORKS.getNetworks(), got: networkName
});
}
this.network = this.cryptocurrency.NETWORKS.getNetwork(networkName);
if (['Algorand', 'BIP32', 'BIP44', 'BIP86', 'Cardano'].includes(hdName)) {
this.semantic = options.semantic ?? this.cryptocurrency.DEFAULT_SEMANTIC;
}
else if (hdName === 'BIP49') {
this.semantic = options.semantic ?? SEMANTICS.P2WPKH_IN_P2SH;
}
else if (['BIP84', 'BIP141'].includes(hdName)) {
this.semantic = options.semantic ?? SEMANTICS.P2WPKH;
}
else {
this.semantic = undefined;
}
let _address = options.address;
if (!options.address) { // Use default address
_address = this.cryptocurrency.DEFAULT_ADDRESS;
if (hdName === 'BIP49') {
_address = 'P2WPKH-In-P2SH';
}
else if (hdName === 'BIP84') {
_address = 'P2WPKH';
}
else if (hdName === 'BIP86') {
_address = 'P2TR';
}
else if (hdName === 'BIP141') {
if (this.semantic === SEMANTICS.P2WPKH) {
_address = 'P2WPKH';
}
else if (this.semantic === SEMANTICS.P2WPKH_IN_P2SH) {
_address = 'P2WPKH-In-P2SH';
}
else if (this.semantic === SEMANTICS.P2WSH) {
_address = 'P2WSH';
}
else if (this.semantic === SEMANTICS.P2WSH_IN_P2SH) {
_address = 'P2WSH-In-P2SH';
}
}
}
const resolvedAddress = ensureTypeMatch(_address, Address, { otherTypes: ['string'] });
const addressName = resolvedAddress.isValid ? resolvedAddress.value.getName() : _address;
if (!this.cryptocurrency.ADDRESSES.isAddress(addressName)) {
throw new AddressError(`${this.cryptocurrency.NAME} doesn't support address type`, {
expected: this.cryptocurrency.ADDRESSES.getAddresses(), got: addressName
});
}
this.address = ADDRESSES.getAddressClass(addressName);
this.language = options.language ?? 'english';
this.passphrase = options.passphrase ?? null;
this.useDefaultPath = options.useDefaultPath ?? false;
this.stakingPublicKey = options.stakingPublicKey;
this.paymentID = options.paymentID;
if (['BIP32', 'BIP44', 'BIP49', 'BIP84', 'BIP86', 'BIP141', 'Electrum-V1'].includes(hdName)) {
this.publicKeyType = options.publicKeyType ?? (hdName === 'Electrum-V1' ? PUBLIC_KEY_TYPES.UNCOMPRESSED : PUBLIC_KEY_TYPES.COMPRESSED);
}
else if (hdName === 'Cardano') {
this.cardanoType = options.cardanoType;
}
else if (hdName === 'Electrum-V2') {
this.mode = options.mode ?? MODES.STANDARD;
this.mnemonicType = options.mnemonicType ?? ELECTRUM_V2_MNEMONIC_TYPES.STANDARD;
this.publicKeyType = options.publicKeyType ?? PUBLIC_KEY_TYPES.UNCOMPRESSED;
}
else if (hdName === 'Monero') {
this.checksum = options.checksum ?? false;
}
this.addressType = options.addressType ?? this.cryptocurrency.DEFAULT_ADDRESS_TYPE;
if (this.cryptocurrency.NAME === 'Tezos') {
this.addressPrefix = options.addressPrefix ?? this.cryptocurrency.DEFAULT_ADDRESS_PREFIX;
}
this.hd = new hdClass({
ecc: this.ecc,
publicKeyType: this.publicKeyType,
semantic: this.semantic,
coinType: this.cryptocurrency.COIN_TYPE,
wifPrefix: this.network.WIF_PREFIX,
cardanoType: this.cardanoType,
mode: this.mode,
paymentID: this.paymentID,
network: this.network
});
}
fromEntropy(entropy) {
if (!this.cryptocurrency.ENTROPIES.isEntropy(entropy.getName())) {
throw new EntropyError(`${this.cryptocurrency.NAME} cryptocurrency doesn't support Entropy type`, {
expected: this.cryptocurrency.ENTROPIES.getEntropies(), got: entropy.getName()
});
}
this.entropy = entropy;
let mnemonic;
if (this.entropy.getName() === 'Electrum-V2') {
mnemonic = ElectrumV2Mnemonic.fromEntropy(this.entropy.getEntropy(), this.language, { mnemonicType: this.mnemonicType });
}
else if (this.entropy.getName() === 'Monero') {
mnemonic = MoneroMnemonic.fromEntropy(this.entropy.getEntropy(), this.language, { checksum: this.checksum });
}
else {
mnemonic = MNEMONICS.getMnemonicClass(this.entropy.getName()).fromEntropy(this.entropy.getEntropy(), this.language);
}
const mnemonicClass = MNEMONICS.getMnemonicClass(this.entropy.getName());
return this.fromMnemonic(this.entropy.getName() === 'Electrum-V2' ?
new mnemonicClass(mnemonic, { mnemonicType: this.mnemonicType }) :
new mnemonicClass(mnemonic));
}
fromMnemonic(mnemonic) {
if (!this.cryptocurrency.MNEMONICS.isMnemonic(mnemonic.getName())) {
throw new EntropyError(`${this.cryptocurrency.NAME} cryptocurrency doesn't support Mnemonic type`, {
expected: this.cryptocurrency.MNEMONICS.getMnemonics(), got: mnemonic.getName()
});
}
this.mnemonic = mnemonic;
if (this.mnemonic.getName() === 'Electrum-V2') {
const entropyBytes = MNEMONICS.getMnemonicClass(this.mnemonic.getName()).decode(this.mnemonic.getMnemonic(), { mnemonicType: this.mnemonicType });
const entropyClass = ENTROPIES.getEntropyClass(this.mnemonic.getName());
this.entropy = new entropyClass(entropyBytes);
}
else {
const entropyBytes = MNEMONICS.getMnemonicClass(this.mnemonic.getName()).decode(this.mnemonic.getMnemonic());
const entropyClass = ENTROPIES.getEntropyClass(this.mnemonic.getName());
this.entropy = new entropyClass(entropyBytes);
}
let seed;
if (this.mnemonic.getName() === 'BIP39' && this.hd.getName() === 'Cardano') {
seed = CardanoSeed.fromMnemonic(this.mnemonic.getMnemonic(), {
passphrase: this.passphrase,
cardanoType: this.cardanoType
});
}
else if (this.mnemonic.getName() === BIP39Seed.getName()) {
seed = BIP39Seed.fromMnemonic(this.mnemonic.getMnemonic(), {
passphrase: this.passphrase
});
}
else if (this.mnemonic.getName() === ElectrumV2Seed.getName()) {
seed = ElectrumV2Seed.fromMnemonic(this.mnemonic.getMnemonic(), {
passphrase: this.passphrase,
mnemonicType: this.mnemonicType
});
}
else {
seed = SEEDS.getSeedClass(this.mnemonic.getName()).fromMnemonic(this.mnemonic.getMnemonic());
}
const seedClass = SEEDS.getSeedClass(this.hd.getName() === 'Cardano' ? 'Cardano' : this.mnemonic.getName());
return this.fromSeed(new seedClass(seed));
}
fromSeed(seed) {
if (!this.cryptocurrency.SEEDS.isSeed(seed.getName())) {
throw new EntropyError(`${this.cryptocurrency.NAME} cryptocurrency doesn't support Seed type`, {
expected: this.cryptocurrency.SEEDS.getSeeds(), got: seed.getName()
});
}
this.seed = seed;
if (this.hd.getName() === 'Cardano') {
this.hd.fromSeed(seed.getSeed(), this.passphrase);
}
else {
this.hd.fromSeed(seed.getSeed());
}
this.derivation = this.hd.getDerivation();
return this;
}
fromXPrivateKey(xprivateKey, encoded = true, strict = false) {
if (['Electrum-V1', 'Monero'].includes(this.hd.getName())) {
throw new XPrivateKeyError(`Support for XPrivate-Key conversion is not implemented in ${this.hd.getName()} HD type`);
}
if (!isValidKey(xprivateKey, encoded)) {
throw new XPrivateKeyError('Invalid XPrivate-Key data');
}
const [version, , , , ,] = deserialize(xprivateKey, encoded);
const decodedLen = encoded ? checkDecode(xprivateKey).length : xprivateKey.length;
if (!this.network.XPRIVATE_KEY_VERSIONS.isVersion(version) || ![78, 110].includes(decodedLen)) {
throw new XPrivateKeyError(`Invalid XPrivate-Key for ${this.cryptocurrency.NAME}`);
}
this.hd.fromXPrivateKey(xprivateKey, encoded, strict);
return this;
}
fromXPublicKey(xpublicKey, encoded = true, strict = false) {
if (['Electrum-V1', 'Monero'].includes(this.hd.getName())) {
throw new XPublicKeyError(`Support for XPublic-Key conversion is not implemented in ${this.hd.getName()} HD type`);
}
else if (this.hd.getName() === 'Cardano' && this.cardanoType === 'byron-legacy') {
throw new XPublicKeyError(`Conversion from XPublic-Key is unavailable in ${this.cardanoType} mode for ${this.hd.getName()} HD type`);
}
if (!isValidKey(xpublicKey, encoded)) {
throw new XPublicKeyError("Invalid XPublic-Key data");
}
const [version, , , , ,] = deserialize(xpublicKey, encoded);
const decodedLen = encoded ? checkDecode(xpublicKey).length : xpublicKey.length;
if (!this.network.XPUBLIC_KEY_VERSIONS.isVersion(version) || ![78, 110].includes(decodedLen)) {
throw new XPublicKeyError(`Invalid XPublic-Key for ${this.cryptocurrency.NAME}`);
}
this.hd.fromXPublicKey(xpublicKey, encoded, strict);
return this;
}
fromDerivation(derivation) {
this.hd.fromDerivation(derivation);
this.derivation = derivation;
return this;
}
updateDerivation(derivation) {
this.hd.updateDerivation(derivation);
this.derivation = derivation;
return this;
}
cleanDerivation() {
this.hd.cleanDerivation();
this.derivation?.clean();
return this;
}
fromPrivateKey(privateKey) {
this.hd.fromPrivateKey(privateKey);
return this;
}
fromWIF(wif) {
if (['Algorand', 'Cardano', 'Monero'].includes(this.hd.getName())) {
throw new WIFError(`WIF is not supported by ${this.hd.getName()} HD type`);
}
if (this.network.WIF_PREFIX === null) {
throw new WIFError(`WIF is not supported by ${this.cryptocurrency.NAME} cryptocurrency`);
}
this.hd.fromWIF(wif);
return this;
}
fromPublicKey(publicKey) {
if (this.hd.getName() === 'Monero') {
throw new PublicKeyError(`From Public-Key is not supported by ${this.hd.getName()} HD type`);
}
this.hd.fromPublicKey(publicKey);
return this;
}
fromSpendPrivateKey(spendPrivateKey) {
if (this.hd.getName() !== 'Monero') {
throw new PrivateKeyError(`From Spend-Private-Key is only supported by ${this.hd.getName()} HD type`);
}
this.hd.fromSpendPrivateKey(spendPrivateKey);
return this;
}
fromWatchOnly(viewPrivateKey, spendPublicKey) {
if (this.hd.getName() !== 'Monero') {
throw new PublicKeyError(`From Watch-Only is only supported by ${this.hd.getName()} HD type`);
}
this.hd.fromWatchOnly(viewPrivateKey, spendPublicKey);
return this;
}
getCryptocurrency() {
return this.cryptocurrency.NAME;
}
getSymbol() {
return this.cryptocurrency.SYMBOL;
}
getCoinType() {
return this.cryptocurrency.COIN_TYPE;
}
getNetwork() {
return this.network.NAME;
}
getEntropy() {
return this.entropy?.getEntropy() ?? null;
}
getStrength() {
return this.entropy?.getStrength() ?? null;
}
getMnemonic() {
return this.mnemonic?.getMnemonic() ?? null;
}
getMnemonicType() {
return this.mnemonicType ?? null;
}
getLanguage() {
return this.mnemonic?.getLanguage() ?? null;
}
getWords() {
return this.mnemonic?.getWords() ?? null;
}
getPassphrase() {
return this.passphrase;
}
getSeed() {
return this.hd.getSeed();
}
getECC() {
return this.hd.ecc.NAME;
}
getHD() {
return this.hd.getName();
}
getSemantic() {
return this.semantic ?? null;
}
getCardanoType() {
return this.hd.getName() === 'Cardano' ? (this.cardanoType ?? null) : null;
}
getMode() {
if (this.hd.getName() !== 'Electrum-V2') {
throw new Error(`Get mode is only for Electrum-V2 HD type, not ${this.hd.getName()}`);
}
return this.hd.getMode();
}
getPathKey() {
return this.hd.getPathKey();
}
getRootXPrivateKey(semantic, encoded = true) {
const currentSemantic = semantic ?? this.semantic;
if (['Electrum-V1', 'Monero'].includes(this.hd.getName()) || !currentSemantic) {
return null;
}
return this.hd.getRootXPrivateKey(this.network.XPRIVATE_KEY_VERSIONS.getVersion(currentSemantic), encoded);
}
getRootXPublicKey(semantic, encoded = true) {
const currentSemantic = semantic ?? this.semantic;
if (['Electrum-V1', 'Monero'].includes(this.hd.getName()) || !currentSemantic) {
return null;
}
return this.hd.getRootXPublicKey(this.network.XPUBLIC_KEY_VERSIONS.getVersion(currentSemantic), encoded);
}
getMasterXPrivateKey(semantic, encoded = true) {
return this.getRootXPrivateKey(semantic, encoded);
}
getMasterXPublicKey(semantic, encoded = true) {
return this.getRootXPublicKey(semantic, encoded);
}
getRootPrivateKey() {
if (['Electrum-V1', 'Electrum-V2'].includes(this.hd.getName())) {
return this.hd.getMasterPrivateKey();
}
return this.hd.getRootPrivateKey();
}
getRootWIF(wifType) {
if (['Algorand', 'Cardano', 'Monero'].includes(this.hd.getName())) {
return null;
}
if (['Electrum-V1', 'Electrum-V2'].includes(this.hd.getName())) {
return this.hd.getMasterWIF(wifType);
}
return this.hd.getRootWIF(wifType);
}
getRootChainCode() {
return this.hd.getRootChainCode();
}
getRootPublicKey(publicKeyType) {
if (['Electrum-V1', 'Electrum-V2'].includes(this.hd.getName())) {
return this.hd.getMasterPublicKey(publicKeyType);
}
return this.hd.getRootPublicKey(publicKeyType);
}
getMasterPrivateKey() {
if (['Electrum-V1', 'Electrum-V2'].includes(this.hd.getName())) {
return this.hd.getMasterPrivateKey();
}
return this.hd.getRootPrivateKey();
}
getMasterWIF(wifType) {
if (['Algorand', 'Cardano', 'Monero'].includes(this.hd.getName())) {
return null;
}
if (['Electrum-V1', 'Electrum-V2'].includes(this.hd.getName())) {
return this.hd.getMasterWIF(wifType);
}
return this.hd.getRootWIF(wifType);
}
getMasterChainCode() {
return this.hd.getRootChainCode();
}
getMasterPublicKey(publicKeyType) {
if (['Electrum-V1', 'Electrum-V2'].includes(this.hd.getName())) {
return this.hd.getMasterPublicKey(publicKeyType);
}
return this.hd.getRootPublicKey(publicKeyType);
}
getXPrivateKey(semantic, encoded = true) {
const currentSemantic = semantic ?? this.semantic;
if (['Electrum-V1', 'Monero'].includes(this.hd.getName()) || !currentSemantic) {
return null;
}
return this.hd.getXPrivateKey(this.network.XPRIVATE_KEY_VERSIONS.getVersion(currentSemantic), encoded);
}
getXPublicKey(semantic, encoded = true) {
const currentSemantic = semantic ?? this.semantic;
if (['Electrum-V1', 'Monero'].includes(this.hd.getName()) || !currentSemantic) {
return null;
}
return this.hd.getXPublicKey(this.network.XPUBLIC_KEY_VERSIONS.getVersion(currentSemantic), encoded);
}
getPrivateKey() {
return this.hd.getPrivateKey();
}
getSpendPrivateKey() {
if (this.hd.getName() !== 'Monero') {
throw new Error('Get Spend-Private-Key is only supported by Monero HD type');
}
return this.hd.getSpendPrivateKey();
}
getViewPrivateKey() {
if (this.hd.getName() !== 'Monero') {
throw new Error('Get View-Private-Key is only supported by Monero HD type');
}
return this.hd.getViewPrivateKey();
}
getWIF(wifType) {
if (['Algorand', 'Cardano', 'Monero'].includes(this.hd.getName())) {
return null;
}
return this.hd.getWIF(wifType);
}
getWIFType() {
return this.getWIF() ? this.hd.getWIFType() : null;
}
getChainCode() {
return this.hd.getChainCode();
}
getPublicKey(publicKeyType) {
return this.hd.getPublicKey(publicKeyType);
}
getPublicKeyType() {
return this.hd.getPublicKeyType();
}
getUncompressed() {
return this.hd.getUncompressed();
}
getCompressed() {
return this.hd.getCompressed();
}
getSpendPublicKey() {
if (this.hd.getName() !== 'Monero') {
throw new Error('Get Spend-Public-Key is only supported by Monero HD type');
}
return this.hd.getSpendPublicKey();
}
getViewPublicKey() {
if (this.hd.getName() !== 'Monero') {
throw new Error('Get View-Public-Key is only supported by Monero HD type');
}
return this.hd.getViewPublicKey();
}
getHash() {
return this.hd.getHash();
}
getDepth() {
return this.hd.getDepth();
}
getFingerprint() {
return this.hd.getFingerprint();
}
getParentFingerprint() {
return this.hd.getParentFingerprint();
}
getPath() {
return this.hd.getPath();
}
getIndex() {
return this.hd.getIndex();
}
getIndexes() {
return this.hd.getIndexes();
}
getStrict() {
return ['Electrum-V1', 'Monero'].includes(this.hd.getName()) ? null : this.hd.getStrict();
}
getPrimaryAddress() {
return this.hd.getName() === 'Monero' ? this.hd.getPrimaryAddress() : null;
}
getIntegratedAddress(paymentID) {
return this.hd.getName() === 'Monero' ? this.hd.getIntegratedAddress(paymentID) : null;
}
getSubAddress(minor, major) {
return this.hd.getName() === 'Monero' ? this.hd.getSubAddress(minor, major) : null;
}
getAddress(options = {}) {
const _address = options.address ?? this.address;
const resolvedAddress = ensureTypeMatch(_address, Address, { otherTypes: ['string'] });
const addressName = resolvedAddress.isValid ? resolvedAddress.value.getName() : _address;
if (!this.cryptocurrency.ADDRESSES.isAddress(addressName)) {
throw new AddressError(`${this.cryptocurrency.NAME} doesn't support address type`, {
expected: this.cryptocurrency.ADDRESSES.getAddresses(), got: addressName
});
}
if (this.network.WITNESS_VERSIONS) {
options.witnessVersion = this.network.WITNESS_VERSIONS.getWitnessVersion(addressName);
}
const hdName = this.hd.getName();
if (hdName === 'Cardano') {
options.network = options.network ?? this.network.NAME;
options.addressType = options.addressType ?? this.addressType;
options.stakingPublicKey = options.stakingPublicKey ?? this.stakingPublicKey;
return this.hd.getAddress(options);
}
else if (hdName === 'Electrum-V1') {
return this.hd.getAddress({
publicKeyAddressPrefix: this.network.PUBLIC_KEY_ADDRESS_PREFIX
});
}
else if (hdName === 'Electrum-V2') {
return this.hd.getAddress({
publicKeyAddressPrefix: this.network.PUBLIC_KEY_ADDRESS_PREFIX,
hrp: this.network.HRP,
witnessVersion: this.network.WITNESS_VERSIONS?.getWitnessVersion('P2WPKH')
});
}
else if (hdName === 'Monero') {
const versionType = options.versionType;
if (versionType === 'standard') {
return this.getPrimaryAddress();
}
else if (versionType === 'integrated') {
return this.getIntegratedAddress(options.paymentID);
}
else if (versionType === 'sub-address') {
return this.getSubAddress(options.minor, options.major);
}
}
else {
const addressClass = ADDRESSES.getAddressClass(addressName);
if (['Bitcoin-Cash', 'Bitcoin-Cash-SLP', 'eCash'].includes(this.cryptocurrency.NAME)) {
const addressType = options.addressType ?? this.addressType;
return addressClass.encode(this.getPublicKey(), {
publicKeyAddressPrefix: this.network[`${addressType?.toUpperCase()}_PUBLIC_KEY_ADDRESS_PREFIX`],
scriptAddressPrefix: this.network[`${addressType?.toUpperCase()}_SCRIPT_ADDRESS_PREFIX`],
networkType: this.network.NAME,
publicKeyType: this.getPublicKeyType(),
hrp: this.network.HRP
});
}
else {
return addressClass.encode(this.getPublicKey(), {
publicKeyAddressPrefix: this.network.PUBLIC_KEY_ADDRESS_PREFIX,
scriptAddressPrefix: this.network.SCRIPT_ADDRESS_PREFIX,
networkType: this.network.NAME,
publicKeyType: this.getPublicKeyType(),
hrp: this.network.HRP,
addressType: options.addressType ?? this.addressType,
addressPrefix: options.addressPrefix ?? this.addressPrefix
});
}
}
throw new AddressError(`Could not resolve address for ${hdName} HD type`);
}
getDump(exclude = []) {
const derivationDump = {};
const hdName = this.hd.getName();
if (this.derivation) {
let at;
switch (this.derivation.getName()) {
case 'BIP44':
case 'BIP49':
case 'BIP84':
case 'BIP86':
at = {
'path': this.derivation.getPath(),
'indexes': this.derivation.getIndexes(),
'depth': this.getDepth(),
'purpose': this.derivation.getPurpose(),
'coin-type': this.derivation.getCoinType(),
'account': this.derivation.getAccount(),
'change': this.derivation.getChange(),
'address': this.derivation.getAddress()
};
break;
case 'CIP1852':
at = {
'path': this.derivation.getPath(),
'indexes': this.derivation.getIndexes(),
'depth': this.getDepth(),
'purpose': this.derivation.getPurpose(),
'coin-type': this.derivation.getCoinType(),
'account': this.derivation.getAccount(),
'role': this.derivation.getRole(),
'address': this.derivation.getAddress()
};
break;
case 'Electrum':
at = {
'change': this.derivation.getChange(),
'address': this.derivation.getAddress()
};
break;
case 'Monero':
at = {
'minor': this.derivation.getMinor(),
'major': this.derivation.getMajor()
};
break;
default:
at = {
'path': this.derivation.getPath(),
'indexes': this.derivation.getIndexes(),
'depth': this.getDepth(),
'index': this.getIndex()
};
}
derivationDump['at'] = at;
}
if ([
'Algorand', 'BIP32', 'BIP44', 'BIP49', 'BIP84', 'BIP86', 'BIP141', 'Cardano'
].includes(hdName)) {
Object.assign(derivationDump, {
'xprivate-key': this.getXPrivateKey(),
'xpublic-key': this.getXPublicKey(),
'private-key': this.getPrivateKey(),
'wif': this.getWIF(),
'chain-code': this.getChainCode(),
'public-key': this.getPublicKey(),
'uncompressed': this.getUncompressed(),
'compressed': this.getCompressed(),
'fingerprint': this.getFingerprint(),
'parent-fingerprint': this.getParentFingerprint(),
'hash': this.getHash()
});
if (['Algorand', 'Cardano'].includes(hdName)) {
delete derivationDump.wif;
delete derivationDump.uncompressed;
delete derivationDump.compressed;
}
if (this.cryptocurrency.ADDRESSES.length() > 1 || this.cryptocurrency.NAME === 'Tezos') {
const addresses = {};
if (this.cryptocurrency.NAME === 'Avalanche' && this.cryptocurrency.ADDRESS_TYPES) {
addresses[toCamelCase(this.cryptocurrency.ADDRESS_TYPES.C_CHAIN)] = this.getAddress({ address: 'Ethereum' });
addresses[toCamelCase(this.cryptocurrency.ADDRESS_TYPES.P_CHAIN)] = this.getAddress({
address: 'Avalanche', addressType: this.cryptocurrency.ADDRESS_TYPES.P_CHAIN
});
addresses[toCamelCase(this.cryptocurrency.ADDRESS_TYPES.X_CHAIN)] = this.getAddress({
address: 'Avalanche', addressType: this.cryptocurrency.ADDRESS_TYPES.X_CHAIN
});
}
else if (this.cryptocurrency.NAME === 'Binance' && this.cryptocurrency.ADDRESS_TYPES) {
addresses[toCamelCase(this.cryptocurrency.ADDRESS_TYPES.CHAIN)] = this.getAddress({ address: 'Cosmos' });
addresses[toCamelCase(this.cryptocurrency.ADDRESS_TYPES.SMART_CHAIN)] = this.getAddress({ address: 'Ethereum' });
}
else if ((this.cryptocurrency.NAME === 'Bitcoin-Cash' ||
this.cryptocurrency.NAME === 'Bitcoin-Cash-SLP' ||
this.cryptocurrency.NAME === 'eCash') &&
this.cryptocurrency.ADDRESS_TYPES) {
for (const addressType of this.cryptocurrency.ADDRESS_TYPES.getAddressTypes()) {
for (const address of this.cryptocurrency.ADDRESSES.getAddresses()) {
addresses[`${addressType}${address.split('-').join('')}`] = ADDRESSES.getAddressClass(address).encode(this.getPublicKey(), {
publicKeyAddressPrefix: this.network[`${addressType?.toUpperCase()}_PUBLIC_KEY_ADDRESS_PREFIX`],
scriptAddressPrefix: this.network[`${addressType?.toUpperCase()}_SCRIPT_ADDRESS_PREFIX`],
publicKeyType: this.getPublicKeyType(),
hrp: this.network.HRP,
});
}
}
}
else if (this.cryptocurrency.NAME === 'Tezos' && this.cryptocurrency.ADDRESS_PREFIXES) {
addresses[this.cryptocurrency.ADDRESS_PREFIXES.TZ1] = this.getAddress({
addressPrefix: this.cryptocurrency.ADDRESS_PREFIXES.TZ1
});
addresses[this.cryptocurrency.ADDRESS_PREFIXES.TZ2] = this.getAddress({
addressPrefix: this.cryptocurrency.ADDRESS_PREFIXES.TZ2
});
addresses[this.cryptocurrency.ADDRESS_PREFIXES.TZ3] = this.getAddress({
addressPrefix: this.cryptocurrency.ADDRESS_PREFIXES.TZ3
});
}
else if (this.hd.getName() === 'BIP44') {
derivationDump['address'] = this.getAddress({ address: 'P2PKH' });
}
else if (this.hd.getName() === 'BIP49') {
derivationDump['address'] = this.getAddress({ address: 'P2WPKH-In-P2SH' });
}
else if (this.hd.getName() === 'BIP84') {
derivationDump['address'] = this.getAddress({ address: 'P2WPKH' });
}
else if (this.hd.getName() === 'BIP86') {
derivationDump['address'] = this.getAddress({ address: 'P2TR' });
}
else if (this.hd.getName() === 'BIP141') {
if (this.semantic === SEMANTICS.P2WPKH) {
derivationDump['address'] = this.getAddress({ address: 'P2WPKH' });
}
else if (this.semantic === SEMANTICS.P2WPKH_IN_P2SH) {
derivationDump['address'] = this.getAddress({ address: 'P2WPKH-In-P2SH' });
}
else if (this.semantic === SEMANTICS.P2WSH) {
derivationDump['address'] = this.getAddress({ address: 'P2WSH' });
}
else if (this.semantic === SEMANTICS.P2WSH_IN_P2SH) {
derivationDump['address'] = this.getAddress({ address: 'P2WSH-In-P2SH' });
}
}
else {
for (const address of this.cryptocurrency.ADDRESSES.getAddresses()) {
addresses[address.toLowerCase()] = this.getAddress({ address: address });
}
}
if (Object.keys(addresses).length !== 0) {
derivationDump['addresses'] = addresses;
}
}
else {
if (this.cryptocurrency.NAME === 'Cardano' && [
Cardano.TYPES.SHELLEY_ICARUS, Cardano.TYPES.SHELLEY_LEDGER
].includes(this.cardanoType)) {
derivationDump['address'] = this.getAddress({
network: this.network.NAME,
addressType: this.addressType,
stakingPublicKey: this.stakingPublicKey
});
}
else {
derivationDump['address'] = this.getAddress();
}
}
}
else if (['Electrum-V1', 'Electrum-V2'].includes(hdName)) {
Object.assign(derivationDump, {
'private-key': this.getPrivateKey(),
'wif': this.getWIF(),
'public-key': this.getPublicKey(),
'uncompressed': this.getUncompressed(),
'compressed': this.getCompressed(),
'address': this.getAddress()
});
}
else if (hdName === 'Monero') {
derivationDump['sub-address'] = this.getSubAddress();
}
if (exclude.includes('at')) {
delete derivationDump['at'];
}
if (exclude.includes('root')) {
return excludeKeys(derivationDump, exclude);
}
const root = {
'cryptocurrency': this.getCryptocurrency(),
'symbol': this.getSymbol(),
'network': this.getNetwork(),
'coin-type': this.getCoinType(),
'entropy': this.getEntropy(),
'strength': this.getStrength(),
'mnemonic': this.getMnemonic(),
'passphrase': this.getPassphrase(),
'language': this.getLanguage(),
'seed': this.getSeed(),
'ecc': this.getECC(),
'hd': this.getHD()
};
if (['Electrum-V1', 'Electrum-V2', 'Monero'].includes(hdName)) {
delete root['passphrase'];
}
if ([
'Algorand', 'BIP32', 'BIP44', 'BIP49', 'BIP84', 'BIP86', 'BIP141', 'Cardano'
].includes(hdName)) {
if (hdName === 'Cardano') {
root['cardano-type'] = this.getCardanoType();
}
Object.assign(root, {
'semantic': this.getSemantic(),
'root-xprivate-key': this.getRootXPrivateKey(),
'root-xpublic-key': this.getRootXPublicKey(),
'root-private-key': this.getRootPrivateKey(),
'root-wif': this.getRootWIF(),
'root-chain-code': this.getRootChainCode(),
'root-public-key': this.getRootPublicKey(),
'path-key': this.getPathKey(),
'strict': this.getStrict(),
'public-key-type': this.getPublicKeyType(),
'wif-type': this.getWIFType()
});
if (['Algorand', 'Cardano'].includes(hdName)) {
delete root['root-wif'];
delete root['public-key-type'];
delete root['root-type'];
if (this.cardanoType !== Cardano.TYPES.BYRON_LEGACY) {
delete root['path-key'];
}
}
else {
delete root['path-key'];
}
}
else if (hdName === 'Electrum-V1' || hdName === 'Electrum-V2') {
if (hdName === 'Electrum-V2') {
root['mode'] = this.getMode();
root['mnemonic-type'] = this.getMnemonicType();
}
Object.assign(root, {
'master-private-key': this.getMasterPrivateKey(),
'master-wif': this.getMasterWIF(),
'master-public-key': this.getMasterPublicKey(),
'public-key-type': this.getPublicKeyType(),
'wif-type': this.getWIFType()
});
}
else if (hdName === 'Monero') {
Object.assign(root, {
'private-key': this.getPrivateKey(),
'spend-private-key': this.getSpendPrivateKey(),
'view-private-key': this.getViewPrivateKey(),
'spend-public-key': this.getSpendPublicKey(),
'view-public-key': this.getViewPublicKey(),
'primary-address': this.getPrimaryAddress()
});
if (this.paymentID) {
root['integrated-address'] = this.getIntegratedAddress(this.paymentID);
}
}
if (!exclude.includes('derivation')) {
root['derivation'] = derivationDump;
}
return excludeKeys(root, exclude);
}
getDumps(exclude = []) {
if (!this.derivation)
return null;
const derivationsList = [];
const isRangeTuple = (tuple) => {
return tuple.length === 3;
};
const drive = (...args) => {
const driveHelper = (derivations, current = []) => {
if (derivations.length === 0) {
const derivationName = this.derivation.getName();
const derivationClass = DERIVATIONS.getDerivationClass(derivationName);
let derivation;
if (['BIP44', 'BIP49', 'BIP84', 'BIP86'].includes(derivationName)) {
derivation = new derivationClass({
coinType: current[1][0],
account: current[2][0],
change: current[3][0],
address: current[4][0]
});
}
else if (derivationName === 'CIP1852') {
derivation = new derivationClass({
coinType: current[1][0],
account: current[2][0],
role: current[3][0],
address: current[4][0]
});
}
else if (derivationName === 'Electrum') {
derivation = new derivationClass({
change: current[0][0],
address: current[1][0]
});
}
else if (derivationName === 'Monero') {
derivation = new derivationClass({
minor: current[0][0],
major: current[1][0]
});
}
else if (derivationName === 'HDW') {
derivation = new derivationClass({
account: current[0][0],
ecc: current[1][0],
address: current[2][0]
});
}
else {
const path = 'm/' + current.map(([v, h]) => `${v}${h ? "'" : ''}`).join('/');
derivation = new derivationClass({ path });
}
this.updateDerivation(derivation);
derivationsList.push(this.getDump(['root', ...exclude]));
return [derivation.getPath()];
}
const [head, ...rest] = derivations;
const result = [];
if (isRangeTuple(head)) {
const [start, end, hardened] = head;
for (let i = start; i <= end; i++) {
result.push(...driveHelper(rest, [...current, [i, hardened]]));
}
}
else {
result.push(...driveHelper(rest, [...current, head]));
}
return result;
};
return driveHelper(args);
};
drive(...this.derivation.getDerivations());
if (exclude.includes('root')) {
return derivationsList;
}
const rootDump = this.getDump(['derivation', ...exclude]);
if (!exclude.includes('derivations')) {
rootDump['derivations'] = derivationsList;
}
return excludeKeys(rootDump, exclude);
}
}
// SPDX-License-Identifier: MIT
const hdwallet = {
info,
consts,
crypto: crypto$1,
utils,
cryptocurrencies,
entropies,
mnemonics,
seeds,
eccs,
derivations,
hds,
addresses,
HDWallet
};
export { HDWallet, addresses, consts, crypto$1 as crypto, cryptocurrencies, derivations, eccs, entropies, hds, hdwallet, info, mnemonics, seeds, utils };
//# sourceMappingURL=hdwallet.js.map