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

package/cjs/extrinsic/submittable/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.signRaw = exports.isKeyringPair = void 0;
+exports.toTxStatus = exports.signRaw = exports.isKeyringPair = void 0;
 const utils_1 = require("@dedot/utils");
 function isKeyringPair(account) {
     return (0, utils_1.isFunction)(account.sign);
@@ -18,3 +18,68 @@ function signRaw(signerPair, raw) {
     return signerPair.sign(toSignRaw, { withType: true });
 }
 exports.signRaw = signRaw;
+/**
+ * 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
+ */
+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':
+            (0, utils_1.assert)(txIndex, 'TxIndex is required');
+            return {
+                type: 'BestChainBlockIncluded',
+                value: {
+                    blockHash: txStatus.value,
+                    txIndex,
+                },
+            };
+        case 'Finalized':
+            (0, utils_1.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',
+                },
+            };
+    }
+}
+exports.toTxStatus = toTxStatus;

package/cjs/storage/QueryableStorage.js

@@ -39,14 +39,14 @@ class QueryableStorage {
         const storageItemHash = (0, utils_2.xxhashAsU8a)(this.storageEntry.name, 128);
         return (0, utils_2.concatU8a)(palletNameHash, storageItemHash);
     }
-    #getStorageMapInfo(type) {
-        (0, utils_1.assert)(type.tag === 'Map');
-        const { hashers, keyTypeId } = type.value;
+    #getStorageMapInfo(storageType) {
+        (0, utils_1.assert)(storageType.type === 'Map');
+        const { hashers, keyTypeId } = storageType.value;
         let keyTypeIds = [keyTypeId];
         if (hashers.length > 1) {
-            const { type } = this.registry.findType(keyTypeId);
-            (0, utils_1.assert)(type.tag === 'Tuple', 'Key type should be a tuple!');
-            keyTypeIds = type.value.fields;
+            const { typeDef } = this.registry.findType(keyTypeId);
+            (0, utils_1.assert)(typeDef.type === 'Tuple', 'Key type should be a tuple!');
+            keyTypeIds = typeDef.value.fields;
         }
         return { hashers, keyTypeIds };
     }
