@pezkuwi/util-crypto 14.0.2 → 14.0.4

package/cjs/ethereum/isAddress.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEthereumAddress = isEthereumAddress;
+const util_1 = require("@pezkuwi/util");
+const isChecksum_js_1 = require("./isChecksum.js");
+function isEthereumAddress(address) {
+    if (!address || address.length !== 42 || !(0, util_1.isHex)(address)) {
+        return false;
+    }
+    else if (/^(0x)?[0-9a-f]{40}$/.test(address) || /^(0x)?[0-9A-F]{40}$/.test(address)) {
+        return true;
+    }
+    return (0, isChecksum_js_1.isEthereumChecksum)(address);
+}

package/cjs/ethereum/isChecksum.d.ts

@@ -0,0 +1 @@
+export declare function isEthereumChecksum(_address: string): boolean;

package/cjs/ethereum/isChecksum.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEthereumChecksum = isEthereumChecksum;
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../keccak/index.js");
+function isInvalidChar(char, byte) {
+    return char !== (byte > 7
+        ? char.toUpperCase()
+        : char.toLowerCase());
+}
+function isEthereumChecksum(_address) {
+    const address = _address.replace('0x', '');
+    const hash = (0, util_1.u8aToHex)((0, index_js_1.keccakAsU8a)(address.toLowerCase()), -1, false);
+    for (let i = 0; i < 40; i++) {
+        if (isInvalidChar(address[i], parseInt(hash[i], 16))) {
+            return false;
+        }
+    }
+    return true;
+}

package/cjs/hd/ethereum/index.d.ts

@@ -0,0 +1,2 @@
+import type { Keypair } from '../../types.js';
+export declare function hdEthereum(seed: Uint8Array, path?: string): Keypair;

package/cjs/hd/ethereum/index.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hdEthereum = hdEthereum;
+const util_1 = require("@pezkuwi/util");
+const bn_js_1 = require("../../bn.js");
+const index_js_1 = require("../../hmac/index.js");
+const index_js_2 = require("../../secp256k1/index.js");
+const validatePath_js_1 = require("../validatePath.js");
+const MASTER_SECRET = (0, util_1.stringToU8a)('Bitcoin seed');
+function createCoded(secretKey, chainCode) {
+    return {
+        chainCode,
+        publicKey: (0, index_js_2.secp256k1PairFromSeed)(secretKey).publicKey,
+        secretKey
+    };
+}
+function deriveChild(hd, index) {
+    const indexBuffer = (0, util_1.bnToU8a)(index, bn_js_1.BN_BE_32_OPTS);
+    const data = index >= validatePath_js_1.HARDENED
+        ? (0, util_1.u8aConcat)(new Uint8Array(1), hd.secretKey, indexBuffer)
+        : (0, util_1.u8aConcat)(hd.publicKey, indexBuffer);
+    try {
+        const I = (0, index_js_1.hmacShaAsU8a)(hd.chainCode, data, 512);
+        return createCoded((0, index_js_2.secp256k1PrivateKeyTweakAdd)(hd.secretKey, I.slice(0, 32)), I.slice(32));
+    }
+    catch {
+        // In case parse256(IL) >= n or ki == 0, proceed with the next value for i
+        return deriveChild(hd, index + 1);
+    }
+}
+function hdEthereum(seed, path = '') {
+    const I = (0, index_js_1.hmacShaAsU8a)(MASTER_SECRET, seed, 512);
+    let hd = createCoded(I.slice(0, 32), I.slice(32));
+    if (!path || path === 'm' || path === 'M' || path === "m'" || path === "M'") {
+        return hd;
+    }
+    if (!(0, validatePath_js_1.hdValidatePath)(path)) {
+        throw new Error('Invalid derivation path');
+    }
+    const parts = path.split('/').slice(1);
+    for (const p of parts) {
+        hd = deriveChild(hd, parseInt(p, 10) + ((p.length > 1) && p.endsWith("'")
+            ? validatePath_js_1.HARDENED
+            : 0));
+    }
+    return hd;
+}

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

@@ -1,6 +1,3 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 export { hdEthereum } from './ethereum/index.js';
 export { hdLedger } from './ledger/index.js';
 export { hdValidatePath } from './validatePath.js';

package/cjs/hd/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hdValidatePath = exports.hdLedger = exports.hdEthereum = void 0;
+var index_js_1 = require("./ethereum/index.js");
+Object.defineProperty(exports, "hdEthereum", { enumerable: true, get: function () { return index_js_1.hdEthereum; } });
+var index_js_2 = require("./ledger/index.js");
+Object.defineProperty(exports, "hdLedger", { enumerable: true, get: function () { return index_js_2.hdLedger; } });
+var validatePath_js_1 = require("./validatePath.js");
+Object.defineProperty(exports, "hdValidatePath", { enumerable: true, get: function () { return validatePath_js_1.hdValidatePath; } });

package/cjs/hd/ledger/derivePrivate.d.ts

@@ -0,0 +1 @@
+export declare function ledgerDerivePrivate(xprv: Uint8Array, index: number): Uint8Array;

