@pezkuwi/util-crypto 14.0.1 → 14.0.3

package/cjs/hmac/shaAsU8a.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hmacSha512AsU8a = exports.hmacSha256AsU8a = void 0;
+exports.hmacShaAsU8a = hmacShaAsU8a;
+const hmac_1 = require("@noble/hashes/hmac");
+const sha256_1 = require("@noble/hashes/sha256");
+const sha512_1 = require("@noble/hashes/sha512");
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+const JS_HASH = {
+    256: sha256_1.sha256,
+    512: sha512_1.sha512
+};
+const WA_MHAC = {
+    256: wasm_crypto_1.hmacSha256,
+    512: wasm_crypto_1.hmacSha512
+};
+function createSha(bitLength) {
+    return (key, data, onlyJs) => hmacShaAsU8a(key, data, bitLength, onlyJs);
+}
+/**
+ * @name hmacShaAsU8a
+ * @description creates a Hmac Sha (256/512) Uint8Array from the key & data
+ */
+function hmacShaAsU8a(key, data, bitLength = 256, onlyJs) {
+    const u8aKey = (0, util_1.u8aToU8a)(key);
+    return !util_1.hasBigInt || (!onlyJs && (0, wasm_crypto_1.isReady)())
+        ? WA_MHAC[bitLength](u8aKey, data)
+        : (0, hmac_1.hmac)(JS_HASH[bitLength], u8aKey, data);
+}
+/**
+ * @name hmacSha256AsU8a
+ * @description creates a Hmac Sha256 Uint8Array from the key & data
+ */
+exports.hmacSha256AsU8a = createSha(256);
+/**
+ * @name hmacSha512AsU8a
+ * @description creates a Hmac Sha512 Uint8Array from the key & data
+ */
+exports.hmacSha512AsU8a = createSha(512);

package/cjs/index.d.ts

@@ -0,0 +1,2 @@
+import './packageDetect.js';
+export * from './bundle.js';

package/cjs/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+require("./packageDetect.js");
+tslib_1.__exportStar(require("./bundle.js"), exports);

package/cjs/json/constants.d.ts

@@ -0,0 +1,6 @@
+import type { EncryptedJsonEncoding, EncryptedJsonVersion } from './types.js';
+export declare const ENCODING: EncryptedJsonEncoding[];
+export declare const ENCODING_NONE: EncryptedJsonEncoding[];
+export declare const ENCODING_VERSION: EncryptedJsonVersion;
+export declare const NONCE_LENGTH = 24;
+export declare const SCRYPT_LENGTH: number;

package/cjs/json/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCRYPT_LENGTH = exports.NONCE_LENGTH = exports.ENCODING_VERSION = exports.ENCODING_NONE = exports.ENCODING = void 0;
+exports.ENCODING = ['scrypt', 'xsalsa20-poly1305'];
+exports.ENCODING_NONE = ['none'];
+exports.ENCODING_VERSION = '3';
+exports.NONCE_LENGTH = 24;
+exports.SCRYPT_LENGTH = 32 + (3 * 4);

package/cjs/json/decrypt.d.ts

@@ -0,0 +1,2 @@
+import type { EncryptedJson } from './types.js';
+export declare function jsonDecrypt({ encoded, encoding }: EncryptedJson, passphrase?: string | null): Uint8Array;

package/cjs/json/decrypt.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonDecrypt = jsonDecrypt;
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../base64/index.js");
+const decryptData_js_1 = require("./decryptData.js");
+function jsonDecrypt({ encoded, encoding }, passphrase) {
+    if (!encoded) {
+        throw new Error('No encrypted data available to decode');
+    }
+    return (0, decryptData_js_1.jsonDecryptData)((0, util_1.isHex)(encoded)
+        ? (0, util_1.hexToU8a)(encoded)
+        : (0, index_js_1.base64Decode)(encoded), passphrase, Array.isArray(encoding.type)
+        ? encoding.type
+        : [encoding.type]);
+}

package/cjs/json/decryptData.d.ts

