@pezkuwi/util-crypto 14.0.2 → 14.0.4

package/src/ethereum/isAddress.ts

@@ -1,16 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { isHex } from '@pezkuwi/util';
-
-import { isEthereumChecksum } from './isChecksum.js';
-
-export function isEthereumAddress (address?: string): boolean {
-  if (!address || address.length !== 42 || !isHex(address)) {
-    return false;
-  } else if (/^(0x)?[0-9a-f]{40}$/.test(address) || /^(0x)?[0-9A-F]{40}$/.test(address)) {
-    return true;
-  }
-
-  return isEthereumChecksum(address);
-}

package/src/ethereum/isChecksum.ts

@@ -1,27 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { u8aToHex } from '@pezkuwi/util';
-
-import { keccakAsU8a } from '../keccak/index.js';
-
-function isInvalidChar (char: string, byte: number): boolean {
-  return char !== (
-    byte > 7
-      ? char.toUpperCase()
-      : char.toLowerCase()
-  );
-}
-
-export function isEthereumChecksum (_address: string): boolean {
-  const address = _address.replace('0x', '');
-  const hash = u8aToHex(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/src/ethereum/isCheksum.spec.ts

@@ -1,30 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { isEthereumChecksum } from './index.js';
-
-const ADDRESS = '0x00a329c0648769A73afAc7F9381E08FB43dBEA72';
-
-describe('isEthereumChecksum', () => {
-  it('returns false on invalid address', () => {
-    expect(isEthereumChecksum('0x00a329c0648769')).toBe(false);
-  });
-
-  it('returns false on non-checksum address', () => {
-    expect(isEthereumChecksum('0x1234567890abcdeedcba1234567890abcdeedcba')).toBe(false);
-  });
-
-  it('returns false when fully lowercase', () => {
-    expect(isEthereumChecksum(ADDRESS.toLowerCase())).toBe(false);
-  });
-
-  it('returns false when fully uppercase', () => {
-    expect(isEthereumChecksum(ADDRESS.toUpperCase().replace('0X', '0x'))).toBe(false);
-  });
-
-  it('returns true on a checksummed address', () => {
-    expect(isEthereumChecksum(ADDRESS)).toBe(true);
-  });
-});

package/src/hd/ethereum/index.spec.ts

@@ -1,54 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { mnemonicToLegacySeed } from '@pezkuwi/util-crypto';
-
-import { hdEthereum } from './index.js';
-
-describe('hdEthereum', (): void => {
-  const PHRASE = 'seed sock milk update focus rotate barely fade car face mechanic mercy';
-  const derivationPath = 'm/44\'/60\'/0\'/0/0';
-  const PUBLIC = new Uint8Array([
-    3, 118, 64, 77, 247, 27, 4, 157,
-    236, 206, 251, 221, 230, 244, 154, 147,
-    189, 131, 249, 169, 102, 78, 3, 185,
-    153, 19, 89, 40, 24, 25, 139, 131,
-    93
-  ]);
-  const SECRET = new Uint8Array([
-    166, 162, 203, 17, 2, 206, 110, 176,
-    18, 102, 230, 144, 90, 158, 25, 232,
-    43, 180, 176, 49, 189, 149, 3, 71,
-    243, 228, 223, 104, 125, 132, 58, 228
-  ]
-  );
-  const PUBLICDERIVED = new Uint8Array([
-    3, 129, 53, 27, 27, 70, 210, 96,
-    43, 9, 146, 187, 93, 85, 49, 249,
-    193, 105, 107, 8, 18, 254, 178, 83,
-    75, 104, 132, 173, 196, 126, 46, 29,
-    139
-  ]);
-  const SECRETDERIVED = new Uint8Array([
-    7, 13, 195, 17, 115, 0, 1, 25,
-    24, 226, 107, 2, 23, 105, 69, 204,
-    21, 195, 213, 72, 207, 73, 253, 132,
-    24, 217, 127, 147, 175, 105, 158, 70
-  ]);
-
-  it('derives the right key pair from a mnemonic', (): void => {
-    const key = hdEthereum(mnemonicToLegacySeed(PHRASE, '', false, 64));
-
-    expect(key.publicKey).toEqual(PUBLIC);
-    expect(key.secretKey).toEqual(SECRET);
-  });
-
-  it('derives the right key pair from a mnemonic and a derivation path', (): void => {
-    const key = hdEthereum(mnemonicToLegacySeed(PHRASE, '', false, 64), derivationPath);
-
-    expect(key.publicKey).toEqual(PUBLICDERIVED);
-    expect(key.secretKey).toEqual(SECRETDERIVED);
-  });
-});

package/src/hd/ethereum/index.ts

@@ -1,69 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Keypair } from '../../types.js';
-
-import { bnToU8a, stringToU8a, u8aConcat } from '@pezkuwi/util';
-
-import { BN_BE_32_OPTS } from '../../bn.js';
-import { hmacShaAsU8a } from '../../hmac/index.js';
-import { secp256k1PairFromSeed, secp256k1PrivateKeyTweakAdd } from '../../secp256k1/index.js';
-import { HARDENED, hdValidatePath } from '../validatePath.js';
-
-interface CodedKeypair extends Keypair {
-  chainCode: Uint8Array;
-}
-
-const MASTER_SECRET = stringToU8a('Bitcoin seed');
-
-function createCoded (secretKey: Uint8Array, chainCode: Uint8Array): CodedKeypair {
-  return {
-    chainCode,
-    publicKey: secp256k1PairFromSeed(secretKey).publicKey,
-    secretKey
-  };
-}
-
-function deriveChild (hd: CodedKeypair, index: number): CodedKeypair {
-  const indexBuffer = bnToU8a(index, BN_BE_32_OPTS);
-  const data = index >= HARDENED
-    ? u8aConcat(new Uint8Array(1), hd.secretKey, indexBuffer)
-    : u8aConcat(hd.publicKey, indexBuffer);
-
-  try {
-    const I = hmacShaAsU8a(hd.chainCode, data, 512);
-
-    return createCoded(
-      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);
-  }
-}
-
-export function hdEthereum (seed: Uint8Array, path = ''): Keypair {
-  const I = 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 (!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("'")
-        ? HARDENED
-        : 0
-    ));
-  }
-
-  return hd;
-}

