@acala-network/chopsticks 0.5.5 → 0.5.7

package/lib/api.js

@@ -1,4 +1,7 @@
-export class Api {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Api = void 0;
+class Api {
     #provider;
     #ready;
     #chain;
@@ -73,3 +76,4 @@ export class Api {
         return this.#provider.send('state_getKeysPaged', [prefix, pageSize, startKey]);
     }
 }
+exports.Api = Api;

package/lib/blockchain/block-builder.js

@@ -1,10 +1,13 @@
-import { Block } from './block';
-import { blake2AsHex } from '@polkadot/util-crypto';
-import { compactAddLength, hexToU8a, stringToHex } from '@polkadot/util';
-import { compactHex } from '../utils';
-import { defaultLogger, truncate } from '../logger';
-import { getCurrentSlot } from '../utils/time-travel';
-const logger = defaultLogger.child({ name: 'block-builder' });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dryRunInherents = exports.dryRunExtrinsic = exports.buildBlock = exports.newHeader = void 0;
+const block_1 = require("./block");
+const util_crypto_1 = require("@polkadot/util-crypto");
+const util_1 = require("@polkadot/util");
+const utils_1 = require("../utils");
+const logger_1 = require("../logger");
+const time_travel_1 = require("../utils/time-travel");
+const logger = logger_1.defaultLogger.child({ name: 'block-builder' });
 const getConsensus = (header) => {
     if (header.digest.logs.length === 0)
         return;
@@ -39,24 +42,24 @@ const getNewSlot = (digest, slotNumber) => {
     }
     return digest.toJSON();
 };
-export const newHeader = async (head) => {
+const newHeader = async (head) => {
     const meta = await head.meta;
     const parentHeader = await head.header;
     let newLogs = parentHeader.digest.logs;
     const consensus = getConsensus(parentHeader);
     if (consensus?.consensusEngine.isAura) {
-        const slot = await getCurrentSlot(head.chain);
-        const newSlot = compactAddLength(meta.registry.createType('Slot', slot + 1).toU8a());
+        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?.consensusEngine.isBabe) {
-        const slot = await getCurrentSlot(head.chain);
+        const slot = await (0, time_travel_1.getCurrentSlot)(head.chain);
         const digest = meta.registry.createType('RawBabePreDigest', consensus.slot);
-        const newSlot = compactAddLength(meta.registry.createType('RawBabePreDigest', getNewSlot(digest, slot + 1)).toU8a());
+        const newSlot = (0, util_1.compactAddLength)(meta.registry.createType('RawBabePreDigest', getNewSlot(digest, slot + 1)).toU8a());
         newLogs = [{ PreRuntime: [consensus.consensusEngine, newSlot] }, ...consensus.rest];
     }
     else if (consensus?.consensusEngine?.toString() == 'nmbs') {
-        const nmbsKey = stringToHex('nmbs');
+        const nmbsKey = (0, util_1.stringToHex)('nmbs');
         newLogs = [
             {
                 // Using previous block author
@@ -72,7 +75,7 @@ export const newHeader = async (head) => {
         if (meta.query.randomness) {
             // TODO: shouldn't modify existing head
             // reset notFirstBlock so randomness will skip validation
-            head.pushStorageLayer().set(compactHex(meta.query.randomness.notFirstBlock()), "Deleted" /* StorageValueKind.Deleted */);
+            head.pushStorageLayer().set((0, utils_1.compactHex)(meta.query.randomness.notFirstBlock()), "Deleted" /* StorageValueKind.Deleted */);
         }
     }
     const header = meta.registry.createType('Header', {
@@ -86,17 +89,18 @@ export const newHeader = async (head) => {
     });
     return header;
 };
+exports.newHeader = newHeader;
 const initNewBlock = async (head, header, inherents) => {
     const blockNumber = header.number.toNumber();
     const hash = `0x${Math.round(Math.random() * 100000000)
         .toString(16)
         .padEnd(64, '0')}`;
-    const newBlock = new Block(head.chain, blockNumber, hash, head, { header, extrinsics: [], storage: head.storage });
+    const newBlock = new block_1.Block(head.chain, blockNumber, hash, head, { header, extrinsics: [], storage: head.storage });
     {
         // initialize block
         const { storageDiff } = await newBlock.call('Core_initialize_block', [header.toHex()]);
         newBlock.pushStorageLayer().setAll(storageDiff);
-        logger.trace(truncate(storageDiff), 'Initialize block');
+        logger.trace((0, logger_1.truncate)(storageDiff), 'Initialize block');
     }
     const layers = [];
     // apply inherents
@@ -106,7 +110,7 @@ const initNewBlock = async (head, header, inherents) => {
             const layer = newBlock.pushStorageLayer();
             layer.setAll(storageDiff);
             layers.push(layer);
-            logger.trace(truncate(storageDiff), 'Applied inherent');
+            logger.trace((0, logger_1.truncate)(storageDiff), 'Applied inherent');
         }
         catch (e) {
             logger.warn('Failed to apply inherents %o %s', e, e);
@@ -118,9 +122,9 @@ const initNewBlock = async (head, header, inherents) => {
         layers: layers,
     };
 };
-export const buildBlock = async (head, inherents, extrinsics, ump, onApplyExtrinsicError) => {
+const buildBlock = async (head, inherents, extrinsics, ump, onApplyExtrinsicError) => {
     const registry = await head.registry;
-    const header = await newHeader(head);
+    const header = await (0, exports.newHeader)(head);
     const { block: newBlock } = await initNewBlock(head, header, inherents);
     logger.info({
         number: newBlock.number,
@@ -141,8 +145,8 @@ export const buildBlock = async (head, inherents, extrinsics, ump, onApplyExtrin
             const messages = meta.registry.createType('Vec<Bytes>', upwardMessages);
             // TODO: make sure we append instead of replace
             layer.setAll([
-                [compactHex(meta.query.ump.relayDispatchQueues(paraId)), messages.toHex()],
-                [compactHex(meta.query.ump.relayDispatchQueueSize(paraId)), queueSize.toHex()],
+                [(0, utils_1.compactHex)(meta.query.ump.relayDispatchQueues(paraId)), messages.toHex()],
+                [(0, utils_1.compactHex)(meta.query.ump.relayDispatchQueueSize(paraId)), queueSize.toHex()],
             ]);
         }
         logger.trace({
@@ -151,7 +155,7 @@ export const buildBlock = async (head, inherents, extrinsics, ump, onApplyExtrin
             ump,
         }, 'Upward messages');
         const needsDispatch = meta.registry.createType('Vec<u32>', Object.keys(ump));
-        layer.set(compactHex(meta.query.ump.needsDispatch()), needsDispatch.toHex());
+        layer.set((0, utils_1.compactHex)(meta.query.ump.needsDispatch()), needsDispatch.toHex());
     }
     // apply extrinsics
     for (const extrinsic of extrinsics) {
@@ -163,7 +167,7 @@ export const buildBlock = async (head, inherents, extrinsics, ump, onApplyExtrin
                 continue;
             }
             newBlock.pushStorageLayer().setAll(storageDiff);
-            logger.trace(truncate(storageDiff), 'Applied extrinsic');
+            logger.trace((0, logger_1.truncate)(storageDiff), 'Applied extrinsic');
             includedExtrinsic.push(extrinsic);
         }
         catch (e) {
@@ -175,15 +179,15 @@ export const buildBlock = async (head, inherents, extrinsics, ump, onApplyExtrin
         // finalize block
         const { storageDiff } = await newBlock.call('BlockBuilder_finalize_block', []);
         newBlock.pushStorageLayer().setAll(storageDiff);
-        logger.trace(truncate(storageDiff), 'Finalize block');
+        logger.trace((0, logger_1.truncate)(storageDiff), 'Finalize block');
     }
     const blockData = registry.createType('Block', {
         header,
         extrinsics: includedExtrinsic,
     });
     const storageDiff = await newBlock.storageDiff();
-    logger.trace(Object.entries(storageDiff).map(([key, value]) => [key, truncate(value)]), 'Final block');
-    const finalBlock = new Block(head.chain, newBlock.number, blockData.hash.toHex(), head, {
+    logger.trace(Object.entries(storageDiff).map(([key, value]) => [key, (0, logger_1.truncate)(value)]), 'Final block');
+    const finalBlock = new block_1.Block(head.chain, newBlock.number, blockData.hash.toHex(), head, {
         header,
         extrinsics: [...inherents, ...includedExtrinsic],
         storage: head.storage,
@@ -191,25 +195,26 @@ export const buildBlock = async (head, inherents, extrinsics, ump, onApplyExtrin
     });
     logger.info({
         hash: finalBlock.hash,
-        extrinsics: includedExtrinsic.map((x) => blake2AsHex(x, 256)),
+        extrinsics: includedExtrinsic.map((x) => (0, util_crypto_1.blake2AsHex)(x, 256)),
         pendingExtrinsics: pendingExtrinsics.length,
         number: newBlock.number,
     }, `Block built #${newBlock.number.toLocaleString()} hash ${finalBlock.hash}`);
     return [finalBlock, pendingExtrinsics];
 };
-export const dryRunExtrinsic = async (head, inherents, extrinsic) => {
+exports.buildBlock = buildBlock;
+const dryRunExtrinsic = async (head, inherents, extrinsic) => {
     const registry = await head.registry;
-    const header = await newHeader(head);
+    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 = await head.meta;
-        const call = registry.createType('Call', hexToU8a(extrinsic.call));
+        const call = registry.createType('Call', (0, util_1.hexToU8a)(extrinsic.call));
         const generic = registry.createType('GenericExtrinsic', call);
-        const accountRaw = await head.get(compactHex(meta.query.system.account(extrinsic.address)));
-        const account = registry.createType('AccountInfo', hexToU8a(accountRaw));
+        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,
@@ -220,14 +225,15 @@ export const dryRunExtrinsic = async (head, inherents, extrinsic) => {
         mockSignature.fill(0xcd);
         mockSignature.set([0xde, 0xad, 0xbe, 0xef]);
         generic.signature.set(mockSignature);
-        defaultLogger.info({ call: call.toHuman() }, 'dry_run_call');
+        logger_1.defaultLogger.info({ call: call.toHuman() }, 'dry_run_call');
         return newBlock.call('BlockBuilder_apply_extrinsic', [generic.toHex()]);
     }
-    defaultLogger.info({ call: registry.createType('GenericExtrinsic', hexToU8a(extrinsic)).toHuman() }, 'dry_run_extrinsic');
+    logger_1.defaultLogger.info({ call: registry.createType('GenericExtrinsic', (0, util_1.hexToU8a)(extrinsic)).toHuman() }, 'dry_run_extrinsic');
     return newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
 };
-export const dryRunInherents = async (head, inherents) => {
-    const header = await newHeader(head);
+exports.dryRunExtrinsic = dryRunExtrinsic;
+const dryRunInherents = async (head, inherents) => {
+    const header = await (0, exports.newHeader)(head);
     const { layers } = await initNewBlock(head, header, inherents);
     const stoarge = {};
     for (const layer of layers) {
@@ -235,3 +241,4 @@ export const dryRunInherents = async (head, inherents) => {
     }
     return Object.entries(stoarge);
 };
+exports.dryRunInherents = dryRunInherents;

package/lib/blockchain/block.js

@@ -1,11 +1,14 @@
-import { Metadata, TypeRegistry } from '@polkadot/types';
-import { expandMetadata } from '@polkadot/types/metadata';
-import { getSpecExtensions, getSpecHasher, getSpecTypes } from '@polkadot/types-known/util';
-import { hexToU8a, objectSpread, stringToHex } from '@polkadot/util';
-import { RemoteStorageLayer, StorageLayer } from './storage-layer';
-import { compactHex } from '../utils';
-import { getRuntimeVersion, runTask, taskHandler } from '../executor';
-export class Block {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Block = void 0;
+const types_1 = require("@polkadot/types");
+const metadata_1 = require("@polkadot/types/metadata");
+const util_1 = require("@polkadot/types-known/util");
+const util_2 = require("@polkadot/util");
+const storage_layer_1 = require("./storage-layer");
+const utils_1 = require("../utils");
+const executor_1 = require("../executor");
+class Block {
     number;
     hash;
     #chain;
@@ -26,12 +29,12 @@ export class Block {
         this.#parentBlock = parentBlock;
         this.#header = block?.header;
         this.#extrinsics = block?.extrinsics;
-        this.#baseStorage = block?.storage ?? new RemoteStorageLayer(chain.api, hash, chain.db);
+        this.#baseStorage = block?.storage ?? new storage_layer_1.RemoteStorageLayer(chain.api, hash, chain.db);
         this.#storages = [];
         const storageDiff = block?.storageDiff;
         if (storageDiff) {
             // if code doesn't change then reuse parent block's meta
-            if (!storageDiff?.[stringToHex(':code')]) {
+            if (!storageDiff?.[(0, util_2.stringToHex)(':code')]) {
                 this.#runtimeVersion = parentBlock?.runtimeVersion;
                 this.#metadata = parentBlock?.metadata;
                 this.#registry = parentBlock?.registry;
@@ -77,7 +80,7 @@ export class Block {
         }
     }
     async getKeysPaged(options) {
-        const layer = new StorageLayer(this.storage);
+        const layer = new storage_layer_1.StorageLayer(this.storage);
         await layer.fold();
         const prefix = options.prefix ?? '0x';
         const startKey = options.startKey ?? prefix;
@@ -85,7 +88,7 @@ export class Block {
         return layer.getKeysPaged(prefix, pageSize, startKey);
     }
     pushStorageLayer() {
-        const layer = new StorageLayer(this.storage);
+        const layer = new storage_layer_1.StorageLayer(this.storage);
         this.#storages.push(layer);
         return layer;
     }
@@ -102,7 +105,7 @@ export class Block {
     get wasm() {
         if (!this.#wasm) {
             this.#wasm = (async () => {
-                const wasmKey = stringToHex(':code');
+                const wasmKey = (0, util_2.stringToHex)(':code');
                 const wasm = await this.get(wasmKey);
                 if (!wasm) {
                     throw new Error('No wasm found');
@@ -113,7 +116,7 @@ export class Block {
         return this.#wasm;
     }
     setWasm(wasm) {
-        const wasmKey = stringToHex(':code');
+        const wasmKey = (0, util_2.stringToHex)(':code');
         this.pushStorageLayer().set(wasmKey, wasm);
         this.#wasm = Promise.resolve(wasm);
         this.#runtimeVersion = undefined;
@@ -129,12 +132,12 @@ export class Block {
                 this.#chain.api.chain,
                 this.runtimeVersion,
             ]).then(([data, properties, chain, version]) => {
-                const registry = new TypeRegistry(this.hash);
+                const registry = new types_1.TypeRegistry(this.hash);
                 registry.setKnownTypes(this.chain.registeredTypes);
                 registry.setChainProperties(registry.createType('ChainProperties', properties));
-                registry.register(getSpecTypes(registry, chain, version.specName, version.specVersion));
-                registry.setHasher(getSpecHasher(registry, chain, version.specName));
-                registry.setMetadata(new Metadata(registry, data), undefined, objectSpread({}, getSpecExtensions(registry, chain, version.specName), this.#chain.api.signedExtensions));
+                registry.register((0, util_1.getSpecTypes)(registry, chain, version.specName, version.specVersion));
+                registry.setHasher((0, util_1.getSpecHasher)(registry, chain, version.specName));
+                registry.setMetadata(new types_1.Metadata(registry, data), undefined, (0, util_2.objectSpread)({}, (0, util_1.getSpecExtensions)(registry, chain, version.specName), this.#chain.api.signedExtensions));
                 return registry;
             });
         }
@@ -142,34 +145,34 @@ export class Block {
     }
     get runtimeVersion() {
         if (!this.#runtimeVersion) {
-            this.#runtimeVersion = this.wasm.then(getRuntimeVersion);
+            this.#runtimeVersion = this.wasm.then(executor_1.getRuntimeVersion);
         }
         return this.#runtimeVersion;
     }
     get metadata() {
         if (!this.#metadata) {
-            this.#metadata = this.call('Metadata_metadata', []).then((resp) => compactHex(hexToU8a(resp.result)));
+            this.#metadata = this.call('Metadata_metadata', []).then((resp) => (0, utils_1.compactHex)((0, util_2.hexToU8a)(resp.result)));
         }
         return this.#metadata;
     }
     get meta() {
         if (!this.#meta) {
             this.#meta = Promise.all([this.registry, this.metadata]).then(([registry, metadataStr]) => {
-                const metadata = new Metadata(registry, metadataStr);
-                return expandMetadata(registry, metadata);
+                const metadata = new types_1.Metadata(registry, metadataStr);
+                return (0, metadata_1.expandMetadata)(registry, metadata);
             });
         }
         return this.#meta;
     }
     async call(method, args, storage = []) {
         const wasm = await this.wasm;
-        const response = await runTask({
+        const response = await (0, executor_1.runTask)({
             wasm,
             calls: [[method, args]],
             storage,
             mockSignatureHost: this.#chain.mockSignatureHost,
             allowUnresolvedImports: this.#chain.allowUnresolvedImports,
-        }, taskHandler(this));
+        }, (0, executor_1.taskHandler)(this));
         if (response.Call)
             return response.Call;
         if (response.Error)
@@ -177,3 +180,4 @@ export class Block {
         throw Error('Unexpected response');
     }
 }
+exports.Block = Block;

package/lib/blockchain/head-state.js

@@ -1,8 +1,12 @@
-import { stringToHex } from '@polkadot/util';
-import { defaultLogger } from '../logger';
-export const randomId = () => Math.random().toString(36).substring(2);
-const logger = defaultLogger.child({ name: 'head-state' });
-export class HeadState {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeadState = exports.randomId = void 0;
+const util_1 = require("@polkadot/util");
+const logger_1 = require("../logger");
+const randomId = () => Math.random().toString(36).substring(2);
+exports.randomId = randomId;
+const logger = logger_1.defaultLogger.child({ name: 'head-state' });
+class HeadState {
     #headListeners = {};
     #storageListeners = {};
     #oldValues = {};
@@ -11,7 +15,7 @@ export class HeadState {
         this.#head = head;
     }
     subscribeHead(cb) {
-        const id = randomId();
+        const id = (0, exports.randomId)();
         this.#headListeners[id] = cb;
         return id;
     }
@@ -19,7 +23,7 @@ export class HeadState {
         delete this.#headListeners[id];
     }
     async subscribeStorage(keys, cb) {
-        const id = randomId();
+        const id = (0, exports.randomId)();
         this.#storageListeners[id] = [keys, cb];
         for (const key of keys) {
             this.#oldValues[key] = await this.#head.get(key);
@@ -30,8 +34,8 @@ export class HeadState {
         delete this.#storageListeners[id];
     }
     async subscrubeRuntimeVersion(cb) {
-        const id = randomId();
-        const codeKey = stringToHex(':code');
+        const id = (0, exports.randomId)();
+        const codeKey = (0, util_1.stringToHex)(':code');
         this.#storageListeners[id] = [[codeKey], cb];
         this.#oldValues[codeKey] = await this.#head.get(codeKey);
         return id;
@@ -64,3 +68,4 @@ export class HeadState {
         Object.assign(this.#oldValues, diff);
     }
 }
+exports.HeadState = HeadState;

package/lib/blockchain/index.js

@@ -1,13 +1,16 @@
-import { blake2AsHex } from '@polkadot/util-crypto';
-import { u8aConcat, u8aToHex } from '@polkadot/util';
-import { Block } from './block';
-import { TxPool } from './txpool';
-import { HeadState } from './head-state';
-import { compactHex } from '../utils';
-import { defaultLogger } from '../logger';
-import { dryRunExtrinsic, dryRunInherents } from './block-builder';
-const logger = defaultLogger.child({ name: 'blockchain' });
-export class Blockchain {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Blockchain = void 0;
+const util_crypto_1 = require("@polkadot/util-crypto");
+const util_1 = require("@polkadot/util");
+const block_1 = require("./block");
+const txpool_1 = require("./txpool");
+const head_state_1 = require("./head-state");
+const utils_1 = require("../utils");
+const logger_1 = require("../logger");
+const block_builder_1 = require("./block-builder");
+const logger = logger_1.defaultLogger.child({ name: 'blockchain' });
+class Blockchain {
     uid = Math.random().toString(36).substring(2);
     api;
     db;
@@ -27,11 +30,11 @@ export class Blockchain {
         this.mockSignatureHost = mockSignatureHost;
         this.allowUnresolvedImports = allowUnresolvedImports;
         this.registeredTypes = registeredTypes;
-        this.#head = new Block(this, header.number, header.hash);
+        this.#head = new block_1.Block(this, header.number, header.hash);
         this.#registerBlock(this.#head);
-        this.#txpool = new TxPool(this, inherentProvider, buildBlockMode);
+        this.#txpool = new txpool_1.TxPool(this, inherentProvider, buildBlockMode);
         this.#inherentProvider = inherentProvider;
-        this.headState = new HeadState(this.#head);
+        this.headState = new head_state_1.HeadState(this.#head);
     }
     #registerBlock(block) {
         this.#blocksByNumber[block.number] = block;
@@ -52,7 +55,7 @@ export class Blockchain {
         }
         if (!this.#blocksByNumber[number]) {
             const hash = await this.api.getBlockHash(number);
-            const block = new Block(this, number, hash);
+            const block = new block_1.Block(this, number, hash);
             this.#registerBlock(block);
         }
         return this.#blocksByNumber[number];
@@ -71,7 +74,7 @@ export class Blockchain {
                 const loadingBlock = (async () => {
                     try {
                         const header = await this.api.getHeader(hash);
-                        const block = new Block(this, Number(header.number), hash);
+                        const block = new block_1.Block(this, Number(header.number), hash);
                         this.#registerBlock(block);
                     }
                     catch (e) {
@@ -105,13 +108,13 @@ export class Blockchain {
     }
     async submitExtrinsic(extrinsic) {
         const source = '0x02'; // External
-        const args = u8aToHex(u8aConcat(source, extrinsic, this.head.hash));
+        const args = (0, util_1.u8aToHex)((0, util_1.u8aConcat)(source, extrinsic, this.head.hash));
         const res = await this.head.call('TaggedTransactionQueue_validate_transaction', [args]);
         const registry = await this.head.registry;
         const validity = registry.createType('TransactionValidity', res.result);
         if (validity.isOk) {
             await this.#txpool.submitExtrinsic(extrinsic);
-            return blake2AsHex(extrinsic, 256);
+            return (0, util_crypto_1.blake2AsHex)(extrinsic, 256);
         }
         throw validity.asErr;
     }
@@ -151,7 +154,7 @@ export class Blockchain {
             upwardMessages: [],
             horizontalMessages: {},
         });
-        const { result, storageDiff } = await dryRunExtrinsic(head, inherents, extrinsic);
+        const { result, storageDiff } = await (0, block_builder_1.dryRunExtrinsic)(head, inherents, extrinsic);
         const outcome = registry.createType('ApplyExtrinsicResult', result);
         return { outcome, storageDiff };
     }
@@ -167,7 +170,7 @@ export class Blockchain {
             upwardMessages: [],
             horizontalMessages: hrmp,
         });
-        return dryRunInherents(head, inherents);
+        return (0, block_builder_1.dryRunInherents)(head, inherents);
     }
     async dryRunDmp(dmp, at) {
         await this.api.isReady;
@@ -181,7 +184,7 @@ export class Blockchain {
             upwardMessages: [],
             horizontalMessages: {},
         });
-        return dryRunInherents(head, inherents);
+        return (0, block_builder_1.dryRunInherents)(head, inherents);
     }
     async dryRunUmp(ump, at) {
         await this.api.isReady;
@@ -192,7 +195,7 @@ export class Blockchain {
         const meta = await head.meta;
         const needsDispatch = meta.registry.createType('Vec<u32>', Object.keys(ump));
         const stroageValues = [
-            [compactHex(meta.query.ump.needsDispatch()), needsDispatch.toHex()],
+            [(0, utils_1.compactHex)(meta.query.ump.needsDispatch()), needsDispatch.toHex()],
         ];
         for (const [paraId, messages] of Object.entries(ump)) {
             const upwardMessages = meta.registry.createType('Vec<Bytes>', messages);
@@ -202,8 +205,8 @@ export class Blockchain {
                 upwardMessages.length,
                 upwardMessages.map((x) => x.byteLength).reduce((s, i) => s + i, 0),
             ]);
-            stroageValues.push([compactHex(meta.query.ump.relayDispatchQueues(paraId)), upwardMessages.toHex()]);
-            stroageValues.push([compactHex(meta.query.ump.relayDispatchQueueSize(paraId)), queueSize.toHex()]);
+            stroageValues.push([(0, utils_1.compactHex)(meta.query.ump.relayDispatchQueues(paraId)), upwardMessages.toHex()]);
+            stroageValues.push([(0, utils_1.compactHex)(meta.query.ump.relayDispatchQueueSize(paraId)), queueSize.toHex()]);
         }
         head.pushStorageLayer().setAll(stroageValues);
         const inherents = await this.#inherentProvider.createInherents(head, {
@@ -212,7 +215,7 @@ export class Blockchain {
             upwardMessages: [],
             horizontalMessages: {},
         });
-        return dryRunInherents(head, inherents);
+        return (0, block_builder_1.dryRunInherents)(head, inherents);
     }
     async getInherents() {
         await this.api.isReady;
@@ -225,3 +228,4 @@ export class Blockchain {
         return inherents;
     }
 }
+exports.Blockchain = Blockchain;

package/lib/blockchain/inherent/index.js

@@ -1,18 +1,26 @@
-import { GenericExtrinsic } from '@polkadot/types';
-import { getCurrentTimestamp, getSlotDuration } from '../../utils/time-travel';
-export { SetValidationData } from './parachain/validation-data';
-export { ParaInherentEnter } from './para-enter';
-export { SetBabeRandomness } from './parachain/babe-randomness';
-export { SetNimbusAuthorInherent } from './parachain/nimbus-author-inherent';
-export class SetTimestamp {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InherentProviders = exports.SetTimestamp = exports.SetNimbusAuthorInherent = exports.SetBabeRandomness = exports.ParaInherentEnter = exports.SetValidationData = void 0;
+const types_1 = require("@polkadot/types");
+const time_travel_1 = require("../../utils/time-travel");
+var validation_data_1 = require("./parachain/validation-data");
+Object.defineProperty(exports, "SetValidationData", { enumerable: true, get: function () { return validation_data_1.SetValidationData; } });
+var para_enter_1 = require("./para-enter");
+Object.defineProperty(exports, "ParaInherentEnter", { enumerable: true, get: function () { return para_enter_1.ParaInherentEnter; } });
+var babe_randomness_1 = require("./parachain/babe-randomness");
+Object.defineProperty(exports, "SetBabeRandomness", { enumerable: true, get: function () { return babe_randomness_1.SetBabeRandomness; } });
+var nimbus_author_inherent_1 = require("./parachain/nimbus-author-inherent");
+Object.defineProperty(exports, "SetNimbusAuthorInherent", { enumerable: true, get: function () { return nimbus_author_inherent_1.SetNimbusAuthorInherent; } });
+class SetTimestamp {
     async createInherents(parent) {
         const meta = await parent.meta;
-        const slotDuration = await getSlotDuration(parent.chain);
-        const currentTimestamp = await getCurrentTimestamp(parent.chain);
-        return [new GenericExtrinsic(meta.registry, meta.tx.timestamp.set(currentTimestamp + slotDuration)).toHex()];
+        const slotDuration = await (0, time_travel_1.getSlotDuration)(parent.chain);
+        const currentTimestamp = await (0, time_travel_1.getCurrentTimestamp)(parent.chain);
+        return [new types_1.GenericExtrinsic(meta.registry, meta.tx.timestamp.set(currentTimestamp + slotDuration)).toHex()];
     }
 }
-export class InherentProviders {
+exports.SetTimestamp = SetTimestamp;
+class InherentProviders {
     #base;
     #providers;
     constructor(base, providers) {
@@ -25,3 +33,4 @@ export class InherentProviders {
         return [...base, ...extra.flat()];
     }
 }
+exports.InherentProviders = InherentProviders;

package/lib/blockchain/inherent/para-enter.js

@@ -1,5 +1,8 @@
-import { GenericExtrinsic } from '@polkadot/types';
-export class ParaInherentEnter {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParaInherentEnter = void 0;
+const types_1 = require("@polkadot/types");
+class ParaInherentEnter {
     async createInherents(parent, _params) {
         const meta = await parent.meta;
         if (!meta.tx.paraInherent?.enter) {
@@ -24,6 +27,7 @@ export class ParaInherentEnter {
             parentHeader,
         };
         // TODO: fill with data
-        return [new GenericExtrinsic(meta.registry, meta.tx.paraInherent.enter(newData)).toHex()];
+        return [new types_1.GenericExtrinsic(meta.registry, meta.tx.paraInherent.enter(newData)).toHex()];
     }
 }
+exports.ParaInherentEnter = ParaInherentEnter;

package/lib/blockchain/inherent/parachain/babe-randomness.js

@@ -1,11 +1,15 @@
-import { GenericExtrinsic } from '@polkadot/types';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetBabeRandomness = void 0;
+const types_1 = require("@polkadot/types");
 // Support for Moonbeam pallet-randomness mandatory inherent
-export class SetBabeRandomness {
+class SetBabeRandomness {
     async createInherents(parent, _params) {
         const meta = await parent.meta;
         if (!meta.tx.randomness?.setBabeRandomnessResults) {
             return [];
         }
-        return [new GenericExtrinsic(meta.registry, meta.tx.randomness.setBabeRandomnessResults()).toHex()];
+        return [new types_1.GenericExtrinsic(meta.registry, meta.tx.randomness.setBabeRandomnessResults()).toHex()];
     }
 }
+exports.SetBabeRandomness = SetBabeRandomness;

package/lib/blockchain/inherent/parachain/nimbus-author-inherent.js

@@ -1,11 +1,15 @@
-import { GenericExtrinsic } from '@polkadot/types';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetNimbusAuthorInherent = void 0;
+const types_1 = require("@polkadot/types");
 // Support for Nimbus Author Inherent
-export class SetNimbusAuthorInherent {
+class SetNimbusAuthorInherent {
     async createInherents(parent, _params) {
         const meta = await parent.meta;
         if (!meta.tx.authorInherent?.kickOffAuthorshipValidation) {
             return [];
         }
-        return [new GenericExtrinsic(meta.registry, meta.tx.authorInherent.kickOffAuthorshipValidation()).toHex()];
+        return [new types_1.GenericExtrinsic(meta.registry, meta.tx.authorInherent.kickOffAuthorshipValidation()).toHex()];
     }
 }
+exports.SetNimbusAuthorInherent = SetNimbusAuthorInherent;