@@ -0,0 +1,2 @@
+import type { EncryptedJsonEncoding } from './types.js';
+export declare function jsonDecryptData(encrypted?: Uint8Array | null, passphrase?: string | null, encType?: EncryptedJsonEncoding[]): Uint8Array;

package/cjs/json/decryptData.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonDecryptData = jsonDecryptData;
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../nacl/index.js");
+const index_js_2 = require("../scrypt/index.js");
+const constants_js_1 = require("./constants.js");
+function jsonDecryptData(encrypted, passphrase, encType = constants_js_1.ENCODING) {
+    if (!encrypted) {
+        throw new Error('No encrypted data available to decode');
+    }
+    else if (encType.includes('xsalsa20-poly1305') && !passphrase) {
+        throw new Error('Password required to decode encrypted data');
+    }
+    let encoded = encrypted;
+    if (passphrase) {
+        let password;
+        if (encType.includes('scrypt')) {
+            const { params, salt } = (0, index_js_2.scryptFromU8a)(encrypted);
+            password = (0, index_js_2.scryptEncode)(passphrase, salt, params).password;
+            encrypted = encrypted.subarray(constants_js_1.SCRYPT_LENGTH);
+        }
+        else {
+            password = (0, util_1.stringToU8a)(passphrase);
+        }
+        encoded = (0, index_js_1.naclDecrypt)(encrypted.subarray(constants_js_1.NONCE_LENGTH), encrypted.subarray(0, constants_js_1.NONCE_LENGTH), (0, util_1.u8aFixLength)(password, 256, true));
+    }
+    if (!encoded) {
+        throw new Error('Unable to decode using the supplied passphrase');
+    }
+    return encoded;
+}

package/cjs/json/encrypt.d.ts

@@ -0,0 +1,2 @@
+import type { EncryptedJson } from './types.js';
+export declare function jsonEncrypt(data: Uint8Array, contentType: string[], passphrase?: string | null): EncryptedJson;

package/cjs/json/encrypt.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonEncrypt = jsonEncrypt;
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../nacl/index.js");
+const index_js_2 = require("../scrypt/index.js");
+const encryptFormat_js_1 = require("./encryptFormat.js");
+function jsonEncrypt(data, contentType, passphrase) {
+    let isEncrypted = false;
+    let encoded = data;
+    if (passphrase) {
+        const { params, password, salt } = (0, index_js_2.scryptEncode)(passphrase);
+        const { encrypted, nonce } = (0, index_js_1.naclEncrypt)(encoded, password.subarray(0, 32));
+        isEncrypted = true;
+        encoded = (0, util_1.u8aConcat)((0, index_js_2.scryptToU8a)(salt, params), nonce, encrypted);
+    }
+    return (0, encryptFormat_js_1.jsonEncryptFormat)(encoded, contentType, isEncrypted);
+}

package/cjs/json/encryptFormat.d.ts

@@ -0,0 +1,2 @@
+import type { EncryptedJson } from './types.js';
+export declare function jsonEncryptFormat(encoded: Uint8Array, contentType: string[], isEncrypted: boolean): EncryptedJson;

package/cjs/json/encryptFormat.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonEncryptFormat = jsonEncryptFormat;
+const index_js_1 = require("../base64/index.js");
+const constants_js_1 = require("./constants.js");
+function jsonEncryptFormat(encoded, contentType, isEncrypted) {
+    return {
+        encoded: (0, index_js_1.base64Encode)(encoded),
+        encoding: {
+            content: contentType,
+            type: isEncrypted
+                ? constants_js_1.ENCODING
+                : constants_js_1.ENCODING_NONE,
+            version: constants_js_1.ENCODING_VERSION
+        }
+    };
+}

package/{src/json/index.ts → cjs/json/index.d.ts}

@@ -1,6 +1,3 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 export { jsonDecrypt } from './decrypt.js';
 export { jsonDecryptData } from './decryptData.js';
 export { jsonEncrypt } from './encrypt.js';