package/src/hd/ledger/derivePrivate.ts

@@ -1,34 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { BN_EIGHT, bnToU8a, u8aConcat, u8aToBn } from '@pezkuwi/util';
-
-import { BN_LE_32_OPTS, BN_LE_512_OPTS, BN_LE_OPTS } from '../../bn.js';
-import { hmacShaAsU8a } from '../../hmac/index.js';
-
-// performs hard-only derivation on the xprv
-export function ledgerDerivePrivate (xprv: Uint8Array, index: number): Uint8Array {
-  const kl = xprv.subarray(0, 32);
-  const kr = xprv.subarray(32, 64);
-  const cc = xprv.subarray(64, 96);
-  const data = u8aConcat([0], kl, kr, bnToU8a(index, BN_LE_32_OPTS));
-  const z = hmacShaAsU8a(cc, data, 512);
-
-  data[0] = 0x01;
-
-  return u8aConcat(
-    bnToU8a(
-      u8aToBn(kl, BN_LE_OPTS).iadd(
-        u8aToBn(z.subarray(0, 28), BN_LE_OPTS).imul(BN_EIGHT)
-      ),
-      BN_LE_512_OPTS
-    ).subarray(0, 32),
-    bnToU8a(
-      u8aToBn(kr, BN_LE_OPTS).iadd(
-        u8aToBn(z.subarray(32, 64), BN_LE_OPTS)
-      ),
-      BN_LE_512_OPTS
-    ).subarray(0, 32),
-    hmacShaAsU8a(cc, data, 512).subarray(32, 64)
-  );
-}

package/src/hd/ledger/index.spec.ts

