@pezkuwi/types-codec 16.5.8 → 16.5.9

package/build-deno/utils/decodeU8a.ts

@@ -1,121 +0,0 @@
-
-import type { Codec, CodecClass, Registry } from '../types/index.ts';
-
-import { u8aToHex } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-const MAX_DEPTH = 1024;
-
-/** @internal */
-function isComplexType (Type: CodecClass): boolean {
-  const typeName = Type.name?.toLowerCase() || '';
-
-  return ['enum', 'hashmap', 'linkage', 'null', 'option', 'range', 'rangeinclusive', 'result', 'struct', 'tuple', 'vec', 'vecfixed'].includes(typeName);
-}
-
-/** @internal */
-function formatFailure (registry: Registry, fn: 'decodeU8a' | 'decodeU8aStruct' | 'decodeU8aVec', _result: unknown[], { message }: Error, u8a: Uint8Array, i: number, count: number, Type: CodecClass, key?: string): string {
-  let type = '';
-
-  try {
-    type = `: ${new Type(registry).toRawType()}`;
-  } catch {
-    // ignore
-  }
-
-  // This is extra debugging info (we most-probably want this in in some way, shape or form,
-  // but at this point not quite sure how to include and format it (it can be quite massive)
-  // console.error(JSON.stringify(result, null, 2));
-
-  return `${fn}: failed at ${u8aToHex(u8a.subarray(0, 16))}…${key ? ` on ${key}` : ''} (index ${i + 1}/${count})${type}:: ${message}`;
-}
-
-/**
- * @internal
- *
- * Given an u8a, and an array of Type constructors, decode the u8a against the
- * types, and return an array of decoded values.
- *
- * @param u8a - The u8a to decode.
- * @param result - The result array (will be returned with values pushed)
- * @param types - The array of CodecClass to decode the U8a against.
- */
-export function decodeU8a <T extends Codec = Codec> (registry: Registry, result: T[], u8a: Uint8Array, [Types, keys]: [CodecClass<T>[], string[]]): [T[], number] {
-  const count = result.length;
-  let offset = 0;
-  let i = 0;
-
-  try {
-    while (i < count) {
-      const value = new Types[i](registry, u8a.subarray(offset));
-
-      offset += value.initialU8aLength || value.encodedLength;
-      result[i] = value;
-      i++;
-    }
-  } catch (error) {
-    throw new Error(formatFailure(registry, 'decodeU8a', result, error as Error, u8a.subarray(offset), i, count, Types[i], keys[i]));
-  }
-
-  return [result, offset];
-}
-
-/**
- * @internal
- *
- * Split from decodeU8a since this is specialized to zip returns ... while we duplicate, this
- * is all on the hot-path, so it is not great, however there is (some) method behind the madness
- */
-export function decodeU8aStruct (registry: Registry, result: [string, Codec][], u8a: Uint8Array, [Types, keys]: [CodecClass[], string[]]): [[string, Codec][], number] {
-  const count = result.length;
-  let offset = 0;
-  let i = 0;
-
-  if (count > MAX_DEPTH && isComplexType(Types[i])) {
-    throw new Error(`decodeU8aStruct: Maximum depth exceeded, received ${count} elements, limit ${MAX_DEPTH}`);
-  }
-
-  try {
-    while (i < count) {
-      const value = new Types[i](registry, u8a.subarray(offset));
-
-      offset += value.initialU8aLength || value.encodedLength;
-      result[i] = [keys[i], value];
-      i++;
-    }
-  } catch (error) {
-    throw new Error(formatFailure(registry, 'decodeU8aStruct', result, error as Error, u8a.subarray(offset), i, count, Types[i], keys[i]));
-  }
-
-  return [result, offset];
-}
-
-/**
- * @internal
- *
- * Split from decodeU8a since this is specialized to 1 instance ... while we duplicate, this
- * is all on the hot-path, so it is not great, however there is (some) method behind the madness
- */
-export function decodeU8aVec <T extends Codec = Codec> (registry: Registry, result: unknown[], u8a: Uint8Array, startAt: number, Type: CodecClass<T>): [number, number] {
-  const count = result.length;
-
-  if (count > MAX_DEPTH && isComplexType(Type)) {
-    throw new Error(`decodeU8aVec: Maximum depth exceeded, received ${count} elements, limit ${MAX_DEPTH}`);
-  }
-
-  let offset = startAt;
-  let i = 0;
-
-  try {
-    while (i < count) {
-      const value = new Type(registry, u8a.subarray(offset));
-
-      offset += value.initialU8aLength || value.encodedLength;
-      result[i] = value;
-      i++;
-    }
-  } catch (error) {
-    throw new Error(formatFailure(registry, 'decodeU8aVec', result, error as Error, u8a.subarray(offset), i, count, Type));
-  }
-
-  return [offset, offset - startAt];
-}