package/cjs/hd/ledger/derivePrivate.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ledgerDerivePrivate = ledgerDerivePrivate;
+const util_1 = require("@pezkuwi/util");
+const bn_js_1 = require("../../bn.js");
+const index_js_1 = require("../../hmac/index.js");
+function ledgerDerivePrivate(xprv, index) {
+    const kl = xprv.subarray(0, 32);
+    const kr = xprv.subarray(32, 64);
+    const cc = xprv.subarray(64, 96);
+    const data = (0, util_1.u8aConcat)([0], kl, kr, (0, util_1.bnToU8a)(index, bn_js_1.BN_LE_32_OPTS));
+    const z = (0, index_js_1.hmacShaAsU8a)(cc, data, 512);
+    data[0] = 0x01;
+    return (0, util_1.u8aConcat)((0, util_1.bnToU8a)((0, util_1.u8aToBn)(kl, bn_js_1.BN_LE_OPTS).iadd((0, util_1.u8aToBn)(z.subarray(0, 28), bn_js_1.BN_LE_OPTS).imul(util_1.BN_EIGHT)), bn_js_1.BN_LE_512_OPTS).subarray(0, 32), (0, util_1.bnToU8a)((0, util_1.u8aToBn)(kr, bn_js_1.BN_LE_OPTS).iadd((0, util_1.u8aToBn)(z.subarray(32, 64), bn_js_1.BN_LE_OPTS)), bn_js_1.BN_LE_512_OPTS).subarray(0, 32), (0, index_js_1.hmacShaAsU8a)(cc, data, 512).subarray(32, 64));
+}

package/cjs/hd/ledger/index.d.ts

@@ -0,0 +1,2 @@
+import type { Keypair } from '../../types.js';
+export declare function hdLedger(_mnemonic: string, path: string): Keypair;

package/cjs/hd/ledger/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hdLedger = hdLedger;
+const index_js_1 = require("../../ed25519/index.js");
+const index_js_2 = require("../../mnemonic/index.js");
+const validatePath_js_1 = require("../validatePath.js");
+const derivePrivate_js_1 = require("./derivePrivate.js");
+const master_js_1 = require("./master.js");
+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 (!(0, index_js_2.mnemonicValidate)(mnemonic)) {
+        throw new Error('Invalid mnemonic passed to ledger derivation');
+    }
+    else if (!(0, validatePath_js_1.hdValidatePath)(path)) {
+        throw new Error('Invalid derivation path');
+    }
+    const parts = path.split('/').slice(1);
+    let seed = (0, master_js_1.ledgerMaster)(mnemonic, password);
+    for (const p of parts) {
+        const n = parseInt(p.replace(/'$/, ''), 10);
+        seed = (0, derivePrivate_js_1.ledgerDerivePrivate)(seed, (n < validatePath_js_1.HARDENED) ? (n + validatePath_js_1.HARDENED) : n);
+    }
+    return (0, index_js_1.ed25519PairFromSeed)(seed.slice(0, 32));
+}

package/cjs/hd/ledger/master.d.ts

@@ -0,0 +1 @@
+export declare function ledgerMaster(mnemonic: string, password?: string): Uint8Array;

package/cjs/hd/ledger/master.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ledgerMaster = ledgerMaster;
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../../hmac/index.js");
+const bip39_js_1 = require("../../mnemonic/bip39.js");
+const ED25519_CRYPTO = 'ed25519 seed';
+function ledgerMaster(mnemonic, password) {
+    const seed = (0, bip39_js_1.mnemonicToSeedSync)(mnemonic, password);
+    const chainCode = (0, index_js_1.hmacShaAsU8a)(ED25519_CRYPTO, new Uint8Array([1, ...seed]), 256);
+    let priv;
+    while (!priv || (priv[31] & 0b0010_0000)) {
+        priv = (0, index_js_1.hmacShaAsU8a)(ED25519_CRYPTO, priv || seed, 512);
+    }
+    priv[0] &= 0b1111_1000;
+    priv[31] &= 0b0111_1111;
+    priv[31] |= 0b0100_0000;
+    return (0, util_1.u8aConcat)(priv, chainCode);
+}

package/cjs/hd/validatePath.d.ts

@@ -0,0 +1,2 @@
+export declare const HARDENED = 2147483648;
+export declare function hdValidatePath(path: string): boolean;

package/cjs/hd/validatePath.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HARDENED = void 0;
+exports.hdValidatePath = hdValidatePath;
+exports.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 >= exports.HARDENED) || (n < 0)) {
+            return false;
+        }
+    }
+    return true;
+}

package/cjs/helpers.d.ts

@@ -0,0 +1,12 @@
+import type { HexString } from '@polkadot/util/types';
+export type { HexString } from '@polkadot/util/types';
+interface DualHash {
+    256: (u8a: Uint8Array) => Uint8Array;
+    512: (u8a: Uint8Array) => Uint8Array;
+}
+/** @internal */
+export declare function createAsHex<T extends (...args: never[]) => Uint8Array>(fn: T): (...args: Parameters<T>) => HexString;
+/** @internal */
+export declare function createBitHasher(bitLength: 256 | 512, fn: (data: string | Uint8Array, bitLength: 256 | 512, onlyJs?: boolean) => Uint8Array): (data: string | Uint8Array, onlyJs?: boolean) => Uint8Array;
+/** @internal */
+export declare function createDualHasher(wa: DualHash, js: DualHash): (value: string | Uint8Array, bitLength?: 256 | 512, onlyJs?: boolean) => Uint8Array;

