@pezkuwi/types-create 16.5.8 → 16.5.10

package/build-deno/create/class.ts

@@ -1,252 +0,0 @@
-
-import type { Codec, CodecClass, LookupString, Registry, U8aBitLength, UIntBitLength } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
-import type { TypeDef } from '../types/index.ts';
-
-import { BTreeMap, BTreeSet, Bytes, CodecSet, Compact, DoNotConstruct, Enum, HashMap, Int, Null, Option, Range, RangeInclusive, Result, Struct, Tuple, U8aFixed, UInt, Vec, VecFixed, WrapperKeepOpaque, WrapperOpaque } from 'https://deno.land/x/pezkuwi/types-codec/mod.ts';
-import { isNumber, stringify } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { TypeDefInfo } from '../types/index.ts';
-import { getTypeDef } from '../util/getTypeDef.ts';
-
-function getTypeDefType ({ lookupName, type }: TypeDef): string {
-  return lookupName || type;
-}
-
-function getSubDefArray (value: TypeDef): TypeDef[] {
-  if (!Array.isArray(value.sub)) {
-    throw new Error(`Expected subtype as TypeDef[] in ${stringify(value)}`);
-  }
-
-  return value.sub;
-}
-
-function getSubDef (value: TypeDef): TypeDef {
-  if (!value.sub || Array.isArray(value.sub)) {
-    throw new Error(`Expected subtype as TypeDef in ${stringify(value)}`);
-  }
-
-  return value.sub;
-}
-
-function getSubType (value: TypeDef): string {
-  return getTypeDefType(getSubDef(value));
-}
-
-function getTypeClassMap (value: TypeDef): Record<string, string> {
-  const subs = getSubDefArray(value);
-  const map: Record<string, string> = {};
-
-  for (let i = 0, count = subs.length; i < count; i++) {
-    const sub = subs[i];
-
-    if (!sub.name) {
-      throw new Error(`No name found in definition ${stringify(sub)}`);
-    }
-
-    map[sub.name] = getTypeDefType(sub);
-  }
-
-  return map;
-}
-
-function getTypeClassArray (value: TypeDef): string[] {
-  return getSubDefArray(value).map(getTypeDefType);
-}
-
-function createInt (Clazz: typeof Int | typeof UInt, { displayName, length }: TypeDef): CodecClass<Codec> {
-  if (!isNumber(length)) {
-    throw new Error(`Expected bitLength information for ${displayName || Clazz.constructor.name}<bitLength>`);
-  }
-
-  return Clazz.with(length as UIntBitLength, displayName);
-}
-
-function createHashMap (Clazz: typeof BTreeMap | typeof HashMap, value: TypeDef): CodecClass<Codec> {
-  const [keyType, valueType] = getTypeClassArray(value);
-
-  return Clazz.with(keyType, valueType);
-}
-
-function createWithSub (Clazz: { with: (t: string) => CodecClass<Codec> }, value: TypeDef): CodecClass<Codec> {
-  return Clazz.with(getSubType(value));
-}
-
-const infoMapping: Record<TypeDefInfo, (registry: Registry, value: TypeDef) => CodecClass<Codec>> = {
-  [TypeDefInfo.BTreeMap]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
-    createHashMap(BTreeMap, value),
-
-  [TypeDefInfo.BTreeSet]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
-    createWithSub(BTreeSet, value),
-
-  [TypeDefInfo.Compact]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
-    createWithSub(Compact, value),
-
-  [TypeDefInfo.DoNotConstruct]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
-    DoNotConstruct.with(value.displayName || value.type),
-
-  [TypeDefInfo.Enum]: (_registry: Registry, value: TypeDef): CodecClass<Codec> => {
-    const subs = getSubDefArray(value);
-
-    return Enum.with(
-      subs.every(({ type }) => type === 'Null')
-        ? subs.reduce<Record<string, number>>((out, { index, name }, count) => {
-          if (!name) {
-            throw new Error('No name found in sub definition');
-          }
-
-          out[name] = index || count;
-
-          return out;
-        }, {})
-        : getTypeClassMap(value)
-    );
-  },
-
-  [TypeDefInfo.HashMap]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
-    createHashMap(HashMap, value),
-
-  [TypeDefInfo.Int]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
-    createInt(Int, value),
-
-  // We have circular deps between Linkage & Struct
-  [TypeDefInfo.Linkage]: (_registry: Registry, value: TypeDef): CodecClass<Codec> => {
-    const type = `Option<${getSubType(value)}>`;
-    // eslint-disable-next-line sort-keys
-    const Clazz = Struct.with({ previous: type, next: type } as any);
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    Clazz.prototype.toRawType = function (): string {
-      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-call
-      return `Linkage<${this.next.toRawType(true)}>`;
-    };
-
-    return Clazz;
-  },
-
-  [TypeDefInfo.Null]: (_registry: Registry, _value: TypeDef): CodecClass<Codec> =>
-    Null,
-
-  [TypeDefInfo.Option]: (_registry: Registry, value: TypeDef): CodecClass<Codec> => {
-    if (!value.sub || Array.isArray(value.sub)) {
-      throw new Error('Expected type information for Option');
-    }
-
-    // NOTE This is opt-in (unhandled), not by default
-    // if (value.sub.type === 'bool') {
-    //   return OptionBool;
-    // }
-
-    return createWithSub(Option, value);
-  },
-
-  [TypeDefInfo.Plain]: (registry: Registry, value: TypeDef): CodecClass<Codec> =>
-    registry.getOrUnknown(value.type),
-
-  [TypeDefInfo.Range]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
-    createWithSub(Range, value),
-
-  [TypeDefInfo.RangeInclusive]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
-    createWithSub(RangeInclusive, value),
-
-  [TypeDefInfo.Result]: (_registry: Registry, value: TypeDef): CodecClass<Codec> => {
-    const [Ok, Err] = getTypeClassArray(value);
-
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    return Result.with({ Err, Ok });
-  },
-
-  [TypeDefInfo.Set]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
-    CodecSet.with(
-      getSubDefArray(value).reduce<Record<string, number>>((result, { index, name }) => {
-        if (!name || !isNumber(index)) {
-          throw new Error('No name found in sub definition');
-        }
-
-        result[name] = index;
-
-        return result;
-      }, {}),
-      value.length
-    ),
-
-  [TypeDefInfo.Si]: (registry: Registry, value: TypeDef): CodecClass<Codec> =>
-    getTypeClass(registry, registry.lookup.getTypeDef(value.type as LookupString)),
-
-  [TypeDefInfo.Struct]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
-    Struct.with(getTypeClassMap(value), value.alias),
-
-  [TypeDefInfo.Tuple]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
-    Tuple.with(getTypeClassArray(value)),
-
-  [TypeDefInfo.UInt]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
-    createInt(UInt, value),
-
-  [TypeDefInfo.Vec]: (_registry: Registry, { sub }: TypeDef): CodecClass<Codec> => {
-    if (!sub || Array.isArray(sub)) {
-      throw new Error('Expected type information for vector');
-    }
-
-    return (
-      sub.type === 'u8'
-        ? Bytes
-        : Vec.with(getTypeDefType(sub))
-    );
-  },
-
-  [TypeDefInfo.VecFixed]: (_registry: Registry, { displayName, length, sub }: TypeDef): CodecClass<Codec> => {
-    if (!isNumber(length) || !sub || Array.isArray(sub)) {
-      throw new Error('Expected length & type information for fixed vector');
-    }
-
-    return (
-      sub.type === 'u8'
-        ? U8aFixed.with((length * 8) as U8aBitLength, displayName)
-        : VecFixed.with(getTypeDefType(sub), length)
-    );
-  },
-
-  [TypeDefInfo.WrapperKeepOpaque]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
-    createWithSub(WrapperKeepOpaque, value),
-
-  [TypeDefInfo.WrapperOpaque]: (_registry: Registry, value: TypeDef): CodecClass<Codec> =>
-    createWithSub(WrapperOpaque, value)
-};
-
-export function constructTypeClass<T extends Codec = Codec> (registry: Registry, typeDef: TypeDef): CodecClass<T> {
-  try {
-    const Type = infoMapping[typeDef.info](registry, typeDef);
-
-    if (!Type) {
-      throw new Error('No class created');
-    }
-
-    // don't clobber any existing
-    if (!Type.__fallbackType && typeDef.fallbackType) {
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore ...this is the only place we we actually assign this...
-      Type.__fallbackType = typeDef.fallbackType;
-    }
-
-    return Type as CodecClass<T>;
-  } catch (error) {
-    throw new Error(`Unable to construct class from ${stringify(typeDef)}: ${(error as Error).message}`);
-  }
-}
-
-export function getTypeClass<T extends Codec = Codec> (registry: Registry, typeDef: TypeDef): CodecClass<T> {
-  return registry.getUnsafe(typeDef.type, false, typeDef) as unknown as CodecClass<T>;
-}
-
-export function createClassUnsafe<T extends Codec = Codec, K extends string = string> (registry: Registry, type: K): CodecClass<T> {
-  return (
-    // just retrieve via name, no creation via typeDef
-    registry.getUnsafe(type) ||
-    // we don't have an existing type, create the class via typeDef
-    getTypeClass(
-      registry,
-      registry.isLookupType(type)
-        ? registry.lookup.getTypeDef(type)
-        : getTypeDef(type)
-    )
-  );
-}

