@leofcoin/launch-chain 0.4.21 → 0.4.23

package/README.md

@@ -17,12 +17,30 @@ const { chain, endpoints, mode } = await launch(
 // when mode is direct means chain is directly available and no endpoint is needed to interact with it
 ```
 
+## command line
+
+No monorepo checkout or global install is required:
+
+```sh
+npx --package @leofcoin/launch-chain leofcoin --help
+```
+
+Run a normal syncing full node with HTTP and WebSocket endpoints:
+
+```sh
+npx --package @leofcoin/launch-chain leofcoin node
+```
+
+The same CLI exposes `node`, `validator`, `account`, `balance`, `status`, and
+`transfer` commands. `node` never registers as a validator. Only the explicit
+`validator` command checks validator eligibility and starts participation.
+
 ## run a validator
 
 No monorepo checkout is required. Run the validator directly from the published package:
 
 ```sh
-npx --package @leofcoin/launch-chain leofcoin-validator
+npx --package @leofcoin/launch-chain leofcoin validator
 ```
 
 The first run uses the normal interactive identity-password prompt. A new account must receive
@@ -43,7 +61,29 @@ process can replace a separate launch-chain server. Change them with `--http-por
 or use `--no-endpoints` for a validator that should not expose an API.
 
 Never put the password or an identity backup in a command-line argument, service file, or Git.
-Use `leofcoin-validator --help` for all options.
+The legacy `leofcoin-validator` command remains an alias for `leofcoin validator`.
+Use `leofcoin --help` for all commands and options.
+
+### send LFC from the local validator
+
+When the validator runs in a terminal it exposes a local wallet shell. Private keys never leave
+the process:
+
+```text
+leofcoin> account
+leofcoin> balance
+leofcoin> transfer YTq... 1000
+```
+
+When the node is stopped, a one-shot transfer can start the same local identity,
+finalize the transfer, and exit. It does not register or participate as a validator:
+
+```sh
+npx --package @leofcoin/launch-chain leofcoin transfer YTq... 1000 \
+  --password-file /secure/leofcoin/password
+```
+
+Do not run the daemon and one-shot command simultaneously against the same data root.
 
 ## options
 

package/exports/cli-options.d.ts

@@ -0,0 +1,14 @@
+export type CliCommand = 'node' | 'validator' | 'account' | 'balance' | 'status' | 'transfer' | 'help' | 'version';
+export type CliOptions = {
+    command: CliCommand;
+    positionals: string[];
+    network?: string;
+    root?: string;
+    passwordFile?: string;
+    intervalMinutes?: number;
+    httpPort: number | false;
+    wsPort: number | false;
+    shell: boolean;
+    stars?: string[];
+};
+export declare const parseCliOptions: (args: string[]) => CliOptions;

package/exports/cli-options.js

@@ -0,0 +1,66 @@
+const commands = new Set(['node', 'validator', 'account', 'balance', 'status', 'transfer', 'help', 'version']);
+const port = (name, value) => {
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed < 1 || parsed > 65_535)
+        throw new Error(`${name} must be a valid port`);
+    return parsed;
+};
+const parseCliOptions = (args) => {
+    let command;
+    const positionals = [];
+    const stars = [];
+    const options = { command: 'help', positionals, httpPort: 8080, wsPort: 4040, shell: true };
+    const value = (index, name) => {
+        const result = args[index + 1];
+        if (!result || result.startsWith('-'))
+            throw new Error(`${name} requires a value`);
+        return result;
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index];
+        if (argument === '-h' || argument === '--help')
+            command = 'help';
+        else if (argument === '-v' || argument === '--version')
+            command = 'version';
+        else if (argument === '--network')
+            options.network = value(index++, argument);
+        else if (argument === '--root')
+            options.root = value(index++, argument);
+        else if (argument === '--password-file')
+            options.passwordFile = value(index++, argument);
+        else if (argument === '--interval') {
+            options.intervalMinutes = Number(value(index++, argument));
+            if (!Number.isFinite(options.intervalMinutes) || options.intervalMinutes < 1)
+                throw new Error('--interval must be at least one minute');
+        }
+        else if (argument === '--http-port')
+            options.httpPort = port(argument, value(index++, argument));
+        else if (argument === '--ws-port')
+            options.wsPort = port(argument, value(index++, argument));
+        else if (argument === '--no-endpoints') {
+            options.httpPort = false;
+            options.wsPort = false;
+        }
+        else if (argument === '--no-shell')
+            options.shell = false;
+        else if (argument === '--star')
+            stars.push(value(index++, argument));
+        else if (argument === '--no-stars')
+            options.stars = [];
+        else if (argument.startsWith('-'))
+            throw new Error(`unknown option: ${argument}`);
+        else if (!command) {
+            if (!commands.has(argument))
+                throw new Error(`unknown command: ${argument}`);
+            command = argument;
+        }
+        else
+            positionals.push(argument);
+    }
+    options.command = command ?? 'help';
+    if (stars.length > 0)
+        options.stars = stars;
+    return options;
+};
+
+export { parseCliOptions };

