@dedot/api 0.0.1-next.cfee875e.21 → 0.1.0

package/client/BaseSubstrateClient.js

@@ -1,6 +1,6 @@
 import { $Metadata, PortableRegistry } from '@dedot/codecs';
 import { LocalStorage } from '@dedot/storage';
-import { calcRuntimeApiHash, ensurePresence as _ensurePresence, u8aToHex } from '@dedot/utils';
+import { calcRuntimeApiHash, deferred, ensurePresence as _ensurePresence, u8aToHex } from '@dedot/utils';
 import { ConstantExecutor, ErrorExecutor, EventExecutor } from '../executor/index.js';
 import { isJsonRpcProvider, JsonRpcClient } from '../json-rpc/index.js';
 import { newProxyChain } from '../proxychain.js';
@@ -22,6 +22,7 @@ export class BaseSubstrateClient extends JsonRpcClient {
     _genesisHash;
     _runtimeVersion;
     _localCache;
+    _runtimeUpgrading;
     constructor(rpcVersion, options) {
         super(options);
         this.rpcVersion = rpcVersion;
@@ -193,6 +194,22 @@ export class BaseSubstrateClient extends JsonRpcClient {
             }, {}),
         };
     }
+    startRuntimeUpgrade() {
+        this._runtimeUpgrading = deferred();
+    }
+    doneRuntimeUpgrade() {
+        if (!this._runtimeUpgrading)
+            return;
+        this._runtimeUpgrading.resolve();
+        setTimeout(() => {
+            this._runtimeUpgrading = undefined;
+        });
+    }
+    async ensureRuntimeUpgraded() {
+        if (!this._runtimeUpgrading)
+            return;
+        await this._runtimeUpgrading.promise;
+    }
     /// --- Public APIs ---
     /**
      * @description Connect to blockchain node
@@ -224,6 +241,10 @@ export class BaseSubstrateClient extends JsonRpcClient {
     get runtimeVersion() {
         return ensurePresence(this._runtimeVersion);
     }
+    async getRuntimeVersion() {
+        await this.ensureRuntimeUpgraded();
+        return this.runtimeVersion;
+    }
     get consts() {
         return newProxyChain({ executor: new ConstantExecutor(this) });
     }

package/client/DedotClient.d.ts

@@ -11,7 +11,8 @@ import { BaseSubstrateClient } from './BaseSubstrateClient.js';
  *
  * __Unstable, use with caution.__
  */
