@dedot/api 0.0.1-alpha.32

package/extrinsic/extensions/known/CheckMortality.js

@@ -0,0 +1,86 @@
+import { assert, bnMin, isZeroHex, numberToHex, u8aToHex } from '@dedot/utils';
+import { SignedExtension } from '../SignedExtension.js';
+export const MAX_FINALITY_LAG = 5;
+export const FALLBACK_MAX_HASH_COUNT = 250;
+export const FALLBACK_PERIOD = 6 * 1000;
+export const MORTAL_PERIOD = 5 * 60 * 1000;
+/**
+ * @description Check for transaction mortality.
+ */
+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;
+    }
+    async #getSigningHeader() {
+        if (this.api.rpcVersion === 'v2') {
+            return this.#getSigningHeaderRpcV2();
+        }
+        return this.#getSigningHeaderViaLegacyRpc();
+    }
+    async #getSigningHeaderRpcV2() {
+        const api = this.api;
+        // TODO similar to the legacy, we should account for the case finality is lagging behind
+        const finalizedBlock = await api.chainHead.finalizedBlock();
+        return {
+            hash: finalizedBlock.hash,
+            number: finalizedBlock.number,
+        };
+    }
+    // Ref: https://github.com/polkadot-js/api/blob/3bdf49b0428a62f16b3222b9a31bfefa43c1ca55/packages/api-derive/src/tx/signingInfo.ts#L34-L64
+    async #getSigningHeaderViaLegacyRpc() {
+        const [header, finalizedHash] = await Promise.all([
+            this.api.rpc.chain_getHeader(),
+            this.api.rpc.chain_getFinalizedHead(),
+        ]);
+        assert(header, 'Current header not found');
+        const [currentHeader, finalizedHeader] = await Promise.all([
+            Promise.resolve(header).then((header) => {
+                const { parentHash } = header;
+                if (parentHash.length === 0 || isZeroHex(parentHash)) {
+                    return header;
+                }
+                else {
+                    return this.api.rpc.chain_getHeader(parentHash);
+                }
+            }),
+            this.api.rpc.chain_getHeader(finalizedHash),
+        ]);
+        assert(currentHeader, 'Cannot determine current header');
+        if (!finalizedHeader || currentHeader.number - finalizedHeader.number > MAX_FINALITY_LAG) {
+            return this.#toSigningHeader(currentHeader);
+        }
+        return this.#toSigningHeader(finalizedHeader);
+    }
+    async #toSigningHeader(header) {
+        const { number } = header;
+        const hash = (await this.api.rpc.chain_getBlockHash(header.number));
+        return { hash, number };
+    }
+    // Ref: https://github.com/polkadot-js/api/blob/3bdf49b0428a62f16b3222b9a31bfefa43c1ca55/packages/api-derive/src/tx/signingInfo.ts#L83-L93
+    #calculateMortalLength() {
+        return bnMin(BigInt(this.#getConst('system', 'blockHashCount') || FALLBACK_MAX_HASH_COUNT), BigInt(MORTAL_PERIOD) /
+            BigInt(this.#getConst('babe', 'expectedBlockTime') ||
+                BigInt(this.#getConst('timestamp', 'minimumPeriod') || 0) * 2n ||
+                FALLBACK_PERIOD) +
+            BigInt(MAX_FINALITY_LAG));
+    }
+    #getConst(pallet, name) {
+        try {
+            return this.api.consts[pallet][name];
+        }
+        catch {
+            // ignore this on purpose
+        }
+        return undefined;
+    }
+    toPayload() {
+        return {
+            era: u8aToHex(this.$Data.tryEncode(this.data)),
+            blockHash: this.additionalSigned,
+            blockNumber: numberToHex(this.#signingHeader.number),
+        };
+    }
+}

package/extrinsic/extensions/known/CheckNonZeroSender.d.ts

@@ -0,0 +1,6 @@
+import { SignedExtension } from '../SignedExtension.js';
+/**
+ * @description Check to ensure that the sender is not the zero address
+ */
+export declare class CheckNonZeroSender extends SignedExtension {
+}

package/extrinsic/extensions/known/CheckNonZeroSender.js

@@ -0,0 +1,6 @@
+import { SignedExtension } from '../SignedExtension.js';
+/**
+ * @description Check to ensure that the sender is not the zero address
+ */
+export class CheckNonZeroSender extends SignedExtension {
+}