package/exports/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export declare const help = "Leofcoin command line\n\nUsage:\n  leofcoin node [options]                     Run a normal full node\n  leofcoin validator [options]                Run a validator node\n  leofcoin account [options]                  Show the local account\n  leofcoin balance [address] [options]        Show an LFC balance\n  leofcoin status [options]                   Show local chain status\n  leofcoin transfer <address> <LFC> [options] Send LFC and await finalization\n\nOptions:\n  --network <name>        Network (default: leofcoin:peach)\n  --root <path>           Persistent data directory\n  --password-file <path>  Read the identity password from a private file\n  --star <url>            Discovery star; repeat for multiple stars\n  --no-stars              Disable discovery stars\n  --http-port <port>      HTTP API port (default: 8080)\n  --ws-port <port>        WebSocket API port (default: 4040)\n  --no-endpoints          Disable HTTP and WebSocket endpoints\n  --no-shell              Disable the interactive wallet shell\n  --interval <minutes>    Validator heartbeat interval (default: 5)\n  -h, --help              Show help\n  -v, --version           Show version\n\nPasswords are never accepted as command-line values. Use --password-file,\nLEOFCOIN_PASSWORD_FILE, LEOFCOIN_PASSWORD, or the interactive password prompt.\n";
+export declare const runCli: (args?: string[]) => Promise<undefined>;

