@pezkuwi/util-crypto 14.0.2 → 14.0.4

package/cjs/sr25519/verify.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sr25519Verify = sr25519Verify;
+const tslib_1 = require("tslib");
+const sr25519 = tslib_1.__importStar(require("@scure/sr25519"));
+const util_1 = require("@pezkuwi/util");
+/**
+ * @name sr25519Verify
+ * @description Verifies the signature of `message`, using the supplied pair
+ */
+function sr25519Verify(message, signature, publicKey) {
+    const publicKeyU8a = (0, util_1.u8aToU8a)(publicKey);
+    const signatureU8a = (0, util_1.u8aToU8a)(signature);
+    if (publicKeyU8a.length !== 32) {
+        throw new Error(`Invalid publicKey, received ${publicKeyU8a.length} bytes, expected 32`);
+    }
+    else if (signatureU8a.length !== 64) {
+        throw new Error(`Invalid signature, received ${signatureU8a.length} bytes, expected 64`);
+    }
+    return sr25519.verify((0, util_1.u8aToU8a)(message), signatureU8a, publicKeyU8a);
+}

package/cjs/sr25519/vrfSign.d.ts

@@ -0,0 +1,6 @@
+import type { Keypair } from '../types.js';
+/**
+ * @name sr25519VrfSign
+ * @description Sign with sr25519 vrf signing (deterministic)
+ */
+export declare function sr25519VrfSign(message: string | Uint8Array, { secretKey }: Partial<Keypair>, context?: string | Uint8Array, extra?: string | Uint8Array): Uint8Array;

package/cjs/sr25519/vrfSign.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sr25519VrfSign = sr25519VrfSign;
+const tslib_1 = require("tslib");
+const utils_1 = require("@noble/hashes/utils");
+const sr25519 = tslib_1.__importStar(require("@scure/sr25519"));
+const util_1 = require("@pezkuwi/util");
+const EMPTY_U8A = new Uint8Array();
+/**
+ * @name sr25519VrfSign
+ * @description Sign with sr25519 vrf signing (deterministic)
+ */
+function sr25519VrfSign(message, { secretKey }, context = EMPTY_U8A, extra = EMPTY_U8A) {
+    if (secretKey?.length !== 64) {
+        throw new Error('Invalid secretKey, expected 64-bytes');
+    }
+    return sr25519.vrf.sign((0, util_1.u8aToU8a)(message), secretKey, (0, util_1.u8aToU8a)(context), (0, util_1.u8aToU8a)(extra), utils_1.randomBytes);
+    // return vrfSign(secretKey, u8aToU8a(context), u8aToU8a(message), u8aToU8a(extra));
+}

package/cjs/sr25519/vrfVerify.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @name sr25519VrfVerify
+ * @description Verify with sr25519 vrf verification
+ */
+export declare function sr25519VrfVerify(message: string | Uint8Array, signOutput: string | Uint8Array, publicKey: string | Uint8Array, context?: string | Uint8Array, extra?: string | Uint8Array): boolean;

package/cjs/sr25519/vrfVerify.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sr25519VrfVerify = sr25519VrfVerify;
+const tslib_1 = require("tslib");
+const sr25519 = tslib_1.__importStar(require("@scure/sr25519"));
+const util_1 = require("@pezkuwi/util");
+const EMPTY_U8A = new Uint8Array();
+/**
+ * @name sr25519VrfVerify
+ * @description Verify with sr25519 vrf verification
+ */
+function sr25519VrfVerify(message, signOutput, publicKey, context = EMPTY_U8A, extra = EMPTY_U8A) {
+    const publicKeyU8a = (0, util_1.u8aToU8a)(publicKey);
+    const proofU8a = (0, util_1.u8aToU8a)(signOutput);
+    if (publicKeyU8a.length !== 32) {
+        throw new Error('Invalid publicKey, expected 32-bytes');
+    }
+    else if (proofU8a.length !== 96) {
+        throw new Error('Invalid vrfSign output, expected 96 bytes');
+    }
+    return sr25519.vrf.verify((0, util_1.u8aToU8a)(message), proofU8a, publicKeyU8a, (0, util_1.u8aToU8a)(context), (0, util_1.u8aToU8a)(extra));
+}

