@acala-network/chopsticks 0.5.5 → 0.5.6

package/lib/blockchain/inherent/parachain/validation-data.js

@@ -1,10 +1,16 @@
-import { GenericExtrinsic } from '@polkadot/types';
-import { hexToU8a, u8aConcat } from '@polkadot/util';
-import _ from 'lodash';
-import { WELL_KNOWN_KEYS, dmqMqcHead, hrmpChannels, hrmpEgressChannelIndex, hrmpIngressChannelIndex, upgradeGoAheadSignal, } from '../../../utils/proof';
-import { blake2AsHex, blake2AsU8a } from '@polkadot/util-crypto';
-import { compactHex, getParaId } from '../../../utils';
-import { createProof, decodeProof } from '../../../executor';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetValidationData = void 0;
+const types_1 = require("@polkadot/types");
+const util_1 = require("@polkadot/util");
+const lodash_1 = __importDefault(require("lodash"));
+const proof_1 = require("../../../utils/proof");
+const util_crypto_1 = require("@polkadot/util-crypto");
+const utils_1 = require("../../../utils");
+const executor_1 = require("../../../executor");
 const MOCK_VALIDATION_DATA = {
     validationData: {
         relayParentNumber: 1000,
@@ -29,7 +35,7 @@ const MOCK_VALIDATION_DATA = {
         ],
     },
 };
