@norionsoft/hd-derivations 1.0.0-beta.0

package/build/browser/libs/modules/key-derivation/networks/dot/dot-base-key-derivation.js

@@ -0,0 +1,331 @@
+import { curveToKeyPairType } from './libs/maps/curve-to-key-pair-type.map.js';
+import { s as secp256k1PairFromSeed, g as getPublicKey, H as HDKD$2, c as curveToKeyPairDeriver } from '../../../../../curve-to-key-pair-deriver.map-B3KvVk1f.js';
+import { DerivationPathSymbol } from '../../../../enums/derivation-path-symbol.enum.js';
+import { DEV_PHRASE } from './libs/constants/index.js';
+import { convertBytesKeyPairToHex } from './libs/helpers/convert-bytes-key-pair-to-hex.helper.js';
+import { importByPrivateKey } from './libs/helpers/import-by-private-key.helper.js';
+import '../../../../../constructor-parameters.type-KUUHqGZo.js';
+import '../../../mnemonic/libs/enums/exception-message.enum.js';
+import '../../../../../index-CjeBPB5t.js';
+import { b as blake2AsU8a } from '../../../../../asU8a-CLKx5k5t.js';
+import { B as BN, f as bnToBn, b as bnToU8a, g as BN_ONE, h as BN_TWO, i as isBigInt, j as BN_LE_256_OPTS } from '../../../../../bn-DgUofJEE.js';
+import { n as isHex, o as hexToU8a, d as stringToU8a, q as isU8a } from '../../../../../bundle-DjgjuASd.js';
+import { u as u8aConcatStrict, a as u8aConcat } from '../../../../../concat-CTfq9e-u.js';
+import { e as ed25519PairFromSeed } from '../../../../../fromSeed-DfhShSKz.js';
+
+/**
+ * @name isBn
+ * @summary Tests for a `BN` object instance.
+ * @description
+ * Checks to see if the input object is an instance of `BN` (bn.js).
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import BN from 'bn.js';
+ * import { isBn } from '@polkadot/util';
+ *
+ * console.log('isBn', isBn(new BN(1))); // => true
+ * ```
+ */
+function isBn(value) {
+    return BN.isBN(value);
+}
+
+const MAX_U8 = BN_TWO.pow(new BN(8 - 2)).isub(BN_ONE);
+const MAX_U16 = BN_TWO.pow(new BN(16 - 2)).isub(BN_ONE);
+const MAX_U32 = BN_TWO.pow(new BN(32 - 2)).isub(BN_ONE);
+const BL_16 = { bitLength: 16 };
+const BL_32 = { bitLength: 32 };
+/**
+ * @name compactToU8a
+ * @description Encodes a number into a compact representation
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { compactToU8a } from '@polkadot/util';
+ *
+ * console.log(compactToU8a(511, 32)); // Uint8Array([0b11111101, 0b00000111])
+ * ```
+ */
+function compactToU8a(value) {
+    const bn = bnToBn(value);
+    if (bn.lte(MAX_U8)) {
+        return new Uint8Array([bn.toNumber() << 2]);
+    }
+    else if (bn.lte(MAX_U16)) {
+        return bnToU8a(bn.shln(2).iadd(BN_ONE), BL_16);
+    }
+    else if (bn.lte(MAX_U32)) {
+        return bnToU8a(bn.shln(2).iadd(BN_TWO), BL_32);
+    }
+    const u8a = bnToU8a(bn);
+    let length = u8a.length;
+    // adjust to the minimum number of bytes
+    while (u8a[length - 1] === 0) {
+        length--;
+    }
+    if (length < 4) {
+        throw new Error('Invalid length, previous checks match anything less than 2^30');
+    }
+    return u8aConcatStrict([
+        // subtract 4 as minimum (also catered for in decoding)
+        new Uint8Array([((length - 4) << 2) + 0b11]),
+        u8a.subarray(0, length)
+    ]);
+}
+
+/**
+ * @name compactAddLength
+ * @description Adds a length prefix to the input value
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { compactAddLength } from '@polkadot/util';
+ *
+ * console.log(compactAddLength(new Uint8Array([0xde, 0xad, 0xbe, 0xef]))); // Uint8Array([4 << 2, 0xde, 0xad, 0xbe, 0xef])
+ * ```
+ */
+function compactAddLength(input) {
+    return u8aConcatStrict([
+        compactToU8a(input.length),
+        input
+    ]);
+}
+
+/**
+ * @name isString
+ * @summary Tests for a string.
+ * @description
+ * Checks to see if the input value is a JavaScript string.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isString } from '@polkadot/util';
+ *
+ * console.log('isString', isString('test')); // => true
+ * ```
+ */
+function isString(value) {
+    return typeof value === 'string' || value instanceof String;
+}
+
+/**
+ * @name isNumber
+ * @summary Tests for a JavaScript number.
+ * @description
+ * Checks to see if the input value is a valid number.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isNumber } from '@polkadot/util';
+ *
+ * console.log('isNumber', isNumber(1234)); // => true
+ * ```
+ */
+function isNumber(value) {
+    return typeof value === 'number';
+}
+
+const RE_NUMBER = /^\d+$/;
+const JUNCTION_ID_LEN = 32;
+class DeriveJunction {
+    #chainCode = new Uint8Array(32);
+    #isHard = false;
+    static from(value) {
+        const result = new DeriveJunction();
+        const [code, isHard] = value.startsWith('/')
+            ? [value.substring(1), true]
+            : [value, false];
+        result.soft(RE_NUMBER.test(code)
+            ? new BN(code, 10)
+            : code);
+        return isHard
+            ? result.harden()
+            : result;
+    }
+    get chainCode() {
+        return this.#chainCode;
+    }
+    get isHard() {
+        return this.#isHard;
+    }
+    get isSoft() {
+        return !this.#isHard;
+    }
+    hard(value) {
+        return this.soft(value).harden();
+    }
+    harden() {
+        this.#isHard = true;
+        return this;
+    }
+    soft(value) {
+        if (isNumber(value) || isBn(value) || isBigInt(value)) {
+            return this.soft(bnToU8a(value, BN_LE_256_OPTS));
+        }
+        else if (isHex(value)) {
+            return this.soft(hexToU8a(value));
+        }
+        else if (isString(value)) {
+            return this.soft(compactAddLength(stringToU8a(value)));
+        }
+        else if (value.length > JUNCTION_ID_LEN) {
+            return this.soft(blake2AsU8a(value));
+        }
+        this.#chainCode.fill(0);
+        this.#chainCode.set(value, 0);
+        return this;
+    }
+    soften() {
+        this.#isHard = false;
+        return this;
+    }
+}
+
+const RE_JUNCTION = /\/(\/?)([^/]+)/g;
+/**
+ * @description Extract derivation junctions from the supplied path
+ */
+function keyExtractPath(derivePath) {
+    const parts = derivePath.match(RE_JUNCTION);
+    const path = [];
+    let constructed = '';
+    if (parts) {
+        constructed = parts.join('');
+        for (const p of parts) {
+            path.push(DeriveJunction.from(p.substring(1)));
+        }
+    }
+    if (constructed !== derivePath) {
+        throw new Error(`Re-constructed path "${constructed}" does not match input`);
+    }
+    return {
+        parts,
+        path
+    };
+}
+
+const RE_CAPTURE = /^((0x[a-fA-F0-9]+|[\p{L}\d]+(?: [\p{L}\d]+)*))((\/\/?[^/]+)*)(\/\/\/(.*))?$/u;
+/**
+ * @description Extracts the phrase, path and password from a SURI format for specifying secret keys `<secret>/<soft-key>//<hard-key>///<password>` (the `///password` may be omitted, and `/<soft-key>` and `//<hard-key>` maybe repeated and mixed).
+ */
+function keyExtractSuri(suri) {
+    // Normalize Unicode to NFC to avoid accent-related mismatches
+    const normalizedSuri = suri.normalize('NFC');
+    // eslint-disable-next-line @typescript-eslint/prefer-regexp-exec
+    const matches = normalizedSuri.match(RE_CAPTURE);
+    if (matches === null) {
+        throw new Error('Unable to match provided value to a secret URI');
+    }
+    const [, phrase, , derivePath, , , password] = matches;
+    const { path } = keyExtractPath(derivePath);
+    return {
+        derivePath,
+        password,
+        path,
+        phrase
+    };
+}
+
+const HDKD$1 = compactAddLength(stringToU8a('Secp256k1HDKD'));
+function secp256k1DeriveHard(seed, chainCode) {
+    if (!isU8a(chainCode) || chainCode.length !== 32) {
+        throw new Error('Invalid chainCode passed to derive');
+    }
+    // NOTE This is specific to the Substrate HDD derivation, so always use the blake2 hasher
+    return blake2AsU8a(u8aConcat(HDKD$1, seed, chainCode), 256);
+}
+
+function createSeedDeriveFn(fromSeed, derive) {
+    return (keypair, { chainCode, isHard }) => {
+        if (!isHard) {
+            throw new Error('A soft key was found in the path and is not supported');
+        }
+        return fromSeed(derive(keypair.secretKey.subarray(0, 32), chainCode));
+    };
+}
+
+const keyHdkdEcdsa = /*#__PURE__*/ createSeedDeriveFn(secp256k1PairFromSeed, secp256k1DeriveHard);
+
+const HDKD = compactAddLength(stringToU8a('Ed25519HDKD'));
+function ed25519DeriveHard(seed, chainCode) {
+    if (!isU8a(chainCode) || chainCode.length !== 32) {
+        throw new Error('Invalid chainCode passed to derive');
+    }
+    return blake2AsU8a(u8aConcat(HDKD, seed, chainCode));
+}
+
+const keyHdkdEd25519 = /*#__PURE__*/ createSeedDeriveFn(ed25519PairFromSeed, ed25519DeriveHard);
+
+function createDeriveFn(derive) {
+    return (keypair, chainCode) => {
+        if (!isU8a(chainCode) || chainCode.length !== 32) {
+            throw new Error('Invalid chainCode passed to derive');
+        }
+        const secretKey = derive(keypair.secretKey, chainCode);
+        const publicKey = getPublicKey(secretKey);
+        return { publicKey, secretKey };
+    };
+}
+
+const sr25519DeriveHard = /*#__PURE__*/ createDeriveFn(HDKD$2.secretHard);
+
+const sr25519DeriveSoft = /*#__PURE__*/ createDeriveFn(HDKD$2.secretSoft);
+
+function keyHdkdSr25519(keypair, { chainCode, isSoft }) {
+    return isSoft
+        ? sr25519DeriveSoft(keypair, chainCode)
+        : sr25519DeriveHard(keypair, chainCode);
+}
+
+const generators = {
+    ecdsa: keyHdkdEcdsa,
+    ed25519: keyHdkdEd25519,
+    // FIXME This is Substrate-compatible, not Ethereum-compatible
+    ethereum: keyHdkdEcdsa,
+    sr25519: keyHdkdSr25519
+};
+function keyFromPath(pair, path, type) {
+    const keyHdkd = generators[type];
+    let result = pair;
+    for (const junction of path) {
+        result = keyHdkd(result, junction);
+    }
+    return result;
+}
+
+class DotBaseKeyDerivation {
+  mnemonic;
+  constructor(mnemonic) {
+    this.mnemonic = mnemonic;
+  }
+  deriveFromMnemonic({
+    derivationPath,
+    scheme
+  }) {
+    const mnemonic = this.mnemonic.getMnemonic();
+    const uri = `${mnemonic}${derivationPath}`;
+    const devFormattedUri = uri.startsWith(DerivationPathSymbol.DOT_HARDENED_DELIMITER) ? `${DEV_PHRASE}${uri}` : uri;
+    const { path } = keyExtractSuri(devFormattedUri);
+    const deriveKeyPair = curveToKeyPairDeriver[scheme];
+    const { publicKey, secretKey } = keyFromPath(
+      deriveKeyPair(this.mnemonic.getSeed()),
+      path,
+      curveToKeyPairType[scheme]
+    );
+    return convertBytesKeyPairToHex(publicKey, secretKey);
+  }
+  importByPrivateKey({
+    privateKey,
+    scheme
+  }) {
+    return importByPrivateKey(privateKey, scheme);
+  }
+}
+
+export { DotBaseKeyDerivation };

