@norionsoft/hd-derivations 1.0.0-beta.0

package/build/browser/bip32-CTos7K79.js

@@ -0,0 +1,421 @@
+import { h as hmac, s as sha512 } from './sha512-D-HY1fu1.js';
+import { z as ripemd160 } from './prefix-config.type-BP_PoMwo.js';
+import { s as sha256 } from './sha256-BFiHgz55.js';
+import { c as compare, f as fromHex, r as readUInt32, a as fromUtf8, w as writeUInt32, b as writeUInt8, d as concat } from './browser-D9H9snNo.js';
+import { b as base58check } from './index-Cm6DbuGy.js';
+import { p as pipe, m as maxValue, a as minValue, i as integer, n as number, b as instance, l as length, o as object, r as regex, s as string, c as parse, e as encode } from './types-DRp_D8oF.js';
+
+function hash160(buffer) {
+    return ripemd160(sha256(buffer));
+}
+function hmacSHA512(key, data) {
+    return hmac(sha512, key, data);
+}
+
+const h = (hex) => fromHex(hex);
+function testEcc(ecc) {
+    assert(ecc.isPoint(h('0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798')));
+    assert(!ecc.isPoint(h('030000000000000000000000000000000000000000000000000000000000000005')));
+    assert(ecc.isPrivate(h('79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798')));
+    // order - 1
+    assert(ecc.isPrivate(h('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140')));
+    // 0
+    assert(!ecc.isPrivate(h('0000000000000000000000000000000000000000000000000000000000000000')));
+    // order
+    assert(!ecc.isPrivate(h('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141')));
+    // order + 1
+    assert(!ecc.isPrivate(h('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364142')));
+    assert(compare(ecc.pointFromScalar(h('b1121e4088a66a28f5b6b0f5844943ecd9f610196d7bb83b25214b60452c09af')), h('02b07ba9dca9523b7ef4bd97703d43d20399eb698e194704791a25ce77a400df99')) === 0);
+    if (ecc.xOnlyPointAddTweak) {
+        assert(ecc.xOnlyPointAddTweak(h('79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'), h('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140')) === null);
+        let xOnlyRes = ecc.xOnlyPointAddTweak(h('1617d38ed8d8657da4d4761e8057bc396ea9e4b9d29776d4be096016dbd2509b'), h('a8397a935f0dfceba6ba9618f6451ef4d80637abf4e6af2669fbc9de6a8fd2ac'));
+        assert(compare(xOnlyRes.xOnlyPubkey, h('e478f99dab91052ab39a33ea35fd5e6e4933f4d28023cd597c9a1f6760346adf')) === 0 && xOnlyRes.parity === 1);
+        xOnlyRes = ecc.xOnlyPointAddTweak(h('2c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991'), h('823c3cd2142744b075a87eade7e1b8678ba308d566226a0056ca2b7a76f86b47'));
+    }
+    assert(compare(ecc.pointAddScalar(h('0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'), h('0000000000000000000000000000000000000000000000000000000000000003')), h('02c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5')) === 0);
+    assert(compare(ecc.privateAdd(h('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036413e'), h('0000000000000000000000000000000000000000000000000000000000000002')), h('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140')) === 0);
+    if (ecc.privateNegate) {
+        assert(compare(ecc.privateNegate(h('0000000000000000000000000000000000000000000000000000000000000001')), h('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140')) === 0);
+        assert(compare(ecc.privateNegate(h('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036413e')), h('0000000000000000000000000000000000000000000000000000000000000003')) === 0);
+        assert(compare(ecc.privateNegate(h('b1121e4088a66a28f5b6b0f5844943ecd9f610196d7bb83b25214b60452c09af')), h('4eede1bf775995d70a494f0a7bb6bc11e0b8cccd41cce8009ab1132c8b0a3792')) === 0);
+    }
+    assert(compare(ecc.sign(h('5e9f0a0d593efdcf78ac923bc3313e4e7d408d574354ee2b3288c0da9fbba6ed'), h('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140')), h('54c4a33c6423d689378f160a7ff8b61330444abb58fb470f96ea16d99d4a2fed07082304410efa6b2943111b6a4e0aaa7b7db55a07e9861d1fb3cb1f421044a5')) === 0);
+    assert(ecc.verify(h('5e9f0a0d593efdcf78ac923bc3313e4e7d408d574354ee2b3288c0da9fbba6ed'), h('0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'), h('54c4a33c6423d689378f160a7ff8b61330444abb58fb470f96ea16d99d4a2fed07082304410efa6b2943111b6a4e0aaa7b7db55a07e9861d1fb3cb1f421044a5')));
+    if (ecc.signSchnorr) {
+        assert(compare(ecc.signSchnorr(h('7e2d58d8b3bcdf1abadec7829054f90dda9805aab56c77333024b9d0a508b75c'), h('c90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b14e5c9'), h('c87aa53824b4d7ae2eb035a2b5bbbccc080e76cdc6d1692c4b0b62d798e6d906')), h('5831aaeed7b44bb74e5eab94ba9d4294c49bcf2a60728d8b4c200f50dd313c1bab745879a5ad954a72c45a91c3a51d3c7adea98d82f8481e0e1e03674a6f3fb7')) === 0);
+    }
+    if (ecc.verifySchnorr) {
+        assert(ecc.verifySchnorr(h('7e2d58d8b3bcdf1abadec7829054f90dda9805aab56c77333024b9d0a508b75c'), h('dd308afec5777e13121fa72b9cc1b7cc0139715309b086c960e18fd969774eb8'), h('5831aaeed7b44bb74e5eab94ba9d4294c49bcf2a60728d8b4c200f50dd313c1bab745879a5ad954a72c45a91c3a51d3c7adea98d82f8481e0e1e03674a6f3fb7')));
+    }
+}
+function assert(bool) {
+    if (!bool)
+        throw new Error('ecc library invalid');
+}
+
+const Uint32Schema = pipe(number(), integer(), minValue(0), maxValue(0xffffffff));
+const Uint31Schema = pipe(number(), integer(), minValue(0), maxValue(0x7fffffff));
+const Uint8Schema = pipe(number(), integer(), minValue(0), maxValue(0xff));
+const Buffer256Bit = pipe(instance(Uint8Array), length(32));
+const Buffer33Bytes = pipe(instance(Uint8Array), length(33));
+const NetworkSchema = object({
+    wif: Uint8Schema,
+    bip32: object({
+        public: Uint32Schema,
+        private: Uint32Schema,
+    }),
+});
+const Bip32PathSchema = pipe(string(), regex(/^(m\/)?(\d+'?\/)*\d+'?$/));
+
+const _bs58check = base58check(sha256);
+const bs58check = {
+    encode: (data) => _bs58check.encode(data),
+    decode: (str) => _bs58check.decode(str),
+};
+function BIP32Factory(ecc) {
+    testEcc(ecc);
+    const BITCOIN = {
+        messagePrefix: '\x18Bitcoin Signed Message:\n',
+        bech32: 'bc',
+        bip32: {
+            public: 0x0488b21e,
+            private: 0x0488ade4,
+        },
+        pubKeyHash: 0x00,
+        scriptHash: 0x05,
+        wif: 0x80,
+    };
+    const HIGHEST_BIT = 0x80000000;
+    function toXOnly(pubKey) {
+        return pubKey.length === 32 ? pubKey : pubKey.slice(1, 33);
+    }
+    class Bip32Signer {
+        __D;
+        __Q;
+        lowR = false;
+        constructor(__D, __Q) {
+            this.__D = __D;
+            this.__Q = __Q;
+        }
+        get publicKey() {
+            if (this.__Q === undefined)
+                this.__Q = ecc.pointFromScalar(this.__D, true);
+            return this.__Q;
+        }
+        get privateKey() {
+            return this.__D;
+        }
+        sign(hash, lowR) {
+            if (!this.privateKey)
+                throw new Error('Missing private key');
+            if (lowR === undefined)
+                lowR = this.lowR;
+            if (lowR === false) {
+                return ecc.sign(hash, this.privateKey);
+            }
+            else {
+                let sig = ecc.sign(hash, this.privateKey);
+                const extraData = new Uint8Array(32);
+                let counter = 0;
+                // if first try is lowR, skip the loop
+                // for second try and on, add extra entropy counting up
+                while (sig[0] > 0x7f) {
+                    counter++;
+                    writeUInt32(extraData, 0, counter, 'LE');
+                    sig = ecc.sign(hash, this.privateKey, extraData);
+                }
+                return sig;
+            }
+        }
+        signSchnorr(hash) {
+            if (!this.privateKey)
+                throw new Error('Missing private key');
+            if (!ecc.signSchnorr)
+                throw new Error('signSchnorr not supported by ecc library');
+            return ecc.signSchnorr(hash, this.privateKey);
+        }
+        verify(hash, signature) {
+            return ecc.verify(hash, this.publicKey, signature);
+        }
+        verifySchnorr(hash, signature) {
+            if (!ecc.verifySchnorr)
+                throw new Error('verifySchnorr not supported by ecc library');
+            return ecc.verifySchnorr(hash, this.publicKey.subarray(1, 33), signature);
+        }
+    }
+    class BIP32 extends Bip32Signer {
+        chainCode;
+        network;
+        __DEPTH;
+        __INDEX;
+        __PARENT_FINGERPRINT;
+        constructor(__D, __Q, chainCode, network, __DEPTH = 0, __INDEX = 0, __PARENT_FINGERPRINT = 0x00000000) {
+            super(__D, __Q);
+            this.chainCode = chainCode;
+            this.network = network;
+            this.__DEPTH = __DEPTH;
+            this.__INDEX = __INDEX;
+            this.__PARENT_FINGERPRINT = __PARENT_FINGERPRINT;
+            parse(NetworkSchema, network);
+        }
+        get depth() {
+            return this.__DEPTH;
+        }
+        get index() {
+            return this.__INDEX;
+        }
+        get parentFingerprint() {
+            return this.__PARENT_FINGERPRINT;
+        }
+        get identifier() {
+            return hash160(this.publicKey);
+        }
+        get fingerprint() {
+            return this.identifier.slice(0, 4);
+        }
+        get compressed() {
+            return true;
+        }
+        // Private === not neutered
+        // Public === neutered
+        isNeutered() {
+            return this.__D === undefined;
+        }
+        neutered() {
+            return fromPublicKeyLocal(this.publicKey, this.chainCode, this.network, this.depth, this.index, this.parentFingerprint);
+        }
+        toBase58() {
+            const network = this.network;
+            const version = !this.isNeutered()
+                ? network.bip32.private
+                : network.bip32.public;
+            const buffer = new Uint8Array(78);
+            // 4 bytes: version bytes
+            writeUInt32(buffer, 0, version, 'BE');
+            // 1 byte: depth: 0x00 for master nodes, 0x01 for level-1 descendants, ....
+            writeUInt8(buffer, 4, this.depth);
+            // 4 bytes: the fingerprint of the parent's key (0x00000000 if master key)
+            writeUInt32(buffer, 5, this.parentFingerprint, 'BE');
+            // 4 bytes: child number. This is the number i in xi = xpar/i, with xi the key being serialized.
+            // This is encoded in big endian. (0x00000000 if master key)
+            writeUInt32(buffer, 9, this.index, 'BE');
+            // 32 bytes: the chain code
+            buffer.set(this.chainCode, 13);
+            // 33 bytes: the public key or private key data
+            if (!this.isNeutered()) {
+                // 0x00 + k for private keys
+                writeUInt8(buffer, 45, 0);
+                buffer.set(this.privateKey, 46);
+                // 33 bytes: the public key
+            }
+            else {
+                // X9.62 encoding for public keys
+                buffer.set(this.publicKey, 45);
+            }
+            return bs58check.encode(buffer);
+        }
+        toWIF() {
+            if (!this.privateKey)
+                throw new TypeError('Missing private key');
+            return encode({
+                version: this.network.wif,
+                privateKey: this.privateKey,
+                compressed: true,
+            });
+        }
+        // https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#child-key-derivation-ckd-functions
+        derive(index) {
+            parse(Uint32Schema, index);
+            const isHardened = index >= HIGHEST_BIT;
+            const data = new Uint8Array(37);
+            // Hardened child
+            if (isHardened) {
+                if (this.isNeutered())
+                    throw new TypeError('Missing private key for hardened child key');
+                // data = 0x00 || ser256(kpar) || ser32(index)
+                data[0] = 0x00;
+                data.set(this.privateKey, 1);
+                writeUInt32(data, 33, index, 'BE');
+                // Normal child
+            }
+            else {
+                // data = serP(point(kpar)) || ser32(index)
+                //      = serP(Kpar) || ser32(index)
+                data.set(this.publicKey, 0);
+                writeUInt32(data, 33, index, 'BE');
+            }
+            const I = hmacSHA512(this.chainCode, data);
+            const IL = I.slice(0, 32);
+            const IR = I.slice(32);
+            // if parse256(IL) >= n, proceed with the next value for i
+            if (!ecc.isPrivate(IL))
+                return this.derive(index + 1);
+            // Private parent key -> private child key
+            let hd;
+            if (!this.isNeutered()) {
+                // ki = parse256(IL) + kpar (mod n)
+                const ki = ecc.privateAdd(this.privateKey, IL);
+                // In case ki == 0, proceed with the next value for i
+                if (ki == null)
+                    return this.derive(index + 1);
+                hd = fromPrivateKeyLocal(ki, IR, this.network, this.depth + 1, index, readUInt32(this.fingerprint, 0, 'BE'));
+                // Public parent key -> public child key
+            }
+            else {
+                // Ki = point(parse256(IL)) + Kpar
+                //    = G*IL + Kpar
+                const Ki = ecc.pointAddScalar(this.publicKey, IL, true);
+                // In case Ki is the point at infinity, proceed with the next value for i
+                if (Ki === null)
+                    return this.derive(index + 1);
+                hd = fromPublicKeyLocal(Ki, IR, this.network, this.depth + 1, index, readUInt32(this.fingerprint, 0, 'BE'));
+            }
+            return hd;
+        }
+        deriveHardened(index) {
+            if (typeof parse(Uint31Schema, index) === 'number')
+                // Only derives hardened private keys by default
+                return this.derive(index + HIGHEST_BIT);
+            throw new TypeError('Expected UInt31, got ' + index);
+        }
+        derivePath(path) {
+            parse(Bip32PathSchema, path);
+            let splitPath = path.split('/');
+            if (splitPath[0] === 'm') {
+                if (this.parentFingerprint)
+                    throw new TypeError('Expected master, got child');
+                splitPath = splitPath.slice(1);
+            }
+            return splitPath.reduce((prevHd, indexStr) => {
+                let index;
+                if (indexStr.slice(-1) === `'`) {
+                    index = parseInt(indexStr.slice(0, -1), 10);
+                    return prevHd.deriveHardened(index);
+                }
+                else {
+                    index = parseInt(indexStr, 10);
+                    return prevHd.derive(index);
+                }
+            }, this);
+        }
+        tweak(t) {
+            if (this.privateKey)
+                return this.tweakFromPrivateKey(t);
+            return this.tweakFromPublicKey(t);
+        }
+        tweakFromPublicKey(t) {
+            const xOnlyPubKey = toXOnly(this.publicKey);
+            if (!ecc.xOnlyPointAddTweak)
+                throw new Error('xOnlyPointAddTweak not supported by ecc library');
+            const tweakedPublicKey = ecc.xOnlyPointAddTweak(xOnlyPubKey, t);
+            if (!tweakedPublicKey || tweakedPublicKey.xOnlyPubkey === null)
+                throw new Error('Cannot tweak public key!');
+            const parityByte = Uint8Array.from([
+                tweakedPublicKey.parity === 0 ? 0x02 : 0x03,
+            ]);
+            const tweakedPublicKeyCompresed = concat([
+                parityByte,
+                tweakedPublicKey.xOnlyPubkey,
+            ]);
+            return new Bip32Signer(undefined, tweakedPublicKeyCompresed);
+        }
+        tweakFromPrivateKey(t) {
+            const hasOddY = this.publicKey[0] === 3 ||
+                (this.publicKey[0] === 4 && (this.publicKey[64] & 1) === 1);
+            const privateKey = (() => {
+                if (!hasOddY)
+                    return this.privateKey;
+                else if (!ecc.privateNegate)
+                    throw new Error('privateNegate not supported by ecc library');
+                else
+                    return ecc.privateNegate(this.privateKey);
+            })();
+            const tweakedPrivateKey = ecc.privateAdd(privateKey, t);
+            if (!tweakedPrivateKey)
+                throw new Error('Invalid tweaked private key!');
+            return new Bip32Signer(tweakedPrivateKey, undefined);
+        }
+    }
+    function fromBase58(inString, network) {
+        const buffer = bs58check.decode(inString);
+        if (buffer.length !== 78)
+            throw new TypeError('Invalid buffer length');
+        network = network || BITCOIN;
+        // 4 bytes: version bytes
+        const version = readUInt32(buffer, 0, 'BE');
+        if (version !== network.bip32.private && version !== network.bip32.public)
+            throw new TypeError('Invalid network version');
+        // 1 byte: depth: 0x00 for master nodes, 0x01 for level-1 descendants, ...
+        const depth = buffer[4];
+        // 4 bytes: the fingerprint of the parent's key (0x00000000 if master key)
+        const parentFingerprint = readUInt32(buffer, 5, 'BE');
+        if (depth === 0) {
+            if (parentFingerprint !== 0x00000000)
+                throw new TypeError('Invalid parent fingerprint');
+        }
+        // 4 bytes: child number. This is the number i in xi = xpar/i, with xi the key being serialized.
+        // This is encoded in MSB order. (0x00000000 if master key)
+        const index = readUInt32(buffer, 9, 'BE');
+        if (depth === 0 && index !== 0)
+            throw new TypeError('Invalid index');
+        // 32 bytes: the chain code
+        const chainCode = buffer.slice(13, 45);
+        let hd;
+        // 33 bytes: private key data (0x00 + k)
+        if (version === network.bip32.private) {
+            if (buffer[45] !== 0x00)
+                throw new TypeError('Invalid private key');
+            const k = buffer.slice(46, 78);
+            hd = fromPrivateKeyLocal(k, chainCode, network, depth, index, parentFingerprint);
+            // 33 bytes: public key data (0x02 + X or 0x03 + X)
+        }
+        else {
+            const X = buffer.slice(45, 78);
+            hd = fromPublicKeyLocal(X, chainCode, network, depth, index, parentFingerprint);
+        }
+        return hd;
+    }
+    function fromPrivateKey(privateKey, chainCode, network) {
+        return fromPrivateKeyLocal(privateKey, chainCode, network);
+    }
+    function fromPrivateKeyLocal(privateKey, chainCode, network, depth, index, parentFingerprint) {
+        parse(Buffer256Bit, privateKey);
+        parse(Buffer256Bit, chainCode);
+        network = network || BITCOIN;
+        if (!ecc.isPrivate(privateKey))
+            throw new TypeError('Private key not in range [1, n)');
+        return new BIP32(privateKey, undefined, chainCode, network, depth, index, parentFingerprint);
+    }
+    function fromPublicKey(publicKey, chainCode, network) {
+        return fromPublicKeyLocal(publicKey, chainCode, network);
+    }
+    function fromPublicKeyLocal(publicKey, chainCode, network, depth, index, parentFingerprint) {
+        parse(Buffer33Bytes, publicKey);
+        parse(Buffer256Bit, chainCode);
+        network = network || BITCOIN;
+        // verify the X coordinate is a point on the curve
+        if (!ecc.isPoint(publicKey))
+            throw new TypeError('Point is not on the curve');
+        return new BIP32(undefined, publicKey, chainCode, network, depth, index, parentFingerprint);
+    }
+    function fromSeed(seed, network) {
+        parse(instance(Uint8Array), seed);
+        if (seed.length < 16)
+            throw new TypeError('Seed should be at least 128 bits');
+        if (seed.length > 64)
+            throw new TypeError('Seed should be at most 512 bits');
+        network = network || BITCOIN;
+        const I = hmacSHA512(fromUtf8('Bitcoin seed'), seed);
+        const IL = I.slice(0, 32);
+        const IR = I.slice(32);
+        return fromPrivateKey(IL, IR, network);
+    }
+    return {
+        fromSeed,
+        fromBase58,
+        fromPublicKey,
+        fromPrivateKey,
+    };
+}
+
+export { BIP32Factory as B };

package/build/browser/bip39-BO8UvXuy.js

@@ -0,0 +1,126 @@
+import { s as sha256 } from './sha256-BFiHgz55.js';
+import { s as sha512 } from './sha512-D-HY1fu1.js';
+import { u as u8aToU8a, h as hasBigInt, i as isReady, g as getRandomValues, p as pbkdf2, a as sha512$1, c as sha256$1, d as stringToU8a } from './bundle-DjgjuASd.js';
+import { p as pbkdf2$1 } from './pbkdf2-2nEOAG5y.js';
+
+/** @internal */
+function createBitHasher(bitLength, fn) {
+    return (data, onlyJs) => fn(data, bitLength, onlyJs);
+}
+/** @internal */
+function createDualHasher(wa, js) {
+    return (value, bitLength = 256, onlyJs) => {
+        const u8a = u8aToU8a(value);
+        return !hasBigInt || (!onlyJs && isReady())
+            ? wa[bitLength](u8a)
+            : js[bitLength](u8a);
+    };
+}
+
+/**
+ * @name randomAsU8a
+ * @summary Creates a Uint8Array filled with random bytes.
+ * @description
+ * Returns a `Uint8Array` with the specified (optional) length filled with random bytes.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { randomAsU8a } from '@polkadot/util-crypto';
+ *
+ * randomAsU8a(); // => Uint8Array([...])
+ * ```
+ */
+function randomAsU8a(length = 32) {
+    return getRandomValues(new Uint8Array(length));
+}
+
+function pbkdf2Encode(passphrase, salt = randomAsU8a(), rounds = 2048, onlyJs) {
+    const u8aPass = u8aToU8a(passphrase);
+    const u8aSalt = u8aToU8a(salt);
+    return {
+        password: !hasBigInt || (isReady())
+            ? pbkdf2(u8aPass, u8aSalt, rounds)
+            : pbkdf2$1(sha512, u8aPass, u8aSalt, { c: rounds, dkLen: 64 }),
+        rounds,
+        salt
+    };
+}
+
+/**
+ * @name shaAsU8a
+ * @summary Creates a sha Uint8Array from the input.
+ */
+const shaAsU8a = /*#__PURE__*/ createDualHasher({ 256: sha256$1, 512: sha512$1 }, { 256: sha256, 512: sha512 });
+/**
+ * @name sha256AsU8a
+ * @summary Creates a sha256 Uint8Array from the input.
+ */
+const sha256AsU8a = /*#__PURE__*/ createBitHasher(256, shaAsU8a);
+
+const DEFAULT_WORDLIST = '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'.split('|');
+
+const INVALID_MNEMONIC = 'Invalid mnemonic';
+const INVALID_ENTROPY = 'Invalid entropy';
+const INVALID_CHECKSUM = 'Invalid mnemonic checksum';
+/** @internal */
+function normalize(str) {
+    return (str || '').normalize('NFKD');
+}
+/** @internal */
+function binaryToByte(bin) {
+    return parseInt(bin, 2);
+}
+/** @internal */
+function bytesToBinary(bytes) {
+    return bytes.map((x) => x.toString(2).padStart(8, '0')).join('');
+}
+/** @internal */
+function deriveChecksumBits(entropyBuffer) {
+    return bytesToBinary(Array.from(sha256AsU8a(entropyBuffer))).slice(0, (entropyBuffer.length * 8) / 32);
+}
+function mnemonicToSeedSync(mnemonic, password) {
+    return pbkdf2Encode(stringToU8a(normalize(mnemonic)), stringToU8a(`mnemonic${normalize(password)}`)).password;
+}
+function mnemonicToEntropy(mnemonic, wordlist = DEFAULT_WORDLIST) {
+    const words = normalize(mnemonic).split(' ');
+    if (words.length % 3 !== 0) {
+        throw new Error(INVALID_MNEMONIC);
+    }
+    // convert word indices to 11 bit binary strings
+    const bits = words
+        .map((word) => {
+        const index = wordlist.indexOf(word);
+        if (index === -1) {
+            throw new Error(INVALID_MNEMONIC);
+        }
+        return index.toString(2).padStart(11, '0');
+    })
+        .join('');
+    // split the binary string into ENT/CS
+    const dividerIndex = Math.floor(bits.length / 33) * 32;
+    const entropyBits = bits.slice(0, dividerIndex);
+    const checksumBits = bits.slice(dividerIndex);
+    // calculate the checksum and compare
+    const matched = entropyBits.match(/(.{1,8})/g);
+    const entropyBytes = matched?.map(binaryToByte);
+    if (!entropyBytes || (entropyBytes.length % 4 !== 0) || (entropyBytes.length < 16) || (entropyBytes.length > 32)) {
+        throw new Error(INVALID_ENTROPY);
+    }
+    const entropy = u8aToU8a(entropyBytes);
+    if (deriveChecksumBits(entropy) !== checksumBits) {
+        throw new Error(INVALID_CHECKSUM);
+    }
+    return entropy;
+}
+function validateMnemonic(mnemonic, wordlist) {
+    try {
+        mnemonicToEntropy(mnemonic, wordlist);
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+
+export { mnemonicToEntropy as a, mnemonicToSeedSync as m, validateMnemonic as v };