@dedot/api 0.18.8 → 1.0.0

package/client/explorer/V2BlockExplorer.js

@@ -0,0 +1,70 @@
+import { $Header } from '@dedot/codecs';
+import { assert } from '@dedot/utils';
+/**
+ * @name V2BlockExplorer
+ * @description Block explorer implementation for V2Client using JSON-RPC v2 (ChainHead API)
+ */
+export class V2BlockExplorer {
+    #chainHead;
+    #archive;
+    constructor(client) {
+        this.#chainHead = client.chainHead;
+        this.#archive = client.archive;
+    }
+    /**
+     * Convert PinnedBlock to BlockInfo format
+     */
+    toBlockInfo(block) {
+        return {
+            hash: block.hash,
+            number: block.number,
+            parent: block.parent,
+            runtimeUpgraded: block.runtimeUpgraded === true,
+        };
+    }
+    best(callback) {
+        if (callback) {
+            // Subscribe mode
+            const handler = (block) => {
+                callback(this.toBlockInfo(block));
+            };
+            this.#chainHead.bestBlock().then((block) => {
+                handler(block);
+            });
+            return this.#chainHead.on('bestBlock', handler);
+        }
+        else {
+            // One-time query
+            return this.#chainHead.bestBlock().then((block) => this.toBlockInfo(block));
+        }
+    }
+    finalized(callback) {
+        if (callback) {
+            // Subscribe mode
+            const handler = (block) => {
+                callback(this.toBlockInfo(block));
+            };
+            this.#chainHead.finalizedBlock().then((block) => {
+                handler(block);
+            });
+            return this.#chainHead.on('finalizedBlock', handler);
+        }
+        else {
+            return this.#chainHead.finalizedBlock().then((block) => this.toBlockInfo(block));
+        }
+    }
+    /**
+     * Get the header of a block by number or hash
+     */
+    async header(hash) {
+        const rawHeader = await this.#chainHead.header(hash);
+        assert(rawHeader, `Header not found for block ${hash}`);
+        return $Header.tryDecode(rawHeader);
+    }
+    /**
+     * Get the body (transactions) of a block by number or hash
+     */
+    async body(hash) {
+        return await this.#chainHead.body(hash);
+    }
+}

package/client/explorer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './V2BlockExplorer.js';
+export * from './LegacyBlockExplorer.js';

package/client/explorer/index.js

@@ -0,0 +1,2 @@
+export * from './V2BlockExplorer.js';
+export * from './LegacyBlockExplorer.js';

package/client/utils.d.ts

@@ -0,0 +1,18 @@
+import { BlockHash, Header, Metadata } from '@dedot/codecs';
+import { HashFn } from '@dedot/utils';
+/**
+ * Detects the hasher from V16 metadata by looking at the System pallet's Hashing associated type
+ *
+ * @param metadata - The metadata to inspect
+ * @returns The detected HashFn or undefined if detection fails
+ */
+export declare function detectHasherFromMetadata(metadata: Metadata): HashFn | undefined;
+/**
+ * Detects the hasher by trying different hash functions on a block header
+ * and comparing the result with the expected block hash
+ *
+ * @param header - The block header to hash
+ * @param expectedHash - The expected block hash
+ * @returns The matching HashFn or undefined if no match is found
+ */
+export declare function detectHasherFromHeader(header: Header, expectedHash: BlockHash): HashFn | undefined;

package/client/utils.js

