@pezkuwi/types-codec 16.5.6 → 16.5.8

package/src/utils/compareArray.ts

@@ -0,0 +1,22 @@
+// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { isUndefined } from '@pezkuwi/util';
+
+import { hasEq } from './util.js';
+
+// NOTE These are used internally and when comparing objects, we expect that
+// when the second is an Codec[] that the first has to be as well
+export function compareArray (a: unknown[], b?: unknown): boolean {
+  if (Array.isArray(b)) {
+    return (a.length === b.length) && isUndefined(
+      a.find((v, index): boolean =>
+        hasEq(v)
+          ? !v.eq(b[index])
+          : v !== b[index]
+      )
+    );
+  }
+
+  return false;
+}

package/src/utils/compareMap.ts

@@ -0,0 +1,40 @@
+// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { isObject, isUndefined } from '@pezkuwi/util';
+
+import { hasEq } from './util.js';
+
+function hasMismatch (a?: unknown, b?: unknown): boolean {
+  return isUndefined(a) || (
+    hasEq(a)
+      ? !a.eq(b)
+      : a !== b
+  );
+}
+
+function notEntry (value: unknown): boolean {
+  return !Array.isArray(value) || value.length !== 2;
+}
+
+function compareMapArray (a: Map<unknown, unknown>, b: [unknown, unknown][]): boolean {
+  // equal number of entries and each entry in the array should match
+  return (a.size === b.length) && !b.some((e) =>
+    notEntry(e) ||
+    hasMismatch(a.get(e[0]), e[1])
+  );
+}
+
+// NOTE These are used internally and when comparing objects, we expect that
+// when the second is an Map<string, Codec> that the first has to be as well
+export function compareMap (a: Map<unknown, unknown>, b?: unknown): boolean {
+  if (Array.isArray(b)) {
+    return compareMapArray(a, b as [unknown, unknown][]);
+  } else if (b instanceof Map) {
+    return compareMapArray(a, [...b.entries()]);
+  } else if (isObject(b)) {
+    return compareMapArray(a, Object.entries(b));
+  }
+
+  return false;
+}

package/src/utils/compareSet.ts

@@ -0,0 +1,23 @@
+// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { isObject } from '@pezkuwi/util';
+
+function compareSetArray (a: Set<unknown>, b: any[]): boolean {
+  // equal number of entries and each entry in the array should match
+  return (a.size === b.length) && !b.some((e) => !a.has(e));
+}
+
+// NOTE These are used internally and when comparing objects, we expect that
+// when the second is an Set<string, Codec> that the first has to be as well
+export function compareSet (a: Set<unknown>, b?: unknown): boolean {
+  if (Array.isArray(b)) {
+    return compareSetArray(a, b);
+  } else if (b instanceof Set) {
+    return compareSetArray(a, [...b.values()]);
+  } else if (isObject(b)) {
+    return compareSetArray(a, Object.values(b));
+  }
+
+  return false;
+}

package/src/utils/decodeU8a.ts

@@ -0,0 +1,123 @@
+// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Codec, CodecClass, Registry } from '../types/index.js';
+
+import { u8aToHex } from '@pezkuwi/util';
+
+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/src/utils/index.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export { compareArray } from './compareArray.js';
+export { compareMap } from './compareMap.js';
+export { compareSet } from './compareSet.js';
+export { decodeU8a, decodeU8aStruct, decodeU8aVec } from './decodeU8a.js';
+export { sanitize } from './sanitize.js';
+export { sortAsc, sortMap, sortSet } from './sortValues.js';
+export { mapToTypeMap, typesToConstructors, typeToConstructor } from './toConstructors.js';
+export { typesToMap } from './typesToMap.js';

package/src/utils/sanitize.spec.ts