@@ -1,64 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { u8aToHex } from '@pezkuwi/util';
-
-import { hdLedger } from '../index.js';
-
-const MNE_0 = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
-const MNE_1 = 'open jelly jeans corn ketchup supreme brief element armed lens vault weather original scissors rug priority vicious lesson raven spot gossip powder person volcano';
-const MNE_P = `${MNE_1} testing`;
-
-const TESTS = {
-  Kusama: {
-    slip44: 0x01b2,
-    tests: [
-      {
-        ed25519: '0x98cb4e14e0e08ea876f88d728545ea7572dc07dbbe69f1731c418fb827e69d41',
-        index: [0, 0],
-        mnemonic: MNE_0
-      },
-      {
-        ed25519: '0x70e9010e84c81095aaa5f63b1c5a6a66a1dcbec017a23c2f3b7a1b08fe5ea65a',
-        index: [0, 0],
-        mnemonic: MNE_1
-      },
-      {
-        ed25519: '0xf06730efb1e6ea59ac752a7c3620fade3909062fb88597856cc3af72045fa65a',
-        index: [5, 7],
-        mnemonic: MNE_1
-      }
-    ]
-  },
-  Polkadot: {
-    slip44: 0x0162,
-    tests: [
-      {
-        ed25519: '0xe8c68348586d53e4e8d1a864b0e4e17c75e4eb06e0c63c1432bef2ba29e69d41',
-        index: [0, 0],
-        mnemonic: MNE_0
-      },
-      {
-        ed25519: '0x3890e8db837eba3f8f25215c753e1091062298ce671a51441e7ef89a7adc4f48',
-        index: [0, 0],
-        mnemonic: MNE_P
-      }
-    ]
-  }
-};
-
-describe('ledgerDerive', (): void => {
-  Object.entries(TESTS).forEach(([network, { slip44, tests }]): void => {
-    tests.forEach(({ ed25519, index: [account, address], mnemonic }, index): void => {
-      it(`derives a known ed25519 seed for ${network} (${index})`, (): void => {
-        expect(u8aToHex(
-          hdLedger(mnemonic, `m/44'/${slip44}'/${account}'/0'/${address}'`)
-            .secretKey
-            .slice(0, 32)
-        )).toEqual(ed25519);
-      });
-    });
-  });
-});

package/src/hd/ledger/index.ts

@@ -1,42 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { Keypair } from '../../types.js';
-
-import { ed25519PairFromSeed } from '../../ed25519/index.js';
-import { mnemonicValidate } from '../../mnemonic/index.js';
-import { HARDENED, hdValidatePath } from '../validatePath.js';
-import { ledgerDerivePrivate } from './derivePrivate.js';
-import { ledgerMaster } from './master.js';
-
-export function hdLedger (_mnemonic: string, path: string): Keypair {
-  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 (!mnemonicValidate(mnemonic)) {
-    throw new Error('Invalid mnemonic passed to ledger derivation');
-  } else if (!hdValidatePath(path)) {
-    throw new Error('Invalid derivation path');
-  }
-
-  const parts = path.split('/').slice(1);
-  let seed = ledgerMaster(mnemonic, password);
-
-  for (const p of parts) {
-    const n = parseInt(p.replace(/'$/, ''), 10);
-
-    seed = ledgerDerivePrivate(seed, (n < HARDENED) ? (n + HARDENED) : n);
-  }
-
-  return ed25519PairFromSeed(seed.slice(0, 32));
-}

package/src/hd/ledger/master.spec.ts

@@ -1,19 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { u8aToHex } from '@pezkuwi/util';
-
-import { ledgerMaster } from './master.js';
-
-const MNEMONIC = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
-const XPRV = '0x402b03cd9c8bed9ba9f9bd6cd9c315ce9fcc59c7c25d37c85a36096617e69d418e35cb4a3b737afd007f0688618f21a8831643c0e6c77fc33c06026d2a0fc93832596435e70647d7d98ef102a32ea40319ca8fb6c851d7346d3bd8f9d1492658';
-
-describe('ledgerDerive', (): void => {
-  it('derives a known master xprv', (): void => {
-    expect(u8aToHex(
-      ledgerMaster(MNEMONIC)
-    )).toEqual(XPRV);
-  });
-});

package/src/hd/ledger/master.ts

@@ -1,26 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { u8aConcat } from '@pezkuwi/util';
-
-import { hmacShaAsU8a } from '../../hmac/index.js';
-import { mnemonicToSeedSync } from '../../mnemonic/bip39.js';
-
-const ED25519_CRYPTO = 'ed25519 seed';
-
-// gets an xprv from a mnemonic
-export function ledgerMaster (mnemonic: string, password?: string): Uint8Array {
-  const seed = mnemonicToSeedSync(mnemonic, password);
-  const chainCode = hmacShaAsU8a(ED25519_CRYPTO, new Uint8Array([1, ...seed]), 256);
-  let priv;
-
-  while (!priv || (priv[31] & 0b0010_0000)) {
-    priv = hmacShaAsU8a(ED25519_CRYPTO, priv || seed, 512);
-  }
-
-  priv[0] &= 0b1111_1000;
-  priv[31] &= 0b0111_1111;
-  priv[31] |= 0b0100_0000;
-
-  return u8aConcat(priv, chainCode);
-}

package/src/hd/validatePath.spec.ts

@@ -1,30 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { hdValidatePath } from './index.js';
-
-const VECTORS: [string, boolean][] = [
-  ["m/44'/60'/0'/0/0", true],
-  ['m/0', true],
-  ["m/123'", true],
-  ["n/44'/60'/0'/0/0", false],
-  ['m', false],
-  ['m/', false],
-  ["m/xyz'", false],
-  ['m/123x', false],
-  ['m/123"', false],
-  ["m/123''", false],
-  ["m/123'0'", false],
-  [`m/${0x80000000}`, false],
-  ['m/-1', false]
-];
-
-describe('hdValidatePath', (): void => {
-  VECTORS.forEach(([path, result]): void => {
-    it(`validates ${path} as ${result.toString()}`, (): void => {
-      expect(hdValidatePath(path)).toEqual(result);
-    });
-  });
-});

package/src/hd/validatePath.ts

@@ -1,24 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export const HARDENED = 0x80000000;
-
-export function hdValidatePath (path: string): boolean {
-  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 >= HARDENED) || (n < 0)) {
-      return false;
-    }
-  }
-
-  return true;
-}

