From a7d826f8397d531fd7930da5185b6f6854f90bbb Mon Sep 17 00:00:00 2001
From: Jaco <jacogr@gmail.com>
Date: Wed, 25 May 2022 14:07:42 +0200
Subject: [PATCH] Optimization for `createClass` with shortcut typeDef creation
 (#4849)

---
 CHANGELOG.md                                      |  7 +++++++
 packages/types-create/src/create/class.ts         | 15 ++++++++++-----
 packages/types-create/src/create/type.ts          | 14 ++++++--------
 packages/types/src/create/registry.ts             |  2 +-
 .../metadata/PortableRegistry/PortableRegistry.ts |  6 ++++--
 5 files changed, 28 insertions(+), 16 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bf2403e751..53604f0936 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,12 @@
 # CHANGELOG
 
+## master
+
+Changes:
+
+- Optimization for `createClass` with shortcut typeDef creation
+
+
 ## 8.5.1 May 22, 2022
 
 Contributed:
diff --git a/packages/types-create/src/create/class.ts b/packages/types-create/src/create/class.ts
index 76e4e81911..efb7f14fba 100644
--- a/packages/types-create/src/create/class.ts
+++ b/packages/types-create/src/create/class.ts
@@ -208,10 +208,15 @@ export function getTypeClass<T extends Codec = Codec> (registry: Registry, typeD
 }
 
 export function createClassUnsafe<T extends Codec = Codec, K extends string = string> (registry: Registry, type: K): CodecClass<T> {
-  return getTypeClass(
-    registry,
-    registry.isLookupType(type)
-      ? registry.lookup.getTypeDef(type)
-      : getTypeDef(type)
+  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)
+    )
   );
 }
diff --git a/packages/types-create/src/create/type.ts b/packages/types-create/src/create/type.ts
index f4dee1d84c..dcc01387ea 100644
--- a/packages/types-create/src/create/type.ts
+++ b/packages/types-create/src/create/type.ts
@@ -32,13 +32,11 @@ function checkInstance (created: Codec, matcher: Uint8Array): void {
   assert(isOk, () => `${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[], isPedantic = false): void {
-  if (isPedantic) {
-    if (isU8a(value)) {
-      checkInstance(created, value);
-    } else if (isHex(value)) {
-      checkInstance(created, u8aToU8a(value));
-    }
+function checkPedantic (created: Codec, [value]: unknown[]): void {
+  if (isU8a(value)) {
+    checkInstance(created, value);
+  } else if (isHex(value)) {
+    checkInstance(created, u8aToU8a(value));
   }
 }
 
@@ -47,7 +45,7 @@ function checkPedantic (created: Codec, [value]: unknown[], isPedantic = false):
 function initType<T extends Codec> (registry: Registry, Type: CodecClass, params: unknown[] = [], { blockHash, isOptional, isPedantic }: CreateOptions = {}): T {
   const created = new (isOptional ? Option.with(Type) : Type)(registry, ...params);
 
-  checkPedantic(created, params, isPedantic);
+  isPedantic && checkPedantic(created, params);
 
   if (blockHash) {
     created.createdAtHash = createTypeUnsafe<IU8a>(registry, 'Hash', [blockHash]);
diff --git a/packages/types/src/create/registry.ts b/packages/types/src/create/registry.ts
index 49bbdeb92f..9624da4a8c 100644
--- a/packages/types/src/create/registry.ts
+++ b/packages/types/src/create/registry.ts
@@ -212,7 +212,7 @@ export class TypeRegistry implements Registry {
   }
 
   /**
-   * @description Returns tru if the type is in a Compat format
+   * @description Returns true if the type is in a Compat format
    */
   public isLookupType (value: string): boolean {
     return /Lookup\d+$/.test(value);
diff --git a/packages/types/src/metadata/PortableRegistry/PortableRegistry.ts b/packages/types/src/metadata/PortableRegistry/PortableRegistry.ts
index 04f23bd325..4e0d015df8 100644
--- a/packages/types/src/metadata/PortableRegistry/PortableRegistry.ts
+++ b/packages/types/src/metadata/PortableRegistry/PortableRegistry.ts
@@ -321,8 +321,9 @@ function extractAliases (params: Record<string, SiTypeParameter[]>, isContract?:
 function extractTypeInfo (lookup: PortableRegistry, portable: PortableType[]): [Record<number, PortableType>, Record<string, string>, Record<number, string>, Record<string, SiTypeParameter[]>] {
   const nameInfo: [number, string, SiTypeParameter[]][] = [];
   const types: Record<number, PortableType> = {};
+  const porCount = portable.length;
 
-  for (let i = 0; i < portable.length; i++) {
+  for (let i = 0; i < porCount; i++) {
     const type = portable[i];
     const extracted = extractName(portable, portable[i]);
 
@@ -337,8 +338,9 @@ function extractTypeInfo (lookup: PortableRegistry, portable: PortableType[]): [
   const lookups: Record<string, string> = {};
   const names: Record<number, string> = {};
   const params: Record<string, SiTypeParameter[]> = {};
+  const dupCount = dedup.length;
 
-  for (let i = 0; i < dedup.length; i++) {
+  for (let i = 0; i < dupCount; i++) {
     const [lookupIndex, name, p] = dedup[i];
 
     names[lookupIndex] = name;