package/extrinsic/extensions/known/CheckNonce.d.ts

@@ -0,0 +1,10 @@
+import { SignerPayloadJSON } from '@polkadot/types/types';
+import { SignedExtension } from '../SignedExtension.js';
+/**
+ * @description Nonce check and increment to give replay protection for transactions.
+ */
+export declare class CheckNonce extends SignedExtension<number> {
+    #private;
+    init(): Promise<void>;
+    toPayload(): Partial<SignerPayloadJSON>;
+}

package/extrinsic/extensions/known/CheckNonce.js

@@ -0,0 +1,29 @@
+import { assert, numberToHex } from '@dedot/utils';
+import { SignedExtension } from '../SignedExtension.js';
+/**
+ * @description Nonce check and increment to give replay protection for transactions.
+ */
+export class CheckNonce extends SignedExtension {
+    async init() {
+        this.data = this.payloadOptions.nonce || (await this.#getNonce());
+    }
+    async #getNonce() {
+        const { signerAddress } = this.options || {};
+        assert(signerAddress, 'Signer address not found');
+        try {
+            return (await this.api.query.system.account(signerAddress)).nonce;
+        }
+        catch { }
+        try {
+            return await this.api.call.accountNonceApi.accountNonce(signerAddress);
+        }
+        catch { }
+        // TODO fallback to api.rpc.system_accountNextIndex if needed
+        return 0;
+    }
+    toPayload() {
+        return {
+            nonce: numberToHex(this.data),
+        };
+    }
+}

package/extrinsic/extensions/known/CheckSpecVersion.d.ts

@@ -0,0 +1,9 @@
+import { SignerPayloadJSON } from '@polkadot/types/types';
+import { SignedExtension } from '../SignedExtension.js';
+/**
+ * @description Ensure the runtime version registered in the transaction is the same as at present.
+ */
+export declare class CheckSpecVersion extends SignedExtension<{}, number> {
+    init(): Promise<void>;
+    toPayload(): Partial<SignerPayloadJSON>;
+}

package/extrinsic/extensions/known/CheckSpecVersion.js

@@ -0,0 +1,15 @@
+import { numberToHex } from '@dedot/utils';
+import { SignedExtension } from '../SignedExtension.js';
+/**
+ * @description Ensure the runtime version registered in the transaction is the same as at present.
+ */
+export class CheckSpecVersion extends SignedExtension {
+    async init() {
+        this.additionalSigned = this.api.runtimeVersion.specVersion;
+    }
+    toPayload() {
+        return {
+            specVersion: numberToHex(this.additionalSigned),
+        };
+    }
+}

package/extrinsic/extensions/known/CheckTxVersion.d.ts

@@ -0,0 +1,9 @@
+import { SignerPayloadJSON } from '@polkadot/types/types';
+import { SignedExtension } from '../SignedExtension.js';
+/**
+ * @description Ensure the transaction version registered in the transaction is the same as at present.
+ */
+export declare class CheckTxVersion extends SignedExtension<{}, number> {
+    init(): Promise<void>;
+    toPayload(): Partial<SignerPayloadJSON>;
+}

package/extrinsic/extensions/known/CheckTxVersion.js

@@ -0,0 +1,15 @@
+import { numberToHex } from '@dedot/utils';
+import { SignedExtension } from '../SignedExtension.js';
+/**
+ * @description Ensure the transaction version registered in the transaction is the same as at present.
+ */
+export class CheckTxVersion extends SignedExtension {
+    async init() {
+        this.additionalSigned = this.api.runtimeVersion.transactionVersion;
+    }
+    toPayload() {
+        return {
+            transactionVersion: numberToHex(this.additionalSigned),
+        };
+    }
+}

package/extrinsic/extensions/known/CheckWeight.d.ts

@@ -0,0 +1,6 @@
+import { SignedExtension } from '../SignedExtension.js';
+/**
+ * @description Block resource (weight) limit check.
+ */
+export declare class CheckWeight extends SignedExtension {
+}

package/extrinsic/extensions/known/CheckWeight.js

@@ -0,0 +1,6 @@
+import { SignedExtension } from '../SignedExtension.js';
+/**
+ * @description Block resource (weight) limit check.
+ */
+export class CheckWeight extends SignedExtension {
+}