package/exports/cli.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { resolve, isAbsolute, relative } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createInterface } from 'node:readline/promises';
+import { parseCliOptions } from './cli-options.js';
+import { startNode } from './node.js';
+import { startValidator } from './validator.js';
+import '@leofcoin/lib';
+import '@leofcoin/networks';
+import './index.js';
+import '@leofcoin/chain/node';
+import '@leofcoin/chain/chain';
+import '@leofcoin/lib/node-config';
+import '@leofcoin/endpoint-clients/ws';
+import '@leofcoin/endpoint-clients/http';
+import '@leofcoin/addresses';
+
+const help = `Leofcoin command line
+
+Usage:
+  leofcoin node [options]                     Run a normal full node
+  leofcoin validator [options]                Run a validator node
+  leofcoin account [options]                  Show the local account
+  leofcoin balance [address] [options]        Show an LFC balance
+  leofcoin status [options]                   Show local chain status
+  leofcoin transfer <address> <LFC> [options] Send LFC and await finalization
+
+Options:
+  --network <name>        Network (default: leofcoin:peach)
+  --root <path>           Persistent data directory
+  --password-file <path>  Read the identity password from a private file
+  --star <url>            Discovery star; repeat for multiple stars
+  --no-stars              Disable discovery stars
+  --http-port <port>      HTTP API port (default: 8080)
+  --ws-port <port>        WebSocket API port (default: 4040)
+  --no-endpoints          Disable HTTP and WebSocket endpoints
+  --no-shell              Disable the interactive wallet shell
+  --interval <minutes>    Validator heartbeat interval (default: 5)
+  -h, --help              Show help
+  -v, --version           Show version
+
+Passwords are never accepted as command-line values. Use --password-file,
+LEOFCOIN_PASSWORD_FILE, LEOFCOIN_PASSWORD, or the interactive password prompt.
+`;
+const packageVersion = async () => {
+    const manifest = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8'));
+    return manifest.version;
+};
+const passwordFor = async (passwordFile) => {
+    const file = passwordFile ?? process.env.LEOFCOIN_PASSWORD_FILE;
+    if (!file)
+        return process.env.LEOFCOIN_PASSWORD;
+    const password = (await readFile(resolve(file), 'utf8')).trim();
+    if (!password)
+        throw new Error(`empty identity password file: ${resolve(file)}`);
+    return password;
+};
+// @leofcoin/storage resolves its root below the home directory. Convert an
+// absolute CLI path to the equivalent home-relative path before it reaches the
+// storage layer, so `--root /var/lib/leofcoin` remains truly absolute.
+const dataRootFor = (root) => root && isAbsolute(root) ? relative(homedir(), root) : root;
+const amountFor = (chain, value) => {
+    if (!value)
+        throw new Error('transfer amount is required');
+    try {
+        const amount = BigInt(chain.utils.parseUnits(value));
+        if (amount <= 0n)
+            throw new Error();
+        return amount;
+    }
+    catch {
+        throw new Error('transfer amount must be a positive LFC amount');
+    }
+};
+const showStatus = async (handle) => {
+    const chain = handle.chain;
+    const lastBlock = await chain.lastBlock;
+    const balance = await chain.balanceOf(handle.account);
+    process.stdout.write(`network: ${chain.network ?? 'leofcoin'}\n`);
+    process.stdout.write(`account: ${handle.account}\n`);
+    process.stdout.write(`balance: ${chain.utils.formatUnits(balance)} LFC\n`);
+    process.stdout.write(`height: ${lastBlock?.index ?? 'unknown'}\n`);
+    for (const url of handle.endpoints.http)
+        process.stdout.write(`http: ${url}\n`);
+    for (const url of handle.endpoints.ws)
+        process.stdout.write(`ws: ${url}\n`);
+};
+const runShell = async (handle) => {
+    const shell = createInterface({ input: process.stdin, output: process.stdout });
+    const chain = handle.chain;
+    process.stdout.write('wallet shell ready; type help for commands\n');
+    while (true) {
+        const [command, ...values] = (await shell.question('leofcoin> ')).trim().split(/\s+/);
+        try {
+            if (!command)
+                continue;
+            if (command === 'account')
+                process.stdout.write(`${handle.account}\n`);
+            else if (command === 'balance') {
+                const balance = await chain.balanceOf(values[0] ?? handle.account);
+                process.stdout.write(`${chain.utils.formatUnits(balance)} LFC\n`);
+            }
+            else if (command === 'status')
+                await showStatus(handle);
+            else if (command === 'transfer') {
+                const hash = await handle.transfer(values[0], amountFor(chain, values[1]));
+                process.stdout.write(`transfer finalized: ${hash}\n`);
+            }
+            else if (command === 'help') {
+                process.stdout.write('account | balance [address] | status | transfer <address> <LFC> | exit\n');
+            }
+            else if (command === 'exit' || command === 'quit') {
+                shell.close();
+                break;
+            }
+            else
+                process.stderr.write(`unknown command: ${command}\n`);
+        }
+        catch (error) {
+            process.stderr.write(`${error?.message ?? error}\n`);
+        }
+    }
+};
+const runCli = async (args = process.argv.slice(2)) => {
+    const options = parseCliOptions(args);
+    if (options.command === 'help')
+        return void process.stdout.write(help);
+    if (options.command === 'version')
+        return void process.stdout.write(`${await packageVersion()}\n`);
+    const common = {
+        network: options.network ?? process.env.LEOFCOIN_NETWORK,
+        root: dataRootFor(options.root ?? process.env.LEOFCOIN_DATA_ROOT),
+        password: await passwordFor(options.passwordFile),
+        stars: options.stars,
+        httpPort: options.httpPort,
+        wsPort: options.wsPort
+    };
+    const handle = options.command === 'validator'
+        ? await startValidator({ ...common, intervalMinutes: options.intervalMinutes })
+        : await startNode(common);
+    const nodeHandle = handle;
+    const chain = nodeHandle.chain;
+    const shutdown = (signal) => {
+        process.stdout.write(`received ${signal}; stopping node\n`);
+        nodeHandle.stop();
+        setTimeout(() => process.exit(0), 100);
+    };
+    process.once('SIGINT', () => shutdown('SIGINT'));
+    process.once('SIGTERM', () => shutdown('SIGTERM'));
+    if (options.command === 'account')
+        process.stdout.write(`${nodeHandle.account}\n`);
+    else if (options.command === 'balance') {
+        const balance = await chain.balanceOf(options.positionals[0] ?? nodeHandle.account);
+        process.stdout.write(`${chain.utils.formatUnits(balance)} LFC\n`);
+    }
+    else if (options.command === 'status')
+        await showStatus(nodeHandle);
+    else if (options.command === 'transfer') {
+        const to = options.positionals[0];
+        if (!to)
+            throw new Error('transfer recipient is required');
+        const hash = await nodeHandle.transfer(to, amountFor(chain, options.positionals[1]));
+        process.stdout.write(`transfer finalized: ${hash}\n`);
+    }
+    else {
+        process.stdout.write(`${options.command} account: ${nodeHandle.account}\n`);
+        if (options.shell && process.stdin.isTTY)
+            await runShell(nodeHandle);
+        else
+            return;
+    }
+    nodeHandle.stop();
+    // Peernet and endpoint servers currently expose no shared async close API.
+    // Give pending output a moment to flush, then make one-shot commands and an
+    // explicitly closed interactive shell terminate predictably.
+    setTimeout(() => process.exit(0), 100);
+};
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    runCli().catch((error) => {
+        process.stderr.write(`leofcoin: ${error?.message ?? error}\n`);
+        process.exitCode = 1;
+    });
+}
+
+export { help, runCli };