package/cjs/types.d.ts

@@ -0,0 +1,26 @@
+export * from './address/types.js';
+export * from './json/types.js';
+export interface Keypair {
+    /** The publicKey for this pair */
+    publicKey: Uint8Array;
+    /** The secretKey for this pair */
+    secretKey: Uint8Array;
+}
+export interface Seedpair {
+    /** The publicKey for this pair */
+    publicKey: Uint8Array;
+    /** The seed used to construct the pair */
+    seed: Uint8Array;
+}
+/** The supported types of pairs */
+export type KeypairType = 'ed25519' | 'sr25519' | 'ecdsa' | 'ethereum';
+export interface VerifyResult {
+    /** The detected crypto interface, or 'none' if not detected */
+    crypto: 'none' | KeypairType;
+    /** The validity for this result, false if invalid */
+    isValid: boolean;
+    /** Flag to indicate if the passed data was wrapped in <Bytes>...</Bytes> */
+    isWrapped: boolean;
+    /** The extracted publicKey */
+    publicKey: Uint8Array;
+}

package/cjs/types.js

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

package/cjs/wbg.d.ts

@@ -0,0 +1,36 @@
+import type { BridgeBase, WasmBaseInstance } from './types.js';
+/**
+ * @name Wbg
+ * @description
+ * This defines the internal interfaces that wasm-bindgen used to communicate
+ * with the host layer. None of these functions are available to the user, rather
+ * they are called internally from the WASM code itself.
+ *
+ * The interfaces here are exposed in the imports on the created WASM interfaces.
+ *
+ * Internally the implementation does a thin layer into the supplied bridge.
+ */
+export declare class Wbg<C extends WasmBaseInstance> {
+    #private;
+    constructor(bridge: BridgeBase<C>);
+    /** @internal */
+    abort: () => never;
+    /** @internal */
+    __wbindgen_is_undefined: (idx: number) => boolean;
+    /** @internal */
+    __wbindgen_throw: (ptr: number, len: number) => boolean;
+    /** @internal */
+    __wbg_self_1b7a39e3a92c949c: () => number;
+    /** @internal */
+    __wbg_require_604837428532a733: (ptr: number, len: number) => never;
+    /** @internal */
+    __wbg_crypto_968f1772287e2df0: (_idx: number) => number;
+    /** @internal */
+    __wbg_getRandomValues_a3d34b4fee3c2869: (_idx: number) => number;
+    /** @internal */
+    __wbg_getRandomValues_f5e14ab7ac8e995d: (_arg0: number, ptr: number, len: number) => void;
+    /** @internal */
+    __wbg_randomFillSync_d5bd2d655fdf256a: (_idx: number, _ptr: number, _len: number) => never;
+    /** @internal */
+    __wbindgen_object_drop_ref: (idx: number) => void;
+}

