@pezkuwi/util-crypto 14.0.1

package/src/base64/pad.spec.ts

@@ -0,0 +1,14 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@polkadot/dev-test/globals.d.ts" />
+
+import { base64Pad } from './index.js';
+
+describe('base64Pad', (): void => {
+  it('pads a utf-8 string', (): void => {
+    expect(
+      base64Pad('YWJjZA')
+    ).toEqual('YWJjZA==');
+  });
+});

package/src/base64/pad.ts

@@ -0,0 +1,10 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @name base64Pad
+ * @description Adds padding characters for correct length
+ */
+export function base64Pad (value: string): string {
+  return value.padEnd(value.length + (value.length % 4), '=');
+}

package/src/base64/trim.spec.ts

@@ -0,0 +1,14 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@polkadot/dev-test/globals.d.ts" />
+
+import { base64Trim } from './index.js';
+
+describe('base64Trim', (): void => {
+  it('trims a utf-8 string', (): void => {
+    expect(
+      base64Trim('aGVsbG8gd29ybGQg0J/RgNC40LLQtdGC0YHRgtCy0YPRjiDQvNC4IOS9oOWlvQ==')
+    ).toEqual('aGVsbG8gd29ybGQg0J/RgNC40LLQtdGC0YHRgtCy0YPRjiDQvNC4IOS9oOWlvQ');
+  });
+});

package/src/base64/trim.ts

@@ -0,0 +1,14 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @name base64Trim
+ * @description Trims padding characters
+ */
+export function base64Trim (value: string): string {
+  while (value.length && value.endsWith('=')) {
+    value = value.slice(0, -1);
+  }
+
+  return value;
+}

package/src/base64/validate.spec.ts

@@ -0,0 +1,32 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@polkadot/dev-test/globals.d.ts" />
+
+import { base64Validate } from './index.js';
+
+describe('base64Validate', (): void => {
+  it('validates a mixed base64 utf8 string', (): void => {
+    expect(
+      () => base64Validate('aGVsbG8gd29ybGQg0J/RgNC40LLQtd^GC0YHRgtCy0YPRjiDQvNC4IOS9oOWlvQ==')
+    ).toThrow(/Invalid base64 character "\^" \(0x5e\) at index 30/);
+  });
+
+  it('validates with one extra padding character', (): void => {
+    expect(
+      base64Validate('bGlnaHQgd28=')
+    ).toEqual(true);
+  });
+
+  it('validates with two extra padding characters', (): void => {
+    expect(
+      base64Validate('bGlnaHQgdw==')
+    ).toEqual(true);
+  });
+
+  it('validates misplaced padding characters', (): void => {
+    expect(
+      () => base64Validate('bGlnaHQgdw=g=')
+    ).toThrow(/Invalid base64 padding sequence "=g"/);
+  });
+});

package/src/blake2/asHex.spec.ts

@@ -0,0 +1,57 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@polkadot/dev-test/globals.d.ts" />
+
+import { hexToU8a } from '@pezkuwi/util';
+import { waitReady } from '@pezkuwi/wasm-crypto';
+
+import { blake2AsHex } from './index.js';
+
+describe('blake2AsHex', (): void => {
+  beforeEach(async (): Promise<void> => {
+    await waitReady();
+  });
+
+  for (const onlyJs of [false, true]) {
+    describe(`onlyJs=${(onlyJs && 'true') || 'false'}`, (): void => {
+      it('returns a 64-bit value (specified)', (): void => {
+        expect(
+          blake2AsHex('abc', 64, null, onlyJs)
+        ).toEqual('0xd8bb14d833d59559');
+      });
+
+      it('returns a 128-bit value (as specified)', (): void => {
+        expect(
+          blake2AsHex('abc', 128, null, onlyJs)
+        ).toEqual('0xcf4ab791c62b8d2b2109c90275287816');
+      });
+
+      it('returns a 128-bit value (as specified, with key)', (): void => {
+        expect(
+          blake2AsHex('abc', 128, new Uint8Array([1, 2]), onlyJs)
+        ).toEqual('0x36f3d08cda72a00ddf2be103eb5770d9');
+      });
+
+      it('returns a 256-bit value (default)', (): void => {
+        expect(
+          blake2AsHex('abc', undefined, null, onlyJs)
+        ).toEqual('0xbddd813c634239723171ef3fee98579b94964e3bb1cb3e427262c8c068d52319');
+      });
+
+      it('returns a 512-bit value (as specified)', (): void => {
+        expect(
+          blake2AsHex('abc', 512, null, onlyJs)
+        ).toEqual('0xba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923');
+      });
+
+      it('matches with the Rust implementation', (): void => {
+        expect(
+          blake2AsHex(
+            hexToU8a('0x454545454545454545454545454545454545454545454545454545454545454501000000000000002481853da20b9f4322f34650fea5f240dcbfb266d02db94bfa0153c31f4a29dbdbf025dd4a69a6f4ee6e1577b251b655097e298b692cb34c18d3182cac3de0dc00000000'), 256, undefined, onlyJs
+          )
+        ).toEqual('0x1025e5db74fdaf4d2818822dccf0e1604ae9ccc62f26cecfde23448ff0248abf');
+      });
+    });
+  }
+});