package/build/browser/libs/modules/key-derivation/networks/dot/dot-ledger-key-derivation.d.ts

@@ -0,0 +1,11 @@
+import { AbstractKeyDerivation, DeriveFromMnemonicParameters, ImportByPrivateKeyParameters } from '../../libs/types/index.js';
+import { CommonKeyPair } from '../../../../types/types.js';
+import { DotMnemonic } from '../../../mnemonic/index.js';
+declare class DotLedgerKeyDerivation implements AbstractKeyDerivation<"dotLedger"> {
+    private mnemonic;
+    constructor(mnemonic: DotMnemonic);
+    deriveFromMnemonic({ derivationPath, }: DeriveFromMnemonicParameters<"dotLedger">): CommonKeyPair;
+    importByPrivateKey({ privateKey, }: ImportByPrivateKeyParameters<"dotLedger">): CommonKeyPair;
+}
+export { DotLedgerKeyDerivation };
+//# sourceMappingURL=dot-ledger-key-derivation.d.ts.map

package/build/browser/libs/modules/key-derivation/networks/dot/dot-ledger-key-derivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dot-ledger-key-derivation.d.ts","sourceRoot":"","sources":["../../../../../../../src/libs/modules/key-derivation/networks/dot/dot-ledger-key-derivation.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,qBAAqB,EACrB,4BAA4B,EAC5B,4BAA4B,EAC7B,MAAM,mDAAmD,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAGpE,cAAM,sBAAuB,YAAW,qBAAqB,CAAC,WAAW,CAAC;IACxE,OAAO,CAAC,QAAQ,CAAc;gBAEX,QAAQ,EAAE,WAAW;IAIjC,kBAAkB,CAAC,EACxB,cAAc,GACf,EAAE,4BAA4B,CAAC,WAAW,CAAC,GAAG,aAAa;IAOrD,kBAAkB,CAAC,EACxB,UAAU,GACX,EAAE,4BAA4B,CAAC,WAAW,CAAC,GAAG,aAAa;CAG7D;AAED,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/build/browser/libs/modules/key-derivation/networks/dot/dot-ledger-key-derivation.js

