@pezkuwi/util-crypto 14.0.13 → 14.0.15

package/build-deno/address/decode.ts

@@ -1,38 +0,0 @@
-
-import type { Prefix } from './types.ts';
-
-import { isHex, isU8a, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { base58Decode } from '../base58/index.ts';
-import { checkAddressChecksum } from './checksum.ts';
-import { defaults } from './defaults.ts';
-
-export function decodeAddress (encoded?: string | Uint8Array | null, ignoreChecksum?: boolean, ss58Format: Prefix = -1): Uint8Array {
-  if (!encoded) {
-    throw new Error('Invalid empty address passed');
-  }
-
-  if (isU8a(encoded) || isHex(encoded)) {
-    return u8aToU8a(encoded);
-  }
-
-  try {
-    const decoded = base58Decode(encoded);
-
-    if (!defaults.allowedEncodedLengths.includes(decoded.length)) {
-      throw new Error('Invalid decoded address length');
-    }
-
-    const [isValid, endPos, ss58Length, ss58Decoded] = checkAddressChecksum(decoded);
-
-    if (!isValid && !ignoreChecksum) {
-      throw new Error('Invalid decoded address checksum');
-    } else if (ss58Format !== -1 && ss58Format !== ss58Decoded) {
-      throw new Error(`Expected ss58Format ${ss58Format}, received ${ss58Decoded}`);
-    }
-
-    return decoded.slice(ss58Length, endPos);
-  } catch (error) {
-    throw new Error(`Decoding ${encoded}: ${(error as Error).message}`);
-  }
-}

package/build-deno/address/defaults.ts

@@ -1,10 +0,0 @@
-
-import { availableNetworks } from '../networks.ts';
-
-export const defaults = {
-  allowedDecodedLengths: [1, 2, 4, 8, 32, 33],
-  // publicKey has prefix + 2 checksum bytes, short only prefix + 1 checksum byte
-  allowedEncodedLengths: [3, 4, 6, 10, 35, 36, 37, 38],
-  allowedPrefix: availableNetworks.map(({ prefix }) => prefix),
-  prefix: 42
-};

package/build-deno/address/derive.ts

@@ -1,34 +0,0 @@
-
-import type { DeriveJunction } from '../key/DeriveJunction.ts';
-import type { Prefix } from './types.ts';
-
-import { keyExtractPath } from '../key/index.ts';
-import { sr25519DerivePublic } from '../sr25519/index.ts';
-import { decodeAddress } from './decode.ts';
-import { encodeAddress } from './encode.ts';
-
-function filterHard ({ isHard }: DeriveJunction): boolean {
-  return isHard;
-}
-
-/**
- * @name deriveAddress
- * @summary Creates a sr25519 derived address from the supplied and path.
- * @description
- * Creates a sr25519 derived address based on the input address/publicKey and the uri supplied.
- */
-export function deriveAddress (who: string | Uint8Array, suri: string, ss58Format?: Prefix): string {
-  const { path } = keyExtractPath(suri);
-
-  if (!path.length || path.every(filterHard)) {
-    throw new Error('Expected suri to contain a combination of non-hard paths');
-  }
-
-  let publicKey = decodeAddress(who);
-
-  for (const { chainCode } of path) {
-    publicKey = sr25519DerivePublic(publicKey, chainCode);
-  }
-
-  return encodeAddress(publicKey, ss58Format);
-}

package/build-deno/address/encode.ts

@@ -1,39 +0,0 @@
-
-import type { Prefix } from './types.ts';
-
-import { u8aConcat } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { base58Encode } from '../base58/index.ts';
-import { decodeAddress } from './decode.ts';
-import { defaults } from './defaults.ts';
-import { sshash } from './sshash.ts';
-
-export function encodeAddress (key: string | Uint8Array, ss58Format: Prefix = defaults.prefix): string {
-  // decode it, this means we can re-encode an address
-  const u8a = decodeAddress(key);
-
-  if ((ss58Format < 0) || (ss58Format > 16383 && !ss58Exceptions.includes(ss58Format)) || [46, 47].includes(ss58Format)) {
-    throw new Error('Out of range ss58Format specified');
-  } else if (!defaults.allowedDecodedLengths.includes(u8a.length)) {
-    throw new Error(`Expected a valid key to convert, with length ${defaults.allowedDecodedLengths.join(', ')}`);
-  }
-
-  const input = u8aConcat(
-    ss58Format < 64
-      ? [ss58Format]
-      : [
-        ((ss58Format & 0b0000_0000_1111_1100) >> 2) | 0b0100_0000,
-        (ss58Format >> 8) | ((ss58Format & 0b0000_0000_0000_0011) << 6)
-      ],
-    u8a
-  );
-
-  return base58Encode(
-    u8aConcat(
-      input,
-      sshash(input).subarray(0, [32, 33].includes(u8a.length) ? 2 : 1)
-    )
-  );
-}
-
-const ss58Exceptions = [29972];

package/build-deno/address/encodeDerived.ts

@@ -1,17 +0,0 @@
-
-import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import type { Prefix } from './types.ts';
-
-import { decodeAddress } from './decode.ts';
-import { encodeAddress } from './encode.ts';
-import { createKeyDerived } from './keyDerived.ts';
-
-/**
- * @name encodeDerivedAddress
- * @summary Creates a derived address as used in Substrate utility.
- * @description
- * Creates a Substrate derived address based on the input address/publicKey and the index supplied.
- */
-export function encodeDerivedAddress (who: string | Uint8Array, index: bigint | BN | number, ss58Format?: Prefix): string {
-  return encodeAddress(createKeyDerived(decodeAddress(who), index), ss58Format);
-}

package/build-deno/address/encodeMulti.ts

@@ -1,16 +0,0 @@
-
-import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import type { Prefix } from './types.ts';
-
-import { encodeAddress } from './encode.ts';
-import { createKeyMulti } from './keyMulti.ts';
-
-/**
- * @name encodeMultiAddress
- * @summary Creates a multisig address.
- * @description
- * Creates a Substrate multisig address based on the input address and the required threshold.
- */
-export function encodeMultiAddress (who: (string | Uint8Array)[], threshold: bigint | BN | number, ss58Format?: Prefix): string {
-  return encodeAddress(createKeyMulti(who, threshold), ss58Format);
-}

package/build-deno/address/eq.ts

@@ -1,22 +0,0 @@
-
-import { u8aEq } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { decodeAddress } from './decode.ts';
-
-/**
- * @name addressEq
- * @summary Compares two addresses, either in ss58, Uint8Array or hex format.
- * @description
- * For the input values, return true is the underlying public keys do match.
- * @example
- * <BR>
- *
- * ```javascript
- * import { u8aEq } from 'https://deno.land/x/pezkuwi/util/mod.ts';
- *
- * u8aEq(new Uint8Array([0x68, 0x65]), new Uint8Array([0x68, 0x65])); // true
- * ```
- */
-export function addressEq (a: string | Uint8Array, b: string | Uint8Array): boolean {
-  return u8aEq(decodeAddress(a), decodeAddress(b));
-}

package/build-deno/address/evmToAddress.ts

@@ -1,22 +0,0 @@
-
-import type { HashType } from '../secp256k1/types.ts';
-import type { Prefix } from './types.ts';
-
-import { u8aConcat } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { hasher } from '../secp256k1/hasher.ts';
-import { encodeAddress } from './encode.ts';
-
-/**
- * @name evmToAddress
- * @summary Converts an EVM address to its corresponding SS58 address.
- */
-export function evmToAddress (evmAddress: string | Uint8Array, ss58Format?: Prefix, hashType: HashType = 'blake2'): string {
-  const message = u8aConcat('evm:', evmAddress);
-
-  if (message.length !== 24) {
-    throw new Error(`Converting ${evmAddress as string}: Invalid evm address length`);
-  }
-
-  return encodeAddress(hasher(hashType, message), ss58Format);
-}

package/build-deno/address/index.ts

@@ -1,18 +0,0 @@
-
-export { addressToEvm } from './addressToEvm.ts';
-export { checkAddress } from './check.ts';
-export { checkAddressChecksum } from './checksum.ts';
-export { decodeAddress } from './decode.ts';
-export { deriveAddress } from './derive.ts';
-export { encodeAddress } from './encode.ts';
-export { encodeDerivedAddress } from './encodeDerived.ts';
-export { encodeMultiAddress } from './encodeMulti.ts';
-export { addressEq } from './eq.ts';
-export { evmToAddress } from './evmToAddress.ts';
-export { isAddress } from './is.ts';
-export { createKeyDerived } from './keyDerived.ts';
-export { createKeyMulti } from './keyMulti.ts';
-export { sortAddresses } from './sort.ts';
-export { validateAddress } from './validate.ts';
-
-export { setSS58Format } from './setSS58Format.ts';

package/build-deno/address/is.ts

@@ -1,12 +0,0 @@
-
-import type { Prefix } from './types.ts';
-
-import { validateAddress } from './validate.ts';
-
-export function isAddress (address?: string | null, ignoreChecksum?: boolean, ss58Format?: Prefix): address is string {
-  try {
-    return validateAddress(address, ignoreChecksum, ss58Format);
-  } catch {
-    return false;
-  }
-}

package/build-deno/address/keyDerived.ts

@@ -1,20 +0,0 @@
-
-import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { bnToU8a, stringToU8a, u8aConcat } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { blake2AsU8a } from '../blake2/asU8a.ts';
-import { BN_LE_16_OPTS } from '../bn.ts';
-import { decodeAddress } from './decode.ts';
-
-const PREFIX = stringToU8a('modlpy/utilisuba');
-
-export function createKeyDerived (who: string | Uint8Array, index: bigint | BN | number): Uint8Array {
-  return blake2AsU8a(
-    u8aConcat(
-      PREFIX,
-      decodeAddress(who),
-      bnToU8a(index, BN_LE_16_OPTS)
-    )
-  );
-}

package/build-deno/address/keyMulti.ts

@@ -1,21 +0,0 @@
-
-import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { bnToU8a, compactToU8a, stringToU8a, u8aConcat, u8aSorted } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { blake2AsU8a } from '../blake2/asU8a.ts';
-import { BN_LE_16_OPTS } from '../bn.ts';
-import { addressToU8a } from './util.ts';
-
-const PREFIX = stringToU8a('modlpy/utilisuba');
-
-export function createKeyMulti (who: (string | Uint8Array)[], threshold: bigint | BN | number): Uint8Array {
-  return blake2AsU8a(
-    u8aConcat(
-      PREFIX,
-      compactToU8a(who.length),
-      ...u8aSorted(who.map(addressToU8a)),
-      bnToU8a(threshold, BN_LE_16_OPTS)
-    )
-  );
-}

package/build-deno/address/setSS58Format.ts

@@ -1,18 +0,0 @@
-
-import type { Prefix } from './types.ts';
-
-import { logger } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { defaults } from './defaults.ts';
-
-const l = logger('setSS58Format');
-
-/**
- * @description Sets the global SS58 format to use for address encoding
- * @deprecated Use keyring.setSS58Format
- */
-export function setSS58Format (prefix: Prefix): void {
-  l.warn('Global setting of the ss58Format is deprecated and not recommended. Set format on the keyring (if used) or as part of the address encode function');
-
-  defaults.prefix = prefix;
-}

package/build-deno/address/sort.ts

@@ -1,15 +0,0 @@
-
-import type { Prefix } from './types.ts';
-
-import { u8aSorted } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { encodeAddress } from './encode.ts';
-import { addressToU8a } from './util.ts';
-
-export function sortAddresses (addresses: (string | Uint8Array)[], ss58Format?: Prefix): string[] {
-  const u8aToAddress = (u8a: Uint8Array) => encodeAddress(u8a, ss58Format);
-
-  return u8aSorted(
-    addresses.map(addressToU8a)
-  ).map(u8aToAddress);
-}

package/build-deno/address/sshash.ts

@@ -1,10 +0,0 @@
-
-import { stringToU8a, u8aConcat } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { blake2AsU8a } from '../blake2/asU8a.ts';
-
-const SS58_PREFIX = stringToU8a('SS58PRE');
-
-export function sshash (key: Uint8Array): Uint8Array {
-  return blake2AsU8a(u8aConcat(SS58_PREFIX, key), 512);
-}

package/build-deno/address/types.ts

@@ -1,2 +0,0 @@
-
-export type Prefix = number;

package/build-deno/address/util.ts

@@ -1,6 +0,0 @@
-
-import { decodeAddress } from './decode.ts';
-
-export function addressToU8a (who: string | Uint8Array): Uint8Array {
-  return decodeAddress(who);
-}

package/build-deno/address/validate.ts

@@ -1,8 +0,0 @@
-
-import type { Prefix } from './types.ts';
-
-import { decodeAddress } from './decode.ts';
-
-export function validateAddress (encoded?: string | null, ignoreChecksum?: boolean, ss58Format?: Prefix): encoded is string {
-  return !!decodeAddress(encoded, ignoreChecksum, ss58Format);
-}

package/build-deno/base32/bs32.ts

@@ -1,51 +0,0 @@
-
-import { utils } from 'https://esm.sh/@scure/base@1.1.7';
-
-import { createDecode, createEncode, createIs, createValidate } from './helpers.ts';
-
-const chars = 'abcdefghijklmnopqrstuvwxyz234567';
-
-const config = {
-  chars,
-  coder: utils.chain(
-    // We define our own chain, the default base32 has padding
-    utils.radix2(5),
-    utils.alphabet(chars),
-    {
-      decode: (input: string) => input.split(''),
-      encode: (input: string[]) => input.join('')
-    }
-  ),
-  ipfs: 'b',
-  type: 'base32'
-};
-
-/**
- * @name base32Validate
- * @summary Validates a base32 value.
- * @description
- * Validates that the supplied value is valid base32, throwing exceptions if not
- */
-export const base32Validate = /*#__PURE__*/ createValidate(config);
-
-/**
-* @name isBase32
-* @description Checks if the input is in base32, returning true/false
-*/
-export const isBase32 = /*#__PURE__*/ createIs(base32Validate);
-
-/**
- * @name base32Decode
- * @summary Delookup a base32 value.
- * @description
- * From the provided input, decode the base32 and return the result as an `Uint8Array`.
- */
-export const base32Decode = /*#__PURE__*/ createDecode(config, base32Validate);
-
-/**
-* @name base32Encode
-* @summary Creates a base32 value.
-* @description
-* From the provided input, create the base32 and return the result as a string.
-*/
-export const base32Encode = /*#__PURE__*/ createEncode(config);

package/build-deno/base32/helpers.ts

@@ -1,90 +0,0 @@
-
-import type { U8aLike } from 'https://deno.land/x/pezkuwi/util/types.ts';
-
-import { u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-export type { U8aLike } from 'https://deno.land/x/pezkuwi/util/types.ts';
-
-interface Coder {
-  decode: (value: string) => Uint8Array;
-  encode: (value: Uint8Array) => string;
-}
-
-interface Config {
-  chars: string;
-  coder: Coder;
-  ipfs?: string;
-  regex?: RegExp;
-  type: string;
-  withPadding?: boolean;
-}
-
-type DecodeFn = (value: string, ipfsCompat?: boolean) => Uint8Array;
-
-type EncodeFn = (value: U8aLike, ipfsCompat?: boolean) => string;
-
-type ValidateFn = (value?: unknown, ipfsCompat?: boolean) => value is string;
-
-/** @internal */
-export function createDecode ({ coder, ipfs }: Config, validate: ValidateFn): DecodeFn {
-  return (value: string, ipfsCompat?: boolean): Uint8Array => {
-    validate(value, ipfsCompat);
-
-    return coder.decode(
-      ipfs && ipfsCompat
-        ? value.substring(1)
-        : value
-    );
-  };
-}
-
-/** @internal */
-export function createEncode ({ coder, ipfs }: Config): EncodeFn {
-  return (value: U8aLike, ipfsCompat?: boolean): string => {
-    const out = coder.encode(u8aToU8a(value));
-
-    return ipfs && ipfsCompat
-      ? `${ipfs}${out}`
-      : out;
-  };
-}
-
-/** @internal */
-export function createIs (validate: ValidateFn): ValidateFn {
-  return (value?: unknown, ipfsCompat?: boolean): value is string => {
-    try {
-      return validate(value, ipfsCompat);
-    } catch {
-      return false;
-    }
-  };
-}
-
-/** @internal */
-export function createValidate ({ chars, ipfs, type, withPadding }: Config): ValidateFn {
-  return (value?: unknown, ipfsCompat?: boolean): value is string => {
-    if (typeof value !== 'string') {
-      throw new Error(`Expected ${type} string input`);
-    } else if (ipfs && ipfsCompat && !value.startsWith(ipfs)) {
-      throw new Error(`Expected ipfs-compatible ${type} to start with '${ipfs}'`);
-    }
-
-    for (let i = (ipfsCompat ? 1 : 0), count = value.length; i < count; i++) {
-      if (chars.includes(value[i])) {
-        // all ok, character found
-      } else if (withPadding && value[i] === '=') {
-        if (i === count - 1) {
-          // last character, everything ok
-        } else if (value[i + 1] === '=') {
-          // next one is also padding, sequence ok
-        } else {
-          throw new Error(`Invalid ${type} padding sequence "${value[i]}${value[i + 1]}" at index ${i}`);
-        }
-      } else {
-        throw new Error(`Invalid ${type} character "${value[i]}" (0x${value.charCodeAt(i).toString(16)}) at index ${i}`);
-      }
-    }
-
-    return true;
-  };
-}

package/build-deno/base32/index.ts

@@ -1,6 +0,0 @@
-
-/**
- * @summary Encode and decode base32 values
- */
-
-export { base32Decode, base32Encode, base32Validate, isBase32 } from './bs32.ts';

package/build-deno/base58/bs58.ts

@@ -1,41 +0,0 @@
-
-import { base58 } from 'https://esm.sh/@scure/base@1.1.7';
-
-import { createDecode, createEncode, createIs, createValidate } from '../base32/helpers.ts';
-
-const config = {
-  chars: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz',
-  coder: base58,
-  ipfs: 'z',
-  type: 'base58'
-};
-
-/**
- * @name base58Validate
- * @summary Validates a base58 value.
- * @description
- * Validates that the supplied value is valid base58, throwing exceptions if not
- */
-export const base58Validate = /*#__PURE__*/ createValidate(config);
-
-/**
- * @name base58Decode
- * @summary Decodes a base58 value.
- * @description
- * From the provided input, decode the base58 and return the result as an `Uint8Array`.
- */
-export const base58Decode = /*#__PURE__*/ createDecode(config, base58Validate);
-
-/**
-* @name base58Encode
-* @summary Creates a base58 value.
-* @description
-* From the provided input, create the base58 and return the result as a string.
-*/
-export const base58Encode = /*#__PURE__*/ createEncode(config);
-
-/**
-* @name isBase58
-* @description Checks if the input is in base58, returning true/false
-*/
-export const isBase58 = /*#__PURE__*/ createIs(base58Validate);

package/build-deno/base58/index.ts

@@ -1,6 +0,0 @@
-
-/**
- * @summary Encode and decode base58 values
- */
-
-export { base58Decode, base58Encode, base58Validate, isBase58 } from './bs58.ts';

package/build-deno/base64/bs64.ts

@@ -1,41 +0,0 @@
-
-import { base64 } from 'https://esm.sh/@scure/base@1.1.7';
-
-import { createDecode, createEncode, createIs, createValidate } from '../base32/helpers.ts';
-
-const config = {
-  chars: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
-  coder: base64,
-  type: 'base64',
-  withPadding: true
-};
-
-/**
- * @name base64Validate
- * @summary Validates a base64 value.
- * @description
- * Validates that the supplied value is valid base64
- */
-export const base64Validate = /*#__PURE__*/ createValidate(config);
-
-/**
- * @name isBase64
- * @description Checks if the input is in base64, returning true/false
- */
-export const isBase64 = /*#__PURE__*/ createIs(base64Validate);
-
-/**
- * @name base64Decode
- * @summary Decodes a base64 value.
- * @description
- * From the provided input, decode the base64 and return the result as an `Uint8Array`.
- */
-export const base64Decode = /*#__PURE__*/ createDecode(config, base64Validate);
-
-/**
- * @name base64Encode
- * @summary Creates a base64 value.
- * @description
- * From the provided input, create the base64 and return the result as a string.
- */
-export const base64Encode = /*#__PURE__*/ createEncode(config);

package/build-deno/base64/index.ts

@@ -1,8 +0,0 @@
-
-/**
- * @summary Encode and decode base64 values
- */
-
-export { base64Decode, base64Encode, base64Validate, isBase64 } from './bs64.ts';
-export { base64Pad } from './pad.ts';
-export { base64Trim } from './trim.ts';

package/build-deno/base64/pad.ts

@@ -1,8 +0,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/build-deno/base64/trim.ts

@@ -1,12 +0,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/build-deno/blake2/asU8a.ts

@@ -1,38 +0,0 @@
-
-import { blake2b as blake2bJs } from 'https://esm.sh/@noble/hashes@1.3.3/blake2b.js';
-
-import { hasBigInt, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { blake2b, isReady } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
-
-import { createAsHex } from '../helpers.ts';
-
-/**
- * @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 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
- *
- * 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);