Initial rebrand: @polkadot -> @pezkuwi (14 packages)

- Package namespace: @polkadot/* -> @pezkuwi/*
- Repository: polkadot-js/common -> pezkuwichain/pezkuwi-common
- Author: Pezkuwi Team <team@pezkuwichain.io>

Core packages:
- @pezkuwi/util (utilities)
- @pezkuwi/util-crypto (crypto primitives)
- @pezkuwi/keyring (account management)
- @pezkuwi/networks (chain metadata)
- @pezkuwi/hw-ledger (Ledger hardware wallet)
- @pezkuwi/x-* (10 polyfill packages)

Total: 14 packages
Upstream: polkadot-js/common v14.0.1

packages/util-crypto/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)
+  );
+}

packages/util-crypto/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';

packages/util-crypto/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);
+  });
+});

packages/util-crypto/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());
+}

packages/util-crypto/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
+    });
+  });
+});

packages/util-crypto/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
+  };
+}

packages/util-crypto/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);
+    });
+  });
+});

packages/util-crypto/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])
+  };
+}

packages/util-crypto/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])
+    });
+  });
+});

packages/util-crypto/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)
+    )
+  );
+}

packages/util-crypto/src/ed25519/sign.spec.ts

@@ -0,0 +1,40 @@
+// 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 { perfWasm } from '../test/index.js';
+import { ed25519PairFromSeed, ed25519Sign } from './index.js';
+
+const PAIR = ed25519PairFromSeed(
+  stringToU8a('12345678901234567890123456789012')
+);
+
+describe('ed25519Sign', (): void => {
+  beforeEach(async (): Promise<void> => {
+    await waitReady();
+  });
+
+  for (const onlyJs of [false, true]) {
+    describe(`onlyJs=${(onlyJs && 'true') || 'false'}`, (): void => {
+      it('returns a valid signature for the message', (): void => {
+        expect(
+          ed25519Sign(
+            new Uint8Array([0x61, 0x62, 0x63, 0x64]),
+            PAIR,
+            onlyJs
+          )
+        ).toEqual(
+          new Uint8Array([28, 58, 206, 239, 249, 70, 59, 191, 166, 40, 219, 218, 235, 170, 25, 79, 10, 94, 9, 197, 34, 126, 1, 150, 246, 68, 28, 238, 36, 26, 172, 163, 168, 90, 202, 211, 126, 246, 57, 212, 43, 24, 88, 197, 240, 113, 118, 76, 37, 81, 91, 110, 236, 50, 144, 134, 100, 223, 220, 238, 34, 185, 211, 7])
+        );
+      });
+    });
+  }
+
+  perfWasm('ed25519Sign', 250, (input, onlyJs) =>
+    ed25519Sign(input, PAIR, onlyJs)
+  );
+});

packages/util-crypto/src/ed25519/sign.ts

@@ -0,0 +1,38 @@
+// 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, u8aToU8a } from '@pezkuwi/util';
+import { ed25519Sign as wasmSign, isReady } from '@pezkuwi/wasm-crypto';
+
+/**
+ * @name ed25519Sign
+ * @summary Signs a message using the supplied secretKey
+ * @description
+ * Returns message signature of `message`, using the `secretKey`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519Sign } from '@pezkuwi/util-crypto';
+ *
+ * ed25519Sign([...], [...]); // => [...]
+ * ```
+ */
+export function ed25519Sign (message: string | Uint8Array, { publicKey, secretKey }: Partial<Keypair>, onlyJs?: boolean): Uint8Array {
+  if (!secretKey) {
+    throw new Error('Expected a valid secretKey');
+  } else if (!publicKey) {
+    throw new Error('Expected a valid publicKey');
+  }
+
+  const messageU8a = u8aToU8a(message);
+  const privateU8a = secretKey.subarray(0, 32);
+
+  return !hasBigInt || (!onlyJs && isReady())
+    ? wasmSign(publicKey, privateU8a, messageU8a)
+    : ed25519.sign(messageU8a, privateU8a);
+}

packages/util-crypto/src/ed25519/verify.spec.ts