package/extrinsic/extensions/known/PrevalidateAttests.d.ts

@@ -0,0 +1,7 @@
+import { SignedExtension } from '../SignedExtension.js';
+/**
+ * @description Validate `attest` calls prior to execution.
+ * Needed to avoid a DoS attack since they are otherwise free to place on chain.
+ */
+export declare class PrevalidateAttests extends SignedExtension {
+}

package/extrinsic/extensions/known/PrevalidateAttests.js

@@ -0,0 +1,7 @@
+import { SignedExtension } from '../SignedExtension.js';
+/**
+ * @description Validate `attest` calls prior to execution.
+ * Needed to avoid a DoS attack since they are otherwise free to place on chain.
+ */
+export class PrevalidateAttests extends SignedExtension {
+}

package/extrinsic/extensions/known/index.d.ts

@@ -0,0 +1,3 @@
+import { ISignedExtension } from '../SignedExtension.js';
+export type AnySignedExtension = new (...args: any[]) => ISignedExtension;
+export declare const knownSignedExtensions: Record<string, AnySignedExtension>;

package/extrinsic/extensions/known/index.js

@@ -0,0 +1,22 @@
+import { ChargeAssetTxPayment } from './ChargeAssetTxPayment.js';
+import { ChargeTransactionPayment } from './ChargeTransactionPayment.js';
+import { CheckGenesis } from './CheckGenesis.js';
+import { CheckMortality } from './CheckMortality.js';
+import { CheckNonZeroSender } from './CheckNonZeroSender.js';
+import { CheckNonce } from './CheckNonce.js';
+import { CheckSpecVersion } from './CheckSpecVersion.js';
+import { CheckTxVersion } from './CheckTxVersion.js';
+import { CheckWeight } from './CheckWeight.js';
+import { PrevalidateAttests } from './PrevalidateAttests.js';
+export const knownSignedExtensions = {
+    CheckNonZeroSender,
+    CheckSpecVersion,
+    CheckTxVersion,
+    CheckGenesis,
+    CheckMortality,
+    CheckNonce,
+    CheckWeight,
+    ChargeTransactionPayment,
+    PrevalidateAttests,
+    ChargeAssetTxPayment,
+};

package/extrinsic/index.d.ts

@@ -0,0 +1,2 @@
+export * from './extensions/index.js';
+export * from './submittable/index.js';

package/extrinsic/index.js

@@ -0,0 +1,2 @@
+export * from './extensions/index.js';
+export * from './submittable/index.js';

package/extrinsic/submittable/BaseSubmittableExtrinsic.d.ts