package/exports/node.d.ts

@@ -0,0 +1,22 @@
+import Chain from '@leofcoin/chain/chain';
+export type LocalNodeOptions = {
+    network?: string;
+    networkVersion?: string;
+    stars?: string[];
+    root?: string;
+    password?: string;
+    httpPort?: number | false;
+    wsPort?: number | false;
+    signal?: AbortSignal;
+};
+export type LocalNodeHandle = {
+    account: string;
+    chain: Chain;
+    endpoints: {
+        http: string[];
+        ws: string[];
+    };
+    transfer: (to: string, amount: bigint) => Promise<string>;
+    stop: () => void;
+};
+export declare const startNode: (options?: LocalNodeOptions) => Promise<LocalNodeHandle>;

package/exports/node.js

@@ -0,0 +1,53 @@
+import { signTransaction } from '@leofcoin/lib';
+import networks from '@leofcoin/networks';
+import launch from './index.js';
+import '@leofcoin/chain/node';
+import '@leofcoin/chain/chain';
+import '@leofcoin/lib/node-config';
+import '@leofcoin/endpoint-clients/ws';
+import '@leofcoin/endpoint-clients/http';
+
+const startNode = async (options = {}) => {
+    const network = options.network ?? 'leofcoin:peach';
+    const networkVersion = options.networkVersion ?? network.split(':')[1] ?? 'peach';
+    const stars = options.stars ?? networks.leofcoin.peach.stars;
+    const controller = new AbortController();
+    options.signal?.addEventListener('abort', () => controller.abort(options.signal?.reason), { once: true });
+    const launched = await launch({
+        mode: 'direct', network, networkVersion, stars, root: options.root,
+        http: options.httpPort === false ? [] : [{ port: options.httpPort ?? 8080 }],
+        ws: options.wsPort === false ? [] : [{ port: options.wsPort ?? 4040 }]
+    }, options.password);
+    if (!launched.chain)
+        throw new Error('node launch did not create a direct chain runtime');
+    const chain = launched.chain;
+    const chainRuntime = chain;
+    const peernet = globalThis.peernet;
+    const account = peernet?.selectedAccount;
+    if (!account)
+        throw new Error('node identity has no selected account');
+    const transfer = async (to, amount) => {
+        if (!to)
+            throw new Error('transfer recipient is required');
+        if (amount <= 0n)
+            throw new Error('transfer amount must be greater than zero');
+        const balance = BigInt(await chainRuntime.balanceOf(account));
+        if (balance < amount)
+            throw new Error(`insufficient balance: have ${balance}, need at least ${amount}`);
+        const raw = await chainRuntime.createTransaction({
+            from: account, to: chain.nativeToken, method: 'transfer', params: [to, amount]
+        });
+        const signed = await signTransaction(raw, peernet.identity);
+        const pending = await chainRuntime.sendTransaction(signed);
+        return pending.wait;
+    };
+    return {
+        account,
+        chain,
+        endpoints: launched.endpoints,
+        transfer,
+        stop: () => controller.abort(new Error('node stopped'))
+    };
+};
+
+export { startNode };

package/exports/validator-cli.js

@@ -1,8 +1,12 @@
 #!/usr/bin/env node
