@pezkuwi/types-create 16.5.5

package/src/types/types.ts

@@ -0,0 +1,47 @@
+// Copyright 2017-2025 @polkadot/types-create authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export enum TypeDefInfo {
+  BTreeMap,
+  BTreeSet,
+  Compact,
+  DoNotConstruct,
+  Enum,
+  HashMap,
+  Int,
+  Linkage,
+  Null,
+  Option,
+  Plain,
+  Range,
+  RangeInclusive,
+  Result,
+  Set,
+  Si,
+  Struct,
+  Tuple,
+  UInt,
+  Vec,
+  VecFixed,
+  WrapperKeepOpaque,
+  WrapperOpaque
+}
+
+export interface TypeDef {
+  alias?: Map<string, string> | undefined;
+  displayName?: string | undefined;
+  docs?: string[] | undefined;
+  fallbackType?: string | undefined;
+  info: TypeDefInfo;
+  index?: number;
+  isFromSi?: boolean;
+  length?: number;
+  lookupIndex?: number;
+  lookupName?: string | undefined;
+  lookupNameRoot?: string | undefined;
+  name?: string | undefined;
+  namespace?: string | undefined;
+  sub?: TypeDef | TypeDef[];
+  type: string;
+  typeName?: string | undefined;
+}

package/src/util/encodeTypes.spec.ts

@@ -0,0 +1,217 @@
+// Copyright 2017-2025 @polkadot/types authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
+
+import { TypeRegistry } from '@pezkuwi/types';
+import { encodeTypeDef, TypeDefInfo } from '@pezkuwi/types-create';
+
+describe('encodeTypeDef', (): void => {
+  const registry = new TypeRegistry();
+
+  it('correctly encodes a complex struct', (): void => {
+    expect(
+      JSON.parse(encodeTypeDef(registry, {
+        info: TypeDefInfo.Struct,
+        sub: [
+          {
+            info: TypeDefInfo.Plain,
+            name: 'a',
+            type: 'u32'
+          },
+          {
+            info: TypeDefInfo.Struct,
+            name: 'b',
+            sub: [
+              {
+                info: TypeDefInfo.Plain,
+                name: 'c',
+                type: 'u32'
+              },
+              {
+                info: TypeDefInfo.Vec,
+                name: 'd',
+                sub: {
+                  info: TypeDefInfo.Plain,
+                  type: 'u32'
+                },
+                type: ''
+              }
+            ],
+            type: ''
+          }
+        ],
+        type: ''
+      }))
+    ).toEqual({
+      a: 'u32',
+      b: '{"c":"u32","d":"Vec<u32>"}'
+    });
+  });
+
+  it('correctly encodes a complex struct (named)', (): void => {
+    expect(
+      JSON.parse(encodeTypeDef(registry, {
+        info: TypeDefInfo.Struct,
+        sub: [
+          {
+            info: TypeDefInfo.Plain,
+            name: 'a',
+            type: 'u32'
+          },
+          {
+            info: TypeDefInfo.Struct,
+            name: 'b',
+            sub: [
+              {
+                info: TypeDefInfo.Plain,
+                name: 'c',
+                type: 'u32'
+              },
+              {
+                displayName: 'Something',
+                info: TypeDefInfo.Vec,
+                name: 'd',
+                sub: {
+                  info: TypeDefInfo.Plain,
+                  type: 'u32'
+                },
+                type: ''
+              }
+            ],
+            type: ''
+          }
+        ],
+        type: ''
+      }))
+    ).toEqual({
+      a: 'u32',
+      b: '{"c":"u32","d":"Something"}'
+    });
+  });
+
+  it('correctly encodes a complex enum', (): void => {
+    expect(
+      JSON.parse(encodeTypeDef(registry, {
+        info: TypeDefInfo.Enum,
+        sub: [
+          {
+            info: TypeDefInfo.Plain,
+            name: 'a',
+            type: 'u32'
+          },
+          {
+            info: TypeDefInfo.Struct,
+            name: 'b',
+            sub: [
+              {
+                info: TypeDefInfo.Plain,
+                name: 'c',
+                type: 'u32'
+              },
+              {
+                info: TypeDefInfo.Vec,
+                name: 'd',
+                sub: {
+                  info: TypeDefInfo.Plain,
+                  type: 'u32'
+                },
+                type: ''
+              }
+            ],
+            type: ''
+          },
+          {
+            info: TypeDefInfo.Enum,
+            name: 'f',
+            sub: [
+              {
+                info: TypeDefInfo.Plain,
+                name: 'g',
+                type: 'Null'
+              },
+              {
+                info: TypeDefInfo.Plain,
+                name: 'h',
+                type: 'Null'
+              }
+            ],
+            type: ''
+          }
+        ],
+        type: ''
+      }))
+    ).toEqual({
+      _enum: {
+        a: 'u32',
+        b: '{"c":"u32","d":"Vec<u32>"}',
+        f: '{"_enum":["g","h"]}'
+      }
+    });
+  });
+
+  it('correctly encodes a complex enum (named)', (): void => {
+    expect(
+      JSON.parse(encodeTypeDef(registry, {
+        info: TypeDefInfo.Enum,
+        sub: [
+          {
+            info: TypeDefInfo.Plain,
+            name: 'a',
+            type: 'u32'
+          },
+          {
+            displayName: 'Something',
+            info: TypeDefInfo.Struct,
+            name: 'b',
+            sub: [
+              {
+                info: TypeDefInfo.Plain,
+                name: 'c',
+                type: 'u32'
+              },
+              {
+                info: TypeDefInfo.Vec,
+                name: 'd',
+                sub: {
+                  info: TypeDefInfo.Plain,
+                  type: 'u32'
+                },
+                type: ''
+              }
+            ],
+            type: ''
+          },
+          {
+            displayName: 'Option',
+            info: TypeDefInfo.Option,
+            name: 'e',
+            sub: {
+              displayName: 'Result',
+              info: TypeDefInfo.Result,
+              sub: [
+                {
+                  info: TypeDefInfo.Null,
+                  type: ''
+                },
+                {
+                  info: TypeDefInfo.Plain,
+                  type: 'u32'
+                }
+              ],
+              type: ''
+            },
+            type: ''
+          }
+        ],
+        type: ''
+      }))
+    ).toEqual({
+      _enum: {
+        a: 'u32',
+        b: 'Something',
+        e: 'Option<Result<Null, u32>>'
+      }
+    });
+  });
+});