-export declare class DedotClient<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends BaseSubstrateClient<ChainApi> {
+export declare class DedotClient<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi>// prettier-end-here
+ extends BaseSubstrateClient<RpcV2, ChainApi> {
     #private;
     protected _chainHead?: ChainHead;
     protected _chainSpec?: ChainSpec;
@@ -42,7 +43,6 @@ export declare class DedotClient<ChainApi extends VersionedGenericSubstrateApi =
      */
     protected doInitialize(): Promise<void>;
     protected subscribeRuntimeUpgrades(): void;
-    protected unsubscribeRuntimeUpgrades(): void;
     protected onRuntimeUpgrade: (block: PinnedBlock) => Promise<void>;
     protected beforeDisconnect(): Promise<void>;
     protected onDisconnected: () => Promise<void>;

package/client/DedotClient.js

@@ -11,7 +11,8 @@ import { BaseSubstrateClient, ensurePresence } from './BaseSubstrateClient.js';
  *
  * __Unstable, use with caution.__
  */
-export class DedotClient extends BaseSubstrateClient {
+export class DedotClient// prettier-end-here
+ extends BaseSubstrateClient {
     _chainHead;
     _chainSpec;
     _txBroadcaster;
@@ -99,16 +100,16 @@ export class DedotClient extends BaseSubstrateClient {
     subscribeRuntimeUpgrades() {
         this.chainHead.on('bestBlock', this.onRuntimeUpgrade);
     }
-    unsubscribeRuntimeUpgrades() {
-        this.chainHead.off('bestBlock', this.onRuntimeUpgrade);
-    }
     onRuntimeUpgrade = async (block) => {
         const runtimeUpgraded = block.runtime && block.runtime.specVersion !== this._runtimeVersion?.specVersion;
         if (!runtimeUpgraded)
             return;
+        this.startRuntimeUpgrade();
         this._runtimeVersion = block.runtime;
         const newMetadata = await this.fetchMetadata(undefined, this._runtimeVersion);
         await this.setupMetadata(newMetadata);
+        this.emit('runtimeUpgraded', this._runtimeVersion);
+        this.doneRuntimeUpgrade();
     };
     async beforeDisconnect() {
         await this.chainHead.unfollow();

package/client/LegacyClient.d.ts

@@ -42,7 +42,8 @@ import { BaseSubstrateClient } from './BaseSubstrateClient.js';
  * run().catch(console.error);
  * ```
  */
-export declare class LegacyClient<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends BaseSubstrateClient<ChainApi> {
+export declare class LegacyClient<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi>// prettier-end-here
+ extends BaseSubstrateClient<RpcLegacy, ChainApi> {
     #private;
     /**
      * Use factory methods (`create`, `new`) to create `Dedot` instances.
@@ -116,7 +117,7 @@ export declare class LegacyClient<ChainApi extends VersionedGenericSubstrateApi
      * // Make a transfer balance transaction
      * api.tx.balances.transferKeepAlive(<address>, <amount>)
      *    .signAndSend(<keyPair|address>, { signer }, ({ status }) => {
-     *      console.log('Transaction status', status.tag);
+     *      console.log('Transaction status', status.type);
      *    });
      * ```
      */

package/client/LegacyClient.js

@@ -41,7 +41,8 @@ const KEEP_ALIVE_INTERVAL = 10_000; // in ms
  * run().catch(console.error);
  * ```
  */
-export class LegacyClient extends BaseSubstrateClient {
+export class LegacyClient// prettier-end-here
+ extends BaseSubstrateClient {
     #runtimeSubscriptionUnsub;
     #healthTimer;
     #apiAtCache = {};
@@ -101,9 +102,12 @@ export class LegacyClient extends BaseSubstrateClient {
         this.rpc
             .state_subscribeRuntimeVersion(async (runtimeVersion) => {
             if (runtimeVersion.specVersion !== this.runtimeVersion?.specVersion) {
+                this.startRuntimeUpgrade();
                 this._runtimeVersion = this.toSubstrateRuntimeVersion(runtimeVersion);
                 const newMetadata = await this.fetchMetadata(undefined, this._runtimeVersion);
                 await this.setupMetadata(newMetadata);
+                this.emit('runtimeUpgraded', this._runtimeVersion);
+                this.doneRuntimeUpgrade();
             }
         })
             .then((unsub) => {
@@ -202,7 +206,7 @@ export class LegacyClient extends BaseSubstrateClient {
      * // Make a transfer balance transaction
      * api.tx.balances.transferKeepAlive(<address>, <amount>)
      *    .signAndSend(<keyPair|address>, { signer }, ({ status }) => {
-     *      console.log('Transaction status', status.tag);
+     *      console.log('Transaction status', status.type);
      *    });
      * ```
      */

package/executor/ErrorExecutor.js

@@ -17,7 +17,7 @@ export class ErrorExecutor extends Executor {
                 palletIndex: targetPallet.index,
             },
             is: (errorInfo) => {
-                if (isObject(errorInfo) && errorInfo.tag === 'Module') {
+                if (isObject(errorInfo) && errorInfo.type === 'Module') {
                     errorInfo = errorInfo.value;
                 }
                 if (isObject(errorInfo) && isNumber(errorInfo.index) && isHex(errorInfo.error)) {
@@ -30,8 +30,8 @@ export class ErrorExecutor extends Executor {
     #getErrorDef(errorTypeId, errorName) {
         const def = this.metadata.types[errorTypeId];
         assert(def, new UnknownApiError(`Error def not found for id ${errorTypeId}`));
-        const { tag, value } = def.type;
-        assert(tag === 'Enum', new UnknownApiError(`Error type should be an enum, found: ${tag}`));
+        const { type, value } = def.typeDef;
+        assert(type === 'Enum', new UnknownApiError(`Error type should be an enum, found: ${type}`));
         const errorDef = value.members.find(({ name }) => stringPascalCase(name) === errorName);
         assert(errorDef, new UnknownApiError(`Error def not found for ${errorName}`));
         return {

package/executor/EventExecutor.js

@@ -36,8 +36,8 @@ export class EventExecutor extends Executor {
     #getEventDef(eventTypeId, errorName) {
         const def = this.metadata.types[eventTypeId];
         assert(def, new UnknownApiError(`Event def not found for id ${eventTypeId}`));
-        const { tag, value } = def.type;
-        assert(tag === 'Enum', new UnknownApiError(`Event type should be an enum, found: ${tag}`));
+        const { type, value } = def.typeDef;
+        assert(type === 'Enum', new UnknownApiError(`Event type should be an enum, found: ${type}`));
         const eventDef = value.members.find(({ name }) => stringPascalCase(name) === errorName);
         assert(eventDef, new UnknownApiError(`Event def not found for ${errorName}`));
         return {

package/executor/Executor.d.ts

@@ -19,13 +19,13 @@ export declare abstract class Executor<ChainApi extends GenericSubstrateApi = Ge
                 name: string;
                 typeId: number | undefined;
             }[];
-            type: {
-                tag: "Struct";
+            typeDef: {
+                type: "Struct";
                 value: {
                     fields: import("@dedot/codecs").Field[];
                 };
             } | {
-                tag: "Enum";
+                type: "Enum";
                 value: {
                     members: {
                         name: string;
@@ -35,33 +35,33 @@ export declare abstract class Executor<ChainApi extends GenericSubstrateApi = Ge
                     }[];
                 };
             } | {
-                tag: "Sequence";
+                type: "Sequence";
                 value: {
                     typeParam: number;
                 };
             } | {
-                tag: "SizedVec";
+                type: "SizedVec";
                 value: {
                     len: number;
                     typeParam: number;
                 };
             } | {
-                tag: "Tuple";
+                type: "Tuple";
                 value: {
                     fields: number[];
                 };
             } | {
-                tag: "Primitive";
+                type: "Primitive";
                 value: {
                     kind: "bool" | "char" | "str" | "u8" | "u16" | "u32" | "u64" | "u128" | "u256" | "i8" | "i16" | "i32" | "i64" | "i128" | "i256";
                 };
             } | {
-                tag: "Compact";
+                type: "Compact";
                 value: {
                     typeParam: number;
                 };
             } | {
-                tag: "BitSequence";
+                type: "BitSequence";
                 value: {
                     bitOrderType: number;
                     bitStoreType: number;
@@ -76,13 +76,13 @@ export declare abstract class Executor<ChainApi extends GenericSubstrateApi = Ge
                 entries: {
                     name: string;
                     modifier: string;
-                    type: {
-                        tag: "Plain";
+                    storageType: {
+                        type: "Plain";
                         value: {
                             valueTypeId: number;
                         };
                     } | {
-                        tag: "Map";
+                        type: "Map";
                         value: {
                             hashers: ("identity" | "blake2_128" | "blake2_256" | "blake2_128Concat" | "twox128" | "twox256" | "twox64Concat")[];
                             keyTypeId: number;

package/executor/StorageQueryExecutor.js

@@ -49,7 +49,7 @@ export class StorageQueryExecutor extends Executor {
             palletIndex: entry.pallet.index,
             ...entry.storageEntry,
         };
-        const isMap = entry.storageEntry.type.tag === 'Map';
+        const isMap = entry.storageEntry.storageType.type === 'Map';
         if (isMap) {
             const queryMultiFn = async (...args) => {
                 const [inArgs, callback] = extractArgs(args);

package/executor/TxExecutor.js

@@ -10,9 +10,9 @@ export class TxExecutor extends Executor {
         const targetPallet = this.getPallet(pallet);
         assert(targetPallet.calls, new UnknownApiError(`Tx calls are not available for pallet ${targetPallet.name}`));
         const txType = this.metadata.types[targetPallet.calls];
-        assert(txType.type.tag === 'Enum', new UnknownApiError('Tx type defs should be enum'));
-        const isFlatEnum = txType.type.value.members.every((m) => m.fields.length === 0);
-        const txCallDef = txType.type.value.members.find((m) => stringCamelCase(m.name) === functionName);
+        assert(txType.typeDef.type === 'Enum', new UnknownApiError('Tx type defs should be enum'));
+        const isFlatEnum = txType.typeDef.value.members.every((m) => m.fields.length === 0);
+        const txCallDef = txType.typeDef.value.members.find((m) => stringCamelCase(m.name) === functionName);
         assert(txCallDef, new UnknownApiError(`Tx call spec not found for ${pallet}.${functionName}`));
         const txCallFn = (...args) => {
             let call;

package/executor/v2/StorageQueryExecutorV2.js

@@ -37,20 +37,20 @@ export class StorageQueryExecutorV2 extends StorageQueryExecutor {
         // TODO subscribe to finalized data source
         // initialHash = this.chainHead.finalizedHash;
         // eventToListen = 'finalizedBlock';
-        const latestChanges = {};
+        const latestChanges = new Map();
         const pull = async ({ hash }) => {
             const results = await this.queryStorage(keys, hash);
             let changed = false;
             keys.forEach((key) => {
                 const newValue = results[key];
-                if (latestChanges[key] === newValue)
+                if (latestChanges.size > 0 && latestChanges.get(key) === newValue)
                     return;
                 changed = true;
-                latestChanges[key] = newValue;
+                latestChanges.set(key, newValue);
             });
             if (!changed)
                 return;
-            callback(keys.map((key) => latestChanges[key]));
+            callback(keys.map((key) => latestChanges.get(key)));
         };
         await pull(best);
         const unsub = this.chainHead.on(eventToListen, pull);

package/extrinsic/extensions/known/ChargeAssetTxPayment.js

@@ -27,8 +27,8 @@ export class ChargeAssetTxPayment extends SignedExtension {
     }
     $AssetId() {
         const extensionTypeDef = this.registry.findType(this.signedExtensionDef.typeId);
-        assert(extensionTypeDef.type.tag === 'Struct');
-        const assetIdTypeDef = extensionTypeDef.type.value.fields.find((f) => f.name === 'asset_id');
+        assert(extensionTypeDef.typeDef.type === 'Struct');
+        const assetIdTypeDef = extensionTypeDef.typeDef.value.fields.find((f) => f.name === 'asset_id');
         const $codec = this.registry.findCodec(assetIdTypeDef.typeId);
         const codecMetadata = $codec.metadata[0];
         if (codecMetadata.name === '$.option') {

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

@@ -0,0 +1,6 @@
+import { SignedExtension } from '../SignedExtension.js';
+/**
+ * @description Storage weight reclaim mechanism.
+ */
+export declare class StorageWeightReclaim extends SignedExtension {
+}

package/extrinsic/extensions/known/StorageWeightReclaim.js

@@ -0,0 +1,6 @@
+import { SignedExtension } from '../SignedExtension.js';
+/**
+ * @description Storage weight reclaim mechanism.
+ */
+export class StorageWeightReclaim extends SignedExtension {
+}

package/extrinsic/extensions/known/index.js

@@ -9,6 +9,7 @@ import { CheckSpecVersion } from './CheckSpecVersion.js';
 import { CheckTxVersion } from './CheckTxVersion.js';
 import { CheckWeight } from './CheckWeight.js';
 import { PrevalidateAttests } from './PrevalidateAttests.js';
+import { StorageWeightReclaim } from './StorageWeightReclaim.js';
 export const knownSignedExtensions = {
     CheckNonZeroSender,
     CheckSpecVersion,
@@ -21,4 +22,5 @@ export const knownSignedExtensions = {
     PrevalidateAttests,
     ChargeAssetTxPayment,
     CheckMetadataHash,
+    StorageWeightReclaim,
 };

package/extrinsic/submittable/BaseSubmittableExtrinsic.d.ts

@@ -1,5 +1,6 @@
 import { BlockHash, Extrinsic, Hash } from '@dedot/codecs';
 import { AddressOrPair, Callback, IRuntimeTxCall, ISubmittableExtrinsic, ISubmittableResult, PayloadOptions, SignerOptions, TxPaymentInfo, Unsub } from '@dedot/types';
+import { HexString } from '@dedot/utils';
 import type { FrameSystemEventRecord } from '../../chaintypes/index.js';
 import type { ISubstrateClient } from '../../types.js';
 export declare abstract class BaseSubmittableExtrinsic extends Extrinsic implements ISubmittableExtrinsic {
@@ -14,4 +15,5 @@ export declare abstract class BaseSubmittableExtrinsic extends Extrinsic impleme
     send(): Promise<Hash>;
     send(callback: Callback): Promise<Unsub>;
     protected getSystemEventsAt(hash: BlockHash): Promise<FrameSystemEventRecord[]>;
+    toHex(): HexString;
 }

package/extrinsic/submittable/BaseSubmittableExtrinsic.js

@@ -1,10 +1,11 @@
 import { Extrinsic } from '@dedot/codecs';
-import { isFunction, u8aToHex } from '@dedot/utils';
+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';
 export class BaseSubmittableExtrinsic extends Extrinsic {
     api;
+    #alterTx;
     constructor(api, call) {
         super(api.registry, call);
         this.api = api;
@@ -23,13 +24,14 @@ export class BaseSubmittableExtrinsic extends Extrinsic {
         });
         await extra.init();
         const { signer } = options || {};
-        let signature;
+        let signature, alteredTx;
         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;
+            alteredTx = result.signedTransaction;
         }
         else {
             throw new Error('Signer not found. Cannot sign the extrinsic!');
@@ -41,6 +43,13 @@ export class BaseSubmittableExtrinsic extends Extrinsic {
             signature: $Signature.tryDecode(signature),
             extra: extra.data,
         });
+        // If the tx payload are altered from signer
+        // We'll need to validate the altered tx
+        // and broadcast it instead of the original tx
+        if (alteredTx) {
+            this.#validateSignedTx(alteredTx);
+            this.#alterTx = toHex(alteredTx);
+        }
         return this;
     }
     async signAndSend(fromAccount, partialOptions, maybeCallback) {
@@ -63,4 +72,25 @@ export class BaseSubmittableExtrinsic extends Extrinsic {
         const atApi = (await this.api.at(hash));
         return await atApi.query.system.events();
     }
+    toHex() {
+        return this.#alterTx || super.toHex();
+    }
+    /**
+     * Validate a raw signed transaction coming from signer
+     * We need to make sure the tx is signed and call-data is intact/not-changing
+     *
+     * @param tx
+     * @private
+     */
+    #validateSignedTx(tx) {
+        const alteredTx = this.$Codec.tryDecode(tx);
+        // The alter tx should be signed
+        if (!alteredTx.signed) {
+            throw new DedotError('Altered transaction from signer is not signed');
+        }
+        // Signer's not allow the change the call data
+        if (alteredTx.callHex !== this.callHex) {
+            throw new DedotError('Call data does not match, signer is not allowed to change tx call data.');
+        }
+    }
 }

package/extrinsic/submittable/SubmittableExtrinsic.js

@@ -1,6 +1,7 @@
 import { assert, isHex } from '@dedot/utils';
 import { BaseSubmittableExtrinsic } from './BaseSubmittableExtrinsic.js';
 import { SubmittableResult } from './SubmittableResult.js';
+import { toTxStatus } from './utils.js';
 /**
  * @name SubmittableExtrinsic
  * @description A wrapper around an Extrinsic that exposes methods to sign, send, and other utility around Extrinsic.
@@ -19,19 +20,21 @@ export class SubmittableExtrinsic extends BaseSubmittableExtrinsic {
         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;
+            return this.api.rpc.author_submitAndWatchExtrinsic(txHex, async (txStatus) => {
+                if (txStatus.type === 'InBlock' || txStatus.type === 'Finalized') {
+                    const blockHash = txStatus.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);
+                    const events = blockEvents.filter(({ phase }) => phase.type === 'ApplyExtrinsic' && phase.value === txIndex);
+                    const status = toTxStatus(txStatus, txIndex);
                     return callback(new SubmittableResult({ status, txHash, events, txIndex }));
                 }
                 else {
+                    const status = toTxStatus(txStatus);
                     return callback(new SubmittableResult({ status, txHash }));
                 }
             });

package/extrinsic/submittable/SubmittableExtrinsicV2.js

@@ -25,10 +25,10 @@ export class SubmittableExtrinsicV2 extends BaseSubmittableExtrinsic {
         };
         const validation = await validateTx(finalizedHash);
         if (validation.isOk) {
-            callback(new SubmittableResult({ status: { tag: 'Validated' }, txHash }));
+            callback(new SubmittableResult({ status: { type: 'Validated' }, txHash }));
         }
         else if (validation.isErr) {
-            throw new InvalidTxError(`Invalid Tx: ${validation.err.tag} - ${validation.err.value.tag}`, validation);
+            throw new InvalidTxError(`Invalid Tx: ${validation.err.type} - ${validation.err.value.type}`, validation);
         }
         const checkTxIsOnChain = async (blockHash) => {
             if (blockHash === finalizedHash)
@@ -39,7 +39,7 @@ export class SubmittableExtrinsicV2 extends BaseSubmittableExtrinsic {
                 return checkTxIsOnChain(api.chainHead.findBlock(blockHash).parent);
             }
             const events = await this.getSystemEventsAt(blockHash);
-            const txEvents = events.filter(({ phase }) => phase.tag == 'ApplyExtrinsic' && phase.value === txIndex);
+            const txEvents = events.filter(({ phase }) => phase.type == 'ApplyExtrinsic' && phase.value === txIndex);
             return {
                 blockHash,
                 index: txIndex,
@@ -85,7 +85,7 @@ export class SubmittableExtrinsicV2 extends BaseSubmittableExtrinsic {
                     if (txFound && bestChainChanged) {
                         txFound = undefined;
                         callback(new SubmittableResult({
-                            status: { tag: 'NoLongerInBestChain' },
+                            status: { type: 'NoLongerInBestChain' },
                             txHash,
                         }));
                     }
@@ -98,7 +98,7 @@ export class SubmittableExtrinsicV2 extends BaseSubmittableExtrinsic {
                 txFound = inBlock;
                 const { index: txIndex, events, blockHash } = inBlock;
                 callback(new SubmittableResult({
-                    status: { tag: 'BestChainBlockIncluded', value: { blockHash, txIndex } },
+                    status: { type: 'BestChainBlockIncluded', value: { blockHash, txIndex } },
                     txHash,
                     events,
                     txIndex,
@@ -131,7 +131,7 @@ export class SubmittableExtrinsicV2 extends BaseSubmittableExtrinsic {
             if (inBlock) {
                 const { index: txIndex, events, blockHash } = inBlock;
                 callback(new SubmittableResult({
-                    status: { tag: 'Finalized', value: { blockHash, txIndex } },
+                    status: { type: 'Finalized', value: { blockHash, txIndex } },
                     txHash,
                     events,
                     txIndex,
@@ -145,8 +145,8 @@ export class SubmittableExtrinsicV2 extends BaseSubmittableExtrinsic {
                     return;
                 callback(new SubmittableResult({
                     status: {
-                        tag: 'Invalid',
-                        value: { error: `Invalid Tx: ${validation.err.tag} - ${validation.err.value.tag}` },
+                        type: 'Invalid',
+                        value: { error: `Invalid Tx: ${validation.err.type} - ${validation.err.value.type}` },
                     },
                     txHash,
                 }));
@@ -155,7 +155,7 @@ export class SubmittableExtrinsicV2 extends BaseSubmittableExtrinsic {
         };
         stopBroadcastFn = await api.txBroadcaster.broadcastTx(txHex);
         callback(new SubmittableResult({
-            status: { tag: 'Broadcasting' },
+            status: { type: 'Broadcasting' },
             txHash,
         }));
         const stopBestBlockTrackingFn = api.chainHead.on('bestBlock', checkBestBlockIncluded);
@@ -181,11 +181,11 @@ export class SubmittableExtrinsicV2 extends BaseSubmittableExtrinsic {
             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') {
+                    if (status.type === 'BestChainBlockIncluded' || status.type === 'Finalized') {
                         defer.resolve(txHash);
                         unsub().catch(noop);
                     }
-                    else if (status.tag === 'Invalid' || status.tag === 'Drop') {
+                    else if (status.type === 'Invalid' || status.type === 'Drop') {
                         defer.reject(new Error(status.value.error));
                         unsub().catch(noop);
                     }

package/extrinsic/submittable/SubmittableResult.d.ts

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

package/extrinsic/submittable/utils.d.ts

@@ -1,5 +1,6 @@
 import { IKeyringPair } from '@polkadot/types/types';
-import type { AddressOrPair } from '@dedot/types';
+import { TransactionStatus } from '@dedot/codecs';
+import type { AddressOrPair, TxStatus } from '@dedot/types';
 import { HexString } from '@dedot/utils';
 export declare function isKeyringPair(account: AddressOrPair): account is IKeyringPair;
 /**
@@ -8,3 +9,11 @@ export declare function isKeyringPair(account: AddressOrPair): account is IKeyri
  * @param raw
  */
 export declare function signRaw(signerPair: IKeyringPair, raw: HexString): Uint8Array;
+/**
+ * Convert transaction status to transaction event
+ *
+ * Ref: https://github.com/paritytech/polkadot-sdk/blob/98a364fe6e7abf10819f5fddd3de0588f7c38700/substrate/client/rpc-spec-v2/src/transaction/transaction.rs#L132-L159
+ * @param txStatus
+ * @param txIndex
+ */
+export declare function toTxStatus(txStatus: TransactionStatus, txIndex?: number): TxStatus;