@dedot/codegen 0.18.8 → 1.0.0

package/cjs/chaintypes/generator/QueryGen.js

@@ -9,7 +9,7 @@ class QueryGen extends ApiGen_js_1.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;
@@ -18,17 +18,17 @@ class QueryGen extends ApiGen_js_1.ApiGen {
             const queries = storage.entries.map((one) => this.#generateEntry(one));
             const queryDefs = queries.map(({ name, valueType, keyType, docs, keyTypeOut }) => {
                 if (keyTypeOut) {
-                    return `${(0, utils_js_1.commentBlock)(docs)}${name}: GenericStorageQuery<Rv, (${keyType}) => ${valueType}, ${keyTypeOut}>`;
+                    return `${(0, utils_js_1.commentBlock)(docs)}${name}: GenericStorageQuery<(${keyType}) => ${valueType}, ${keyTypeOut}>`;
                 }
                 else {
-                    return `${(0, utils_js_1.commentBlock)(docs)}${name}: GenericStorageQuery<Rv, (${keyType}) => ${valueType}>`;
+                    return `${(0, utils_js_1.commentBlock)(docs)}${name}: GenericStorageQuery<(${keyType}) => ${valueType}>`;
                 }
             });
             defTypeOut += (0, utils_js_1.commentBlock)(`Pallet \`${pallet.name}\`'s storage queries`);
             defTypeOut += `${(0, utils_1.stringCamelCase)(pallet.name)}: {
         ${queryDefs.join(',\n')}
         
-        ${(0, utils_js_1.commentBlock)('Generic pallet storage query')}[storage: string]: GenericStorageQuery<Rv>;
+        ${(0, utils_js_1.commentBlock)('Generic pallet storage query')}[storage: string]: GenericStorageQuery;
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });

package/cjs/chaintypes/generator/RuntimeApisGen.js

@@ -17,7 +17,7 @@ class RuntimeApisGen extends ApiGen_js_1.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) => {
@@ -26,7 +26,7 @@ class RuntimeApisGen extends ApiGen_js_1.ApiGen {
                 runtimeCallsOut += `${(0, utils_1.stringCamelCase)(runtimeApiName)}: {
             ${methods.map((method) => this.#generateMethodDef(runtimeApiName, method)).join('\n')} 
               
-            ${(0, utils_js_1.commentBlock)('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod<Rv>
+            ${(0, utils_js_1.commentBlock)('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod
         }`;
             });
         }
@@ -43,7 +43,7 @@ class RuntimeApisGen extends ApiGen_js_1.ApiGen {
                 }))
                     .join('\n')} 
               
-            ${(0, utils_js_1.commentBlock)('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod<Rv>
+            ${(0, utils_js_1.commentBlock)('Generic runtime api call')}[method: string]: GenericRuntimeApiMethod
           }`;
             });
         }
@@ -72,7 +72,7 @@ class RuntimeApisGen extends ApiGen_js_1.ApiGen {
             .map(({ name, isOptional, plainType }) => `${(0, utils_1.stringCamelCase)(name)}${isOptional ? '?' : ''}: ${plainType}`)
             .join(', ');
         const typeOut = this.#getGeneratedTypeName(type, false);
-        return `${(0, utils_js_1.commentBlock)(docs, '\n', defaultDocs, typedParams.map(({ plainType, name }) => `@param {${plainType}} ${name}`))}${methodName}: GenericRuntimeApiMethod<Rv, (${paramsOut}) => Promise<${typeOut}>>`;
+        return `${(0, utils_js_1.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;
@@ -97,7 +97,7 @@ class RuntimeApisGen extends ApiGen_js_1.ApiGen {
         const paramsOut = typedInputs
             .map(({ name, type, isOptional }) => `${(0, utils_1.stringCamelCase)(name)}${isOptional ? '?' : ''}: ${type}`)
             .join(', ');
-        return `${(0, utils_js_1.commentBlock)(docs, '\n', defaultDocs, typedInputs.map(({ type, name }) => `@param {${type}} ${name}`), deprecationComments)}${(0, utils_1.stringCamelCase)(methodName)}: GenericRuntimeApiMethod<Rv, (${paramsOut}) => Promise<${typeOut}>>`;
+        return `${(0, utils_js_1.commentBlock)(docs, '\n', defaultDocs, typedInputs.map(({ type, name }) => `@param {${type}} ${name}`), deprecationComments)}${(0, utils_1.stringCamelCase)(methodName)}: GenericRuntimeApiMethod<(${paramsOut}) => Promise<${typeOut}>>`;
     }
     #targetRuntimeApiSpecs() {
         const specs = Object.entries(this.runtimeApis).map(([runtimeApiHash, version]) => {

package/cjs/chaintypes/generator/TxGen.js

@@ -8,7 +8,7 @@ class TxGen extends index_js_1.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);
@@ -50,23 +50,19 @@ class TxGen extends index_js_1.ApiGen {
                 if (deprecationComments.length > 0) {
                     deprecationComments.unshift('\n');
                 }
-                return `${(0, utils_js_1.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 `${(0, utils_js_1.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')}
             
-          ${(0, utils_js_1.commentBlock)('Generic pallet tx call')}[callName: string]: GenericTxCall<Rv, TxCall<Rv>>,
+          ${(0, utils_js_1.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 = (0, utils_js_1.compileTemplate)('chaintypes/templates/tx.hbs');
         return (0, utils_js_1.beautifySourceCode)(template({ importTypes, defTypes, txDefsOut }));

package/cjs/chaintypes/generator/ViewFunctionsGen.js

@@ -10,7 +10,7 @@ class ViewFunctionsGen extends ApiGen_js_1.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)
@@ -27,13 +27,13 @@ class ViewFunctionsGen extends ApiGen_js_1.ApiGen {
                 }
                 const params = vf.inputs.map((input) => `${(0, utils_1.stringCamelCase)(input.name)}: ${this.typesGen.generateType(input.typeId, 1)}`);
                 const outputType = this.typesGen.generateType(vf.output, 1, true);
-                return `${(0, utils_js_1.commentBlock)(docs)}${(0, utils_1.stringCamelCase)(vf.name)}: GenericViewFunction<Rv, (${params.join(', ')}) => Promise<${outputType}>>`;
+                return `${(0, utils_js_1.commentBlock)(docs)}${(0, utils_1.stringCamelCase)(vf.name)}: GenericViewFunction<(${params.join(', ')}) => Promise<${outputType}>>`;
             });
             defTypeOut += (0, utils_js_1.commentBlock)(`Pallet \`${pallet.name}\`'s view functions`);
             defTypeOut += `${(0, utils_1.stringCamelCase)(pallet.name)}: {
         ${viewFns.join(',\n')}
         
-        ${(0, utils_js_1.commentBlock)('Generic pallet view function')}[name: string]: GenericViewFunction<Rv>;
+        ${(0, utils_js_1.commentBlock)('Generic pallet view function')}[name: string]: GenericViewFunction;
       },`;
         }
         const importTypes = this.typesGen.typeImports.toImports({ useSubPaths });

package/cjs/chaintypes/index.js

@@ -29,19 +29,67 @@ const providers_1 = require("@dedot/providers");
 const utils_1 = require("@dedot/utils");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const utils_js_1 = require("../utils.js");
 const index_js_1 = require("./generator/index.js");
-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 api_1.LegacyClient.new(new providers_1.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;
+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 api_1.DedotClient.legacy(new providers_1.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 (0, utils_js_1.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);
+            (0, utils_1.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();
+        }
+    }
 }
 exports.generateTypesFromEndpoint = generateTypesFromEndpoint;
-async function generateTypes(chain, metadata, rpcMethods, runtimeVersion, outDir = '.', extension = 'd.ts', useSubPaths = false) {
-    const dirPath = path.resolve(outDir, (0, utils_1.stringDashCase)(chain));
+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, (0, utils_1.stringDashCase)(chain) + folderSuffix);
     const defTypesFileName = path.join(dirPath, `types.${extension}`);
     const constsTypesFileName = path.join(dirPath, `consts.${extension}`);
     const queryTypesFileName = path.join(dirPath, `query.${extension}`);
@@ -55,7 +103,9 @@ async function generateTypes(chain, metadata, rpcMethods, runtimeVersion, outDir
     if (!fs.existsSync(dirPath)) {
         fs.mkdirSync(dirPath, { recursive: true });
     }
-    const interfaceName = `${(0, utils_1.stringPascalCase)(chain)}Api`;
+    // Build interface suffix with spec version if requested
+    const interfaceSuffix = appendSpecVersion ? runtimeVersion.specVersion : '';
+    const interfaceName = `${(0, utils_1.stringPascalCase)(chain)}Api${interfaceSuffix}`;
     const typesGen = new index_js_1.TypesGen(metadata);
     const constsGen = new index_js_1.ConstsGen(typesGen);
     const queryGen = new index_js_1.QueryGen(typesGen);

package/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/index.js

@@ -14,7 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBlockHash = void 0;
 __exportStar(require("./types.js"), exports);
 __exportStar(require("./chaintypes/index.js"), exports);
 __exportStar(require("./typink/index.js"), exports);
 __exportStar(require("./sol/index.js"), exports);
+var utils_js_1 = require("./utils.js");
+Object.defineProperty(exports, "resolveBlockHash", { enumerable: true, get: function () { return utils_js_1.resolveBlockHash; } });

package/cjs/sol/generator/ConstructorQueryGen.js

@@ -32,7 +32,7 @@ class ConstructorQueryGen {
     }
     generateMethodDef(abiItem, optionsParamName = 'options') {
         const paramsOut = this.generateParamsOut(abiItem);
-        return `GenericConstructorQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorCallOptions) => Promise<GenericConstructorCallResult<[], ContractInstantiateResult<ChainApi>>>, Type>`;
+        return `GenericConstructorQueryCall<(${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorCallOptions) => Promise<GenericConstructorCallResult<[], ContractInstantiateResult>>, Type>`;
     }
     generateParamsOut(abiItem) {
         return abiItem.inputs

package/cjs/sol/generator/ConstructorTxGen.js

@@ -16,7 +16,7 @@ class ConstructorTxGen extends ConstructorQueryGen_js_1.ConstructorQueryGen {
     }
     generateMethodDef(abiItem, optionsParamName = 'options') {
         const paramsOut = this.generateParamsOut(abiItem);
-        return `GenericConstructorTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorTxOptions) => GenericInstantiateSubmittableExtrinsic<ChainApi, ContractApi>, Type>`;
+        return `GenericConstructorTxCall<(${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorTxOptions) => GenericInstantiateSubmittableExtrinsic<ContractApi>, Type>`;
     }
 }
 exports.ConstructorTxGen = ConstructorTxGen;

package/cjs/sol/generator/IndexGen.js

@@ -13,7 +13,7 @@ class IndexGen {
     generate(useSubPaths = false) {
         const interfaceName = this.interfaceName;
         const typeImports = new index_js_1.TypeImports();
-        typeImports.addKnownType('VersionedGenericSubstrateApi', 'RpcVersion', 'RpcV2');
+        typeImports.addKnownType('GenericSubstrateApi', 'RpcVersion', 'RpcV2');
         typeImports.addContractType('SolGenericContractApi', 'SolRegistry');
         typeImports.addChainType('SubstrateApi');
         const importTypes = typeImports.toImports({ useSubPaths });

package/cjs/sol/generator/QueryGen.js

@@ -39,7 +39,7 @@ class QueryGen {
         const typeOutInner = `${outputs.map((o) => this.typesGen.generateType(o, abiItem, 1, true)).join(',')}`;
         // If there is only one output, we don't need to wrap it in a tuple, for user-friendly
         const typeOut = outputs.length === 1 ? typeOutInner : `[${typeOutInner}]`;
-        return `GenericContractQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult<ChainApi>>>, Type>`;
+        return `GenericContractQueryCall<(${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult>>, Type>`;
     }
     generateParamsOut(abiItem) {
         return abiItem.inputs

package/cjs/sol/generator/TxGen.js

@@ -16,7 +16,7 @@ class TxGen extends QueryGen_js_1.QueryGen {
     }
     generateMethodDef(abiItem, optionsParamName = 'options') {
         const paramsOut = this.generateParamsOut(abiItem);
-        return `GenericContractTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractTxOptions) => ContractSubmittableExtrinsic<ChainApi>, Type>`;
+        return `GenericContractTxCall<(${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractTxOptions) => ContractSubmittableExtrinsic, Type>`;
     }
 }
 exports.TxGen = TxGen;

package/cjs/sol/templates/constructor-query.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ConstructorQuery <ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericConstructorQuery <ChainApi, Type> {
+export interface ConstructorQuery<Type extends MetadataType> extends GenericConstructorQuery<Type> {
     {{{ constructorsOut }}}
 }

package/cjs/sol/templates/constructor-tx.hbs

@@ -3,9 +3,8 @@
 {{{ importTypes }}}
 
 export interface ConstructorTx<
-  ChainApi extends GenericSubstrateApi, 
   ContractApi extends SolGenericContractApi,
   Type extends MetadataType
-> extends GenericConstructorTx <ChainApi, Type> {
+> extends GenericConstructorTx<Type> {
   {{{ constructorsOut }}}
 }

package/cjs/sol/templates/events.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ContractEvents <ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericContractEvents <ChainApi, Type> {
+export interface ContractEvents<Type extends MetadataType> extends GenericContractEvents<Type> {
     {{{ eventsOut }}}
 }

package/cjs/sol/templates/index.hbs

@@ -9,15 +9,15 @@ import { ContractEvents } from './events.js';
 
 export * from './types.js';
 
-{{{interfaceDocs}}}export interface {{{interfaceName}}}<Rv extends RpcVersion = RpcVersion, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends SolGenericContractApi<Rv, ChainApi> {
+{{{interfaceDocs}}}export interface {{{interfaceName}}}<ChainApi extends GenericSubstrateApi = SubstrateApi> extends SolGenericContractApi<ChainApi> {
     metadataType: 'sol';
-    query: ContractQuery<ChainApi[Rv], 'sol'>;
-    tx: ContractTx<ChainApi[Rv], 'sol'>;
-    constructorQuery: ConstructorQuery<ChainApi[Rv], 'sol'>;
-    events: ContractEvents<ChainApi[Rv], 'sol'>;
-    constructorTx: ConstructorTx<ChainApi[Rv], {{{interfaceName}}}, 'sol'>;
+    query: ContractQuery<'sol'>;
+    tx: ContractTx<'sol'>;
+    constructorQuery: ConstructorQuery<'sol'>;
+    events: ContractEvents<'sol'>;
+    constructorTx: ConstructorTx<{{{interfaceName}}}, 'sol'>;
 
     types: {
-      ChainApi: ChainApi[Rv];
+      ChainApi: ChainApi;
     };
 }

package/cjs/sol/templates/query.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ContractQuery<ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericContractQuery<ChainApi, Type> {
+export interface ContractQuery<Type extends MetadataType> extends GenericContractQuery<Type> {
     {{{ queryCallsOut }}}
 }

package/cjs/sol/templates/tx.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ContractTx<ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericContractTx<ChainApi, Type> {
+export interface ContractTx<Type extends MetadataType> extends GenericContractTx<Type> {
     {{{ txCallsOut }}}
 }

package/cjs/typink/generator/ConstructorQueryGen.js

@@ -20,7 +20,7 @@ class ConstructorQueryGen extends QueryGen_js_1.QueryGen {
         const typeOutRaw = this.typesGen.generateType(returnType.type, 0, true);
         // Unwrap langError result
         const typeOut = typeOutRaw.match(/^(\w+)<(.*), (.*)>$/).at(2);
-        return `GenericConstructorQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorCallOptions) => Promise<GenericConstructorCallResult<${typeOut}, ContractInstantiateResult<ChainApi>>>, Type>`;
+        return `GenericConstructorQueryCall<(${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorCallOptions) => Promise<GenericConstructorCallResult<${typeOut}, ContractInstantiateResult>>, Type>`;
     }
 }
 exports.ConstructorQueryGen = ConstructorQueryGen;

package/cjs/typink/generator/ConstructorTxGen.js

@@ -16,7 +16,7 @@ class ConstructorTxGen extends QueryGen_js_1.QueryGen {
     }
     generateMethodDef(def, optionsParamName = 'options') {
         const paramsOut = this.generateParamsOut(def.args);
-        return `GenericConstructorTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorTxOptions) => GenericInstantiateSubmittableExtrinsic<ChainApi, ContractApi>, Type>`;
+        return `GenericConstructorTxCall<(${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorTxOptions) => GenericInstantiateSubmittableExtrinsic<ContractApi>, Type>`;
     }
 }
 exports.ConstructorTxGen = ConstructorTxGen;

package/cjs/typink/generator/IndexGen.js

@@ -18,7 +18,7 @@ class IndexGen {
         const langErrorId = this.contractMetadata.spec.lang_error.type;
         const langErrorName = this.typesGen.cleanPath(this.contractMetadata.types[langErrorId].type.path);
         const typeImports = new index_js_1.TypeImports();
-        typeImports.addKnownType('VersionedGenericSubstrateApi', 'RpcVersion', 'RpcV2');
+        typeImports.addKnownType('GenericSubstrateApi', 'RpcVersion', 'RpcV2');
         typeImports.addContractType('InkGenericContractApi', 'WithLazyStorage');
         typeImports.addChainType('SubstrateApi');
         typeImports.addPortableType(langErrorName);

package/cjs/typink/generator/QueryGen.js

@@ -40,7 +40,7 @@ class QueryGen {
         const typeOutRaw = this.typesGen.generateType(returnType.type, 0, true);
         // Unwrap langError result
         const typeOut = typeOutRaw.match(/^(\w+)<(.*), (.*)>$/).at(2);
-        return `GenericContractQueryCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult<ChainApi>>>, Type>`;
+        return `GenericContractQueryCall<(${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult>>, Type>`;
     }
     generateParamsOut(args) {
         return args

package/cjs/typink/generator/TxGen.js

@@ -17,7 +17,7 @@ class TxGen extends QueryGen_js_1.QueryGen {
     }
     generateMethodDef(def, optionsParamName = 'options') {
         const paramsOut = this.generateParamsOut(def.args);
-        return `GenericContractTxCall<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractTxOptions) => ContractSubmittableExtrinsic<ChainApi>, Type>`;
+        return `GenericContractTxCall<(${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractTxOptions) => ContractSubmittableExtrinsic, Type>`;
     }
 }
 exports.TxGen = TxGen;

package/cjs/typink/templates/constructor-query.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ConstructorQuery<ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericConstructorQuery<ChainApi, Type> {  
+export interface ConstructorQuery<Type extends MetadataType> extends GenericConstructorQuery<Type> {
     {{{ constructorsOut }}}
 }

package/cjs/typink/templates/constructor-tx.hbs

@@ -3,9 +3,8 @@
 {{{ importTypes }}}
 
 export interface ConstructorTx<
-  ChainApi extends GenericSubstrateApi,
   ContractApi extends InkGenericContractApi,
   Type extends MetadataType
-> extends GenericConstructorTx<ChainApi, Type> {
+> extends GenericConstructorTx<Type> {
     {{{ constructorsOut }}}
 }

package/cjs/typink/templates/events.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ContractEvents <ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericContractEvents <ChainApi, Type> {
+export interface ContractEvents<Type extends MetadataType> extends GenericContractEvents <Type> {
     {{{ eventsOut }}}
 }

package/cjs/typink/templates/index.hbs

@@ -9,20 +9,20 @@ import { ContractEvents } from './events.js';
 
 export * from './types.js';
 
-{{{interfaceDocs}}}export interface {{{interfaceName}}}<Rv extends RpcVersion = RpcVersion, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends InkGenericContractApi<Rv, ChainApi> {
+{{{interfaceDocs}}}export interface {{{interfaceName}}}<ChainApi extends GenericSubstrateApi = SubstrateApi> extends InkGenericContractApi<ChainApi> {
     metadataType: 'ink';
-    query: ContractQuery<ChainApi[Rv], 'ink'>;
-    tx: ContractTx<ChainApi[Rv], 'ink'>;
-    constructorQuery: ConstructorQuery<ChainApi[Rv], 'ink'>;
-    constructorTx: ConstructorTx<ChainApi[Rv], {{{interfaceName}}}, 'ink'>;
-    events: ContractEvents<ChainApi[Rv], 'ink'>;
+    query: ContractQuery<'ink'>;
+    tx: ContractTx<'ink'>;
+    constructorQuery: ConstructorQuery<'ink'>;
+    constructorTx: ConstructorTx<{{{interfaceName}}}, 'ink'>;
+    events: ContractEvents<'ink'>;
     storage: {
       root(): Promise<{{{rootStorageName}}}>;
       lazy(): {{{lazyStorageName}}};
     };
 
     types: {
-      ChainApi: ChainApi[Rv];
+      ChainApi: ChainApi;
       RootStorage: {{{rootStorageName}}};
       LazyStorage: {{{lazyStorageName}}};
       LangError: {{{langErrorName}}};

package/cjs/typink/templates/query.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ContractQuery<ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericContractQuery<ChainApi, Type> {
+export interface ContractQuery<Type extends MetadataType> extends GenericContractQuery<Type> {
     {{{ queryCallsOut }}}
 }

package/cjs/typink/templates/tx.hbs

@@ -2,6 +2,6 @@
 
 {{{ importTypes }}}
 
-export interface ContractTx<ChainApi extends GenericSubstrateApi, Type extends MetadataType> extends GenericContractTx<ChainApi, Type> {
+export interface ContractTx<Type extends MetadataType> extends GenericContractTx<Type> {
     {{{ txCallsOut }}}
 }