@acala-network/chopsticks-core 0.8.5-1 → 0.8.5-2

package/lib/api.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -44,10 +35,8 @@ class Api {
         __classPrivateFieldSet(this, _Api_provider, provider, "f");
         this.signedExtensions = signedExtensions || {};
     }
-    disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return __classPrivateFieldGet(this, _Api_provider, "f").disconnect();
-        });
+    async disconnect() {
+        return __classPrivateFieldGet(this, _Api_provider, "f").disconnect();
     }
     get isReady() {
         if (!__classPrivateFieldGet(this, _Api_ready, "f")) {
@@ -56,10 +45,13 @@ class Api {
             }
             else {
                 __classPrivateFieldSet(this, _Api_ready, new Promise((resolve) => {
-                    __classPrivateFieldGet(this, _Api_provider, "f").on('connected', () => {
+                    if (__classPrivateFieldGet(this, _Api_provider, "f").hasSubscriptions) {
+                        __classPrivateFieldGet(this, _Api_provider, "f").on('connected', resolve);
+                        __classPrivateFieldGet(this, _Api_provider, "f").connect();
+                    }
+                    else {
                         resolve();
-                    });
-                    __classPrivateFieldGet(this, _Api_provider, "f").connect();
+                    }
                 }), "f");
             }
         }
@@ -77,76 +69,60 @@ class Api {
         }
         return __classPrivateFieldGet(this, _Api_chainProperties, "f");
     }
-    getSystemName() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return __classPrivateFieldGet(this, _Api_provider, "f").send('system_name', []);
-        });
+    async getSystemName() {
+        return __classPrivateFieldGet(this, _Api_provider, "f").send('system_name', []);
     }
-    getSystemProperties() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return __classPrivateFieldGet(this, _Api_provider, "f").send('system_properties', []);
-        });
+    async getSystemProperties() {
+        return __classPrivateFieldGet(this, _Api_provider, "f").send('system_properties', []);
     }
-    getSystemChain() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return __classPrivateFieldGet(this, _Api_provider, "f").send('system_chain', []);
-        });
+    async getSystemChain() {
+        return __classPrivateFieldGet(this, _Api_provider, "f").send('system_chain', []);
     }
-    getBlockHash(blockNumber) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return __classPrivateFieldGet(this, _Api_provider, "f").send('chain_getBlockHash', Number.isInteger(blockNumber) ? [blockNumber] : []);
-        });
+    async getBlockHash(blockNumber) {
+        return __classPrivateFieldGet(this, _Api_provider, "f").send('chain_getBlockHash', Number.isInteger(blockNumber) ? [blockNumber] : []);
     }
-    getHeader(hash) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return __classPrivateFieldGet(this, _Api_provider, "f").send('chain_getHeader', hash ? [hash] : []);
-        });
+    async getHeader(hash) {
+        return __classPrivateFieldGet(this, _Api_provider, "f").send('chain_getHeader', hash ? [hash] : []);
     }
-    getBlock(hash) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return __classPrivateFieldGet(this, _Api_provider, "f").send('chain_getBlock', hash ? [hash] : []);
-        });
+    async getBlock(hash) {
+        return __classPrivateFieldGet(this, _Api_provider, "f").send('chain_getBlock', hash ? [hash] : []);
     }
-    getStorage(key, hash) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [child, storageKey] = (0, utils_1.splitChildKey)(key);
-            if (child) {
-                // child storage key, use childstate_getStorage
-                const params = [child, storageKey];
-                if (hash)
-                    params.push(hash);
-                return __classPrivateFieldGet(this, _Api_provider, "f").send('childstate_getStorage', params);
-            }
-            else {
-                // main storage key, use state_getStorage
-                const params = [key];
-                if (hash)
-                    params.push(hash);
-                return __classPrivateFieldGet(this, _Api_provider, "f").send('state_getStorage', params);
-            }
-        });
+    async getStorage(key, hash) {
+        const [child, storageKey] = (0, utils_1.splitChildKey)(key);
+        if (child) {
+            // child storage key, use childstate_getStorage
+            const params = [child, storageKey];
+            if (hash)
+                params.push(hash);
+            return __classPrivateFieldGet(this, _Api_provider, "f").send('childstate_getStorage', params);
+        }
+        else {
+            // main storage key, use state_getStorage
+            const params = [key];
+            if (hash)
+                params.push(hash);
+            return __classPrivateFieldGet(this, _Api_provider, "f").send('state_getStorage', params);
+        }
     }
