Fix typegen adding invalid imports (#6082)

* ignore Unused types

* add ignoreUnusedLookups to other generate functionalities

* lint

packages/typegen/src/generate/consts.ts

@@ -13,6 +13,7 @@ import lookupDefinitions from '@polkadot/types-augment/lookup/definitions';
 import { stringCamelCase } from '@polkadot/util';
 
 import { compareName, createImports, formatType, initMeta, readTemplate, setImports, writeFile } from '../util/index.js';
+import { ignoreUnusedLookups } from './lookup.js';
 
 const generateForMetaTemplate = Handlebars.compile(readTemplate('consts'));
 
@@ -34,6 +35,7 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes,
       return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
     }, {});
     const { lookup, pallets, registry } = meta.asLatest;
+    const usedTypes = new Set<string>([]);
 
     const modules = pallets
       .filter(({ constants }) => constants.length > 0)
@@ -47,6 +49,11 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes,
             const typeDef = lookup.getTypeDef(type);
             const returnType = typeDef.lookupName || formatType(registry, allDefs, typeDef, imports);
 
+            // Add the type to the list of used types
+            if (!(imports.primitiveTypes[returnType])) {
+              usedTypes.add(returnType);
+            }
+
             setImports(allDefs, imports, [returnType]);
 
             return {
@@ -64,6 +71,9 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes,
       })
       .sort(compareName);
 
+    // filter out the unused lookup types from imports
+    ignoreUnusedLookups([...usedTypes], imports);
+
     return generateForMetaTemplate({
       headerType: 'chain',
       imports,

packages/typegen/src/generate/events.ts

@@ -13,6 +13,7 @@ import lookupDefinitions from '@polkadot/types-augment/lookup/definitions';
 import { stringCamelCase } from '@polkadot/util';
 
 import { compareName, createImports, formatType, initMeta, readTemplate, setImports, writeFile } from '../util/index.js';
+import { ignoreUnusedLookups } from './lookup.js';
 
 const generateForMetaTemplate = Handlebars.compile(readTemplate('events'));
 
@@ -78,6 +79,7 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes,
       return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
     }, {});
     const { lookup, pallets, registry } = meta.asLatest;
+    const usedTypes = new Set<string>([]);
     const modules = pallets
       .filter(({ events }) => events.isSome)
       .map(({ events, name }) => ({
@@ -85,7 +87,17 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes,
           .map(({ docs, fields, name }) => {
             const args = fields
               .map(({ type }) => lookup.getTypeDef(type))
-              .map((typeDef) => typeDef.lookupName || formatType(registry, allDefs, typeDef, imports));
+              .map((typeDef) => {
+                const arg = typeDef.lookupName || formatType(registry, allDefs, typeDef, imports);
+
+                // Add the type to the list of used types
+                if (!(imports.primitiveTypes[arg])) {
+                  usedTypes.add(arg);
+                }
+
+                return arg;
+              });
+
             const names = fields
               .map(({ name }) => registry.lookup.sanitizeField(name)[0])
               .filter((n): n is string => !!n);
@@ -105,6 +117,9 @@ function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes,
       }))
       .sort(compareName);
 
+    // filter out the unused lookup types from imports
+    ignoreUnusedLookups([...usedTypes], imports);
+
     return generateForMetaTemplate({
       headerType: 'chain',
       imports,

packages/typegen/src/generate/lookup.ts

@@ -16,7 +16,7 @@ import staticPolkadot from '@polkadot/types-support/metadata/v15/polkadot-hex';
 import staticSubstrate from '@polkadot/types-support/metadata/v15/substrate-hex';
 import { isString, stringify } from '@polkadot/util';
 
-import { createImports, exportInterface, initMeta, readTemplate, writeFile } from '../util/index.js';
+import { createImports, exportInterface, initMeta, readTemplate, type TypeImports, writeFile } from '../util/index.js';
 import { typeEncoders } from './tsDef.js';
 
 // Record<string, >
@@ -275,3 +275,16 @@ export function generateDefaultLookup (destDir = 'packages/types-augment/src/loo
       ]
   );
 }
+
+// Based on a list of types, it filters out the lookup types that are not needed.
+export function ignoreUnusedLookups (usedTypes: string[], imports: TypeImports) {
+  const usedStringified = usedTypes.toString();
+
+  const [lookupKey, typeDefinitions] = Object.entries(imports.localTypes).find(([typeModule, _]) => typeModule.includes('/lookup')) || ['', {}];
+
+  Object.keys(typeDefinitions).forEach((typeDef) => {
+    if (!(usedStringified.includes(typeDef))) {
+      delete (imports.localTypes[lookupKey])[typeDef];
+    }
+  });
+}

packages/typegen/src/generate/query.ts

@@ -5,8 +5,7 @@ import type { StorageEntryMetadataLatest } from '@polkadot/types/interfaces';
 import type { Metadata, PortableRegistry } from '@polkadot/types/metadata';
 import type { Definitions, Registry } from '@polkadot/types/types';
 import type { HexString } from '@polkadot/util/types';
-import type { ModuleTypes } from '../util/imports.js';
-import type { TypeImports } from '../util/index.js';
+import type { ModuleTypes, TypeImports } from '../util/imports.js';
 import type { ExtraTypes } from './types.js';
 
 import Handlebars from 'handlebars';
@@ -17,6 +16,7 @@ import lookupDefinitions from '@polkadot/types-augment/lookup/definitions';
 import { stringCamelCase } from '@polkadot/util';
 
 import { compareName, createImports, formatType, getSimilarTypes, initMeta, readTemplate, setImports, writeFile } from '../util/index.js';
+import { ignoreUnusedLookups } from './lookup.js';
 
 const generateForMetaTemplate = Handlebars.compile(readTemplate('query'));
 
@@ -82,24 +82,28 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr
       ...extraTypes
     };
 
-    // Incorrect type assignment in StagingXcmV4Xcm.
-    // Temporarily ignore this type to prevent import errors.
-    //
-    // See https://github.com/polkadot-js/api/issues/5977
-    // for more details
-    const ignoreTypes = { types: { StagingXcmV4Xcm: undefined } };
-
-    const imports = createImports(allTypes, ignoreTypes);
+    const imports = createImports(allTypes);
     const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => {
       return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
     }, {});
     const { lookup, pallets } = meta.asLatest;