@@ -0,0 +1,52 @@
+import { $Header } from '@dedot/codecs';
+import { blake2_256, keccak_256, u8aToHex } from '@dedot/utils';
+const HASHERS = {
+    BlakeTwo256: blake2_256, // commonly used in polkadot-sdk based-chains
+    Keccak256: keccak_256, // widely used in EVM-compatible chains, e.g: Hyperbridge
+};
+/**
+ * Detects the hasher from V16 metadata by looking at the System pallet's Hashing associated type
+ *
+ * @param metadata - The metadata to inspect
+ * @returns The detected HashFn or undefined if detection fails
+ */
+export function detectHasherFromMetadata(metadata) {
+    try {
+        const latest = metadata.latest;
+        // Find the System pallet
+        const systemPallet = latest.pallets.find((p) => p.name === 'System');
+        if (!systemPallet)
+            return undefined;
+        // Find the Hashing associated type
+        const hashingType = systemPallet.associatedTypes.find((t) => t.name === 'Hashing');
+        if (!hashingType)
+            return undefined;
+        // Get the type definition
+        const typeDef = latest.types[hashingType.typeId];
+        if (!typeDef)
+            return undefined;
+        // Get the hasher name from the type path (last element)
+        const hasherName = typeDef.path.at(-1);
+        if (!hasherName)
+            return undefined;
+        return HASHERS[hasherName];
+    }
+    catch { }
+    return undefined;
+}
+/**
+ * Detects the hasher by trying different hash functions on a block header
+ * and comparing the result with the expected block hash
+ *
+ * @param header - The block header to hash
+ * @param expectedHash - The expected block hash
+ * @returns The matching HashFn or undefined if no match is found
+ */
+export function detectHasherFromHeader(header, expectedHash) {
+    try {
+        const encodedHeader = $Header.tryEncode(header);
+        return Object.values(HASHERS).find((h) => u8aToHex(h(encodedHeader)) === expectedHash);
+    }
+    catch { }
+    return undefined;
+}

package/executor/ConstantExecutor.d.ts

@@ -1,10 +1,9 @@
-import { GenericSubstrateApi } from '@dedot/types';
 import { Executor } from './Executor.js';
 /**
  * @name ConstantExecutor
  *
  * Find & decode the constant value from metadata
  */
-export declare class ConstantExecutor<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends Executor<ChainApi> {
+export declare class ConstantExecutor extends Executor {
     doExecute(pallet: string, constantName: string): unknown;
 }

package/executor/ErrorExecutor.d.ts

@@ -1,10 +1,10 @@
-import type { GenericPalletError, GenericSubstrateApi } from '@dedot/types';
+import type { GenericPalletError } from '@dedot/types';
 import { Executor } from './Executor.js';
 /**
  * @name ErrorExecutor
  * @description Find pallet error information from metadata
  */
-export declare class ErrorExecutor<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends Executor<ChainApi> {
+export declare class ErrorExecutor extends Executor {
     #private;
     doExecute(pallet: string, errorName: string): GenericPalletError;
 }

package/executor/EventExecutor.d.ts

@@ -1,10 +1,10 @@
-import type { GenericPalletEvent, GenericSubstrateApi } from '@dedot/types';
+import type { GenericPalletEvent } from '@dedot/types';
 import { Executor } from './Executor.js';
 /**
  * @name EventExecutor
  * @description Find pallet event information from metadata
  */
-export declare class EventExecutor<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends Executor<ChainApi> {
+export declare class EventExecutor extends Executor {
     #private;
     doExecute(pallet: string, eventName: string): GenericPalletEvent;
 }

package/executor/EventExecutor.js

@@ -56,6 +56,7 @@ export class EventExecutor extends Executor {
             palletIndex: targetPallet.index,
         };
         return {
+            // @ts-ignore
             is,
             find,
             filter,

package/executor/Executor.d.ts

@@ -1,5 +1,4 @@
 import type { BlockHash, PalletDefLatest } from '@dedot/codecs';
-import type { GenericSubstrateApi } from '@dedot/types';
 import { HexString } from '@dedot/utils';
 import { ISubstrateClient, ISubstrateClientAt } from '../types.js';
 export interface StateCallParams {
@@ -11,12 +10,12 @@ export interface StateCallParams {
  * @name Executor
  * @description Execution abstraction for a specific action
  */
-export declare abstract class Executor<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> {
+export declare abstract class Executor {
     #private;
-    readonly client: ISubstrateClientAt<ChainApi> | ISubstrateClient<ChainApi, any>;
-    constructor(client: ISubstrateClientAt<ChainApi> | ISubstrateClient<ChainApi, any>, atBlockHash?: BlockHash);
+    readonly client: ISubstrateClientAt<any> | ISubstrateClient<any, any>;
+    constructor(client: ISubstrateClientAt<any> | ISubstrateClient<any, any>, atBlockHash?: BlockHash);
     get atBlockHash(): any;
-    get registry(): import("@dedot/codecs").PortableRegistry<ChainApi["types"]>;
+    get registry(): import("@dedot/codecs").PortableRegistry<any>;
     get metadata(): {
         types: {
             id: number;

package/executor/RuntimeApiExecutor.d.ts

@@ -1,4 +1,4 @@
-import type { GenericRuntimeApiMethod, GenericSubstrateApi, RuntimeApiMethodParamSpec, RuntimeApiMethodSpec, RuntimeApiSpec } from '@dedot/types';
+import type { GenericRuntimeApiMethod, RuntimeApiMethodParamSpec, RuntimeApiMethodSpec, RuntimeApiSpec } from '@dedot/types';
 import { Executor } from './Executor.js';
 export declare const FallbackRuntimeApis: Record<string, number>;
 export declare const FallbackRuntimeApiSpecs: {
@@ -11,7 +11,7 @@ export declare const FallbackRuntimeApiSpecs: {
  * or defined externally when initializing `Dedot` instance
  * via `ApiOptions.runtimeApis` option.
  */
-export declare class RuntimeApiExecutor<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends Executor<ChainApi> {
+export declare class RuntimeApiExecutor extends Executor {
     #private;
     doExecute(runtimeApi: string, method: string): GenericRuntimeApiMethod;
     tryDecode(callSpec: RuntimeApiMethodSpec, raw: any): unknown;

package/executor/RuntimeApiExecutor.js

@@ -1,6 +1,8 @@
 import { Metadata, toRuntimeApiMethods, toRuntimeApiSpecs } from '@dedot/runtime-specs';
-import { assert, calcRuntimeApiHash, concatU8a, isNumber, stringPascalCase, stringSnakeCase, u8aToHex, UnknownApiError, } from '@dedot/utils';
+import * as $ from '@dedot/shape';
+import { assert, calcRuntimeApiHash, isNumber, stringPascalCase, stringSnakeCase, u8aToHex, UnknownApiError, } from '@dedot/utils';
 import { Executor } from './Executor.js';
+import { buildCompatibilityError, padArgsForOptionalParams } from './validation-helpers.js';
 export const FallbackRuntimeApis = { '0x37e397fc7c91f5e4': 2 };
 export const FallbackRuntimeApiSpecs = { Metadata };
 /**
@@ -19,8 +21,30 @@ export class RuntimeApiExecutor extends Executor {
         assert(callSpec, new UnknownApiError(`Runtime api spec not found for ${callName}`));
         const callFn = async (...args) => {
             const { params } = callSpec;
-            const formattedInputs = params.map((param, index) => this.tryEncode(param, args[index]));
-            const bytes = u8aToHex(concatU8a(...formattedInputs));
+            // Pad args with undefined for missing trailing optional parameters
+            const withCodecs = params.every((p) => !!p.codec);
+            const paddedArgs = padArgsForOptionalParams(args, params, withCodecs
+                ? {} // intentional trick to pass-by client initialization
+                : this.registry);
+            const $ParamsTuple = $.Tuple(...params.map((param) => this.#findCodec(param, // --
+            `Codec not found for param ${param.name}`)));
+            // Enhanced validation with detailed error messages
+            try {
+                $ParamsTuple.assert?.(paddedArgs);
+            }
+            catch (error) {
+                // Enhance Shape assertion errors with detailed compatibility information
+                if (error instanceof $.ShapeAssertError) {
+                    throw buildCompatibilityError(error, // --
+                    params, args, {
+                        apiName: `${runtimeApi}.${method}`,
+                        registry: this.registry,
+                    });
+                }
+                throw error;
+            }
+            const formattedInputs = $ParamsTuple.tryEncode(paddedArgs);
+            const bytes = u8aToHex(formattedInputs);
             const callParams = {
                 func: callName,
                 params: bytes,

package/executor/StorageQueryExecutor.d.ts

@@ -1,12 +1,13 @@
 import { BlockHash, Option, StorageData, StorageKey } from '@dedot/codecs';
-import type { AsyncMethod, Callback, GenericStorageQuery, GenericSubstrateApi, Unsub } from '@dedot/types';
+import type { AsyncMethod, Callback, GenericStorageQuery, Unsub } from '@dedot/types';
 import { type BaseStorageQuery, QueryableStorage } from '../storage/index.js';
 import { Executor } from './Executor.js';
 /**
  * @name StorageQueryExecutor
  * @description Execute a query to on-chain storage
  */
-export declare class StorageQueryExecutor<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends Executor<ChainApi> {
+export declare class StorageQueryExecutor extends Executor {
+    #private;
     doExecute(pallet: string, storage: string): GenericStorageQuery;
     protected exposeStorageMapMethods(entry: QueryableStorage): Record<string, AsyncMethod>;
     protected getStorageQuery(): BaseStorageQuery;

package/executor/StorageQueryExecutor.js

@@ -1,6 +1,8 @@
-import { assert, isFunction, isObject } from '@dedot/utils';
+import * as $ from '@dedot/shape';
+import { assert, isFunction, isObject, stringCamelCase } from '@dedot/utils';
 import { LegacyStorageQuery, QueryableStorage } from '../storage/index.js';
 import { Executor } from './Executor.js';
+import { buildCompatibilityError } from './validation-helpers.js';
 const DEFAULT_KEYS_PAGE_SIZE = 1000;
 const DEFAULT_ENTRIES_PAGE_SIZE = 250;
 /**
@@ -29,6 +31,8 @@ export class StorageQueryExecutor extends Executor {
         };
         const queryFn = async (...args) => {
             const [inArgs, callback] = extractArgs(args);
+            // Validate storage inputs before encoding
+            this.#validateStorageInputs(entry, inArgs.at(0));
             const encodedKey = entry.encodeKey(inArgs.at(0));
             // if a callback is passed, make a storage subscription and return an unsub function
             if (callback) {
@@ -55,6 +59,10 @@ export class StorageQueryExecutor extends Executor {
                 const [inArgs, callback] = extractArgs(args);
                 const multiArgs = inArgs.at(0);
                 assert(Array.isArray(multiArgs), 'First param for multi query should be an array');
+                // Validate each argument before encoding
+                multiArgs.forEach((arg, index) => {
+                    this.#validateStorageInputs(entry, arg, index);
+                });
                 const encodedKeys = multiArgs.map((arg) => entry.encodeKey(arg));
                 // if a callback is passed, make a storage subscription and return an unsub function
                 if (callback) {
@@ -76,7 +84,7 @@ export class StorageQueryExecutor extends Executor {
     exposeStorageMapMethods(entry) {
         const rawKeys = async (partialInput, pagination) => {
             const pageSize = pagination?.pageSize || DEFAULT_KEYS_PAGE_SIZE;
-            const startKey = pagination?.startKey || entry.prefixKey;
+            const startKey = pagination?.startKey;
             return await this.client.rpc.state_getKeysPaged(entry.encodeKey(partialInput, true), pageSize, startKey, this.atBlockHash);
         };
         const extractArgs = (args) => {
@@ -96,7 +104,88 @@ export class StorageQueryExecutor extends Executor {
             const storageMap = await this.queryStorage(storageKeys, this.atBlockHash);
             return storageKeys.map((key) => [entry.decodeKey(key), entry.decodeValue(storageMap[key])]);
         };
-        return { pagedKeys, pagedEntries };
+        const entries = async (...args) => {
+            const [inArgs] = extractArgs(args);
+            const allEntries = [];
+            let startKey;
+            while (true) {
+                const pagination = {
+                    pageSize: DEFAULT_ENTRIES_PAGE_SIZE,
+                    ...(startKey ? { startKey } : {}),
+                };
+                const storageKeys = await rawKeys(inArgs, pagination);
+                if (storageKeys.length === 0)
+                    break;
+                const storageMap = await this.queryStorage(storageKeys, this.atBlockHash);
+                const pageEntries = storageKeys.map((key) => [
+                    entry.decodeKey(key),
+                    entry.decodeValue(storageMap[key]),
+                ]);
+                allEntries.push(...pageEntries);
+                if (storageKeys.length < DEFAULT_ENTRIES_PAGE_SIZE)
+                    break;
+                startKey = storageKeys[storageKeys.length - 1];
+            }
+            return allEntries;
+        };
+        return { entries, pagedKeys, pagedEntries };
+    }
+    /**
+     * Validate storage query inputs before encoding
+     * @param entry - QueryableStorage instance
+     * @param keyInput - Input keys to validate
+     * @param itemIndex - Optional index for multi query error messages
+     */
+    #validateStorageInputs(entry, keyInput, itemIndex) {
+        const { storageType } = entry.storageEntry;
+        // Plain storage doesn't require validation
+        if (storageType.type === 'Plain') {
+            return;
+        }
+        if (storageType.type === 'Map') {
+            const { hashers, keyTypeId } = storageType.value;
+            const requiredKeys = hashers.length;
+            // Extract keyTypeIds for multi-key storage
+            let keyTypeIds = [keyTypeId];
+            if (hashers.length > 1) {
+                const { typeDef } = this.registry.findType(keyTypeId);
+                assert(typeDef.type === 'Tuple', 'Key type should be a tuple!');
+                keyTypeIds = typeDef.value.fields;
+            }
+            // Normalize input to array format
+            let keys;
+            if (requiredKeys === 1) {
+                // Single key: accept both single value or array
+                keys = Array.isArray(keyInput) ? keyInput : [keyInput];
+            }
+            else {
+                // Multiple keys: must be array
+                assert(Array.isArray(keyInput), 'Multi-key storage requires array input');
+                keys = keyInput;
+            }
+            // Build parameter specs for error messages
+            const paramSpecs = keyTypeIds.map((typeId, index) => ({
+                name: `key${index}`,
+                typeId,
+            }));
+            // Create tuple codec for validation
+            const $ParamsTuple = $.Tuple(...keyTypeIds.map((id) => this.registry.findCodec(id)));
+            // Validate inputs
+            try {
+                $ParamsTuple.assert?.(keys);
+            }
+            catch (error) {
+                if (error instanceof $.ShapeAssertError) {
+                    throw buildCompatibilityError(error, // -
+                    paramSpecs, keys, {
+                        apiName: `${stringCamelCase(entry.pallet.name)}.${stringCamelCase(entry.storageEntry.name)}`,
+                        registry: this.registry,
+                        itemIndex,
+                    });
+                }
+                throw error;
+            }
+        }
     }
     getStorageQuery() {
         return new LegacyStorageQuery(this.client);

package/executor/TxExecutor.d.ts

@@ -1,10 +1,10 @@
-import type { GenericSubstrateApi, GenericTxCall, IRuntimeTxCall } from '@dedot/types';
+import type { GenericTxCall, IRuntimeTxCall } from '@dedot/types';
 import { Executor } from './Executor.js';
 /**
  * @name TxExecutor
  * @description Execute a transaction instruction, returns a submittable extrinsic
  */
-export declare class TxExecutor<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends Executor<ChainApi> {
+export declare class TxExecutor extends Executor {
     doExecute(pallet: string, functionName: string): GenericTxCall;
     protected createExtrinsic(call: IRuntimeTxCall): any;
 }

package/executor/ViewFunctionExecutor.d.ts

@@ -1,10 +1,10 @@
-import type { GenericSubstrateApi, GenericViewFunction } from '@dedot/types';
+import type { GenericViewFunction } from '@dedot/types';
 import { Executor } from './Executor.js';
 /**
  * @name ViewFunctionExecutor
  * @description Execute view functions using the runtimeViewFunction API
  */
-export declare class ViewFunctionExecutor<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends Executor<ChainApi> {
+export declare class ViewFunctionExecutor extends Executor {
     #private;
     doExecute(pallet: string, viewFunction: string): GenericViewFunction;
 }

package/executor/ViewFunctionExecutor.js

@@ -1,6 +1,7 @@
 import * as $ from '@dedot/shape';
-import { assert, concatU8a, stringCamelCase, u8aToHex, UnknownApiError, DedotError } from '@dedot/utils';
+import { assert, concatU8a, DedotError, stringCamelCase, u8aToHex, UnknownApiError } from '@dedot/utils';
 import { Executor } from './Executor.js';
+import { buildCompatibilityError, padArgsForOptionalParams } from './validation-helpers.js';
 const RUNTIME_API_NAME = 'RuntimeViewFunction';
 const METHOD_NAME = 'execute_view_function';
 /**
@@ -14,8 +15,26 @@ export class ViewFunctionExecutor extends Executor {
         assert(viewFunctionDef, new UnknownApiError(`View function not found: ${pallet}.${viewFunction}`));
         const callFn = async (...args) => {
             const { inputs, id, output } = viewFunctionDef;
-            const formattedInputs = inputs.map(({ typeId }, index) => this.registry.findCodec(typeId).tryEncode(args[index]));
-            const bytes = u8aToHex(concatU8a(id, $.Vec($.u8).tryEncode(concatU8a(...formattedInputs))));
+            // Pad args with undefined for missing trailing optional parameters
+            const paddedArgs = padArgsForOptionalParams(args, inputs, this.registry);
+            const $ParamsTuple = $.Tuple(...inputs.map((param) => this.registry.findCodec(param.typeId)));
+            // Enhanced validation with detailed error messages
+            try {
+                $ParamsTuple.assert?.(paddedArgs);
+            }
+            catch (error) {
+                // Enhance Shape assertion errors with detailed compatibility information
+                if (error instanceof $.ShapeAssertError) {
+                    throw buildCompatibilityError(error, // --
+                    inputs, args, {
+                        apiName: `${pallet}.${viewFunction}`,
+                        registry: this.registry,
+                    });
+                }
+                throw error;
+            }
+            const formattedInputs = $ParamsTuple.tryEncode(paddedArgs);
+            const bytes = u8aToHex(concatU8a(id, $.Vec($.u8).tryEncode(formattedInputs)));
             const func = `${RUNTIME_API_NAME}_${METHOD_NAME}`;
             const callParams = {
                 func,

package/executor/v2/RuntimeApiExecutorV2.d.ts

@@ -1,5 +1,4 @@
 import type { BlockHash } from '@dedot/codecs';
-import type { GenericSubstrateApi } from '@dedot/types';
 import { HexString } from '@dedot/utils';
 import { ChainHead } from '../../json-rpc/index.js';
 import { ISubstrateClient, ISubstrateClientAt } from '../../types.js';
@@ -8,8 +7,8 @@ import { RuntimeApiExecutor } from '../RuntimeApiExecutor.js';
 /**
  * @name RuntimeApiExecutorV2
  */
-export declare class RuntimeApiExecutorV2<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends RuntimeApiExecutor<ChainApi> {
+export declare class RuntimeApiExecutorV2 extends RuntimeApiExecutor {
     chainHead: ChainHead;
-    constructor(client: ISubstrateClientAt<ChainApi> | ISubstrateClient<ChainApi, any>, chainHead: ChainHead, atBlockHash?: BlockHash);
+    constructor(client: ISubstrateClientAt<any> | ISubstrateClient<any, any>, chainHead: ChainHead, atBlockHash?: BlockHash);
     protected stateCall(callParams: StateCallParams): Promise<HexString>;
 }

package/executor/v2/StorageQueryExecutorV2.d.ts

@@ -1,5 +1,5 @@
 import { BlockHash } from '@dedot/codecs';
-import type { AsyncMethod, GenericSubstrateApi } from '@dedot/types';
+import type { AsyncMethod } from '@dedot/types';
 import { ChainHead } from '../../json-rpc/index.js';
 import { type BaseStorageQuery, QueryableStorage } from '../../storage/index.js';
 import { ISubstrateClient, ISubstrateClientAt } from '../../types.js';
@@ -7,9 +7,9 @@ import { StorageQueryExecutor } from '../StorageQueryExecutor.js';
 /**
  * @name StorageQueryExecutorV2
  */
-export declare class StorageQueryExecutorV2<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends StorageQueryExecutor<ChainApi> {
+export declare class StorageQueryExecutorV2 extends StorageQueryExecutor {
     chainHead: ChainHead;
-    constructor(client: ISubstrateClientAt<ChainApi> | ISubstrateClient<ChainApi, any>, chainHead: ChainHead, atBlockHash?: BlockHash);
+    constructor(client: ISubstrateClientAt<any> | ISubstrateClient<any, any>, chainHead: ChainHead, atBlockHash?: BlockHash);
     protected exposeStorageMapMethods(entry: QueryableStorage): Record<string, AsyncMethod>;
     protected getStorageQuery(): BaseStorageQuery;
 }

package/executor/v2/StorageQueryExecutorV2.js

@@ -1,4 +1,4 @@
-import { assert } from '@dedot/utils';
+import { assert, DedotError } from '@dedot/utils';
 import { NewStorageQuery } from '../../storage/index.js';
 import { StorageQueryExecutor } from '../StorageQueryExecutor.js';
 /**
@@ -25,7 +25,13 @@ export class StorageQueryExecutorV2 extends StorageQueryExecutor {
                 entry.decodeValue(value),
             ]);
         };
-        return { entries };
+        const pagedKeys = () => {
+            throw new DedotError('The pagedKeys method is not yet available via the new JSON-RPC (v2) specification. Please use the legacy client instead.');
+        };
+        const pagedEntries = () => {
+            throw new DedotError('The pagedEntries method is not yet available via the new JSON-RPC (v2) specification. Please use the legacy client instead.');
+        };
+        return { entries, pagedKeys, pagedEntries };
     }
     getStorageQuery() {
         // @ts-ignore little trick to make querying data client.at instance works here,

package/executor/v2/TxExecutorV2.d.ts

@@ -1,12 +1,12 @@
-import { IRuntimeTxCall, RpcVersion, VersionedGenericSubstrateApi } from '@dedot/types';
-import { DedotClient } from '../../client/index.js';
+import { IRuntimeTxCall } from '@dedot/types';
+import { V2Client } from '../../client/V2Client.js';
 import { TxExecutor } from '../TxExecutor.js';
 /**
  * @name TxExecutor
  * @description Execute a transaction instruction, returns a submittable extrinsic
  */
-export declare class TxExecutorV2<ChainApi extends VersionedGenericSubstrateApi = VersionedGenericSubstrateApi> extends TxExecutor<ChainApi[RpcVersion]> {
-    readonly client: DedotClient<ChainApi>;
-    constructor(client: DedotClient<ChainApi>);
+export declare class TxExecutorV2 extends TxExecutor {
+    readonly client: V2Client<any>;
+    constructor(client: V2Client<any>);
     protected createExtrinsic(call: IRuntimeTxCall): any;
 }

package/executor/v2/ViewFunctionExecutorV2.d.ts

@@ -1,4 +1,3 @@
-import type { GenericSubstrateApi } from '@dedot/types';
 import { HexString } from '@dedot/utils';
 import { ChainHead } from '../../json-rpc/index.js';
 import { ISubstrateClient, ISubstrateClientAt } from '../../types.js';
@@ -7,8 +6,8 @@ import { ViewFunctionExecutor } from '../ViewFunctionExecutor.js';
 /**
  * @name ViewFunctionExecutorV2
  */
-export declare class ViewFunctionExecutorV2<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends ViewFunctionExecutor<ChainApi> {
+export declare class ViewFunctionExecutorV2 extends ViewFunctionExecutor {
     chainHead: ChainHead;
-    constructor(client: ISubstrateClientAt<ChainApi> | ISubstrateClient<ChainApi, any>, chainHead: ChainHead);
+    constructor(client: ISubstrateClientAt<any> | ISubstrateClient<any, any>, chainHead: ChainHead);
     protected stateCall(callParams: StateCallParams): Promise<HexString>;
 }

package/executor/validation-helpers.d.ts

@@ -0,0 +1,36 @@
+import type { TypeRegistry } from '@dedot/codecs';
+import type { AnyShape } from '@dedot/shape';
+import { ApiCompatibilityError } from '@dedot/utils';
+/**
+ * Parameter specification for validation
+ */
+export interface ParamSpec {
+    name: string;
+    typeId?: number;
+    codec?: AnyShape;
+}
+/**
+ * Context for error messages
+ */
+export interface ValidationContext {
+    apiName: string;
+    registry: TypeRegistry;
+    itemIndex?: number;
+}
+/**
+ * Check if a codec is an Option type
+ */
+export declare function isOptionCodec(codec: AnyShape): boolean;
+/**
+ * Check if a parameter is optional (wrapped in Option)
+ */
+export declare function isOptionalParam(param: ParamSpec, registry: TypeRegistry): boolean;
+/**
+ * Pad args array with undefined for missing trailing optional parameters.
+ * This allows users to omit optional parameters at the end of the parameter list.
+ */
+export declare function padArgsForOptionalParams<T extends ParamSpec>(args: any[], params: T[], registry: TypeRegistry): any[];
+/**
+ * Build a comprehensive API compatibility error with detailed information
+ */
+export declare function buildCompatibilityError(originalError: Error, params: ParamSpec[], args: any[], context: ValidationContext): ApiCompatibilityError;