@dedot/contracts 0.18.8 → 1.0.0

package/errors.d.ts

@@ -14,13 +14,13 @@ export declare class ContractInstantiateError<ContractApi extends GenericContrac
     /**
      * The raw result of the contract instantiation.
      */
-    raw: ContractInstantiateResult<ContractApi['types']['ChainApi']>;
+    raw: ContractInstantiateResult;
     /**
      * Constructs a new `ContractInstantiateError` instance.
      *
      * @param raw - The raw result of the contract instantiation.
      */
-    constructor(raw: ContractInstantiateResult<ContractApi['types']['ChainApi']>);
+    constructor(raw: ContractInstantiateResult);
 }
 /**
  * Represents an error that occurred during the dispatch phase of contract instantiation.
@@ -47,7 +47,7 @@ export declare class ContractInstantiateDispatchError<ContractApi extends Generi
      * @param raw - The raw result of the contract instantiation.
      * @param moduleError - The decoded module error, if any.
      */
-    constructor(err: DispatchError, raw: ContractInstantiateResult<ContractApi['types']['ChainApi']>, moduleError?: PalletErrorMetadataLatest);
+    constructor(err: DispatchError, raw: ContractInstantiateResult, moduleError?: PalletErrorMetadataLatest);
 }
 /**
  * Represents an error that occurred during the instantiation of a smart contract due to a language-specific error.
@@ -75,7 +75,7 @@ export declare class ContractInstantiateLangError<ContractApi extends InkGeneric
      * @param err - The `LangError` that occurred during the instantiation phase.
      * @param raw - The raw result of the contract instantiation.
      */
-    constructor(err: ContractApi['types']['LangError'], raw: ContractInstantiateResult<ContractApi['types']['ChainApi']>);
+    constructor(err: ContractApi['types']['LangError'], raw: ContractInstantiateResult);
 }
 /**
  * Represents an error that occurred during the execution of a smart contract call.
@@ -90,13 +90,13 @@ export declare class ContractExecutionError<ContractApi extends GenericContractA
     /**
      * The raw result of the contract call.
      */
-    raw: ContractCallResult<ContractApi['types']['ChainApi']>;
+    raw: ContractCallResult;
     /**
      * Constructs a new `ContractExecutionError` instance.
      *
      * @param raw - The raw result of the contract call.
      */
-    constructor(raw: ContractCallResult<ContractApi['types']['ChainApi']>);
+    constructor(raw: ContractCallResult);
 }
 /**
  * Represents an error that occurred during the execution of a smart contract call due to a dispatch error.
@@ -123,7 +123,7 @@ export declare class ContractDispatchError<ContractApi extends GenericContractAp
      * @param raw - The raw result of the contract call.
      * @param moduleError - The decoded module error, if any.
      */
-    constructor(err: DispatchError, raw: ContractCallResult<ContractApi['types']['ChainApi']>, moduleError?: PalletErrorMetadataLatest);
+    constructor(err: DispatchError, raw: ContractCallResult, moduleError?: PalletErrorMetadataLatest);
 }
 /**
  * Represents an error that occurred during the execution of a smart contract call due to a language-specific error.
@@ -151,7 +151,7 @@ export declare class ContractLangError<ContractApi extends InkGenericContractApi
      * @param err - The `LangError` that occurred during the execution phase.
      * @param raw - The raw result of the contract call.
      */