package/src/helpers.ts

@@ -1,38 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { HexString } from '@pezkuwi/util/types';
-
-import { hasBigInt, u8aToHex, u8aToU8a } from '@pezkuwi/util';
-import { isReady } from '@pezkuwi/wasm-crypto';
-
-// re-export so TS *.d.ts generation is correct
-export type { HexString } from '@pezkuwi/util/types';
-
-interface DualHash {
-  256: (u8a: Uint8Array) => Uint8Array;
-  512: (u8a: Uint8Array) => Uint8Array;
-}
-
-/** @internal */
-export function createAsHex <T extends (...args: never[]) => Uint8Array> (fn: T): (...args: Parameters<T>) => HexString {
-  return (...args: Parameters<T>): HexString =>
-    u8aToHex(fn(...args));
-}
-
-/** @internal */
-export function createBitHasher (bitLength: 256 | 512, fn: (data: string | Uint8Array, bitLength: 256 | 512, onlyJs?: boolean) => Uint8Array): (data: string | Uint8Array, onlyJs?: boolean) => Uint8Array {
-  return (data: string | Uint8Array, onlyJs?: boolean): Uint8Array =>
-    fn(data, bitLength, onlyJs);
-}
-
-/** @internal */
-export function createDualHasher (wa: DualHash, js: DualHash): (value: string | Uint8Array, bitLength?: 256 | 512, onlyJs?: boolean) => Uint8Array {
-  return (value: string | Uint8Array, bitLength: 256 | 512 = 256, onlyJs?: boolean): Uint8Array => {
-    const u8a = u8aToU8a(value);
-
-    return !hasBigInt || (!onlyJs && isReady())
-      ? wa[bitLength](u8a)
-      : js[bitLength](u8a);
-  };
-}

package/src/hmac/index.ts

@@ -1,4 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-export { hmacSha256AsU8a, hmacSha512AsU8a, hmacShaAsU8a } from './shaAsU8a.js';

package/src/hmac/shaAsU8a.spec.ts

@@ -1,45 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@polkadot/dev-test/globals.d.ts" />
-
-import { hexToU8a, stringToU8a } from '@pezkuwi/util';
-import { waitReady } from '@pezkuwi/wasm-crypto';
-
-import { perfWasm } from '../test/index.js';
-import { hmacShaAsU8a } from './index.js';
-
-describe('hmacShaAsU8a', (): void => {
-  beforeEach(async (): Promise<void> => {
-    await waitReady();
-  });
-
-  const key = stringToU8a('secret');
-  const data = stringToU8a('some message');
-  const output = {
-    256: hexToU8a(
-      '0xf28a70b41263840e5c059a0a733336e0957efba87902aa8cca11441d4b0c96d7'
-    ),
-    512: hexToU8a(
-      '0x295832e97ed77be75a9fa98029497e4a722c4b9a2f21b39d34f1befa931a39ec520fd24711d6f5c03501384ea66b83066a01a82c57a0460f8cd1f471fcce5841'
-    )
-  };
-
-  for (const bitLength of [256, 512] as const) {
-    describe(`bitLength=${bitLength}`, (): void => {
-      for (const onlyJs of [false, true]) {
-        describe(`onlyJs=${(onlyJs && 'true') || 'false'}`, (): void => {
-          it('returns an hex representation (string)', (): void => {
-            expect(
-              hmacShaAsU8a(key, data, bitLength, onlyJs)
-            ).toEqual(output[bitLength]);
-          });
-        });
-      }
-    });
-
-    perfWasm(`hmacShaAsU8a, bitLength=${bitLength}`, 16000, (input, onlyJs) =>
-      hmacShaAsU8a(input, input, bitLength, onlyJs)
-    );
-  }
-});