package/build-deno/utils/index.ts

@@ -1,9 +0,0 @@
-
-export { compareArray } from './compareArray.ts';
-export { compareMap } from './compareMap.ts';
-export { compareSet } from './compareSet.ts';
-export { decodeU8a, decodeU8aStruct, decodeU8aVec } from './decodeU8a.ts';
-export { sanitize } from './sanitize.ts';
-export { sortAsc, sortMap, sortSet } from './sortValues.ts';
-export { mapToTypeMap, typesToConstructors, typeToConstructor } from './toConstructors.ts';
-export { typesToMap } from './typesToMap.ts';

package/build-deno/utils/sanitize.ts

@@ -1,282 +0,0 @@
-
-import type { AnyString } from '../types/index.ts';
-
-type Mapper = (value: string) => string;
-
-const BOUNDED = ['BTreeMap', 'BTreeSet', 'HashMap', 'Vec'];
-const ALLOWED_BOXES = BOUNDED.concat(['Compact', 'DoNotConstruct', 'Int', 'Linkage', 'Range', 'RangeInclusive', 'Result', 'Opaque', 'Option', 'UInt', 'WrapperKeepOpaque', 'WrapperOpaque']);
-const BOX_PRECEDING = ['<', '(', '[', '"', ',', ' ']; // start of vec, tuple, fixed array, part of struct def or in tuple
-
-const mappings: Mapper[] = [
-  // alias <T::InherentOfflineReport as InherentOfflineReport>::Inherent -> InherentOfflineReport
-  alias('<T::InherentOfflineReport as InherentOfflineReport>::Inherent', 'InherentOfflineReport', false),
-  alias('VecDeque<', 'Vec<', false),
-  // <T::Balance as HasCompact>
-  cleanupCompact(),
-  // Change BoundedVec<Type, Size> to Vec<Type>
-  removeExtensions('Bounded', true),
-  // Change WeakVec<Type> to Vec<Type>
-  removeExtensions('Weak', false),
-  // Remove all the trait prefixes
-  removeTraits(),
-  // remove PairOf<T> -> (T, T)
-  removePairOf(),
-  // remove boxing, `Box<Proposal>` -> `Proposal`
-  removeWrap('Box<'),
-  // remove generics, `MisbehaviorReport<Hash, BlockNumber>` -> `MisbehaviorReport`
-  removeGenerics(),
-  // alias String -> Text (compat with jsonrpc methods)
-  alias('String', 'Text'),
-  // alias Vec<u8> -> Bytes
-  alias('Vec<u8>', 'Bytes'),
-  alias('&\\[u8\\]', 'Bytes'),
-  alias("&'static\\[u8\\]", 'Bytes'),
-  // alias RawAddress -> Address
-  alias('RawAddress', 'Address'),
-  // lookups, mapped to Address/AccountId as appropriate in runtime
-  alias('Lookup::Source', 'LookupSource'),
-  alias('Lookup::Target', 'LookupTarget'),
-  // HACK duplication between contracts & primitives, however contracts prefixed with exec
-  alias('exec::StorageKey', 'ContractStorageKey'),
-  // flattens tuples with one value, `(AccountId)` -> `AccountId`
-  flattenSingleTuple(),
-  // converts ::Type to Type, <T as Trait<I>>::Proposal -> Proposal
-  removeColons(),
-  // remove all trailing spaces - this should always be the last
-  trim()
-];
-
-export function trim (): Mapper {
-  return (value: string): string =>
-    value.trim();
-}
-
-export function findClosing (value: string, start: number): number {
-  let depth = 0;
-
-  for (let i = start, count = value.length; i < count; i++) {
-    if (value[i] === '>') {
-      if (!depth) {
-        return i;
-      }
-
-      depth--;
-    } else if (value[i] === '<') {
-      depth++;
-    }
-  }
-
-  throw new Error(`Unable to find closing matching <> on '${value}' (start ${start})`);
-}
-
-export function alias (src: string, dest: string, withChecks = true): Mapper {
-  const from = new RegExp(`(^${src}|${BOX_PRECEDING.map((box) => `\\${box}${src}`).join('|')})`, 'g');
-
-  const to = (src: string): string => {
-    from.lastIndex = 0;
-
-    return withChecks && BOX_PRECEDING.includes(src[0])
-      ? `${src[0]}${dest}`
-      : dest;
-  };
-
-  return (value: string): string =>
-    value.replace(from, to);
-}
-
-export function cleanupCompact (): Mapper {
-  return (value: string): string => {
-    if (value.includes(' as HasCompact')) {
-      for (let i = 0, count = value.length; i < count; i++) {
-        if (value[i] === '<') {
-          const end = findClosing(value, i + 1) - 14;
-
-          if (value.substring(end, end + 14) === ' as HasCompact') {
-            value = `Compact<${value.substring(i + 1, end)}>`;
-          }
-        }
-      }
-    }
-
-    return value;
-  };
-}
-
-export function flattenSingleTuple (): Mapper {
-  const from1 = /,\)/g;
-  const from2 = /\(([^,]+)\)/;
-
-  return (value: string) => {
-    from1.lastIndex = 0;
-
-    return value
-      // tuples may have trailing commas, e.g. (u32, BlockNumber, )
-      .replace(from1, ')')
-      // change (u32) -> u32
-      .replace(from2, '$1');
-  };
-}
-
-function replaceTagWith (value: string, matcher: string, replacer: (inner: string) => string): string {
-  let index = -1;
-
-  while (true) {
-    index = value.indexOf(matcher, index + 1);
-
-    if (index === -1) {
-      return value;
-    }
-
-    const start = index + matcher.length;
-    const end = findClosing(value, start);
-
-    value = `${value.substring(0, index)}${replacer(value.substring(start, end))}${value.substring(end + 1)}`;
-  }
-}
-
-export function removeExtensions (type: string, isSized: boolean): Mapper {
-  return (value: string): string => {
-    for (let i = 0, count = BOUNDED.length; i < count; i++) {
-      const tag = BOUNDED[i];
-
-      value = replaceTagWith(value, `${type}${tag}<`, (v: string): string => {
-        const parts = v
-          .split(',')
-          .map((s) => s.trim())
-          .filter((s) => s);
-
-        if (isSized) {
-          parts.pop();
-        }
-
-        return `${tag}<${parts.join(',')}>`;
-      });
-    }
-
-    return value;
-  };
-}
-
-export function removeColons (): Mapper {
-  return (value: string): string => {
-    let index = 0;
-
-    while (index !== -1) {
-      index = value.indexOf('::');
-
-      if (index === 0) {
-        value = value.substring(2);
-      } else if (index !== -1) {
-        let start = index;
-
-        while (start !== -1 && !BOX_PRECEDING.includes(value[start])) {
-          start--;
-        }
-
-        value = `${value.substring(0, start + 1)}${value.substring(index + 2)}`;
-      }
-    }
-
-    return value;
-  };
-}
-
-export function removeGenerics (): Mapper {
-  return (value: string): string => {
-    for (let i = 0, count = value.length; i < count; i++) {
-      if (value[i] === '<') {
-        // check against the allowed wrappers, be it Vec<..>, Option<...> ...
-        const box = ALLOWED_BOXES.find((box): boolean => {
-          const start = i - box.length;
-
-          return (
-            (
-              start >= 0 &&
-              value.substring(start, i) === box
-            ) && (
-              // make sure it is stand-alone, i.e. don't catch ElectionResult<...> as Result<...>
-              start === 0 ||
-              BOX_PRECEDING.includes(value[start - 1])
-            )
-          );
-        });
-
-        // we have not found anything, unwrap generic innards
-        if (!box) {
-          const end = findClosing(value, i + 1);
-
-          value = `${value.substring(0, i)}${value.substring(end + 1)}`;
-        }
-      }
-    }
-
-    return value;
-  };
-}
-
-export function removePairOf (): Mapper {
-  const replacer = (v: string) => `(${v},${v})`;
-
-  return (value: string) =>
-    replaceTagWith(value, 'PairOf<', replacer);
-}
-
-export function removeTraits (): Mapper {
-  const from1 = /\s/g;
-  const from2 = /(T|Self)::/g;
-  const from3 = /<(T|Self)asTrait>::/g;
-  const from4 = /<Tas[a-z]+::Trait>::/g;
-  const from5 = /<LookupasStaticLookup>/g;
-  const from6 = /::Type/g;
-
-  return (value: string): string => {
-    from1.lastIndex = 0;
-    from2.lastIndex = 0;
-    from3.lastIndex = 0;
-    from4.lastIndex = 0;
-    from5.lastIndex = 0;
-    from6.lastIndex = 0;
-
-    return value
-      // remove all whitespaces
-      .replace(from1, '')
-      // anything `T::<type>` to end up as `<type>`
-      .replace(from2, '')
-      // replace `<T as Trait>::` (whitespaces were removed above)
-      .replace(from3, '')
-      // replace `<T as something::Trait>::` (whitespaces were removed above)
-      .replace(from4, '')
-      // replace <Lookup as StaticLookup>
-      .replace(from5, 'Lookup')
-      // replace `<...>::Type`
-      .replace(from6, '');
-  };
-}
-
-export function removeWrap (check: string): Mapper {
-  const replacer = (v: string) => v;
-
-  return (value: string) =>
-    replaceTagWith(value, check, replacer);
-}
-
-const sanitizeMap = new Map<string, string>();
-
-export function sanitize (value: AnyString): string {
-  const startValue = value.toString();
-  const memoized = sanitizeMap.get(startValue);
-
-  if (memoized) {
-    return memoized;
-  }
-
-  let result = startValue;
-
-  for (let i = 0, count = mappings.length; i < count; i++) {
-    result = mappings[i](result);
-  }
-
-  sanitizeMap.set(startValue, result);
-
-  return result;
-}