-    getKeysPaged(prefix, pageSize, startKey, hash) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [child, storageKey] = (0, utils_1.splitChildKey)(prefix);
-            if (child) {
-                // child storage key, use childstate_getKeysPaged
-                // strip child prefix from startKey
-                const params = [child, storageKey, pageSize, (0, utils_1.stripChildPrefix)(startKey)];
-                if (hash)
-                    params.push(hash);
-                return __classPrivateFieldGet(this, _Api_provider, "f")
-                    .send('childstate_getKeysPaged', params)
-                    .then((keys) => keys.map((key) => (0, utils_1.prefixedChildKey)(child, key)));
-            }
-            else {
-                // main storage key, use state_getKeysPaged
-                const params = [prefix, pageSize, startKey];
-                if (hash)
-                    params.push(hash);
-                return __classPrivateFieldGet(this, _Api_provider, "f").send('state_getKeysPaged', params);
-            }
-        });
+    async getKeysPaged(prefix, pageSize, startKey, hash) {
+        const [child, storageKey] = (0, utils_1.splitChildKey)(prefix);
+        if (child) {
+            // child storage key, use childstate_getKeysPaged
+            // strip child prefix from startKey
+            const params = [child, storageKey, pageSize, (0, utils_1.stripChildPrefix)(startKey)];
+            if (hash)
+                params.push(hash);
+            return __classPrivateFieldGet(this, _Api_provider, "f")
+                .send('childstate_getKeysPaged', params)
+                .then((keys) => keys.map((key) => (0, utils_1.prefixedChildKey)(child, key)));
+        }
+        else {
+            // main storage key, use state_getKeysPaged
+            const params = [prefix, pageSize, startKey];
+            if (hash)
+                params.push(hash);
+            return __classPrivateFieldGet(this, _Api_provider, "f").send('state_getKeysPaged', params);
+        }
     }
 }
 exports.Api = Api;

package/lib/blockchain/block-builder.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dryRunInherents = exports.dryRunExtrinsic = exports.buildBlock = exports.newHeader = void 0;
 const block_1 = require("./block");