package/src/index.ts

@@ -1,6 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import './packageDetect.js';
-
-export * from './bundle.js';

package/src/json/constants.ts

@@ -1,11 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { EncryptedJsonEncoding, EncryptedJsonVersion } from './types.js';
-
-export const ENCODING: EncryptedJsonEncoding[] = ['scrypt', 'xsalsa20-poly1305'];
-export const ENCODING_NONE: EncryptedJsonEncoding[] = ['none'];
-export const ENCODING_VERSION: EncryptedJsonVersion = '3';
-
-export const NONCE_LENGTH = 24;
-export const SCRYPT_LENGTH = 32 + (3 * 4);

package/src/json/decrypt.ts

@@ -1,25 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { EncryptedJson } from './types.js';
-
-import { hexToU8a, isHex } from '@pezkuwi/util';
-
-import { base64Decode } from '../base64/index.js';
-import { jsonDecryptData } from './decryptData.js';
-
-export function jsonDecrypt ({ encoded, encoding }: EncryptedJson, passphrase?: string | null): Uint8Array {
-  if (!encoded) {
-    throw new Error('No encrypted data available to decode');
-  }
-
-  return jsonDecryptData(
-    isHex(encoded)
-      ? hexToU8a(encoded)
-      : base64Decode(encoded),
-    passphrase,
-    Array.isArray(encoding.type)
-      ? encoding.type
-      : [encoding.type]
-  );
-}

package/src/json/decryptData.ts

@@ -1,45 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { EncryptedJsonEncoding } from './types.js';
-
-import { stringToU8a, u8aFixLength } from '@pezkuwi/util';
-
-import { naclDecrypt } from '../nacl/index.js';
-import { scryptEncode, scryptFromU8a } from '../scrypt/index.js';
-import { ENCODING, NONCE_LENGTH, SCRYPT_LENGTH } from './constants.js';
-
-export function jsonDecryptData (encrypted?: Uint8Array | null, passphrase?: string | null, encType: EncryptedJsonEncoding[] = ENCODING): Uint8Array {
-  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: Uint8Array | null = encrypted;
-
-  if (passphrase) {
-    let password: Uint8Array;
-
-    if (encType.includes('scrypt')) {
-      const { params, salt } = scryptFromU8a(encrypted);
-
-      password = scryptEncode(passphrase, salt, params).password;
-      encrypted = encrypted.subarray(SCRYPT_LENGTH);
-    } else {
-      password = stringToU8a(passphrase);
-    }
-
-    encoded = naclDecrypt(
-      encrypted.subarray(NONCE_LENGTH),
-      encrypted.subarray(0, NONCE_LENGTH),
-      u8aFixLength(password, 256, true)
-    );
-  }
-
-  if (!encoded) {
-    throw new Error('Unable to decode using the supplied passphrase');
-  }
-
-  return encoded;
-}

package/src/json/encrypt.ts

@@ -1,25 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { EncryptedJson } from './types.js';
-
-import { u8aConcat } from '@pezkuwi/util';
-
-import { naclEncrypt } from '../nacl/index.js';
-import { scryptEncode, scryptToU8a } from '../scrypt/index.js';
-import { jsonEncryptFormat } from './encryptFormat.js';
-
-export function jsonEncrypt (data: Uint8Array, contentType: string[], passphrase?: string | null): EncryptedJson {
-  let isEncrypted = false;
-  let encoded = data;
-
-  if (passphrase) {
-    const { params, password, salt } = scryptEncode(passphrase);
-    const { encrypted, nonce } = naclEncrypt(encoded, password.subarray(0, 32));
-
-    isEncrypted = true;
-    encoded = u8aConcat(scryptToU8a(salt, params), nonce, encrypted);
-  }
-
-  return jsonEncryptFormat(encoded, contentType, isEncrypted);
-}

package/src/json/encryptFormat.ts

@@ -1,20 +0,0 @@
-// Copyright 2017-2025 @polkadot/util-crypto authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { EncryptedJson } from './types.js';
-
-import { base64Encode } from '../base64/index.js';
-import { ENCODING, ENCODING_NONE, ENCODING_VERSION } from './constants.js';
-
-export function jsonEncryptFormat (encoded: Uint8Array, contentType: string[], isEncrypted: boolean): EncryptedJson {
-  return {
-    encoded: base64Encode(encoded),
-    encoding: {
-      content: contentType,
-      type: isEncrypted
-        ? ENCODING
-        : ENCODING_NONE,
-      version: ENCODING_VERSION
-    }
-  };
-}