package/build-deno/utils/sortValues.ts

@@ -1,101 +0,0 @@
-
-import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import type { HexString } from 'https://deno.land/x/pezkuwi/util/types.ts';
-import type { Enum } from '../base/Enum.ts';
-import type { Option } from '../base/Option.ts';
-import type { Codec } from '../types/index.ts';
-
-import { bnToBn, isBigInt, isBn, isBoolean, isCodec, isNumber, stringify } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-type SortArg = Codec | Codec[] | number[] | BN | bigint | number | Uint8Array;
-
-/** @internal **/
-function isArrayLike (arg: SortArg): arg is Uint8Array | Codec[] | number[] {
-  return arg instanceof Uint8Array || Array.isArray(arg);
-}
-
-/** @internal **/
-function isEnum (arg: SortArg): arg is Enum {
-  return isCodec<Codec>(arg) && isNumber((arg as Enum).index) && isCodec((arg as Enum).value);
-}
-
-/** @internal **/
-function isOption (arg: SortArg): arg is Option<Codec> {
-  return isCodec<Codec>(arg) && isBoolean((arg as Option<Codec>).isSome) && isCodec((arg as Option<Codec>).value);
-}
-
-/** @internal */
-function isNumberLike (arg: SortArg): arg is BN | bigint | number {
-  return isNumber(arg) || isBn(arg) || isBigInt(arg);
-}
-
-/** @internal */
-function sortArray (a: Uint8Array | Codec[] | number[], b: Uint8Array | Codec[] | number[]): number {
-  // Vec, Tuple, Bytes etc.
-  let sortRes = 0;
-  const minLen = Math.min(a.length, b.length);
-
-  for (let i = 0; i < minLen; ++i) {
-    sortRes = sortAsc(a[i], b[i]);
-
-    if (sortRes !== 0) {
-      return sortRes;
-    }
-  }
-
-  return a.length - b.length;
-}
-
-/** @internal */
-function checkForDuplicates (container: string, seen: Set<HexString>, arg: SortArg): boolean {
-  // Convert the value to hex.
-  if (isCodec<Codec>(arg)) {
-    const hex = arg.toHex();
-
-    // Check if we have seen the value.
-    if (seen.has(hex)) {
-      // Duplicates are not allowed.
-      throw new Error(`Duplicate value in ${container}: ${stringify(arg)}`);
-    }
-
-    seen.add(hex);
-  }
-
-  return true;
-}
-
-/**
-* Sort keys/values of BTreeSet/BTreeMap in ascending order for encoding compatibility with Rust's BTreeSet/BTreeMap
-* (https://doc.rust-lang.org/stable/std/collections/struct.BTreeSet.html)
-* (https://doc.rust-lang.org/stable/std/collections/struct.BTreeMap.html)
-*/
-export function sortAsc<V extends SortArg = Codec> (a: V, b: V): number {
-  if (isNumberLike(a) && isNumberLike(b)) {
-    return bnToBn(a).cmp(bnToBn(b));
-  } else if (a instanceof Map && b instanceof Map) {
-    return sortAsc(Array.from(a.values()), Array.from(b.values()));
-  } else if (isEnum(a) && isEnum(b)) {
-    return sortAsc(a.index, b.index) || sortAsc(a.value, b.value);
-  } else if (isOption(a) && isOption(b)) {
-    return sortAsc(a.isNone ? 0 : 1, b.isNone ? 0 : 1) || sortAsc(a.value, b.value);
-  } else if (isArrayLike(a) && isArrayLike(b)) {
-    return sortArray(a, b);
-  } else if (isCodec<Codec>(a) && isCodec<Codec>(b)) {
-    // Text, Bool etc.
-    return sortAsc(a.toU8a(true), b.toU8a(true));
-  }
-
-  throw new Error(`Attempting to sort unrecognized values: ${stringify(a)} (typeof ${typeof a}) <-> ${stringify(b)} (typeof ${typeof b})`);
-}
-
-export function sortSet<V extends Codec = Codec> (set: Set<V>): Set<V> {
-  const seen = new Set<HexString>();
-
-  return new Set(Array.from(set).filter((value) => checkForDuplicates('BTreeSet', seen, value)).sort(sortAsc));
-}
-
-export function sortMap<K extends Codec = Codec, V extends Codec = Codec> (map: Map<K, V>): Map<K, V> {
-  const seen = new Set<HexString>();
-
-  return new Map(Array.from(map.entries()).filter(([key]) => checkForDuplicates('BTreeMap', seen, key)).sort(([keyA], [keyB]) => sortAsc(keyA, keyB)));
-}

