@dedot/codegen 0.18.8 → 1.0.0

package/chaintypes/generator/ConstsGen.js

@@ -6,7 +6,7 @@ export class ConstsGen extends ApiGen {
     generate(useSubPaths = false) {
         const { pallets } = this.metadata;
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainConsts', 'RpcVersion');
+        this.typesGen.typeImports.addKnownType('GenericChainConsts');
         let defTypeOut = '';
         for (let pallet of pallets) {
             const typedConstants = pallet.constants.map((one) => {

package/chaintypes/generator/ErrorsGen.js

@@ -6,7 +6,7 @@ export class ErrorsGen extends ApiGen {
     generate(useSubPaths = false) {
         const { pallets } = this.metadata;
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainErrors', 'GenericPalletError', 'RpcVersion');
+        this.typesGen.typeImports.addKnownType('GenericChainErrors', 'GenericPalletError');
         let defTypeOut = '';
         for (let pallet of pallets) {
             const errorTypeId = pallet.error;
@@ -25,10 +25,10 @@ export class ErrorsGen extends ApiGen {
                 }
                 return { ...def, docs };
             })
-                .map(({ name, docs }) => `${commentBlock(docs)}${stringPascalCase(name)}: GenericPalletError<Rv>`)
+                .map(({ name, docs }) => `${commentBlock(docs)}${stringPascalCase(name)}: GenericPalletError`)
                 .join(',\n')}
           
-        ${commentBlock('Generic pallet error')}[error: string]: GenericPalletError<Rv>,
+        ${commentBlock('Generic pallet error')}[error: string]: GenericPalletError,
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });

package/chaintypes/generator/EventsGen.js

@@ -6,7 +6,7 @@ export class EventsGen extends ApiGen {
     generate(useSubPaths = false) {
         const { pallets } = this.metadata;
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainEvents', 'GenericPalletEvent', 'RpcVersion');
+        this.typesGen.typeImports.addKnownType('GenericChainEvents', 'GenericPalletEvent');
         let defTypeOut = '';
         for (let pallet of pallets) {
             const eventTypeId = pallet.event;
@@ -34,10 +34,10 @@ export class EventsGen extends ApiGen {
                 }
                 return { ...def, genericParts, docs };
             })
-                .map(({ name, docs, genericParts }) => `${commentBlock(docs)}${stringPascalCase(name)}: GenericPalletEvent<Rv, ${genericParts.join(', ')}>`)
+                .map(({ name, docs, genericParts }) => `${commentBlock(docs)}${stringPascalCase(name)}: GenericPalletEvent<${genericParts.join(', ')}>`)
                 .join(',\n')}
           
-        ${commentBlock('Generic pallet event')}[prop: string]: GenericPalletEvent<Rv>,
+        ${commentBlock('Generic pallet event')}[prop: string]: GenericPalletEvent,
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });

package/chaintypes/generator/IndexGen.d.ts

@@ -6,4 +6,5 @@ export declare class IndexGen {
     readonly typesGen: TypesGen;
     constructor(interfaceName: string, runtimeVersion: SubstrateRuntimeVersion, typesGen: TypesGen);
     generate(useSubPaths?: boolean): Promise<string>;
+    private findAssetIdType;
 }

package/chaintypes/generator/IndexGen.js

@@ -12,7 +12,7 @@ export class IndexGen {
         const interfaceName = this.interfaceName;
         // Clear cache and setup type imports
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericSubstrateApi', 'GenericChainKnownTypes', 'RpcLegacy', 'RpcV2', 'RpcVersion');
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi', 'GenericChainKnownTypes');
         // Extract type IDs from metadata.extrinsic
         const { callTypeId, addressTypeId, signatureTypeId, signedExtensions } = this.typesGen.metadata.extrinsic;
         // Generate proper TypeScript types using typeOut format (0, true)
@@ -25,8 +25,10 @@ export class IndexGen {
             const signedExtensionTypes = signedExtensions.map(({ typeId }) => this.typesGen.generateType(typeId, 1, true));
             extraType = `[${signedExtensionTypes.join(', ')}]`;
         }
+        // Generate AssetId type from ChargeAssetTxPayment extension
+        const assetIdType = this.findAssetIdType(signedExtensions) ?? 'undefined';
         // Add generated types to imports
-        const generatedTypes = [runtimeCallType, addressType, signatureType, extraType];
+        const generatedTypes = [runtimeCallType, addressType, signatureType, extraType, assetIdType];
         this.typesGen.addTypeImport(generatedTypes);
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
         const interfaceDocs = commentBlock([
@@ -42,6 +44,36 @@ export class IndexGen {
             signatureType,
             runtimeCallType,
             extraType,
+            assetIdType,
         }));
     }
+    findAssetIdType(signedExtensions) {
+        // Find ChargeAssetTxPayment extension
+        const chargeAssetExt = signedExtensions.find((ext) => ext.ident.endsWith('ChargeAssetTxPayment'));
+        if (!chargeAssetExt)
+            return undefined;
+        try {
+            const extensionTypeDef = this.typesGen.registry.findType(chargeAssetExt.typeId);
+            if (extensionTypeDef.typeDef.type !== 'Struct')
+                return undefined;
+            const assetIdField = extensionTypeDef.typeDef.value.fields.find((f) => f.name === 'asset_id');
+            if (!assetIdField)
+                return undefined;
+            // Check if wrapped in Option - need to unwrap to get inner type
+            const assetIdTypeDef = this.typesGen.registry.findType(assetIdField.typeId);
+            let assetIdTypeId = assetIdField.typeId;
+            // Option is an Enum type with path ['Option']
+            if (assetIdTypeDef.typeDef.type === 'Enum' && assetIdTypeDef.path.join('::') === 'Option') {
+                // Get the inner type from the 'Some' variant
+                const someVariant = assetIdTypeDef.typeDef.value.members.find((m) => m.name === 'Some');
+                if (someVariant && someVariant.fields.length > 0) {
+                    assetIdTypeId = someVariant.fields[0].typeId;
+                }
+            }
+            return this.typesGen.generateType(assetIdTypeId, 1, true);
+        }
+        catch {
+            return undefined;
+        }
+    }
 }