@@ -0,0 +1,217 @@
+import { convertBytesKeyPairToHex } from './libs/helpers/convert-bytes-key-pair-to-hex.helper.js';
+import { importByPrivateKey } from './libs/helpers/import-by-private-key.helper.js';
+import '../../../../../constructor-parameters.type-KUUHqGZo.js';
+import '../../../mnemonic/libs/enums/exception-message.enum.js';
+import '../../../../../index-CjeBPB5t.js';
+import { Curve } from '../../../../enums/curve.type.js';
+import { B as BN, b as bnToU8a, a as BN_EIGHT, c as BN_LE_32_OPTS, d as BN_LE_512_OPTS, e as BN_LE_OPTS } from '../../../../../bn-DgUofJEE.js';
+import { h as hmac, s as sha512 } from '../../../../../sha512-D-HY1fu1.js';
+import { s as sha256 } from '../../../../../sha256-BFiHgz55.js';
+import { u as u8aToU8a, h as hasBigInt, i as isReady, f as hmacSha512, j as hmacSha256, k as bip39Validate } from '../../../../../bundle-DjgjuASd.js';
+import { a as u8aConcat } from '../../../../../concat-CTfq9e-u.js';
+import { v as validateMnemonic, m as mnemonicToSeedSync } from '../../../../../bip39-BO8UvXuy.js';
+import { e as ed25519PairFromSeed } from '../../../../../fromSeed-DfhShSKz.js';
+
+/**
+ * @name u8aToBn
+ * @summary Creates a BN from a Uint8Array object.
+ * @description
+ * `UInt8Array` input values return the actual BN. `null` or `undefined` values returns an `0x0` value.
+ * @param value The value to convert
+ * @param options Options to pass while converting
+ * @param options.isLe Convert using Little Endian (default)
+ * @param options.isNegative Convert using two's complement
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { u8aToBn } from '@polkadot/util';
+ *
+ * u8aToHex(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0xf])); // 0x68656c0f
+ * ```
+ */
+function u8aToBn(value, { isLe = true, isNegative = false } = {}) {
+    // slice + reverse is expensive, however SCALE is LE by default so this is the path
+    // we are most interested in (the BE is added for the sake of being comprehensive)
+    if (!isLe) {
+        value = value.slice().reverse();
+    }
+    const count = value.length;
+    // shortcut for <= u48 values - in this case the manual conversion
+    // here seems to be more efficient than passing the full array
+    if (isNegative && count && (value[count - 1] & 0x80)) {
+        // Most common case i{8, 16, 32} default LE SCALE-encoded
+        // For <= 32, we also optimize the xor to a single op
+        switch (count) {
+            case 0:
+                return new BN(0);
+            case 1:
+                return new BN(((value[0] ^ 0x0000_00ff) * -1) - 1);
+            case 2:
+                return new BN((((value[0] + (value[1] << 8)) ^ 0x0000_ffff) * -1) - 1);
+            case 3:
+                return new BN((((value[0] + (value[1] << 8) + (value[2] << 16)) ^ 0x00ff_ffff) * -1) - 1);
+            case 4:
+                // for the 3rd byte, we don't << 24 - since JS converts all bitwise operators to
+                // 32-bit, in the case where the top-most bit is set this yields a negative value
+                return new BN((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) * -1) - 1);
+            case 5:
+                return new BN(((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + ((value[4] ^ 0xff) * 0x1_00_00_00_00)) * -1) - 1);
+            case 6:
+                return new BN(((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + (((value[4] + (value[5] << 8)) ^ 0x0000_ffff) * 0x1_00_00_00_00)) * -1) - 1);
+            default:
+                return new BN(value, 'le').fromTwos(count * 8);
+        }
+    }
+    // Most common case - u{8, 16, 32} default LE SCALE-encoded
+    //
+    // There are some slight benefits in unrolling this specific loop,
+    // however it comes with diminishing returns since here the actual
+    // `new BN` does seem to take up the bulk of the time
+    switch (count) {
+        case 0:
+            return new BN(0);
+        case 1:
+            return new BN(value[0]);
+        case 2:
+            return new BN(value[0] + (value[1] << 8));
+        case 3:
+            return new BN(value[0] + (value[1] << 8) + (value[2] << 16));
+        case 4:
+            // for the 3rd byte, we don't << 24 - since JS converts all bitwise operators to
+            // 32-bit, in the case where the top-most bit is set this yields a negative value
+            return new BN(value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00));
+        case 5:
+            return new BN(value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8)) * 0x1_00_00_00));
+        case 6:
+            return new BN(value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8) + (value[5] << 16)) * 0x1_00_00_00));
+        default:
+            return new BN(value, 'le');
+    }
+}
+
+const JS_HASH = {
+    256: sha256,
+    512: sha512
+};
+const WA_MHAC = {
+    256: hmacSha256,
+    512: hmacSha512
+};
+/**
+ * @name hmacShaAsU8a
+ * @description creates a Hmac Sha (256/512) Uint8Array from the key & data
+ */
+function hmacShaAsU8a(key, data, bitLength = 256, onlyJs) {
+    const u8aKey = u8aToU8a(key);
+    return !hasBigInt || (isReady())
+        ? WA_MHAC[bitLength](u8aKey, data)
+        : hmac(JS_HASH[bitLength], u8aKey, data);
+}
+
+const HARDENED = 0x80000000;
+function hdValidatePath(path) {
+    if (!path.startsWith('m/')) {
+        return false;
+    }
+    const parts = path.split('/').slice(1);
+    for (const p of parts) {
+        const n = /^\d+'?$/.test(p)
+            ? parseInt(p.replace(/'$/, ''), 10)
+            : Number.NaN;
+        if (isNaN(n) || (n >= HARDENED) || (n < 0)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * @name mnemonicValidate
+ * @summary Validates a mnemonic input using [BIP39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki).
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { mnemonicGenerate, mnemonicValidate } from '@polkadot/util-crypto';
+ *
+ * const mnemonic = mnemonicGenerate(); // => string
+ * const isValidMnemonic = mnemonicValidate(mnemonic); // => boolean
+ * ```
+ */
+function mnemonicValidate(mnemonic, wordlist, onlyJs) {
+    return !hasBigInt || (isReady())
+        ? bip39Validate(mnemonic)
+        : validateMnemonic(mnemonic, wordlist);
+}
+
+function ledgerDerivePrivate(xprv, index) {
+    const kl = xprv.subarray(0, 32);
+    const kr = xprv.subarray(32, 64);
+    const cc = xprv.subarray(64, 96);
+    const data = u8aConcat([0], kl, kr, bnToU8a(index, BN_LE_32_OPTS));
+    const z = hmacShaAsU8a(cc, data, 512);
+    data[0] = 0x01;
+    return u8aConcat(bnToU8a(u8aToBn(kl, BN_LE_OPTS).iadd(u8aToBn(z.subarray(0, 28), BN_LE_OPTS).imul(BN_EIGHT)), BN_LE_512_OPTS).subarray(0, 32), bnToU8a(u8aToBn(kr, BN_LE_OPTS).iadd(u8aToBn(z.subarray(32, 64), BN_LE_OPTS)), BN_LE_512_OPTS).subarray(0, 32), hmacShaAsU8a(cc, data, 512).subarray(32, 64));
+}
+
+const ED25519_CRYPTO = 'ed25519 seed';
+function ledgerMaster(mnemonic, password) {
+    const seed = mnemonicToSeedSync(mnemonic, password);
+    const chainCode = hmacShaAsU8a(ED25519_CRYPTO, new Uint8Array([1, ...seed]), 256);
+    let priv;
+    while (!priv || (priv[31] & 0b0010_0000)) {
+        priv = hmacShaAsU8a(ED25519_CRYPTO, priv || seed, 512);
+    }
+    priv[0] &= 0b1111_1000;
+    priv[31] &= 0b0111_1111;
+    priv[31] |= 0b0100_0000;
+    return u8aConcat(priv, chainCode);
+}
+
+function hdLedger(_mnemonic, path) {
+    const words = _mnemonic
+        .split(' ')
+        .map((s) => s.trim())
+        .filter((s) => s);
+    if (![12, 24, 25].includes(words.length)) {
+        throw new Error('Expected a mnemonic with 24 words (or 25 including a password)');
+    }
+    const [mnemonic, password] = words.length === 25
+        ? [words.slice(0, 24).join(' '), words[24]]
+        : [words.join(' '), ''];
+    if (!mnemonicValidate(mnemonic)) {
+        throw new Error('Invalid mnemonic passed to ledger derivation');
+    }
+    else if (!hdValidatePath(path)) {
+        throw new Error('Invalid derivation path');
+    }
+    const parts = path.split('/').slice(1);
+    let seed = ledgerMaster(mnemonic, password);
+    for (const p of parts) {
+        const n = parseInt(p.replace(/'$/, ''), 10);
+        seed = ledgerDerivePrivate(seed, (n < HARDENED) ? (n + HARDENED) : n);
+    }
+    return ed25519PairFromSeed(seed.slice(0, 32));
+}
+
+class DotLedgerKeyDerivation {
+  mnemonic;
+  constructor(mnemonic) {
+    this.mnemonic = mnemonic;
+  }
+  deriveFromMnemonic({
+    derivationPath
+  }) {
+    const mnemonic = this.mnemonic.getMnemonic();
+    const { publicKey, secretKey } = hdLedger(mnemonic, derivationPath);
+    return convertBytesKeyPairToHex(publicKey, secretKey);
+  }
+  importByPrivateKey({
+    privateKey
+  }) {
+    return importByPrivateKey(privateKey, Curve.ED25519);
+  }
+}
+
+export { DotLedgerKeyDerivation };

package/build/browser/libs/modules/key-derivation/networks/dot/dot.d.ts

@@ -0,0 +1,3 @@
+export { DotBaseKeyDerivation } from './dot-base-key-derivation.js';
+export { DotLedgerKeyDerivation } from './dot-ledger-key-derivation.js';
+//# sourceMappingURL=dot.d.ts.map

package/build/browser/libs/modules/key-derivation/networks/dot/dot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dot.d.ts","sourceRoot":"","sources":["../../../../../../../src/libs/modules/key-derivation/networks/dot/dot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC"}

package/build/browser/libs/modules/key-derivation/networks/dot/dot.js

@@ -0,0 +1,2 @@
+export { DotBaseKeyDerivation } from './dot-base-key-derivation.js';
+export { DotLedgerKeyDerivation } from './dot-ledger-key-derivation.js';

package/build/browser/libs/modules/key-derivation/networks/dot/libs/constants/index.d.ts

@@ -0,0 +1,3 @@
+declare const DEV_PHRASE = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
+export { DEV_PHRASE };
+//# sourceMappingURL=index.d.ts.map

package/build/browser/libs/modules/key-derivation/networks/dot/libs/constants/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/libs/modules/key-derivation/networks/dot/libs/constants/index.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,UAAU,0EAA0E,CAAC;AAE3F,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/build/browser/libs/modules/key-derivation/networks/dot/libs/constants/index.js

@@ -0,0 +1,3 @@
+const DEV_PHRASE = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
+
+export { DEV_PHRASE };

package/build/browser/libs/modules/key-derivation/networks/dot/libs/helpers/convert-bytes-key-pair-to-hex.helper.d.ts

@@ -0,0 +1,4 @@
+import { CommonKeyPair } from '../../../../../../types/keys/index.js';
+declare function convertBytesKeyPairToHex(publicKeyBytes: Uint8Array, privateKeyBytes: Uint8Array): CommonKeyPair;
+export { convertBytesKeyPairToHex };
+//# sourceMappingURL=convert-bytes-key-pair-to-hex.helper.d.ts.map

package/build/browser/libs/modules/key-derivation/networks/dot/libs/helpers/convert-bytes-key-pair-to-hex.helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-bytes-key-pair-to-hex.helper.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/libs/modules/key-derivation/networks/dot/libs/helpers/convert-bytes-key-pair-to-hex.helper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAGhE,iBAAS,wBAAwB,CAC/B,cAAc,EAAE,UAAU,EAC1B,eAAe,EAAE,UAAU,GAC1B,aAAa,CAKf;AAED,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

package/build/browser/libs/modules/key-derivation/networks/dot/libs/helpers/convert-bytes-key-pair-to-hex.helper.js

@@ -0,0 +1,10 @@
+import '../../../../../../../index-CjeBPB5t.js';
+import { convertBytesToHex } from '../../../../../../utils/convert-bytes-to-hex.util.js';
+
+function convertBytesKeyPairToHex(publicKeyBytes, privateKeyBytes) {
+  const publicKeyHex = convertBytesToHex(publicKeyBytes);
+  const privateKeyHex = convertBytesToHex(privateKeyBytes);
+  return { privateKey: privateKeyHex, publicKey: publicKeyHex };
+}
+
+export { convertBytesKeyPairToHex };

package/build/browser/libs/modules/key-derivation/networks/dot/libs/helpers/helpers.d.ts

@@ -0,0 +1,3 @@
+export { convertBytesKeyPairToHex } from './convert-bytes-key-pair-to-hex.helper.js';
+export { importByPrivateKey } from './import-by-private-key.helper.js';
+//# sourceMappingURL=helpers.d.ts.map

package/build/browser/libs/modules/key-derivation/networks/dot/libs/helpers/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/libs/modules/key-derivation/networks/dot/libs/helpers/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AACrF,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC"}

package/build/browser/libs/modules/key-derivation/networks/dot/libs/helpers/helpers.js

@@ -0,0 +1,2 @@
+export { convertBytesKeyPairToHex } from './convert-bytes-key-pair-to-hex.helper.js';
+export { importByPrivateKey } from './import-by-private-key.helper.js';

package/build/browser/libs/modules/key-derivation/networks/dot/libs/helpers/import-by-private-key.helper.d.ts

@@ -0,0 +1,5 @@
+import { CommonKeyPair } from '../../../../../../types/keys/index.js';
+import { Curve } from '../../../../../../enums/enums.js';
+declare function importByPrivateKey(privateKeyHex: string, curve: Curve["ED25519" | "SECP256K1" | "SR25519"]): CommonKeyPair;
+export { importByPrivateKey };
+//# sourceMappingURL=import-by-private-key.helper.d.ts.map

package/build/browser/libs/modules/key-derivation/networks/dot/libs/helpers/import-by-private-key.helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-by-private-key.helper.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/libs/modules/key-derivation/networks/dot/libs/helpers/import-by-private-key.helper.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAGnD,iBAAS,kBAAkB,CACzB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,KAAK,CAAC,SAAS,GAAG,WAAW,GAAG,SAAS,CAAC,GAChD,aAAa,CAMf;AAED,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/build/browser/libs/modules/key-derivation/networks/dot/libs/helpers/import-by-private-key.helper.js

@@ -0,0 +1,13 @@
+import { convertBytesKeyPairToHex } from './convert-bytes-key-pair-to-hex.helper.js';
+import { curveToPublicKeyDeriver } from '../maps/curve-to-public-key-deriver.map.js';
+import { convertHexToBytes } from '../../../../../../utils/convert-hex-to-bytes/convert-hex-to-bytes.util.js';
+import '../../../../../../../index-CjeBPB5t.js';
+
+function importByPrivateKey(privateKeyHex, curve) {
+  const derivePublicKey = curveToPublicKeyDeriver[curve];
+  const privateKeyBytes = convertHexToBytes(privateKeyHex);
+  const publicKeyBytes = derivePublicKey(privateKeyBytes);
+  return convertBytesKeyPairToHex(publicKeyBytes, privateKeyBytes);
+}
+
+export { importByPrivateKey };

package/build/browser/libs/modules/key-derivation/networks/dot/libs/maps/curve-to-key-pair-deriver.map.d.ts

@@ -0,0 +1,5 @@
+import { Keypair } from '@polkadot/util-crypto/types';
+import { Curve } from '../../../../../../enums/enums.js';
+declare const curveToKeyPairDeriver: Record<Curve["ED25519"] | Curve["SECP256K1"] | Curve["SR25519"], (seed: Uint8Array) => Keypair>;
+export { curveToKeyPairDeriver };
+//# sourceMappingURL=curve-to-key-pair-deriver.map.d.ts.map

package/build/browser/libs/modules/key-derivation/networks/dot/libs/maps/curve-to-key-pair-deriver.map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curve-to-key-pair-deriver.map.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/libs/modules/key-derivation/networks/dot/libs/maps/curve-to-key-pair-deriver.map.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAE3D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAEnD,QAAA,MAAM,qBAAqB,EAAE,MAAM,CACjC,KAAK,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC,WAAW,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC,EACxD,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAK9B,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/build/browser/libs/modules/key-derivation/networks/dot/libs/maps/curve-to-key-pair-deriver.map.js

@@ -0,0 +1,2 @@
+export { c as curveToKeyPairDeriver } from '../../../../../../../curve-to-key-pair-deriver.map-B3KvVk1f.js';
+import '../../../../../../../fromSeed-DfhShSKz.js';