package/build-deno/utils/toConstructors.ts

@@ -1,44 +0,0 @@
-
-import type { Codec, CodecClass, Registry } from '../types/index.ts';
-
-/**
- * @internal
- * From a type string or class, return the associated type class
- */
-export function typeToConstructor <T extends Codec = Codec> (registry: Registry, type: string | CodecClass<T>): CodecClass<T> {
-  return typeof type === 'function'
-    ? type
-    : registry.createClassUnsafe(type);
-}
-
-/**
- * @internal
- * Takes an input array of types and returns the associated classes for it
-*/
-export function typesToConstructors <T extends Codec = Codec> (registry: Registry, types: (string | CodecClass<T>)[]): CodecClass<T>[] {
-  const count = types.length;
-  const result = new Array<CodecClass<T>>(count);
-
-  for (let i = 0; i < count; i++) {
-    result[i] = typeToConstructor(registry, types[i]);
-  }
-
-  return result;
-}
-
-/**
- * @internal
- * Takes an input map of the form `{ [string]: string | CodecClass }` and returns a map of `{ [string]: CodecClass }`
- */
-export function mapToTypeMap (registry: Registry, input: Record<string, string | CodecClass>): [CodecClass[], string[]] {
-  const entries = Object.entries(input);
-  const count = entries.length;
-  const output: [CodecClass[], string[]] = [new Array<CodecClass>(count), new Array<string>(count)];
-
-  for (let i = 0; i < count; i++) {
-    output[1][i] = entries[i][0];
-    output[0][i] = typeToConstructor(registry, entries[i][1]);
-  }
-
-  return output;
-}