@@ -0,0 +1,17 @@
+import { BlockHash, Extrinsic, Hash } from '@dedot/codecs';
+import { AddressOrPair, Callback, IRuntimeTxCall, ISubmittableExtrinsic, ISubmittableResult, PayloadOptions, SignerOptions, TxPaymentInfo, Unsub } from '@dedot/types';
+import type { FrameSystemEventRecord } from '../../chaintypes/index.js';
+import type { ISubstrateClient } from '../../types.js';
+export declare abstract class BaseSubmittableExtrinsic extends Extrinsic implements ISubmittableExtrinsic {
+    #private;
+    api: ISubstrateClient;
+    constructor(api: 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>;
+    protected getSystemEventsAt(hash: BlockHash): Promise<FrameSystemEventRecord[]>;
+}

package/extrinsic/submittable/BaseSubmittableExtrinsic.js

@@ -0,0 +1,66 @@
+import { Extrinsic } from '@dedot/codecs';
+import { isFunction, u8aToHex } from '@dedot/utils';
+import { ExtraSignedExtension } from '../extensions/index.js';
+import { fakeSigner } from './fakeSigner.js';
+import { isKeyringPair, signRaw } from './utils.js';
+export class BaseSubmittableExtrinsic extends Extrinsic {
+    api;
+    constructor(api, call) {
+        super(api.registry, call);
+        this.api = api;
+    }
+    async paymentInfo(account, options) {
+        await this.sign(account, { ...options, signer: fakeSigner });
+        const txU8a = this.toU8a();
+        const api = this.api;
+        return api.call.transactionPaymentApi.queryInfo(txU8a, txU8a.length);
+    }
+    async sign(fromAccount, options) {
+        const address = isKeyringPair(fromAccount) ? fromAccount.address : fromAccount.toString();
+        const extra = new ExtraSignedExtension(this.api, {
+            signerAddress: address,
+            payloadOptions: options,
+        });
+        await extra.init();
+        const { signer } = options || {};
+        let signature;
+        if (isKeyringPair(fromAccount)) {
+            signature = u8aToHex(signRaw(fromAccount, extra.toRawPayload(this.callHex).data));
+        }
+        else if (signer?.signPayload) {
+            const result = await signer.signPayload(extra.toPayload(this.callHex));
+            signature = result.signature;
+        }
+        else {
+            throw new Error('Signer not found. Cannot sign the extrinsic!');
+        }
+        const { signatureTypeId } = this.registry.metadata.extrinsic;
+        const $Signature = this.registry.findCodec(signatureTypeId);
+        this.attachSignature({
+            address: address,
+            signature: $Signature.tryDecode(signature),
+            extra: extra.data,
+        });
+        return this;
+    }
+    async signAndSend(fromAccount, partialOptions, maybeCallback) {
+        const [options, callback] = this.#normalizeOptions(partialOptions, maybeCallback);
+        await this.sign(fromAccount, options);
+        return this.send(callback);
+    }
+    #normalizeOptions(partialOptions, callback) {
+        if (isFunction(partialOptions)) {
+            return [{}, partialOptions];
+        }
+        else {
+            return [Object.assign({}, partialOptions), callback];
+        }
+    }
+    send(callback) {
+        throw new Error('Unimplemented!');
+    }
+    async getSystemEventsAt(hash) {
+        const atApi = (await this.api.at(hash));
+        return await atApi.query.system.events();
+    }
+}

package/extrinsic/submittable/SubmittableExtrinsic.d.ts

@@ -0,0 +1,12 @@
+import { BlockHash, Hash } from '@dedot/codecs';
+import { AddressOrPair, Callback, DryRunResult, ISubmittableExtrinsicLegacy, ISubmittableResult, SignerOptions, Unsub } from '@dedot/types';
+import { BaseSubmittableExtrinsic } from './BaseSubmittableExtrinsic.js';
+/**
+ * @name SubmittableExtrinsic
+ * @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 {
+    dryRun(account: AddressOrPair, optionsOrHash?: Partial<SignerOptions> | BlockHash): Promise<DryRunResult>;
+    send(): Promise<Hash>;
+    send(callback: Callback<ISubmittableResult>): Promise<Unsub>;
+}

package/extrinsic/submittable/SubmittableExtrinsic.js

@@ -0,0 +1,43 @@
+import { assert, isHex } from '@dedot/utils';
+import { BaseSubmittableExtrinsic } from './BaseSubmittableExtrinsic.js';
+import { SubmittableResult } from './SubmittableResult.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 {
+    async dryRun(account, optionsOrHash) {
+        const dryRunFn = this.api.rpc.system_dryRun;
+        if (isHex(optionsOrHash)) {
+            return dryRunFn(this.toHex(), optionsOrHash);
+        }
+        await this.sign(account, optionsOrHash);
+        return dryRunFn(this.toHex());
+    }
+    async send(callback) {
+        const isSubscription = !!callback;
+        const txHex = this.toHex();
+        const txHash = this.hash;
+        if (isSubscription) {
+            return this.api.rpc.author_submitAndWatchExtrinsic(txHex, async (status) => {
+                if (status.tag === 'InBlock' || status.tag === 'Finalized') {
+                    const blockHash = status.value;
+                    const [signedBlock, blockEvents] = await Promise.all([
+                        this.api.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.tag === 'ApplyExtrinsic' && phase.value === txIndex);
+                    return callback(new SubmittableResult({ status, txHash, events, txIndex }));
+                }
+                else {
+                    return callback(new SubmittableResult({ status, txHash }));
+                }
+            });
+        }
+        else {
+            return this.api.rpc.author_submitExtrinsic(txHex);
+        }
+    }
+}

package/extrinsic/submittable/SubmittableExtrinsicV2.d.ts

@@ -0,0 +1,15 @@
+import type { Hash } from '@dedot/codecs';
+import type { Callback, IRuntimeTxCall, Unsub } from '@dedot/types';
+import { DedotClient } from '../../client/index.js';
+import { BaseSubmittableExtrinsic } from './BaseSubmittableExtrinsic.js';
+/**
+ * @name SubmittableExtrinsicV2
+ * @description Submittable extrinsic based on JSON-RPC v2
+ */
+export declare class SubmittableExtrinsicV2 extends BaseSubmittableExtrinsic {
+    #private;
+    api: DedotClient;
+    constructor(api: DedotClient, call: IRuntimeTxCall);
+    send(): Promise<Hash>;
+    send(callback: Callback): Promise<Unsub>;
+}

