@acala-network/chopsticks 0.2.3 → 0.3.0

package/dist/index.js

@@ -3,146 +3,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeKey = exports.runBlock = exports.setupWithServer = exports.setup = void 0;
-require("@polkadot/types-codec");
-const api_1 = require("@polkadot/api");
-const util_1 = require("@polkadot/util");
 const helpers_1 = require("yargs/helpers");
 const node_fs_1 = require("node:fs");
 const js_yaml_1 = __importDefault(require("js-yaml"));
 const yargs_1 = __importDefault(require("yargs"));
-const api_2 = require("./api");
-const blockchain_1 = require("./blockchain");
 const txpool_1 = require("./blockchain/txpool");
 const schema_1 = require("./schema");
-const genesis_provider_1 = require("./genesis-provider");
-const inherents_1 = require("./blockchain/inherents");
-const server_1 = require("./server");
-const logger_1 = require("./logger");
-const rpc_1 = require("./rpc");
-const import_storage_1 = require("./utils/import-storage");
-const db_1 = require("./db");
-const executor_1 = require("./executor");
-const setup = async (argv) => {
-    let provider;
-    if (argv.genesis) {
-        if (typeof argv.genesis === 'string') {
-            provider = await genesis_provider_1.GenesisProvider.fromUrl(argv.genesis);
-        }
-        else {
-            provider = new genesis_provider_1.GenesisProvider(argv.genesis);
-        }
-    }
-    else {
-        provider = new api_1.WsProvider(argv.endpoint);
-    }
-    const api = new api_2.Api(provider);
-    await api.isReady;
-    let blockHash;
-    if (argv.block == null) {
-        blockHash = await api.getBlockHash();
-    }
-    else if (Number.isInteger(argv.block)) {
-        blockHash = await api.getBlockHash(Number(argv.block));
-    }
-    else {
-        blockHash = argv.block;
-    }
-    logger_1.defaultLogger.info({ ...argv, blockHash }, 'Args');
-    let db;
-    if (argv.db) {
-        db = await (0, db_1.openDb)(argv.db);
-    }
-    const header = await api.getHeader(blockHash);
-    const blockNumber = +header.number;
-    const timestamp = argv.timestamp ?? Date.now();
-    const setTimestamp = new inherents_1.SetTimestamp((newBlockNumber) => {
-        return timestamp + (newBlockNumber - blockNumber) * 12000; // TODO: make this more flexible
-    });
-    const inherents = new inherents_1.InherentProviders(setTimestamp, [new inherents_1.SetValidationData()]);
-    const chain = new blockchain_1.Blockchain({
-        api,
-        buildBlockMode: argv['build-block-mode'],
-        inherentProvider: inherents,
-        db,
-        header: {
-            hash: blockHash,
-            number: Number(header.number),
-        },
-    });
-    const context = { chain, api, ws: provider };
-    await (0, import_storage_1.importStorage)(chain, argv['import-storage']);
-    await (0, import_storage_1.overrideWasm)(chain, argv['wasm-override']);
-    return context;
-};
-exports.setup = setup;
-const setupWithServer = async (argv) => {
-    const context = await (0, exports.setup)(argv);
-    const port = argv.port || Number(process.env.PORT) || 8000;
-    const { close } = (0, server_1.createServer)(port, (0, rpc_1.handler)(context));
-    if (argv.genesis) {
-        // mine 1st block when starting from genesis to set some mock validation data
-        await context.chain.newBlock();
-    }
-    return {
-        ...context,
-        close,
-    };
-};
-exports.setupWithServer = setupWithServer;
-const runBlock = async (argv) => {
-    const context = await (0, exports.setupWithServer)(argv);
-    const header = await context.chain.head.header;
-    const parent = header.parentHash.toHex();
-    const wasm = await context.chain.head.wasm;
-    const block = context.chain.head;
-    const calls = [['Core_initialize_block', header.toHex()]];
-    for (const extrinsic of await block.extrinsics) {
-        calls.push(['BlockBuilder_apply_extrinsic', extrinsic]);
-    }
-    calls.push(['BlockBuilder_finalize_block', '0x']);
-    const result = await (0, executor_1.runTask)({
-        blockHash: parent,
-        wasm,
-        calls,
-        storage: [],
-        mockSignatureHost: false,
-        allowUnresolvedImports: false,
-    });
-    if (argv['output-path']) {
-        (0, node_fs_1.writeFileSync)(argv['output-path'], JSON.stringify(result, null, 2));
-    }
-    else {
-        console.dir(result, { depth: null, colors: false });
-    }
-    await context.close();
-    setTimeout(() => process.exit(0), 50);
-};
-exports.runBlock = runBlock;
-const decodeKey = async (argv) => {
-    const context = await (0, exports.setup)(argv);
-    const key = argv.key;
-    const meta = await context.chain.head.meta;
-    outer: for (const module of Object.values(meta.query)) {
-        for (const storage of Object.values(module)) {
-            const keyPrefix = (0, util_1.u8aToHex)(storage.keyPrefix());
-            if (key.startsWith(keyPrefix)) {
-                const decodedKey = meta.registry.createType('StorageKey', key);
-                decodedKey.setMeta(storage.meta);
-                console.log(`${storage.section}.${storage.method}`, decodedKey.args.map((x) => x.toHuman()).join(', '));
-                break outer;
-            }
-        }
-    }
-    setTimeout(() => process.exit(0), 50);
+const xcm_1 = require("./xcm");
+const decode_key_1 = require("./decode-key");
+const run_block_1 = require("./run-block");
+const setup_with_server_1 = require("./setup-with-server");
+const processConfig = (path) => {
+    const configFile = (0, node_fs_1.readFileSync)(path, 'utf8');
+    const config = js_yaml_1.default.load(configFile);
+    return schema_1.configSchema.parse(config);
 };
-exports.decodeKey = decodeKey;
-const processConfig = (argv) => {
+const processArgv = (argv) => {
     if (argv.config) {
-        const configFile = (0, node_fs_1.readFileSync)(argv.config, 'utf8');
-        const config = js_yaml_1.default.load(configFile);
-        const parsed = schema_1.configSchema.parse(config);
-        return { ...parsed, ...argv };
+        return { ...processConfig(argv.config), ...argv };
     }
     return argv;
 };
@@ -180,11 +58,8 @@ const defaultOptions = {
         desc: 'File path to print output',
         string: true,
     },
-}), (argv) => {
-    (0, exports.runBlock)(processConfig(argv)).catch((err) => {
-        console.error(err);
-        process.exit(1);
-    });
+}), async (argv) => {
+    await (0, run_block_1.runBlock)(processArgv(argv));
 })
     .command('dev', 'Dev mode', (yargs) => yargs.options({
     ...defaultOptions,
@@ -204,11 +79,8 @@ const defaultOptions = {
         desc: 'Mock signature host so any signature starts with 0xdeadbeef and filled by 0xcd is considered valid',
         boolean: true,
     },
-}), (argv) => {
-    (0, exports.setupWithServer)(processConfig(argv)).catch((err) => {
-        console.error(err);
-        process.exit(1);
-    });
+}), async (argv) => {
+    await (0, setup_with_server_1.setupWithServer)(processArgv(argv));
 })
     .command('decode-key <key>', 'Deocde a key', (yargs) => yargs
     .positional('key', {
@@ -217,11 +89,35 @@ const defaultOptions = {
 })
     .options({
     ...defaultOptions,
-}), (argv) => {
-    (0, exports.decodeKey)(processConfig(argv)).catch((err) => {
-        console.error(err);
-        process.exit(1);
-    });
+}), async (argv) => {
+    await (0, decode_key_1.decodeKey)(processArgv(argv));
+})
+    .command('xcm', 'XCM setup with relaychain and parachains', (yargs) => yargs.options({
+    relaychain: {
+        desc: 'Relaychain config file path',
+        string: true,
+    },
+    parachain: {
+        desc: 'Parachain config file path',
+        type: 'array',
+        string: true,
+        required: true,
+    },
+}), async (argv) => {
+    const parachains = [];
+    for (const config of argv.parachain) {
+        const { chain } = await (0, setup_with_server_1.setupWithServer)(processConfig(config));
+        parachains.push(chain);
+    }
+    if (parachains.length > 1) {
+        await (0, xcm_1.connectParachains)(parachains);
+    }
+    if (argv.relaychain) {
+        const { chain: relaychain } = await (0, setup_with_server_1.setupWithServer)(processConfig(argv.relaychain));
+        for (const parachain of parachains) {
+            await (0, xcm_1.connectDownward)(relaychain, parachain);
+        }
+    }
 })
     .strict()
     .help()