@@ -0,0 +1,89 @@
+// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { alias, flattenSingleTuple, removeColons, removeExtensions } from './sanitize.js';
+
+describe('sanitize', (): void => {
+  describe('alias', (): void => {
+    const fn = alias('String', 'Text');
+
+    it('replaces all occurrences for types', (): void => {
+      expect(fn('(String,Address,MasterString,String)')).toEqual(
+        '(Text,Address,MasterString,Text)'
+      );
+    });
+
+    it('replaces actual types, but leaves struct names', (): void => {
+      expect(fn('{"system":"String","versionString":"String"}')).toEqual(
+        '{"system":"Text","versionString":"Text"}'
+      );
+    });
+
+    it('handles the preceding correctly', (): void => {
+      // NOTE This type doesn't make sense
+      expect(fn('String String (String,[String;32],String)"String<String>')).toEqual(
+        'Text Text (Text,[Text;32],Text)"Text<Text>'
+      );
+    });
+
+    it('handles embedded Vec/Tuples', (): void => {
+      const ann = alias('Announcement', 'ProxyAnnouncement');
+
+      expect(ann('(Vec<Announcement>,BalanceOf)')).toEqual(
+        '(Vec<ProxyAnnouncement>,BalanceOf)'
+      );
+    });
+  });
+
+  describe('removeColons', (): void => {
+    const fn = removeColons();
+
+    it('removes preceding ::Text -> Text', (): void => {
+      expect(fn('::Text')).toEqual('Text');
+    });
+
+    it('removes middle voting::TallyType -> TallyType', (): void => {
+      expect(fn('voting::TallyType')).toEqual('TallyType');
+    });
+
+    it('removes on embedded values (one)', (): void => {
+      expect(fn('(T::AccountId, SpanIndex)')).toEqual('(AccountId, SpanIndex)');
+    });
+
+    it('removes on embedded values (all)', (): void => {
+      expect(fn('(T::AccountId, slashing::SpanIndex)')).toEqual('(AccountId, SpanIndex)');
+    });
+  });
+
+  describe('bounded', (): void => {
+    const fn = removeExtensions('Bounded', true);
+
+    it('correctly cleans up bounded values', (): void => {
+      expect(fn('BoundedVec<u32, 256>')).toEqual('Vec<u32>');
+    });
+
+    it('correctly cleans up nested bounded values', (): void => {
+      expect(
+        fn('BoundedBTreeMap<BoundedVec<BoundedVec<u32, 1>, 2>, BoundedBTreeSet<u32, BoundedVec<u64, 3>, 4>, 5>')
+      ).toEqual('BTreeMap<Vec<Vec<u32>>,BTreeSet<u32,Vec<u64>>>');
+    });
+
+    it('cleans up values with trailing commas', (): void => {
+      expect(
+        flattenSingleTuple()(
+          fn('(BoundedVec<Announcement<T::AccountId, CallHashOf<T>, T::BlockNumber>, T::MaxPending,>,BalanceOf<T>,)')
+        )
+      ).toEqual('(Vec<Announcement<T::AccountId,CallHashOf<T>,T::BlockNumber>>,BalanceOf<T>)');
+    });
+  });
+
+  describe('weak', (): void => {
+    const fn = removeExtensions('Weak', false);
+
+    it('correctly cleans up weak values', (): void => {
+      expect(fn('WeakVec<u32>')).toEqual('Vec<u32>');
+    });
+  });
+});

package/src/utils/sanitize.ts

@@ -0,0 +1,290 @@
+// Copyright 2017-2025 @pezkuwi/types-codec authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { AnyString } from '../types/index.js';
+
+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()
+];
+
+// given a string, trim it
+export function trim (): Mapper {
+  return (value: string): string =>
+    value.trim();
+}
+
+// given a starting index, find the closing >
+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)}`;
+  }
+}
+
+// remove the Bounded* or Weak* wrappers
+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;
+  };
+}
+
+// remove the PairOf wrappers
+export function removePairOf (): Mapper {
+  const replacer = (v: string) => `(${v},${v})`;
+
+  return (value: string) =>
+    replaceTagWith(value, 'PairOf<', replacer);
+}
+
+// remove the type traits
+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, '');
+  };
+}
+
+// remove wrapping values, i.e. Box<Proposal> -> Proposal
+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;
+}