@acala-network/chopsticks 0.5.3 → 0.5.5

package/lib/rpc/substrate/system.js

@@ -1,11 +1,6 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("@polkadot/util");
-const node_fs_1 = require("node:fs");
-const node_path_1 = __importDefault(require("node:path"));
+import { hexToU8a } from '@polkadot/util';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
 const handlers = {
     system_localPeerId: async () => '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
     system_nodeRoles: async () => ['Full'],
@@ -20,7 +15,7 @@ const handlers = {
         return context.chain.api.getSystemName();
     },
     system_version: async (_context) => {
-        const { version } = JSON.parse((0, node_fs_1.readFileSync)(node_path_1.default.join(__dirname, '../../../package.json'), 'utf-8'));
+        const { version } = JSON.parse(readFileSync(path.join(__dirname, '../../../package.json'), 'utf-8'));
         return `chopsticks-v${version}`;
     },
     system_chainType: async (_context) => {
@@ -42,8 +37,8 @@ const handlers = {
         const registry = await head.registry;
         const account = registry.createType('AccountId', address);
         const result = await head.call('AccountNonceApi_account_nonce', [account.toHex()]);
-        const nonce = registry.createType('Index', (0, util_1.hexToU8a)(result.result)).toNumber();
+        const nonce = registry.createType('Index', hexToU8a(result.result)).toNumber();
         return nonce + context.chain.txPool.pendingExtrinsicsBy(address).length;
     },
 };
-exports.default = handlers;
+export default handlers;

package/lib/run-block.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runBlock = void 0;
-const node_fs_1 = require("node:fs");
-const generate_html_diff_1 = require("./utils/generate-html-diff");
-const open_html_1 = require("./utils/open-html");
-const executor_1 = require("./executor");
-const setup_1 = require("./setup");
-const runBlock = async (argv) => {
-    const context = await (0, setup_1.setup)(argv);
+import { writeFileSync } from 'node:fs';
+import { generateHtmlDiffPreviewFile } from './utils/generate-html-diff';
+import { openHtml } from './utils/open-html';
+import { runTask, taskHandler } from './executor';
+import { setup } from './setup';
+export const runBlock = async (argv) => {
+    const context = await setup(argv);
     const header = await context.chain.head.header;
     const wasm = await context.chain.head.wasm;
     const block = context.chain.head;
@@ -19,29 +16,28 @@ const runBlock = async (argv) => {
         calls.push(['BlockBuilder_apply_extrinsic', [extrinsic]]);
     }
     calls.push(['BlockBuilder_finalize_block', []]);
-    const result = await (0, executor_1.runTask)({
+    const result = await runTask({
         wasm,
         calls,
         storage: [],
         mockSignatureHost: false,
         allowUnresolvedImports: false,
-    }, (0, executor_1.taskHandler)(parent));
+    }, taskHandler(parent));
     if (result.Error) {
         throw new Error(result.Error);
     }
     if (argv['html']) {
-        const filePath = await (0, generate_html_diff_1.generateHtmlDiffPreviewFile)(parent, result.Call.storageDiff, block.hash);
+        const filePath = await generateHtmlDiffPreviewFile(parent, result.Call.storageDiff, block.hash);
         console.log(`Generated preview ${filePath}`);
         if (argv['open']) {
-            (0, open_html_1.openHtml)(filePath);
+            openHtml(filePath);
         }
     }
     else if (argv['output-path']) {
-        (0, node_fs_1.writeFileSync)(argv['output-path'], JSON.stringify(result, null, 2));
+        writeFileSync(argv['output-path'], JSON.stringify(result, null, 2));
     }
     else {
         console.dir(result, { depth: null, colors: false });
     }
     process.exit(0);
 };
-exports.runBlock = runBlock;

package/lib/schema/index.js

@@ -1,30 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.configSchema = exports.genesisSchema = void 0;
-const txpool_1 = require("../blockchain/txpool");
-const zod_1 = require("zod");
-exports.genesisSchema = zod_1.z.object({
-    id: zod_1.z.string(),
-    name: zod_1.z.string(),
-    properties: zod_1.z.object({
-        ss58Format: zod_1.z.number().optional(),
-        tokenDecimals: zod_1.z.union([zod_1.z.number(), zod_1.z.array(zod_1.z.number())]).optional(),
-        tokenSymbol: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional(),
+import { BuildBlockMode } from '../blockchain/txpool';
+import { z } from 'zod';
+export const genesisSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    properties: z.object({
+        ss58Format: z.number().optional(),
+        tokenDecimals: z.union([z.number(), z.array(z.number())]).optional(),
+        tokenSymbol: z.union([z.string(), z.array(z.string())]).optional(),
     }),
-    genesis: zod_1.z.object({ raw: zod_1.z.object({ top: zod_1.z.record(zod_1.z.string()) }) }),
+    genesis: z.object({ raw: z.object({ top: z.record(z.string()) }) }),
 });
-exports.configSchema = zod_1.z
+export const configSchema = z
     .object({
-    port: zod_1.z.number().optional(),
-    endpoint: zod_1.z.string().optional(),
-    block: zod_1.z.union([zod_1.z.string().length(66).startsWith('0x'), zod_1.z.number()]).optional(),
-    'build-block-mode': zod_1.z.nativeEnum(txpool_1.BuildBlockMode).optional(),
-    'import-storage': zod_1.z.any().optional(),
-    'mock-signature-host': zod_1.z.boolean().optional(),
-    db: zod_1.z.string().optional(),
-    'wasm-override': zod_1.z.string().optional(),
-    genesis: zod_1.z.union([zod_1.z.string(), exports.genesisSchema]).optional(),
-    timestamp: zod_1.z.number().optional(),
-    'registered-types': zod_1.z.any().optional(),
+    port: z.number().optional(),
+    endpoint: z.string().optional(),
+    block: z.union([z.string().length(66).startsWith('0x'), z.number()]).optional(),
+    'build-block-mode': z.nativeEnum(BuildBlockMode).optional(),
+    'import-storage': z.any().optional(),
+    'mock-signature-host': z.boolean().optional(),
+    db: z.string().optional(),
+    'wasm-override': z.string().optional(),
+    genesis: z.union([z.string(), genesisSchema]).optional(),
+    timestamp: z.number().optional(),
+    'registered-types': z.any().optional(),
 })
     .strict();

package/lib/server.js

@@ -1,32 +1,6 @@
-"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.createServer = void 0;
-const ws_1 = __importStar(require("ws"));
-const logger_1 = require("./logger");
-const logger = logger_1.defaultLogger.child({ name: 'ws' });
+import WebSocket, { WebSocketServer } from 'ws';
+import { defaultLogger, truncate } from './logger';
+const logger = defaultLogger.child({ name: 'ws' });
 const parseRequest = (request) => {
     try {
         return JSON.parse(request);
@@ -36,7 +10,7 @@ const parseRequest = (request) => {
     }
 };
 const createWS = async (port) => {
-    const wss = new ws_1.WebSocketServer({ port, maxPayload: 1024 * 1024 * 100 });
+    const wss = new WebSocketServer({ port, maxPayload: 1024 * 1024 * 100 });
     const promise = new Promise((resolve) => {
         wss.on('listening', () => {
             resolve([wss, wss.address().port]);
@@ -47,7 +21,7 @@ const createWS = async (port) => {
     });
     return promise;
 };
-const createServer = async (handler, port) => {
+export const createServer = async (handler, port) => {
     let wss;
     let listenPort;
     for (let i = 0; i < 5; i++) {
@@ -66,7 +40,7 @@ const createServer = async (handler, port) => {
     wss.on('connection', (ws) => {
         logger.debug('New connection');
         const send = (data) => {
-            if (ws.readyState === ws_1.default.OPEN) {
+            if (ws.readyState === WebSocket.OPEN) {
                 ws.send(JSON.stringify(data));
             }
         };
@@ -76,7 +50,7 @@ const createServer = async (handler, port) => {
                 subscriptions[subid] = onCancel;
                 return (data) => {
                     if (subscriptions[subid]) {
-                        logger.trace({ method, subid, data: (0, logger_1.truncate)(data) }, 'Subscription notification');
+                        logger.trace({ method, subid, data: truncate(data) }, 'Subscription notification');
                         send({
                             jsonrpc: '2.0',
                             method,
@@ -132,7 +106,7 @@ const createServer = async (handler, port) => {
                 logger.trace({
                     id: req.id,
                     method: req.method,
-                    result: (0, logger_1.truncate)(resp),
+                    result: truncate(resp),
                 }, 'Sending response for request');
                 send({
                     id: req.id,
@@ -165,4 +139,3 @@ const createServer = async (handler, port) => {
         }),
     };
 };
-exports.createServer = createServer;

package/lib/setup-with-server.js

@@ -1,23 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupWithServer = void 0;
-const server_1 = require("./server");
-const rpc_1 = require("./rpc");
-const shared_1 = require("./rpc/shared");
-const setup_1 = require("./setup");
-const setupWithServer = async (argv) => {
-    const context = await (0, setup_1.setup)(argv);
+import { createServer } from './server';
+import { handler } from './rpc';
+import { logger } from './rpc/shared';
+import { setup } from './setup';
+export const setupWithServer = async (argv) => {
+    const context = await setup(argv);
     const port = argv.port ?? 8000;
     if (argv.genesis) {
         // mine 1st block when starting from genesis to set some mock validation data
         await context.chain.newBlock();
     }
-    const { close, port: listenPort } = await (0, server_1.createServer)((0, rpc_1.handler)(context), port);
-    shared_1.logger.info(`${await context.chain.api.getSystemChain()} RPC listening on port ${listenPort}`);
+    const { close, port: listenPort } = await createServer(handler(context), port);
+    logger.info(`${await context.chain.api.getSystemChain()} RPC listening on port ${listenPort}`);
     return {
         ...context,
         close,
         listenPort,
     };
 };
-exports.setupWithServer = setupWithServer;

package/lib/setup.js

@@ -1,30 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setup = void 0;
-require("@polkadot/types-codec");
-const api_1 = require("@polkadot/api");
-const api_2 = require("./api");
-const blockchain_1 = require("./blockchain");
-const genesis_provider_1 = require("./genesis-provider");
-const inherent_1 = require("./blockchain/inherent");
-const logger_1 = require("./logger");
-const import_storage_1 = require("./utils/import-storage");
-const db_1 = require("./db");
-const time_travel_1 = require("./utils/time-travel");
-const setup = async (argv) => {
+import '@polkadot/types-codec';
+import { WsProvider } from '@polkadot/api';
+import { Api } from './api';
+import { Blockchain } from './blockchain';
+import { GenesisProvider } from './genesis-provider';
+import { InherentProviders, ParaInherentEnter, SetBabeRandomness, SetNimbusAuthorInherent, SetTimestamp, SetValidationData, } from './blockchain/inherent';
+import { defaultLogger } from './logger';
+import { importStorage, overrideWasm } from './utils/import-storage';
+import { openDb } from './db';
+import { timeTravel } from './utils/time-travel';
+export const setup = async (argv) => {
     let provider;
     if (argv.genesis) {
         if (typeof argv.genesis === 'string') {
-            provider = await genesis_provider_1.GenesisProvider.fromUrl(argv.genesis);
+            provider = await GenesisProvider.fromUrl(argv.genesis);
         }
         else {
-            provider = new genesis_provider_1.GenesisProvider(argv.genesis);
+            provider = new GenesisProvider(argv.genesis);
         }
     }
     else {
-        provider = new api_1.WsProvider(argv.endpoint);
+        provider = new WsProvider(argv.endpoint);
     }
-    const api = new api_2.Api(provider);
+    const api = new Api(provider);
     await api.isReady;
     let blockHash;
     if (argv.block == null) {
@@ -39,19 +36,19 @@ const setup = async (argv) => {
     else {
         throw new Error(`Invalid block number or hash: ${argv.block}`);
     }
-    logger_1.defaultLogger.debug({ ...argv, blockHash }, 'Args');
+    defaultLogger.debug({ ...argv, blockHash }, 'Args');
     let db;
     if (argv.db) {
-        db = await (0, db_1.openDb)(argv.db);
+        db = await openDb(argv.db);
     }
     const header = await api.getHeader(blockHash);
-    const inherents = new inherent_1.InherentProviders(new inherent_1.SetTimestamp(), [
-        new inherent_1.SetValidationData(),
-        new inherent_1.ParaInherentEnter(),
-        new inherent_1.SetNimbusAuthorInherent(),
-        new inherent_1.SetBabeRandomness(),
+    const inherents = new InherentProviders(new SetTimestamp(), [
+        new SetValidationData(),
+        new ParaInherentEnter(),
+        new SetNimbusAuthorInherent(),
+        new SetBabeRandomness(),
     ]);
-    const chain = new blockchain_1.Blockchain({
+    const chain = new Blockchain({
         api,
         buildBlockMode: argv['build-block-mode'],
         inherentProvider: inherents,
@@ -65,11 +62,10 @@ const setup = async (argv) => {
         registeredTypes: argv['registered-types'],
     });
     if (argv.timestamp)
-        await (0, time_travel_1.timeTravel)(chain, argv.timestamp);
+        await timeTravel(chain, argv.timestamp);
     // override wasm before importing storage, in case new pallets have been
     // added that have storage imports
-    await (0, import_storage_1.overrideWasm)(chain, argv['wasm-override']);
-    await (0, import_storage_1.importStorage)(chain, argv['import-storage']);
+    await overrideWasm(chain, argv['wasm-override']);
+    await importStorage(chain, argv['import-storage']);
     return { chain, api, ws: provider };
 };
-exports.setup = setup;

package/lib/utils/decoder.js

@@ -1,15 +1,9 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeStorageDiff = exports.decodeKeyValue = exports.decodeKey = void 0;
-require("@polkadot/types-codec");
-const util_crypto_1 = require("@polkadot/util-crypto");
-const jsondiffpatch_1 = require("jsondiffpatch");
-const util_1 = require("@polkadot/util");
-const lodash_1 = __importDefault(require("lodash"));
-const diffPatcher = (0, jsondiffpatch_1.create)({
+import '@polkadot/types-codec';
+import { blake2AsHex } from '@polkadot/util-crypto';
+import { create } from 'jsondiffpatch';
+import { hexToU8a, u8aToHex } from '@polkadot/util';
+import _ from 'lodash';
+const diffPatcher = create({
     array: { detectMove: false },
     textDiff: { minLength: Number.MAX_VALUE }, // skip text diff
 });
@@ -28,7 +22,7 @@ const getStorageEntry = (meta, block, key) => {
     }
     for (const module of Object.values(meta.query)) {
         for (const storage of Object.values(module)) {
-            const keyPrefix = (0, util_1.u8aToHex)(storage.keyPrefix());
+            const keyPrefix = u8aToHex(storage.keyPrefix());
             if (key.startsWith(keyPrefix)) {
                 cache[keyPrefix] = storage;
                 return storage;
@@ -37,7 +31,7 @@ const getStorageEntry = (meta, block, key) => {
     }
     return undefined;
 };
-const decodeKey = (meta, block, key) => {
+export const decodeKey = (meta, block, key) => {
     const storage = getStorageEntry(meta, block, key);
     const decodedKey = meta.registry.createType('StorageKey', key);
     if (storage) {
@@ -46,9 +40,8 @@ const decodeKey = (meta, block, key) => {
     }
     return {};
 };
-exports.decodeKey = decodeKey;
-const decodeKeyValue = (meta, block, key, value) => {
-    const { storage, decodedKey } = (0, exports.decodeKey)(meta, block, key);
+export const decodeKeyValue = (meta, block, key, value) => {
+    const { storage, decodedKey } = decodeKey(meta, block, key);
     if (!storage || !decodedKey) {
         return { [key]: value };
     }
@@ -56,9 +49,9 @@ const decodeKeyValue = (meta, block, key, value) => {
         if (!value)
             return null;
         if (storage.section === 'substrate' && storage.method === 'code') {
-            return `:code blake2_256 ${(0, util_crypto_1.blake2AsHex)(value, 256)} (${(0, util_1.hexToU8a)(value).length} bytes)`;
+            return `:code blake2_256 ${blake2AsHex(value, 256)} (${hexToU8a(value).length} bytes)`;
         }
-        return meta.registry.createType(decodedKey.outputType, (0, util_1.hexToU8a)(value)).toHuman();
+        return meta.registry.createType(decodedKey.outputType, hexToU8a(value)).toHuman();
     };
     switch (decodedKey.args.length) {
         case 2: {
@@ -89,19 +82,17 @@ const decodeKeyValue = (meta, block, key, value) => {
             };
     }
 };
-exports.decodeKeyValue = decodeKeyValue;
-const decodeStorageDiff = async (block, diff) => {
+export const decodeStorageDiff = async (block, diff) => {
     const oldState = {};
     const newState = {};
     const meta = await block.meta;
     for (const [key, value] of diff) {
-        lodash_1.default.merge(oldState, (0, exports.decodeKeyValue)(meta, block, key, (await block.get(key))));
-        lodash_1.default.merge(newState, (0, exports.decodeKeyValue)(meta, block, key, value));
+        _.merge(oldState, decodeKeyValue(meta, block, key, (await block.get(key))));
+        _.merge(newState, decodeKeyValue(meta, block, key, value));
     }
-    const oldStateWithoutEvents = lodash_1.default.cloneDeep(oldState);
+    const oldStateWithoutEvents = _.cloneDeep(oldState);
     if (oldStateWithoutEvents['system']?.['events']) {
         oldStateWithoutEvents['system']['events'] = [];
     }
     return [oldState, newState, diffPatcher.diff(oldStateWithoutEvents, newState)];
 };
-exports.decodeStorageDiff = decodeStorageDiff;

package/lib/utils/generate-html-diff.js

@@ -1,24 +1,16 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+import { decodeStorageDiff } from './decoder';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { template } from 'lodash';
+import path from 'node:path';
+export const generateHtmlDiff = async (block, diff) => {
+    const [left, _right, delta] = await decodeStorageDiff(block, diff);
+    const htmlTemplate = readFileSync(path.join(__dirname, '../../template/diff.html'), 'utf-8');
+    return template(htmlTemplate)({ left: JSON.stringify(left), delta: JSON.stringify(delta) });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateHtmlDiffPreviewFile = exports.generateHtmlDiff = void 0;
-const decoder_1 = require("./decoder");
-const node_fs_1 = require("node:fs");
-const lodash_1 = require("lodash");
-const node_path_1 = __importDefault(require("node:path"));
-const generateHtmlDiff = async (block, diff) => {
-    const [left, _right, delta] = await (0, decoder_1.decodeStorageDiff)(block, diff);
-    const htmlTemplate = (0, node_fs_1.readFileSync)(node_path_1.default.join(__dirname, '../../template/diff.html'), 'utf-8');
-    return (0, lodash_1.template)(htmlTemplate)({ left: JSON.stringify(left), delta: JSON.stringify(delta) });
-};
-exports.generateHtmlDiff = generateHtmlDiff;
-const generateHtmlDiffPreviewFile = async (block, diff, filename) => {
-    const html = await (0, exports.generateHtmlDiff)(block, diff);
-    (0, node_fs_1.mkdirSync)('./preview', { recursive: true });
+export const generateHtmlDiffPreviewFile = async (block, diff, filename) => {
+    const html = await generateHtmlDiff(block, diff);
+    mkdirSync('./preview', { recursive: true });
     const filePath = `./preview/${filename}.html`;
-    (0, node_fs_1.writeFileSync)(filePath, html);
+    writeFileSync(filePath, html);
     return filePath;
 };
-exports.generateHtmlDiffPreviewFile = generateHtmlDiffPreviewFile;

package/lib/utils/import-storage.js

@@ -1,35 +1,28 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.overrideWasm = exports.importStorage = void 0;
-const node_fs_1 = require("node:fs");
-const js_yaml_1 = __importDefault(require("js-yaml"));
-const set_storage_1 = require("./set-storage");
-const logger_1 = require("../logger");
-const importStorage = async (chain, storage) => {
+import { existsSync, readFileSync } from 'node:fs';
+import yaml from 'js-yaml';
+import { setStorage } from './set-storage';
+import { defaultLogger } from '../logger';
+export const importStorage = async (chain, storage) => {
     if (storage == null) {
         return;
     }
     let storageValue;
     if (typeof storage === 'string') {
-        if (!(0, node_fs_1.existsSync)(storage))
+        if (!existsSync(storage))
             throw Error(`File ${storage} does not exist`);
-        storageValue = js_yaml_1.default.load(String((0, node_fs_1.readFileSync)(storage)));
+        storageValue = yaml.load(String(readFileSync(storage)));
     }
     else {
         storageValue = storage;
     }
-    const blockHash = await (0, set_storage_1.setStorage)(chain, storageValue);
-    logger_1.defaultLogger.trace({ blockHash, storage }, 'ImportStorage');
+    const blockHash = await setStorage(chain, storageValue);
+    defaultLogger.trace({ blockHash, storage }, 'ImportStorage');
 };
-exports.importStorage = importStorage;
-const overrideWasm = async (chain, wasmPath) => {
+export const overrideWasm = async (chain, wasmPath) => {
     if (wasmPath == null) {
         return;
     }
-    const wasm = (0, node_fs_1.readFileSync)(wasmPath);
+    const wasm = readFileSync(wasmPath);
     let wasmHex;
     if (wasm.at(0) === 0x30 && wasm.at(1) === 0x78) {
         // starts with 0x
@@ -40,4 +33,3 @@ const overrideWasm = async (chain, wasmPath) => {
     }
     chain.head.setWasm(wasmHex);
 };
-exports.overrideWasm = overrideWasm;

package/lib/utils/index.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defer = exports.isUrl = exports.getParaId = exports.compactHex = exports.fetchKeysToArray = exports.fetchKeys = void 0;
-const util_1 = require("@polkadot/util");
-async function fetchKeys(getKeys, processKey) {
+import { compactStripLength, hexToU8a, u8aToHex } from '@polkadot/util';
+export async function fetchKeys(getKeys, processKey) {
     const processKeys = async (keys) => {
         for (const key of keys) {
             await processKey(key);
@@ -19,26 +16,22 @@ async function fetchKeys(getKeys, processKey) {
         nextKey = await processKeys(keys);
     }
 }
-exports.fetchKeys = fetchKeys;
-async function fetchKeysToArray(getKeys) {
+export async function fetchKeysToArray(getKeys) {
     const res = [];
     await fetchKeys(getKeys, (key) => res.push(key));
     return res;
 }
-exports.fetchKeysToArray = fetchKeysToArray;
-const compactHex = (value) => {
-    return (0, util_1.u8aToHex)((0, util_1.compactStripLength)(value)[1]);
+export const compactHex = (value) => {
+    return u8aToHex(compactStripLength(value)[1]);
 };
-exports.compactHex = compactHex;
-const getParaId = async (chain) => {
+export const getParaId = async (chain) => {
     const meta = await chain.head.meta;
-    const raw = await chain.head.get((0, exports.compactHex)(meta.query.parachainInfo.parachainId()));
+    const raw = await chain.head.get(compactHex(meta.query.parachainInfo.parachainId()));
     if (!raw)
         throw new Error('Cannot find parachain id');
-    return meta.registry.createType('u32', (0, util_1.hexToU8a)(raw));
+    return meta.registry.createType('u32', hexToU8a(raw));
 };
-exports.getParaId = getParaId;
-const isUrl = (url) => {
+export const isUrl = (url) => {
     try {
         new URL(url);
         return true;
@@ -47,8 +40,7 @@ const isUrl = (url) => {
         return false;
     }
 };
-exports.isUrl = isUrl;
-function defer() {
+export function defer() {
     const deferred = {};
     deferred.promise = new Promise((resolve, reject) => {
         deferred.resolve = resolve;
@@ -56,4 +48,3 @@ function defer() {
     });
     return deferred;
 }
-exports.defer = defer;

package/lib/utils/open-html.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.openHtml = void 0;
-const node_child_process_1 = require("node:child_process");
-const openHtml = (filePath) => {
+import { execSync } from 'node:child_process';
+export const openHtml = (filePath) => {
     const start = process.platform == 'darwin' ? 'open' : process.platform == 'win32' ? 'start' : 'xdg-open';
-    (0, node_child_process_1.execSync)(start + ' ' + filePath);
+    execSync(start + ' ' + filePath);
 };
-exports.openHtml = openHtml;