@dedot/api 0.0.1-next.d9aff57d.57 → 0.1.0

package/extrinsic/extensions/known/CheckMetadataHash.js

@@ -0,0 +1,27 @@
+import { assert, isHex } from '@dedot/utils';
+import { SignedExtension } from '../SignedExtension.js';
+/**
+ * @description Genesis hash check to provide replay protection between different networks.
+ */
+export class CheckMetadataHash extends SignedExtension {
+    async init() {
+        let metadataHash = this.payloadOptions.metadataHash;
+        if (metadataHash) {
+            assert(isHex(metadataHash), 'Metadata hash is not a valid hex string');
+            this.data = { mode: 'Enabled' };
+            this.additionalSigned = metadataHash;
+        }
+        else {
+            this.data = { mode: 'Disabled' };
+            this.additionalSigned = undefined;
+        }
+    }
+    toPayload() {
+        // Ref: https://github.com/paritytech/polkadot-sdk/blob/8dbe4ee80734bba6644c7e5f879a363ce7c0a19f/substrate/frame/metadata-hash-extension/src/lib.rs#L55-L58
+        let enabled = this.data.mode === 'Enabled';
+        return {
+            mode: enabled ? 1 : 0, // 0 -> disabled, 1 -> enabled
+            metadataHash: this.additionalSigned,
+        };
+    }
+}

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

@@ -1,6 +1,7 @@
 import { ChargeAssetTxPayment } from './ChargeAssetTxPayment.js';
 import { ChargeTransactionPayment } from './ChargeTransactionPayment.js';
 import { CheckGenesis } from './CheckGenesis.js';
+import { CheckMetadataHash } from './CheckMetadataHash.js';
 import { CheckMortality } from './CheckMortality.js';
 import { CheckNonZeroSender } from './CheckNonZeroSender.js';
 import { CheckNonce } from './CheckNonce.js';
@@ -8,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,
@@ -19,4 +21,6 @@ export const knownSignedExtensions = {
     ChargeTransactionPayment,
     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;

package/extrinsic/submittable/utils.js

@@ -1,4 +1,4 @@
-import { blake2AsU8a, hexToU8a, isFunction } from '@dedot/utils';
+import { assert, blake2AsU8a, hexToU8a, isFunction } from '@dedot/utils';
 export function isKeyringPair(account) {
     return isFunction(account.sign);
 }
@@ -13,3 +13,67 @@ export function signRaw(signerPair, raw) {
     const toSignRaw = u8a.length > 256 ? blake2AsU8a(u8a, 256) : u8a;
     return signerPair.sign(toSignRaw, { withType: true });
 }
+/**
+ * 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 function toTxStatus(txStatus, txIndex) {
+    switch (txStatus.type) {
+        case 'Ready':
+        case 'Future':
+            return { type: 'Validated' };
+        case 'Broadcast':
+            return { type: 'Broadcasting' };
+        case 'Retracted':
+            return { type: 'NoLongerInBestChain' };
+        case 'InBlock':
+            assert(txIndex, 'TxIndex is required');
+            return {
+                type: 'BestChainBlockIncluded',
+                value: {
+                    blockHash: txStatus.value,
+                    txIndex,
+                },
+            };
+        case 'Finalized':
+            assert(txIndex, 'TxIndex is required');
+            return {
+                type: 'Finalized',
+                value: {
+                    blockHash: txStatus.value,
+                    txIndex,
+                },
+            };
+        case 'FinalityTimeout':
+            return {
+                type: 'Drop',
+                value: {
+                    error: 'Maximum number of finality watchers has been reached',
+                },
+            };
+        case 'Dropped':
+            return {
+                type: 'Drop',
+                value: {
+                    error: 'Extrinsic dropped from the pool due to exceeding limits',
+                },
+            };
+        case 'Usurped':
+            return {
+                type: 'Invalid',
+                value: {
+                    error: 'Extrinsic was rendered invalid by another extrinsic',
+                },
+            };
+        case 'Invalid':
+            return {
+                type: 'Invalid',
+                value: {
+                    error: 'Extrinsic marked as invalid',
+                },
+            };
+    }
+}

package/json-rpc/JsonRpcClient.d.ts

@@ -1,10 +1,11 @@
 import type { ConnectionStatus, JsonRpcProvider, ProviderEvent } from '@dedot/providers';
-import type { GenericSubstrateApi, RpcVersion } from '@dedot/types';
+import type { RpcVersion, VersionedGenericSubstrateApi } from '@dedot/types';
 import { EventEmitter } from '@dedot/utils';
 import type { SubstrateApi } from '../chaintypes/index.js';
 import type { IJsonRpcClient, JsonRpcClientOptions } from '../types.js';
 export declare const isJsonRpcProvider: (provider: any) => provider is JsonRpcProvider;
-export declare class JsonRpcClient<ChainApi extends GenericSubstrateApi = SubstrateApi[RpcVersion], Events extends string = ProviderEvent> extends EventEmitter<Events> implements IJsonRpcClient<ChainApi, Events> {
+export declare class JsonRpcClient<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi, // prettier-end-here
+Events extends string = ProviderEvent> extends EventEmitter<Events> implements IJsonRpcClient<ChainApi[RpcVersion], Events> {
     #private;
     constructor(options: JsonRpcClientOptions | JsonRpcProvider);
     /**
@@ -12,13 +13,13 @@ export declare class JsonRpcClient<ChainApi extends GenericSubstrateApi = Substr
      *
      * @param options
      */
-    static create<ChainApi extends GenericSubstrateApi = SubstrateApi[RpcVersion]>(options: JsonRpcClientOptions | JsonRpcProvider): Promise<JsonRpcClient<ChainApi>>;
+    static create<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi>(options: JsonRpcClientOptions | JsonRpcProvider): Promise<JsonRpcClient<ChainApi>>;
     /**
      * Alias for __JsonRpcClient.create__
      *
      * @param options
      */
-    static new<ChainApi extends GenericSubstrateApi = SubstrateApi[RpcVersion]>(options: JsonRpcClientOptions | JsonRpcProvider): Promise<JsonRpcClient<ChainApi>>;
+    static new<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi>(options: JsonRpcClientOptions | JsonRpcProvider): Promise<JsonRpcClient<ChainApi>>;
     get options(): JsonRpcClientOptions;
     /**
      * @description Check connection status of the api instance
@@ -46,5 +47,5 @@ export declare class JsonRpcClient<ChainApi extends GenericSubstrateApi = Substr
      * const result = await client.rpc.module_rpc_name();
      * ```
      */
-    get rpc(): ChainApi['rpc'];
+    get rpc(): ChainApi[RpcVersion]['rpc'];
 }

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@dedot/api",
-  "version": "0.0.1-next.d9aff57d.57+d9aff57",
+  "version": "0.1.0",
   "description": "A delightful JavaScript/TypeScript client for Polkadot & Substrate",
   "author": "Thang X. Vu <thang@coongcrafts.io>",