package/src/blake2/asU8a.spec.ts

@@ -0,0 +1,74 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@polkadot/dev-test/globals.d.ts" />
+
+import { hexToU8a } from '@pezkuwi/util';
+import { waitReady } from '@pezkuwi/wasm-crypto';
+
+import { perfWasm } from '../test/index.js';
+import { blake2AsU8a } from './index.js';
+
+describe('blake2AsU8a', (): void => {
+  beforeEach(async (): Promise<void> => {
+    await waitReady();
+  });
+
+  for (const onlyJs of [false, true]) {
+    describe(`onlyJs=${(onlyJs && 'true') || 'false'}`, (): void => {
+      it('returns a 64-bit value by default', (): void => {
+        expect(
+          blake2AsU8a('abc', undefined, undefined, onlyJs)
+        ).toEqual(
+          new Uint8Array([189, 221, 129, 60, 99, 66, 57, 114, 49, 113, 239, 63, 238, 152, 87, 155, 148, 150, 78, 59, 177, 203, 62, 66, 114, 98, 200, 192, 104, 213, 35, 25])
+        );
+      });
+
+      it('returns a 128-bit value (as specified,)', (): void => {
+        expect(
+          blake2AsU8a('abc', 128, undefined, onlyJs)
+        ).toEqual(
+          new Uint8Array([207, 74, 183, 145, 198, 43, 141, 43, 33, 9, 201, 2, 117, 40, 120, 22])
+        );
+      });
+
+      it('returns a 256-bit value (as specified)', (): void => {
+        expect(
+          blake2AsU8a('abc', 256, undefined, onlyJs)
+        ).toEqual(
+          new Uint8Array([189, 221, 129, 60, 99, 66, 57, 114, 49, 113, 239, 63, 238, 152, 87, 155, 148, 150, 78, 59, 177, 203, 62, 66, 114, 98, 200, 192, 104, 213, 35, 25])
+        );
+      });
+
+      it('returns a 512-bit value (as specified)', (): void => {
+        expect(
+          blake2AsU8a('abc', 512, undefined, onlyJs)
+        ).toEqual(
+          hexToU8a('0xba80a53f981c4d0d6a2797b69f12f6e94c212f14685ac4b74b12bb6fdbffa2d17d87c5392aab792dc252d5de4533cc9518d38aa8dbf1925ab92386edd4009923')
+        );
+      });
+    });
+  }
+
+  it('has equivalent Wasm/Js outputs on hex inputs', (): void => {
+    const a = blake2AsU8a('0x123456', 256, null, false);
+    const b = blake2AsU8a('0x123456', 256, null, true);
+
+    expect(a).toEqual(b);
+  });
+
+  it('has equivalent Wasm/Js outputs with key inputs', (): void => {
+    const a = blake2AsU8a('0x123456', 256, new Uint8Array([1, 2]), false);
+    const b = blake2AsU8a('0x123456', 256, new Uint8Array([1, 2]), true);
+
+    expect(a).toEqual(b);
+  });
+
+  for (const bitLength of [256, 512] as const) {
+    describe(`bitLength=${bitLength}`, (): void => {
+      perfWasm(`blake2AsU8a, bitLength=${bitLength}`, 64000, (input, onlyJs) =>
+        blake2AsU8a(input, bitLength, null, onlyJs)
+      );
+    });
+  }
+});

