@dedot/api 1.0.4 → 1.2.0

package/cjs/client/BaseSubstrateClient.js

@@ -410,6 +410,9 @@ class BaseSubstrateClient extends index_js_2.JsonRpcClient {
     sendTx(tx, callback) {
         throw new Error('Unimplemented!');
     }
+    toTx(tx) {
+        throw new Error('Unimplemented!');
+    }
     get chainSpec() {
         throw new Error('Unimplemented!');
     }

package/cjs/client/DedotClient.js

@@ -394,6 +394,33 @@ class DedotClient {
     sendTx(tx, callback) {
         return this.#client.sendTx(tx, callback);
     }
+    /**
+     * Convert a transaction input into a submittable extrinsic
+     * with `sign`, `signAndSend`, `send`, and `paymentInfo` methods.
+     *
+     * @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
+     * // 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);
+     * });
+     * ```
+     */
+    toTx(tx) {
+        return this.#client.toTx(tx);
+    }
     /**
      * Clear internal caches.
      *

package/cjs/client/LegacyClient.js

@@ -360,5 +360,8 @@ class LegacyClient// prettier-end-here
             callback && callback(result);
         });
     }
+    toTx(tx) {
+        return SubmittableExtrinsic_js_1.SubmittableExtrinsic.fromTx(this, tx);
+    }
 }
 exports.LegacyClient = LegacyClient;

package/cjs/client/V2Client.js

@@ -312,5 +312,8 @@ class V2Client// prettier-end-here
             callback && callback(result);
         });
     }
+    toTx(tx) {
+        return SubmittableExtrinsicV2_js_1.SubmittableExtrinsicV2.fromTx(this, tx);
+    }
 }
 exports.V2Client = V2Client;

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/BaseSubmittableExtrinsic.js

@@ -50,7 +50,9 @@ class BaseSubmittableExtrinsic extends codecs_1.Extrinsic {
         return result;
     }
     async paymentInfo(account, options) {
-        await this.sign(account, { ...options, signer: fakeSigner_js_1.fakeSigner });
+        if (!this.signed) {
+            await this.sign(account, { ...options, signer: fakeSigner_js_1.fakeSigner });
+        }
         const txU8a = this.toU8a();
         const api = this.client;
         return api.call.transactionPaymentApi.queryInfo(txU8a, txU8a.length);

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, 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,6 +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 | Uint8Array | Extrinsic | IRuntimeTxCall): ChainSubmittableExtrinsic<ChainApi>;
     get chainSpec(): IChainSpec;
     on<Event extends Events = Events>(event: Event, handler: EventHandlerFn<Event>): () => void;
 }

package/client/BaseSubstrateClient.js

@@ -406,6 +406,9 @@ export class BaseSubstrateClient extends JsonRpcClient {
     sendTx(tx, callback) {
         throw new Error('Unimplemented!');
     }
+    toTx(tx) {
+        throw new Error('Unimplemented!');
+    }
     get chainSpec() {
         throw new Error('Unimplemented!');
     }

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, 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';
@@ -359,6 +359,31 @@ export declare class DedotClient<ChainApi extends GenericSubstrateApi = Substrat
      * ```
      */
     sendTx(tx: HexString | Extrinsic, callback?: Callback<ISubmittableResult<ChainApi['types']['EventRecord']>>): TxUnsub;
+    /**
+     * Convert a transaction input into a submittable extrinsic
+     * with `sign`, `signAndSend`, `send`, and `paymentInfo` methods.
+     *
+     * @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
+     * // 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);
+     * });
+     * ```
+     */
+    toTx(tx: HexString | Uint8Array | Extrinsic | IRuntimeTxCall): ChainSubmittableExtrinsic<ChainApi>;
     /**
      * Clear internal caches.
      *

package/client/DedotClient.js

@@ -391,6 +391,33 @@ export class DedotClient {
     sendTx(tx, callback) {
         return this.#client.sendTx(tx, callback);
     }
+    /**
+     * Convert a transaction input into a submittable extrinsic
+     * with `sign`, `signAndSend`, `send`, and `paymentInfo` methods.
+     *
+     * @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
+     * // 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);
+     * });
+     * ```
+     */
+    toTx(tx) {
+        return this.#client.toTx(tx);
+    }
     /**
      * Clear internal caches.
      *

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, 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,4 +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 | Uint8Array | Extrinsic | IRuntimeTxCall): ChainSubmittableExtrinsic<ChainApi>;
 }

package/client/LegacyClient.js

@@ -357,4 +357,7 @@ export class LegacyClient// prettier-end-here
             callback && callback(result);
         });
     }
+    toTx(tx) {
+        return SubmittableExtrinsic.fromTx(this, tx);
+    }
 }

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, 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,4 +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 | Uint8Array | Extrinsic | IRuntimeTxCall): ChainSubmittableExtrinsic<ChainApi>;
 }

package/client/V2Client.js

@@ -309,4 +309,7 @@ export class V2Client// prettier-end-here
             callback && callback(result);
         });
     }
+    toTx(tx) {
+        return SubmittableExtrinsicV2.fromTx(this, tx);
+    }
 }

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/BaseSubmittableExtrinsic.js

@@ -24,7 +24,9 @@ export class BaseSubmittableExtrinsic extends Extrinsic {
         return result;
     }
     async paymentInfo(account, options) {
-        await this.sign(account, { ...options, signer: fakeSigner });
+        if (!this.signed) {
+            await this.sign(account, { ...options, signer: fakeSigner });
+        }
         const txU8a = this.toU8a();
         const api = this.client;
         return api.call.transactionPaymentApi.queryInfo(txU8a, txU8a.length);

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.0.4",
+  "version": "1.2.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.0.4",
-    "@dedot/providers": "1.0.4",
-    "@dedot/runtime-specs": "1.0.4",
-    "@dedot/shape": "1.0.4",
-    "@dedot/storage": "1.0.4",
-    "@dedot/types": "1.0.4",
-    "@dedot/utils": "1.0.4"
+    "@dedot/codecs": "^1.2.0",
+    "@dedot/providers": "^1.2.0",
+    "@dedot/runtime-specs": "^1.2.0",
+    "@dedot/shape": "^1.2.0",
+    "@dedot/storage": "^1.2.0",
+    "@dedot/types": "^1.2.0",
+    "@dedot/utils": "^1.2.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": "ad52d3d391c858c058f356dd13f279ea223a0f5f",
+  "gitHead": "d0da366e311d33389d0fd1b9e9435c1d61da5799",
   "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, 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';
@@ -225,6 +225,37 @@ Events extends string = ApiEvent> extends IJsonRpcClient<ChainApi, Events>, IGen
      * console.log('Transaction finalized:', result);
      */
     sendTx(tx: HexString | Extrinsic, callback?: Callback<ISubmittableResult<ChainApi['types']['EventRecord']>>): TxUnsub;
+    /**
+     * Convert a transaction input into a submittable extrinsic
+     * with `sign`, `signAndSend`, `send`, and `paymentInfo` methods.
+     *
+     * @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
+     * // 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);
+     * });
+     * ```
+     */
+    toTx(tx: HexString | Uint8Array | Extrinsic | IRuntimeTxCall): ChainSubmittableExtrinsic<ChainApi>;
     /**
      * Query multiple storage items in a single call or subscribe to multiple storage items
      *