package/cjs/json/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonEncryptFormat = exports.jsonEncrypt = exports.jsonDecryptData = exports.jsonDecrypt = void 0;
+var decrypt_js_1 = require("./decrypt.js");
+Object.defineProperty(exports, "jsonDecrypt", { enumerable: true, get: function () { return decrypt_js_1.jsonDecrypt; } });
+var decryptData_js_1 = require("./decryptData.js");
+Object.defineProperty(exports, "jsonDecryptData", { enumerable: true, get: function () { return decryptData_js_1.jsonDecryptData; } });
+var encrypt_js_1 = require("./encrypt.js");
+Object.defineProperty(exports, "jsonEncrypt", { enumerable: true, get: function () { return encrypt_js_1.jsonEncrypt; } });
+var encryptFormat_js_1 = require("./encryptFormat.js");
+Object.defineProperty(exports, "jsonEncryptFormat", { enumerable: true, get: function () { return encryptFormat_js_1.jsonEncryptFormat; } });

package/cjs/json/types.d.ts

@@ -0,0 +1,16 @@
+export type EncryptedJsonVersion = '0' | '1' | '2' | '3';
+export type EncryptedJsonEncoding = 'none' | 'scrypt' | 'xsalsa20-poly1305';
+export interface EncryptedJsonDescriptor {
+    /** Descriptor for the content */
+    content: string[];
+    /** The encoding (in current/latest versions this is always an array) */
+    type: EncryptedJsonEncoding | EncryptedJsonEncoding[];
+    /** The version of encoding applied */
+    version: EncryptedJsonVersion;
+}
+export interface EncryptedJson {
+    /** The encoded string */
+    encoded: string;
+    /** The encoding used */
+    encoding: EncryptedJsonDescriptor;
+}

package/cjs/json/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/keccak/asU8a.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @name keccakAsU8a
+ * @summary Creates a keccak Uint8Array from the input.
+ * @description
+ * From either a `string` or a `Buffer` input, create the keccak and return the result as a `Uint8Array`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { keccakAsU8a } from '@polkadot/util-crypto';
+ *
+ * keccakAsU8a('123'); // => Uint8Array
+ * ```
+ */
+export declare const keccakAsU8a: (value: string | Uint8Array, bitLength?: 256 | 512, onlyJs?: boolean) => Uint8Array;
+/**
+ * @name keccak256AsU8a
+ * @description Creates a keccak256 Uint8Array from the input.
+ */
+export declare const keccak256AsU8a: (data: string | Uint8Array, onlyJs?: boolean) => Uint8Array;
+/**
+ * @name keccak512AsU8a
+ * @description Creates a keccak512 Uint8Array from the input.
+ */
+export declare const keccak512AsU8a: (data: string | Uint8Array, onlyJs?: boolean) => Uint8Array;
+/**
+ * @name keccakAsHex
+ * @description Creates a keccak hex string from the input.
+ */
+export declare const keccakAsHex: (value: string | Uint8Array, bitLength?: 256 | 512 | undefined, onlyJs?: boolean | undefined) => import("@polkadot/util/types").HexString;

package/cjs/keccak/asU8a.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keccakAsHex = exports.keccak512AsU8a = exports.keccak256AsU8a = exports.keccakAsU8a = void 0;
+const sha3_1 = require("@noble/hashes/sha3");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+const helpers_js_1 = require("../helpers.js");
+/**
+ * @name keccakAsU8a
+ * @summary Creates a keccak Uint8Array from the input.
+ * @description
+ * From either a `string` or a `Buffer` input, create the keccak and return the result as a `Uint8Array`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { keccakAsU8a } from '@pezkuwi/util-crypto';
+ *
+ * keccakAsU8a('123'); // => Uint8Array
+ * ```
+ */
+exports.keccakAsU8a = (0, helpers_js_1.createDualHasher)({ 256: wasm_crypto_1.keccak256, 512: wasm_crypto_1.keccak512 }, { 256: sha3_1.keccak_256, 512: sha3_1.keccak_512 });
+/**
+ * @name keccak256AsU8a
+ * @description Creates a keccak256 Uint8Array from the input.
+ */
+exports.keccak256AsU8a = (0, helpers_js_1.createBitHasher)(256, exports.keccakAsU8a);
+/**
+ * @name keccak512AsU8a
+ * @description Creates a keccak512 Uint8Array from the input.
+ */
+exports.keccak512AsU8a = (0, helpers_js_1.createBitHasher)(512, exports.keccakAsU8a);
+/**
+ * @name keccakAsHex
+ * @description Creates a keccak hex string from the input.
+ */
+exports.keccakAsHex = (0, helpers_js_1.createAsHex)(exports.keccakAsU8a);