package/src/blake2/asU8a.ts

@@ -0,0 +1,40 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { blake2b as blake2bJs } from '@noble/hashes/blake2b';
+
+import { hasBigInt, u8aToU8a } from '@pezkuwi/util';
+import { blake2b, isReady } from '@pezkuwi/wasm-crypto';
+
+import { createAsHex } from '../helpers.js';
+
+/**
+ * @name blake2AsU8a
+ * @summary Creates a blake2b u8a from the input.
+ * @description
+ * From a `Uint8Array` input, create the blake2b and return the result as a u8a with the specified `bitLength`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { blake2AsU8a } from '@pezkuwi/util-crypto';
+ *
+ * blake2AsU8a('abc'); // => [0xba, 0x80, 0xa5, 0x3f, 0x98, 0x1c, 0x4d, 0x0d]
+ * ```
+ */
+export function blake2AsU8a (data: string | Uint8Array, bitLength: 64 | 128 | 256 | 384 | 512 = 256, key?: Uint8Array | null, onlyJs?: boolean): Uint8Array {
+  const byteLength = Math.ceil(bitLength / 8);
+  const u8a = u8aToU8a(data);
+
+  return !hasBigInt || (!onlyJs && isReady())
+    ? blake2b(u8a, u8aToU8a(key), byteLength)
+    : key
+      ? blake2bJs(u8a, { dkLen: byteLength, key })
+      : blake2bJs(u8a, { dkLen: byteLength });
+}
+
+/**
+ * @name blake2AsHex
+ * @description Creates a blake2b hex from the input.
+ */
+export const blake2AsHex = /*#__PURE__*/ createAsHex(blake2AsU8a);

package/src/blake2/index.ts

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

package/src/bn.ts

@@ -0,0 +1,15 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export const BN_BE_OPTS = { isLe: false };
+export const BN_LE_OPTS = { isLe: true };
+
+export const BN_LE_16_OPTS = { bitLength: 16, isLe: true };
+
+export const BN_BE_32_OPTS = { bitLength: 32, isLe: false };
+export const BN_LE_32_OPTS = { bitLength: 32, isLe: true };
+
+export const BN_BE_256_OPTS = { bitLength: 256, isLe: false };
+export const BN_LE_256_OPTS = { bitLength: 256, isLe: true };
+
+export const BN_LE_512_OPTS = { bitLength: 512, isLe: true };

package/src/bundle.ts

@@ -0,0 +1,33 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import './bundleInit.js';
+
+// all named
+export { packageInfo } from './packageInfo.js';
+
+// all starred
+export * from './address/index.js';
+export * from './base32/index.js';
+export * from './base58/index.js';
+export * from './base64/index.js';
+export * from './blake2/index.js';
+export * from './crypto.js';
+export * from './ed25519/index.js';
+export * from './ethereum/index.js';
+export * from './hd/index.js';
+export * from './hmac/index.js';
+export * from './json/index.js';
+export * from './keccak/index.js';
+export * from './key/index.js';
+export * from './mnemonic/index.js';
+export * from './nacl/index.js';
+export * from './networks.js';
+export * from './pbkdf2/index.js';
+export * from './random/index.js';
+export * from './scrypt/index.js';
+export * from './secp256k1/index.js';
+export * from './sha/index.js';
+export * from './signature/index.js';
+export * from './sr25519/index.js';
+export * from './xxhash/index.js';

package/src/bundleInit.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import '@polkadot/x-bigint/shim';
+
+import { cryptoWaitReady } from './crypto.js';
+
+// start init process immediately
+cryptoWaitReady().catch((): void => {
+  // shouldn't happen, logged and caught inside cryptoWaitReady
+});

package/src/crypto.spec.ts

@@ -0,0 +1,18 @@
+// Copyright 2017-2025 @polkadot/util authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@polkadot/dev-test/globals.d.ts" />
+
+describe('cryptoWaitReady', (): void => {
+  it('should return false when it cannot initialize', async (): Promise<void> => {
+    const old = global.WebAssembly;
+
+    global.WebAssembly = null as unknown as typeof WebAssembly;
+
+    const { cryptoWaitReady } = await import('./crypto.js');
+
+    expect(await cryptoWaitReady()).toBe(false);
+
+    global.WebAssembly = old;
+  });
+});

