@acala-network/chopsticks-core 0.8.0-0 → 0.8.0-2

package/lib/offchain.js

@@ -1,3 +1,4 @@
+"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -7,11 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { blake2AsHex } from '@polkadot/util-crypto';
-import { defaultLogger } from './logger';
-import { queueScheduler } from 'rxjs';
-const logger = defaultLogger.child({ name: 'offchain' });
-export class OffchainWorker {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OffchainWorker = void 0;
+const util_crypto_1 = require("@polkadot/util-crypto");
+const logger_1 = require("./logger");
+const rxjs_1 = require("rxjs");
+const logger = logger_1.defaultLogger.child({ name: 'offchain' });
+class OffchainWorker {
     constructor() {
         this.pendingExtrinsics = [];
         this.offchainStorage = new Map();
@@ -30,7 +33,7 @@ export class OffchainWorker {
             logger.info(`Offchain Worker complete for block #${block.number.toLocaleString()}`);
             const txs = this.pendingExtrinsics.splice(0);
             if (txs.length > 0) {
-                queueScheduler.schedule((transactions) => __awaiter(this, void 0, void 0, function* () {
+                rxjs_1.queueScheduler.schedule((transactions) => __awaiter(this, void 0, void 0, function* () {
                     yield block.chain.txPool.buildBlock({ transactions });
                 }), 100, txs);
             }
@@ -41,9 +44,10 @@ export class OffchainWorker {
             const validity = yield block.chain.validateExtrinsic(extrinsic, '0x01');
             if (validity.isOk) {
                 this.pendingExtrinsics.push(extrinsic);
-                return blake2AsHex(extrinsic, 256);
+                return (0, util_crypto_1.blake2AsHex)(extrinsic, 256);
             }
             throw validity.asErr;
         });
     }
 }
+exports.OffchainWorker = OffchainWorker;

package/lib/schema/index.js

@@ -1,11 +1,14 @@
-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.genesisSchema = void 0;
+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()) }) }),
 });

package/lib/setup.d.ts