package/cjs/helpers.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAsHex = createAsHex;
+exports.createBitHasher = createBitHasher;
+exports.createDualHasher = createDualHasher;
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+/** @internal */
+function createAsHex(fn) {
+    return (...args) => (0, util_1.u8aToHex)(fn(...args));
+}
+/** @internal */
+function createBitHasher(bitLength, fn) {
+    return (data, onlyJs) => fn(data, bitLength, onlyJs);
+}
+/** @internal */
+function createDualHasher(wa, js) {
+    return (value, bitLength = 256, onlyJs) => {
+        const u8a = (0, util_1.u8aToU8a)(value);
+        return !util_1.hasBigInt || (!onlyJs && (0, wasm_crypto_1.isReady)())
+            ? wa[bitLength](u8a)
+            : js[bitLength](u8a);
+    };
+}

package/cjs/hmac/index.d.ts

@@ -0,0 +1 @@
+export { hmacSha256AsU8a, hmacSha512AsU8a, hmacShaAsU8a } from './shaAsU8a.js';

package/cjs/hmac/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hmacShaAsU8a = exports.hmacSha512AsU8a = exports.hmacSha256AsU8a = void 0;
+var shaAsU8a_js_1 = require("./shaAsU8a.js");
+Object.defineProperty(exports, "hmacSha256AsU8a", { enumerable: true, get: function () { return shaAsU8a_js_1.hmacSha256AsU8a; } });
+Object.defineProperty(exports, "hmacSha512AsU8a", { enumerable: true, get: function () { return shaAsU8a_js_1.hmacSha512AsU8a; } });
+Object.defineProperty(exports, "hmacShaAsU8a", { enumerable: true, get: function () { return shaAsU8a_js_1.hmacShaAsU8a; } });

package/cjs/hmac/shaAsU8a.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name hmacShaAsU8a
+ * @description creates a Hmac Sha (256/512) Uint8Array from the key & data
+ */
+export declare function hmacShaAsU8a(key: Uint8Array | string, data: Uint8Array, bitLength?: 256 | 512, onlyJs?: boolean): Uint8Array;
+/**
+ * @name hmacSha256AsU8a
+ * @description creates a Hmac Sha256 Uint8Array from the key & data
+ */
+export declare const hmacSha256AsU8a: (key: Uint8Array | string, data: Uint8Array, onlyJs?: boolean) => Uint8Array;
+/**
+ * @name hmacSha512AsU8a
+ * @description creates a Hmac Sha512 Uint8Array from the key & data
+ */
+export declare const hmacSha512AsU8a: (key: Uint8Array | string, data: Uint8Array, onlyJs?: boolean) => Uint8Array;

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/init.d.ts

@@ -0,0 +1,10 @@
+import type { InitFn, WasmBaseInstance, WasmImports } from './types.js';
+/**
+ * @name createWasmFn
+ * @description
+ * Create a WASM (or ASM.js) creator interface based on the supplied information.
+ *
+ * It will attempt to create a WASM interface first and if this fails or is not available in
+ * the environment, will fallback to attempting to create an ASM.js interface.
+ */
+export declare function createWasmFn<C extends WasmBaseInstance>(root: 'crypto', wasmBytes: null | Uint8Array, asmFn: null | ((wbg: WasmImports) => C)): InitFn<C>;

package/cjs/init.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWasmFn = createWasmFn;
+/**
+ * @name createWasmFn
+ * @description
+ * Create a WASM (or ASM.js) creator interface based on the supplied information.
+ *
+ * It will attempt to create a WASM interface first and if this fails or is not available in
+ * the environment, will fallback to attempting to create an ASM.js interface.
+ */
+function createWasmFn(root, wasmBytes, asmFn) {
+    return async (wbg) => {
+        const result = {
+            error: null,
+            type: 'none',
+            wasm: null
+        };
+        try {
+            if (!wasmBytes?.length) {
+                throw new Error('No WebAssembly provided for initialization');
+            }
+            else if (typeof WebAssembly !== 'object' || typeof WebAssembly.instantiate !== 'function') {
+                throw new Error('WebAssembly is not available in your environment');
+            }
+            const source = await WebAssembly.instantiate(wasmBytes, { wbg });
+            result.wasm = source.instance.exports;
+            result.type = 'wasm';
+        }
+        catch (error) {
+            // if we have a valid supplied asm.js, return that
+            if (typeof asmFn === 'function') {
+                result.wasm = asmFn(wbg);
+                result.type = 'asm';
+            }
+            else {
+                result.error = `FATAL: Unable to initialize @pezkuwi/wasm-${root}:: ${error.message}`;
+                console.error(result.error);
+            }
+        }
+        return result;
+    };
+}

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';