package/src/crypto.ts

@@ -0,0 +1,18 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { isReady, waitReady } from '@pezkuwi/wasm-crypto';
+
+export const cryptoIsReady = isReady;
+
+export function cryptoWaitReady (): Promise<boolean> {
+  return waitReady()
+    .then((): boolean => {
+      if (!isReady()) {
+        throw new Error('Unable to initialize @polkadot/util-crypto');
+      }
+
+      return true;
+    })
+    .catch(() => false);
+}

package/src/ed25519/deriveHard.ts

@@ -0,0 +1,18 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { compactAddLength, isU8a, stringToU8a, u8aConcat } from '@pezkuwi/util';
+
+import { blake2AsU8a } from '../blake2/asU8a.js';
+
+const HDKD = compactAddLength(stringToU8a('Ed25519HDKD'));
+
+export function ed25519DeriveHard (seed: Uint8Array, chainCode: Uint8Array): Uint8Array {
+  if (!isU8a(chainCode) || chainCode.length !== 32) {
+    throw new Error('Invalid chainCode passed to derive');
+  }
+
+  return blake2AsU8a(
+    u8aConcat(HDKD, seed, chainCode)
+  );
+}

package/src/ed25519/index.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @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/src/ed25519/pair/fromRandom.spec.ts

@@ -0,0 +1,28 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@polkadot/dev-test/globals.d.ts" />
+
+import type { Keypair } from '../../types.js';
+
+import { ed25519PairFromRandom } from '../index.js';
+
+describe('ed25519PairFromRandom', (): void => {
+  let keypair: Keypair;
+
+  beforeEach((): void => {
+    keypair = ed25519PairFromRandom();
+  });
+
+  it('generates a valid publicKey', (): void => {
+    expect(
+      keypair.publicKey
+    ).toHaveLength(32);
+  });
+
+  it('generates a valid secretKey', (): void => {
+    expect(
+      keypair.secretKey
+    ).toHaveLength(64);
+  });
+});

package/src/ed25519/pair/fromRandom.ts

@@ -0,0 +1,25 @@
+// 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.
+ * @description
+ * Returns a new generate object containing a `publicKey` & `secretKey`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519PairFromRandom } from '@pezkuwi/util-crypto';
+ *
+ * ed25519PairFromRandom(); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+export function ed25519PairFromRandom (): Keypair {
+  return ed25519PairFromSeed(randomAsU8a());
+}

package/src/ed25519/pair/fromSecret.spec.ts

@@ -0,0 +1,33 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@polkadot/dev-test/globals.d.ts" />
+
+import { ed25519PairFromSecret } from '../index.js';
+
+describe('ed25519PairFromSecret', (): void => {
+  const secretKey = new Uint8Array([
+    18, 52, 86, 120, 144, 18, 52, 86,
+    120, 144, 18, 52, 86, 120, 144, 18,
+    18, 52, 86, 120, 144, 18, 52, 86,
+    120, 144, 18, 52, 86, 120, 144, 18,
+    180, 114, 93, 155, 165, 255, 217, 82,
+    16, 250, 209, 11, 193, 10, 88, 218,
+    190, 190, 41, 193, 236, 252, 1, 152,
+    216, 214, 0, 41, 45, 138, 13, 53
+  ]);
+
+  it('generates a valid publicKey/secretKey pair', (): void => {
+    expect(
+      ed25519PairFromSecret(secretKey)
+    ).toEqual({
+      publicKey: new Uint8Array([
+        180, 114, 93, 155, 165, 255, 217, 82,
+        16, 250, 209, 11, 193, 10, 88, 218,
+        190, 190, 41, 193, 236, 252, 1, 152,
+        216, 214, 0, 41, 45, 138, 13, 53
+      ]),
+      secretKey
+    });
+  });
+});

package/src/ed25519/pair/fromSecret.ts

@@ -0,0 +1,29 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+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 '@pezkuwi/util-crypto';
+ *
+ * ed25519PairFromSecret(...); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+export function ed25519PairFromSecret (secretKey: Uint8Array): Keypair {
+  if (secretKey.length !== 64) {
+    throw new Error('Invalid secretKey provided');
+  }
+
+  return {
+    publicKey: secretKey.slice(32),
+    secretKey
+  };
+}