@@ -8,7 +8,7 @@ type Options = {
     block?: string | number | null;
     genesis?: string | Genesis;
     buildBlockMode?: BuildBlockMode;
-    db?: string;
+    db?: string | URL;
     mockSignatureHost?: boolean;
     allowUnresolvedImports?: boolean;
     runtimeLogLevel?: number;

package/lib/setup.js

@@ -1,3 +1,4 @@
+"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -7,28 +8,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-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 { openDb } from './db';
-export const setup = (options) => __awaiter(void 0, void 0, void 0, function* () {
+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 db_1 = require("./db");
+const setup = (options) => __awaiter(void 0, void 0, void 0, function* () {
     let provider;
     if (options.genesis) {
         if (typeof options.genesis === 'string') {
-            provider = yield GenesisProvider.fromUrl(options.genesis);
+            provider = yield genesis_provider_1.GenesisProvider.fromUrl(options.genesis);
         }
         else {
-            provider = new GenesisProvider(options.genesis);
+            provider = new genesis_provider_1.GenesisProvider(options.genesis);
         }
     }
     else {
-        provider = new WsProvider(options.endpoint);
+        provider = new api_1.WsProvider(options.endpoint);
     }
-    const api = new Api(provider);
+    const api = new api_2.Api(provider);
     yield api.isReady;
     let blockHash;
     if (options.block == null) {
@@ -43,19 +46,24 @@ export const setup = (options) => __awaiter(void 0, void 0, void 0, function* ()
     else {
         throw new Error(`Invalid block number or hash: ${options.block}`);
     }
-    defaultLogger.debug(Object.assign(Object.assign({}, options), { blockHash }), 'Args');
+    logger_1.defaultLogger.debug(Object.assign(Object.assign({}, options), { blockHash }), 'Args');
     let db;
     if (options.db) {
-        db = yield openDb(options.db);
+        if (typeof window !== 'undefined') {
+            if (!(options.db instanceof URL)) {
+                throw new Error('options.db must be an URL to sql-wasm.wasm when running in browser');
+            }
+        }
+        db = yield (0, db_1.openDb)(options.db);
     }
     const header = yield 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(),
     ]);
-    return new Blockchain({
+    return new blockchain_1.Blockchain({
         api,
         buildBlockMode: options.buildBlockMode,
         inherentProvider: inherents,
@@ -72,3 +80,4 @@ export const setup = (options) => __awaiter(void 0, void 0, void 0, function* ()
         maxMemoryBlockCount: options.maxMemoryBlockCount,
     });
 });
+exports.setup = setup;

package/lib/utils/index.js

@@ -1,3 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -7,10 +22,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { compactStripLength, hexToU8a, u8aToHex } from '@polkadot/util';
-export * from './set-storage';
-export * from './time-travel';
-export function fetchKeys(getKeys, processKey) {
+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");
+__exportStar(require("./set-storage"), exports);
+__exportStar(require("./time-travel"), exports);
+function fetchKeys(getKeys, processKey) {
     return __awaiter(this, void 0, void 0, function* () {
         const processKeys = (keys) => __awaiter(this, void 0, void 0, function* () {
             for (const key of keys) {
@@ -29,24 +46,28 @@ export function fetchKeys(getKeys, processKey) {
         }
     });
 }
-export function fetchKeysToArray(getKeys) {
+exports.fetchKeys = fetchKeys;
+function fetchKeysToArray(getKeys) {
     return __awaiter(this, void 0, void 0, function* () {
         const res = [];
         yield 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 = (chain) => __awaiter(void 0, void 0, void 0, function* () {
+exports.compactHex = compactHex;
+const getParaId = (chain) => __awaiter(void 0, void 0, void 0, function* () {
     const meta = yield chain.head.meta;
-    const raw = yield chain.head.get(compactHex(meta.query.parachainInfo.parachainId()));
+    const raw = yield 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;
@@ -55,7 +76,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;
@@ -63,3 +85,4 @@ export function defer() {
     });
     return deferred;
 }
+exports.defer = defer;

package/lib/utils/key-cache.js

@@ -1,3 +1,4 @@
+"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -7,59 +8,64 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import _ from 'lodash';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PREFIX_LENGTH = void 0;
+const lodash_1 = __importDefault(require("lodash"));
 // 0x + 32 module + 32 method
-export const PREFIX_LENGTH = 66;
-export default class KeyCache {
+exports.PREFIX_LENGTH = 66;
+class KeyCache {
     constructor() {
         this.ranges = [];
     }
     feed(keys) {
-        const _keys = keys.filter((key) => key.length >= PREFIX_LENGTH);
+        const _keys = keys.filter((key) => key.length >= exports.PREFIX_LENGTH);
         if (_keys.length === 0)
             return;
-        const startKey = _keys[0].slice(PREFIX_LENGTH);
-        const endKey = _keys[_keys.length - 1].slice(PREFIX_LENGTH);
-        const grouped = _.groupBy(_keys, (key) => key.slice(0, PREFIX_LENGTH));
+        const startKey = _keys[0].slice(exports.PREFIX_LENGTH);
+        const endKey = _keys[_keys.length - 1].slice(exports.PREFIX_LENGTH);
+        const grouped = lodash_1.default.groupBy(_keys, (key) => key.slice(0, exports.PREFIX_LENGTH));
         for (const [prefix, keys] of Object.entries(grouped)) {
             const ranges = this.ranges.filter((range) => range.prefix === prefix);
             if (ranges.length === 0) {
                 // no existing range with prefix
-                this.ranges.push({ prefix, keys: keys.map((i) => i.slice(PREFIX_LENGTH)) });
+                this.ranges.push({ prefix, keys: keys.map((i) => i.slice(exports.PREFIX_LENGTH)) });
                 continue;
             }
             let merged = false;
             for (const range of ranges) {
-                const startPosition = _.sortedIndex(range.keys, startKey);
+                const startPosition = lodash_1.default.sortedIndex(range.keys, startKey);
                 if (startPosition >= 0 && range.keys[startPosition] === startKey) {
                     // found existing range with prefix
-                    range.keys.splice(startPosition, keys.length, ...keys.map((i) => i.slice(PREFIX_LENGTH)));
+                    range.keys.splice(startPosition, keys.length, ...keys.map((i) => i.slice(exports.PREFIX_LENGTH)));
                     merged = true;
                     break;
                 }
-                const endPosition = _.sortedIndex(range.keys, endKey);
+                const endPosition = lodash_1.default.sortedIndex(range.keys, endKey);
                 if (endPosition >= 0 && range.keys[endPosition] === endKey) {
                     // found existing range with prefix
-                    range.keys.splice(0, endPosition + 1, ...keys.map((i) => i.slice(PREFIX_LENGTH)));
+                    range.keys.splice(0, endPosition + 1, ...keys.map((i) => i.slice(exports.PREFIX_LENGTH)));
                     merged = true;
                     break;
                 }
             }
             // insert new prefix with range
             if (!merged) {
-                this.ranges.push({ prefix, keys: keys.map((i) => i.slice(PREFIX_LENGTH)) });
+                this.ranges.push({ prefix, keys: keys.map((i) => i.slice(exports.PREFIX_LENGTH)) });
             }
         }
         // TODO: merge ranges if they overlap
     }
     next(startKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (startKey.length < PREFIX_LENGTH)
+            if (startKey.length < exports.PREFIX_LENGTH)
                 return;
-            const prefix = startKey.slice(0, PREFIX_LENGTH);
-            const key = startKey.slice(PREFIX_LENGTH);
+            const prefix = startKey.slice(0, exports.PREFIX_LENGTH);
+            const key = startKey.slice(exports.PREFIX_LENGTH);
             for (const range of this.ranges.filter((range) => range.prefix === prefix)) {
-                const index = _.sortedIndex(range.keys, key);
+                const index = lodash_1.default.sortedIndex(range.keys, key);
                 if (range.keys[index] !== key)
                     continue;
                 const nextKey = range.keys[index + 1];
@@ -70,3 +76,4 @@ export default class KeyCache {
         });
     }
 }
+exports.default = KeyCache;

package/lib/utils/proof.js

@@ -1,6 +1,9 @@
-import { hexToU8a, u8aConcat, u8aToHex } from '@polkadot/util';
-import { xxhashAsU8a } from '@polkadot/util-crypto';
-export const WELL_KNOWN_KEYS = {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hrmpChannels = exports.hrmpEgressChannelIndex = exports.hrmpIngressChannelIndex = exports.upgradeGoAheadSignal = exports.dmqMqcHead = exports.WELL_KNOWN_KEYS = void 0;
+const util_1 = require("@polkadot/util");
+const util_crypto_1 = require("@polkadot/util-crypto");
+exports.WELL_KNOWN_KEYS = {
     EPOCH_INDEX: '0x1cb6f36e027abb2091cfb5110ab5087f38316cbf8fa0da822a20ac1c55bf1be3',
     CURRENT_BLOCK_RANDOMNESS: '0x1cb6f36e027abb2091cfb5110ab5087fd077dfdb8adb10f78f10a5df8742c545',
     ONE_EPOCH_AGO_RANDOMNESS: '0x1cb6f36e027abb2091cfb5110ab5087f7ce678799d3eff024253b90e84927cc6',
@@ -9,25 +12,30 @@ export const WELL_KNOWN_KEYS = {
     ACTIVE_CONFIG: '0x06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385',
 };
 const hash = (prefix, suffix) => {
-    return u8aToHex(u8aConcat(hexToU8a(prefix), xxhashAsU8a(suffix, 64), suffix));
+    return (0, util_1.u8aToHex)((0, util_1.u8aConcat)((0, util_1.hexToU8a)(prefix), (0, util_crypto_1.xxhashAsU8a)(suffix, 64), suffix));
 };
-export const dmqMqcHead = (paraId) => {
+const dmqMqcHead = (paraId) => {
     const prefix = '0x63f78c98723ddc9073523ef3beefda0c4d7fefc408aac59dbfe80a72ac8e3ce5';
     return hash(prefix, paraId.toU8a());
 };
-export const upgradeGoAheadSignal = (paraId) => {
+exports.dmqMqcHead = dmqMqcHead;
+const upgradeGoAheadSignal = (paraId) => {
     const prefix = '0xcd710b30bd2eab0352ddcc26417aa1949e94c040f5e73d9b7addd6cb603d15d3';
     return hash(prefix, paraId.toU8a());
 };
-export const hrmpIngressChannelIndex = (paraId) => {
+exports.upgradeGoAheadSignal = upgradeGoAheadSignal;
+const hrmpIngressChannelIndex = (paraId) => {
     const prefix = '0x6a0da05ca59913bc38a8630590f2627c1d3719f5b0b12c7105c073c507445948';
     return hash(prefix, paraId.toU8a());
 };
-export const hrmpEgressChannelIndex = (paraId) => {
+exports.hrmpIngressChannelIndex = hrmpIngressChannelIndex;
+const hrmpEgressChannelIndex = (paraId) => {
     const prefix = '0x6a0da05ca59913bc38a8630590f2627cf12b746dcf32e843354583c9702cc020';
     return hash(prefix, paraId.toU8a());
 };
-export const hrmpChannels = (channelId) => {
+exports.hrmpEgressChannelIndex = hrmpEgressChannelIndex;
+const hrmpChannels = (channelId) => {
     const prefix = '0x6a0da05ca59913bc38a8630590f2627cb6604cff828a6e3f579ca6c59ace013d';
     return hash(prefix, channelId.toU8a());
 };
+exports.hrmpChannels = hrmpChannels;

package/lib/utils/set-storage.js

@@ -1,3 +1,4 @@
+"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -7,40 +8,42 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { StorageKey } from '@polkadot/types';
-import { stringCamelCase } from '@polkadot/util/string';
-import { u8aToHex } from '@polkadot/util';
-import { StorageValueKind } from '../blockchain/storage-layer';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setStorage = void 0;
+const types_1 = require("@polkadot/types");
+const string_1 = require("@polkadot/util/string");
+const util_1 = require("@polkadot/util");
+const storage_layer_1 = require("../blockchain/storage-layer");
 function objectToStorageItems(meta, storage) {
     const storageItems = [];
     for (const sectionName in storage) {
         const section = storage[sectionName];
-        const pallet = meta.query[stringCamelCase(sectionName)];
+        const pallet = meta.query[(0, string_1.stringCamelCase)(sectionName)];
         if (!pallet)
             throw Error(`Cannot find pallet ${sectionName}`);
         for (const storageName in section) {
             const storage = section[storageName];
             if (storageName === '$removePrefix') {
                 for (const mapName of storage) {
-                    const storageEntry = pallet[stringCamelCase(mapName)];
+                    const storageEntry = pallet[(0, string_1.stringCamelCase)(mapName)];
                     if (!storageEntry)
                         throw Error(`Cannot find storage ${mapName} in pallet ${sectionName}`);
                     const prefix = storageEntry.keyPrefix();
-                    storageItems.push([u8aToHex(prefix), StorageValueKind.DeletedPrefix]);
+                    storageItems.push([(0, util_1.u8aToHex)(prefix), storage_layer_1.StorageValueKind.DeletedPrefix]);
                 }
                 continue;
             }
-            const storageEntry = pallet[stringCamelCase(storageName)];
+            const storageEntry = pallet[(0, string_1.stringCamelCase)(storageName)];
             if (!storageEntry)
                 throw Error(`Cannot find storage ${storageName} in pallet ${sectionName}`);
             if (storageEntry.meta.type.isPlain) {
-                const key = new StorageKey(meta.registry, [storageEntry]);
+                const key = new types_1.StorageKey(meta.registry, [storageEntry]);
                 const type = storageEntry.meta.modifier.isOptional ? `Option<${key.outputType}>` : key.outputType;
                 storageItems.push([key.toHex(), storage ? meta.registry.createType(type, storage).toHex() : null]);
             }
             else {
                 for (const [keys, value] of storage) {
-                    const key = new StorageKey(meta.registry, [storageEntry, keys]);
+                    const key = new types_1.StorageKey(meta.registry, [storageEntry, keys]);
                     const type = storageEntry.meta.modifier.isOptional ? `Option<${key.outputType}>` : key.outputType;
                     storageItems.push([key.toHex(), value ? meta.registry.createType(type, value).toHex() : null]);
                 }
@@ -49,7 +52,7 @@ function objectToStorageItems(meta, storage) {
     }
     return storageItems;
 }
-export const setStorage = (chain, storage, blockHash) => __awaiter(void 0, void 0, void 0, function* () {
+const setStorage = (chain, storage, blockHash) => __awaiter(void 0, void 0, void 0, function* () {
     const block = yield chain.getBlock(blockHash);
     if (!block)
         throw Error(`Cannot find block ${blockHash || 'latest'}`);
@@ -63,3 +66,4 @@ export const setStorage = (chain, storage, blockHash) => __awaiter(void 0, void
     block.pushStorageLayer().setAll(storageItems);
     return block.hash;
 });
+exports.setStorage = setStorage;

package/lib/utils/time-travel.js

@@ -1,3 +1,4 @@
+"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -7,11 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { hexToU8a, u8aToHex } from '@polkadot/util';
-import { compactHex } from '.';
-import { getAuraSlotDuration } from '../executor';
-import { setStorage } from './set-storage';
-export const getCurrentSlot = (chain) => __awaiter(void 0, void 0, void 0, function* () {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeTravel = exports.getSlotDuration = exports.getCurrentTimestamp = exports.getCurrentSlot = void 0;
+const util_1 = require("@polkadot/util");
+const _1 = require(".");
+const executor_1 = require("../executor");
+const set_storage_1 = require("./set-storage");
+const getCurrentSlot = (chain) => __awaiter(void 0, void 0, void 0, function* () {
     const meta = yield chain.head.meta;
     // use raw key here because some chain did not expose those storage to metadata
     const slotRaw = meta.consts.babe
@@ -19,49 +22,53 @@ export const getCurrentSlot = (chain) => __awaiter(void 0, void 0, void 0, funct
         : yield chain.head.get('0x57f8dc2f5ab09467896f47300f04243806155b3cd9a8c9e5e9a23fd5dc13a5ed'); // aura.currentSlot
     if (!slotRaw)
         throw new Error('Cannot find current slot');
-    return meta.registry.createType('Slot', hexToU8a(slotRaw)).toNumber();
+    return meta.registry.createType('Slot', (0, util_1.hexToU8a)(slotRaw)).toNumber();
 });
-export const getCurrentTimestamp = (chain) => __awaiter(void 0, void 0, void 0, function* () {
+exports.getCurrentSlot = getCurrentSlot;
+const getCurrentTimestamp = (chain) => __awaiter(void 0, void 0, void 0, function* () {
     const meta = yield chain.head.meta;
-    const currentTimestampRaw = (yield chain.head.get(compactHex(meta.query.timestamp.now()))) || '0x';
-    return meta.registry.createType('u64', hexToU8a(currentTimestampRaw)).toNumber();
+    const currentTimestampRaw = (yield chain.head.get((0, _1.compactHex)(meta.query.timestamp.now()))) || '0x';
+    return meta.registry.createType('u64', (0, util_1.hexToU8a)(currentTimestampRaw)).toNumber();
 });
-export const getSlotDuration = (chain) => __awaiter(void 0, void 0, void 0, function* () {
+exports.getCurrentTimestamp = getCurrentTimestamp;
+const getSlotDuration = (chain) => __awaiter(void 0, void 0, void 0, function* () {
     const meta = yield chain.head.meta;
     return meta.consts.babe
         ? meta.consts.babe.expectedBlockTime.toNumber()
         : meta.query.aura
-            ? getAuraSlotDuration(yield chain.head.wasm, meta.registry)
+            ? (0, executor_1.getAuraSlotDuration)(yield chain.head.wasm, meta.registry)
             : 12000;
 });
-export const timeTravel = (chain, timestamp) => __awaiter(void 0, void 0, void 0, function* () {
+exports.getSlotDuration = getSlotDuration;
+const timeTravel = (chain, timestamp) => __awaiter(void 0, void 0, void 0, function* () {
     const meta = yield chain.head.meta;
-    const slotDuration = yield getSlotDuration(chain);
+    const slotDuration = yield (0, exports.getSlotDuration)(chain);
     const newSlot = Math.floor(timestamp / slotDuration);
     // new timestamp
     const storage = [
-        [compactHex(meta.query.timestamp.now()), u8aToHex(meta.registry.createType('u64', timestamp).toU8a())],
+        [(0, _1.compactHex)(meta.query.timestamp.now()), (0, util_1.u8aToHex)(meta.registry.createType('u64', timestamp).toU8a())],
     ];
     if (meta.consts.babe) {
         // new slot
         storage.push([
-            compactHex(meta.query.babe.currentSlot()),
-            u8aToHex(meta.registry.createType('Slot', newSlot).toU8a()),
+            (0, _1.compactHex)(meta.query.babe.currentSlot()),
+            (0, util_1.u8aToHex)(meta.registry.createType('Slot', newSlot).toU8a()),
         ]);
         // new epoch
         const epochDuration = meta.consts.babe.epochDuration.toNumber();
         const newEpoch = Math.floor(timestamp / epochDuration);
         storage.push([
-            compactHex(meta.query.babe.epochIndex()),
-            u8aToHex(meta.registry.createType('u64', newEpoch).toU8a()),
+            (0, _1.compactHex)(meta.query.babe.epochIndex()),
+            (0, util_1.u8aToHex)(meta.registry.createType('u64', newEpoch).toU8a()),
         ]);
     }
     else if (meta.query.aura) {
         // new slot
         storage.push([
-            compactHex(meta.query.aura.currentSlot()),
-            u8aToHex(meta.registry.createType('Slot', newSlot).toU8a()),
+            (0, _1.compactHex)(meta.query.aura.currentSlot()),
+            (0, util_1.u8aToHex)(meta.registry.createType('Slot', newSlot).toU8a()),
         ]);
     }
-    yield setStorage(chain, storage);
+    yield (0, set_storage_1.setStorage)(chain, storage);
 });
+exports.timeTravel = timeTravel;

package/lib/xcm/downward.js

@@ -1,3 +1,4 @@
+"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -7,28 +8,31 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { hexToU8a } from '@polkadot/util';
-import { compactHex, getParaId } from '../utils';
-import { logger } from '.';
-import { setStorage } from '../utils/set-storage';
-export const connectDownward = (relaychain, parachain) => __awaiter(void 0, void 0, void 0, function* () {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectDownward = void 0;
+const util_1 = require("@polkadot/util");
+const utils_1 = require("../utils");
+const _1 = require(".");
+const set_storage_1 = require("../utils/set-storage");
+const connectDownward = (relaychain, parachain) => __awaiter(void 0, void 0, void 0, function* () {
     const meta = yield relaychain.head.meta;
-    const paraId = yield getParaId(parachain);
-    const downwardMessageQueuesKey = compactHex(meta.query.dmp.downwardMessageQueues(paraId));
+    const paraId = yield (0, utils_1.getParaId)(parachain);
+    const downwardMessageQueuesKey = (0, utils_1.compactHex)(meta.query.dmp.downwardMessageQueues(paraId));
     yield relaychain.headState.subscribeStorage([downwardMessageQueuesKey], (head, pairs) => __awaiter(void 0, void 0, void 0, function* () {
         const value = pairs[0][1];
         if (!value)
             return;
         const meta = yield head.meta;
-        const downwardMessageQueuesKey = compactHex(meta.query.dmp.downwardMessageQueues(paraId));
+        const downwardMessageQueuesKey = (0, utils_1.compactHex)(meta.query.dmp.downwardMessageQueues(paraId));
         // clear relaychain message queue
-        yield setStorage(relaychain, [[downwardMessageQueuesKey, null]], head.hash);
+        yield (0, set_storage_1.setStorage)(relaychain, [[downwardMessageQueuesKey, null]], head.hash);
         const downwardMessages = meta.registry
-            .createType('Vec<PolkadotCorePrimitivesInboundDownwardMessage>', hexToU8a(value))
+            .createType('Vec<PolkadotCorePrimitivesInboundDownwardMessage>', (0, util_1.hexToU8a)(value))
             .toJSON();
         if (downwardMessages.length === 0)
             return;
-        logger.debug({ downwardMessages }, 'downward_message');
+        _1.logger.debug({ downwardMessages }, 'downward_message');
         parachain.submitDownwardMessages(downwardMessages);
     }));
 });
+exports.connectDownward = connectDownward;