@@ -27,47 +18,56 @@ const getConsensus = (header) => {
 const getNewSlot = (digest, slotNumber) => {
     if (digest.isPrimary) {
         return {
-            primary: Object.assign(Object.assign({}, digest.asPrimary.toJSON()), { slotNumber }),
+            primary: {
+                ...digest.asPrimary.toJSON(),
+                slotNumber,
+            },
         };
     }
     if (digest.isSecondaryPlain) {
         return {
-            secondaryPlain: Object.assign(Object.assign({}, digest.asSecondaryPlain.toJSON()), { slotNumber }),
+            secondaryPlain: {
+                ...digest.asSecondaryPlain.toJSON(),
+                slotNumber,
+            },
         };
     }
     if (digest.isSecondaryVRF) {
         return {
-            secondaryVRF: Object.assign(Object.assign({}, digest.asSecondaryVRF.toJSON()), { slotNumber }),
+            secondaryVRF: {
+                ...digest.asSecondaryVRF.toJSON(),
+                slotNumber,
+            },
         };
     }
     return digest.toJSON();
 };
-const newHeader = (head, unsafeBlockHeight) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    const meta = yield head.meta;
-    const parentHeader = yield head.header;
+const newHeader = async (head, unsafeBlockHeight) => {
+    const meta = await head.meta;
+    const parentHeader = await head.header;
     let newLogs = parentHeader.digest.logs;
     const consensus = getConsensus(parentHeader);
-    if (consensus === null || consensus === void 0 ? void 0 : consensus.consensusEngine.isAura) {
-        const slot = yield (0, time_travel_1.getCurrentSlot)(head.chain);
+    if (consensus?.consensusEngine.isAura) {
+        const slot = await (0, time_travel_1.getCurrentSlot)(head.chain);
         const newSlot = (0, util_1.compactAddLength)(meta.registry.createType('Slot', slot + 1).toU8a());
         newLogs = [{ PreRuntime: [consensus.consensusEngine, newSlot] }, ...consensus.rest];
     }
-    else if (consensus === null || consensus === void 0 ? void 0 : consensus.consensusEngine.isBabe) {
-        const slot = yield (0, time_travel_1.getCurrentSlot)(head.chain);
+    else if (consensus?.consensusEngine.isBabe) {
+        const slot = await (0, time_travel_1.getCurrentSlot)(head.chain);
         const digest = meta.registry.createType('RawBabePreDigest', consensus.slot);
         const newSlot = (0, util_1.compactAddLength)(meta.registry.createType('RawBabePreDigest', getNewSlot(digest, slot + 1)).toU8a());
         newLogs = [{ PreRuntime: [consensus.consensusEngine, newSlot] }, ...consensus.rest];
     }
-    else if (((_a = consensus === null || consensus === void 0 ? void 0 : consensus.consensusEngine) === null || _a === void 0 ? void 0 : _a.toString()) == 'nmbs') {
+    else if (consensus?.consensusEngine?.toString() == 'nmbs') {
         const nmbsKey = (0, util_1.stringToHex)('nmbs');
         newLogs = [
             {
                 // Using previous block author
                 PreRuntime: [
                     consensus.consensusEngine,
-                    (_b = parentHeader.digest.logs
-                        .find((log) => log.isPreRuntime && log.asPreRuntime[0].toHex() == nmbsKey)) === null || _b === void 0 ? void 0 : _b.asPreRuntime[1].toHex(),
+                    parentHeader.digest.logs
+                        .find((log) => log.isPreRuntime && log.asPreRuntime[0].toHex() == nmbsKey)
+                        ?.asPreRuntime[1].toHex(),
                 ],
             },
             ...consensus.rest,
@@ -80,7 +80,7 @@ const newHeader = (head, unsafeBlockHeight) => __awaiter(void 0, void 0, void 0,
     }
     const header = meta.registry.createType('Header', {
         parentHash: head.hash,
-        number: unsafeBlockHeight !== null && unsafeBlockHeight !== void 0 ? unsafeBlockHeight : head.number + 1,
+        number: unsafeBlockHeight ?? head.number + 1,
         stateRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
         extrinsicsRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
         digest: {
@@ -88,10 +88,9 @@ const newHeader = (head, unsafeBlockHeight) => __awaiter(void 0, void 0, void 0,
         },
     });
     return header;
-});
+};
 exports.newHeader = newHeader;
-const initNewBlock = (head, header, inherents, storageLayer, callback) => __awaiter(void 0, void 0, void 0, function* () {
-    var _c, _d;
+const initNewBlock = async (head, header, inherents, storageLayer, callback) => {
     const blockNumber = header.number.toNumber();
     const hash = `0x${Math.round(Math.random() * 100000000)
         .toString(16)
@@ -99,23 +98,23 @@ const initNewBlock = (head, header, inherents, storageLayer, callback) => __awai
     const newBlock = new block_1.Block(head.chain, blockNumber, hash, head, {
         header,
         extrinsics: [],
-        storage: storageLayer !== null && storageLayer !== void 0 ? storageLayer : head.storage,
+        storage: storageLayer ?? head.storage,
     });
     {
         // initialize block
-        const resp = yield newBlock.call('Core_initialize_block', [header.toHex()]);
+        const resp = await newBlock.call('Core_initialize_block', [header.toHex()]);
         newBlock.pushStorageLayer().setAll(resp.storageDiff);
-        (_c = callback === null || callback === void 0 ? void 0 : callback.onPhaseApplied) === null || _c === void 0 ? void 0 : _c.call(callback, 'initialize', resp);
+        callback?.onPhaseApplied?.('initialize', resp);
     }
     const layers = [];
     // apply inherents
     for (const extrinsic of inherents) {
         try {
-            const resp = yield newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
+            const resp = await newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
             const layer = newBlock.pushStorageLayer();
             layer.setAll(resp.storageDiff);
             layers.push(layer);
-            (_d = callback === null || callback === void 0 ? void 0 : callback.onPhaseApplied) === null || _d === void 0 ? void 0 : _d.call(callback, layers.length - 1, resp);
+            callback?.onPhaseApplied?.(layers.length - 1, resp);
         }
         catch (e) {
             logger.warn('Failed to apply inherents %o %s', e, e);
@@ -126,11 +125,10 @@ const initNewBlock = (head, header, inherents, storageLayer, callback) => __awai
         block: newBlock,
         layers: layers,
     };
-});
-const buildBlock = (head, inherents, extrinsics, ump, callbacks, unsafeBlockHeight) => __awaiter(void 0, void 0, void 0, function* () {
-    var _e, _f, _g;
-    const registry = yield head.registry;
-    const header = yield (0, exports.newHeader)(head, unsafeBlockHeight);
+};
+const buildBlock = async (head, inherents, extrinsics, ump, callbacks, unsafeBlockHeight) => {
+    const registry = await head.registry;
+    const header = await (0, exports.newHeader)(head, unsafeBlockHeight);
     const newBlockNumber = header.number.toNumber();
     logger.info({
         number: newBlockNumber,
@@ -140,7 +138,7 @@ const buildBlock = (head, inherents, extrinsics, ump, callbacks, unsafeBlockHeig
     let layer;
     // apply ump via storage override hack
     if (Object.keys(ump).length > 0) {
-        const meta = yield head.meta;
+        const meta = await head.meta;
         layer = new storage_layer_1.StorageLayer(head.storage);
         for (const [paraId, upwardMessages] of Object.entries(ump)) {
             const upwardMessagesU8a = upwardMessages.map((x) => (0, util_1.hexToU8a)(x));
@@ -209,21 +207,21 @@ const buildBlock = (head, inherents, extrinsics, ump, callbacks, unsafeBlockHeig
             layer.set((0, utils_1.compactHex)(meta.query.ump.needsDispatch()), needsDispatch.toHex());
         }
     }
-    const { block: newBlock } = yield initNewBlock(head, header, inherents, layer);
+    const { block: newBlock } = await initNewBlock(head, header, inherents, layer);
     const pendingExtrinsics = [];
     const includedExtrinsic = [];
     // apply extrinsics
     for (const extrinsic of extrinsics) {
         try {
-            const resp = yield newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
+            const resp = await newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
             const outcome = registry.createType('ApplyExtrinsicResult', resp.result);
             if (outcome.isErr) {
-                (_e = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onApplyExtrinsicError) === null || _e === void 0 ? void 0 : _e.call(callbacks, extrinsic, outcome.asErr);
+                callbacks?.onApplyExtrinsicError?.(extrinsic, outcome.asErr);
                 continue;
             }
             newBlock.pushStorageLayer().setAll(resp.storageDiff);
             includedExtrinsic.push(extrinsic);
-            (_f = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onPhaseApplied) === null || _f === void 0 ? void 0 : _f.call(callbacks, includedExtrinsic.length - 1, resp);
+            callbacks?.onPhaseApplied?.(includedExtrinsic.length - 1, resp);
         }
         catch (e) {
             logger.info('Failed to apply extrinsic %o %s', e, e);
@@ -232,15 +230,15 @@ const buildBlock = (head, inherents, extrinsics, ump, callbacks, unsafeBlockHeig
     }
     {
         // finalize block
-        const resp = yield newBlock.call('BlockBuilder_finalize_block', []);
+        const resp = await newBlock.call('BlockBuilder_finalize_block', []);
         newBlock.pushStorageLayer().setAll(resp.storageDiff);
-        (_g = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onPhaseApplied) === null || _g === void 0 ? void 0 : _g.call(callbacks, 'finalize', resp);
+        callbacks?.onPhaseApplied?.('finalize', resp);
     }
     const blockData = registry.createType('Block', {
         header,
         extrinsics: includedExtrinsic,
     });
-    const storageDiff = yield newBlock.storageDiff();
+    const storageDiff = await newBlock.storageDiff();
     if (logger.level.toLowerCase() === 'trace') {
         logger.trace(Object.entries(storageDiff).map(([key, value]) => [key, (0, logger_1.truncate)(value)]), 'Final block');
     }
@@ -258,25 +256,25 @@ const buildBlock = (head, inherents, extrinsics, ump, callbacks, unsafeBlockHeig
         ump: (0, logger_1.truncate)(ump),
     }, 'Block built');
     return [finalBlock, pendingExtrinsics];
-});
+};
 exports.buildBlock = buildBlock;
-const dryRunExtrinsic = (head, inherents, extrinsic) => __awaiter(void 0, void 0, void 0, function* () {
-    const registry = yield head.registry;
-    const header = yield (0, exports.newHeader)(head);
-    const { block: newBlock } = yield initNewBlock(head, header, inherents);
+const dryRunExtrinsic = async (head, inherents, extrinsic) => {
+    const registry = await head.registry;
+    const header = await (0, exports.newHeader)(head);
+    const { block: newBlock } = await initNewBlock(head, header, inherents);
     if (typeof extrinsic !== 'string') {
         if (!head.chain.mockSignatureHost) {
             throw new Error('Cannot fake signature because mock signature host is not enabled. Start chain with `mockSignatureHost: true`');
         }
-        const meta = yield head.meta;
+        const meta = await head.meta;
         const call = registry.createType('Call', (0, util_1.hexToU8a)(extrinsic.call));
         const generic = registry.createType('GenericExtrinsic', call);
-        const accountRaw = yield head.get((0, utils_1.compactHex)(meta.query.system.account(extrinsic.address)));
+        const accountRaw = await head.get((0, utils_1.compactHex)(meta.query.system.account(extrinsic.address)));
         const account = registry.createType('AccountInfo', (0, util_1.hexToU8a)(accountRaw));
         generic.signFake(extrinsic.address, {
             blockHash: head.hash,
             genesisHash: head.hash,
-            runtimeVersion: yield head.runtimeVersion,
+            runtimeVersion: await head.runtimeVersion,
             nonce: account.nonce,
         });
         const mockSignature = new Uint8Array(64);
@@ -288,15 +286,15 @@ const dryRunExtrinsic = (head, inherents, extrinsic) => __awaiter(void 0, void 0
     }
     logger_1.defaultLogger.info({ call: registry.createType('GenericExtrinsic', (0, util_1.hexToU8a)(extrinsic)).toHuman() }, 'dry_run_extrinsic');
     return newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
-});
+};
 exports.dryRunExtrinsic = dryRunExtrinsic;
-const dryRunInherents = (head, inherents) => __awaiter(void 0, void 0, void 0, function* () {
-    const header = yield (0, exports.newHeader)(head);
-    const { layers } = yield initNewBlock(head, header, inherents);
+const dryRunInherents = async (head, inherents) => {
+    const header = await (0, exports.newHeader)(head);
+    const { layers } = await initNewBlock(head, header, inherents);
     const storage = {};
     for (const layer of layers) {
-        yield layer.mergeInto(storage);
+        await layer.mergeInto(storage);
     }
     return Object.entries(storage);
-});
+};
 exports.dryRunInherents = dryRunInherents;

package/lib/blockchain/block.d.ts

@@ -1,6 +1,7 @@
 import { Header } from '@polkadot/types/interfaces';
 import { DecoratedMeta } from '@polkadot/types/metadata/decorate/types';
 import { TypeRegistry } from '@polkadot/types';
+import { StorageEntry } from '@polkadot/types/primitive/types';
 import type { HexString } from '@polkadot/util/types';
 import { Blockchain } from '.';
 import { StorageLayer, StorageLayerProvider, StorageValue } from './storage-layer';
@@ -44,7 +45,7 @@ export declare class Block {
     get chain(): Blockchain;
     get header(): Header | Promise<Header>;
     get extrinsics(): HexString[] | Promise<HexString[]>;
-    get parentBlock(): undefined | Block | Promise<Block | undefined>;
+    get parentBlock(): Promise<Block | undefined>;
     /**
      * Get the block storage.
      */
@@ -53,6 +54,7 @@ export declare class Block {
      * Get the block storage by key.
      */
     get(key: string): Promise<string | undefined>;
+    read<T extends string>(type: T, query: StorageEntry, ...args: any[]): Promise<import("@polkadot/types/types").DetectCodec<import("@polkadot/types-codec/types").Codec, T> | undefined>;
     /**
      * Get paged storage keys.
      */