@dedot/contracts 0.17.0 → 0.17.1-next.9d03d21b.3

package/types/index.d.ts

@@ -1,75 +1,15 @@
 import { SubstrateApi } from '@dedot/api/chaintypes';
-import { AccountId32Like, type Bytes, BytesLike, type DispatchError, Extrinsic, type H256, type Result, Weight } from '@dedot/codecs';
+import { Extrinsic } from '@dedot/codecs';
 import { AnyFunc, AsyncMethod, GenericSubstrateApi, IEventRecord, ISubmittableExtrinsic, ISubmittableResult, RpcVersion, Unsub, VersionedGenericSubstrateApi } from '@dedot/types';
 import { Contract } from '../Contract.js';
-import { ContractAddress, ContractCallMessage, ContractConstructorMessage } from './shared.js';
-import { ContractEventV4, ContractMetadataV4 } from './v4.js';
-import { ContractEventV5, ContractMetadataV5 } from './v5.js';
-import { ContractMetadataV6 } from './v6.js';
+import { ContractCallMessage, ContractConstructorMessage, ContractEventMeta } from './ink/index.js';
+import { ContractCallResult, ContractInstantiateResult, ExecutionOptions, GenericConstructorCallResult, GenericContractCallResult, ContractAddress } from './shared.js';
+import { SolAbiConstructor, SolAbiEvent, SolAbiFunction } from './sol/index.js';
+export * from './ink/index.js';
+export * from './sol/index.js';
 export * from './shared.js';
-export * from './v4.js';
-export * from './v5.js';
-export * from './v6.js';
-export type ContractEventMeta = ContractEventV4 | ContractEventV5;
-/**
- * Flags used by a contract to customize exit behaviour.
- * Ref: https://github.com/paritytech/polkadot-sdk/blob/d2fd53645654d3b8e12cbf735b67b93078d70113/substrate/frame/contracts/uapi/src/flags.rs#L23-L26
- */
-export type ReturnFlags = {
-    bits: number;
-    revert: boolean;
-};
-export interface GenericContractCallResult<DecodedData = any, ContractResult = any> {
-    data: DecodedData;
-    raw: ContractResult;
-    flags: ReturnFlags;
-    inputData: Bytes;
-}
-export interface GenericConstructorCallResult<DecodedData = any, ContractResult = any> extends GenericContractCallResult<DecodedData, ContractResult> {
-    address: ContractAddress;
-}
-export type ContractCode = {
-    type: 'Upload';
-    value: Bytes;
-} | {
-    type: 'Existing';
-    value: H256;
-};
-export type WeightV2 = {
-    refTime: bigint;
-    proofSize: bigint;
-};
-export type StorageDeposit = {
-    type: 'Refund';
-    value: bigint;
-} | {
-    type: 'Charge';
-    value: bigint;
-};
-export type ExecReturnValue = {
-    flags: {
-        bits: number;
-    };
-    data: Bytes;
-};
-export type InstantiateReturnValue = {
-    result: ExecReturnValue;
-    address: ContractAddress;
-};
-export type ContractCallResult<_ extends GenericSubstrateApi> = {
-    gasConsumed: WeightV2;
-    gasRequired: WeightV2;
-    storageDeposit: StorageDeposit;
-    debugMessage?: Bytes;
-    result: Result<ExecReturnValue, DispatchError>;
-};
-export type ContractInstantiateResult<_ extends GenericSubstrateApi> = {
-    gasConsumed: WeightV2;
-    gasRequired: WeightV2;
-    storageDeposit: StorageDeposit;
-    debugMessage?: Bytes;
-    result: Result<InstantiateReturnValue, DispatchError>;
-};
+type SubmittableExtrinsic<R extends ISubmittableResult> = ISubmittableExtrinsic<R> & Extrinsic;
+export type ContractSubmittableExtrinsic<_ extends GenericSubstrateApi> = SubmittableExtrinsic<ISubmittableResult>;
 export interface IContractInstantiateSubmittableResult<ContractApi extends GenericContractApi = GenericContractApi> extends ISubmittableResult {
     /**
      * Get deployed contract address
@@ -80,53 +20,38 @@ export interface IContractInstantiateSubmittableResult<ContractApi extends Gener
      */
     contract(options?: ExecutionOptions): Promise<Contract<ContractApi>>;
 }
