@pezkuwi/util-crypto 14.0.6 → 14.0.7

package/build-deno/blake2/index.ts

@@ -1,6 +0,0 @@
-
-/**
- * @summary Create blake2b values with specified bitlengths
- */
-
-export { blake2AsHex, blake2AsU8a } from './asU8a.ts';

package/build-deno/bn.ts

@@ -1,13 +0,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/build-deno/bundle.ts

@@ -1,29 +0,0 @@
-
-import './bundleInit.ts';
-
-export { packageInfo } from './packageInfo.ts';
-
-export * from './address/index.ts';
-export * from './base32/index.ts';
-export * from './base58/index.ts';
-export * from './base64/index.ts';
-export * from './blake2/index.ts';
-export * from './crypto.ts';
-export * from './ed25519/index.ts';
-export * from './ethereum/index.ts';
-export * from './hd/index.ts';
-export * from './hmac/index.ts';
-export * from './json/index.ts';
-export * from './keccak/index.ts';
-export * from './key/index.ts';
-export * from './mnemonic/index.ts';
-export * from './nacl/index.ts';
-export * from './networks.ts';
-export * from './pbkdf2/index.ts';
-export * from './random/index.ts';
-export * from './scrypt/index.ts';
-export * from './secp256k1/index.ts';
-export * from './sha/index.ts';
-export * from './signature/index.ts';
-export * from './sr25519/index.ts';
-export * from './xxhash/index.ts';

package/build-deno/bundleInit.ts

@@ -1,8 +0,0 @@
-
-import 'https://deno.land/x/pezkuwi/x-bigint/shim.ts';
-
-import { cryptoWaitReady } from './crypto.ts';
-
-cryptoWaitReady().catch((): void => {
-  // shouldn't happen, logged and caught inside cryptoWaitReady
-});

package/build-deno/crypto.ts

@@ -1,16 +0,0 @@
-
-import { isReady, waitReady } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
-
-export const cryptoIsReady = isReady;
-
-export function cryptoWaitReady (): Promise<boolean> {
-  return waitReady()
-    .then((): boolean => {
-      if (!isReady()) {
-        throw new Error('Unable to initialize @pezkuwi/util-crypto');
-      }
-
-      return true;
-    })
-    .catch(() => false);
-}

package/build-deno/ed25519/deriveHard.ts

@@ -1,16 +0,0 @@
-
-import { compactAddLength, isU8a, stringToU8a, u8aConcat } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { blake2AsU8a } from '../blake2/asU8a.ts';
-
-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/build-deno/ed25519/index.ts

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

package/build-deno/ed25519/pair/fromRandom.ts

@@ -1,23 +0,0 @@
-
-import type { Keypair } from '../../types.ts';
-
-import { randomAsU8a } from '../../random/index.ts';
-import { ed25519PairFromSeed } from './fromSeed.ts';
-
-/**
- * @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 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
- *
- * ed25519PairFromRandom(); // => { secretKey: [...], publicKey: [...] }
- * ```
- */
-export function ed25519PairFromRandom (): Keypair {
-  return ed25519PairFromSeed(randomAsU8a());
-}

package/build-deno/ed25519/pair/fromSecret.ts

@@ -1,27 +0,0 @@
-
-import type { Keypair } from '../../types.ts';
-
-/**
- * @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 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
- *
- * 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/build-deno/ed25519/pair/fromSeed.ts

@@ -1,39 +0,0 @@
-
-import type { Keypair } from '../../types.ts';
-
-import { ed25519 } from 'https://esm.sh/@noble/curves@1.3.0/ed25519.js';
-
-import { hasBigInt, u8aConcatStrict } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { ed25519KeypairFromSeed, isReady } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
-
-/**
- * @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 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
- *
- * 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/build-deno/ed25519/pair/fromString.ts

@@ -1,29 +0,0 @@
-
-import type { Keypair } from '../../types.ts';
-
-import { stringToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { blake2AsU8a } from '../../blake2/asU8a.ts';
-import { ed25519PairFromSeed } from './fromSeed.ts';
-
-/**
- * @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 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
- *
- * ed25519PairFromString('test'); // => { secretKey: [...], publicKey: [...] }
- * ```
- */
-export function ed25519PairFromString (value: string): Keypair {
-  return ed25519PairFromSeed(
-    blake2AsU8a(
-      stringToU8a(value)
-    )
-  );
-}

package/build-deno/ed25519/sign.ts

