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

package/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/typink/generator/ConstructorQueryGen.js

@@ -17,6 +17,6 @@ export class ConstructorQueryGen extends 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>`;
     }
 }

package/typink/generator/IndexGen.js

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

package/typink/generator/QueryGen.js

@@ -37,7 +37,7 @@ export 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/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/utils.d.ts

@@ -1,4 +1,6 @@
+import { DedotClient } from '@dedot/api';
 import { ItemDeprecationInfoDefV16, EnumDeprecationInfoDefV16 } from '@dedot/codecs';
+import { HexString } from '@dedot/utils';
 export declare const WRAPPER_TYPE_REGEX: RegExp;
 export declare const TUPLE_TYPE_REGEX: RegExp;
 export declare const commentBlock: (...docs: (string | string[])[]) => string;
@@ -27,3 +29,10 @@ export declare const getDeprecationComment: (deprecationInfo: ItemDeprecationInf
  * @param variantIndex
  */
 export declare const getVariantDeprecationComment: (deprecationInfo: EnumDeprecationInfoDefV16 | undefined, variantIndex: number) => string[];
+/**
+ * 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
+ */
+export declare function resolveBlockHash(client: DedotClient, at: string): Promise<HexString>;

package/utils.js

@@ -1,3 +1,4 @@
+import { DedotError, isHex } from '@dedot/utils';
 import * as fs from 'fs';
 import handlebars from 'handlebars';
 import * as path from 'path';
@@ -21,6 +22,7 @@ ${flatLines.map((line) => `* ${line.replaceAll(/\s+/g, ' ').trim()}`).join('\n')
 export const beautifySourceCode = async (source) => {
     const prettierOptions = await prettier.resolveConfig(path.resolve(currentDirname(), '../../../.prettierrc.cjs'));
     return prettier.format(source, { parser: 'babel-ts', ...prettierOptions });
+    // return source;
 };
 export const compileTemplate = (templateFile) => {
     const templateFilePath = path.resolve(currentDirname(), templateFile);
@@ -105,3 +107,26 @@ export const getVariantDeprecationComment = (deprecationInfo, variantIndex) => {
             return [];
     }
 };
+/**
+ * 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
+ */
+export async function resolveBlockHash(client, at) {
+    // Check if it's a hex string (block hash)
+    if (isHex(at)) {
+        return at;
+    }
+    // Try to parse as a number (block height)
+    const blockNumber = parseInt(at, 10);
+    if (isNaN(blockNumber) || blockNumber < 0) {
+        throw new 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 DedotError(`Block not found at height: ${blockNumber}`);
+    }
+    return blockHash;
+}