package/build-deno/create/index.ts

@@ -1,3 +0,0 @@
-
-export * from './class.ts';
-export * from './type.ts';

package/build-deno/create/type.ts

@@ -1,85 +0,0 @@
-
-import type { Bytes } from 'https://deno.land/x/pezkuwi/types-codec/mod.ts';
-import type { Codec, CodecClass, IU8a, Registry } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
-import type { CreateOptions } from '../types/index.ts';
-
-import { Option } from 'https://deno.land/x/pezkuwi/types-codec/mod.ts';
-import { isHex, isU8a, u8aEq, u8aToHex, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { createClassUnsafe } from './class.ts';
-
-function checkInstance (created: Codec, matcher: Uint8Array): void {
-  const u8a = created.toU8a();
-  const rawType = created.toRawType();
-  const isOk = (
-    // full match, all ok
-    u8aEq(u8a, matcher) ||
-    (
-      // on a length-prefixed type, just check the actual length
-      ['Bytes', 'Text', 'Type'].includes(rawType) &&
-      matcher.length === (created as unknown as Bytes).length
-    ) ||
-    (
-      // when the created is empty and matcher is also empty, let it slide...
-      created.isEmpty &&
-      matcher.every((v) => !v)
-    )
-  );
-
-  if (!isOk) {
-    throw new Error(`${rawType}:: Decoded input doesn't match input, received ${u8aToHex(matcher, 512)} (${matcher.length} bytes), created ${u8aToHex(u8a, 512)} (${u8a.length} bytes)`);
-  }
-}
-
-function checkPedantic (created: Codec, [value]: unknown[]): void {
-  if (isU8a(value)) {
-    checkInstance(created, value);
-  } else if (isHex(value)) {
-    checkInstance(created, u8aToU8a(value));
-  }
-}
-
-function initType<T extends Codec> (registry: Registry, Type: CodecClass, params: unknown[] = [], { blockHash, isFallback, isOptional, isPedantic }: CreateOptions = {}): T {
-  const created = new (
-    isOptional
-      ? Option.with(Type)
-      : Type
-  )(registry, ...params);
-
-  isPedantic && checkPedantic(created, params);
-
-  if (blockHash) {
-    created.createdAtHash = createTypeUnsafe<IU8a>(registry, 'BlockHash', [blockHash]);
-  }
-
-  if (isFallback) {
-    created.isStorageFallback = true;
-  }
-
-  return created as T;
-}
-
-export function createTypeUnsafe<T extends Codec = Codec, K extends string = string> (registry: Registry, type: K, params: unknown[] = [], options: CreateOptions = {}): T {
-  let Clazz: CodecClass | null = null;
-  let firstError: Error | null = null;
-
-  try {
-    Clazz = createClassUnsafe(registry, type);
-
-    return initType(registry, Clazz, params, options);
-  } catch (error) {
-    firstError = new Error(`createType(${type}):: ${(error as Error).message}`);
-  }
-
-  if (Clazz?.__fallbackType) {
-    try {
-      Clazz = createClassUnsafe(registry, Clazz.__fallbackType as unknown as K);
-
-      return initType(registry, Clazz, params, options);
-    } catch {
-      // swallow, we will throw the first error again
-    }
-  }
-
-  throw firstError;
-}

package/build-deno/exports.ts

@@ -1,3 +0,0 @@
-
-export * from './create/index.ts';
-export * from './util/index.ts';

package/build-deno/index.ts

@@ -1,4 +0,0 @@
-
-import './packageDetect.ts';
-
-export * from './bundle.ts';

package/build-deno/mod.ts

@@ -1,2 +0,0 @@
-
-export * from './index.ts';

package/build-deno/packageDetect.ts

@@ -1,8 +0,0 @@
-
-
-import { packageInfo as codecInfo } from 'https://deno.land/x/pezkuwi/types-codec/packageInfo.ts';
-import { detectPackage } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { packageInfo } from './packageInfo.ts';
-
-detectPackage(packageInfo, null, [codecInfo]);

package/build-deno/packageInfo.ts

@@ -1,3 +0,0 @@
-
-
-export const packageInfo = { name: '@pezkuwi/types-create', path: new URL(import.meta.url).pathname, type: 'deno', version: '16.5.8' };

package/build-deno/types/augmentRegistry.ts

@@ -1,15 +0,0 @@
-
-import 'https://deno.land/x/pezkuwi/types-codec/types/registry.ts';
-
-import type { Codec, CodecClass, ICompact, INumber, LookupString } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
-import type { ILookup, TypeDef } from 'https://deno.land/x/pezkuwi/types-create/types/index.ts';
-
-declare module 'https://deno.land/x/pezkuwi/types-codec/types/registry.ts' {
-  interface Registry {
-    readonly lookup: ILookup;
-
-    createLookupType (lookupId: ICompact<INumber> | number): LookupString;
-    getUnsafe <T extends Codec = Codec, K extends string = string> (name: K, withUnknown?: boolean, knownTypeDef?: TypeDef): CodecClass<T> | undefined;
-    setLookup (lookup: ILookup): void;
-  }
-}

package/build-deno/types/index.ts

@@ -1,7 +0,0 @@
-
-import './augmentRegistry.ts';
-
-export type { CodecCreateOptions as CreateOptions } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
-
-export * from './lookup.ts';
-export * from './types.ts';

package/build-deno/types/lookup.ts

@@ -1,16 +0,0 @@
-
-import type { Option, Text } from 'https://deno.land/x/pezkuwi/types-codec/mod.ts';
-import type { ICompact, INumber, LookupString } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
-import type { TypeDef } from './types.ts';
-
-interface SiTypeBase {
-  def: {
-    asTuple: ICompact<INumber>[]
-  }
-}
-
-export interface ILookup {
-  getSiType (lookupId: ICompact<INumber> | LookupString | number): SiTypeBase;
-  getTypeDef (lookupId: ICompact<INumber> | LookupString | number): TypeDef;
-  sanitizeField (name: Option<Text>): [string | null, string | null];
-}

package/build-deno/types/types.ts

@@ -1,45 +0,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/build-deno/util/encodeTypes.ts

@@ -1,201 +0,0 @@
-
-import type { Registry } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
-import type { TypeDef } from 'https://deno.land/x/pezkuwi/types-create/types/index.ts';
-
-import { isNumber, isUndefined, objectSpread, stringify } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { TypeDefInfo } from '../types/index.ts';
-
-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
-  );
-}
-
-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)
-  });
-}