package/src/util/encodeTypes.ts

@@ -0,0 +1,205 @@
+// Copyright 2017-2025 @polkadot/types-create authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { TypeDef } from '@pezkuwi/types-create/types';
+
+import { isNumber, isUndefined, objectSpread, stringify } from '@pezkuwi/util';
+
+import { TypeDefInfo } from '../types/index.js';
+
+interface ToString { toString: () => string }
+
+const stringIdentity = <T extends ToString> (value: T): string => value.toString();
+
+const INFO_WRAP = ['BTreeMap', 'BTreeSet', 'Compact', 'HashMap', 'Option', 'Result', 'Vec'];
+
+export function paramsNotation <T extends ToString> (outer: string, inner?: T | T[], transform: (_: T) => string = stringIdentity): string {
+  return `${outer}${
+    inner
+      ? `<${(Array.isArray(inner) ? inner : [inner]).map(transform).join(', ')}>`
+      : ''
+  }`;
+}
+
+function encodeWithParams (registry: Registry, typeDef: TypeDef, outer: string): string {
+  const { info, sub } = typeDef;
+
+  switch (info) {
+    case TypeDefInfo.BTreeMap:
+    case TypeDefInfo.BTreeSet:
+    case TypeDefInfo.Compact:
+    case TypeDefInfo.HashMap:
+    case TypeDefInfo.Linkage:
+    case TypeDefInfo.Option:
+    case TypeDefInfo.Range:
+    case TypeDefInfo.RangeInclusive:
+    case TypeDefInfo.Result:
+    case TypeDefInfo.Vec:
+    case TypeDefInfo.WrapperKeepOpaque:
+    case TypeDefInfo.WrapperOpaque:
+      return paramsNotation(outer, sub, (p) => encodeTypeDef(registry, p));
+  }
+
+  throw new Error(`Unable to encode ${stringify(typeDef)} with params`);
+}
+
+function encodeSubTypes (registry: Registry, sub: TypeDef[], asEnum?: boolean, extra?: Record<string, unknown>): string {
+  const names = sub.map(({ name }) => name);
+
+  if (!names.every((n) => !!n)) {
+    throw new Error(`Subtypes does not have consistent names, ${names.join(', ')}`);
+  }
+
+  const inner: Record<string, string> = objectSpread({}, extra);
+
+  for (let i = 0, count = sub.length; i < count; i++) {
+    const def = sub[i];
+
+    if (!def.name) {
+      throw new Error(`No name found in ${stringify(def)}`);
+    }
+
+    inner[def.name] = encodeTypeDef(registry, def);
+  }
+
+  return stringify(
+    asEnum
+      ? { _enum: inner }
+      : inner
+  );
+}
+
+// We setup a record here to ensure we have comprehensive coverage (any item not covered will result
+// in a compile-time error with the missing index)
+const encoders: Record<TypeDefInfo, (registry: Registry, typeDef: TypeDef) => string> = {
+  [TypeDefInfo.BTreeMap]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'BTreeMap'),
+
+  [TypeDefInfo.BTreeSet]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'BTreeSet'),
+
+  [TypeDefInfo.Compact]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'Compact'),
+
+  [TypeDefInfo.DoNotConstruct]: (registry: Registry, { displayName, lookupIndex, lookupName }: TypeDef) =>
+    `DoNotConstruct<${lookupName || displayName || (isUndefined(lookupIndex) ? 'Unknown' : registry.createLookupType(lookupIndex))}>`,
+
+  [TypeDefInfo.Enum]: (registry: Registry, { sub }: TypeDef): string => {
+    if (!Array.isArray(sub)) {
+      throw new Error('Unable to encode Enum type');
+    }
+
+    // c-like enums have all Null entries
+    // TODO We need to take the disciminant into account and auto-add empty entries
+    return sub.every(({ type }) => type === 'Null')
+      ? stringify({ _enum: sub.map(({ name }, index) => `${name || `Empty${index}`}`) })
+      : encodeSubTypes(registry, sub, true);
+  },
+
+  [TypeDefInfo.HashMap]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'HashMap'),
+
+  [TypeDefInfo.Int]: (_registry: Registry, { length = 32 }: TypeDef) =>
+    `Int<${length}>`,
+
+  [TypeDefInfo.Linkage]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'Linkage'),
+
+  [TypeDefInfo.Null]: (_registry: Registry, _typeDef: TypeDef) =>
+    'Null',
+
+  [TypeDefInfo.Option]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'Option'),
+
+  [TypeDefInfo.Plain]: (_registry: Registry, { displayName, type }: TypeDef) =>
+    displayName || type,
+
+  [TypeDefInfo.Range]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'Range'),
+
+  [TypeDefInfo.RangeInclusive]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'RangeInclusive'),
+
+  [TypeDefInfo.Result]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'Result'),
+
+  [TypeDefInfo.Set]: (_registry: Registry, { length = 8, sub }: TypeDef): string => {
+    if (!Array.isArray(sub)) {
+      throw new Error('Unable to encode Set type');
+    }
+
+    return stringify({
+      _set: sub.reduce((all, { index, name }, count) =>
+        objectSpread(all, { [`${name || `Unknown${index || count}`}`]: index || count }),
+      { _bitLength: length || 8 })
+    });
+  },
+
+  [TypeDefInfo.Si]: (_registry: Registry, { lookupName, type }: TypeDef) =>
+    lookupName || type,
+
+  [TypeDefInfo.Struct]: (registry: Registry, { alias, sub }: TypeDef): string => {
+    if (!Array.isArray(sub)) {
+      throw new Error('Unable to encode Struct type');
+    }
+
+    return encodeSubTypes(registry, sub, false, alias
+      ? {
+        _alias: [...alias.entries()].reduce<Record<string, string>>((all, [k, v]) =>
+          objectSpread(all, { [k]: v }), {}
+        )
+      }
+      : {}
+    );
+  },
+
+  [TypeDefInfo.Tuple]: (registry: Registry, { sub }: TypeDef): string => {
+    if (!Array.isArray(sub)) {
+      throw new Error('Unable to encode Tuple type');
+    }
+
+    return `(${sub.map((type) => encodeTypeDef(registry, type)).join(',')})`;
+  },
+
+  [TypeDefInfo.UInt]: (_registry: Registry, { length = 32 }: TypeDef) =>
+    `UInt<${length}>`,
+
+  [TypeDefInfo.Vec]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'Vec'),
+
+  [TypeDefInfo.VecFixed]: (_registry: Registry, { length, sub }: TypeDef): string => {
+    if (!isNumber(length) || !sub || Array.isArray(sub)) {
+      throw new Error('Unable to encode VecFixed type');
+    }
+
+    return `[${sub.type};${length}]`;
+  },
+
+  [TypeDefInfo.WrapperKeepOpaque]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'WrapperKeepOpaque'),
+
+  [TypeDefInfo.WrapperOpaque]: (registry: Registry, typeDef: TypeDef) =>
+    encodeWithParams(registry, typeDef, 'WrapperOpaque')
+};
+
+function encodeType (registry: Registry, typeDef: TypeDef, withLookup = true): string {
+  return withLookup && typeDef.lookupName
+    ? typeDef.lookupName
+    : encoders[typeDef.info](registry, typeDef);
+}
+
+export function encodeTypeDef (registry: Registry, typeDef: TypeDef): string {
+  // In the case of contracts we do have the unfortunate situation where the displayName would
+  // refer to "Option" when it is an option. For these, string it out, only using when actually
+  // not a top-level element to be used
+  return (typeDef.displayName && !INFO_WRAP.some((i) => typeDef.displayName === i))
+    ? typeDef.displayName
+    : encodeType(registry, typeDef);
+}
+
+export function withTypeString (registry: Registry, typeDef: Omit<TypeDef, 'type'> & { type?: string }): TypeDef {
+  return objectSpread({}, typeDef, {
+    type: encodeType(registry, typeDef as TypeDef, false)
+  });
+}