@dedot/codegen 0.18.7 → 1.0.0-next.a0f8d41e.25

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<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorCallOptions) => Promise<GenericConstructorCallResult<[], ContractInstantiateResult>>, Type>`;
     }
     generateParamsOut(abiItem) {
         return abiItem.inputs

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<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult>>, Type>`;
     }
     generateParamsOut(abiItem) {
         return abiItem.inputs

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<ChainApi, 'sol'>;
+    tx: ContractTx<ChainApi, 'sol'>;
+    constructorQuery: ConstructorQuery<ChainApi, 'sol'>;
+    events: ContractEvents<ChainApi, 'sol'>;
+    constructorTx: ConstructorTx<ChainApi, {{{interfaceName}}}, 'sol'>;
 
     types: {
-      ChainApi: ChainApi[Rv];
+      ChainApi: ChainApi;
     };
 }

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<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorCallOptions) => Promise<GenericConstructorCallResult<${typeOut}, ContractInstantiateResult>>, Type>`;
     }
 }
 exports.ConstructorQueryGen = ConstructorQueryGen;

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<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult>>, Type>`;
     }
     generateParamsOut(args) {
         return args

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<ChainApi, 'ink'>;
+    tx: ContractTx<ChainApi, 'ink'>;
+    constructorQuery: ConstructorQuery<ChainApi, 'ink'>;
+    constructorTx: ConstructorTx<ChainApi, {{{interfaceName}}}, 'ink'>;
+    events: ContractEvents<ChainApi, 'ink'>;
     storage: {
       root(): Promise<{{{rootStorageName}}}>;
       lazy(): {{{lazyStorageName}}};
     };
 
     types: {
-      ChainApi: ChainApi[Rv];
+      ChainApi: ChainApi;
       RootStorage: {{{rootStorageName}}};
       LazyStorage: {{{lazyStorageName}}};
       LangError: {{{langErrorName}}};

package/cjs/utils.js

@@ -26,7 +26,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVariantDeprecationComment = exports.getDeprecationComment = exports.isNativeType = exports.isReservedWord = exports.compileTemplate = exports.beautifySourceCode = exports.commentBlock = exports.TUPLE_TYPE_REGEX = exports.WRAPPER_TYPE_REGEX = void 0;
+exports.resolveBlockHash = exports.getVariantDeprecationComment = exports.getDeprecationComment = exports.isNativeType = exports.isReservedWord = exports.compileTemplate = exports.beautifySourceCode = exports.commentBlock = exports.TUPLE_TYPE_REGEX = exports.WRAPPER_TYPE_REGEX = void 0;
+const utils_1 = require("@dedot/utils");
 const fs = __importStar(require("fs"));
 const handlebars_1 = __importDefault(require("handlebars"));
 const path = __importStar(require("path"));
@@ -51,6 +52,7 @@ exports.commentBlock = commentBlock;
 const beautifySourceCode = async (source) => {
     const prettierOptions = await prettier.resolveConfig(path.resolve((0, dirname_js_1.currentDirname)(), '../../../.prettierrc.cjs'));
     return prettier.format(source, { parser: 'babel-ts', ...prettierOptions });
+    // return source;
 };
 exports.beautifySourceCode = beautifySourceCode;
 const compileTemplate = (templateFile) => {
@@ -141,3 +143,27 @@ const getVariantDeprecationComment = (deprecationInfo, variantIndex) => {
     }
 };
 exports.getVariantDeprecationComment = getVariantDeprecationComment;
+/**
+ * Resolve block hash from either a block hash or block number
+ * @param client - The API client
+ * @param at - Block hash (0x...) or block number (number)
+ * @returns The resolved block hash
+ */
+async function resolveBlockHash(client, at) {
+    // Check if it's a hex string (block hash)
+    if ((0, utils_1.isHex)(at)) {
+        return at;
+    }
+    // Try to parse as a number (block height)
+    const blockNumber = parseInt(at, 10);
+    if (isNaN(blockNumber) || blockNumber < 0) {
+        throw new utils_1.DedotError(`Invalid block specifier: ${at}. Must be a block hash (0x...) or block number.`);
+    }
+    // Resolve block number to block hash
+    const blockHash = await client.rpc.chain_getBlockHash(blockNumber);
+    if (!blockHash) {
+        throw new utils_1.DedotError(`Block not found at height: ${blockNumber}`);
+    }
+    return blockHash;
+}
+exports.resolveBlockHash = resolveBlockHash;

package/index.d.ts

@@ -2,3 +2,4 @@ export * from './types.js';
 export * from './chaintypes/index.js';
 export * from './typink/index.js';
 export * from './sol/index.js';
+export { resolveBlockHash } from './utils.js';

package/index.js

@@ -2,3 +2,4 @@ export * from './types.js';
 export * from './chaintypes/index.js';
 export * from './typink/index.js';
 export * from './sol/index.js';
+export { resolveBlockHash } from './utils.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/codegen",
-  "version": "0.18.7",
+  "version": "1.0.0-next.a0f8d41e.25+a0f8d41e",
   "description": "Generate types",
   "author": "Thang X. Vu <thang@dedot.dev>",
   "homepage": "https://dedot.dev",
@@ -19,16 +19,16 @@
     "copy": "cp -R ./src/chaintypes/templates ./dist/chaintypes && cp -R ./src/chaintypes/templates ./dist/cjs/chaintypes && cp -R ./src/typink/templates ./dist/typink && cp -R ./src/typink/templates ./dist/cjs/typink && cp -R ./src/sol/templates ./dist/sol && cp -R ./src/sol/templates ./dist/cjs/sol"
   },
   "dependencies": {
-    "@dedot/api": "0.18.7",
-    "@dedot/codecs": "0.18.7",
-    "@dedot/contracts": "0.18.7",
-    "@dedot/providers": "0.18.7",
-    "@dedot/runtime-specs": "0.18.7",
-    "@dedot/shape": "0.18.7",
-    "@dedot/types": "0.18.7",
-    "@dedot/utils": "0.18.7",
+    "@dedot/api": "1.0.0-next.a0f8d41e.25+a0f8d41e",
+    "@dedot/codecs": "1.0.0-next.a0f8d41e.25+a0f8d41e",
+    "@dedot/contracts": "1.0.0-next.a0f8d41e.25+a0f8d41e",
+    "@dedot/providers": "1.0.0-next.a0f8d41e.25+a0f8d41e",
+    "@dedot/runtime-specs": "1.0.0-next.a0f8d41e.25+a0f8d41e",
+    "@dedot/shape": "1.0.0-next.a0f8d41e.25+a0f8d41e",
+    "@dedot/types": "1.0.0-next.a0f8d41e.25+a0f8d41e",
+    "@dedot/utils": "1.0.0-next.a0f8d41e.25+a0f8d41e",
     "handlebars": "^4.7.8",
-    "prettier": "^3.6.2"
+    "prettier": "^3.7.3"
   },
   "publishConfig": {
     "access": "public",
@@ -38,7 +38,7 @@
     "node": ">=18"
   },
   "license": "Apache-2.0",
-  "gitHead": "07f47f75512087407e03f301fc18c2059b3f613a",
+  "gitHead": "a0f8d41e632a44c03ccc31ee77bcb7d19df936e9",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {

package/sol/generator/ConstructorQueryGen.js

@@ -29,7 +29,7 @@ export 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<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ConstructorCallOptions) => Promise<GenericConstructorCallResult<[], ContractInstantiateResult>>, Type>`;
     }
     generateParamsOut(abiItem) {
         return abiItem.inputs

package/sol/generator/IndexGen.js

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

package/sol/generator/QueryGen.js

@@ -36,7 +36,7 @@ export 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<ChainApi, (${paramsOut && `${paramsOut},`} ${optionsParamName}?: ContractCallOptions) => Promise<GenericContractCallResult<${typeOut}, ContractCallResult>>, Type>`;
     }
     generateParamsOut(abiItem) {
         return abiItem.inputs