@@ -1,36 +0,0 @@
-
-import type { Keypair } from '../types.ts';
-
-import { ed25519 } from 'https://esm.sh/@noble/curves@1.3.0/ed25519.js';
-
-import { hasBigInt, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { ed25519Sign as wasmSign, isReady } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
-
-/**
- * @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 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
- *
- * 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);
-}

package/build-deno/ed25519/verify.ts

@@ -1,39 +0,0 @@
-
-import { ed25519 } from 'https://esm.sh/@noble/curves@1.3.0/ed25519.js';
-
-import { hasBigInt, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { ed25519Verify as wasmVerify, isReady } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
-
-/**
- * @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 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
- *
- * 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;
-  }
-}

package/build-deno/ethereum/encode.ts

@@ -1,37 +0,0 @@
-
-import type { HexString } from 'https://deno.land/x/pezkuwi/util/types.ts';
-
-import { u8aToHex, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { keccakAsU8a } from '../keccak/index.ts';
-import { secp256k1Expand } from '../secp256k1/index.ts';
-
-function getH160 (u8a: Uint8Array): Uint8Array {
-  if ([33, 65].includes(u8a.length)) {
-    u8a = keccakAsU8a(secp256k1Expand(u8a));
-  }
-
-  return u8a.slice(-20);
-}
-
-export function ethereumEncode (addressOrPublic?: string | Uint8Array): HexString {
-  if (!addressOrPublic) {
-    return '0x';
-  }
-
-  const u8aAddress = u8aToU8a(addressOrPublic);
-
-  if (![20, 32, 33, 65].includes(u8aAddress.length)) {
-    throw new Error(`Invalid address or publicKey provided, received ${u8aAddress.length} bytes input`);
-  }
-
-  const address = u8aToHex(getH160(u8aAddress), -1, false);
-  const hash = u8aToHex(keccakAsU8a(address), -1, false);
-  let result = '';
-
-  for (let i = 0; i < 40; i++) {
-    result = `${result}${parseInt(hash[i], 16) > 7 ? address[i].toUpperCase() : address[i]}`;
-  }
-
-  return `0x${result}`;
-}

package/build-deno/ethereum/index.ts

@@ -1,4 +0,0 @@
-
-export { ethereumEncode } from './encode.ts';
-export { isEthereumAddress } from './isAddress.ts';
-export { isEthereumChecksum } from './isChecksum.ts';

package/build-deno/ethereum/isAddress.ts

@@ -1,14 +0,0 @@
-
-import { isHex } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { isEthereumChecksum } from './isChecksum.ts';
-
-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/build-deno/ethereum/isChecksum.ts

@@ -1,25 +0,0 @@
-
-import { u8aToHex } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { keccakAsU8a } from '../keccak/index.ts';
-
-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/build-deno/hd/ethereum/index.ts

@@ -1,69 +0,0 @@
-import { Buffer } from 'node:buffer';
-
-
-import type { Keypair } from '../../types.ts';
-
-import { bnToU8a, stringToU8a, u8aConcat } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { BN_BE_32_OPTS } from '../../bn.ts';
-import { hmacShaAsU8a } from '../../hmac/index.ts';
-import { secp256k1PairFromSeed, secp256k1PrivateKeyTweakAdd } from '../../secp256k1/index.ts';
-import { HARDENED, hdValidatePath } from '../validatePath.ts';
-
-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/build-deno/hd/index.ts

@@ -1,4 +0,0 @@
-
-export { hdEthereum } from './ethereum/index.ts';
-export { hdLedger } from './ledger/index.ts';
-export { hdValidatePath } from './validatePath.ts';

package/build-deno/hd/ledger/derivePrivate.ts

@@ -1,31 +0,0 @@
-
-import { BN_EIGHT, bnToU8a, u8aConcat, u8aToBn } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { BN_LE_32_OPTS, BN_LE_512_OPTS, BN_LE_OPTS } from '../../bn.ts';
-import { hmacShaAsU8a } from '../../hmac/index.ts';
-
-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/build-deno/hd/ledger/index.ts

@@ -1,40 +0,0 @@
-
-import type { Keypair } from '../../types.ts';
-
-import { ed25519PairFromSeed } from '../../ed25519/index.ts';
-import { mnemonicValidate } from '../../mnemonic/index.ts';
-import { HARDENED, hdValidatePath } from '../validatePath.ts';
-import { ledgerDerivePrivate } from './derivePrivate.ts';
-import { ledgerMaster } from './master.ts';
-
-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/build-deno/hd/ledger/master.ts

@@ -1,23 +0,0 @@
-
-import { u8aConcat } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { hmacShaAsU8a } from '../../hmac/index.ts';
-import { mnemonicToSeedSync } from '../../mnemonic/bip39.ts';
-
-const ED25519_CRYPTO = 'ed25519 seed';
-
-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/build-deno/hd/validatePath.ts

@@ -1,22 +0,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/build-deno/helpers.ts

@@ -1,35 +0,0 @@
-
-import type { HexString } from 'https://deno.land/x/pezkuwi/util/types.ts';
-
-import { hasBigInt, u8aToHex, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { isReady } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
-
-export type { HexString } from 'https://deno.land/x/pezkuwi/util/types.ts';
-
-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/build-deno/hmac/index.ts

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