@acala-network/chopsticks 0.2.2 → 0.3.0

package/dist/index.js

@@ -3,150 +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 task_1 = require("./task");
-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 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 port = argv.port || Number(process.env.PORT) || 8000;
-    const tasks = new task_1.TaskManager(port, argv['mock-signature-host'], argv['executor-cmd']);
-    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(tasks, 1)]);
-    const chain = new blockchain_1.Blockchain({
-        api,
-        tasks,
-        buildBlockMode: argv['build-block-mode'],
-        inherentProvider: inherents,
-        db,
-        header: {
-            hash: blockHash,
-            number: Number(header.number),
-        },
-    });
-    const context = { chain, api, ws: provider, tasks };
-    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 { port: listeningPort, close } = (0, server_1.createServer)(port, (0, rpc_1.handler)(context));
-    context.tasks.updateListeningPort(await listeningPort);
-    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']);
-    await context.tasks.addAndRunTask({
-        Call: {
-            blockHash: parent,
-            wasm,
-            calls,
-        },
-    }, (output) => {
-        if (argv['output-path']) {
-            (0, node_fs_1.writeFileSync)(argv['output-path'], JSON.stringify(output, null, 2));
-        }
-        else {
-            console.dir(output, { 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,19 +54,12 @@ const defaultOptions = {
         desc: 'Port to listen on',
         number: true,
     },
-    'executor-cmd': {
-        desc: 'Command to execute the executor',
-        string: true,
-    },
     'output-path': {
         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,
@@ -200,10 +67,6 @@ const defaultOptions = {
         desc: 'Port to listen on',
         number: true,
     },
-    'executor-cmd': {
-        desc: 'Command to execute the executor',
-        string: true,
-    },
     'build-block-mode': {
         desc: 'Build block mode. Default to Batch',
         enum: [txpool_1.BuildBlockMode.Batch, txpool_1.BuildBlockMode.Manual, txpool_1.BuildBlockMode.Instant],
@@ -216,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', {
@@ -229,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/logger.d.ts

@@ -1,7 +1,9 @@
+import { HexString } from '@polkadot/util/types';
 export declare const defaultLogger: import("pino").Logger<{
     level: string;
     transport: {
         target: string;
     };
 }>;
-export declare const truncate: (str?: string) => string | undefined;
+export declare const truncate: (str: string | null) => string | null;
+export declare const truncateStorageDiff: (diff: [HexString, HexString | null][]) => [HexString, string | null][];

package/dist/logger.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.truncate = exports.defaultLogger = void 0;
+exports.truncateStorageDiff = exports.truncate = exports.defaultLogger = void 0;
 const pino_1 = __importDefault(require("pino"));
 exports.defaultLogger = (0, pino_1.default)({
     level: process.env.LOG_LEVEL || 'info',
@@ -23,3 +23,7 @@ const truncate = (str) => {
     }
 };
 exports.truncate = truncate;
+const truncateStorageDiff = (diff) => {
+    return diff.map(([key, value]) => [key, (0, exports.truncate)(value)]);
+};
+exports.truncateStorageDiff = truncateStorageDiff;

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/index.js

@@ -6,10 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handler = void 0;
 const shared_1 = require("./shared");
 const dev_1 = __importDefault(require("./dev"));
-const exec_1 = __importDefault(require("./exec"));
 const substrate_1 = __importDefault(require("./substrate"));
 const allHandlers = {
-    ...exec_1.default,
     ...substrate_1.default,
     ...dev_1.default,
 };

package/dist/rpc/shared.d.ts

@@ -1,7 +1,4 @@
-import { ProviderInterface } from '@polkadot/rpc-provider/types';
-import { Api } from '../api';
 import { Blockchain } from '../blockchain';
-import { TaskManager } from '../task';
 export declare const logger: import("pino").default.Logger<{
     level: string;
     transport: {
@@ -18,9 +15,6 @@ export declare class ResponseError extends Error {
 }
 export interface Context {
     chain: Blockchain;
-    api: Api;
-    ws: ProviderInterface;
-    tasks: TaskManager;
 }
 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.d.ts

@@ -65,7 +65,6 @@ export declare const configSchema: z.ZodObject<{
     port: z.ZodOptional<z.ZodNumber>;
     endpoint: z.ZodOptional<z.ZodString>;
     block: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    'executor-cmd': z.ZodOptional<z.ZodString>;
     'build-block-mode': z.ZodOptional<z.ZodNativeEnum<typeof BuildBlockMode>>;
     'import-storage': z.ZodOptional<z.ZodAny>;
     'mock-signature-host': z.ZodOptional<z.ZodBoolean>;
@@ -133,7 +132,6 @@ export declare const configSchema: z.ZodObject<{
     }>]>>;
     timestamp: z.ZodOptional<z.ZodNumber>;
 }, "strict", z.ZodTypeAny, {
-    port?: number | undefined;
     timestamp?: number | undefined;
     db?: string | undefined;
     genesis?: string | {
@@ -150,15 +148,14 @@ export declare const configSchema: z.ZodObject<{
             };
         };
     } | undefined;
+    port?: number | undefined;
     endpoint?: string | undefined;
     block?: string | number | undefined;
-    'executor-cmd'?: string | undefined;
     'build-block-mode'?: BuildBlockMode | undefined;
     'import-storage'?: any;
     'mock-signature-host'?: boolean | undefined;
     'wasm-override'?: string | undefined;
 }, {
-    port?: number | undefined;
     timestamp?: number | undefined;
     db?: string | undefined;
     genesis?: string | {
@@ -175,9 +172,9 @@ export declare const configSchema: z.ZodObject<{
             };
         };
     } | undefined;
+    port?: number | undefined;
     endpoint?: string | undefined;
     block?: string | number | undefined;
-    'executor-cmd'?: string | undefined;
     'build-block-mode'?: BuildBlockMode | undefined;
     'import-storage'?: any;
     'mock-signature-host'?: boolean | undefined;

package/dist/schema/index.js

@@ -17,8 +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(),
-    'executor-cmd': 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(),

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;
+}>;