@dedot/api 0.0.1-alpha.34 → 0.0.1-alpha.36

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/SubmittableExtrinsic.js

@@ -20,7 +20,7 @@ export class SubmittableExtrinsic extends BaseSubmittableExtrinsic {
         const txHash = this.hash;
         if (isSubscription) {
             return this.api.rpc.author_submitAndWatchExtrinsic(txHex, async (status) => {
-                if (status.tag === 'InBlock' || status.tag === 'Finalized') {
+                if (status.type === 'InBlock' || status.type === 'Finalized') {
                     const blockHash = status.value;
                     const [signedBlock, blockEvents] = await Promise.all([
                         this.api.rpc.chain_getBlock(blockHash),
@@ -28,7 +28,7 @@ export class SubmittableExtrinsic extends BaseSubmittableExtrinsic {
                     ]);
                     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);
                     return callback(new SubmittableResult({ status, txHash, events, txIndex }));
                 }
                 else {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/api",
-  "version": "0.0.1-alpha.34",
+  "version": "0.0.1-alpha.36",
   "description": "A delightful JavaScript/TypeScript client for Polkadot & Substrate",
   "author": "Thang X. Vu <thang@coongcrafts.io>",
   "homepage": "https://github.com/dedotdev/dedot",
@@ -13,13 +13,13 @@
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@dedot/codecs": "0.0.1-alpha.34",
-    "@dedot/providers": "0.0.1-alpha.34",
-    "@dedot/runtime-specs": "0.0.1-alpha.34",
-    "@dedot/shape": "0.0.1-alpha.34",
-    "@dedot/storage": "0.0.1-alpha.34",
-    "@dedot/types": "0.0.1-alpha.34",
-    "@dedot/utils": "0.0.1-alpha.34"
+    "@dedot/codecs": "0.0.1-alpha.36",
+    "@dedot/providers": "0.0.1-alpha.36",
+    "@dedot/runtime-specs": "0.0.1-alpha.36",
+    "@dedot/shape": "0.0.1-alpha.36",
+    "@dedot/storage": "0.0.1-alpha.36",
+    "@dedot/types": "0.0.1-alpha.36",
+    "@dedot/utils": "0.0.1-alpha.36"
   },
   "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.2.1"
+    "@polkadot/types": "^12.0.1"
   },
-  "gitHead": "053078f3aed79a3044314421967325b9fe0e6f57",
+  "gitHead": "798f0b8ce218baf212b8853e4e6eb0cf45157f6e",
   "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;