package/dist/rpc/dev.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const shared_1 = require("./shared");
 const set_storage_1 = require("../utils/set-storage");
 const logger_1 = require("../logger");
+const time_travel_1 = require("../utils/time-travel");
 const logger = logger_1.defaultLogger.child({ name: 'rpc-dev' });
 const handlers = {
     dev_newBlock: async (context, [param]) => {
@@ -12,7 +13,9 @@ const handlers = {
         const finalCount = diff > 0 ? diff : 1;
         let finalHash;
         for (let i = 0; i < finalCount; i++) {
-            const block = await context.chain.newBlock();
+            const block = await context.chain.newBlock().catch((error) => {
+                throw new shared_1.ResponseError(1, error.toString());
+            });
             logger.debug({ hash: block.hash }, 'dev_newBlock');
             finalHash = block.hash;
         }
@@ -29,5 +32,12 @@ const handlers = {
         }, 'dev_setStorages');
         return hash;
     },
+    dev_timeTravel: async (context, [date]) => {
+        const timestamp = typeof date === 'string' ? Date.parse(date) : date;
+        if (Number.isNaN(timestamp))
+            throw new shared_1.ResponseError(1, 'Invalid date');
+        await (0, time_travel_1.timeTravel)(context.chain, timestamp);
+        return timestamp;
+    },
 };
 exports.default = handlers;