-import { readFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import { startValidator } from './validator.js';
-import '@leofcoin/addresses';
+import { runCli } from './cli.js';
+import 'node:fs/promises';
+import 'node:os';
+import 'node:path';
+import 'node:url';
+import 'node:readline/promises';
+import './cli-options.js';
+import './node.js';
 import '@leofcoin/lib';
 import '@leofcoin/networks';
 import './index.js';
@@ -11,62 +15,10 @@ import '@leofcoin/chain/chain';
 import '@leofcoin/lib/node-config';
 import '@leofcoin/endpoint-clients/ws';
 import '@leofcoin/endpoint-clients/http';
+import './validator.js';
+import '@leofcoin/addresses';
 
-const args = process.argv.slice(2);
-const valueAfter = (name) => {
-    const index = args.indexOf(name);
-    if (index === -1)
-        return undefined;
-    const value = args[index + 1];
-    if (value === undefined || value.startsWith('--'))
-        throw new Error(`${name} requires a value`);
-    return value;
-};
-if (args.includes('--help') || args.includes('-h')) {
-    process.stdout.write(`Usage: leofcoin-validator [options]
-
-Options:
-  --network <name>           Network (default: leofcoin:peach)
-  --root <path>              Persistent Leofcoin data directory
-  --password-file <path>     Read the identity password from a private file
-  --interval <minutes>       Heartbeat interval (default: 5, minimum: 1)
-  --http-port <port>         HTTP API port (default: 8080)
-  --ws-port <port>           WebSocket API port (default: 4040)
-  --no-endpoints             Disable both API endpoints
-  -h, --help                 Show this help
-
-Without --password-file, LEOFCOIN_PASSWORD is used when set. Otherwise the
-standard interactive password prompt is shown. Never pass a password directly
-as a command-line argument.
-`);
-    process.exit(0);
-}
-const passwordFile = valueAfter('--password-file') ?? process.env.LEOFCOIN_PASSWORD_FILE;
-const password = passwordFile
-    ? (await readFile(resolve(passwordFile), 'utf8')).trim()
-    : process.env.LEOFCOIN_PASSWORD;
-if (passwordFile && !password)
-    throw new Error(`empty validator password file: ${resolve(passwordFile)}`);
-const intervalValue = valueAfter('--interval') ?? process.env.LEOFCOIN_TRANSACTION_INTERVAL_MINUTES;
-const noEndpoints = args.includes('--no-endpoints');
-const port = (name, fallback) => {
-    const value = Number(valueAfter(name) ?? fallback);
-    if (!Number.isSafeInteger(value) || value < 1 || value > 65_535)
-        throw new Error(`${name} must be a valid port`);
-    return value;
-};
-const handle = await startValidator({
-    network: valueAfter('--network') ?? process.env.LEOFCOIN_NETWORK,
-    root: valueAfter('--root') ?? process.env.LEOFCOIN_DATA_ROOT,
-    password,
-    intervalMinutes: intervalValue === undefined ? undefined : Number(intervalValue),
-    httpPort: noEndpoints ? false : port('--http-port', 8080),
-    wsPort: noEndpoints ? false : port('--ws-port', 4040)
+runCli(['validator', ...process.argv.slice(2)]).catch((error) => {
+    process.stderr.write(`leofcoin-validator: ${error?.message ?? error}\n`);
+    process.exitCode = 1;
 });
-const shutdown = (signal) => {
-    process.stdout.write(`received ${signal}; stopping validator\n`);
-    handle.stop();
-    setTimeout(() => process.exit(0), 100);
-};
-process.once('SIGINT', () => shutdown('SIGINT'));
-process.once('SIGTERM', () => shutdown('SIGTERM'));

package/exports/validator.d.ts

@@ -9,12 +9,18 @@ export type ValidatorOptions = {
     registrationTimeoutMs?: number;
     httpPort?: number | false;
     wsPort?: number | false;
+    heartbeat?: boolean;
     signal?: AbortSignal;
     logger?: Pick<Console, 'log' | 'warn' | 'error'>;
 };
 export type ValidatorHandle = {
     account: string;
     chain: Chain;
+    endpoints: {
+        http: string[];
+        ws: string[];
+    };
+    transfer: (to: string, amount: bigint) => Promise<string>;
     stop: () => void;
 };
 export declare const validateIntervalMinutes: (value: number) => number;

package/exports/validator.js

@@ -1,7 +1,8 @@
 import addresses from '@leofcoin/addresses';
-import { signTransaction } from '@leofcoin/lib';
-import networks from '@leofcoin/networks';
-import launch from './index.js';
+import { startNode } from './node.js';
+import '@leofcoin/lib';
+import '@leofcoin/networks';
+import './index.js';
 import '@leofcoin/chain/node';
 import '@leofcoin/chain/chain';
 import '@leofcoin/lib/node-config';
@@ -29,24 +30,22 @@ const validateIntervalMinutes = (value) => {
 const startValidator = async (options = {}) => {
     const network = options.network ?? 'leofcoin:peach';
     const networkVersion = options.networkVersion ?? network.split(':')[1] ?? 'peach';
-    const stars = options.stars ?? networks.leofcoin.peach.stars;
     const intervalMinutes = validateIntervalMinutes(options.intervalMinutes ?? 5);
     const registrationTimeoutMs = options.registrationTimeoutMs ?? 5 * 60_000;
     const logger = options.logger ?? console;
     const controller = new AbortController();
     options.signal?.addEventListener('abort', () => controller.abort(options.signal?.reason), { once: true });
-    const launched = await launch({
-        mode: 'direct',
+    const node = await startNode({
         network,
         networkVersion,
-        stars,
+        stars: options.stars,
         root: options.root,
-        http: options.httpPort === false ? [] : [{ port: options.httpPort ?? 8080 }],
-        ws: options.wsPort === false ? [] : [{ port: options.wsPort ?? 4040 }]
-    }, options.password);
-    if (!launched.chain)
-        throw new Error('validator launch did not create a direct chain runtime');
-    const chain = launched.chain;
+        password: options.password,
+        httpPort: options.httpPort,
+        wsPort: options.wsPort,
+        signal: controller.signal
+    });
+    const chain = node.chain;
     const chainRuntime = chain;
     const peernet = globalThis.peernet;
     const account = peernet?.selectedAccount;
@@ -79,6 +78,7 @@ const startValidator = async (options = {}) => {
         throw new Error('validator is registered but participation did not activate');
     }
     logger.log('validator participation active');
+    const transfer = node.transfer;
     let sending = false;
     const heartbeat = async () => {
         if (controller.signal.aborted || sending)
@@ -90,15 +90,7 @@ const startValidator = async (options = {}) => {
                 logger.warn(`heartbeat skipped: balance ${balance} is too low`);
                 return;
             }
-            const raw = await chainRuntime.createTransaction({
-                from: account,
-                to: chain.nativeToken,
-                method: 'transfer',
-                params: [account, account, 1n]
-            });
-            const signed = await signTransaction(raw, peernet.identity);
-            const pending = await chainRuntime.sendTransaction(signed);
-            const hash = await pending.wait;
+            const hash = await transfer(account, 1n);
             logger.log(`heartbeat transaction finalized: ${hash}`);
         }
         catch (error) {
@@ -108,16 +100,22 @@ const startValidator = async (options = {}) => {
             sending = false;
         }
     };
-    await heartbeat();
-    const interval = setInterval(heartbeat, intervalMinutes * 60_000);
+    // Startup must not wait for a transaction to finalize. In particular, the
+    // interactive wallet shell and API endpoints must remain available while a
+    // single-node validator is still trying to produce/finalize its heartbeat.
+    if (options.heartbeat !== false)
+        void heartbeat();
+    const interval = options.heartbeat === false ? undefined : setInterval(heartbeat, intervalMinutes * 60_000);
     const stop = () => {
         if (controller.signal.aborted)
             return;
         controller.abort(new Error('validator stopped'));
-        clearInterval(interval);
+        node.stop();
+        if (interval)
+            clearInterval(interval);
     };
-    controller.signal.addEventListener('abort', () => clearInterval(interval), { once: true });
-    return { account, chain, stop };
+    controller.signal.addEventListener('abort', () => interval && clearInterval(interval), { once: true });
+    return { account, chain, endpoints: node.endpoints, transfer, stop };
 };
 
 export { startValidator, validateIntervalMinutes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/launch-chain",
-  "version": "0.4.21",
+  "version": "0.4.23",
   "description": "",
   "exports": {
     ".": {
@@ -10,9 +10,14 @@
     "./validator": {
       "import": "./exports/validator.js",
       "types": "./exports/validator.d.ts"
+    },
+    "./node": {
+      "import": "./exports/node.js",
+      "types": "./exports/node.d.ts"
     }
   },
   "bin": {
+    "leofcoin": "./exports/cli.js",
     "leofcoin-validator": "./exports/validator-cli.js"
   },
   "files": [
@@ -41,7 +46,8 @@
     "@leofcoin/endpoint-clients": "^0.3.16",
     "@leofcoin/endpoints": "^0.4.9",
     "@leofcoin/lib": "^1.3.10",
-    "@leofcoin/networks": "^1.1.30"
+    "@leofcoin/networks": "^1.1.30",
+    "@vandeurenglenn/wrtc": "^0.5.5"
   },
   "devDependencies": {
     "@rollup/plugin-typescript": "^12.3.0",