package/cjs/wbg.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Wbg = void 0;
+const x_randomvalues_1 = require("@pezkuwi/x-randomvalues");
+const DEFAULT_CRYPTO = { getRandomValues: x_randomvalues_1.getRandomValues };
+const DEFAULT_SELF = { crypto: DEFAULT_CRYPTO };
+/**
+ * @name Wbg
+ * @description
+ * This defines the internal interfaces that wasm-bindgen used to communicate
+ * with the host layer. None of these functions are available to the user, rather
+ * they are called internally from the WASM code itself.
+ *
+ * The interfaces here are exposed in the imports on the created WASM interfaces.
+ *
+ * Internally the implementation does a thin layer into the supplied bridge.
+ */
+class Wbg {
+    #bridge;
+    constructor(bridge) {
+        this.#bridge = bridge;
+    }
+    /** @internal */
+    abort = () => {
+        throw new Error('abort');
+    };
+    /** @internal */
+    __wbindgen_is_undefined = (idx) => {
+        return this.#bridge.getObject(idx) === undefined;
+    };
+    /** @internal */
+    __wbindgen_throw = (ptr, len) => {
+        throw new Error(this.#bridge.getString(ptr, len));
+    };
+    /** @internal */
+    __wbg_self_1b7a39e3a92c949c = () => {
+        return this.#bridge.addObject(DEFAULT_SELF);
+    };
+    /** @internal */
+    __wbg_require_604837428532a733 = (ptr, len) => {
+        throw new Error(`Unable to require ${this.#bridge.getString(ptr, len)}`);
+    };
+    /** @internal */
+    __wbg_crypto_968f1772287e2df0 = (_idx) => {
+        return this.#bridge.addObject(DEFAULT_CRYPTO);
+    };
+    /** @internal */
+    __wbg_getRandomValues_a3d34b4fee3c2869 = (_idx) => {
+        return this.#bridge.addObject(DEFAULT_CRYPTO.getRandomValues);
+    };
+    /** @internal */
+    __wbg_getRandomValues_f5e14ab7ac8e995d = (_arg0, ptr, len) => {
+        DEFAULT_CRYPTO.getRandomValues(this.#bridge.getU8a(ptr, len));
+    };
+    /** @internal */
+    __wbg_randomFillSync_d5bd2d655fdf256a = (_idx, _ptr, _len) => {
+        throw new Error('randomFillsync is not available');
+        // getObject(idx).randomFillSync(getU8a(ptr, len));
+    };
+    /** @internal */
+    __wbindgen_object_drop_ref = (idx) => {
+        this.#bridge.takeObject(idx);
+    };
+}
+exports.Wbg = Wbg;

package/cjs/xxhash/asU8a.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @name xxhashAsU8a
+ * @summary Creates a xxhash64 u8a from the input.
+ * @description
+ * From either a `string`, `Uint8Array` or a `Buffer` input, create the xxhash64 and return the result as a `Uint8Array` with the specified `bitLength`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { xxhashAsU8a } from '@polkadot/util-crypto';
+ *
+ * xxhashAsU8a('abc'); // => 0x44bc2cf5ad770999
+ * ```
+ */
+export declare function xxhashAsU8a(data: string | Uint8Array, bitLength?: 64 | 128 | 192 | 256 | 320 | 384 | 448 | 512, onlyJs?: boolean): Uint8Array;
+/**
+ * @name xxhashAsHex
+ * @description Creates a xxhash64 hex from the input.
+ */
+export declare const xxhashAsHex: (data: string | Uint8Array, bitLength?: 256 | 512 | 64 | 128 | 384 | 320 | 192 | 448 | undefined, onlyJs?: boolean | undefined) => import("@polkadot/util/types").HexString;

package/cjs/xxhash/asU8a.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xxhashAsHex = void 0;
+exports.xxhashAsU8a = xxhashAsU8a;
+const util_1 = require("@pezkuwi/util");
+const wasm_crypto_1 = require("@pezkuwi/wasm-crypto");
+const helpers_js_1 = require("../helpers.js");
+const xxhash64_js_1 = require("./xxhash64.js");
+/**
+ * @name xxhashAsU8a
+ * @summary Creates a xxhash64 u8a from the input.
+ * @description
+ * From either a `string`, `Uint8Array` or a `Buffer` input, create the xxhash64 and return the result as a `Uint8Array` with the specified `bitLength`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { xxhashAsU8a } from '@pezkuwi/util-crypto';
+ *
+ * xxhashAsU8a('abc'); // => 0x44bc2cf5ad770999
+ * ```
+ */
+function xxhashAsU8a(data, bitLength = 64, onlyJs) {
+    const rounds = Math.ceil(bitLength / 64);
+    const u8a = (0, util_1.u8aToU8a)(data);
+    if (!util_1.hasBigInt || (!onlyJs && (0, wasm_crypto_1.isReady)())) {
+        return (0, wasm_crypto_1.twox)(u8a, rounds);
+    }
+    const result = new Uint8Array(rounds * 8);
+    for (let seed = 0; seed < rounds; seed++) {
+        result.set((0, xxhash64_js_1.xxhash64)(u8a, seed).reverse(), seed * 8);
+    }
+    return result;
+}
+/**
+ * @name xxhashAsHex
+ * @description Creates a xxhash64 hex from the input.
+ */
+exports.xxhashAsHex = (0, helpers_js_1.createAsHex)(xxhashAsU8a);

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

@@ -1,8 +1,4 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 /**
  * @summary Create xxhash64 values with specified bitlengths
  */
-
 export { xxhashAsHex, xxhashAsU8a } from './asU8a.js';

package/cjs/xxhash/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xxhashAsU8a = exports.xxhashAsHex = void 0;
+/**
+ * @summary Create xxhash64 values with specified bitlengths
+ */
+var asU8a_js_1 = require("./asU8a.js");
+Object.defineProperty(exports, "xxhashAsHex", { enumerable: true, get: function () { return asU8a_js_1.xxhashAsHex; } });
+Object.defineProperty(exports, "xxhashAsU8a", { enumerable: true, get: function () { return asU8a_js_1.xxhashAsU8a; } });

package/cjs/xxhash/xxhash64.d.ts

@@ -0,0 +1 @@
+export declare function xxhash64(input: Uint8Array, initSeed: bigint | number): Uint8Array;

package/cjs/xxhash/xxhash64.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xxhash64 = xxhash64;
+const util_1 = require("@pezkuwi/util");
+const x_bigint_1 = require("@pezkuwi/x-bigint");
+const P64_1 = (0, x_bigint_1.BigInt)('11400714785074694791');
+const P64_2 = (0, x_bigint_1.BigInt)('14029467366897019727');
+const P64_3 = (0, x_bigint_1.BigInt)('1609587929392839161');
+const P64_4 = (0, x_bigint_1.BigInt)('9650029242287828579');
+const P64_5 = (0, x_bigint_1.BigInt)('2870177450012600261');
+const U64 = (0, x_bigint_1.BigInt)('0xffffffffffffffff');
+const _7n = (0, x_bigint_1.BigInt)(7);
+const _11n = (0, x_bigint_1.BigInt)(11);
+const _12n = (0, x_bigint_1.BigInt)(12);
+const _16n = (0, x_bigint_1.BigInt)(16);
+const _18n = (0, x_bigint_1.BigInt)(18);
+const _23n = (0, x_bigint_1.BigInt)(23);
+const _27n = (0, x_bigint_1.BigInt)(27);
+const _29n = (0, x_bigint_1.BigInt)(29);
+const _31n = (0, x_bigint_1.BigInt)(31);
+const _32n = (0, x_bigint_1.BigInt)(32);
+const _33n = (0, x_bigint_1.BigInt)(33);
+const _64n = (0, x_bigint_1.BigInt)(64);
+const _256n = (0, x_bigint_1.BigInt)(256);
+function rotl(a, b) {
+    const c = a & U64;
+    return ((c << b) | (c >> (_64n - b))) & U64;
+}
+function fromU8a(u8a, p, count) {
+    const bigints = new Array(count);
+    let offset = 0;
+    for (let i = 0; i < count; i++, offset += 2) {
+        bigints[i] = (0, x_bigint_1.BigInt)(u8a[p + offset] | (u8a[p + 1 + offset] << 8));
+    }
+    let result = util_1._0n;
+    for (let i = count - 1; i >= 0; i--) {
+        result = (result << _16n) + bigints[i];
+    }
+    return result;
+}
+function init(seed, input) {
+    const state = {
+        seed,
+        u8a: new Uint8Array(32),
+        u8asize: 0,
+        v1: seed + P64_1 + P64_2,
+        v2: seed + P64_2,
+        v3: seed,
+        v4: seed - P64_1
+    };
+    if (input.length < 32) {
+        state.u8a.set(input);
+        state.u8asize = input.length;
+        return state;
+    }
+    const limit = input.length - 32;
+    let p = 0;
+    if (limit >= 0) {
+        const adjustV = (v) => P64_1 * rotl(v + P64_2 * fromU8a(input, p, 4), _31n);
+        do {
+            state.v1 = adjustV(state.v1);
+            p += 8;
+            state.v2 = adjustV(state.v2);
+            p += 8;
+            state.v3 = adjustV(state.v3);
+            p += 8;
+            state.v4 = adjustV(state.v4);
+            p += 8;
+        } while (p <= limit);
+    }
+    if (p < input.length) {
+        state.u8a.set(input.subarray(p, input.length));
+        state.u8asize = input.length - p;
+    }
+    return state;
+}
+function xxhash64(input, initSeed) {
+    const { seed, u8a, u8asize, v1, v2, v3, v4 } = init((0, x_bigint_1.BigInt)(initSeed), input);
+    let p = 0;
+    let h64 = U64 & ((0, x_bigint_1.BigInt)(input.length) + (input.length >= 32
+        ? (((((((((rotl(v1, util_1._1n) + rotl(v2, _7n) + rotl(v3, _12n) + rotl(v4, _18n)) ^ (P64_1 * rotl(v1 * P64_2, _31n))) * P64_1 + P64_4) ^ (P64_1 * rotl(v2 * P64_2, _31n))) * P64_1 + P64_4) ^ (P64_1 * rotl(v3 * P64_2, _31n))) * P64_1 + P64_4) ^ (P64_1 * rotl(v4 * P64_2, _31n))) * P64_1 + P64_4)
+        : (seed + P64_5)));
+    while (p <= (u8asize - 8)) {
+        h64 = U64 & (P64_4 + P64_1 * rotl(h64 ^ (P64_1 * rotl(P64_2 * fromU8a(u8a, p, 4), _31n)), _27n));
+        p += 8;
+    }
+    if ((p + 4) <= u8asize) {
+        h64 = U64 & (P64_3 + P64_2 * rotl(h64 ^ (P64_1 * fromU8a(u8a, p, 2)), _23n));
+        p += 4;
+    }
+    while (p < u8asize) {
+        h64 = U64 & (P64_1 * rotl(h64 ^ (P64_5 * (0, x_bigint_1.BigInt)(u8a[p++])), _11n));
+    }
+    h64 = U64 & (P64_2 * (h64 ^ (h64 >> _33n)));
+    h64 = U64 & (P64_3 * (h64 ^ (h64 >> _29n)));
+    h64 = U64 & (h64 ^ (h64 >> _32n));
+    const result = new Uint8Array(8);
+    for (let i = 7; i >= 0; i--) {
+        result[i] = Number(h64 % _256n);
+        h64 = h64 / _256n;
+    }
+    return result;
+}

package/crypto.d.ts

@@ -0,0 +1,3 @@
+import { isReady } from '@polkadot/wasm-crypto';
+export declare const cryptoIsReady: typeof isReady;
+export declare function cryptoWaitReady(): Promise<boolean>;

package/crypto.js

@@ -0,0 +1,12 @@
+import { isReady, waitReady } from '@pezkuwi/wasm-crypto';
+export const cryptoIsReady = isReady;
+export function cryptoWaitReady() {
+    return waitReady()
+        .then(() => {
+        if (!isReady()) {
+            throw new Error('Unable to initialize @pezkuwi/util-crypto');
+        }
+        return true;
+    })
+        .catch(() => false);
+}

package/ed25519/deriveHard.d.ts

@@ -0,0 +1 @@
+export declare function ed25519DeriveHard(seed: Uint8Array, chainCode: Uint8Array): Uint8Array;

package/ed25519/deriveHard.js

@@ -0,0 +1,9 @@
+import { compactAddLength, isU8a, stringToU8a, u8aConcat } from '@pezkuwi/util';
+import { blake2AsU8a } from '../blake2/asU8a.js';
+const HDKD = compactAddLength(stringToU8a('Ed25519HDKD'));
+export function ed25519DeriveHard(seed, chainCode) {
+    if (!isU8a(chainCode) || chainCode.length !== 32) {
+        throw new Error('Invalid chainCode passed to derive');
+    }
+    return blake2AsU8a(u8aConcat(HDKD, seed, chainCode));
+}

package/ed25519/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @summary Implements ed25519 operations
+ */
+export { ed25519DeriveHard } from './deriveHard.js';
+export { ed25519PairFromRandom } from './pair/fromRandom.js';
+export { ed25519PairFromSecret } from './pair/fromSecret.js';
+export { ed25519PairFromSeed } from './pair/fromSeed.js';
+export { ed25519PairFromString } from './pair/fromString.js';
+export { ed25519Sign } from './sign.js';
+export { ed25519Verify } from './verify.js';

package/ed25519/index.js

@@ -0,0 +1,10 @@
+/**
+ * @summary Implements ed25519 operations
+ */
+export { ed25519DeriveHard } from './deriveHard.js';
+export { ed25519PairFromRandom } from './pair/fromRandom.js';
+export { ed25519PairFromSecret } from './pair/fromSecret.js';
+export { ed25519PairFromSeed } from './pair/fromSeed.js';
+export { ed25519PairFromString } from './pair/fromString.js';
+export { ed25519Sign } from './sign.js';
+export { ed25519Verify } from './verify.js';

package/ed25519/pair/fromRandom.d.ts

@@ -0,0 +1,16 @@
+import type { Keypair } from '../../types.js';
+/**
+ * @name ed25519PairFromRandom
+ * @summary Creates a new public/secret keypair.
+ * @description
+ * Returns a new generate object containing a `publicKey` & `secretKey`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519PairFromRandom } from '@polkadot/util-crypto';
+ *
+ * ed25519PairFromRandom(); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+export declare function ed25519PairFromRandom(): Keypair;

package/{src/ed25519/pair/fromRandom.ts → ed25519/pair/fromRandom.js}

@@ -1,11 +1,5 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Keypair } from '../../types.js';
-
 import { randomAsU8a } from '../../random/index.js';
 import { ed25519PairFromSeed } from './fromSeed.js';
-
 /**
  * @name ed25519PairFromRandom
  * @summary Creates a new public/secret keypair.
@@ -20,6 +14,6 @@ import { ed25519PairFromSeed } from './fromSeed.js';
  * ed25519PairFromRandom(); // => { secretKey: [...], publicKey: [...] }
  * ```
  */
-export function ed25519PairFromRandom (): Keypair {
-  return ed25519PairFromSeed(randomAsU8a());
+export function ed25519PairFromRandom() {
+    return ed25519PairFromSeed(randomAsU8a());
 }

package/ed25519/pair/fromSecret.d.ts

@@ -0,0 +1,16 @@
+import type { Keypair } from '../../types.js';
+/**
+ * @name ed25519PairFromSecret
+ * @summary Creates a new public/secret keypair from a secret.
+ * @description
+ * Returns a object containing a `publicKey` & `secretKey` generated from the supplied secret.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519PairFromSecret } from '@polkadot/util-crypto';
+ *
+ * ed25519PairFromSecret(...); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+export declare function ed25519PairFromSecret(secretKey: Uint8Array): Keypair;

package/ed25519/pair/fromSecret.js

@@ -0,0 +1,23 @@
+/**
+ * @name ed25519PairFromSecret
+ * @summary Creates a new public/secret keypair from a secret.
+ * @description
+ * Returns a object containing a `publicKey` & `secretKey` generated from the supplied secret.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519PairFromSecret } from '@pezkuwi/util-crypto';
+ *
+ * ed25519PairFromSecret(...); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+export function ed25519PairFromSecret(secretKey) {
+    if (secretKey.length !== 64) {
+        throw new Error('Invalid secretKey provided');
+    }
+    return {
+        publicKey: secretKey.slice(32),
+        secretKey
+    };
+}

package/ed25519/pair/fromSeed.d.ts

@@ -0,0 +1,16 @@
+import type { Keypair } from '../../types.js';
+/**
+ * @name ed25519PairFromSeed
+ * @summary Creates a new public/secret keypair from a seed.
+ * @description
+ * Returns a object containing a `publicKey` & `secretKey` generated from the supplied seed.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519PairFromSeed } from '@polkadot/util-crypto';
+ *
+ * ed25519PairFromSeed(...); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+export declare function ed25519PairFromSeed(seed: Uint8Array, onlyJs?: boolean): Keypair;

package/{src/ed25519/pair/fromSeed.ts → ed25519/pair/fromSeed.js}

@@ -1,13 +1,6 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Keypair } from '../../types.js';
-
 import { ed25519 } from '@noble/curves/ed25519';
-
 import { hasBigInt, u8aConcatStrict } from '@pezkuwi/util';
 import { ed25519KeypairFromSeed, isReady } from '@pezkuwi/wasm-crypto';
-
 /**
  * @name ed25519PairFromSeed
  * @summary Creates a new public/secret keypair from a seed.
@@ -22,20 +15,17 @@ import { ed25519KeypairFromSeed, isReady } from '@pezkuwi/wasm-crypto';
  * ed25519PairFromSeed(...); // => { secretKey: [...], publicKey: [...] }
  * ```
  */
-export function ed25519PairFromSeed (seed: Uint8Array, onlyJs?: boolean): Keypair {
-  if (!hasBigInt || (!onlyJs && isReady())) {
-    const full = ed25519KeypairFromSeed(seed);
-
+export function ed25519PairFromSeed(seed, onlyJs) {
+    if (!hasBigInt || (!onlyJs && isReady())) {
+        const full = ed25519KeypairFromSeed(seed);
+        return {
+            publicKey: full.slice(32),
+            secretKey: full.slice(0, 64)
+        };
+    }
+    const publicKey = ed25519.getPublicKey(seed);
     return {
-      publicKey: full.slice(32),
-      secretKey: full.slice(0, 64)
+        publicKey,
+        secretKey: u8aConcatStrict([seed, publicKey])
     };
-  }
-
-  const publicKey = ed25519.getPublicKey(seed);
-
-  return {
-    publicKey,
-    secretKey: u8aConcatStrict([seed, publicKey])
-  };
 }

package/ed25519/pair/fromString.d.ts

@@ -0,0 +1,16 @@
+import type { Keypair } from '../../types.js';
+/**
+ * @name ed25519PairFromString
+ * @summary Creates a new public/secret keypair from a string.
+ * @description
+ * Returns a object containing a `publicKey` & `secretKey` generated from the supplied string. The string is hashed and the value used as the input seed.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519PairFromString } from '@polkadot/util-crypto';
+ *
+ * ed25519PairFromString('test'); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+export declare function ed25519PairFromString(value: string): Keypair;

package/{src/ed25519/pair/fromString.ts → ed25519/pair/fromString.js}

@@ -1,13 +1,6 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Keypair } from '../../types.js';
-
 import { stringToU8a } from '@pezkuwi/util';
-
 import { blake2AsU8a } from '../../blake2/asU8a.js';
 import { ed25519PairFromSeed } from './fromSeed.js';
-
 /**
  * @name ed25519PairFromString
  * @summary Creates a new public/secret keypair from a string.
@@ -22,10 +15,6 @@ import { ed25519PairFromSeed } from './fromSeed.js';
  * ed25519PairFromString('test'); // => { secretKey: [...], publicKey: [...] }
  * ```
  */
-export function ed25519PairFromString (value: string): Keypair {
-  return ed25519PairFromSeed(
-    blake2AsU8a(
-      stringToU8a(value)
-    )
-  );
+export function ed25519PairFromString(value) {
+    return ed25519PairFromSeed(blake2AsU8a(stringToU8a(value)));
 }