@acala-network/chopsticks 0.5.5 → 0.5.7

package/lib/rpc/substrate/system.js

@@ -1,6 +1,11 @@
-import { hexToU8a } from '@polkadot/util';
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
+"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"));
 const handlers = {
     system_localPeerId: async () => '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
     system_nodeRoles: async () => ['Full'],
@@ -15,7 +20,7 @@ const handlers = {
         return context.chain.api.getSystemName();
     },
     system_version: async (_context) => {
-        const { version } = JSON.parse(readFileSync(path.join(__dirname, '../../../package.json'), 'utf-8'));
+        const { version } = JSON.parse((0, node_fs_1.readFileSync)(node_path_1.default.join(__dirname, '../../../package.json'), 'utf-8'));
         return `chopsticks-v${version}`;
     },
     system_chainType: async (_context) => {
@@ -37,8 +42,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', hexToU8a(result.result)).toNumber();
+        const nonce = registry.createType('Index', (0, util_1.hexToU8a)(result.result)).toNumber();
         return nonce + context.chain.txPool.pendingExtrinsicsBy(address).length;
     },
 };
-export default handlers;
+exports.default = handlers;

package/lib/run-block.js

@@ -1,10 +1,13 @@
-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);
+"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);
     const header = await context.chain.head.header;
     const wasm = await context.chain.head.wasm;
     const block = context.chain.head;
@@ -16,28 +19,29 @@ export const runBlock = async (argv) => {
         calls.push(['BlockBuilder_apply_extrinsic', [extrinsic]]);
     }
     calls.push(['BlockBuilder_finalize_block', []]);
-    const result = await runTask({
+    const result = await (0, executor_1.runTask)({
         wasm,
         calls,
         storage: [],
         mockSignatureHost: false,
         allowUnresolvedImports: false,
-    }, taskHandler(parent));
+    }, (0, executor_1.taskHandler)(parent));
     if (result.Error) {
         throw new Error(result.Error);
     }
     if (argv['html']) {
-        const filePath = await generateHtmlDiffPreviewFile(parent, result.Call.storageDiff, block.hash);
+        const filePath = await (0, generate_html_diff_1.generateHtmlDiffPreviewFile)(parent, result.Call.storageDiff, block.hash);
         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(result, null, 2));
+        (0, node_fs_1.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,27 +1,30 @@
-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(),
+"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(),
     }),
-    genesis: z.object({ raw: z.object({ top: z.record(z.string()) }) }),
+    genesis: zod_1.z.object({ raw: zod_1.z.object({ top: zod_1.z.record(zod_1.z.string()) }) }),
 });
-export const configSchema = z
+exports.configSchema = zod_1.z
     .object({
-    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(),
+    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(),
 })
     .strict();

package/lib/server.js

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

package/lib/setup-with-server.js

@@ -1,19 +1,23 @@
-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);
+"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);
     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 createServer(handler(context), port);