package/extrinsic/submittable/SubmittableExtrinsicV2.js

@@ -0,0 +1,200 @@
+import { AsyncQueue, deferred, noop } from '@dedot/utils';
+import { BaseSubmittableExtrinsic } from './BaseSubmittableExtrinsic.js';
+import { SubmittableResult } from './SubmittableResult.js';
+import { InvalidTxError } from './errors.js';
+/**
+ * @name SubmittableExtrinsicV2
+ * @description Submittable extrinsic based on JSON-RPC v2
+ */
+export class SubmittableExtrinsicV2 extends BaseSubmittableExtrinsic {
+    api;
+    constructor(api, call) {
+        super(api, call);
+        this.api = api;
+    }
+    async #send(callback) {
+        const api = this.api;
+        const txHex = this.toHex();
+        const txHash = this.hash;
+        // validate the transaction
+        // https://github.com/paritytech/json-rpc-interface-spec/issues/55#issuecomment-1609011150
+        const finalizedHash = await this.api.chainHead.finalizedHash();
+        const validateTx = async (hash) => {
+            const apiAt = await api.at(hash);
+            return apiAt.call.taggedTransactionQueue.validateTransaction('External', txHex, hash);
+        };
+        const validation = await validateTx(finalizedHash);
+        if (validation.isOk) {
+            callback(new SubmittableResult({ status: { tag: 'Validated' }, txHash }));
+        }
+        else if (validation.isErr) {
+            throw new InvalidTxError(`Invalid Tx: ${validation.err.tag} - ${validation.err.value.tag}`, validation);
+        }
+        const checkTxIsOnChain = async (blockHash) => {
+            if (blockHash === finalizedHash)
+                return;
+            const txs = await api.chainHead.body(blockHash);
+            const txIndex = txs.indexOf(txHex);
+            if (txIndex < 0) {
+                return checkTxIsOnChain(api.chainHead.findBlock(blockHash).parent);
+            }
+            const events = await this.getSystemEventsAt(blockHash);
+            const txEvents = events.filter(({ phase }) => phase.tag == 'ApplyExtrinsic' && phase.value === txIndex);
+            return {
+                blockHash,
+                index: txIndex,
+                events: txEvents,
+            };
+        };
+        let txFound;
+        let isSearching = false;
+        let searchQueue = new AsyncQueue();
+        // TODO 1. move the searching logic into a different utility
+        //      2. properly cancel the work by actually cancel the on-going operations
+        const cancelPendingSearch = () => {
+            searchQueue.clear();
+        };
+        const cancelBodySearch = () => {
+            searchQueue.cancel();
+        };
+        const startSearching = (block) => {
+            return searchQueue.enqueue(async () => {
+                const found = await checkTxIsOnChain(block.hash);
+                if (found) {
+                    cancelPendingSearch();
+                }
+                return found;
+            });
+        };
+        const checkBestBlockIncluded = async (block, bestChainChanged) => {
+            if (bestChainChanged) {
+                if (isSearching) {
+                    // if the best chain is changing, we cancel the current search
+                    // and start searching on the current best chain
+                    cancelBodySearch();
+                }
+            }
+            else {
+                if (txFound)
+                    return;
+            }
+            try {
+                isSearching = true;
+                const inBlock = await startSearching(block);
+                if (!inBlock) {
+                    if (txFound && bestChainChanged) {
+                        txFound = undefined;
+                        callback(new SubmittableResult({
+                            status: { tag: 'NoLongerInBestChain' },
+                            txHash,
+                        }));
+                    }
+                    return;
+                }
+                if (txFound && bestChainChanged) {
+                    if (txFound.blockHash === inBlock.blockHash)
+                        return;
+                }
+                txFound = inBlock;
+                const { index: txIndex, events, blockHash } = inBlock;
+                callback(new SubmittableResult({
+                    status: { tag: 'BestChainBlockIncluded', value: { blockHash, txIndex } },
+                    txHash,
+                    events,
+                    txIndex,
+                }));
+            }
+            catch {
+                // ignore this!
+            }
+            finally {
+                if (searchQueue.size === 0 && !searchQueue.isWorking) {
+                    isSearching = false;
+                }
+            }
+        };
+        let txUnsub;
+        // This whole thing is just to make sure
+        // that we're not calling stopBroadcastFn twice
+        let stopBroadcastFn;
+        let stopped = false;
+        const stopBroadcast = () => {
+            if (stopped)
+                return;
+            if (stopBroadcastFn) {
+                stopped = true;
+                stopBroadcastFn().catch(noop);
+            }
+        };
+        const checkFinalizedBlockIncluded = async (block) => {
+            const inBlock = await checkTxIsOnChain(block.hash);
+            if (inBlock) {
+                const { index: txIndex, events, blockHash } = inBlock;
+                callback(new SubmittableResult({
+                    status: { tag: 'Finalized', value: { blockHash, txIndex } },
+                    txHash,
+                    events,
+                    txIndex,
+                }));
+            }
+            else {
+                // Revalidate the tx, just in-case it becomes invalid along the way
+                // Context: https://github.com/paritytech/json-rpc-interface-spec/pull/107#issuecomment-1906008814
+                const validation = await validateTx(block.hash);
+                if (validation.isOk)
+                    return;
+                callback(new SubmittableResult({
+                    status: {
+                        tag: 'Invalid',
+                        value: { error: `Invalid Tx: ${validation.err.tag} - ${validation.err.value.tag}` },
+                    },
+                    txHash,
+                }));
+            }
+            txUnsub().catch(noop);
+        };
+        stopBroadcastFn = await api.txBroadcaster.broadcastTx(txHex);
+        callback(new SubmittableResult({
+            status: { tag: 'Broadcasting' },
+            txHash,
+        }));
+        const stopBestBlockTrackingFn = api.chainHead.on('bestBlock', checkBestBlockIncluded);
+        const stopFinalizedBlockTrackingFn = api.chainHead.on('finalizedBlock', checkFinalizedBlockIncluded);
+        const stopTracking = () => {
+            stopBestBlockTrackingFn();
+            stopFinalizedBlockTrackingFn();
+            cancelBodySearch();
+        };
+        txUnsub = async () => {
+            stopTracking();
+            stopBroadcast();
+        };
+        return txUnsub;
+    }
+    async 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.tag === 'BestChainBlockIncluded' || status.tag === 'Finalized') {
+                        defer.resolve(txHash);
+                        unsub().catch(noop);
+                    }
+                    else if (status.tag === 'Invalid' || status.tag === 'Drop') {
+                        defer.reject(new Error(status.value.error));
+                        unsub().catch(noop);
+                    }
+                });
+            }
+            catch (e) {
+                defer.reject(e);
+            }
+            return defer.promise;
+        }
+    }
+}

package/extrinsic/submittable/SubmittableResult.d.ts

@@ -0,0 +1,19 @@
+import type { DispatchError, DispatchInfo, Hash } from '@dedot/codecs';
+import type { IEventRecord, ISubmittableResult } from '@dedot/types';
+import type { FrameSystemEventRecord } from '../../chaintypes/index.js';
+export interface SubmittableResultInputs<E extends IEventRecord = FrameSystemEventRecord, TxStatus extends any = any> {
+    events?: E[];
+    status: TxStatus;
+    txHash: Hash;
+    txIndex?: number;
+}
+export declare class SubmittableResult<E extends IEventRecord = FrameSystemEventRecord, TxStatus extends any = any> implements ISubmittableResult<E, TxStatus> {
+    status: TxStatus;
+    events: E[];
+    dispatchInfo?: DispatchInfo;
+    dispatchError?: DispatchError;
+    txHash: Hash;
+    txIndex?: number;
+    constructor({ events, status, txHash, txIndex }: SubmittableResultInputs<E, TxStatus>);
+    _extractDispatchInfo(): [DispatchInfo | undefined, DispatchError | undefined];
+}