package/{src/keccak/index.ts → cjs/keccak/index.d.ts}

@@ -1,8 +1,4 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 /**
  * @summary Create Keccak256/512 values as hex & Uint8Array output
  */
-
 export { keccak256AsU8a, keccak512AsU8a, keccakAsHex, keccakAsU8a } from './asU8a.js';

package/cjs/keccak/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keccakAsU8a = exports.keccakAsHex = exports.keccak512AsU8a = exports.keccak256AsU8a = void 0;
+/**
+ * @summary Create Keccak256/512 values as hex & Uint8Array output
+ */
+var asU8a_js_1 = require("./asU8a.js");
+Object.defineProperty(exports, "keccak256AsU8a", { enumerable: true, get: function () { return asU8a_js_1.keccak256AsU8a; } });
+Object.defineProperty(exports, "keccak512AsU8a", { enumerable: true, get: function () { return asU8a_js_1.keccak512AsU8a; } });
+Object.defineProperty(exports, "keccakAsHex", { enumerable: true, get: function () { return asU8a_js_1.keccakAsHex; } });
+Object.defineProperty(exports, "keccakAsU8a", { enumerable: true, get: function () { return asU8a_js_1.keccakAsU8a; } });

package/cjs/key/DeriveJunction.d.ts

@@ -0,0 +1,12 @@
+import { BN } from '@polkadot/util';
+export declare class DeriveJunction {
+    #private;
+    static from(value: string): DeriveJunction;
+    get chainCode(): Uint8Array;
+    get isHard(): boolean;
+    get isSoft(): boolean;
+    hard(value: number | string | bigint | BN | Uint8Array): DeriveJunction;
+    harden(): DeriveJunction;
+    soft(value: number | string | bigint | BN | Uint8Array): DeriveJunction;
+    soften(): DeriveJunction;
+}

package/cjs/key/DeriveJunction.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeriveJunction = void 0;
+const util_1 = require("@pezkuwi/util");
+const asU8a_js_1 = require("../blake2/asU8a.js");
+const bn_js_1 = require("../bn.js");
+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 util_1.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 ((0, util_1.isNumber)(value) || (0, util_1.isBn)(value) || (0, util_1.isBigInt)(value)) {
+            return this.soft((0, util_1.bnToU8a)(value, bn_js_1.BN_LE_256_OPTS));
+        }
+        else if ((0, util_1.isHex)(value)) {
+            return this.soft((0, util_1.hexToU8a)(value));
+        }
+        else if ((0, util_1.isString)(value)) {
+            return this.soft((0, util_1.compactAddLength)((0, util_1.stringToU8a)(value)));
+        }
+        else if (value.length > JUNCTION_ID_LEN) {
+            return this.soft((0, asU8a_js_1.blake2AsU8a)(value));
+        }
+        this.#chainCode.fill(0);
+        this.#chainCode.set(value, 0);
+        return this;
+    }
+    soften() {
+        this.#isHard = false;
+        return this;
+    }
+}
+exports.DeriveJunction = DeriveJunction;

package/cjs/key/extractPath.d.ts

@@ -0,0 +1,9 @@
+import { DeriveJunction } from './DeriveJunction.js';
+export interface ExtractResult {
+    parts: string[] | null;
+    path: DeriveJunction[];
+}
+/**
+ * @description Extract derivation junctions from the supplied path
+ */
+export declare function keyExtractPath(derivePath: string): ExtractResult;