+    const usedTypes = new Set<string>([]);
     const modules = pallets
       .filter(({ storage }) => storage.isSome)
       .map(({ name, storage }) => {
         const items = storage.unwrap().items
           .map((storageEntry) => {
             const [isOptional, args, params, _returnType] = entrySignature(lookup, allDefs, registry, name.toString(), storageEntry, imports);
+
+            // Add the type and args to the list of used types
+            if (!(imports.primitiveTypes[_returnType])) {
+              usedTypes.add(_returnType);
+            }
+
+            if (!(imports.primitiveTypes[args])) {
+              usedTypes.add(args);
+            }
+
             const returnType = isOptional
               ? `Option<${_returnType}>`
               : _returnType;
@@ -124,6 +128,9 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr
 
     imports.typesTypes['Observable'] = true;
 
+    // filter out the unused lookup types from imports
+    ignoreUnusedLookups([...usedTypes], imports);
+
     return generateForMetaTemplate({
       headerType: 'chain',
       imports,

packages/typegen/src/generate/tx.ts

@@ -14,6 +14,7 @@ import lookupDefinitions from '@polkadot/types-augment/lookup/definitions';
 import { stringCamelCase } from '@polkadot/util';
 
 import { compareName, createImports, formatType, getSimilarTypes, initMeta, readTemplate, setImports, writeFile } from '../util/index.js';
+import { ignoreUnusedLookups } from './lookup.js';
 
 const MAPPED_NAMES: Record<string, string> = {
   class: 'clazz',
@@ -46,6 +47,7 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr
       return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
     }, {});
     const { lookup, pallets } = meta.asLatest;
+    const usedTypes = new Set<string>([]);
     const modules = pallets
       .sort(compareName)
       .filter(({ calls }) => calls.isSome)
@@ -76,6 +78,11 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr
 
                 setImports(allDefs, imports, [typeStr, ...similarTypes]);
 
+                // Add the type to the list of used types
+                if (!(imports.primitiveTypes[typeStr])) {
+                  usedTypes.add(typeStr);
+                }
+
                 return `${name}: ${similarTypes.join(' | ')}`;
               })
               .join(', ');
@@ -98,6 +105,9 @@ function generateForMeta (registry: Registry, meta: Metadata, dest: string, extr
       })
       .sort(compareName);
 
+    // filter out the unused lookup types from imports
+    ignoreUnusedLookups([...usedTypes], imports);
+
     return generateForMetaTemplate({
       headerType: 'chain',
       imports,