package/build-deno/utils/typesToMap.ts

@@ -1,12 +0,0 @@
-
-import type { CodecClass, Registry } from '../types/index.ts';
-
-export function typesToMap (registry: Registry, [Types, keys]: [CodecClass[], string[]]): Record<string, string> {
-  const result: Record<string, string> = {};
-
-  for (let i = 0, count = keys.length; i < count; i++) {
-    result[keys[i]] = registry.getClassName(Types[i]) || new Types[i](registry).toRawType();
-  }
-
-  return result;
-}

package/build-deno/utils/util.ts

@@ -1,6 +0,0 @@
-
-import { isFunction } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-export function hasEq (o: unknown): o is { eq: (other: unknown) => boolean } {
-  return isFunction((o as { eq: unknown }).eq);
-}

package/build-tsc/abstract/Array.d.ts

@@ -1,89 +0,0 @@
-import type { HexString } from '@pezkuwi/util/types';
-import type { AnyJson, Codec, Inspect, IU8a, IVec, Registry } from '../types/index.js';
-/**
- * @name AbstractArray
- * @description
- * This manages codec arrays. It is an extension to Array, providing
- * specific encoding/decoding on top of the base type.
- * @noInheritDoc
- */
-export declare abstract class AbstractArray<T extends Codec> extends Array<T> implements IVec<T> {
-    readonly registry: Registry;
-    createdAtHash?: IU8a;
-    initialU8aLength?: number;
-    isStorageFallback?: boolean;
-    /**
-     * @description This ensures that operators such as clice, filter, map, etc. return
-     * new Array instances (without this we need to apply overrides)
-     */
-    static get [Symbol.species](): typeof Array;
-    protected constructor(registry: Registry, length: number);
-    /**
-     * @description The length of the value when encoded as a Uint8Array
-     */
-    get encodedLength(): number;
-    /**
-     * @description returns a hash of the contents
-     */
-    get hash(): IU8a;
-    /**
-     * @description Checks if the value is an empty value
-     */
-    get isEmpty(): boolean;
-    /**
-     * @description The length of the value
-     */
-    get length(): number;
-    /**
-     * @description Compares the value of the input to see if there is a match
-     */
-    eq(other?: unknown): boolean;
-    /**
-     * @description Returns a breakdown of the hex encoding for this Codec
-     */
-    inspect(): Inspect;
-    /**
-     * @internal
-     * @description Internal per-item inspection of internal values
-     */
-    inspectInner(): Inspect[];
-    /**
-     * @description Converts the Object to an standard JavaScript Array
-     */
-    toArray(): T[];
-    /**
-     * @description Returns a hex string representation of the value
-     */
-    toHex(): HexString;
-    /**
-     * @description Converts the Object to to a human-friendly JSON, with additional fields, expansion and formatting of information
-     */
-    toHuman(isExtended?: boolean, disableAscii?: boolean): AnyJson;
-    /**
-     * @description Converts the Object to JSON, typically used for RPC transfers
-     */
-    toJSON(): AnyJson;
-    /**
-     * @description Converts the value in a best-fit primitive form
-     */
-    toPrimitive(disableAscii?: boolean): AnyJson;
-    /**
-     * @description Returns the base runtime type name for this instance
-     */
-    abstract toRawType(): string;
-    /**
-     * @description Returns the string representation of the value
-     */
-    toString(): string;
-    /**
-     * @description Encodes the value as a Uint8Array as per the SCALE specifications
-     * @param isBare true when the value has none of the type-specific prefixes (internal)
-     */
-    toU8a(isBare?: boolean): Uint8Array;
-    /**
-     * @internal
-     * @description Internal per-item SCALE encoding of contained values
-     * @param isBare true when the value has none of the type-specific prefixes (internal)
-     */
-    toU8aInner(isBare?: boolean): Uint8Array[];
-}