package/cjs/key/extractPath.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyExtractPath = keyExtractPath;
+const DeriveJunction_js_1 = require("./DeriveJunction.js");
+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_js_1.DeriveJunction.from(p.substring(1)));
+        }
+    }
+    if (constructed !== derivePath) {
+        throw new Error(`Re-constructed path "${constructed}" does not match input`);
+    }
+    return {
+        parts,
+        path
+    };
+}

package/cjs/key/extractSuri.d.ts

@@ -0,0 +1,11 @@
+import type { DeriveJunction } from './DeriveJunction.js';
+export interface ExtractResult {
+    derivePath: string;
+    password?: string;
+    path: DeriveJunction[];
+    phrase: string;
+}
+/**
+ * @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).
+ */
+export declare function keyExtractSuri(suri: string): ExtractResult;

package/cjs/key/extractSuri.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyExtractSuri = keyExtractSuri;
+const extractPath_js_1 = require("./extractPath.js");
+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 } = (0, extractPath_js_1.keyExtractPath)(derivePath);
+    return {
+        derivePath,
+        password,
+        path,
+        phrase
+    };
+}

package/cjs/key/fromPath.d.ts

@@ -0,0 +1,3 @@
+import type { Keypair, KeypairType } from '../types.js';
+import type { DeriveJunction } from './DeriveJunction.js';
+export declare function keyFromPath(pair: Keypair, path: DeriveJunction[], type: KeypairType): Keypair;

package/cjs/key/fromPath.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyFromPath = keyFromPath;
+const hdkdEcdsa_js_1 = require("./hdkdEcdsa.js");
+const hdkdEd25519_js_1 = require("./hdkdEd25519.js");
+const hdkdSr25519_js_1 = require("./hdkdSr25519.js");
+const generators = {
+    ecdsa: hdkdEcdsa_js_1.keyHdkdEcdsa,
+    ed25519: hdkdEd25519_js_1.keyHdkdEd25519,
+    // FIXME This is Substrate-compatible, not Ethereum-compatible
+    ethereum: hdkdEcdsa_js_1.keyHdkdEcdsa,
+    sr25519: hdkdSr25519_js_1.keyHdkdSr25519
+};
+function keyFromPath(pair, path, type) {
+    const keyHdkd = generators[type];
+    let result = pair;
+    for (const junction of path) {
+        result = keyHdkd(result, junction);
+    }
+    return result;
+}

package/cjs/key/hdkdDerive.d.ts

@@ -0,0 +1,3 @@
+import type { Keypair } from '../types.js';
+import type { DeriveJunction } from './DeriveJunction.js';
+export declare function createSeedDeriveFn(fromSeed: (seed: Uint8Array) => Keypair, derive: (seed: Uint8Array, chainCode: Uint8Array) => Uint8Array): (keypair: Keypair, junction: DeriveJunction) => Keypair;

package/cjs/key/hdkdDerive.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSeedDeriveFn = createSeedDeriveFn;
+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));
+    };
+}

package/cjs/key/hdkdEcdsa.d.ts

@@ -0,0 +1 @@
+export declare const keyHdkdEcdsa: (keypair: import("../types.js").Keypair, junction: import("./DeriveJunction.js").DeriveJunction) => import("../types.js").Keypair;

package/cjs/key/hdkdEcdsa.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyHdkdEcdsa = void 0;
+const deriveHard_js_1 = require("../secp256k1/deriveHard.js");
+const fromSeed_js_1 = require("../secp256k1/pair/fromSeed.js");
+const hdkdDerive_js_1 = require("./hdkdDerive.js");
+exports.keyHdkdEcdsa = (0, hdkdDerive_js_1.createSeedDeriveFn)(fromSeed_js_1.secp256k1PairFromSeed, deriveHard_js_1.secp256k1DeriveHard);