package/src/ed25519/pair/fromSeed.spec.ts

@@ -0,0 +1,42 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@polkadot/dev-test/globals.d.ts" />
+
+import { stringToU8a } from '@pezkuwi/util';
+import { waitReady } from '@pezkuwi/wasm-crypto';
+
+import { ed25519PairFromSeed } from '../index.js';
+
+describe('ed25519PairFromSeed', (): void => {
+  // NOTE: Aligned with Rust test, b"12345678901234567890123456789012"
+  const TEST = stringToU8a('12345678901234567890123456789012');
+  const RESULT = {
+    publicKey: new Uint8Array([
+      0x2f, 0x8c, 0x61, 0x29, 0xd8, 0x16, 0xcf, 0x51,
+      0xc3, 0x74, 0xbc, 0x7f, 0x08, 0xc3, 0xe6, 0x3e,
+      0xd1, 0x56, 0xcf, 0x78, 0xae, 0xfb, 0x4a, 0x65,
+      0x50, 0xd9, 0x7b, 0x87, 0x99, 0x79, 0x77, 0xee
+    ]),
+    secretKey: new Uint8Array([
+      49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50,
+      // public part
+      0x2f, 0x8c, 0x61, 0x29, 0xd8, 0x16, 0xcf, 0x51,
+      0xc3, 0x74, 0xbc, 0x7f, 0x08, 0xc3, 0xe6, 0x3e,
+      0xd1, 0x56, 0xcf, 0x78, 0xae, 0xfb, 0x4a, 0x65,
+      0x50, 0xd9, 0x7b, 0x87, 0x99, 0x79, 0x77, 0xee
+    ])
+  };
+
+  beforeEach(async (): Promise<void> => {
+    await waitReady();
+  });
+
+  it('generates a valid publicKey/secretKey pair (u8a)', (): void => {
+    [true, false].forEach((onlyJs): void => {
+      expect(
+        ed25519PairFromSeed(TEST, onlyJs)
+      ).toEqual(RESULT);
+    });
+  });
+});

package/src/ed25519/pair/fromSeed.ts

@@ -0,0 +1,41 @@
+// 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.
+ * @description
+ * Returns a object containing a `publicKey` & `secretKey` generated from the supplied seed.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519PairFromSeed } from '@pezkuwi/util-crypto';
+ *
+ * ed25519PairFromSeed(...); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+export function ed25519PairFromSeed (seed: Uint8Array, onlyJs?: boolean): Keypair {
+  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,
+    secretKey: u8aConcatStrict([seed, publicKey])
+  };
+}

package/src/ed25519/pair/fromString.spec.ts

@@ -0,0 +1,17 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@polkadot/dev-test/globals.d.ts" />
+
+import { ed25519PairFromString } from '../index.js';
+
+describe('ed25519PairFromSeed', (): void => {
+  it('generates a valid publicKey/secretKey pair', (): void => {
+    expect(
+      ed25519PairFromString('test')
+    ).toEqual({
+      publicKey: new Uint8Array([188, 108, 179, 142, 36, 142, 76, 87, 77, 193, 147, 139, 254, 110, 196, 217, 117, 233, 167, 165, 250, 150, 247, 237, 198, 68, 129, 4, 211, 209, 136, 48]),
+      secretKey: new Uint8Array([146, 139, 32, 54, 105, 67, 226, 175, 209, 30, 188, 14, 174, 46, 83, 169, 59, 241, 119, 164, 252, 243, 91, 204, 100, 213, 3, 112, 78, 101, 226, 2, 188, 108, 179, 142, 36, 142, 76, 87, 77, 193, 147, 139, 254, 110, 196, 217, 117, 233, 167, 165, 250, 150, 247, 237, 198, 68, 129, 4, 211, 209, 136, 48])
+    });
+  });
+});

package/src/ed25519/pair/fromString.ts

@@ -0,0 +1,31 @@
+// 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.
+ * @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 '@pezkuwi/util-crypto';
+ *
+ * ed25519PairFromString('test'); // => { secretKey: [...], publicKey: [...] }
+ * ```
+ */
+export function ed25519PairFromString (value: string): Keypair {
+  return ed25519PairFromSeed(
+    blake2AsU8a(
+      stringToU8a(value)
+    )
+  );
+}