package/dist/rpc/shared.d.ts

@@ -1,5 +1,3 @@
-import { ProviderInterface } from '@polkadot/rpc-provider/types';
-import { Api } from '../api';
 import { Blockchain } from '../blockchain';
 export declare const logger: import("pino").default.Logger<{
     level: string;
@@ -17,8 +15,6 @@ export declare class ResponseError extends Error {
 }
 export interface Context {
     chain: Blockchain;
-    api: Api;
-    ws: ProviderInterface;
 }
 export interface SubscriptionManager {
     subscribe: (method: string, subid: string, onCancel?: () => void) => (data: any) => void;

package/dist/rpc/substrate/author.d.ts

@@ -1,3 +1,3 @@
-import { Handlers } from '../shared';
+import { Handlers } from '../../rpc/shared';
 declare const handlers: Handlers;
 export default handlers;

package/dist/rpc/substrate/author.js

@@ -1,10 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const shared_1 = require("../../rpc/shared");
 const logger_1 = require("../../logger");
 const logger = logger_1.defaultLogger.child({ name: 'rpc-author' });
 const handlers = {
     author_submitExtrinsic: async (context, [extrinsic]) => {
-        return context.chain.submitExtrinsic(extrinsic);
+        return context.chain.submitExtrinsic(extrinsic).catch((error) => {
+            throw new shared_1.ResponseError(1, error.toString());
+        });
     },
     author_submitAndWatchExtrinsic: async (context, [extrinsic], { subscribe, unsubscribe }) => {
         let update = (_block) => { };
@@ -38,6 +41,8 @@ const handlers = {
     author_unwatchExtrinsic: async (_context, [subid], { unsubscribe }) => {
         unsubscribe(subid);
     },
-    author_pendingExtrinsics: async (_context) => [],
+    author_pendingExtrinsics: async (context) => {
+        return context.chain.pendingExtrinsics;
+    },
 };
 exports.default = handlers;

package/dist/rpc/substrate/chain.js

@@ -5,7 +5,7 @@ const handlers = {
     chain_getBlockHash: async (context, [blockNumber]) => {
         const block = await context.chain.getBlockAt(blockNumber);
         if (!block) {
-            throw new shared_1.ResponseError(1, 'Block not found');
+            throw new shared_1.ResponseError(1, `Block #${blockNumber} not found`);
         }
         return block.hash;
     },
@@ -15,7 +15,7 @@ const handlers = {
     chain_getBlock: async (context, [hash]) => {
         const block = await context.chain.getBlock(hash);
         if (!block) {
-            throw new shared_1.ResponseError(1, 'Block not found');
+            throw new shared_1.ResponseError(1, `Block ${hash} not found`);
         }
         return {
             block: {

package/dist/rpc/substrate/state.js

@@ -41,7 +41,7 @@ const handlers = {
     },
     state_subscribeRuntimeVersion: async (context, _params, { subscribe }) => {
         let update = (_block) => { };
-        const id = context.chain.headState.subscrubeRuntimeVersion((block) => update(block));
+        const id = await context.chain.headState.subscrubeRuntimeVersion((block) => update(block));
         const callback = subscribe('state_runtimeVersion', id);
         update = async (block) => callback(await block.runtimeVersion);
         context.chain.head.runtimeVersion.then(callback);

package/dist/rpc/substrate/system.js

@@ -2,13 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const handlers = {
     system_chain: async (context) => {
-        return context.api.getSystemChain();
+        return context.chain.api.getSystemChain();
     },
     system_properties: async (context) => {
-        return context.api.getSystemProperties();
+        return context.chain.api.getSystemProperties();
     },
     system_name: async (context) => {
-        return context.api.getSystemName();
+        return context.chain.api.getSystemName();
     },
     system_version: async (_context) => {
         return 'chopsticks-1.1.0';

package/dist/run-block.d.ts

@@ -0,0 +1,2 @@
+import { Config } from './schema';
+export declare const runBlock: (argv: Config) => Promise<void>;

package/dist/run-block.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBlock = void 0;
+const node_fs_1 = require("node:fs");
+const executor_1 = require("./executor");
+const setup_with_server_1 = require("./setup-with-server");
+const runBlock = async (argv) => {
+    const context = await (0, setup_with_server_1.setupWithServer)(argv);
+    const header = await context.chain.head.header;
+    const wasm = await context.chain.head.wasm;
+    const block = context.chain.head;
+    const parent = await block.parentBlock;
+    if (!parent)
+        throw Error('cant find parent block');
+    const calls = [['Core_initialize_block', header.toHex()]];
+    for (const extrinsic of await block.extrinsics) {
+        calls.push(['BlockBuilder_apply_extrinsic', extrinsic]);
+    }
+    calls.push(['BlockBuilder_finalize_block', '0x']);
+    const result = await (0, executor_1.runTask)({
+        wasm,
+        calls,
+        storage: [],
+        mockSignatureHost: false,
+        allowUnresolvedImports: false,
+    }, (0, executor_1.taskHandler)(parent));
+    if (argv['output-path']) {
+        (0, node_fs_1.writeFileSync)(argv['output-path'], JSON.stringify(result, null, 2));
+    }
+    else {
+        console.dir(result, { depth: null, colors: false });
+    }
+    await context.close();
+    setTimeout(() => process.exit(0), 50);
+};
+exports.runBlock = runBlock;

package/dist/schema/index.js

@@ -17,7 +17,7 @@ exports.configSchema = zod_1.z
     .object({
     port: zod_1.z.number().optional(),
     endpoint: zod_1.z.string().optional(),
-    block: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]).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(),

package/dist/server.d.ts

@@ -3,7 +3,7 @@ export type Handler = (data: {
     method: string;
     params: string[];
 }, subscriptionManager: SubscriptionManager) => Promise<any>;
-export declare const createServer: (port: number, handler: Handler) => {
-    port: Promise<number>;
+export declare const createServer: (handler: Handler, port?: number) => Promise<{
+    port: number;
     close: () => Promise<void>;
-};
+}>;

package/dist/server.js

@@ -35,19 +35,34 @@ const parseRequest = (request) => {
         return undefined;
     }
 };
-const createServer = (port, handler) => {
-    logger.debug('Starting on port %d', port);
+const createWS = async (port) => {
     const wss = new ws_1.WebSocketServer({ port, maxPayload: 1024 * 1024 * 100 });
-    const promise = new Promise((resolve, reject) => {
+    const promise = new Promise((resolve) => {
         wss.on('listening', () => {
-            logger.debug(wss.address(), 'Listening');
-            resolve(wss.address().port);
+            resolve([wss, wss.address().port]);
         });
-        wss.on('error', (err) => {
-            logger.error(err, 'Error');
-            reject(err);
+        wss.on('error', (_) => {
+            resolve([]);
         });
     });
+    return promise;
+};
+const createServer = async (handler, port) => {
+    let wss;
+    let listenPort;
+    for (let i = 0; i < 5; i++) {
+        const preferPort = (port || 0) + i;
+        logger.debug('Try starting on port %d', preferPort);
+        const [maybeWss, maybeListenPort] = await createWS(preferPort);
+        if (maybeWss && maybeListenPort) {
+            wss = maybeWss;
+            listenPort = maybeListenPort;
+            break;
+        }
+    }
+    if (!wss || !listenPort) {
+        throw new Error(`Failed to create WebsocketServer at port ${port}`);
+    }
     wss.on('connection', (ws) => {
         logger.debug('New connection');
         const send = (data) => {
@@ -131,10 +146,10 @@ const createServer = (port, handler) => {
         });
     });
     return {
-        port: promise,
+        port: listenPort,
         close: () => new Promise((resolve, reject) => {
-            wss.clients.forEach((socket) => socket.close());
-            wss.close((err) => {
+            wss?.clients.forEach((socket) => socket.close());
+            wss?.close((err) => {
                 if (err) {
                     reject(err);
                 }

package/dist/setup-with-server.d.ts

@@ -0,0 +1,8 @@
+import { Config } from './schema';
+export declare const setupWithServer: (argv: Config) => Promise<{
+    close: () => Promise<void>;
+    listenPort: number;
+    chain: import("./blockchain").Blockchain;
+    api: import("./api").Api;
+    ws: import("@polkadot/rpc-provider/types").ProviderInterface;
+}>;

package/dist/setup-with-server.js

@@ -0,0 +1,23 @@
+"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 || Number(process.env.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}`);
+    return {
+        ...context,
+        close,
+        listenPort,
+    };
+};
+exports.setupWithServer = setupWithServer;

package/dist/setup.d.ts

@@ -0,0 +1,10 @@
+import '@polkadot/types-codec';
+import { ProviderInterface } from '@polkadot/rpc-provider/types';
+import { Api } from './api';
+import { Blockchain } from './blockchain';
+import { Config } from './schema';
+export declare const setup: (argv: Config) => Promise<{
+    chain: Blockchain;
+    api: Api;
+    ws: ProviderInterface;
+}>;

package/dist/setup.js

@@ -0,0 +1,62 @@
+"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 genesis_provider_1.GenesisProvider.fromUrl(argv.genesis);
+        }
+        else {
+            provider = new genesis_provider_1.GenesisProvider(argv.genesis);
+        }
+    }
+    else {
+        provider = new api_1.WsProvider(argv.endpoint);
+    }
+    const api = new api_2.Api(provider);
+    await api.isReady;
+    let blockHash;
+    if (argv.block == null) {
+        blockHash = await api.getBlockHash();
+    }
+    else if (Number.isInteger(argv.block)) {
+        blockHash = await api.getBlockHash(Number(argv.block));
+    }
+    else {
+        blockHash = argv.block;
+    }
+    logger_1.defaultLogger.debug({ ...argv, blockHash }, 'Args');
+    let db;
+    if (argv.db) {
+        db = await (0, db_1.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()]);
+    const chain = new blockchain_1.Blockchain({
+        api,
+        buildBlockMode: argv['build-block-mode'],
+        inherentProvider: inherents,
+        db,
+        header: {
+            hash: blockHash,
+            number: Number(header.number),
+        },
+    });
+    if (argv.timestamp)
+        await (0, time_travel_1.timeTravel)(chain, argv.timestamp);
+    await (0, import_storage_1.importStorage)(chain, argv['import-storage']);
+    await (0, import_storage_1.overrideWasm)(chain, argv['wasm-override']);
+    return { chain, api, ws: provider };
+};
+exports.setup = setup;

package/dist/utils/index.d.ts

@@ -1,7 +1,9 @@
 import { HexString } from '@polkadot/util/types';
 import { StorageKey } from '@polkadot/types';
+import { Blockchain } from '../blockchain';
 export type GetKeys = (startKey?: string) => Promise<StorageKey<any>[]>;
 export type ProcessKey = (key: StorageKey<any>) => any;
 export declare function fetchKeys(getKeys: GetKeys, processKey: ProcessKey): Promise<void>;
 export declare function fetchKeysToArray(getKeys: GetKeys): Promise<StorageKey<any>[]>;
 export declare const compactHex: (value: Uint8Array) => HexString;
+export declare const getParaId: (chain: Blockchain) => Promise<import("@polkadot/types").u32>;

package/dist/utils/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compactHex = exports.fetchKeysToArray = exports.fetchKeys = void 0;
+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) => {
@@ -30,3 +30,11 @@ const compactHex = (value) => {
     return (0, util_1.u8aToHex)((0, util_1.compactStripLength)(value)[1]);
 };
 exports.compactHex = compactHex;
+const getParaId = async (chain) => {
+    const meta = await chain.head.meta;
+    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', (0, util_1.hexToU8a)(raw));
+};
+exports.getParaId = getParaId;

package/dist/utils/proof.d.ts

@@ -1,7 +1,15 @@
-import { HexString } from '@polkadot/util/types';
+import { HrmpChannelId } from '@polkadot/types/interfaces';
 import { u32 } from '@polkadot/types';
-export declare const WELL_KNOWN_KEYS: Record<string, HexString>;
+export declare const WELL_KNOWN_KEYS: {
+    EPOCH_INDEX: `0x${string}`;
+    CURRENT_BLOCK_RANDOMNESS: `0x${string}`;
+    ONE_EPOCH_AGO_RANDOMNESS: `0x${string}`;
+    TWO_EPOCHS_AGO_RANDOMNESS: `0x${string}`;
+    CURRENT_SLOT: `0x${string}`;
+    ACTIVE_CONFIG: `0x${string}`;
+};
 export declare const dmqMqcHead: (paraId: u32) => `0x${string}`;
 export declare const upgradeGoAheadSignal: (paraId: u32) => `0x${string}`;
 export declare const hrmpIngressChannelIndex: (paraId: u32) => `0x${string}`;
 export declare const hrmpEgressChannelIndex: (paraId: u32) => `0x${string}`;
+export declare const hrmpChannels: (channelId: HrmpChannelId) => `0x${string}`;