package/chaintypes/generator/JsonRpcGen.js

@@ -42,7 +42,7 @@ export class JsonRpcGen extends ApiGen {
     }
     generate(useSubPaths = false) {
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericJsonRpcApis', 'RpcVersion');
+        this.typesGen.typeImports.addKnownType('GenericJsonRpcApis');
         this.typesGen.typeImports.addKnownJsonRpcType('JsonRpcApis');
         const toExclude = Object.values(subscriptionsInfo).flat();
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });

package/chaintypes/generator/QueryGen.js

@@ -6,7 +6,7 @@ export class QueryGen extends ApiGen {
     generate(useSubPaths = false) {
         const { pallets } = this.metadata;
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainStorage', 'GenericStorageQuery', 'Callback', 'RpcVersion');
+        this.typesGen.typeImports.addKnownType('GenericChainStorage', 'GenericStorageQuery', 'Callback');
         let defTypeOut = '';
         for (let pallet of pallets) {
             const storage = pallet.storage;
@@ -15,17 +15,17 @@ export class QueryGen extends ApiGen {
             const queries = storage.entries.map((one) => this.#generateEntry(one));
             const queryDefs = queries.map(({ name, valueType, keyType, docs, keyTypeOut }) => {
                 if (keyTypeOut) {
-                    return `${commentBlock(docs)}${name}: GenericStorageQuery<Rv, (${keyType}) => ${valueType}, ${keyTypeOut}>`;
+                    return `${commentBlock(docs)}${name}: GenericStorageQuery<(${keyType}) => ${valueType}, ${keyTypeOut}>`;
                 }
                 else {
-                    return `${commentBlock(docs)}${name}: GenericStorageQuery<Rv, (${keyType}) => ${valueType}>`;
+                    return `${commentBlock(docs)}${name}: GenericStorageQuery<(${keyType}) => ${valueType}>`;
                 }
             });
             defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s storage queries`);
             defTypeOut += `${stringCamelCase(pallet.name)}: {
         ${queryDefs.join(',\n')}
         
-        ${commentBlock('Generic pallet storage query')}[storage: string]: GenericStorageQuery<Rv>;
+        ${commentBlock('Generic pallet storage query')}[storage: string]: GenericStorageQuery;
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });

package/chaintypes/generator/RuntimeApisGen.js

@@ -14,7 +14,7 @@ export class RuntimeApisGen extends ApiGen {
     }
     generate(useSubPaths = false) {
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericRuntimeApis', 'GenericRuntimeApiMethod', 'RpcVersion');
+        this.typesGen.typeImports.addKnownType('GenericRuntimeApis', 'GenericRuntimeApiMethod');
         let runtimeCallsOut = '';
         if (this.metadata.apis.length > 0) {
             this.metadata.apis.forEach((runtimeApi) => {
@@ -23,7 +23,7 @@ export class RuntimeApisGen extends ApiGen {
                 runtimeCallsOut += `${stringCamelCase(runtimeApiName)}: {
             ${methods.map((method) => this.#generateMethodDef(runtimeApiName, method)).join('\n')} 
               
-            ${commentBlock('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod<Rv>
+            ${commentBlock('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod
         }`;
             });
         }
@@ -40,7 +40,7 @@ export class RuntimeApisGen extends ApiGen {
                 }))
                     .join('\n')} 
               
-            ${commentBlock('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod<Rv>
+            ${commentBlock('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod
           }`;
             });
         }
@@ -69,7 +69,7 @@ export class RuntimeApisGen extends ApiGen {
             .map(({ name, isOptional, plainType }) => `${stringCamelCase(name)}${isOptional ? '?' : ''}: ${plainType}`)
             .join(', ');
         const typeOut = this.#getGeneratedTypeName(type, false);
-        return `${commentBlock(docs, '\n', defaultDocs, typedParams.map(({ plainType, name }) => `@param {${plainType}} ${name}`))}${methodName}: GenericRuntimeApiMethod<Rv, (${paramsOut}) => Promise<${typeOut}>>`;
+        return `${commentBlock(docs, '\n', defaultDocs, typedParams.map(({ plainType, name }) => `@param {${plainType}} ${name}`))}${methodName}: GenericRuntimeApiMethod<(${paramsOut}) => Promise<${typeOut}>>`;
     }
     #generateMethodDef(runtimeApiName, methodDef) {
         const { name: methodName, inputs, output, docs, deprecationInfo } = methodDef;
@@ -94,7 +94,7 @@ export class RuntimeApisGen extends ApiGen {
         const paramsOut = typedInputs
             .map(({ name, type, isOptional }) => `${stringCamelCase(name)}${isOptional ? '?' : ''}: ${type}`)
             .join(', ');
-        return `${commentBlock(docs, '\n', defaultDocs, typedInputs.map(({ type, name }) => `@param {${type}} ${name}`), deprecationComments)}${stringCamelCase(methodName)}: GenericRuntimeApiMethod<Rv, (${paramsOut}) => Promise<${typeOut}>>`;
+        return `${commentBlock(docs, '\n', defaultDocs, typedInputs.map(({ type, name }) => `@param {${type}} ${name}`), deprecationComments)}${stringCamelCase(methodName)}: GenericRuntimeApiMethod<(${paramsOut}) => Promise<${typeOut}>>`;
     }
     #targetRuntimeApiSpecs() {
         const specs = Object.entries(this.runtimeApis).map(([runtimeApiHash, version]) => {

package/chaintypes/generator/TxGen.js

@@ -5,7 +5,7 @@ export class TxGen extends ApiGen {
     generate(useSubPaths = false) {
         const { pallets, types } = this.metadata;
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainTx', 'GenericTxCall', 'ISubmittableExtrinsic', 'ISubmittableResult', 'IRuntimeTxCall', 'RpcVersion', 'RpcV2', 'ISubmittableExtrinsicLegacy');
+        this.typesGen.typeImports.addKnownType('GenericChainTx', 'GenericTxCall', 'GenericChainKnownTypes', 'ISubmittableExtrinsic', 'ISubmittableResult', 'IRuntimeTxCall');
         const { callTypeId, addressTypeId, signatureTypeId } = this.metadata.extrinsic;
         const callTypeIn = this.typesGen.generateType(callTypeId, 1);
         const addressTypeIn = this.typesGen.generateType(addressTypeId, 1);
@@ -47,23 +47,19 @@ export class TxGen extends ApiGen {
                 if (deprecationComments.length > 0) {
                     deprecationComments.unshift('\n');
                 }
-                return `${commentBlock(docs, '\n', params.map((p) => `@param {${p.type}} ${p.normalizedName} ${p.docs}`), deprecationComments)}${functionName}: GenericTxCall<Rv, (${params.map((p) => `${p.normalizedName}: ${p.type}`).join(', ')}) => ChainSubmittableExtrinsic<Rv, ${callInput}>>`;
+                return `${commentBlock(docs, '\n', params.map((p) => `@param {${p.type}} ${p.normalizedName} ${p.docs}`), deprecationComments)}${functionName}: GenericTxCall<(${params.map((p) => `${p.normalizedName}: ${p.type}`).join(', ')}) => ChainSubmittableExtrinsic<${callInput}, ChainKnownTypes>>`;
             })
                 .join(',\n')}
             
-          ${commentBlock('Generic pallet tx call')}[callName: string]: GenericTxCall<Rv, TxCall<Rv>>,
+          ${commentBlock('Generic pallet tx call')}[callName: string]: GenericTxCall<TxCall<ChainKnownTypes>>,
         },`;
         }
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
-        // TODO make explicit separate type for Extra
         const defTypes = `
-    export type ChainSubmittableExtrinsic<Rv extends RpcVersion, T extends IRuntimeTxCall = ${callTypeIn}> = 
-        Extrinsic<${addressTypeIn}, T, ${signatureTypeIn}, any[]> &
-        (Rv extends RpcV2
-          ? ISubmittableExtrinsic<ISubmittableResult<FrameSystemEventRecord>>
-          : ISubmittableExtrinsicLegacy<ISubmittableResult<FrameSystemEventRecord>>)
+    export type ChainSubmittableExtrinsic<T extends IRuntimeTxCall = ${callTypeIn}, ChainKnownTypes extends GenericChainKnownTypes = GenericChainKnownTypes> = 
+        Extrinsic<${addressTypeIn}, T, ${signatureTypeIn}, ChainKnownTypes['Extra']> & ISubmittableExtrinsic<ISubmittableResult<FrameSystemEventRecord>, ChainKnownTypes['AssetId']>
         
-    export type TxCall<Rv extends RpcVersion> = (...args: any[]) => ChainSubmittableExtrinsic<Rv>;    
+    export type TxCall<ChainKnownTypes extends GenericChainKnownTypes = GenericChainKnownTypes> = (...args: any[]) => ChainSubmittableExtrinsic<${callTypeIn}, ChainKnownTypes>;    
 `;
         const template = compileTemplate('chaintypes/templates/tx.hbs');
         return beautifySourceCode(template({ importTypes, defTypes, txDefsOut }));

package/chaintypes/generator/ViewFunctionsGen.js

@@ -7,7 +7,7 @@ export class ViewFunctionsGen extends ApiGen {
         const { pallets } = this.metadata;
         this.typesGen.clearCache();
         this.typesGen.typeImports.addKnownType('GenericChainViewFunctions', // --
-        'GenericViewFunction', 'RpcVersion');
+        'GenericViewFunction');
         let defTypeOut = '';
         for (let pallet of pallets) {
             if (!pallet.viewFunctions || pallet.viewFunctions.length === 0)
@@ -24,13 +24,13 @@ export class ViewFunctionsGen extends ApiGen {
                 }
                 const params = vf.inputs.map((input) => `${stringCamelCase(input.name)}: ${this.typesGen.generateType(input.typeId, 1)}`);
                 const outputType = this.typesGen.generateType(vf.output, 1, true);
-                return `${commentBlock(docs)}${stringCamelCase(vf.name)}: GenericViewFunction<Rv, (${params.join(', ')}) => Promise<${outputType}>>`;
+                return `${commentBlock(docs)}${stringCamelCase(vf.name)}: GenericViewFunction<(${params.join(', ')}) => Promise<${outputType}>>`;
             });
             defTypeOut += commentBlock(`Pallet \`${pallet.name}\`'s view functions`);
             defTypeOut += `${stringCamelCase(pallet.name)}: {
         ${viewFns.join(',\n')}
         
-        ${commentBlock('Generic pallet view function')}[name: string]: GenericViewFunction<Rv>;
+        ${commentBlock('Generic pallet view function')}[name: string]: GenericViewFunction;
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });

package/chaintypes/index.d.ts

@@ -1,5 +1,24 @@
-import { SubstrateRuntimeVersion } from '@dedot/api';
+import { DedotClient, SubstrateRuntimeVersion } from '@dedot/api';
 import { MetadataLatest } from '@dedot/codecs';
 import { GeneratedResult } from '../types.js';
-export declare function generateTypesFromEndpoint(chain: string, endpoint: string, outDir?: string, extension?: string, useSubPaths?: boolean): Promise<GeneratedResult>;
-export declare function generateTypes(chain: string, metadata: MetadataLatest, rpcMethods: string[], runtimeVersion: SubstrateRuntimeVersion, outDir?: string, extension?: string, useSubPaths?: boolean): Promise<GeneratedResult>;
+export interface GenerateTypesFromEndpointOptions {
+    chain: string;
+    endpoint?: string;
+    client?: DedotClient;
+    outDir?: string;
+    extension?: string;
+    useSubPaths?: boolean;
+    at?: string;
+}
+export declare function generateTypesFromEndpoint(options: GenerateTypesFromEndpointOptions): Promise<GeneratedResult>;
+export interface GenerateTypesOptions {
+    chain: string;
+    metadata: MetadataLatest;
+    rpcMethods: string[];
+    runtimeVersion: SubstrateRuntimeVersion;
+    outDir?: string;
+    extension?: string;
+    useSubPaths?: boolean;
+    appendSpecVersion?: boolean;
+}
+export declare function generateTypes(options: GenerateTypesOptions): Promise<GeneratedResult>;

package/chaintypes/index.js

@@ -1,20 +1,68 @@
-import { LegacyClient } from '@dedot/api';
+import { DedotClient } from '@dedot/api';
 import { WsProvider } from '@dedot/providers';
-import { stringDashCase, stringPascalCase } from '@dedot/utils';
+import { assert, stringDashCase, stringPascalCase } from '@dedot/utils';
 import * as fs from 'fs';
 import * as path from 'path';
+import { resolveBlockHash } from '../utils.js';
 import { ConstsGen, ErrorsGen, EventsGen, IndexGen, JsonRpcGen, QueryGen, RuntimeApisGen, TxGen, ViewFunctionsGen, TypesGen, } from './generator/index.js';
-export async function generateTypesFromEndpoint(chain, endpoint, outDir, extension = 'd.ts', useSubPaths = false) {
-    // Immediately throw error if cannot connect to provider for the first time.
-    const client = await LegacyClient.new(new WsProvider({ endpoint, retryDelayMs: 0, timeout: 0 }));
-    const { methods } = await client.rpc.rpc_methods();
-    chain = chain || client.runtimeVersion.specName || 'local';
-    const result = await generateTypes(chain, client.metadata.latest, methods, client.runtimeVersion, outDir, extension, useSubPaths);
-    await client.disconnect();
-    return result;
+export async function generateTypesFromEndpoint(options) {
+    const { chain, endpoint, client: providedClient, outDir, extension = 'd.ts', useSubPaths = false, at } = options;
+    // Validate that either endpoint or client is provided
+    if (!endpoint && !providedClient) {
+        throw new Error('Either "endpoint" or "client" must be provided');
+    }
+    if (endpoint && providedClient) {
+        throw new Error('Cannot provide both "endpoint" and "client"');
+    }
+    // Create client if not provided
+    const client = providedClient || (await DedotClient.legacy(new WsProvider({ endpoint: endpoint, retryDelayMs: 0, timeout: 0 })));
+    const shouldDisconnect = !providedClient;
+    try {
+        const { methods } = await client.rpc.rpc_methods();
+        // Resolve block hash if `at` is provided
+        let blockHash;
+        if (at) {
+            blockHash = await resolveBlockHash(client, at);
+        }
+        // Get runtime version and metadata at the specified block
+        let runtimeVersion;
+        let metadata;
+        if (blockHash) {
+            // Get the header of the target block
+            const header = await client.block.header(blockHash);
+            assert(`Header not found for block hash: ${blockHash}`);
+            const childBlockHash = await client.rpc.chain_getBlockHash(header.number + 1);
+            const clientAt = await client.at(childBlockHash);
+            runtimeVersion = clientAt.runtimeVersion;
+            metadata = clientAt.metadata;
+        }
+        else {
+            runtimeVersion = client.runtimeVersion;
+            metadata = client.metadata;
+        }
+        const resolvedChain = chain || runtimeVersion.specName || 'local';
+        return await generateTypes({
+            chain: resolvedChain,
+            metadata: metadata.latest,
+            rpcMethods: methods,
+            runtimeVersion,
+            outDir,
+            extension,
+            useSubPaths,
+            appendSpecVersion: !!blockHash,
+        });
+    }
+    finally {
+        if (shouldDisconnect) {
+            await client.disconnect();
+        }
+    }
 }
-export async function generateTypes(chain, metadata, rpcMethods, runtimeVersion, outDir = '.', extension = 'd.ts', useSubPaths = false) {
-    const dirPath = path.resolve(outDir, stringDashCase(chain));
+export async function generateTypes(options) {
+    const { chain, metadata, rpcMethods, runtimeVersion, outDir = '.', extension = 'd.ts', useSubPaths = false, appendSpecVersion = false, } = options;
+    // Build folder suffix with spec version if requested
+    const folderSuffix = appendSpecVersion ? `-${runtimeVersion.specVersion}` : '';
+    const dirPath = path.resolve(outDir, stringDashCase(chain) + folderSuffix);
     const defTypesFileName = path.join(dirPath, `types.${extension}`);
     const constsTypesFileName = path.join(dirPath, `consts.${extension}`);
     const queryTypesFileName = path.join(dirPath, `query.${extension}`);
@@ -28,7 +76,9 @@ export async function generateTypes(chain, metadata, rpcMethods, runtimeVersion,
     if (!fs.existsSync(dirPath)) {
         fs.mkdirSync(dirPath, { recursive: true });
     }
-    const interfaceName = `${stringPascalCase(chain)}Api`;
+    // Build interface suffix with spec version if requested
+    const interfaceSuffix = appendSpecVersion ? runtimeVersion.specVersion : '';
+    const interfaceName = `${stringPascalCase(chain)}Api${interfaceSuffix}`;
     const typesGen = new TypesGen(metadata);
     const constsGen = new ConstsGen(typesGen);
     const queryGen = new QueryGen(typesGen);

package/chaintypes/templates/consts.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ChainConsts<Rv extends RpcVersion> extends GenericChainConsts<Rv> {
+export interface ChainConsts extends GenericChainConsts {
   {{{ defTypeOut }}}
 }

package/chaintypes/templates/errors.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<Rv> {
+export interface ChainErrors extends GenericChainErrors {
   {{{ defTypeOut }}}
 }

package/chaintypes/templates/events.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<Rv> {
+export interface ChainEvents extends GenericChainEvents {
   {{{ defTypeOut }}}
 }

package/chaintypes/templates/index.hbs

@@ -17,22 +17,18 @@ interface ChainKnownTypes extends GenericChainKnownTypes {
   Signature: {{{signatureType}}};
   RuntimeCall: {{{runtimeCallType}}};
   Extra: {{{extraType}}};
+  AssetId: {{{assetIdType}}};
 }
 
-export interface Versioned{{{interfaceName}}}<Rv extends RpcVersion> extends GenericSubstrateApi<Rv> {
-  rpc: ChainJsonRpcApis<Rv>;
-  consts: ChainConsts<Rv>;
-  query: ChainStorage<Rv>;
-  errors: ChainErrors<Rv>;
-  events: ChainEvents<Rv>;
-  call: RuntimeApis<Rv>;
-  view: ChainViewFunctions<Rv>;
-  tx: ChainTx<Rv>;
+{{interfaceDocs}}export interface {{{interfaceName}}} extends GenericSubstrateApi {
+  rpc: ChainJsonRpcApis;
+  consts: ChainConsts;
+  query: ChainStorage;
+  errors: ChainErrors;
+  events: ChainEvents;
+  call: RuntimeApis;
+  view: ChainViewFunctions;
+  tx: ChainTx<ChainKnownTypes>;
   
   types: ChainKnownTypes;
 }
-
-{{interfaceDocs}}export interface {{{interfaceName}}} {
-  legacy: Versioned{{{interfaceName}}}<RpcLegacy>;
-  v2: Versioned{{{interfaceName}}}<RpcV2>;
-}

package/chaintypes/templates/json-rpc.hbs

@@ -2,9 +2,9 @@
 
 {{{ importTypes }}}
 
-export type ChainJsonRpcApis<Rv extends RpcVersion> =
+export type ChainJsonRpcApis =
   {{#if jsonRpcMethods.length}}
-    Pick<JsonRpcApis, {{{jsonRpcMethods}}}> & GenericJsonRpcApis<Rv>;
+    Pick<JsonRpcApis, {{{jsonRpcMethods}}}> & GenericJsonRpcApis;
   {{else}}
-    JsonRpcApis & GenericJsonRpcApis<Rv>;
+    JsonRpcApis & GenericJsonRpcApis;
   {{/if}}

package/chaintypes/templates/query.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ChainStorage<Rv extends RpcVersion> extends GenericChainStorage<Rv> {
+export interface ChainStorage extends GenericChainStorage {
   {{{ defTypeOut }}}
 }

package/chaintypes/templates/runtime.hbs

@@ -2,7 +2,7 @@
 
 {{{ importTypes }}}
 
-export interface RuntimeApis<Rv extends RpcVersion> extends GenericRuntimeApis<Rv> {
+export interface RuntimeApis extends GenericRuntimeApis {
 {{{ runtimeCallsOut }}}
 }
 

package/chaintypes/templates/tx.hbs

@@ -4,6 +4,6 @@
 
 {{{ defTypes }}}
 
-export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCall<Rv>> {
+export interface ChainTx<ChainKnownTypes extends GenericChainKnownTypes = GenericChainKnownTypes> extends GenericChainTx<TxCall<ChainKnownTypes>> {
   {{{ txDefsOut }}}
 }

package/chaintypes/templates/view-functions.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ChainViewFunctions<Rv extends RpcVersion> extends GenericChainViewFunctions<Rv> {
+export interface ChainViewFunctions extends GenericChainViewFunctions {
   {{{ defTypeOut }}}
 }

package/cjs/chaintypes/generator/ConstsGen.js

@@ -9,7 +9,7 @@ class ConstsGen extends ApiGen_js_1.ApiGen {
     generate(useSubPaths = false) {
         const { pallets } = this.metadata;
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainConsts', 'RpcVersion');
+        this.typesGen.typeImports.addKnownType('GenericChainConsts');
         let defTypeOut = '';
         for (let pallet of pallets) {
             const typedConstants = pallet.constants.map((one) => {

package/cjs/chaintypes/generator/ErrorsGen.js

@@ -9,7 +9,7 @@ class ErrorsGen extends ApiGen_js_1.ApiGen {
     generate(useSubPaths = false) {
         const { pallets } = this.metadata;
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainErrors', 'GenericPalletError', 'RpcVersion');
+        this.typesGen.typeImports.addKnownType('GenericChainErrors', 'GenericPalletError');
         let defTypeOut = '';
         for (let pallet of pallets) {
             const errorTypeId = pallet.error;
@@ -28,10 +28,10 @@ class ErrorsGen extends ApiGen_js_1.ApiGen {
                 }
                 return { ...def, docs };
             })
-                .map(({ name, docs }) => `${(0, utils_js_1.commentBlock)(docs)}${(0, utils_1.stringPascalCase)(name)}: GenericPalletError<Rv>`)
+                .map(({ name, docs }) => `${(0, utils_js_1.commentBlock)(docs)}${(0, utils_1.stringPascalCase)(name)}: GenericPalletError`)
                 .join(',\n')}
           
-        ${(0, utils_js_1.commentBlock)('Generic pallet error')}[error: string]: GenericPalletError<Rv>,
+        ${(0, utils_js_1.commentBlock)('Generic pallet error')}[error: string]: GenericPalletError,
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });

package/cjs/chaintypes/generator/EventsGen.js

@@ -9,7 +9,7 @@ class EventsGen extends ApiGen_js_1.ApiGen {
     generate(useSubPaths = false) {
         const { pallets } = this.metadata;
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericChainEvents', 'GenericPalletEvent', 'RpcVersion');
+        this.typesGen.typeImports.addKnownType('GenericChainEvents', 'GenericPalletEvent');
         let defTypeOut = '';
         for (let pallet of pallets) {
             const eventTypeId = pallet.event;
@@ -37,10 +37,10 @@ class EventsGen extends ApiGen_js_1.ApiGen {
                 }
                 return { ...def, genericParts, docs };
             })
-                .map(({ name, docs, genericParts }) => `${(0, utils_js_1.commentBlock)(docs)}${(0, utils_1.stringPascalCase)(name)}: GenericPalletEvent<Rv, ${genericParts.join(', ')}>`)
+                .map(({ name, docs, genericParts }) => `${(0, utils_js_1.commentBlock)(docs)}${(0, utils_1.stringPascalCase)(name)}: GenericPalletEvent<${genericParts.join(', ')}>`)
                 .join(',\n')}
           
-        ${(0, utils_js_1.commentBlock)('Generic pallet event')}[prop: string]: GenericPalletEvent<Rv>,
+        ${(0, utils_js_1.commentBlock)('Generic pallet event')}[prop: string]: GenericPalletEvent,
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });

package/cjs/chaintypes/generator/IndexGen.js

@@ -15,7 +15,7 @@ class IndexGen {
         const interfaceName = this.interfaceName;
         // Clear cache and setup type imports
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericSubstrateApi', 'GenericChainKnownTypes', 'RpcLegacy', 'RpcV2', 'RpcVersion');
+        this.typesGen.typeImports.addKnownType('GenericSubstrateApi', 'GenericChainKnownTypes');
         // Extract type IDs from metadata.extrinsic
         const { callTypeId, addressTypeId, signatureTypeId, signedExtensions } = this.typesGen.metadata.extrinsic;
         // Generate proper TypeScript types using typeOut format (0, true)
@@ -28,8 +28,10 @@ class IndexGen {
             const signedExtensionTypes = signedExtensions.map(({ typeId }) => this.typesGen.generateType(typeId, 1, true));
             extraType = `[${signedExtensionTypes.join(', ')}]`;
         }
+        // Generate AssetId type from ChargeAssetTxPayment extension
+        const assetIdType = this.findAssetIdType(signedExtensions) ?? 'undefined';
         // Add generated types to imports
-        const generatedTypes = [runtimeCallType, addressType, signatureType, extraType];
+        const generatedTypes = [runtimeCallType, addressType, signatureType, extraType, assetIdType];
         this.typesGen.addTypeImport(generatedTypes);
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });
         const interfaceDocs = (0, utils_js_1.commentBlock)([
@@ -45,7 +47,37 @@ class IndexGen {
             signatureType,
             runtimeCallType,
             extraType,
+            assetIdType,
         }));
     }
+    findAssetIdType(signedExtensions) {
+        // Find ChargeAssetTxPayment extension
+        const chargeAssetExt = signedExtensions.find((ext) => ext.ident.endsWith('ChargeAssetTxPayment'));
+        if (!chargeAssetExt)
+            return undefined;
+        try {
+            const extensionTypeDef = this.typesGen.registry.findType(chargeAssetExt.typeId);
+            if (extensionTypeDef.typeDef.type !== 'Struct')
+                return undefined;
+            const assetIdField = extensionTypeDef.typeDef.value.fields.find((f) => f.name === 'asset_id');
+            if (!assetIdField)
+                return undefined;
+            // Check if wrapped in Option - need to unwrap to get inner type
+            const assetIdTypeDef = this.typesGen.registry.findType(assetIdField.typeId);
+            let assetIdTypeId = assetIdField.typeId;
+            // Option is an Enum type with path ['Option']
+            if (assetIdTypeDef.typeDef.type === 'Enum' && assetIdTypeDef.path.join('::') === 'Option') {
+                // Get the inner type from the 'Some' variant
+                const someVariant = assetIdTypeDef.typeDef.value.members.find((m) => m.name === 'Some');
+                if (someVariant && someVariant.fields.length > 0) {
+                    assetIdTypeId = someVariant.fields[0].typeId;
+                }
+            }
+            return this.typesGen.generateType(assetIdTypeId, 1, true);
+        }
+        catch {
+            return undefined;
+        }
+    }
 }
 exports.IndexGen = IndexGen;

package/cjs/chaintypes/generator/JsonRpcGen.js

@@ -45,7 +45,7 @@ class JsonRpcGen extends ApiGen_js_1.ApiGen {
     }
     generate(useSubPaths = false) {
         this.typesGen.clearCache();
-        this.typesGen.typeImports.addKnownType('GenericJsonRpcApis', 'RpcVersion');
+        this.typesGen.typeImports.addKnownType('GenericJsonRpcApis');
         this.typesGen.typeImports.addKnownJsonRpcType('JsonRpcApis');
         const toExclude = Object.values(api_1.subscriptionsInfo).flat();
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });