@dedot/api 1.1.1 → 1.3.0

package/cjs/client/BaseSubstrateClient.js

@@ -257,15 +257,26 @@ class BaseSubstrateClient extends index_js_2.JsonRpcClient {
         this.on('connected', this.onConnected);
         // @ts-ignore
         this.on('disconnected', this.onDisconnected);
-        return new Promise((resolve) => {
+        return new Promise((resolve, reject) => {
+            // @ts-ignore
+            const offError = this.on('error', (err) => {
+                reject(err instanceof Error ? err : new Error(String(err)));
+            });
             // @ts-ignore
             this.once('ready', () => {
+                offError();
                 resolve(this);
             });
         });
     }
     onConnected = async () => {
-        await this.initialize();
+        try {
+            await this.initialize();
+        }
+        catch (e) {
+            // @ts-ignore — surface init failure so the pending connect() promise can reject
+            this.emit('error', e);
+        }
     };
     onDisconnected = async () => { };
     async initialize() {

package/cjs/client/DedotClient.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DedotClient = void 0;
+const utils_1 = require("@dedot/utils");
 const index_js_1 = require("../json-rpc/index.js");
 const LegacyClient_js_1 = require("./LegacyClient.js");
 const V2Client_js_1 = require("./V2Client.js");
@@ -51,7 +52,12 @@ const V2Client_js_1 = require("./V2Client.js");
  */
 class DedotClient {
     #client;
-    /** The JSON-RPC version being used ('v2' or 'legacy') */
+    #pendingOptions;
+    /**
+     * The JSON-RPC version being used ('v2' or 'legacy').
+     *
+     * In auto-detect mode (no `rpcVersion` option), this is resolved during `connect()`.
+     */
     rpcVersion;
     /**
      * Creates a new DedotClient instance.
@@ -61,18 +67,14 @@ class DedotClient {
      * @param options - Client configuration options or a JsonRpcProvider instance
      */
     constructor(options) {
-        let rpcVersion = 'v2';
-        if (!(0, index_js_1.isJsonRpcProvider)(options)) {
-            if (options['rpcVersion'] === 'legacy') {
-                rpcVersion = 'legacy';
-            }
-        }
-        this.rpcVersion = rpcVersion;
-        if (this.rpcVersion === 'legacy') {
-            this.#client = new LegacyClient_js_1.LegacyClient(options);
+        const explicitVersion = (0, index_js_1.isJsonRpcProvider)(options) ? undefined : options.rpcVersion;
+        if (explicitVersion) {
+            this.rpcVersion = explicitVersion;
+            this.#client =
+                explicitVersion === 'legacy' ? new LegacyClient_js_1.LegacyClient(options) : new V2Client_js_1.V2Client(options);
         }
         else {
-            this.#client = new V2Client_js_1.V2Client(options);
+            this.#pendingOptions = options;
         }
     }
     /**
@@ -284,10 +286,34 @@ class DedotClient {
     /**
      * Establishes connection to the blockchain network.
      *
+     * When `rpcVersion` was not specified, this tries JSON-RPC v2 first and
+     * transparently falls back to legacy if the node does not support v2.
+     *
      * @returns This client instance for method chaining
      */
     async connect() {
-        await this.#client.connect();
+        if (this.#client) {
+            await this.#client.connect();
+            return this;
+        }
+        const options = this.#pendingOptions;
+        this.#pendingOptions = undefined;
+        const v2 = new V2Client_js_1.V2Client(options);
+        try {
+            await v2.connect();
+            this.#client = v2;
+            this.rpcVersion = 'v2';
+        }
+        catch (e) {
+            if (!(e instanceof utils_1.JsonRpcV2NotSupportedError))
+                throw e;
+            console.warn('JSON-RPC v2 is not supported by the connected node, falling back to legacy JSON-RPC.');
+            await v2.disconnect().catch(utils_1.noop);
+            const legacy = new LegacyClient_js_1.LegacyClient(options);
+            await legacy.connect();
+            this.#client = legacy;
+            this.rpcVersion = 'legacy';
+        }
         return this;
     }
     /**
@@ -395,25 +421,27 @@ class DedotClient {
         return this.#client.sendTx(tx, callback);
     }
     /**
-     * Convert a raw hex-encoded transaction or an Extrinsic instance into a submittable extrinsic
+     * Convert a transaction input into a submittable extrinsic
      * with `sign`, `signAndSend`, `send`, and `paymentInfo` methods.
      *
-     * @param tx - A hex-encoded transaction string or an Extrinsic instance
+     * @param tx - A hex-encoded extrinsic or runtime call, a Uint8Array of encoded bytes,
+     *   an Extrinsic instance, or an IRuntimeTxCall object.
+     *   For HexString/Uint8Array, it first tries to decode as a full extrinsic;
+     *   if that fails, it falls back to decoding as a raw runtime call.
      * @returns A submittable extrinsic instance
      *
      * @example
      * ```typescript
-     * // Convert a raw hex transaction to a submittable extrinsic
+     * // From a raw hex extrinsic
      * const submittable = client.toTx(rawTxHex);
      *
+     * // From a runtime call object
+     * const submittable = client.toTx({ pallet: 'Balances', palletCall: { name: 'TransferKeepAlive', params: { dest, value } } });
+     *
      * // Sign and send
      * const unsub = await submittable.signAndSend(alice, (result) => {
      *   console.log('Status:', result.status);
      * });
-     *
-     * // Or query payment info
-     * const paymentInfo = await submittable.paymentInfo(alice);
-     * console.log('Estimated fee:', paymentInfo.partialFee);
      * ```
      */
     toTx(tx) {

package/cjs/client/V2Client.js

@@ -78,6 +78,10 @@ class V2Client// prettier-end-here
         const shouldInitialize = !this._genesisHash;
         if (shouldInitialize) {
             const rpcMethods = (await this.rpc.rpc_methods()).methods;
+            if (!rpcMethods.some((m) => m.startsWith('chainHead_'))) {
+                throw new utils_1.JsonRpcV2NotSupportedError('The connected node does not support JSON-RPC v2 (no chainHead_* methods). ' +
+                    'Omit `rpcVersion` to auto-detect, or pass `rpcVersion: "legacy"`.');
+            }
             this._chainHead = new index_js_2.ChainHead(this, { rpcMethods });
             this._chainSpec = new index_js_2.ChainSpec(this, { rpcMethods });
             // Always initialize Archive, but only set up fallback if supported

package/cjs/extrinsic/extensions/known/CheckMortality.js

@@ -13,9 +13,17 @@ exports.MORTAL_PERIOD = 12 * 60 * 1000;
 class CheckMortality extends SignedExtension_js_1.SignedExtension {
     #signingHeader;
     async init() {
-        this.#signingHeader = await this.#getSigningHeader();
-        this.data = { period: this.#calculateMortalLength(), current: BigInt(this.#signingHeader.number) };
-        this.additionalSigned = this.#signingHeader.hash;
+        const mortality = this.payloadOptions.mortality;
+        if (mortality?.type === 'Immortal') {
+            this.data = { type: 'Immortal' };
+            this.additionalSigned = this.client.genesisHash;
+        }
+        else {
+            this.#signingHeader = await this.#getSigningHeader();
+            const period = mortality?.type === 'Mortal' ? BigInt(mortality.period) : this.#calculateMortalLength();
+            this.data = { period, current: BigInt(this.#signingHeader.number) };
+            this.additionalSigned = this.#signingHeader.hash;
+        }
     }
     async fromPayload(payload) {
         const { era, blockHash, blockNumber } = payload;
@@ -88,7 +96,7 @@ class CheckMortality extends SignedExtension_js_1.SignedExtension {
         return {
             era: (0, utils_1.u8aToHex)(this.$Data.tryEncode(this.data)),
             blockHash: this.additionalSigned,
-            blockNumber: (0, utils_1.numberToHex)(this.#signingHeader.number),
+            blockNumber: (0, utils_1.numberToHex)(this.#signingHeader?.number ?? 0),
         };
     }
 }

package/cjs/extrinsic/submittable/SubmittableExtrinsic.js

@@ -11,14 +11,8 @@ const utils_js_1 = require("./utils.js");
  */
 class SubmittableExtrinsic extends BaseSubmittableExtrinsic_js_1.BaseSubmittableExtrinsic {
     static fromTx(client, tx) {
-        let extrinsic;
-        if ((0, utils_1.isHex)(tx)) {
-            extrinsic = client.registry.$Extrinsic.tryDecode(tx);
-        }
-        else {
-            extrinsic = tx;
-        }
-        return new SubmittableExtrinsic(client, extrinsic.call, extrinsic.preamble);
+        const { call, preamble } = (0, utils_js_1.resolveCallAndPreamble)(client.registry, tx);
+        return new SubmittableExtrinsic(client, call, preamble);
     }
     async dryRun(account, optionsOrHash) {
         const dryRunFn = this.client.rpc.system_dryRun;

package/cjs/extrinsic/submittable/SubmittableExtrinsicV2.js

@@ -17,14 +17,8 @@ class SubmittableExtrinsicV2 extends BaseSubmittableExtrinsic_js_1.BaseSubmittab
         this.client = client;
     }
     static fromTx(client, tx) {
-        let extrinsic;
-        if ((0, utils_1.isHex)(tx)) {
-            extrinsic = client.registry.$Extrinsic.tryDecode(tx);
-        }
-        else {
-            extrinsic = tx;
-        }
-        return new SubmittableExtrinsicV2(client, extrinsic.call, extrinsic.preamble);
+        const { call, preamble } = (0, utils_js_1.resolveCallAndPreamble)(client.registry, tx);
+        return new SubmittableExtrinsicV2(client, call, preamble);
     }
     async #send(callback) {
         const api = this.client;

package/cjs/extrinsic/submittable/utils.js

@@ -1,8 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.txDefer = exports.toTxStatus = exports.signRawMessage = exports.isKeyringPair = void 0;
+exports.txDefer = exports.toTxStatus = exports.signRawMessage = exports.isKeyringPair = exports.resolveCallAndPreamble = void 0;
+const codecs_1 = require("@dedot/codecs");
 const utils_1 = require("@dedot/utils");
 const errors_js_1 = require("./errors.js");
+/**
+ * Check if a value is an IRuntimeTxCall object (has a 'pallet' property).
+ */
+function isRuntimeTxCall(tx) {
+    return typeof tx === 'object' && tx !== null && 'pallet' in tx;
+}
+/**
+ * Resolve a transaction input into a call and optional preamble.
+ *
+ * Supports:
+ * - `Extrinsic` instance: extract call + preamble
+ * - `IRuntimeTxCall` object: use directly as call, no preamble
+ * - `HexString` or `Uint8Array`: try decode as extrinsic first, fallback to runtime call
+ */
+function resolveCallAndPreamble(registry, tx) {
+    if (tx instanceof codecs_1.Extrinsic) {
+        return { call: tx.call, preamble: tx.preamble };
+    }
+    if (isRuntimeTxCall(tx)) {
+        return { call: tx };
+    }
+    // HexString or Uint8Array: try extrinsic decode first, fallback to runtime call
+    try {
+        const extrinsic = registry.$Extrinsic.tryDecode(tx);
+        return { call: extrinsic.call, preamble: extrinsic.preamble };
+    }
+    catch {
+        const { callTypeId } = registry.metadata.extrinsic;
+        const $RuntimeCall = registry.findCodec(callTypeId);
+        const call = $RuntimeCall.tryDecode(tx);
+        return { call };
+    }
+}
+exports.resolveCallAndPreamble = resolveCallAndPreamble;
 function isKeyringPair(account) {
     return (0, utils_1.isFunction)(account.sign);
 }

package/client/BaseSubstrateClient.d.ts

@@ -1,7 +1,7 @@
 import { BlockHash, Extrinsic, Hash, Metadata, PortableRegistry, RuntimeVersion } from '@dedot/codecs';
 import { type JsonRpcProvider } from '@dedot/providers';
 import { type IStorage } from '@dedot/storage';
-import { Callback, ChainSubmittableExtrinsic, GenericStorageQuery, GenericSubstrateApi, InjectedSigner, ISubmittableResult, Query, QueryFnResult, RpcVersion, TxUnsub, Unsub } from '@dedot/types';
+import { Callback, ChainSubmittableExtrinsic, GenericStorageQuery, GenericSubstrateApi, InjectedSigner, IRuntimeTxCall, ISubmittableResult, Query, QueryFnResult, RpcVersion, TxUnsub, Unsub } from '@dedot/types';
 import { Deferred, HexString, LRUCache } from '@dedot/utils';
 import type { SubstrateApi } from '../chaintypes/index.js';
 import { JsonRpcClient } from '../json-rpc/index.js';
@@ -133,7 +133,7 @@ export declare abstract class BaseSubstrateClient<ChainApi extends GenericSubstr
     }>): Promise<Unsub>;
     protected getStorageQuery(): BaseStorageQuery;
     sendTx(tx: HexString | Extrinsic, callback?: Callback<ISubmittableResult<ChainApi['types']['EventRecord']>>): TxUnsub;
-    toTx(tx: HexString | Extrinsic): ChainSubmittableExtrinsic<ChainApi>;
+    toTx(tx: HexString | Uint8Array | Extrinsic | IRuntimeTxCall): ChainSubmittableExtrinsic<ChainApi>;
     get chainSpec(): IChainSpec;
     on<Event extends Events = Events>(event: Event, handler: EventHandlerFn<Event>): () => void;
 }

package/client/BaseSubstrateClient.js

@@ -253,15 +253,26 @@ export class BaseSubstrateClient extends JsonRpcClient {
         this.on('connected', this.onConnected);
         // @ts-ignore
         this.on('disconnected', this.onDisconnected);
-        return new Promise((resolve) => {
+        return new Promise((resolve, reject) => {
+            // @ts-ignore
+            const offError = this.on('error', (err) => {
+                reject(err instanceof Error ? err : new Error(String(err)));
+            });
             // @ts-ignore
             this.once('ready', () => {
+                offError();
                 resolve(this);
             });
         });
     }
     onConnected = async () => {
-        await this.initialize();
+        try {
+            await this.initialize();
+        }
+        catch (e) {
+            // @ts-ignore — surface init failure so the pending connect() promise can reject
+            this.emit('error', e);
+        }
     };
     onDisconnected = async () => { };
     async initialize() {

package/client/DedotClient.d.ts

@@ -1,6 +1,6 @@
 import { type Extrinsic, Metadata, PortableRegistry } from '@dedot/codecs';
 import { ConnectionStatus, JsonRpcProvider } from '@dedot/providers';
-import { Callback, ChainSubmittableExtrinsic, GenericStorageQuery, GenericSubstrateApi, InjectedSigner, ISubmittableResult, Query, QueryFnResult, RpcVersion, TxUnsub, Unsub } from '@dedot/types';
+import { Callback, ChainSubmittableExtrinsic, GenericStorageQuery, GenericSubstrateApi, InjectedSigner, IRuntimeTxCall, ISubmittableResult, Query, QueryFnResult, RpcVersion, TxUnsub, Unsub } from '@dedot/types';
 import { HexString } from '@dedot/utils';
 import { SubstrateApi } from '../chaintypes/index.js';
 import { ApiEvent, ApiOptions, BlockExplorer, ISubstrateClient, ISubstrateClientAt, SubstrateRuntimeVersion, IChainSpec, type EventHandlerFn } from '../types.js';
@@ -9,9 +9,14 @@ import { ApiEvent, ApiOptions, BlockExplorer, ISubstrateClient, ISubstrateClient
  */
 export type ClientOptions = ApiOptions & {
     /**
-     * The JSON-RPC version to use
-     * - 'v2' (default): Uses the new JSON-RPC v2 specification
-     * - 'legacy': Uses the legacy JSON-RPC specification for older nodes
+     * The JSON-RPC version to use.
+     *
+     * - _unset_ (default): auto-detect. Try JSON-RPC v2 first and transparently fall back
+     *   to legacy if the connected node does not expose v2 methods (no `chainHead_*`).
+     *   After `connect()` resolves, `client.rpcVersion` reflects the version that was picked.
+     * - `'v2'`: force JSON-RPC v2. Throws `JsonRpcV2NotSupportedError` during `connect()`
+     *   if the node does not support v2.
+     * - `'legacy'`: force legacy JSON-RPC.
      */
     rpcVersion?: RpcVersion;
 };
@@ -62,7 +67,11 @@ export type ClientOptions = ApiOptions & {
  */
 export declare class DedotClient<ChainApi extends GenericSubstrateApi = SubstrateApi> implements ISubstrateClient<ChainApi, ApiEvent> {
     #private;
-    /** The JSON-RPC version being used ('v2' or 'legacy') */
+    /**
+     * The JSON-RPC version being used ('v2' or 'legacy').
+     *
+     * In auto-detect mode (no `rpcVersion` option), this is resolved during `connect()`.
+     */
     rpcVersion: RpcVersion;
     /**
      * Creates a new DedotClient instance.
@@ -239,6 +248,9 @@ export declare class DedotClient<ChainApi extends GenericSubstrateApi = Substrat
     /**
      * Establishes connection to the blockchain network.
      *
+     * When `rpcVersion` was not specified, this tries JSON-RPC v2 first and
+     * transparently falls back to legacy if the node does not support v2.
+     *
      * @returns This client instance for method chaining
      */
     connect(): Promise<this>;
@@ -360,28 +372,30 @@ export declare class DedotClient<ChainApi extends GenericSubstrateApi = Substrat
      */
     sendTx(tx: HexString | Extrinsic, callback?: Callback<ISubmittableResult<ChainApi['types']['EventRecord']>>): TxUnsub;
     /**
-     * Convert a raw hex-encoded transaction or an Extrinsic instance into a submittable extrinsic
+     * Convert a transaction input into a submittable extrinsic
      * with `sign`, `signAndSend`, `send`, and `paymentInfo` methods.
      *
-     * @param tx - A hex-encoded transaction string or an Extrinsic instance
+     * @param tx - A hex-encoded extrinsic or runtime call, a Uint8Array of encoded bytes,
+     *   an Extrinsic instance, or an IRuntimeTxCall object.
+     *   For HexString/Uint8Array, it first tries to decode as a full extrinsic;
+     *   if that fails, it falls back to decoding as a raw runtime call.
      * @returns A submittable extrinsic instance
      *
      * @example
      * ```typescript
-     * // Convert a raw hex transaction to a submittable extrinsic
+     * // From a raw hex extrinsic
      * const submittable = client.toTx(rawTxHex);
      *
+     * // From a runtime call object
+     * const submittable = client.toTx({ pallet: 'Balances', palletCall: { name: 'TransferKeepAlive', params: { dest, value } } });
+     *
      * // Sign and send
      * const unsub = await submittable.signAndSend(alice, (result) => {
      *   console.log('Status:', result.status);
      * });
-     *
-     * // Or query payment info
-     * const paymentInfo = await submittable.paymentInfo(alice);
-     * console.log('Estimated fee:', paymentInfo.partialFee);
      * ```
      */
-    toTx(tx: HexString | Extrinsic): ChainSubmittableExtrinsic<ChainApi>;
+    toTx(tx: HexString | Uint8Array | Extrinsic | IRuntimeTxCall): ChainSubmittableExtrinsic<ChainApi>;
     /**
      * Clear internal caches.
      *

package/client/DedotClient.js

@@ -1,3 +1,4 @@
+import { JsonRpcV2NotSupportedError, noop } from '@dedot/utils';
 import { isJsonRpcProvider } from '../json-rpc/index.js';
 import { LegacyClient } from './LegacyClient.js';
 import { V2Client } from './V2Client.js';
@@ -48,7 +49,12 @@ import { V2Client } from './V2Client.js';
  */
 export class DedotClient {
     #client;
-    /** The JSON-RPC version being used ('v2' or 'legacy') */
+    #pendingOptions;
+    /**
+     * The JSON-RPC version being used ('v2' or 'legacy').
+     *
+     * In auto-detect mode (no `rpcVersion` option), this is resolved during `connect()`.
+     */
     rpcVersion;
     /**
      * Creates a new DedotClient instance.
@@ -58,18 +64,14 @@ export class DedotClient {
      * @param options - Client configuration options or a JsonRpcProvider instance
      */
     constructor(options) {
-        let rpcVersion = 'v2';
-        if (!isJsonRpcProvider(options)) {
-            if (options['rpcVersion'] === 'legacy') {
-                rpcVersion = 'legacy';
-            }
-        }
-        this.rpcVersion = rpcVersion;
-        if (this.rpcVersion === 'legacy') {
-            this.#client = new LegacyClient(options);
+        const explicitVersion = isJsonRpcProvider(options) ? undefined : options.rpcVersion;
+        if (explicitVersion) {
+            this.rpcVersion = explicitVersion;
+            this.#client =
+                explicitVersion === 'legacy' ? new LegacyClient(options) : new V2Client(options);
         }
         else {
-            this.#client = new V2Client(options);
+            this.#pendingOptions = options;
         }
     }
     /**
@@ -281,10 +283,34 @@ export class DedotClient {
     /**
      * Establishes connection to the blockchain network.
      *
+     * When `rpcVersion` was not specified, this tries JSON-RPC v2 first and
+     * transparently falls back to legacy if the node does not support v2.
+     *
      * @returns This client instance for method chaining
      */
     async connect() {
-        await this.#client.connect();
+        if (this.#client) {
+            await this.#client.connect();
+            return this;
+        }
+        const options = this.#pendingOptions;
+        this.#pendingOptions = undefined;
+        const v2 = new V2Client(options);
+        try {
+            await v2.connect();
+            this.#client = v2;
+            this.rpcVersion = 'v2';
+        }
+        catch (e) {
+            if (!(e instanceof JsonRpcV2NotSupportedError))
+                throw e;
+            console.warn('JSON-RPC v2 is not supported by the connected node, falling back to legacy JSON-RPC.');
+            await v2.disconnect().catch(noop);
+            const legacy = new LegacyClient(options);
+            await legacy.connect();
+            this.#client = legacy;
+            this.rpcVersion = 'legacy';
+        }
         return this;
     }
     /**
@@ -392,25 +418,27 @@ export class DedotClient {
         return this.#client.sendTx(tx, callback);
     }
     /**
-     * Convert a raw hex-encoded transaction or an Extrinsic instance into a submittable extrinsic
+     * Convert a transaction input into a submittable extrinsic
      * with `sign`, `signAndSend`, `send`, and `paymentInfo` methods.
      *
-     * @param tx - A hex-encoded transaction string or an Extrinsic instance
+     * @param tx - A hex-encoded extrinsic or runtime call, a Uint8Array of encoded bytes,
+     *   an Extrinsic instance, or an IRuntimeTxCall object.
+     *   For HexString/Uint8Array, it first tries to decode as a full extrinsic;
+     *   if that fails, it falls back to decoding as a raw runtime call.
      * @returns A submittable extrinsic instance
      *
      * @example
      * ```typescript
-     * // Convert a raw hex transaction to a submittable extrinsic
+     * // From a raw hex extrinsic
      * const submittable = client.toTx(rawTxHex);
      *
+     * // From a runtime call object
+     * const submittable = client.toTx({ pallet: 'Balances', palletCall: { name: 'TransferKeepAlive', params: { dest, value } } });
+     *
      * // Sign and send
      * const unsub = await submittable.signAndSend(alice, (result) => {
      *   console.log('Status:', result.status);
      * });
-     *
-     * // Or query payment info
-     * const paymentInfo = await submittable.paymentInfo(alice);
-     * console.log('Estimated fee:', paymentInfo.partialFee);
      * ```
      */
     toTx(tx) {

package/client/LegacyClient.d.ts

@@ -1,6 +1,6 @@
 import { BlockHash, type Extrinsic, Metadata } from '@dedot/codecs';
 import type { JsonRpcProvider } from '@dedot/providers';
-import { Callback, ChainSubmittableExtrinsic, GenericSubstrateApi, ISubmittableResult, TxUnsub } from '@dedot/types';
+import { Callback, ChainSubmittableExtrinsic, GenericSubstrateApi, IRuntimeTxCall, ISubmittableResult, TxUnsub } from '@dedot/types';
 import { HexString } from '@dedot/utils';
 import type { SubstrateApi } from '../chaintypes/index.js';
 import { BaseStorageQuery } from '../storage/index.js';
@@ -137,5 +137,5 @@ export declare class LegacyClient<ChainApi extends GenericSubstrateApi = Substra
     at<ChainApiAt extends GenericSubstrateApi = ChainApi>(hash: BlockHash): Promise<ISubstrateClientAt<ChainApiAt>>;
     protected getStorageQuery(): BaseStorageQuery;
     sendTx(tx: HexString | Extrinsic, callback?: Callback<ISubmittableResult<ChainApi['types']['EventRecord']>>): TxUnsub;
-    toTx(tx: HexString | Extrinsic): ChainSubmittableExtrinsic<ChainApi>;
+    toTx(tx: HexString | Uint8Array | Extrinsic | IRuntimeTxCall): ChainSubmittableExtrinsic<ChainApi>;
 }

package/client/V2Client.d.ts

@@ -1,6 +1,6 @@
 import { BlockHash, type Extrinsic, Metadata } from '@dedot/codecs';
 import type { JsonRpcProvider } from '@dedot/providers';
-import { Callback, ChainSubmittableExtrinsic, GenericSubstrateApi, ISubmittableResult, TxUnsub } from '@dedot/types';
+import { Callback, ChainSubmittableExtrinsic, GenericSubstrateApi, IRuntimeTxCall, ISubmittableResult, TxUnsub } from '@dedot/types';
 import { HexString } from '@dedot/utils';
 import type { SubstrateApi } from '../chaintypes/index.js';
 import { Archive, ChainHead, ChainSpec, PinnedBlock } from '../json-rpc/index.js';
@@ -72,5 +72,5 @@ export declare class V2Client<ChainApi extends GenericSubstrateApi = SubstrateAp
     at<ChainApiAt extends GenericSubstrateApi = ChainApi>(hash: BlockHash): Promise<ISubstrateClientAt<ChainApiAt>>;
     protected getStorageQuery(): BaseStorageQuery;
     sendTx(tx: HexString | Extrinsic, callback?: Callback<ISubmittableResult<ChainApi['types']['EventRecord']>>): TxUnsub;
-    toTx(tx: HexString | Extrinsic): ChainSubmittableExtrinsic<ChainApi>;
+    toTx(tx: HexString | Uint8Array | Extrinsic | IRuntimeTxCall): ChainSubmittableExtrinsic<ChainApi>;
 }

package/client/V2Client.js

@@ -1,6 +1,6 @@
 import { $H256, $Header, $RuntimeVersion, PortableRegistry, } from '@dedot/codecs';
 import { u32 } from '@dedot/shape';
-import { assert, concatU8a, DedotError, twox64Concat, u8aToHex, xxhashAsU8a } from '@dedot/utils';
+import { assert, concatU8a, DedotError, JsonRpcV2NotSupportedError, twox64Concat, u8aToHex, xxhashAsU8a, } from '@dedot/utils';
 import { ConstantExecutor, ErrorExecutor, EventExecutor, RuntimeApiExecutorV2, StorageQueryExecutorV2, TxExecutorV2, ViewFunctionExecutorV2, } from '../executor/index.js';
 import { SubmittableExtrinsicV2 } from '../extrinsic/submittable/SubmittableExtrinsicV2.js';
 import { Archive, ChainHead, ChainSpec, Transaction, TransactionWatch } from '../json-rpc/index.js';
@@ -75,6 +75,10 @@ export class V2Client// prettier-end-here
         const shouldInitialize = !this._genesisHash;
         if (shouldInitialize) {
             const rpcMethods = (await this.rpc.rpc_methods()).methods;
+            if (!rpcMethods.some((m) => m.startsWith('chainHead_'))) {
+                throw new JsonRpcV2NotSupportedError('The connected node does not support JSON-RPC v2 (no chainHead_* methods). ' +
+                    'Omit `rpcVersion` to auto-detect, or pass `rpcVersion: "legacy"`.');
+            }
             this._chainHead = new ChainHead(this, { rpcMethods });
             this._chainSpec = new ChainSpec(this, { rpcMethods });
             // Always initialize Archive, but only set up fallback if supported

package/extrinsic/extensions/known/CheckMortality.js

@@ -10,9 +10,17 @@ export const MORTAL_PERIOD = 12 * 60 * 1000;
 export class CheckMortality extends SignedExtension {
     #signingHeader;
     async init() {
-        this.#signingHeader = await this.#getSigningHeader();
-        this.data = { period: this.#calculateMortalLength(), current: BigInt(this.#signingHeader.number) };
-        this.additionalSigned = this.#signingHeader.hash;
+        const mortality = this.payloadOptions.mortality;
+        if (mortality?.type === 'Immortal') {
+            this.data = { type: 'Immortal' };
+            this.additionalSigned = this.client.genesisHash;
+        }
+        else {
+            this.#signingHeader = await this.#getSigningHeader();
+            const period = mortality?.type === 'Mortal' ? BigInt(mortality.period) : this.#calculateMortalLength();
+            this.data = { period, current: BigInt(this.#signingHeader.number) };
+            this.additionalSigned = this.#signingHeader.hash;
+        }
     }
     async fromPayload(payload) {
         const { era, blockHash, blockNumber } = payload;
@@ -85,7 +93,7 @@ export class CheckMortality extends SignedExtension {
         return {
             era: u8aToHex(this.$Data.tryEncode(this.data)),
             blockHash: this.additionalSigned,
-            blockNumber: numberToHex(this.#signingHeader.number),
+            blockNumber: numberToHex(this.#signingHeader?.number ?? 0),
         };
     }
 }

package/extrinsic/submittable/SubmittableExtrinsic.d.ts

@@ -1,5 +1,5 @@
 import { BlockHash, Extrinsic } from '@dedot/codecs';
-import { AddressOrPair, Callback, DryRunResult, ISubmittableExtrinsicLegacy, ISubmittableResult, SignerOptions, TxHash, TxUnsub } from '@dedot/types';
+import { AddressOrPair, Callback, DryRunResult, IRuntimeTxCall, ISubmittableExtrinsicLegacy, ISubmittableResult, SignerOptions, TxHash, TxUnsub } from '@dedot/types';
 import { HexString } from '@dedot/utils';
 import { LegacyClient } from '../../client/LegacyClient.js';
 import { BaseSubmittableExtrinsic } from './BaseSubmittableExtrinsic.js';
@@ -8,7 +8,7 @@ import { BaseSubmittableExtrinsic } from './BaseSubmittableExtrinsic.js';
  * @description A wrapper around an Extrinsic that exposes methods to sign, send, and other utility around Extrinsic.
  */
 export declare class SubmittableExtrinsic extends BaseSubmittableExtrinsic implements ISubmittableExtrinsicLegacy {
-    static fromTx(client: LegacyClient<any>, tx: HexString | Extrinsic): SubmittableExtrinsic;
+    static fromTx(client: LegacyClient<any>, tx: HexString | Uint8Array | Extrinsic | IRuntimeTxCall): SubmittableExtrinsic;
     dryRun(account: AddressOrPair, optionsOrHash?: Partial<SignerOptions> | BlockHash): Promise<DryRunResult>;
     send(): TxHash;
     send(callback: Callback<ISubmittableResult>): TxUnsub;

package/extrinsic/submittable/SubmittableExtrinsic.js

@@ -1,21 +1,15 @@
 import { assert, isHex, noop } from '@dedot/utils';
 import { BaseSubmittableExtrinsic } from './BaseSubmittableExtrinsic.js';
 import { SubmittableResult } from './SubmittableResult.js';
-import { toTxStatus, txDefer } from './utils.js';
+import { resolveCallAndPreamble, toTxStatus, txDefer } from './utils.js';
 /**
  * @name SubmittableExtrinsic
  * @description A wrapper around an Extrinsic that exposes methods to sign, send, and other utility around Extrinsic.
  */
 export class SubmittableExtrinsic extends BaseSubmittableExtrinsic {
     static fromTx(client, tx) {
-        let extrinsic;
-        if (isHex(tx)) {
-            extrinsic = client.registry.$Extrinsic.tryDecode(tx);
-        }
-        else {
-            extrinsic = tx;
-        }
-        return new SubmittableExtrinsic(client, extrinsic.call, extrinsic.preamble);
+        const { call, preamble } = resolveCallAndPreamble(client.registry, tx);
+        return new SubmittableExtrinsic(client, call, preamble);
     }
     async dryRun(account, optionsOrHash) {
         const dryRunFn = this.client.rpc.system_dryRun;

package/extrinsic/submittable/SubmittableExtrinsicV2.d.ts

@@ -11,7 +11,7 @@ export declare class SubmittableExtrinsicV2 extends BaseSubmittableExtrinsic {
     #private;
     client: V2Client<any>;
     constructor(client: V2Client<any>, call: IRuntimeTxCall, preamble?: Preamble);
-    static fromTx(client: V2Client<any>, tx: HexString | Extrinsic): SubmittableExtrinsicV2;
+    static fromTx(client: V2Client<any>, tx: HexString | Uint8Array | Extrinsic | IRuntimeTxCall): SubmittableExtrinsicV2;
     send(): TxHash;
     send(callback: Callback<ISubmittableResult>): TxUnsub;
 }

package/extrinsic/submittable/SubmittableExtrinsicV2.js

@@ -1,8 +1,8 @@
-import { AsyncQueue, isHex, noop, waitFor } from '@dedot/utils';
+import { AsyncQueue, noop, waitFor } from '@dedot/utils';
 import { BaseSubmittableExtrinsic } from './BaseSubmittableExtrinsic.js';
 import { SubmittableResult } from './SubmittableResult.js';
 import { InvalidTxError } from './errors.js';
-import { txDefer } from './utils.js';
+import { resolveCallAndPreamble, txDefer } from './utils.js';
 /**
  * @name SubmittableExtrinsicV2
  * @description Submittable extrinsic based on JSON-RPC v2
@@ -14,14 +14,8 @@ export class SubmittableExtrinsicV2 extends BaseSubmittableExtrinsic {
         this.client = client;
     }
     static fromTx(client, tx) {
-        let extrinsic;
-        if (isHex(tx)) {
-            extrinsic = client.registry.$Extrinsic.tryDecode(tx);
-        }
-        else {
-            extrinsic = tx;
-        }
-        return new SubmittableExtrinsicV2(client, extrinsic.call, extrinsic.preamble);
+        const { call, preamble } = resolveCallAndPreamble(client.registry, tx);
+        return new SubmittableExtrinsicV2(client, call, preamble);
     }
     async #send(callback) {
         const api = this.client;

package/extrinsic/submittable/utils.d.ts

@@ -1,6 +1,18 @@
-import { TransactionStatus } from '@dedot/codecs';
-import { AddressOrPair, IKeyringPair, ISubmittableResult, TxStatus, Unsub } from '@dedot/types';
+import { Extrinsic, Preamble, PortableRegistry, TransactionStatus } from '@dedot/codecs';
+import { AddressOrPair, IKeyringPair, IRuntimeTxCall, ISubmittableResult, TxStatus, Unsub } from '@dedot/types';
 import { Deferred, HexString } from '@dedot/utils';
+/**
+ * Resolve a transaction input into a call and optional preamble.
+ *
+ * Supports:
+ * - `Extrinsic` instance: extract call + preamble
+ * - `IRuntimeTxCall` object: use directly as call, no preamble
+ * - `HexString` or `Uint8Array`: try decode as extrinsic first, fallback to runtime call
+ */
+export declare function resolveCallAndPreamble(registry: PortableRegistry, tx: HexString | Uint8Array | Extrinsic | IRuntimeTxCall): {
+    call: IRuntimeTxCall;
+    preamble?: Preamble;
+};
 export declare function isKeyringPair(account: AddressOrPair): account is IKeyringPair;
 /**
  * Sign a raw message

package/extrinsic/submittable/utils.js

@@ -1,5 +1,39 @@
+import { Extrinsic } from '@dedot/codecs';
 import { assert, blake2AsU8a, deferred, hexToU8a, isFunction } from '@dedot/utils';
 import { RejectedTxError } from './errors.js';
+/**
+ * Check if a value is an IRuntimeTxCall object (has a 'pallet' property).
+ */
+function isRuntimeTxCall(tx) {
+    return typeof tx === 'object' && tx !== null && 'pallet' in tx;
+}
+/**
+ * Resolve a transaction input into a call and optional preamble.
+ *
+ * Supports:
+ * - `Extrinsic` instance: extract call + preamble
+ * - `IRuntimeTxCall` object: use directly as call, no preamble
+ * - `HexString` or `Uint8Array`: try decode as extrinsic first, fallback to runtime call
+ */
+export function resolveCallAndPreamble(registry, tx) {
+    if (tx instanceof Extrinsic) {
+        return { call: tx.call, preamble: tx.preamble };
+    }
+    if (isRuntimeTxCall(tx)) {
+        return { call: tx };
+    }
+    // HexString or Uint8Array: try extrinsic decode first, fallback to runtime call
+    try {
+        const extrinsic = registry.$Extrinsic.tryDecode(tx);
+        return { call: extrinsic.call, preamble: extrinsic.preamble };
+    }
+    catch {
+        const { callTypeId } = registry.metadata.extrinsic;
+        const $RuntimeCall = registry.findCodec(callTypeId);
+        const call = $RuntimeCall.tryDecode(tx);
+        return { call };
+    }
+}
 export function isKeyringPair(account) {
     return isFunction(account.sign);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/api",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "description": "A delightful JavaScript/TypeScript client for Polkadot & Substrate",
   "author": "Thang X. Vu <thang@dedot.dev>",
   "homepage": "https://dedot.dev",
@@ -13,13 +13,13 @@
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@dedot/codecs": "^1.1.1",
-    "@dedot/providers": "^1.1.1",
-    "@dedot/runtime-specs": "^1.1.1",
-    "@dedot/shape": "^1.1.1",
-    "@dedot/storage": "^1.1.1",
-    "@dedot/types": "^1.1.1",
-    "@dedot/utils": "^1.1.1"
+    "@dedot/codecs": "^1.3.0",
+    "@dedot/providers": "^1.3.0",
+    "@dedot/runtime-specs": "^1.3.0",
+    "@dedot/shape": "^1.3.0",
+    "@dedot/storage": "^1.3.0",
+    "@dedot/types": "^1.3.0",
+    "@dedot/utils": "^1.3.0"
   },
   "scripts": {
     "build": "tsc --project tsconfig.build.json && tsc --project tsconfig.build.cjs.json",
@@ -48,7 +48,7 @@
     "node": ">=18"
   },
   "license": "Apache-2.0",
-  "gitHead": "d64c5da3433f21b17fcf1e431235b8694ed11fa2",
+  "gitHead": "1179ba75b371517a21eb1162881e6e4c655514a0",
   "module": "./index.js",
   "types": "./index.d.ts"
 }

package/types.d.ts

@@ -2,7 +2,7 @@ import { BlockHash, Extrinsic, Hash, Header, Metadata, PortableRegistry } from '
 import type { ConnectionStatus, JsonRpcProvider, ProviderEvent } from '@dedot/providers';
 import type { AnyShape } from '@dedot/shape';
 import type { IStorage } from '@dedot/storage';
-import { Callback, ChainSubmittableExtrinsic, GenericStorageQuery, GenericSubstrateApi, InjectedSigner, ISubmittableResult, Query, QueryFnResult, RpcVersion, RuntimeApiName, RuntimeApiSpec, TxUnsub, Unsub } from '@dedot/types';
+import { Callback, ChainSubmittableExtrinsic, GenericStorageQuery, GenericSubstrateApi, InjectedSigner, IRuntimeTxCall, ISubmittableResult, Query, QueryFnResult, RpcVersion, RuntimeApiName, RuntimeApiSpec, TxUnsub, Unsub } from '@dedot/types';
 import { Properties } from '@dedot/types/json-rpc';
 import type { HashFn, HexString, IEventEmitter } from '@dedot/utils';
 import type { SubstrateApi } from './chaintypes/index.js';
@@ -226,28 +226,36 @@ Events extends string = ApiEvent> extends IJsonRpcClient<ChainApi, Events>, IGen
      */
     sendTx(tx: HexString | Extrinsic, callback?: Callback<ISubmittableResult<ChainApi['types']['EventRecord']>>): TxUnsub;
     /**
-     * Convert a raw hex-encoded transaction or an Extrinsic instance into a submittable extrinsic
+     * Convert a transaction input into a submittable extrinsic
      * with `sign`, `signAndSend`, `send`, and `paymentInfo` methods.
      *
-     * @param tx - A hex-encoded transaction string or an Extrinsic instance
+     * @param tx - A hex-encoded extrinsic or runtime call, a Uint8Array of encoded bytes,
+     *   an Extrinsic instance, or an IRuntimeTxCall object.
+     *   For HexString/Uint8Array, it first tries to decode as a full extrinsic;
+     *   if that fails, it falls back to decoding as a raw runtime call.
      * @returns A submittable extrinsic instance
      *
      * @example
      * ```typescript
-     * // Convert a raw hex transaction to a submittable extrinsic
+     * // From a raw hex extrinsic
      * const submittable = client.toTx(rawTxHex);
      *
+     * // From a runtime call hex (encoded call data)
+     * const submittable = client.toTx(runtimeCallHex);
+     *
+     * // From a Uint8Array
+     * const submittable = client.toTx(callBytes);
+     *
+     * // From a runtime call object
+     * const submittable = client.toTx({ pallet: 'Balances', palletCall: { name: 'TransferKeepAlive', params: { dest, value } } });
+     *
      * // Sign and send
      * const unsub = await submittable.signAndSend(alice, (result) => {
      *   console.log('Status:', result.status);
      * });
-     *
-     * // Or query payment info
-     * const paymentInfo = await submittable.paymentInfo(alice);
-     * console.log('Estimated fee:', paymentInfo.partialFee);
      * ```
      */
-    toTx(tx: HexString | Extrinsic): ChainSubmittableExtrinsic<ChainApi>;
+    toTx(tx: HexString | Uint8Array | Extrinsic | IRuntimeTxCall): ChainSubmittableExtrinsic<ChainApi>;
     /**
      * Query multiple storage items in a single call or subscribe to multiple storage items
      *