@@ -0,0 +1,84 @@
+// 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, ed25519Verify } from './index.js';
+
+describe('ed25519Verify', (): void => {
+  let publicKey: Uint8Array;
+  let signature: Uint8Array;
+
+  beforeEach(async (): Promise<void> => {
+    await waitReady();
+
+    publicKey = ed25519PairFromSeed(
+      stringToU8a('12345678901234567890123456789012')
+    ).publicKey;
+    signature = new Uint8Array([28, 58, 206, 239, 249, 70, 59, 191, 166, 40, 219, 218, 235, 170, 25, 79, 10, 94, 9, 197, 34, 126, 1, 150, 246, 68, 28, 238, 36, 26, 172, 163, 168, 90, 202, 211, 126, 246, 57, 212, 43, 24, 88, 197, 240, 113, 118, 76, 37, 81, 91, 110, 236, 50, 144, 134, 100, 223, 220, 238, 34, 185, 211, 7]);
+  });
+
+  for (const onlyJs of [false, true]) {
+    describe(`onlyJs=${(onlyJs && 'true') || 'false'}`, (): void => {
+      it('validates a correctly signed message', (): void => {
+        expect(
+          ed25519Verify(
+            new Uint8Array([0x61, 0x62, 0x63, 0x64]),
+            signature,
+            publicKey,
+            onlyJs
+          )
+        ).toEqual(true);
+      });
+
+      it('fails a correctly signed message (message changed)', (): void => {
+        expect(
+          ed25519Verify(
+            new Uint8Array([0x61, 0x62, 0x63, 0x64, 0x65]),
+            signature,
+            publicKey,
+            onlyJs
+          )
+        ).toEqual(false);
+      });
+
+      it('fails a correctly signed message (signature changed)', (): void => {
+        signature[0] = 0xff;
+
+        expect(
+          ed25519Verify(
+            new Uint8Array([0x61, 0x62, 0x63, 0x64]),
+            signature,
+            publicKey,
+            onlyJs
+          )
+        ).toEqual(false);
+      });
+
+      it('throws error when publicKey lengths do not match', (): void => {
+        expect(
+          () => ed25519Verify(
+            new Uint8Array([0x61, 0x62, 0x63, 0x64]),
+            signature,
+            new Uint8Array([1, 2]),
+            onlyJs
+          )
+        ).toThrow(/Invalid publicKey/);
+      });
+
+      it('throws error when signature lengths do not match', (): void => {
+        expect(
+          () => ed25519Verify(
+            new Uint8Array([0x61, 0x62, 0x63, 0x64]),
+            new Uint8Array([1, 2]),
+            publicKey,
+            onlyJs
+          )
+        ).toThrow(/Invalid signature/);
+      });
+    });
+  }
+});

packages/util-crypto/src/ed25519/verify.ts

@@ -0,0 +1,41 @@
+// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ed25519 } from '@noble/curves/ed25519';
+
+import { hasBigInt, u8aToU8a } from '@pezkuwi/util';
+import { ed25519Verify as wasmVerify, isReady } from '@pezkuwi/wasm-crypto';
+
+/**
+ * @name ed25519Sign
+ * @summary Verifies the signature on the supplied message.
+ * @description
+ * Verifies the `signature` on `message` with the supplied `publicKey`. Returns `true` on sucess, `false` otherwise.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { ed25519Verify } from '@pezkuwi/util-crypto';
+ *
+ * ed25519Verify([...], [...], [...]); // => true/false
+ * ```
+ */
+export function ed25519Verify (message: string | Uint8Array, signature: string | Uint8Array, publicKey: string | Uint8Array, onlyJs?: boolean): boolean {
+  const messageU8a = u8aToU8a(message);
+  const publicKeyU8a = u8aToU8a(publicKey);
+  const signatureU8a = u8aToU8a(signature);
+
+  if (publicKeyU8a.length !== 32) {
+    throw new Error(`Invalid publicKey, received ${publicKeyU8a.length}, expected 32`);
+  } else if (signatureU8a.length !== 64) {
+    throw new Error(`Invalid signature, received ${signatureU8a.length} bytes, expected 64`);
+  }
+
+  try {
+    return !hasBigInt || (!onlyJs && isReady())
+      ? wasmVerify(signatureU8a, messageU8a, publicKeyU8a)
+      : ed25519.verify(signatureU8a, messageU8a, publicKeyU8a);
+  } catch {
+    return false;
+  }
+}