-    constructor(err: ContractApi['types']['LangError'], raw: ContractCallResult<ContractApi['types']['ChainApi']>);
+    constructor(err: ContractApi['types']['LangError'], raw: ContractCallResult);
 }
 export type SolErrorResult = {
     abiItem: SolAbiError;
@@ -169,7 +169,7 @@ export type SolErrorResult = {
 export declare class SolContractInstantiateError<ContractApi extends SolGenericContractApi = SolGenericContractApi> extends ContractInstantiateError {
     name: string;
     details?: SolErrorResult;
-    constructor(raw: ContractInstantiateResult<ContractApi['types']['ChainApi']>, { details, message }: {
+    constructor(raw: ContractInstantiateResult, { details, message }: {
         details?: SolErrorResult;
         message?: string;
     });
@@ -185,7 +185,7 @@ export declare class SolContractInstantiateError<ContractApi extends SolGenericC
 export declare class SolContractExecutionError<ContractApi extends SolGenericContractApi = SolGenericContractApi> extends ContractExecutionError {
     name: string;
     details?: SolErrorResult;
-    constructor(raw: ContractCallResult<ContractApi['types']['ChainApi']>, { details, message }: {
+    constructor(raw: ContractCallResult, { details, message }: {
         details?: SolErrorResult;
         message?: string;
     });

package/executor/ink/ConstructorQueryExecutor.d.ts

@@ -1,5 +1,4 @@
-import { GenericSubstrateApi } from '@dedot/types';
 import { DeployerExecutor } from './abstract/index.js';
-export declare class ConstructorQueryExecutor<ChainApi extends GenericSubstrateApi> extends DeployerExecutor<ChainApi> {
+export declare class ConstructorQueryExecutor extends DeployerExecutor {
     doExecute(constructor: string): any;
 }

package/executor/ink/ConstructorTxExecutor.d.ts

@@ -1,5 +1,4 @@
-import { GenericSubstrateApi } from '@dedot/types';
 import { DeployerExecutor } from './abstract/index.js';
-export declare class ConstructorTxExecutor<ChainApi extends GenericSubstrateApi> extends DeployerExecutor<ChainApi> {
+export declare class ConstructorTxExecutor extends DeployerExecutor {
     doExecute(constructor: string): any;
 }

package/executor/ink/EventExecutor.d.ts

@@ -1,7 +1,6 @@
-import { GenericSubstrateApi } from '@dedot/types';
 import { GenericContractEvent } from '../../types/index.js';
 import { ContractExecutor } from './abstract/index.js';
-export declare class EventExecutor<ChainApi extends GenericSubstrateApi> extends ContractExecutor<ChainApi> {
+export declare class EventExecutor extends ContractExecutor {
     #private;
     doExecute(eventName: string): GenericContractEvent<string, any, 'ink'>;
 }

package/executor/ink/QueryExecutor.d.ts

@@ -1,5 +1,4 @@
-import { GenericSubstrateApi } from '@dedot/types';
 import { ContractExecutor } from './abstract/index.js';
-export declare class QueryExecutor<ChainApi extends GenericSubstrateApi> extends ContractExecutor<ChainApi> {
+export declare class QueryExecutor extends ContractExecutor {
     doExecute(message: string): any;
 }

package/executor/ink/TxExecutor.d.ts

@@ -1,5 +1,4 @@
-import { GenericSubstrateApi } from '@dedot/types';
 import { ContractExecutor } from './abstract/index.js';
-export declare class TxExecutor<ChainApi extends GenericSubstrateApi> extends ContractExecutor<ChainApi> {
+export declare class TxExecutor extends ContractExecutor {
     doExecute(message: string): any;
 }

package/executor/ink/abstract/ContractExecutor.d.ts

@@ -1,11 +1,10 @@
 import { ISubstrateClient } from '@dedot/api';
-import { GenericSubstrateApi } from '@dedot/types';
 import { TypinkRegistry } from '../../../TypinkRegistry.js';
 import { ContractAddress, ContractCallMessage, ExecutionOptions } from '../../../types/index.js';
 import { Executor } from './Executor.js';
-export declare abstract class ContractExecutor<ChainApi extends GenericSubstrateApi> extends Executor<ChainApi> {
+export declare abstract class ContractExecutor extends Executor {
     readonly address: ContractAddress;
-    constructor(client: ISubstrateClient<ChainApi>, registry: TypinkRegistry, address: ContractAddress, options?: ExecutionOptions);
+    constructor(client: ISubstrateClient, registry: TypinkRegistry, address: ContractAddress, options?: ExecutionOptions);
     protected findMessage(message: string): ContractCallMessage | undefined;
     protected findTxMessage(message: string): ContractCallMessage | undefined;
 }

package/executor/ink/abstract/DeployerExecutor.d.ts

@@ -1,12 +1,11 @@
 import { ISubstrateClient } from '@dedot/api';
 import { Hash } from '@dedot/codecs';
-import { GenericSubstrateApi } from '@dedot/types';
 import { HexString } from '@dedot/utils';
 import { TypinkRegistry } from '../../../TypinkRegistry.js';
 import { ContractConstructorMessage, ExecutionOptions } from '../../../types/index.js';
 import { Executor } from './Executor.js';
-export declare abstract class DeployerExecutor<ChainApi extends GenericSubstrateApi> extends Executor<ChainApi> {
+export declare abstract class DeployerExecutor extends Executor {
     readonly code: Hash | Uint8Array | HexString | string;
-    constructor(client: ISubstrateClient<ChainApi>, registry: TypinkRegistry, code: Hash | Uint8Array | HexString | string, options?: ExecutionOptions);
+    constructor(client: ISubstrateClient, registry: TypinkRegistry, code: Hash | Uint8Array | HexString | string, options?: ExecutionOptions);
     protected findConstructorMeta(constructor: string): ContractConstructorMessage | undefined;
 }

package/executor/ink/abstract/Executor.d.ts

@@ -1,13 +1,11 @@
 import { ISubstrateClient } from '@dedot/api';
-import { SubstrateApi } from '@dedot/api/chaintypes';
-import { GenericSubstrateApi, RpcVersion } from '@dedot/types';
 import { TypinkRegistry } from '../../../TypinkRegistry.js';
-import { ContractMessageArg, ContractMessage, ExecutionOptions, ContractMetadata } from '../../../types/index.js';
-export declare abstract class Executor<ChainApi extends GenericSubstrateApi = SubstrateApi[RpcVersion]> {
-    readonly client: ISubstrateClient<ChainApi>;
+import { ContractMessage, ContractMessageArg, ContractMetadata, ExecutionOptions } from '../../../types/index.js';
+export declare abstract class Executor {
+    readonly client: ISubstrateClient;
     readonly registry: TypinkRegistry;
     readonly options: ExecutionOptions;
-    constructor(client: ISubstrateClient<ChainApi>, registry: TypinkRegistry, options?: ExecutionOptions);
+    constructor(client: ISubstrateClient, registry: TypinkRegistry, options?: ExecutionOptions);
     get metadata(): ContractMetadata;
     abstract doExecute(...paths: string[]): unknown;
     tryEncode(param: ContractMessageArg, value: any): Uint8Array;

package/executor/sol/SolConstructorQueryExecutor.d.ts

@@ -1,5 +1,4 @@
-import { GenericSubstrateApi } from '@dedot/types';
 import { SolDeployerExecutor } from './abstract/index.js';
-export declare class SolConstructorQueryExecutor<ChainApi extends GenericSubstrateApi> extends SolDeployerExecutor<ChainApi> {
+export declare class SolConstructorQueryExecutor extends SolDeployerExecutor {
     doExecute(_: string): any;
 }

package/executor/sol/SolConstructorTxExecutor.d.ts

@@ -1,5 +1,4 @@
-import { GenericSubstrateApi } from '@dedot/types';
 import { SolDeployerExecutor } from './abstract/index.js';
-export declare class SolConstructorTxExecutor<ChainApi extends GenericSubstrateApi> extends SolDeployerExecutor<ChainApi> {
+export declare class SolConstructorTxExecutor extends SolDeployerExecutor {
     doExecute(_: string): any;
 }

package/executor/sol/SolEventExecutor.d.ts

@@ -1,6 +1,5 @@
-import { GenericSubstrateApi } from '@dedot/types';
 import { GenericContractEvent } from '../../types/index.js';
 import { SolContractExecutor } from './abstract/index.js';
-export declare class SolEventExecutor<ChainApi extends GenericSubstrateApi> extends SolContractExecutor<ChainApi> {
+export declare class SolEventExecutor extends SolContractExecutor {
     doExecute(eventName: string): GenericContractEvent<string, any, 'sol'>;
 }

package/executor/sol/SolQueryExecutor.d.ts

@@ -1,5 +1,4 @@
-import { GenericSubstrateApi } from '@dedot/types';
 import { SolContractExecutor } from './abstract/SolContractExecutor.js';
-export declare class SolQueryExecutor<ChainApi extends GenericSubstrateApi> extends SolContractExecutor<ChainApi> {
+export declare class SolQueryExecutor extends SolContractExecutor {
     doExecute(name: string): any;
 }

package/executor/sol/SolTxExecutor.d.ts

@@ -1,5 +1,4 @@
-import { GenericSubstrateApi } from '@dedot/types';
 import { SolContractExecutor } from './abstract/SolContractExecutor.js';
-export declare class SolTxExecutor<ChainApi extends GenericSubstrateApi> extends SolContractExecutor<ChainApi> {
+export declare class SolTxExecutor extends SolContractExecutor {
     doExecute(name: string): any;
 }

package/executor/sol/abstract/SolContractExecutor.d.ts

@@ -1,9 +1,8 @@
 import { ISubstrateClient } from '@dedot/api';
-import { GenericSubstrateApi } from '@dedot/types';
 import { SolRegistry } from '../../../SolRegistry.js';
 import { ContractAddress, ExecutionOptions } from '../../../types/index.js';
 import { SolExecutor } from './SolExecutor.js';
-export declare abstract class SolContractExecutor<ChainApi extends GenericSubstrateApi> extends SolExecutor<ChainApi> {
+export declare abstract class SolContractExecutor extends SolExecutor {
     readonly address: ContractAddress;
-    constructor(client: ISubstrateClient<ChainApi>, registry: SolRegistry, address: ContractAddress, options?: ExecutionOptions);
+    constructor(client: ISubstrateClient, registry: SolRegistry, address: ContractAddress, options?: ExecutionOptions);
 }

package/executor/sol/abstract/SolDeployerExecutor.d.ts

@@ -1,11 +1,10 @@
 import { ISubstrateClient } from '@dedot/api';
 import { Hash } from '@dedot/codecs';
-import { GenericSubstrateApi } from '@dedot/types';
 import { HexString } from '@dedot/utils';
 import { SolRegistry } from '../../../SolRegistry.js';
 import { ExecutionOptions } from '../../../types/index.js';
 import { SolExecutor } from './SolExecutor.js';
-export declare abstract class SolDeployerExecutor<ChainApi extends GenericSubstrateApi> extends SolExecutor<ChainApi> {
+export declare abstract class SolDeployerExecutor extends SolExecutor {
     readonly code: Hash | Uint8Array | HexString | string;
-    constructor(client: ISubstrateClient<ChainApi>, registry: SolRegistry, code: Hash | Uint8Array | HexString | string, options?: ExecutionOptions);
+    constructor(client: ISubstrateClient, registry: SolRegistry, code: Hash | Uint8Array | HexString | string, options?: ExecutionOptions);
 }

package/executor/sol/abstract/SolExecutor.d.ts

@@ -1,13 +1,11 @@
 import { ISubstrateClient } from '@dedot/api';
-import { SubstrateApi } from '@dedot/api/chaintypes';
-import { GenericSubstrateApi, RpcVersion } from '@dedot/types';
 import { SolRegistry } from '../../../SolRegistry.js';
 import { ExecutionOptions, SolAbi } from '../../../types/index.js';
-export declare abstract class SolExecutor<ChainApi extends GenericSubstrateApi = SubstrateApi[RpcVersion]> {
-    readonly client: ISubstrateClient<ChainApi>;
+export declare abstract class SolExecutor {
+    readonly client: ISubstrateClient;
     readonly registry: SolRegistry;
     readonly options: ExecutionOptions;
-    protected constructor(client: ISubstrateClient<ChainApi>, registry: SolRegistry, options?: ExecutionOptions);
+    protected constructor(client: ISubstrateClient, registry: SolRegistry, options?: ExecutionOptions);
     get abi(): SolAbi;
     abstract doExecute(...paths: string[]): unknown;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/contracts",
-  "version": "0.18.8",
+  "version": "1.0.0",
   "description": "Delightful ink! Contract APIs",
   "author": "Tung Vu <tung@dedot.dev>",
   "homepage": "https://dedot.dev",
@@ -18,11 +18,11 @@
     "test": "npx vitest --watch=false"
   },
   "dependencies": {
-    "@dedot/api": "0.18.8",
-    "@dedot/codecs": "0.18.8",
-    "@dedot/types": "0.18.8",
-    "@dedot/utils": "0.18.8",
-    "viem": "^2.37.7"
+    "@dedot/api": "1.0.0",
+    "@dedot/codecs": "1.0.0",
+    "@dedot/types": "1.0.0",
+    "@dedot/utils": "1.0.0",
+    "viem": "^2.40.3"
   },
   "publishConfig": {
     "access": "public",
@@ -32,7 +32,7 @@
     "node": ">=18"
   },
   "license": "Apache-2.0",
-  "gitHead": "5f87f515d4ce4183038681dd02b20bb682a5fdce",
+  "gitHead": "7767062a2188b4ac90561c5ad3cc3f06ac608a24",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {

package/types/index.d.ts

@@ -1,6 +1,6 @@
 import { SubstrateApi } from '@dedot/api/chaintypes';
 import { Extrinsic } from '@dedot/codecs';
-import { AnyFunc, AsyncMethod, GenericSubstrateApi, IEventRecord, ISubmittableExtrinsic, ISubmittableResult, RpcVersion, Unsub, VersionedGenericSubstrateApi } from '@dedot/types';
+import { AnyFunc, AsyncMethod, GenericSubstrateApi, IEventRecord, ISubmittableExtrinsic, ISubmittableResult, Unsub } from '@dedot/types';
 import { Contract } from '../Contract.js';
 import { ContractCallMessage, ContractConstructorMessage, ContractEventMeta } from './ink/index.js';
 import { ContractCallResult, ContractInstantiateResult, ExecutionOptions, GenericConstructorCallResult, GenericContractCallResult, ContractAddress } from './shared.js';
@@ -8,8 +8,7 @@ import { SolAbiConstructor, SolAbiEvent, SolAbiFunction } from './sol/index.js';
 export * from './ink/index.js';
 export * from './sol/index.js';
 export * from './shared.js';
-type SubmittableExtrinsic<R extends ISubmittableResult> = ISubmittableExtrinsic<R> & Extrinsic;
-export type ContractSubmittableExtrinsic<_ extends GenericSubstrateApi> = SubmittableExtrinsic<ISubmittableResult>;
+export type ContractSubmittableExtrinsic<R extends ISubmittableResult = ISubmittableResult> = ISubmittableExtrinsic<R> & Extrinsic;
 export interface IContractInstantiateSubmittableResult<ContractApi extends GenericContractApi = GenericContractApi> extends ISubmittableResult {
     /**
      * Get deployed contract address
@@ -20,7 +19,7 @@ export interface IContractInstantiateSubmittableResult<ContractApi extends Gener
      */
     contract(options?: ExecutionOptions): Promise<Contract<ContractApi>>;
 }
-export type GenericInstantiateSubmittableExtrinsic<_ extends GenericSubstrateApi, ContractApi extends GenericContractApi = GenericContractApi> = SubmittableExtrinsic<IContractInstantiateSubmittableResult<ContractApi>>;
+export type GenericInstantiateSubmittableExtrinsic<ContractApi extends GenericContractApi = GenericContractApi> = ContractSubmittableExtrinsic<IContractInstantiateSubmittableResult<ContractApi>>;
 export interface LooseContractMetadata {
     version: number | string;
     [prop: string]: any;
@@ -29,29 +28,29 @@ export type LooseSolAbi = Array<{
     type: string;
     [prop: string]: any;
 }>;
-export type GenericContractQueryCall<ChainApi extends GenericSubstrateApi, F extends AsyncMethod = (...args: any[]) => Promise<GenericContractCallResult<any, ContractCallResult<ChainApi>>>, Type extends MetadataType = MetadataType> = F & {
+export type GenericContractQueryCall<F extends AsyncMethod = (...args: any[]) => Promise<GenericContractCallResult<any, ContractCallResult>>, Type extends MetadataType = MetadataType> = F & {
     meta: Type extends 'ink' ? ContractCallMessage : SolAbiFunction;
 };
-export type GenericContractTxCall<ChainApi extends GenericSubstrateApi, F extends AnyFunc = (...args: any[]) => ContractSubmittableExtrinsic<ChainApi>, Type extends MetadataType = MetadataType> = F & {
+export type GenericContractTxCall<F extends AnyFunc = (...args: any[]) => ContractSubmittableExtrinsic, Type extends MetadataType = MetadataType> = F & {
     meta: Type extends 'ink' ? ContractCallMessage : SolAbiFunction;
 };
-export type GenericConstructorQueryCall<ChainApi extends GenericSubstrateApi, F extends AsyncMethod = (...args: any[]) => Promise<GenericConstructorCallResult<any, ContractInstantiateResult<ChainApi>>>, Type extends MetadataType = MetadataType> = F & {
+export type GenericConstructorQueryCall<F extends AsyncMethod = (...args: any[]) => Promise<GenericConstructorCallResult<any, ContractInstantiateResult>>, Type extends MetadataType = MetadataType> = F & {
     meta: Type extends 'ink' ? ContractConstructorMessage : SolAbiConstructor;
 };
-export type GenericConstructorTxCall<ChainApi extends GenericSubstrateApi, F extends AnyFunc = (...args: any[]) => GenericInstantiateSubmittableExtrinsic<ChainApi>, Type extends MetadataType = MetadataType> = F & {
+export type GenericConstructorTxCall<F extends AnyFunc = (...args: any[]) => GenericInstantiateSubmittableExtrinsic, Type extends MetadataType = MetadataType> = F & {
     meta: Type extends 'ink' ? ContractConstructorMessage : SolAbiConstructor;
 };
-export interface GenericContractQuery<ChainApi extends GenericSubstrateApi, Type extends MetadataType = MetadataType> {
-    [method: string]: GenericContractQueryCall<ChainApi, (...args: any[]) => Promise<GenericContractCallResult<any, ContractCallResult<ChainApi>>>, Type>;
+export interface GenericContractQuery<Type extends MetadataType = MetadataType> {
+    [method: string]: GenericContractQueryCall<(...args: any[]) => Promise<GenericContractCallResult<any, ContractCallResult>>, Type>;
 }
-export interface GenericContractTx<ChainApi extends GenericSubstrateApi, Type extends MetadataType = MetadataType> {
-    [method: string]: GenericContractTxCall<ChainApi, (...args: any[]) => ContractSubmittableExtrinsic<ChainApi>, Type>;
+export interface GenericContractTx<Type extends MetadataType = MetadataType> {
+    [method: string]: GenericContractTxCall<(...args: any[]) => ContractSubmittableExtrinsic, Type>;
 }
-export interface GenericConstructorQuery<ChainApi extends GenericSubstrateApi, Type extends MetadataType = MetadataType> {
-    [method: string]: GenericConstructorQueryCall<ChainApi, (...args: any[]) => Promise<GenericConstructorCallResult<any, ContractInstantiateResult<ChainApi>>>, Type>;
+export interface GenericConstructorQuery<Type extends MetadataType = MetadataType> {
+    [method: string]: GenericConstructorQueryCall<(...args: any[]) => Promise<GenericConstructorCallResult<any, ContractInstantiateResult>>, Type>;
 }
-export interface GenericConstructorTx<ChainApi extends GenericSubstrateApi, Type extends MetadataType = MetadataType> {
-    [method: string]: GenericConstructorTxCall<ChainApi, (...args: any[]) => GenericInstantiateSubmittableExtrinsic<ChainApi>, Type>;
+export interface GenericConstructorTx<Type extends MetadataType = MetadataType> {
+    [method: string]: GenericConstructorTxCall<(...args: any[]) => GenericInstantiateSubmittableExtrinsic, Type>;
 }
 export type ContractEvent<EventName extends string = string, Data extends any = any> = Data extends undefined ? {
     name: EventName;
@@ -66,7 +65,7 @@ export interface GenericContractEvent<EventName extends string = string, Data ex
     watch: (callback: (events: ContractEvent<EventName, Data>[]) => void) => Promise<Unsub>;
     meta: Type extends 'ink' ? ContractEventMeta : SolAbiEvent;
 }
-export interface GenericContractEvents<_ extends GenericSubstrateApi, Type extends MetadataType = MetadataType> {
+export interface GenericContractEvents<Type extends MetadataType = MetadataType> {
     [event: string]: GenericContractEvent<string, any, Type>;
 }
 export type GenericInkLangError = 'CouldNotReadInput' | any;
@@ -74,19 +73,19 @@ export type GenericRootStorage = any;
 export type GenericLazyStorage = any;
 export type MetadataType = 'ink' | 'sol';
 export type AB<Type extends MetadataType, A, B> = Type extends 'ink' ? A : B;
-export interface GenericContractApi<Rv extends RpcVersion = RpcVersion, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi, Type extends MetadataType = MetadataType> {
+export interface GenericContractApi<ChainApi extends GenericSubstrateApi = SubstrateApi, Type extends MetadataType = MetadataType> {
     metadataType: Type;
-    query: GenericContractQuery<ChainApi[Rv], Type>;
-    tx: GenericContractTx<ChainApi[Rv], Type>;
-    constructorQuery: GenericConstructorQuery<ChainApi[Rv], Type>;
-    constructorTx: GenericConstructorTx<ChainApi[Rv], Type>;
-    events: GenericContractEvents<ChainApi[Rv], Type>;
+    query: GenericContractQuery<Type>;
+    tx: GenericContractTx<Type>;
+    constructorQuery: GenericConstructorQuery<Type>;
+    constructorTx: GenericConstructorTx<Type>;
+    events: GenericContractEvents<Type>;
     storage: AB<Type, {
         root(): Promise<GenericRootStorage>;
         lazy(): GenericLazyStorage;
     }, undefined>;
     types: {
-        ChainApi: ChainApi[Rv];
+        ChainApi: ChainApi;
         [TypeName: string]: any;
     };
 }
@@ -96,7 +95,7 @@ type HasGetter<T> = T extends {
 export type WithLazyStorage<T> = {
     [K in keyof T as HasGetter<T[K]> extends true ? K : T[K] extends object ? keyof WithLazyStorage<T[K]> extends never ? never : K : never]: T[K] extends object ? HasGetter<T[K]> extends true ? T[K] : WithLazyStorage<T[K]> : never;
 };
-export interface InkGenericContractApi<Rv extends RpcVersion = RpcVersion, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends GenericContractApi<Rv, ChainApi, 'ink'> {
+export interface InkGenericContractApi<ChainApi extends GenericSubstrateApi = SubstrateApi> extends GenericContractApi<ChainApi, 'ink'> {
 }
-export interface SolGenericContractApi<Rv extends RpcVersion = RpcVersion, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends GenericContractApi<Rv, ChainApi, 'sol'> {
+export interface SolGenericContractApi<ChainApi extends GenericSubstrateApi = SubstrateApi> extends GenericContractApi<ChainApi, 'sol'> {
 }

package/types/shared.d.ts

@@ -1,6 +1,5 @@
 import { AccountId32Like, Bytes, BytesLike, DispatchError, H256, Weight } from '@dedot/codecs';
 import { Result } from '@dedot/shape';
-import { GenericSubstrateApi } from '@dedot/types';
 export type ContractAddress = string;
 /**
  * Flags used by a contract to customize exit behaviour.
@@ -47,14 +46,14 @@ export type InstantiateReturnValue = {
     result: ExecReturnValue;
     address: ContractAddress;
 };
-export type ContractCallResult<_ extends GenericSubstrateApi> = {
+export type ContractCallResult = {
     gasConsumed: WeightV2;
     gasRequired: WeightV2;
     storageDeposit: StorageDeposit;
     debugMessage?: Bytes;
     result: Result<ExecReturnValue, DispatchError>;
 };
-export type ContractInstantiateResult<_ extends GenericSubstrateApi> = {
+export type ContractInstantiateResult = {
     gasConsumed: WeightV2;
     gasRequired: WeightV2;
     storageDeposit: StorageDeposit;

package/utils/ensure.d.ts

@@ -1,12 +1,10 @@
 import { ISubstrateClient } from '@dedot/api';
-import { SubstrateApi } from '@dedot/api/chaintypes';
 import { AccountId32Like, Hash } from '@dedot/codecs';
-import { RpcVersion } from '@dedot/types';
 import { LRUCache } from '@dedot/utils';
 import { ContractAddress, LooseContractMetadata } from '../types/index.js';
 export declare const ensureStorageApiSupports: (version: string | number) => void;
-export declare function ensurePalletPresence(client: ISubstrateClient<SubstrateApi[RpcVersion]>, isRevive: boolean): void;
-export declare function ensureContractPresence(client: ISubstrateClient<SubstrateApi[RpcVersion]>, isRevive: boolean, address: ContractAddress, cache?: LRUCache): Promise<void>;
+export declare function ensurePalletPresence(client: ISubstrateClient, isRevive: boolean): void;
+export declare function ensureContractPresence(client: ISubstrateClient, isRevive: boolean, address: ContractAddress, cache?: LRUCache): Promise<void>;
 export declare function ensureValidContractAddress(address: ContractAddress, isRevive: boolean): void;
 export declare function ensureValidAccountId32Address(address: AccountId32Like, customErrorMessage?: string): void;
 export declare function ensureValidCodeHashOrCode(codeHashOrCode: Hash | Uint8Array | string, isRevive: boolean): void;

package/utils/proxy.d.ts

@@ -1,3 +1,3 @@
 import { GenericSubstrateApi } from '@dedot/types';
 import { Executor } from 'src/executor';
-export declare function newProxyChain<ChainApi extends GenericSubstrateApi>(carrier: Executor<ChainApi>): unknown;
+export declare function newProxyChain<ChainApi extends GenericSubstrateApi>(carrier: Executor): unknown;