package/cjs/key/hdkdEd25519.d.ts

@@ -0,0 +1 @@
+export declare const keyHdkdEd25519: (keypair: import("../types.js").Keypair, junction: import("./DeriveJunction.js").DeriveJunction) => import("../types.js").Keypair;

package/cjs/key/hdkdEd25519.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyHdkdEd25519 = void 0;
+const index_js_1 = require("../ed25519/index.js");
+const hdkdDerive_js_1 = require("./hdkdDerive.js");
+exports.keyHdkdEd25519 = (0, hdkdDerive_js_1.createSeedDeriveFn)(index_js_1.ed25519PairFromSeed, index_js_1.ed25519DeriveHard);

package/cjs/key/hdkdSr25519.d.ts

@@ -0,0 +1,3 @@
+import type { Keypair } from '../types.js';
+import type { DeriveJunction } from './DeriveJunction.js';
+export declare function keyHdkdSr25519(keypair: Keypair, { chainCode, isSoft }: DeriveJunction): Keypair;

package/cjs/key/hdkdSr25519.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyHdkdSr25519 = keyHdkdSr25519;
+const deriveHard_js_1 = require("../sr25519/deriveHard.js");
+const deriveSoft_js_1 = require("../sr25519/deriveSoft.js");
+function keyHdkdSr25519(keypair, { chainCode, isSoft }) {
+    return isSoft
+        ? (0, deriveSoft_js_1.sr25519DeriveSoft)(keypair, chainCode)
+        : (0, deriveHard_js_1.sr25519DeriveHard)(keypair, chainCode);
+}

package/{src/key/index.ts → cjs/key/index.d.ts}

@@ -1,6 +1,3 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 /**
  * @summary Create keys from paths, seeds and password
  */

package/cjs/key/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyHdkdSr25519 = exports.keyHdkdEd25519 = exports.keyHdkdEcdsa = exports.keyFromPath = exports.keyExtractSuri = exports.keyExtractPath = void 0;
+/**
+ * @summary Create keys from paths, seeds and password
+ */
+var extractPath_js_1 = require("./extractPath.js");
+Object.defineProperty(exports, "keyExtractPath", { enumerable: true, get: function () { return extractPath_js_1.keyExtractPath; } });
+var extractSuri_js_1 = require("./extractSuri.js");
+Object.defineProperty(exports, "keyExtractSuri", { enumerable: true, get: function () { return extractSuri_js_1.keyExtractSuri; } });
+var fromPath_js_1 = require("./fromPath.js");
+Object.defineProperty(exports, "keyFromPath", { enumerable: true, get: function () { return fromPath_js_1.keyFromPath; } });
+var hdkdEcdsa_js_1 = require("./hdkdEcdsa.js");
+Object.defineProperty(exports, "keyHdkdEcdsa", { enumerable: true, get: function () { return hdkdEcdsa_js_1.keyHdkdEcdsa; } });
+var hdkdEd25519_js_1 = require("./hdkdEd25519.js");
+Object.defineProperty(exports, "keyHdkdEd25519", { enumerable: true, get: function () { return hdkdEd25519_js_1.keyHdkdEd25519; } });
+var hdkdSr25519_js_1 = require("./hdkdSr25519.js");
+Object.defineProperty(exports, "keyHdkdSr25519", { enumerable: true, get: function () { return hdkdSr25519_js_1.keyHdkdSr25519; } });

package/cjs/mnemonic/bip39.d.ts

@@ -0,0 +1,5 @@
+export declare function mnemonicToSeedSync(mnemonic: string, password?: string): Uint8Array;
+export declare function mnemonicToEntropy(mnemonic: string, wordlist?: string[]): Uint8Array;
+export declare function entropyToMnemonic(entropy: Uint8Array, wordlist?: string[]): string;
+export declare function generateMnemonic(numWords: 12 | 15 | 18 | 21 | 24, wordlist?: string[]): string;
+export declare function validateMnemonic(mnemonic: string, wordlist?: string[]): boolean;