-export class SetValidationData {
+class SetValidationData {
     async createInherents(parent, params) {
         const meta = await parent.meta;
         if (!meta.tx.parachainSystem?.setValidationData) {
@@ -55,13 +61,13 @@ export class SetValidationData {
             const newEntries = [];
             const downwardMessages = [];
             const horizontalMessages = {};
-            const paraId = await getParaId(parent.chain);
-            const dmqMqcHeadKey = dmqMqcHead(paraId);
-            const hrmpIngressChannelIndexKey = hrmpIngressChannelIndex(paraId);
-            const hrmpEgressChannelIndexKey = hrmpEgressChannelIndex(paraId);
+            const paraId = await (0, utils_1.getParaId)(parent.chain);
+            const dmqMqcHeadKey = (0, proof_1.dmqMqcHead)(paraId);
+            const hrmpIngressChannelIndexKey = (0, proof_1.hrmpIngressChannelIndex)(paraId);
+            const hrmpEgressChannelIndexKey = (0, proof_1.hrmpEgressChannelIndex)(paraId);
             // TODO: refactor this to have a single decodeProof
-            const decoded = await decodeProof(extrinsic.validationData.relayParentStorageRoot, [...Object.values(WELL_KNOWN_KEYS), dmqMqcHeadKey, hrmpIngressChannelIndexKey, hrmpEgressChannelIndexKey], extrinsic.relayChainState.trieNodes);
-            for (const key of Object.values(WELL_KNOWN_KEYS)) {
+            const decoded = await (0, executor_1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, [...Object.values(proof_1.WELL_KNOWN_KEYS), dmqMqcHeadKey, hrmpIngressChannelIndexKey, hrmpEgressChannelIndexKey], extrinsic.relayChainState.trieNodes);
+            for (const key of Object.values(proof_1.WELL_KNOWN_KEYS)) {
                 newEntries.push([key, decoded[key]]);
             }
             newEntries.push([hrmpIngressChannelIndexKey, decoded[hrmpIngressChannelIndexKey]]);
@@ -71,7 +77,7 @@ export class SetValidationData {
             if (dmqMqcHeadHash) {
                 for (const { msg, sentAt } of params.downwardMessages) {
                     // calculate new hash
-                    dmqMqcHeadHash = blake2AsHex(u8aConcat(meta.registry.createType('Hash', dmqMqcHeadHash).toU8a(), meta.registry.createType('BlockNumber', sentAt).toU8a(), blake2AsU8a(meta.registry.createType('Bytes', msg).toU8a(), 256)), 256);
+                    dmqMqcHeadHash = (0, util_crypto_1.blake2AsHex)((0, util_1.u8aConcat)(meta.registry.createType('Hash', dmqMqcHeadHash).toU8a(), meta.registry.createType('BlockNumber', sentAt).toU8a(), (0, util_crypto_1.blake2AsU8a)(meta.registry.createType('Bytes', msg).toU8a(), 256)), 256);
                     downwardMessages.push({
                         msg,
                         sentAt,
@@ -87,7 +93,7 @@ export class SetValidationData {
                 .toJSON();
             const hrmpMessages = {
                 // reset values, we just need the keys
-                ..._.mapValues(extrinsic.horizontalMessages, () => []),
+                ...lodash_1.default.mapValues(extrinsic.horizontalMessages, () => []),
                 ...params.horizontalMessages,
             };
             // inject horizontal messages
@@ -98,19 +104,19 @@ export class SetValidationData {
                     sender,
                     receiver: paraId.toNumber(),
                 });
-                const hrmpChannelKey = hrmpChannels(channelId);
-                const decoded = await decodeProof(extrinsic.validationData.relayParentStorageRoot, [hrmpChannelKey], extrinsic.relayChainState.trieNodes);
+                const hrmpChannelKey = (0, proof_1.hrmpChannels)(channelId);
+                const decoded = await (0, executor_1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, [hrmpChannelKey], extrinsic.relayChainState.trieNodes);
                 const abridgedHrmpRaw = decoded[hrmpChannelKey];
                 if (!abridgedHrmpRaw)
                     throw new Error('Canoot find hrmp channels from validation data');
                 const abridgedHrmp = meta.registry
-                    .createType('AbridgedHrmpChannel', hexToU8a(abridgedHrmpRaw))
+                    .createType('AbridgedHrmpChannel', (0, util_1.hexToU8a)(abridgedHrmpRaw))
                     .toJSON();
                 const paraMessages = [];
                 for (const { data, sentAt } of messages) {
                     // calculate new hash
                     const bytes = meta.registry.createType('Bytes', data);
-                    abridgedHrmp.mqcHead = blake2AsHex(u8aConcat(meta.registry.createType('Hash', abridgedHrmp.mqcHead).toU8a(), meta.registry.createType('BlockNumber', sentAt).toU8a(), blake2AsU8a(bytes.toU8a(), 256)), 256);
+                    abridgedHrmp.mqcHead = (0, util_crypto_1.blake2AsHex)((0, util_1.u8aConcat)(meta.registry.createType('Hash', abridgedHrmp.mqcHead).toU8a(), meta.registry.createType('BlockNumber', sentAt).toU8a(), (0, util_crypto_1.blake2AsU8a)(bytes.toU8a(), 256)), 256);
                     abridgedHrmp.msgCount = abridgedHrmp.msgCount + 1;
                     abridgedHrmp.totalSize = abridgedHrmp.totalSize + bytes.length;
                     paraMessages.push({
@@ -129,12 +135,12 @@ export class SetValidationData {
                     sender: paraId.toNumber(),
                     receiver,
                 });
-                const hrmpChannelKey = hrmpChannels(channelId);
-                const decoded = await decodeProof(extrinsic.validationData.relayParentStorageRoot, [hrmpChannelKey], extrinsic.relayChainState.trieNodes);
+                const hrmpChannelKey = (0, proof_1.hrmpChannels)(channelId);
+                const decoded = await (0, executor_1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, [hrmpChannelKey], extrinsic.relayChainState.trieNodes);
                 newEntries.push([hrmpChannelKey, decoded[hrmpChannelKey]]);
             }
-            const upgradeKey = upgradeGoAheadSignal(paraId);
-            const pendingUpgrade = await parent.get(compactHex(meta.query.parachainSystem.pendingValidationCode()));
+            const upgradeKey = (0, proof_1.upgradeGoAheadSignal)(paraId);
+            const pendingUpgrade = await parent.get((0, utils_1.compactHex)(meta.query.parachainSystem.pendingValidationCode()));
             if (pendingUpgrade) {
                 // send goAhead signal
                 const goAhead = meta.registry.createType('UpgradeGoAhead', 'GoAhead');
@@ -144,7 +150,7 @@ export class SetValidationData {
                 // make sure previous goAhead is removed
                 newEntries.push([upgradeKey, null]);
             }
-            const { trieRootHash, nodes } = await createProof(extrinsic.validationData.relayParentStorageRoot, extrinsic.relayChainState.trieNodes, newEntries);
+            const { trieRootHash, nodes } = await (0, executor_1.createProof)(extrinsic.validationData.relayParentStorageRoot, extrinsic.relayChainState.trieNodes, newEntries);
             newData = {
                 ...extrinsic,
                 downwardMessages,
@@ -159,7 +165,8 @@ export class SetValidationData {
                 },
             };
         }
-        const inherent = new GenericExtrinsic(meta.registry, meta.tx.parachainSystem.setValidationData(newData));
+        const inherent = new types_1.GenericExtrinsic(meta.registry, meta.tx.parachainSystem.setValidationData(newData));
         return [inherent.toHex()];
     }
 }
+exports.SetValidationData = SetValidationData;

package/lib/blockchain/storage-layer.js

@@ -1,7 +1,13 @@
-import _ from 'lodash';
-import { defaultLogger } from '../logger';
-const logger = defaultLogger.child({ name: 'layer' });
-export class RemoteStorageLayer {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageLayer = exports.RemoteStorageLayer = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const logger_1 = require("../logger");
+const logger = logger_1.defaultLogger.child({ name: 'layer' });
+class RemoteStorageLayer {
     #api;
     #at;
     #db;
@@ -31,7 +37,8 @@ export class RemoteStorageLayer {
         return this.#api.getKeysPaged(prefix, pageSize, startKey, this.#at);
     }
 }
-export class StorageLayer {
+exports.RemoteStorageLayer = RemoteStorageLayer;
+class StorageLayer {
     #store = {};
     #keys = [];
     #deletedPrefix = [];
@@ -40,7 +47,7 @@ export class StorageLayer {
         this.#parent = parent;
     }
     #addKey(key) {
-        const idx = _.sortedIndex(this.#keys, key);
+        const idx = lodash_1.default.sortedIndex(this.#keys, key);
         const key2 = this.#keys[idx];
         if (key === key2) {
             return;
@@ -48,7 +55,7 @@ export class StorageLayer {
         this.#keys.splice(idx, 0, key);
     }
     #removeKey(key) {
-        const idx = _.sortedIndex(this.#keys, key);
+        const idx = lodash_1.default.sortedIndex(this.#keys, key);
         const key2 = this.#keys[idx];
         if (key === key2) {
             this.#keys.splice(idx, 1);
@@ -130,7 +137,7 @@ export class StorageLayer {
                 this.#addKey(key);
             }
         }
-        let idx = _.sortedIndex(this.#keys, startKey);
+        let idx = lodash_1.default.sortedIndex(this.#keys, startKey);
         if (this.#keys[idx] === startKey) {
             ++idx;
         }
@@ -157,3 +164,4 @@ export class StorageLayer {
         }
     }
 }
+exports.StorageLayer = StorageLayer;

package/lib/blockchain/txpool.js

@@ -1,15 +1,21 @@
-import { EventEmitter } from 'node:stream';
-import _ from 'lodash';
-import { defer } from '../utils';
-import { buildBlock } from './block-builder';
-export const APPLY_EXTRINSIC_ERROR = 'TxPool::ApplyExtrinsicError';
-export var BuildBlockMode;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxPool = exports.BuildBlockMode = exports.APPLY_EXTRINSIC_ERROR = void 0;
+const node_stream_1 = require("node:stream");
+const lodash_1 = __importDefault(require("lodash"));
+const utils_1 = require("../utils");
+const block_builder_1 = require("./block-builder");
+exports.APPLY_EXTRINSIC_ERROR = 'TxPool::ApplyExtrinsicError';
+var BuildBlockMode;
 (function (BuildBlockMode) {
     BuildBlockMode[BuildBlockMode["Batch"] = 0] = "Batch";
     BuildBlockMode[BuildBlockMode["Instant"] = 1] = "Instant";
     BuildBlockMode[BuildBlockMode["Manual"] = 2] = "Manual";
-})(BuildBlockMode || (BuildBlockMode = {}));
-export class TxPool {
+})(BuildBlockMode = exports.BuildBlockMode || (exports.BuildBlockMode = {}));
+class TxPool {
     #chain;
     #pool = [];
     #ump = {};
@@ -18,7 +24,7 @@ export class TxPool {
     #mode;
     #inherentProvider;
     #pendingBlocks = [];
-    event = new EventEmitter();
+    event = new node_stream_1.EventEmitter();
     #isBuilding = false;
     constructor(chain, inherentProvider, mode = BuildBlockMode.Batch) {
         this.#chain = chain;
@@ -71,11 +77,11 @@ export class TxPool {
                 break;
         }
     }
-    #batchBuildBlock = _.debounce(this.buildBlock, 100, { maxWait: 1000 });
+    #batchBuildBlock = lodash_1.default.debounce(this.buildBlock, 100, { maxWait: 1000 });
     async buildBlockWithParams(params) {
         this.#pendingBlocks.push({
             params,
-            deferred: defer(),
+            deferred: (0, utils_1.defer)(),
         });
         this.#buildBlockIfNeeded();
         await this.upcomingBlocks();
@@ -132,8 +138,8 @@ export class TxPool {
         const { params, deferred } = pending;
         const head = this.#chain.head;
         const inherents = await this.#inherentProvider.createInherents(head, params);
-        const [newBlock, pendingExtrinsics] = await buildBlock(head, inherents, params.transactions, params.upwardMessages, (extrinsic, error) => {
-            this.event.emit(APPLY_EXTRINSIC_ERROR, [extrinsic, error]);
+        const [newBlock, pendingExtrinsics] = await (0, block_builder_1.buildBlock)(head, inherents, params.transactions, params.upwardMessages, (extrinsic, error) => {
+            this.event.emit(exports.APPLY_EXTRINSIC_ERROR, [extrinsic, error]);
         });
         for (const extrinsic of pendingExtrinsics) {
             this.#pool.push({ extrinsic, signer: await this.#getSigner(extrinsic) });
@@ -143,3 +149,4 @@ export class TxPool {
         deferred.resolve();
     }
 }
+exports.TxPool = TxPool;

package/lib/cli.js

@@ -1,25 +1,30 @@
-import { hideBin } from 'yargs/helpers';
-import { readFileSync } from 'node:fs';
-import axios from 'axios';
-import yaml from 'js-yaml';
-import yargs from 'yargs';
-import { BuildBlockMode, connectParachains, connectVertical, setup, setupWithServer } from '.';
-import { configSchema } from './schema';
-import { decodeKey } from './utils/decoder';
-import { dryRun } from './dry-run';
-import { dryRunPreimage } from './dry-run-preimage';
-import { isUrl } from './utils';
-import { runBlock } from './run-block';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("yargs/helpers");
+const node_fs_1 = require("node:fs");
+const axios_1 = __importDefault(require("axios"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const yargs_1 = __importDefault(require("yargs"));
+const _1 = require(".");
+const schema_1 = require("./schema");
+const decoder_1 = require("./utils/decoder");
+const dry_run_1 = require("./dry-run");
+const dry_run_preimage_1 = require("./dry-run-preimage");
+const utils_1 = require("./utils");
+const run_block_1 = require("./run-block");
 const processConfig = async (path) => {
     let file;
-    if (isUrl(path)) {
-        file = await axios.get(path).then((x) => x.data);
+    if ((0, utils_1.isUrl)(path)) {
+        file = await axios_1.default.get(path).then((x) => x.data);
     }
     else {
-        file = readFileSync(path, 'utf8');
+        file = (0, node_fs_1.readFileSync)(path, 'utf8');
     }
-    const config = yaml.load(file);
-    return configSchema.parse(config);
+    const config = js_yaml_1.default.load(file);
+    return schema_1.configSchema.parse(config);
 };
 const processArgv = async (argv) => {
     if (argv.config) {
@@ -50,7 +55,7 @@ const defaultOptions = {
         string: true,
     },
 };
-yargs(hideBin(process.argv))
+(0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
     .scriptName('chopsticks')
     .command('run-block', 'Replay a block', (yargs) => yargs.options({
     ...defaultOptions,
@@ -69,7 +74,7 @@ yargs(hideBin(process.argv))
         desc: 'Open generated html',
     },
 }), async (argv) => {
-    await runBlock(await processArgv(argv));
+    await (0, run_block_1.runBlock)(await processArgv(argv));
 })
     .command('dry-run', 'Dry run an extrinsic', (yargs) => yargs.options({
     ...defaultOptions,
@@ -102,10 +107,10 @@ yargs(hideBin(process.argv))
 }), async (argv) => {
     const config = await processArgv(argv);
     if (config.preimage) {
-        await dryRunPreimage(config);
+        await (0, dry_run_preimage_1.dryRunPreimage)(config);
     }
     else {
-        await dryRun(config);
+        await (0, dry_run_1.dryRun)(config);
     }
 })
     .command('dev', 'Dev mode', (yargs) => yargs.options({
@@ -116,7 +121,7 @@ yargs(hideBin(process.argv))
     },
     'build-block-mode': {
         desc: 'Build block mode. Default to Batch',
-        enum: [BuildBlockMode.Batch, BuildBlockMode.Manual, BuildBlockMode.Instant],
+        enum: [_1.BuildBlockMode.Batch, _1.BuildBlockMode.Manual, _1.BuildBlockMode.Instant],
     },
     'import-storage': {
         desc: 'Pre-defined JSON/YAML storage file path',
@@ -131,7 +136,7 @@ yargs(hideBin(process.argv))
         boolean: true,
     },
 }), async (argv) => {
-    await setupWithServer(await processArgv(argv));
+    await (0, _1.setupWithServer)(await processArgv(argv));
 })
     .command('decode-key <key>', 'Deocde a key', (yargs) => yargs
     .positional('key', {
@@ -141,8 +146,8 @@ yargs(hideBin(process.argv))
     .options({
     ...defaultOptions,
 }), async (argv) => {
-    const context = await setup(await processArgv(argv));
-    const { storage, decodedKey } = decodeKey(await context.chain.head.meta, context.chain.head, argv.key);
+    const context = await (0, _1.setup)(await processArgv(argv));
+    const { storage, decodedKey } = (0, decoder_1.decodeKey)(await context.chain.head.meta, context.chain.head, argv.key);
     if (storage && decodedKey) {
         console.log(`${storage.section}.${storage.method}`, decodedKey.args.map((x) => JSON.stringify(x.toHuman())).join(', '));
     }
@@ -165,23 +170,23 @@ yargs(hideBin(process.argv))
 }), async (argv) => {
     const parachains = [];
     for (const config of argv.parachain) {
-        const { chain } = await setupWithServer(await processConfig(config));
+        const { chain } = await (0, _1.setupWithServer)(await processConfig(config));
         parachains.push(chain);
     }
     if (parachains.length > 1) {
-        await connectParachains(parachains);
+        await (0, _1.connectParachains)(parachains);
     }
     if (argv.relaychain) {
-        const { chain: relaychain } = await setupWithServer(await processConfig(argv.relaychain));
+        const { chain: relaychain } = await (0, _1.setupWithServer)(await processConfig(argv.relaychain));
         for (const parachain of parachains) {
-            await connectVertical(relaychain, parachain);
+            await (0, _1.connectVertical)(relaychain, parachain);
         }
     }
 })
     .command({
     command: '*',
     handler() {
-        yargs.showHelp();
+        yargs_1.default.showHelp();
     },
 })
     .strict()

package/lib/db/entities.js

@@ -1,3 +1,4 @@
+"use strict";
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -7,25 +8,27 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Column, Entity, PrimaryColumn } from 'typeorm';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyValuePair = void 0;
+const typeorm_1 = require("typeorm");
 let KeyValuePair = class KeyValuePair {
     blockHash;
     key;
     value;
 };
 __decorate([
-    PrimaryColumn(),
+    (0, typeorm_1.PrimaryColumn)(),
     __metadata("design:type", String)
 ], KeyValuePair.prototype, "blockHash", void 0);
 __decorate([
-    PrimaryColumn(),
+    (0, typeorm_1.PrimaryColumn)(),
     __metadata("design:type", String)
 ], KeyValuePair.prototype, "key", void 0);
 __decorate([
-    Column({ nullable: true }),
+    (0, typeorm_1.Column)({ nullable: true }),
     __metadata("design:type", String)
 ], KeyValuePair.prototype, "value", void 0);
 KeyValuePair = __decorate([
-    Entity()
+    (0, typeorm_1.Entity)()
 ], KeyValuePair);
-export { KeyValuePair };
+exports.KeyValuePair = KeyValuePair;

package/lib/db/index.js

@@ -1,8 +1,34 @@
-import 'reflect-metadata';
-import { DataSource } from 'typeorm';
-import * as entities from './entities';
-export const openDb = async (dbPath) => {
-    const source = new DataSource({
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openDb = void 0;
+require("reflect-metadata");
+const typeorm_1 = require("typeorm");
+const entities = __importStar(require("./entities"));
+const openDb = async (dbPath) => {
+    const source = new typeorm_1.DataSource({
         type: 'sqlite',
         database: dbPath,
         entities: Object.values(entities),
@@ -12,3 +38,4 @@ export const openDb = async (dbPath) => {
     await source.initialize();
     return source;
 };
+exports.openDb = openDb;

package/lib/dry-run-preimage.js

@@ -1,21 +1,24 @@
-import { blake2AsHex } from '@polkadot/util-crypto';
-import { hexToU8a } from '@polkadot/util';
-import { defaultLogger } from './logger';
-import { generateHtmlDiffPreviewFile } from './utils/generate-html-diff';
-import { newHeader } from './blockchain/block-builder';
-import { openHtml } from './utils/open-html';
-import { runTask, taskHandler } from './executor';
-import { setStorage } from './utils/set-storage';
-import { setup } from './setup';
-export const dryRunPreimage = async (argv) => {
-    const context = await setup(argv);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dryRunPreimage = void 0;
+const util_crypto_1 = require("@polkadot/util-crypto");
+const util_1 = require("@polkadot/util");
+const logger_1 = require("./logger");
+const generate_html_diff_1 = require("./utils/generate-html-diff");
+const block_builder_1 = require("./blockchain/block-builder");
+const open_html_1 = require("./utils/open-html");
+const executor_1 = require("./executor");
+const set_storage_1 = require("./utils/set-storage");
+const setup_1 = require("./setup");
+const dryRunPreimage = async (argv) => {
+    const context = await (0, setup_1.setup)(argv);
     const extrinsic = argv['preimage'];
     const block = context.chain.head;
     const registry = await block.registry;
-    const header = await newHeader(block);
-    const data = hexToU8a(extrinsic);
-    const hash = blake2AsHex(data, 256);
-    await setStorage(context.chain, {
+    const header = await (0, block_builder_1.newHeader)(block);
+    const data = (0, util_1.hexToU8a)(extrinsic);
+    const hash = (0, util_crypto_1.blake2AsHex)(data, 256);
+    await (0, set_storage_1.setStorage)(context.chain, {
         Preimage: {
             PreimageFor: [[[[hash, data.byteLength]], extrinsic]],
             StatusFor: [
@@ -57,21 +60,21 @@ export const dryRunPreimage = async (argv) => {
         calls.push(['BlockBuilder_apply_extrinsic', [inherent]]);
     }
     calls.push(['BlockBuilder_finalize_block', []]);
-    defaultLogger.info({ preimage: registry.createType('Call', data).toHuman() }, 'Dry run preimage');
-    const result = await runTask({
+    logger_1.defaultLogger.info({ preimage: registry.createType('Call', data).toHuman() }, 'Dry run preimage');
+    const result = await (0, executor_1.runTask)({
         wasm: await block.wasm,
         calls,
         storage: [],
         mockSignatureHost: false,
         allowUnresolvedImports: false,
-    }, taskHandler(block));
+    }, (0, executor_1.taskHandler)(block));
     if (result.Error) {
         throw new Error(result.Error);
     }
-    const filePath = await generateHtmlDiffPreviewFile(block, result.Call.storageDiff, hash);
+    const filePath = await (0, generate_html_diff_1.generateHtmlDiffPreviewFile)(block, result.Call.storageDiff, hash);
     console.log(`Generated preview ${filePath}`);
     if (argv['open']) {
-        openHtml(filePath);
+        (0, open_html_1.openHtml)(filePath);
     }
     // if dry-run preimage has extrinsic arguments then dry-run extrinsic
     // this is usefull to test something after preimage is applied
@@ -83,13 +86,14 @@ export const dryRunPreimage = async (argv) => {
             throw new Error(outcome.asErr.toString());
         }
         else {
-            defaultLogger.info(outcome.toHuman(), 'dry_run_outcome');
+            logger_1.defaultLogger.info(outcome.toHuman(), 'dry_run_outcome');
         }
-        const filePath = await generateHtmlDiffPreviewFile(context.chain.head, storageDiff, blake2AsHex(argv['extrinsic'], 256));
+        const filePath = await (0, generate_html_diff_1.generateHtmlDiffPreviewFile)(context.chain.head, storageDiff, (0, util_crypto_1.blake2AsHex)(argv['extrinsic'], 256));
         console.log(`Generated preview ${filePath}`);
         if (argv['open']) {
-            openHtml(filePath);
+            (0, open_html_1.openHtml)(filePath);
         }
     }
     process.exit(0);
 };
+exports.dryRunPreimage = dryRunPreimage;

package/lib/dry-run.js

@@ -1,31 +1,35 @@
-import { blake2AsHex } from '@polkadot/util-crypto';
-import { writeFileSync } from 'node:fs';
-import { defaultLogger } from './logger';
-import { generateHtmlDiffPreviewFile } from './utils/generate-html-diff';
-import { openHtml } from './utils/open-html';
-import { setup } from './setup';
-export const dryRun = async (argv) => {
-    const context = await setup(argv);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dryRun = void 0;
+const util_crypto_1 = require("@polkadot/util-crypto");
+const node_fs_1 = require("node:fs");
+const logger_1 = require("./logger");
+const generate_html_diff_1 = require("./utils/generate-html-diff");
+const open_html_1 = require("./utils/open-html");
+const setup_1 = require("./setup");
+const dryRun = async (argv) => {
+    const context = await (0, setup_1.setup)(argv);
     const input = argv['address'] ? { call: argv['extrinsic'], address: argv['address'] } : argv['extrinsic'];
     const { outcome, storageDiff } = await context.chain.dryRunExtrinsic(input, argv['at']);
     if (outcome.isErr) {
         throw new Error(outcome.asErr.toString());
     }
     else {
-        defaultLogger.info(outcome.toHuman(), 'dry_run_outcome');
+        logger_1.defaultLogger.info(outcome.toHuman(), 'dry_run_outcome');
     }
     if (argv['html']) {
-        const filePath = await generateHtmlDiffPreviewFile(context.chain.head, storageDiff, blake2AsHex(argv['extrinsic'], 256));
+        const filePath = await (0, generate_html_diff_1.generateHtmlDiffPreviewFile)(context.chain.head, storageDiff, (0, util_crypto_1.blake2AsHex)(argv['extrinsic'], 256));
         console.log(`Generated preview ${filePath}`);
         if (argv['open']) {
-            openHtml(filePath);
+            (0, open_html_1.openHtml)(filePath);
         }
     }
     else if (argv['output-path']) {
-        writeFileSync(argv['output-path'], JSON.stringify({ outcome: outcome.toHuman(), storageDiff }, null, 2));
+        (0, node_fs_1.writeFileSync)(argv['output-path'], JSON.stringify({ outcome: outcome.toHuman(), storageDiff }, null, 2));
     }
     else {
         console.dir({ outcome: outcome.toHuman(), storageDiff }, { depth: null, colors: false });
     }
     process.exit(0);
 };
+exports.dryRun = dryRun;