-  "homepage": "https://github.com/dedotdev/dedot",
+  "homepage": "https://github.com/dedotdev/dedot/tree/main/packages/api",
   "repository": {
     "directory": "packages/api",
     "type": "git",
@@ -13,13 +13,13 @@
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@dedot/codecs": "0.0.1-next.d9aff57d.57+d9aff57",
-    "@dedot/providers": "0.0.1-next.d9aff57d.57+d9aff57",
-    "@dedot/runtime-specs": "0.0.1-next.d9aff57d.57+d9aff57",
-    "@dedot/shape": "0.0.1-next.d9aff57d.57+d9aff57",
-    "@dedot/storage": "0.0.1-next.d9aff57d.57+d9aff57",
-    "@dedot/types": "0.0.1-next.d9aff57d.57+d9aff57",
-    "@dedot/utils": "0.0.1-next.d9aff57d.57+d9aff57"
+    "@dedot/codecs": "0.1.0",
+    "@dedot/providers": "0.1.0",
+    "@dedot/runtime-specs": "0.1.0",
+    "@dedot/shape": "0.1.0",
+    "@dedot/storage": "0.1.0",
+    "@dedot/types": "0.1.0",
+    "@dedot/utils": "0.1.0"
   },
   "scripts": {
     "build": "tsc --project tsconfig.build.json && tsc --project tsconfig.build.cjs.json",
@@ -46,9 +46,9 @@
   },
   "license": "Apache-2.0",
   "devDependencies": {
-    "@polkadot/types": "^11.0.2"
+    "@polkadot/types": "^12.2.1"
   },
-  "gitHead": "d9aff57dcbd8e15455da9627cbc43f07cb6c0afc",
+  "gitHead": "c8220a4ab4b171fe04adb49759318bde865d7c17",
   "module": "./index.js",
   "types": "./index.d.ts"
 }

package/storage/QueryableStorage.js

@@ -36,14 +36,14 @@ export class QueryableStorage {
         const storageItemHash = xxhashAsU8a(this.storageEntry.name, 128);
         return concatU8a(palletNameHash, storageItemHash);
     }
