@dedot/api 0.10.0 → 0.11.0

package/cjs/extrinsic/submittable/BaseSubmittableExtrinsic.js

@@ -55,10 +55,35 @@ class BaseSubmittableExtrinsic extends codecs_1.Extrinsic {
         }
         return this;
     }
-    async signAndSend(fromAccount, partialOptions, maybeCallback) {
+    signAndSend(fromAccount, partialOptions, maybeCallback) {
         const [options, callback] = this.#normalizeOptions(partialOptions, maybeCallback);
-        await this.sign(fromAccount, options);
-        return this.send(callback);
+        const { deferTx, deferFinalized, deferBestChainBlockIncluded, onTxProgress } = (0, utils_js_1.txDefer)();
+        this.sign(fromAccount, options)
+            .then(() => {
+            const deferSend = this.send(callback);
+            deferSend
+                .then(deferTx.resolve) // --
+                .catch(deferTx.reject);
+            deferSend
+                .untilBestChainBlockIncluded() //--
+                .then((r) => {
+                onTxProgress(r);
+            })
+                .catch((e) => {
+                deferBestChainBlockIncluded()?.reject(e);
+            });
+            deferSend
+                .untilFinalized() //--
+                .then((r) => {
+                onTxProgress(r);
+            })
+                .catch((e) => {
+                deferBestChainBlockIncluded()?.reject(e);
+                deferFinalized()?.reject(e);
+            });
+        })
+            .catch(deferTx.reject);
+        return deferTx.promise;
     }
     #normalizeOptions(partialOptions, callback) {
         if ((0, utils_1.isFunction)(partialOptions)) {

package/cjs/extrinsic/submittable/SubmittableExtrinsic.js

@@ -18,34 +18,42 @@ class SubmittableExtrinsic extends BaseSubmittableExtrinsic_js_1.BaseSubmittable
         await this.sign(account, optionsOrHash);
         return dryRunFn(this.toHex());
     }
-    async send(callback) {
+    send(callback) {
         const isSubscription = !!callback;
         const txHex = this.toHex();
         const txHash = this.hash;
+        const { deferTx, onTxProgress } = (0, utils_js_1.txDefer)();
+        const unsub = this.client.rpc.author_submitAndWatchExtrinsic(txHex, async (txStatus) => {
+            if (txStatus.type === 'InBlock' || txStatus.type === 'Finalized') {
+                const blockHash = txStatus.value;
+                const [signedBlock, blockEvents] = await Promise.all([
+                    this.client.rpc.chain_getBlock(blockHash),
+                    this.getSystemEventsAt(blockHash),
+                ]);
+                const txIndex = signedBlock.block.extrinsics.indexOf(txHex);
+                (0, utils_1.assert)(txIndex >= 0, 'Extrinsic not found!');
+                const events = blockEvents.filter(({ phase }) => phase.type === 'ApplyExtrinsic' && phase.value === txIndex);
+                const blockNumber = signedBlock.block.header.number;
+                const status = (0, utils_js_1.toTxStatus)(txStatus, { txIndex, blockNumber });
+                const result = new SubmittableResult_js_1.SubmittableResult({ status, txHash, events, txIndex });
+                onTxProgress(result);
+                !isSubscription && deferTx.resolve(txHash);
+                return callback?.(result);
+            }
+            else {
+                const status = (0, utils_js_1.toTxStatus)(txStatus);
+                const result = new SubmittableResult_js_1.SubmittableResult({ status, txHash });
+                onTxProgress(result);
+                !isSubscription && deferTx.resolve(txHash);
+                return callback?.(new SubmittableResult_js_1.SubmittableResult({ status, txHash }));
+            }
+        });
         if (isSubscription) {
-            return this.client.rpc.author_submitAndWatchExtrinsic(txHex, async (txStatus) => {
-                if (txStatus.type === 'InBlock' || txStatus.type === 'Finalized') {
-                    const blockHash = txStatus.value;
-                    const [signedBlock, blockEvents] = await Promise.all([
-                        this.client.rpc.chain_getBlock(blockHash),
-                        this.getSystemEventsAt(blockHash),
-                    ]);
-                    const txIndex = signedBlock.block.extrinsics.indexOf(txHex);
-                    (0, utils_1.assert)(txIndex >= 0, 'Extrinsic not found!');
-                    const events = blockEvents.filter(({ phase }) => phase.type === 'ApplyExtrinsic' && phase.value === txIndex);
-                    const blockNumber = signedBlock.block.header.number;
-                    const status = (0, utils_js_1.toTxStatus)(txStatus, { txIndex, blockNumber });
-                    return callback(new SubmittableResult_js_1.SubmittableResult({ status, txHash, events, txIndex }));
-                }
-                else {
-                    const status = (0, utils_js_1.toTxStatus)(txStatus);
-                    return callback(new SubmittableResult_js_1.SubmittableResult({ status, txHash }));
-                }
+            unsub.then((x) => {
+                deferTx.resolve(x);
             });
         }
-        else {
-            return this.client.rpc.author_submitExtrinsic(txHex);
-        }
+        return deferTx.promise;
     }
 }
 exports.SubmittableExtrinsic = SubmittableExtrinsic;

package/cjs/extrinsic/submittable/SubmittableExtrinsicV2.js

@@ -5,6 +5,7 @@ const utils_1 = require("@dedot/utils");
 const BaseSubmittableExtrinsic_js_1 = require("./BaseSubmittableExtrinsic.js");
 const SubmittableResult_js_1 = require("./SubmittableResult.js");
 const errors_js_1 = require("./errors.js");
+const utils_js_1 = require("./utils.js");
 /**
  * @name SubmittableExtrinsicV2
  * @description Submittable extrinsic based on JSON-RPC v2
@@ -176,31 +177,39 @@ class SubmittableExtrinsicV2 extends BaseSubmittableExtrinsic_js_1.BaseSubmittab
         };
         return txUnsub;
     }
-    async send(callback) {
+    send(callback) {
         const isSubscription = !!callback;
-        if (isSubscription) {
-            return this.#send(callback);
-        }
-        else {
-            const defer = (0, utils_1.deferred)();
-            try {
-                // TODO handle timeout for this with the Drop status, just in-case we somehow can't find the tx in any block
-                const unsub = await this.#send(({ status, txHash }) => {
-                    if (status.type === 'BestChainBlockIncluded' || status.type === 'Finalized') {
-                        defer.resolve(txHash);
-                        unsub().catch(utils_1.noop);
-                    }
-                    else if (status.type === 'Invalid' || status.type === 'Drop') {
-                        defer.reject(new Error(status.value.error));
-                        unsub().catch(utils_1.noop);
-                    }
-                });
+        const { deferTx, onTxProgress } = (0, utils_js_1.txDefer)();
+        // TODO handle timeout for this with the Drop status,
+        //  just in-case we somehow can't find the tx in any block
+        let unsub;
+        this.#send((result) => {
+            onTxProgress(result);
+            if (isSubscription) {
+                try {
+                    callback?.(result);
+                }
+                catch { }
+                return;
             }
-            catch (e) {
-                defer.reject(e);
+            const { status, txHash } = result;
+            if (status.type === 'BestChainBlockIncluded' ||
+                status.type === 'Finalized' ||
+                status.type === 'Invalid' ||
+                status.type === 'Drop') {
+                deferTx.resolve(txHash);
+                // Unsub the subscription if we're at the final states
+                if (status.type !== 'BestChainBlockIncluded') {
+                    unsub?.().catch(utils_1.noop);
+                }
             }
-            return defer.promise;
-        }
+        })
+            .then((x) => {
+            unsub = x;
+            isSubscription && deferTx.resolve(unsub);
+        })
+            .catch(deferTx.reject);
+        return deferTx.promise;
     }
 }
 exports.SubmittableExtrinsicV2 = SubmittableExtrinsicV2;

package/cjs/extrinsic/submittable/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidTxError = void 0;
+exports.RejectedTxError = exports.InvalidTxError = void 0;
 const utils_1 = require("@dedot/utils");
 /**
  * This throws out if the extrinsic is invalid
@@ -15,3 +15,12 @@ class InvalidTxError extends utils_1.DedotError {
     }
 }
 exports.InvalidTxError = InvalidTxError;
+class RejectedTxError extends utils_1.DedotError {
+    result;
+    name = 'RejectedTxError';
+    constructor(result) {
+        super();
+        this.result = result;
+    }
+}
+exports.RejectedTxError = RejectedTxError;

package/cjs/extrinsic/submittable/utils.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toTxStatus = exports.signRaw = exports.isKeyringPair = void 0;
+exports.txDefer = exports.toTxStatus = exports.signRaw = exports.isKeyringPair = void 0;
 const utils_1 = require("@dedot/utils");
+const errors_js_1 = require("./errors.js");
 function isKeyringPair(account) {
     return (0, utils_1.isFunction)(account.sign);
 }
@@ -83,3 +84,40 @@ function toTxStatus(txStatus, txInfo) {
     }
 }
 exports.toTxStatus = toTxStatus;
+function txDefer() {
+    const deferTx = (0, utils_1.deferred)();
+    let deferFinalized;
+    let deferBestChainBlockIncluded;
+    Object.assign(deferTx.promise, {
+        untilFinalized: () => {
+            deferFinalized = (0, utils_1.deferred)();
+            return deferFinalized.promise;
+        },
+        untilBestChainBlockIncluded: () => {
+            deferBestChainBlockIncluded = (0, utils_1.deferred)();
+            return deferBestChainBlockIncluded.promise;
+        },
+    });
+    const onTxProgress = (result) => {
+        const { status } = result;
+        if (status.type === 'BestChainBlockIncluded') {
+            deferBestChainBlockIncluded?.resolve(result);
+        }
+        else if (status.type === 'Finalized') {
+            deferBestChainBlockIncluded?.resolve(result);
+            deferFinalized?.resolve(result);
+        }
+        else if (status.type === 'Invalid' || status.type === 'Drop') {
+            const e = new errors_js_1.RejectedTxError(result);
+            deferBestChainBlockIncluded?.reject(e);
+            deferFinalized?.reject(e);
+        }
+    };
+    return {
+        deferTx,
+        deferFinalized: () => deferFinalized,
+        deferBestChainBlockIncluded: () => deferBestChainBlockIncluded,
+        onTxProgress,
+    };
+}
+exports.txDefer = txDefer;

package/extrinsic/submittable/BaseSubmittableExtrinsic.d.ts

@@ -1,5 +1,5 @@
-import { BlockHash, Extrinsic, Hash } from '@dedot/codecs';
-import { AddressOrPair, Callback, IRuntimeTxCall, ISubmittableExtrinsic, ISubmittableResult, PayloadOptions, SignerOptions, TxPaymentInfo, Unsub } from '@dedot/types';
+import { BlockHash, Extrinsic } from '@dedot/codecs';
+import { AddressOrPair, Callback, IRuntimeTxCall, ISubmittableExtrinsic, ISubmittableResult, PayloadOptions, SignerOptions, TxHash, TxPaymentInfo, TxUnsub } from '@dedot/types';
 import { HexString } from '@dedot/utils';
 import type { FrameSystemEventRecord } from '../../chaintypes/index.js';
 import type { ISubstrateClient } from '../../types.js';
@@ -9,11 +9,11 @@ export declare abstract class BaseSubmittableExtrinsic extends Extrinsic impleme
     constructor(client: ISubstrateClient, call: IRuntimeTxCall);
     paymentInfo(account: AddressOrPair, options?: Partial<PayloadOptions>): Promise<TxPaymentInfo>;
     sign(fromAccount: AddressOrPair, options?: Partial<SignerOptions>): Promise<this>;
-    signAndSend(account: AddressOrPair, options?: Partial<SignerOptions>): Promise<Hash>;
-    signAndSend(account: AddressOrPair, callback: Callback<ISubmittableResult>): Promise<Unsub>;
-    signAndSend(account: AddressOrPair, options: Partial<SignerOptions>, callback?: Callback<ISubmittableResult>): Promise<Unsub>;
-    send(): Promise<Hash>;
-    send(callback: Callback): Promise<Unsub>;
+    signAndSend(account: AddressOrPair, options?: Partial<SignerOptions>): TxHash;
+    signAndSend(account: AddressOrPair, callback: Callback<ISubmittableResult>): TxUnsub;
+    signAndSend(account: AddressOrPair, options: Partial<SignerOptions>, callback?: Callback<ISubmittableResult>): TxUnsub;
+    send(): TxHash;
+    send(callback: Callback): TxUnsub;
     protected getSystemEventsAt(hash: BlockHash): Promise<FrameSystemEventRecord[]>;
     toHex(): HexString;
 }

package/extrinsic/submittable/BaseSubmittableExtrinsic.js

@@ -2,7 +2,7 @@ import { Extrinsic } from '@dedot/codecs';
 import { DedotError, isFunction, toHex, u8aToHex } from '@dedot/utils';
 import { ExtraSignedExtension } from '../extensions/index.js';
 import { fakeSigner } from './fakeSigner.js';
-import { isKeyringPair, signRaw } from './utils.js';
+import { isKeyringPair, signRaw, txDefer } from './utils.js';
 export class BaseSubmittableExtrinsic extends Extrinsic {
     client;
     #alterTx;
@@ -52,10 +52,35 @@ export class BaseSubmittableExtrinsic extends Extrinsic {
         }
         return this;
     }
-    async signAndSend(fromAccount, partialOptions, maybeCallback) {
+    signAndSend(fromAccount, partialOptions, maybeCallback) {
         const [options, callback] = this.#normalizeOptions(partialOptions, maybeCallback);
-        await this.sign(fromAccount, options);
-        return this.send(callback);
+        const { deferTx, deferFinalized, deferBestChainBlockIncluded, onTxProgress } = txDefer();
+        this.sign(fromAccount, options)
+            .then(() => {
+            const deferSend = this.send(callback);
+            deferSend
+                .then(deferTx.resolve) // --
+                .catch(deferTx.reject);
+            deferSend
+                .untilBestChainBlockIncluded() //--
+                .then((r) => {
+                onTxProgress(r);
+            })
+                .catch((e) => {
+                deferBestChainBlockIncluded()?.reject(e);
+            });
+            deferSend
+                .untilFinalized() //--
+                .then((r) => {
+                onTxProgress(r);
+            })
+                .catch((e) => {
+                deferBestChainBlockIncluded()?.reject(e);
+                deferFinalized()?.reject(e);
+            });
+        })
+            .catch(deferTx.reject);
+        return deferTx.promise;
     }
     #normalizeOptions(partialOptions, callback) {
         if (isFunction(partialOptions)) {

package/extrinsic/submittable/SubmittableExtrinsic.d.ts

@@ -1,5 +1,5 @@
-import { BlockHash, Hash } from '@dedot/codecs';
-import { AddressOrPair, Callback, DryRunResult, ISubmittableExtrinsicLegacy, ISubmittableResult, SignerOptions, Unsub } from '@dedot/types';
+import { BlockHash } from '@dedot/codecs';
+import { AddressOrPair, Callback, DryRunResult, ISubmittableExtrinsicLegacy, ISubmittableResult, SignerOptions, TxHash, TxUnsub } from '@dedot/types';
 import { BaseSubmittableExtrinsic } from './BaseSubmittableExtrinsic.js';
 /**
  * @name SubmittableExtrinsic
@@ -7,6 +7,6 @@ import { BaseSubmittableExtrinsic } from './BaseSubmittableExtrinsic.js';
  */
 export declare class SubmittableExtrinsic extends BaseSubmittableExtrinsic implements ISubmittableExtrinsicLegacy {
     dryRun(account: AddressOrPair, optionsOrHash?: Partial<SignerOptions> | BlockHash): Promise<DryRunResult>;
-    send(): Promise<Hash>;
-    send(callback: Callback<ISubmittableResult>): Promise<Unsub>;
+    send(): TxHash;
+    send(callback: Callback<ISubmittableResult>): TxUnsub;
 }

package/extrinsic/submittable/SubmittableExtrinsic.js

@@ -1,7 +1,7 @@
 import { assert, isHex } from '@dedot/utils';
 import { BaseSubmittableExtrinsic } from './BaseSubmittableExtrinsic.js';
 import { SubmittableResult } from './SubmittableResult.js';
-import { toTxStatus } from './utils.js';
+import { toTxStatus, txDefer } from './utils.js';
 /**
  * @name SubmittableExtrinsic
  * @description A wrapper around an Extrinsic that exposes methods to sign, send, and other utility around Extrinsic.
@@ -15,33 +15,41 @@ export class SubmittableExtrinsic extends BaseSubmittableExtrinsic {
         await this.sign(account, optionsOrHash);
         return dryRunFn(this.toHex());
     }
-    async send(callback) {
+    send(callback) {
         const isSubscription = !!callback;
         const txHex = this.toHex();
         const txHash = this.hash;
+        const { deferTx, onTxProgress } = txDefer();
+        const unsub = this.client.rpc.author_submitAndWatchExtrinsic(txHex, async (txStatus) => {
+            if (txStatus.type === 'InBlock' || txStatus.type === 'Finalized') {
+                const blockHash = txStatus.value;
+                const [signedBlock, blockEvents] = await Promise.all([
+                    this.client.rpc.chain_getBlock(blockHash),
+                    this.getSystemEventsAt(blockHash),
+                ]);
+                const txIndex = signedBlock.block.extrinsics.indexOf(txHex);
+                assert(txIndex >= 0, 'Extrinsic not found!');
+                const events = blockEvents.filter(({ phase }) => phase.type === 'ApplyExtrinsic' && phase.value === txIndex);
+                const blockNumber = signedBlock.block.header.number;
+                const status = toTxStatus(txStatus, { txIndex, blockNumber });
+                const result = new SubmittableResult({ status, txHash, events, txIndex });
+                onTxProgress(result);
+                !isSubscription && deferTx.resolve(txHash);
+                return callback?.(result);
+            }
+            else {
+                const status = toTxStatus(txStatus);
+                const result = new SubmittableResult({ status, txHash });
+                onTxProgress(result);
+                !isSubscription && deferTx.resolve(txHash);
+                return callback?.(new SubmittableResult({ status, txHash }));
+            }
+        });
         if (isSubscription) {
-            return this.client.rpc.author_submitAndWatchExtrinsic(txHex, async (txStatus) => {
-                if (txStatus.type === 'InBlock' || txStatus.type === 'Finalized') {
-                    const blockHash = txStatus.value;
-                    const [signedBlock, blockEvents] = await Promise.all([
-                        this.client.rpc.chain_getBlock(blockHash),
-                        this.getSystemEventsAt(blockHash),
-                    ]);
-                    const txIndex = signedBlock.block.extrinsics.indexOf(txHex);
-                    assert(txIndex >= 0, 'Extrinsic not found!');
-                    const events = blockEvents.filter(({ phase }) => phase.type === 'ApplyExtrinsic' && phase.value === txIndex);
-                    const blockNumber = signedBlock.block.header.number;
-                    const status = toTxStatus(txStatus, { txIndex, blockNumber });
-                    return callback(new SubmittableResult({ status, txHash, events, txIndex }));
-                }
-                else {
-                    const status = toTxStatus(txStatus);
-                    return callback(new SubmittableResult({ status, txHash }));
-                }
+            unsub.then((x) => {
+                deferTx.resolve(x);
             });
         }
-        else {
-            return this.client.rpc.author_submitExtrinsic(txHex);
-        }
+        return deferTx.promise;
     }
 }

package/extrinsic/submittable/SubmittableExtrinsicV2.d.ts

@@ -1,5 +1,4 @@
-import type { Hash } from '@dedot/codecs';
-import type { Callback, IRuntimeTxCall, Unsub } from '@dedot/types';
+import { Callback, IRuntimeTxCall, TxHash, TxUnsub } from '@dedot/types';
 import { DedotClient } from '../../client/index.js';
 import { BaseSubmittableExtrinsic } from './BaseSubmittableExtrinsic.js';
 /**
@@ -10,6 +9,6 @@ export declare class SubmittableExtrinsicV2 extends BaseSubmittableExtrinsic {
     #private;
     client: DedotClient;
     constructor(client: DedotClient, call: IRuntimeTxCall);
-    send(): Promise<Hash>;
-    send(callback: Callback): Promise<Unsub>;
+    send(): TxHash;
+    send(callback: Callback): TxUnsub;
 }

package/extrinsic/submittable/SubmittableExtrinsicV2.js

@@ -1,7 +1,8 @@
-import { AsyncQueue, deferred, noop } from '@dedot/utils';
+import { AsyncQueue, noop } from '@dedot/utils';
 import { BaseSubmittableExtrinsic } from './BaseSubmittableExtrinsic.js';
 import { SubmittableResult } from './SubmittableResult.js';
 import { InvalidTxError } from './errors.js';
+import { txDefer } from './utils.js';
 /**
  * @name SubmittableExtrinsicV2
  * @description Submittable extrinsic based on JSON-RPC v2
@@ -173,30 +174,38 @@ export class SubmittableExtrinsicV2 extends BaseSubmittableExtrinsic {
         };
         return txUnsub;
     }
-    async send(callback) {
+    send(callback) {
         const isSubscription = !!callback;
-        if (isSubscription) {
-            return this.#send(callback);
-        }
-        else {
-            const defer = deferred();
-            try {
-                // TODO handle timeout for this with the Drop status, just in-case we somehow can't find the tx in any block
-                const unsub = await this.#send(({ status, txHash }) => {
-                    if (status.type === 'BestChainBlockIncluded' || status.type === 'Finalized') {
-                        defer.resolve(txHash);
-                        unsub().catch(noop);
-                    }
-                    else if (status.type === 'Invalid' || status.type === 'Drop') {
-                        defer.reject(new Error(status.value.error));
-                        unsub().catch(noop);
-                    }
-                });
+        const { deferTx, onTxProgress } = txDefer();
+        // TODO handle timeout for this with the Drop status,
+        //  just in-case we somehow can't find the tx in any block
+        let unsub;
+        this.#send((result) => {
+            onTxProgress(result);
+            if (isSubscription) {
+                try {
+                    callback?.(result);
+                }
+                catch { }
+                return;
             }
-            catch (e) {
-                defer.reject(e);
+            const { status, txHash } = result;
+            if (status.type === 'BestChainBlockIncluded' ||
+                status.type === 'Finalized' ||
+                status.type === 'Invalid' ||
+                status.type === 'Drop') {
+                deferTx.resolve(txHash);
+                // Unsub the subscription if we're at the final states
+                if (status.type !== 'BestChainBlockIncluded') {
+                    unsub?.().catch(noop);
+                }
             }
-            return defer.promise;
-        }
+        })
+            .then((x) => {
+            unsub = x;
+            isSubscription && deferTx.resolve(unsub);
+        })
+            .catch(deferTx.reject);
+        return deferTx.promise;
     }
 }

package/extrinsic/submittable/errors.d.ts

@@ -1,4 +1,5 @@
 import type { Result } from '@dedot/codecs';
+import { ISubmittableResult } from '@dedot/types';
 import { DedotError } from '@dedot/utils';
 import type { SpRuntimeTransactionValidityTransactionValidityError, SpRuntimeTransactionValidityValidTransaction } from '../../chaintypes/index.js';
 /**
@@ -10,3 +11,8 @@ export declare class InvalidTxError extends DedotError {
     name: string;
     constructor(message: string, data: Result<SpRuntimeTransactionValidityValidTransaction, SpRuntimeTransactionValidityTransactionValidityError>);
 }
+export declare class RejectedTxError extends DedotError {
+    result: ISubmittableResult;
+    name: string;
+    constructor(result: ISubmittableResult);
+}

package/extrinsic/submittable/errors.js

@@ -11,3 +11,11 @@ export class InvalidTxError extends DedotError {
         this.data = data;
     }
 }
+export class RejectedTxError extends DedotError {
+    result;
+    name = 'RejectedTxError';
+    constructor(result) {
+        super();
+        this.result = result;
+    }
+}

package/extrinsic/submittable/utils.d.ts

@@ -1,6 +1,6 @@
 import { TransactionStatus } from '@dedot/codecs';
-import type { AddressOrPair, IKeyringPair, TxStatus } from '@dedot/types';
-import { HexString } from '@dedot/utils';
+import { AddressOrPair, IKeyringPair, ISubmittableResult, TxStatus, Unsub } from '@dedot/types';
+import { Deferred, HexString } from '@dedot/utils';
 export declare function isKeyringPair(account: AddressOrPair): account is IKeyringPair;
 /**
  * Sign a raw message
@@ -20,4 +20,10 @@ type TxInfo = {
  * @param txInfo
  */
 export declare function toTxStatus(txStatus: TransactionStatus, txInfo?: TxInfo): TxStatus;
+export declare function txDefer(): {
+    deferTx: Deferred<`0x${string}` | Unsub>;
+    deferFinalized: () => Deferred<ISubmittableResult<import("@dedot/types").IEventRecord<import("@dedot/types").IRuntimeEvent, `0x${string}`>>> | undefined;
+    deferBestChainBlockIncluded: () => Deferred<ISubmittableResult<import("@dedot/types").IEventRecord<import("@dedot/types").IRuntimeEvent, `0x${string}`>>> | undefined;
+    onTxProgress: (result: ISubmittableResult) => void;
+};
 export {};

package/extrinsic/submittable/utils.js

@@ -1,4 +1,5 @@
-import { assert, blake2AsU8a, hexToU8a, isFunction } from '@dedot/utils';
+import { assert, blake2AsU8a, deferred, hexToU8a, isFunction } from '@dedot/utils';
+import { RejectedTxError } from './errors.js';
 export function isKeyringPair(account) {
     return isFunction(account.sign);
 }
@@ -77,3 +78,39 @@ export function toTxStatus(txStatus, txInfo) {
             };
     }
 }
+export function txDefer() {
+    const deferTx = deferred();
+    let deferFinalized;
+    let deferBestChainBlockIncluded;
+    Object.assign(deferTx.promise, {
+        untilFinalized: () => {
+            deferFinalized = deferred();
+            return deferFinalized.promise;
+        },
+        untilBestChainBlockIncluded: () => {
+            deferBestChainBlockIncluded = deferred();
+            return deferBestChainBlockIncluded.promise;
+        },
+    });
+    const onTxProgress = (result) => {
+        const { status } = result;
+        if (status.type === 'BestChainBlockIncluded') {
+            deferBestChainBlockIncluded?.resolve(result);
+        }
+        else if (status.type === 'Finalized') {
+            deferBestChainBlockIncluded?.resolve(result);
+            deferFinalized?.resolve(result);
+        }
+        else if (status.type === 'Invalid' || status.type === 'Drop') {
+            const e = new RejectedTxError(result);
+            deferBestChainBlockIncluded?.reject(e);
+            deferFinalized?.reject(e);
+        }
+    };
+    return {
+        deferTx,
+        deferFinalized: () => deferFinalized,
+        deferBestChainBlockIncluded: () => deferBestChainBlockIncluded,
+        onTxProgress,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/api",
-  "version": "0.10.0",
+  "version": "0.11.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": "0.10.0",
-    "@dedot/providers": "0.10.0",
-    "@dedot/runtime-specs": "0.10.0",
-    "@dedot/shape": "0.10.0",
-    "@dedot/storage": "0.10.0",
-    "@dedot/types": "0.10.0",
-    "@dedot/utils": "0.10.0"
+    "@dedot/codecs": "0.11.0",
+    "@dedot/providers": "0.11.0",
+    "@dedot/runtime-specs": "0.11.0",
+    "@dedot/shape": "0.11.0",
+    "@dedot/storage": "0.11.0",
+    "@dedot/types": "0.11.0",
+    "@dedot/utils": "0.11.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": "b6139d257df621080e3e7a0ce260da19e572c1c5",
+  "gitHead": "5aa20d8c24305df30528f008b55dc0f6f89b9e95",
   "module": "./index.js",
   "types": "./index.d.ts"
 }