@@ -56,12 +56,12 @@ 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];
@@ -71,7 +71,7 @@ class QueryableStorage {
             });
             return (0, utils_2.u8aToHex)((0, utils_2.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
@@ -80,16 +80,16 @@ 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 = (0, utils_2.hexToU8a)((0, utils_1.hexAddPrefix)(key.slice(prefix.length)));
             const results = keyTypeIds.map((keyId, index) => {
                 const [hashLen, canDecode] = HASHER_INFO[hashers[index]];
@@ -104,7 +104,7 @@ 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
@@ -112,7 +112,7 @@ 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/client/BaseSubstrateClient.d.ts

@@ -2,6 +2,7 @@ import { BlockHash, Hash, Metadata, PortableRegistry, RuntimeVersion } from '@de
 import type { JsonRpcProvider } from '@dedot/providers';
 import { type IStorage } from '@dedot/storage';
 import { GenericSubstrateApi, RpcVersion, VersionedGenericSubstrateApi } from '@dedot/types';
+import { Deferred } from '@dedot/utils';
 import type { SubstrateApi } from '../chaintypes/index.js';
 import { JsonRpcClient } from '../json-rpc/index.js';
 import type { ApiEvent, ApiOptions, ISubstrateClient, ISubstrateClientAt, JsonRpcClientOptions, MetadataKey, SubstrateRuntimeVersion } from '../types.js';
@@ -10,7 +11,7 @@ export declare function ensurePresence<T>(value: T): NonNullable<T>;
  * @name BaseSubstrateClient
  * @description Base & shared abstraction for Substrate API Clients
  */
-export declare abstract class BaseSubstrateClient<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends JsonRpcClient<ChainApi[RpcVersion], ApiEvent> implements ISubstrateClient<ChainApi[RpcVersion]> {
+export declare abstract class BaseSubstrateClient<Rv extends RpcVersion, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends JsonRpcClient<ChainApi, ApiEvent> implements ISubstrateClient<ChainApi[Rv]> {
     rpcVersion: RpcVersion;
     protected _options: ApiOptions;
     protected _registry?: PortableRegistry;
@@ -18,6 +19,7 @@ export declare abstract class BaseSubstrateClient<ChainApi extends VersionedGene
     protected _genesisHash?: Hash;
     protected _runtimeVersion?: SubstrateRuntimeVersion;
     protected _localCache?: IStorage;
+    protected _runtimeUpgrading?: Deferred<void>;
     protected constructor(rpcVersion: RpcVersion, options: JsonRpcClientOptions | JsonRpcProvider);
     protected normalizeOptions(options: ApiOptions | JsonRpcProvider): ApiOptions;
     protected initializeLocalCache(): Promise<void>;
@@ -41,6 +43,9 @@ export declare abstract class BaseSubstrateClient<ChainApi extends VersionedGene
     protected beforeDisconnect(): Promise<void>;
     protected afterDisconnect(): Promise<void>;
     protected toSubstrateRuntimeVersion(runtimeVersion: RuntimeVersion): SubstrateRuntimeVersion;
+    protected startRuntimeUpgrade(): void;
+    protected doneRuntimeUpgrade(): void;
+    protected ensureRuntimeUpgraded(): Promise<void>;
     /**
      * @description Connect to blockchain node
      */
@@ -54,12 +59,13 @@ export declare abstract class BaseSubstrateClient<ChainApi extends VersionedGene
     get registry(): PortableRegistry;
     get genesisHash(): Hash;
     get runtimeVersion(): SubstrateRuntimeVersion;
-    get consts(): ChainApi[RpcVersion]['consts'];
-    get errors(): ChainApi[RpcVersion]['errors'];
-    get events(): ChainApi[RpcVersion]['events'];
-    get query(): ChainApi[RpcVersion]['query'];
-    get call(): ChainApi[RpcVersion]['call'];
-    protected callAt(hash?: BlockHash): ChainApi[RpcVersion]['call'];
-    get tx(): ChainApi[RpcVersion]['tx'];
-    at<ChainApiAt extends GenericSubstrateApi = ChainApi[RpcVersion]>(hash: BlockHash): Promise<ISubstrateClientAt<ChainApiAt>>;
+    getRuntimeVersion(): Promise<SubstrateRuntimeVersion>;
+    get consts(): ChainApi[Rv]['consts'];
+    get errors(): ChainApi[Rv]['errors'];
+    get events(): ChainApi[Rv]['events'];
+    get query(): ChainApi[Rv]['query'];
+    get call(): ChainApi[Rv]['call'];
+    protected callAt(hash?: BlockHash): ChainApi[Rv]['call'];
+    get tx(): ChainApi[Rv]['tx'];
+    at<ChainApiAt extends GenericSubstrateApi = ChainApi[Rv]>(hash: BlockHash): Promise<ISubstrateClientAt<ChainApiAt>>;
 }

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/{Dedot.d.ts → LegacyClient.d.ts}

@@ -5,7 +5,7 @@ import type { SubstrateApi } from '../chaintypes/index.js';
 import type { ApiOptions, ISubstrateClientAt } from '../types.js';
 import { BaseSubstrateClient } from './BaseSubstrateClient.js';
 /**
- * @name Dedot
+ * @name LegacyClient
  * @description Promised-based API Client for Polkadot & Substrate
  *
  * Initialize API instance and interact with substrate-based network
@@ -14,7 +14,7 @@ import { BaseSubstrateClient } from './BaseSubstrateClient.js';
  * import type { PolkadotApi } from '@dedot/chaintypes/polkadot';
  *
  * const run = async () => {
- *   const api = await Dedot.new<PolkadotApi>('wss://rpc.polkadot.io');
+ *   const api = await LegacyClient.new<PolkadotApi>('wss://rpc.polkadot.io');
  *
  *   // Call rpc `state_getMetadata` to fetch raw scale-encoded metadata and decode it.
  *   const metadata = await api.rpc.state.getMetadata();
@@ -42,7 +42,8 @@ import { BaseSubstrateClient } from './BaseSubstrateClient.js';
  * run().catch(console.error);
  * ```
  */
-export declare class Dedot<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.
@@ -55,13 +56,13 @@ export declare class Dedot<ChainApi extends VersionedGenericSubstrateApi = Subst
      *
      * @param options
      */
-    static create<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi>(options: ApiOptions | JsonRpcProvider): Promise<Dedot<ChainApi>>;
+    static create<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi>(options: ApiOptions | JsonRpcProvider): Promise<LegacyClient<ChainApi>>;
     /**
-     * Alias for __Dedot.create__
+     * Alias for __LegacyClient.create__
      *
      * @param options
      */
-    static new<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi>(options: ApiOptions | JsonRpcProvider): Promise<Dedot<ChainApi>>;
+    static new<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi>(options: ApiOptions | JsonRpcProvider): Promise<LegacyClient<ChainApi>>;
     protected onDisconnected: () => Promise<void>;
     protected beforeDisconnect(): Promise<void>;
     /**
@@ -116,7 +117,7 @@ export declare class Dedot<ChainApi extends VersionedGenericSubstrateApi = Subst
      * // 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/{Dedot.js → LegacyClient.js}

@@ -4,7 +4,7 @@ import { newProxyChain } from '../proxychain.js';
 import { BaseSubstrateClient } from './BaseSubstrateClient.js';
 const KEEP_ALIVE_INTERVAL = 10_000; // in ms
 /**
- * @name Dedot
+ * @name LegacyClient
  * @description Promised-based API Client for Polkadot & Substrate
  *
  * Initialize API instance and interact with substrate-based network
@@ -13,7 +13,7 @@ const KEEP_ALIVE_INTERVAL = 10_000; // in ms
  * import type { PolkadotApi } from '@dedot/chaintypes/polkadot';
  *
  * const run = async () => {
- *   const api = await Dedot.new<PolkadotApi>('wss://rpc.polkadot.io');
+ *   const api = await LegacyClient.new<PolkadotApi>('wss://rpc.polkadot.io');
  *
  *   // Call rpc `state_getMetadata` to fetch raw scale-encoded metadata and decode it.
  *   const metadata = await api.rpc.state.getMetadata();
@@ -41,7 +41,8 @@ const KEEP_ALIVE_INTERVAL = 10_000; // in ms
  * run().catch(console.error);
  * ```
  */
-export class Dedot extends BaseSubstrateClient {
+export class LegacyClient// prettier-end-here
+ extends BaseSubstrateClient {
     #runtimeSubscriptionUnsub;
     #healthTimer;
     #apiAtCache = {};
@@ -59,15 +60,15 @@ export class Dedot extends BaseSubstrateClient {
      * @param options
      */
     static async create(options) {
-        return new Dedot(options).connect();
+        return new LegacyClient(options).connect();
     }
     /**
-     * Alias for __Dedot.create__
+     * Alias for __LegacyClient.create__
      *
      * @param options
      */
     static async new(options) {
-        return Dedot.create(options);
+        return LegacyClient.create(options);
     }
     onDisconnected = async () => {
         await this.#unsubscribeUpdates();
@@ -101,9 +102,12 @@ export class Dedot 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 Dedot 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/client/index.d.ts

@@ -1,2 +1,2 @@
-export * from './Dedot.js';
+export * from './LegacyClient.js';
 export * from './DedotClient.js';

package/client/index.js

@@ -1,2 +1,2 @@
-export * from './Dedot.js';
+export * from './LegacyClient.js';
 export * from './DedotClient.js';

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

@@ -32,27 +32,27 @@ export class StorageQueryExecutorV2 extends StorageQueryExecutor {
         }, {});
     }
     async subscribeStorage(keys, callback) {
-        let initialHash = await this.chainHead.bestHash();
+        let best = await this.chainHead.bestBlock();
         let eventToListen = 'bestBlock';
         // TODO subscribe to finalized data source
         // initialHash = this.chainHead.finalizedHash;
         // eventToListen = 'finalizedBlock';
-        const latestChanges = {};
-        const pull = async (hash) => {
+        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(initialHash);
+        await pull(best);
         const unsub = this.chainHead.on(eventToListen, pull);
         return async () => {
             unsub();

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/CheckMetadataHash.d.ts

@@ -0,0 +1,13 @@
+import { SignerPayloadJSON } from '@polkadot/types/types';
+import { Hash } from '@dedot/codecs';
+import { SignedExtension } from '../SignedExtension.js';
+export type CheckMetadataHashMode = 'Disabled' | 'Enabled';
+/**
+ * @description Genesis hash check to provide replay protection between different networks.
+ */
+export declare class CheckMetadataHash extends SignedExtension<{
+    mode: CheckMetadataHashMode;
+}, Hash | undefined> {
+    init(): Promise<void>;
+    toPayload(): Partial<SignerPayloadJSON>;
+}