-    #getStorageMapInfo(type) {
-        assert(type.tag === 'Map');
-        const { hashers, keyTypeId } = type.value;
+    #getStorageMapInfo(storageType) {
+        assert(storageType.type === 'Map');
+        const { hashers, keyTypeId } = storageType.value;
         let keyTypeIds = [keyTypeId];
         if (hashers.length > 1) {
-            const { type } = this.registry.findType(keyTypeId);
-            assert(type.tag === 'Tuple', 'Key type should be a tuple!');
-            keyTypeIds = type.value.fields;
+            const { typeDef } = this.registry.findType(keyTypeId);
+            assert(typeDef.type === 'Tuple', 'Key type should be a tuple!');
+            keyTypeIds = typeDef.value.fields;
         }
         return { hashers, keyTypeIds };
     }
@@ -53,12 +53,12 @@ export class QueryableStorage {
      * @param keyInput
      */
     encodeKey(keyInput) {
-        const { type } = this.storageEntry;
-        if (type.tag === 'Plain') {
+        const { storageType } = this.storageEntry;
+        if (storageType.type === 'Plain') {
             return this.prefixKey;
         }
-        else if (type.tag === 'Map') {
-            const { hashers, keyTypeIds } = this.#getStorageMapInfo(type);
+        else if (storageType.type === 'Map') {
+            const { hashers, keyTypeIds } = this.#getStorageMapInfo(storageType);
             const extractedInputs = this.#extractRequiredKeyInputs(keyInput, hashers.length);
             const keyParts = keyTypeIds.map((keyId, index) => {
                 const input = extractedInputs[index];
@@ -68,7 +68,7 @@ export class QueryableStorage {
             });
             return u8aToHex(concatU8a(this.prefixKeyAsU8a, ...keyParts));
         }
-        throw Error(`Invalid storage entry type: ${type}`);
+        throw Error(`Invalid storage entry type: ${JSON.stringify(storageType)}`);
     }
     /**
      * Decode storage key to plain key input
@@ -77,16 +77,16 @@ export class QueryableStorage {
      * @param key
      */
     decodeKey(key) {
-        const { type } = this.storageEntry;
-        if (type.tag === 'Plain') {
+        const { storageType } = this.storageEntry;
+        if (storageType.type === 'Plain') {
             return;
         }
-        else if (type.tag === 'Map') {
+        else if (storageType.type === 'Map') {
             const prefix = this.prefixKey;
             if (!key.startsWith(prefix)) {
                 throw new Error(`Storage key does not match this storage entry (${this.palletName}.${this.storageItem})`);
             }
-            const { hashers, keyTypeIds } = this.#getStorageMapInfo(type);
+            const { hashers, keyTypeIds } = this.#getStorageMapInfo(storageType);
             let keyData = hexToU8a(hexAddPrefix(key.slice(prefix.length)));
             const results = keyTypeIds.map((keyId, index) => {
                 const [hashLen, canDecode] = HASHER_INFO[hashers[index]];
@@ -101,7 +101,7 @@ export class QueryableStorage {
             });
             return hashers.length > 1 ? results : results[0];
         }
-        throw Error(`Invalid storage entry type: ${type}`);
+        throw Error(`Invalid storage entry type: ${JSON.stringify(storageType)}`);
     }
     /**
      * Decode raw/bytes storage data to plain value
@@ -109,7 +109,7 @@ export class QueryableStorage {
      * @param raw
      */
     decodeValue(raw) {
-        const { modifier, type: { value: { valueTypeId }, }, default: defaultValue, } = this.storageEntry;
+        const { modifier, storageType: { value: { valueTypeId }, }, default: defaultValue, } = this.storageEntry;
         if (raw === null || raw === undefined) {
             if (modifier === 'Optional') {
                 return undefined;

package/types.d.ts

@@ -56,7 +56,7 @@ export interface ApiOptions extends JsonRpcClientOptions {
      */
     hasher?: HashFn;
 }
-export type ApiEvent = ProviderEvent | 'ready';
+export type ApiEvent = ProviderEvent | 'ready' | 'runtimeUpgraded';
 export interface SubstrateRuntimeVersion {
     specName: string;
     implName: string;
@@ -101,6 +101,14 @@ export interface ISubstrateClient<ChainApi extends GenericSubstrateApi = Generic
     options: ApiOptions;
     tx: ChainApi['tx'];
     at<ChainApiAt extends GenericSubstrateApi = ChainApi>(hash: BlockHash): Promise<ISubstrateClientAt<ChainApiAt>>;
+    /**
+     * Get current version of the runtime
+     * This is similar to `.runtimeVersion` but also ensure
+     * the corresponding metadata of this runtime version is downloaded & setup.
+     *
+     * This is helpful when you want to check runtime version to prepare for runtime upgrade
+     */
+    getRuntimeVersion(): Promise<SubstrateRuntimeVersion>;
 }
 /**
  * A generic interface for broadcasting transactions