-    logger.info(`${await context.chain.api.getSystemChain()} RPC listening on port ${listenPort}`);
+    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}`);
     return {
         ...context,
         close,
         listenPort,
     };
 };
+exports.setupWithServer = setupWithServer;

package/lib/setup.js

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

package/lib/utils/decoder.js

@@ -1,9 +1,15 @@
-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({
+"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)({
     array: { detectMove: false },
     textDiff: { minLength: Number.MAX_VALUE }, // skip text diff
 });
@@ -22,7 +28,7 @@ const getStorageEntry = (meta, block, key) => {
     }
     for (const module of Object.values(meta.query)) {
         for (const storage of Object.values(module)) {
-            const keyPrefix = u8aToHex(storage.keyPrefix());
+            const keyPrefix = (0, util_1.u8aToHex)(storage.keyPrefix());
             if (key.startsWith(keyPrefix)) {
                 cache[keyPrefix] = storage;
                 return storage;
@@ -31,7 +37,7 @@ const getStorageEntry = (meta, block, key) => {
     }
     return undefined;
 };
-export const decodeKey = (meta, block, key) => {
+const decodeKey = (meta, block, key) => {
     const storage = getStorageEntry(meta, block, key);
     const decodedKey = meta.registry.createType('StorageKey', key);
     if (storage) {
@@ -40,8 +46,9 @@ export const decodeKey = (meta, block, key) => {
     }
     return {};
 };
-export const decodeKeyValue = (meta, block, key, value) => {
-    const { storage, decodedKey } = decodeKey(meta, block, key);
+exports.decodeKey = decodeKey;
+const decodeKeyValue = (meta, block, key, value) => {
+    const { storage, decodedKey } = (0, exports.decodeKey)(meta, block, key);
     if (!storage || !decodedKey) {
         return { [key]: value };
     }
@@ -49,9 +56,9 @@ export const decodeKeyValue = (meta, block, key, value) => {
         if (!value)
             return null;
         if (storage.section === 'substrate' && storage.method === 'code') {
-            return `:code blake2_256 ${blake2AsHex(value, 256)} (${hexToU8a(value).length} bytes)`;
+            return `:code blake2_256 ${(0, util_crypto_1.blake2AsHex)(value, 256)} (${(0, util_1.hexToU8a)(value).length} bytes)`;
         }
-        return meta.registry.createType(decodedKey.outputType, hexToU8a(value)).toHuman();
+        return meta.registry.createType(decodedKey.outputType, (0, util_1.hexToU8a)(value)).toHuman();
     };
     switch (decodedKey.args.length) {
         case 2: {
@@ -82,17 +89,19 @@ export const decodeKeyValue = (meta, block, key, value) => {
             };
     }
 };
-export const decodeStorageDiff = async (block, diff) => {
+exports.decodeKeyValue = decodeKeyValue;
+const decodeStorageDiff = async (block, diff) => {
     const oldState = {};
     const newState = {};
     const meta = await block.meta;
     for (const [key, value] of diff) {
-        _.merge(oldState, decodeKeyValue(meta, block, key, (await block.get(key))));
-        _.merge(newState, decodeKeyValue(meta, block, key, value));
+        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));
     }
-    const oldStateWithoutEvents = _.cloneDeep(oldState);
+    const oldStateWithoutEvents = lodash_1.default.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,16 +1,24 @@
-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) });
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-export const generateHtmlDiffPreviewFile = async (block, diff, filename) => {
-    const html = await generateHtmlDiff(block, diff);
-    mkdirSync('./preview', { recursive: true });
+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 });
     const filePath = `./preview/${filename}.html`;
-    writeFileSync(filePath, html);
+    (0, node_fs_1.writeFileSync)(filePath, html);
     return filePath;
 };
+exports.generateHtmlDiffPreviewFile = generateHtmlDiffPreviewFile;

package/lib/utils/import-storage.js

@@ -1,28 +1,35 @@
-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) => {
+"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) => {
     if (storage == null) {
         return;
     }
     let storageValue;
     if (typeof storage === 'string') {
-        if (!existsSync(storage))
+        if (!(0, node_fs_1.existsSync)(storage))
             throw Error(`File ${storage} does not exist`);
-        storageValue = yaml.load(String(readFileSync(storage)));
+        storageValue = js_yaml_1.default.load(String((0, node_fs_1.readFileSync)(storage)));
     }
     else {
         storageValue = storage;
     }
-    const blockHash = await setStorage(chain, storageValue);
-    defaultLogger.trace({ blockHash, storage }, 'ImportStorage');
+    const blockHash = await (0, set_storage_1.setStorage)(chain, storageValue);
+    logger_1.defaultLogger.trace({ blockHash, storage }, 'ImportStorage');
 };
-export const overrideWasm = async (chain, wasmPath) => {
+exports.importStorage = importStorage;
+const overrideWasm = async (chain, wasmPath) => {
     if (wasmPath == null) {
         return;
     }
-    const wasm = readFileSync(wasmPath);
+    const wasm = (0, node_fs_1.readFileSync)(wasmPath);
     let wasmHex;
     if (wasm.at(0) === 0x30 && wasm.at(1) === 0x78) {
         // starts with 0x
@@ -33,3 +40,4 @@ export const overrideWasm = async (chain, wasmPath) => {
     }
     chain.head.setWasm(wasmHex);
 };
+exports.overrideWasm = overrideWasm;

package/lib/utils/index.js

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

package/lib/utils/open-html.js

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