@pezkuwi/util-crypto 14.0.7 → 14.0.10

package/build-deno/address/decode.ts

@@ -0,0 +1,38 @@
+
+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

@@ -0,0 +1,10 @@
+
+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

@@ -0,0 +1,34 @@
+
+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

@@ -0,0 +1,39 @@
+
+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

@@ -0,0 +1,17 @@
+
+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

@@ -0,0 +1,16 @@
+
+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

@@ -0,0 +1,22 @@
+
+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

@@ -0,0 +1,22 @@
+
+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

@@ -0,0 +1,18 @@
+
+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

@@ -0,0 +1,12 @@
+
+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

@@ -0,0 +1,20 @@
+
+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

@@ -0,0 +1,21 @@
+
+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

@@ -0,0 +1,18 @@
+
+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

@@ -0,0 +1,15 @@
+
+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

@@ -0,0 +1,10 @@
+
+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

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

package/build-deno/address/util.ts

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

package/build-deno/address/validate.ts

@@ -0,0 +1,8 @@
+
+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

@@ -0,0 +1,51 @@
+
+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

@@ -0,0 +1,90 @@
+
+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

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

package/build-deno/base58/bs58.ts

@@ -0,0 +1,41 @@
+
+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

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

package/build-deno/base64/bs64.ts

@@ -0,0 +1,41 @@
+
+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

@@ -0,0 +1,8 @@
+
+/**
+ * @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

@@ -0,0 +1,8 @@
+
+/**
+ * @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

@@ -0,0 +1,12 @@
+
+/**
+ * @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

@@ -0,0 +1,38 @@
+
+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);