-type SubmittableExtrinsic<R extends ISubmittableResult> = ISubmittableExtrinsic<R> & Extrinsic;
-export type ContractSubmittableExtrinsic<_ extends GenericSubstrateApi> = SubmittableExtrinsic<ISubmittableResult>;
 export type GenericInstantiateSubmittableExtrinsic<_ extends GenericSubstrateApi, ContractApi extends GenericContractApi = GenericContractApi> = SubmittableExtrinsic<IContractInstantiateSubmittableResult<ContractApi>>;
-export type ContractMetadata = ContractMetadataV4 | ContractMetadataV5 | ContractMetadataV6;
 export interface LooseContractMetadata {
     version: number | string;
     [prop: string]: any;
 }
-export type CallOptions = {
-    value?: bigint;
-    gasLimit?: Weight | undefined;
-    storageDepositLimit?: bigint | undefined;
-};
-export type ConstructorCallOptions = CallOptions & {
-    salt?: BytesLike;
-    caller?: AccountId32Like;
-};
-export type ConstructorTxOptions = CallOptions & {
-    salt?: BytesLike;
-};
-export type ContractCallOptions = CallOptions & {
-    caller?: AccountId32Like;
-};
-export type ContractTxOptions = CallOptions;
-export type GenericContractQueryCall<ChainApi extends GenericSubstrateApi, F extends AsyncMethod = (...args: any[]) => Promise<GenericContractCallResult<any, ContractCallResult<ChainApi>>>> = F & {
-    meta: ContractCallMessage;
+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 & {
+    meta: Type extends 'ink' ? ContractCallMessage : SolAbiFunction;
 };
-export type GenericContractTxCall<ChainApi extends GenericSubstrateApi, F extends AnyFunc = (...args: any[]) => ContractSubmittableExtrinsic<ChainApi>> = F & {
-    meta: ContractCallMessage;
+export type GenericContractTxCall<ChainApi extends GenericSubstrateApi, F extends AnyFunc = (...args: any[]) => ContractSubmittableExtrinsic<ChainApi>, 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>>>> = F & {
-    meta: ContractConstructorMessage;
+export type GenericConstructorQueryCall<ChainApi extends GenericSubstrateApi, F extends AsyncMethod = (...args: any[]) => Promise<GenericConstructorCallResult<any, ContractInstantiateResult<ChainApi>>>, Type extends MetadataType = MetadataType> = F & {
+    meta: Type extends 'ink' ? ContractConstructorMessage : SolAbiConstructor;
 };
-export type GenericConstructorTxCall<ChainApi extends GenericSubstrateApi, F extends AnyFunc = (...args: any[]) => GenericInstantiateSubmittableExtrinsic<ChainApi>> = F & {
-    meta: ContractConstructorMessage;
+export type GenericConstructorTxCall<ChainApi extends GenericSubstrateApi, F extends AnyFunc = (...args: any[]) => GenericInstantiateSubmittableExtrinsic<ChainApi>, Type extends MetadataType = MetadataType> = F & {
+    meta: Type extends 'ink' ? ContractConstructorMessage : SolAbiConstructor;
 };
-export interface GenericContractQuery<ChainApi extends GenericSubstrateApi> {
-    [method: string]: GenericContractQueryCall<ChainApi>;
+export interface GenericContractQuery<ChainApi extends GenericSubstrateApi, Type extends MetadataType = MetadataType> {
+    [method: string]: GenericContractQueryCall<ChainApi, (...args: any[]) => Promise<GenericContractCallResult<any, ContractCallResult<ChainApi>>>, Type>;
 }
-export interface GenericContractTx<ChainApi extends GenericSubstrateApi> {
-    [method: string]: GenericContractTxCall<ChainApi>;
+export interface GenericContractTx<ChainApi extends GenericSubstrateApi, Type extends MetadataType = MetadataType> {
+    [method: string]: GenericContractTxCall<ChainApi, (...args: any[]) => ContractSubmittableExtrinsic<ChainApi>, Type>;
 }
-export interface GenericConstructorQuery<ChainApi extends GenericSubstrateApi> {
-    [method: string]: GenericConstructorQueryCall<ChainApi>;
+export interface GenericConstructorQuery<ChainApi extends GenericSubstrateApi, Type extends MetadataType = MetadataType> {
+    [method: string]: GenericConstructorQueryCall<ChainApi, (...args: any[]) => Promise<GenericConstructorCallResult<any, ContractInstantiateResult<ChainApi>>>, Type>;
 }
-export interface GenericConstructorTx<ChainApi extends GenericSubstrateApi> {
-    [method: string]: GenericConstructorTxCall<ChainApi>;
+export interface GenericConstructorTx<ChainApi extends GenericSubstrateApi, Type extends MetadataType = MetadataType> {
+    [method: string]: GenericConstructorTxCall<ChainApi, (...args: any[]) => GenericInstantiateSubmittableExtrinsic<ChainApi>, Type>;
 }
 export type ContractEvent<EventName extends string = string, Data extends any = any> = Data extends undefined ? {
     name: EventName;
@@ -134,42 +59,44 @@ export type ContractEvent<EventName extends string = string, Data extends any =
     name: EventName;
     data: Data;
 };
-export interface GenericContractEvent<EventName extends string = string, Data extends any = any> {
+export interface GenericContractEvent<EventName extends string = string, Data extends any = any, Type extends MetadataType = MetadataType> {
     is: (event: IEventRecord | ContractEvent) => event is ContractEvent<EventName, Data>;
     find: (events: IEventRecord[] | ContractEvent[]) => ContractEvent<EventName, Data> | undefined;
     filter: (events: IEventRecord[] | ContractEvent[]) => ContractEvent<EventName, Data>[];
     watch: (callback: (events: ContractEvent<EventName, Data>[]) => void) => Promise<Unsub>;
-    meta: ContractEventMeta;
+    meta: Type extends 'ink' ? ContractEventMeta : SolAbiEvent;
 }
-export interface GenericContractEvents<_ extends GenericSubstrateApi> {
-    [event: string]: GenericContractEvent;
+export interface GenericContractEvents<_ extends GenericSubstrateApi, Type extends MetadataType = MetadataType> {
+    [event: string]: GenericContractEvent<string, any, Type>;
 }
 export type GenericInkLangError = 'CouldNotReadInput' | any;
 export type GenericRootStorage = any;
 export type GenericLazyStorage = any;
-export interface GenericContractApi<Rv extends RpcVersion = RpcVersion, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> {
-    query: GenericContractQuery<ChainApi[Rv]>;
-    tx: GenericContractTx<ChainApi[Rv]>;
-    constructorQuery: GenericConstructorQuery<ChainApi[Rv]>;
-    constructorTx: GenericConstructorTx<ChainApi[Rv]>;
-    events: GenericContractEvents<ChainApi[Rv]>;
-    storage: {
+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> {
+    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>;
+    storage: AB<Type, {
         root(): Promise<GenericRootStorage>;
         lazy(): GenericLazyStorage;
-    };
+    }, undefined>;
     types: {
-        RootStorage: GenericRootStorage;
-        LazyStorage: GenericLazyStorage;
-        LangError: GenericInkLangError;
         ChainApi: ChainApi[Rv];
+        [TypeName: string]: any;
     };
 }
-export interface ExecutionOptions {
-    defaultCaller?: AccountId32Like;
-}
 type HasGetter<T> = T extends {
     get: (...args: any[]) => any;
 } ? true : false;
 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 SolGenericContractApi<Rv extends RpcVersion = RpcVersion, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends GenericContractApi<Rv, ChainApi, 'sol'> {
+}

package/types/index.js

@@ -1,4 +1,3 @@
+export * from './ink/index.js';
+export * from './sol/index.js';
 export * from './shared.js';
-export * from './v4.js';
-export * from './v5.js';
-export * from './v6.js';

package/types/ink/index.d.ts

@@ -0,0 +1,9 @@
+import { ContractEventV4, ContractMetadataV4 } from './v4.js';
+import { ContractEventV5, ContractMetadataV5 } from './v5.js';
+import { ContractMetadataV6 } from './v6.js';
+export * from './shared.js';
+export * from './v4.js';
+export * from './v5.js';
+export * from './v6.js';
+export type ContractEventMeta = ContractEventV4 | ContractEventV5;
+export type ContractMetadata = ContractMetadataV4 | ContractMetadataV5 | ContractMetadataV6;

package/types/ink/index.js

@@ -0,0 +1,4 @@
+export * from './shared.js';
+export * from './v4.js';
+export * from './v5.js';
+export * from './v6.js';

package/types/ink/shared.d.ts

@@ -0,0 +1,100 @@
+export interface ContractInformation {
+    name: string;
+    version: string;
+    authors: string[];
+}
+export interface ContractSource {
+    hash: string;
+    language: string;
+    compiler: string;
+    build_info: BuildInfo;
+}
+export interface BuildInfo {
+    build_mode: string;
+    cargo_contract_version: string;
+    rust_toolchain: string;
+}
+export interface WasmOptSettings {
+    keep_debug_symbols: boolean;
+    optimization_passes: string;
+}
+export interface ContractMessageArg {
+    label: string;
+    type: ContractTypeInfo;
+}
+export interface ContractTypeInfo {
+    displayName: string[];
+    type: number;
+}
+export interface ContractMessage {
+    args: ContractMessageArg[];
+    default: boolean;
+    docs: string[];
+    label: string;
+    payable: boolean;
+    returnType: ContractTypeInfo;
+    selector: string;
+}
+export interface ContractConstructorMessage extends ContractMessage {
+}
+export interface ContractCallMessage extends ContractMessage {
+    mutates: boolean;
+}
+export interface ContractType {
+    id: number;
+    type: {
+        def: ContractTypeDef;
+        path?: string[];
+        params?: ParamInfo[];
+    };
+}
+export interface ContractTypeDef {
+    composite?: CompositeType;
+    array?: ArrayType;
+    primitive?: string;
+    sequence?: SequenceType;
+    variant?: VariantType;
+    tuple?: number[];
+    compact?: CompactType;
+    bitsequence?: BitSequenceType;
+}
+export interface BitSequenceType {
+    bit_order_type: number;
+    bit_store_type: number;
+}
+export interface CompactType {
+    type: number;
+}
+export interface CompositeType {
+    fields?: {
+        type: number;
+        typeName: string;
+        name?: string;
+    }[];
+}
+export interface ArrayType {
+    len: number;
+    type: number;
+}
+export interface SequenceType {
+    type: number;
+}
+export interface VariantType {
+    variants?: {
+        index: number;
+        name: string;
+        fields?: {
+            type: number;
+            typeName?: string;
+            name?: string;
+        }[];
+    }[];
+}
+export interface ParamInfo {
+    name: string;
+    type: number;
+}
+export interface ContractEventArg extends ContractMessageArg {
+    docs: string[];
+    indexed: boolean;
+}

package/types/ink/v6.js

@@ -0,0 +1 @@
+export {};

package/types/shared.d.ts

@@ -1,101 +1,82 @@
+import { AccountId32Like, Bytes, BytesLike, DispatchError, H256, Weight } from '@dedot/codecs';
+import { Result } from '@dedot/shape';
+import { GenericSubstrateApi } from '@dedot/types';
 export type ContractAddress = string;
-export interface ContractInformation {
-    name: string;
-    version: string;
-    authors: string[];
-}
-export interface ContractSource {
-    hash: string;
-    language: string;
-    compiler: string;
-    build_info: BuildInfo;
-}
-export interface BuildInfo {
-    build_mode: string;
-    cargo_contract_version: string;
-    rust_toolchain: string;
-}
-export interface WasmOptSettings {
-    keep_debug_symbols: boolean;
-    optimization_passes: string;
-}
-export interface ContractMessageArg {
-    label: string;
-    type: ContractTypeInfo;
-}
-export interface ContractTypeInfo {
-    displayName: string[];
-    type: number;
-}
-export interface ContractMessage {
-    args: ContractMessageArg[];
-    default: boolean;
-    docs: string[];
-    label: string;
-    payable: boolean;
-    returnType: ContractTypeInfo;
-    selector: string;
-}
-export interface ContractConstructorMessage extends ContractMessage {
-}
-export interface ContractCallMessage extends ContractMessage {
-    mutates: boolean;
-}
-export interface ContractType {
-    id: number;
-    type: {
-        def: ContractTypeDef;
-        path?: string[];
-        params?: ParamInfo[];
+/**
+ * Flags used by a contract to customize exit behaviour.
+ * Ref: https://github.com/paritytech/polkadot-sdk/blob/d2fd53645654d3b8e12cbf735b67b93078d70113/substrate/frame/contracts/uapi/src/flags.rs#L23-L26
+ */
+export type ReturnFlags = {
+    bits: number;
+    revert: boolean;
+};
+export interface GenericContractCallResult<DecodedData = any, ContractResult = any> {
+    data: DecodedData;
+    raw: ContractResult;
+    flags: ReturnFlags;
+    inputData: Bytes;
+}
+export interface GenericConstructorCallResult<DecodedData = any, ContractResult = any> extends GenericContractCallResult<DecodedData, ContractResult> {
+    address: ContractAddress;
+}
+export type ContractCode = {
+    type: 'Upload';
+    value: Bytes;
+} | {
+    type: 'Existing';
+    value: H256;
+};
+export type WeightV2 = {
+    refTime: bigint;
+    proofSize: bigint;
+};
+export type StorageDeposit = {
+    type: 'Refund';
+    value: bigint;
+} | {
+    type: 'Charge';
+    value: bigint;
+};
+export type ExecReturnValue = {
+    flags: {
+        bits: number;
     };
-}
-export interface ContractTypeDef {
-    composite?: CompositeType;
-    array?: ArrayType;
-    primitive?: string;
-    sequence?: SequenceType;
-    variant?: VariantType;
-    tuple?: number[];
-    compact?: CompactType;
-    bitsequence?: BitSequenceType;
-}
-export interface BitSequenceType {
-    bit_order_type: number;
-    bit_store_type: number;
-}
-export interface CompactType {
-    type: number;
-}
-export interface CompositeType {
-    fields?: {
-        type: number;
-        typeName: string;
-        name?: string;
-    }[];
-}
-export interface ArrayType {
-    len: number;
-    type: number;
-}
-export interface SequenceType {
-    type: number;
-}
-export interface VariantType {
-    variants?: {
-        index: number;
-        name: string;
-        fields?: {
-            type: number;
-            typeName?: string;
-            name?: string;
-        }[];
-    }[];
-}
-export interface ParamInfo {
-    name: string;
-    type: number;
-}
-export interface ContractEventArg extends ContractMessageArg {
-    docs: string[];
-    indexed: boolean;
-}
+    data: Bytes;
+};
+export type InstantiateReturnValue = {
+    result: ExecReturnValue;
+    address: ContractAddress;
+};
+export type ContractCallResult<_ extends GenericSubstrateApi> = {
+    gasConsumed: WeightV2;
+    gasRequired: WeightV2;
+    storageDeposit: StorageDeposit;
+    debugMessage?: Bytes;
+    result: Result<ExecReturnValue, DispatchError>;
+};
+export type ContractInstantiateResult<_ extends GenericSubstrateApi> = {
+    gasConsumed: WeightV2;
+    gasRequired: WeightV2;
+    storageDeposit: StorageDeposit;
+    debugMessage?: Bytes;
+    result: Result<InstantiateReturnValue, DispatchError>;
+};
+export interface ExecutionOptions {
+    defaultCaller?: AccountId32Like;
+}
+export type CallOptions = {
+    value?: bigint;
+    gasLimit?: Weight | undefined;
+    storageDepositLimit?: bigint | undefined;
+};
+export type ConstructorCallOptions = CallOptions & {
+    salt?: BytesLike;
+    caller?: AccountId32Like;
+};
+export type ConstructorTxOptions = CallOptions & {
+    salt?: BytesLike;
+};
+export type ContractCallOptions = CallOptions & {
+    caller?: AccountId32Like;
+};
+export type ContractTxOptions = CallOptions;

package/types/sol/abi.d.ts

@@ -0,0 +1,45 @@
+export interface SolAbiTypeDef {
+    internalType?: string;
+    components?: SolAbiTypeDef[];
+    name: string;
+    type: string;
+}
+export interface SolAbiInput extends SolAbiTypeDef {
+}
+export interface SolAbiOutput extends SolAbiTypeDef {
+}
+export interface SolAbiFunction {
+    inputs: SolAbiInput[];
+    name: string;
+    outputs: SolAbiOutput[];
+    stateMutability: 'pure' | 'view' | 'nonpayable' | 'payable';
+    type: 'function';
+}
+export interface SolAbiConstructor {
+    inputs: SolAbiInput[];
+    stateMutability: 'nonpayable' | 'payable';
+    type: 'constructor';
+}
+export interface SolAbiEvent {
+    anonymous?: boolean;
+    inputs: (SolAbiInput & {
+        indexed?: boolean;
+    })[];
+    name: string;
+    type: 'event';
+}
+export interface SolAbiError {
+    inputs: SolAbiInput[];
+    name: string;
+    type: 'error';
+}
+export interface SolAbiFallback {
+    type: 'fallback';
+    stateMutability: 'nonpayable' | 'payable';
+}
+export interface SolAbiReceive {
+    type: 'receive';
+    stateMutability: 'payable';
+}
+export type SolAbiItem = SolAbiFunction | SolAbiConstructor | SolAbiEvent | SolAbiError | SolAbiFallback | SolAbiReceive;
+export type SolAbi = SolAbiItem[];

package/types/sol/abi.js

@@ -0,0 +1 @@
+export {};

package/types/sol/index.d.ts

@@ -0,0 +1 @@
+export * from './abi.js';

package/types/sol/index.js

@@ -0,0 +1 @@
+export * from './abi.js';

package/utils/address.js

@@ -1,6 +1,6 @@
 import { AccountId20, AccountId32 } from '@dedot/codecs';
 import { concatU8a, hexToU8a, keccakAsU8a, toHex, toU8a, u8aToHex } from '@dedot/utils';
-import { RLP } from '@ethereumjs/rlp';
+import { toRlp } from 'viem/utils';
 /**
  * Calculate new contract's address is based on the deployer's address and a nonce
  *
@@ -10,7 +10,7 @@ import { RLP } from '@ethereumjs/rlp';
  * @param nonce
  */
 export function CREATE1(deployer, nonce) {
-    const encodedData = RLP.encode([new AccountId20(deployer).raw, toHex(nonce)]);
+    const encodedData = toRlp([new AccountId20(deployer).raw, toHex(nonce)]);
     const hash = keccakAsU8a(encodedData);
     return u8aToHex(hash.subarray(12));
 }

package/utils/ensure.d.ts

@@ -1,13 +1,14 @@
 import { ISubstrateClient } from '@dedot/api';
 import { SubstrateApi } from '@dedot/api/chaintypes';
-import { Hash } from '@dedot/codecs';
+import { AccountId32Like, Hash } from '@dedot/codecs';
 import { RpcVersion } from '@dedot/types';
-import { TypinkRegistry } from 'src/TypinkRegistry';
-import { ContractAddress, LooseContractMetadata } from 'src/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]>, registry: TypinkRegistry): void;
-export declare function ensureContractPresence(client: ISubstrateClient<SubstrateApi[RpcVersion]>, registry: TypinkRegistry, address: ContractAddress): Promise<void>;
-export declare function ensureValidContractAddress(address: ContractAddress, registry: TypinkRegistry): void;
-export declare function ensureValidCodeHashOrCode(codeHashOrCode: Hash | Uint8Array | string, registry: TypinkRegistry): 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 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;
 export declare function ensureSupportedContractMetadataVersion(metadata: LooseContractMetadata): void;
 export declare function ensureParamsLength(expectedArgsLength: number, actualParamsLength: number): void;