@leofcoin/launch-chain 0.5.0 → 0.5.1

package/README.md

@@ -102,8 +102,46 @@ the process:
 leofcoin> account
 leofcoin> balance
 leofcoin> transfer YTq... 1000
+leofcoin> batch
 ```
 
+### interactive testnet batch
+
+Type `batch` in the existing node or validator wallet shell. It uses the already
+unlocked wallet and selected account in that process: **no wallet export, password
+file, extra endpoint, or second node is required**.
+When the node is stopped, `leofcoin batch [options]` opens the existing local
+wallet in a normal non-participating node and starts the same wizard. It requires
+a terminal. Do not run it alongside a node using the same root.
+
+The wizard asks for transaction count (default 100,000), recipient (default self),
+LFC per transaction (default one atom), and concurrency (default 32). Smaller and
+larger positive safe-integer counts are supported. Enter `yes` to prepare; after
+signing and exact fee/balance checks, enter `SEND` to actually enqueue.
+Anything else at either confirmation cancels without sending.
+
+Only a synced, connected Peach node is accepted. Local validator heartbeats are
+paused while the wizard owns the wallet. A transfer already awaiting finalization
+must finish first. Do not use this account from another node, wallet UI or API
+during the batch; the wizard rechecks its nonce before sending but cannot reserve
+the key across other processes.
+
+All transactions are signed before submission; concurrency bounds simultaneous
+admission calls, not total pool size. Submissions do not wait for blocks, and
+`admitted` is not finality. Self-transfers recycle principal but still need the
+transfer amount plus all fees. Preparing very large batches uses time and memory.
+Only load testnets you own or have permission to test.
+
+Receipts are automatically saved under `~/.leofcoin/batch-receipts/` in a unique
+mode-0600 JSONL file. Each attempted transaction records its signed public fields
+before submission, then hash/status after admission. No private keys or passwords
+are stored. Errors stop new calls and drain in-flight work; unknown transactions
+may still finalize. Reconcile the journal and pending/canonical state before
+retrying; no automatic retry or cancellation of admitted transactions occurs.
+
+The standalone [batch script](../../docs/testnet-batch.md) remains available for
+automation with explicit encrypted signer files.
+
 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:
 

package/exports/batch.d.ts

@@ -0,0 +1,30 @@
+import { signTransaction } from '@leofcoin/lib';
+type SignedTransaction = Awaited<ReturnType<typeof signTransaction>>;
+type JournalEntry = Record<string, string | number | boolean>;
+export type BatchJournal = {
+    path: string;
+    append: (entry: JournalEntry) => Promise<void>;
+    close: () => Promise<void>;
+};
+export type BatchWallet = {
+    account: string;
+    identity: () => Promise<unknown>;
+    connected: () => boolean;
+    balance: () => Promise<bigint>;
+    nonce: () => Promise<number>;
+    parseAmount: (value: string) => bigint;
+    formatAmount: (value: bigint) => string;
+    sign: (nonce: number, to: string, amount: bigint) => Promise<SignedTransaction>;
+    submit: (transaction: SignedTransaction) => Promise<{
+        hash: string;
+        wait: Promise<unknown>;
+    }>;
+};
+export type BatchInteraction = {
+    question: (prompt: string) => Promise<string>;
+    log: (message: string) => void;
+    createJournal?: () => Promise<BatchJournal>;
+};
+/** Uses the running node's signer; never starts another node or opens wallet stores. */
+export declare function interactiveBatch(wallet: BatchWallet, interaction: BatchInteraction): Promise<void>;
+export {};

package/exports/batch.js

@@ -0,0 +1,140 @@
+import { mkdir, open } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { calculateFee } from '@leofcoin/lib';
+import { verifyChainIdentity, createChainIdentity } from '@leofcoin/lib/chain-identity';
+import addresses from '@leofcoin/addresses';
+
+const createJournal = async () => {
+    const directory = join(homedir(), '.leofcoin', 'batch-receipts');
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const path = join(directory, `${Date.now()}-${randomUUID()}.jsonl`);
+    const file = await open(path, 'wx', 0o600);
+    let tail = Promise.resolve();
+    return {
+        path,
+        append: entry => {
+            tail = tail.then(async () => { await file.writeFile(JSON.stringify(entry) + '\n'); await file.sync(); });
+            return tail;
+        },
+        close: () => file.close()
+    };
+};
+const positiveInteger = (value, label, maximum = Number.MAX_SAFE_INTEGER) => {
+    if (!/^[1-9]\d*$/.test(value))
+        throw new Error(`${label} must be a positive integer`);
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed > maximum)
+        throw new Error(`${label} exceeds ${maximum}`);
+    return parsed;
+};
+/** Uses the running node's signer; never starts another node or opens wallet stores. */
+async function interactiveBatch(wallet, interaction) {
+    const { question, log } = interaction;
+    const identity = await verifyChainIdentity(await wallet.identity());
+    const expected = await createChainIdentity('leofcoin:peach', addresses);
+    if (identity.network !== 'leofcoin:peach' || identity.chainId !== expected.chainId)
+        throw new Error('Batch sending is only available on the expected Peach testnet');
+    if (!wallet.connected())
+        throw new Error('Node must be synced and connected before batch sending');
+    log(`Testnet batch wallet: ${wallet.account}`);
+    log(`Balance: ${wallet.formatAmount(await wallet.balance())} LFC`);
+    const count = positiveInteger((await question('Number of transactions [100000]: ')).trim() || '100000', 'count');
+    const to = (await question(`Recipient [self: ${wallet.account}]: `)).trim() || wallet.account;
+    const defaultAmount = wallet.formatAmount(1n);
+    const amount = wallet.parseAmount((await question(`LFC per transaction [${defaultAmount}]: `)).trim() || defaultAmount);
+    if (amount <= 0n)
+        throw new Error('Amount must be positive');
+    const concurrency = positiveInteger((await question('Concurrent submissions [32]: ')).trim() || '32', 'concurrency', 1024);
+    log(`${count} transactions to ${to}, ${wallet.formatAmount(amount)} LFC each; concurrency ${concurrency}.`);
+    log('Uses your unlocked wallet. Fees apply; admission is not finalization. Only load networks you are permitted to test.');
+    if ((await question('Prepare this batch? Type yes: ')).trim().toLowerCase() !== 'yes') {
+        log('Batch cancelled; no transactions sent.');
+        return;
+    }
+    const startNonce = await wallet.nonce();
+    if (!Number.isSafeInteger(startNonce) || startNonce < 0 || !Number.isSafeInteger(startNonce + count))
+        throw new Error('Invalid or unsafe nonce range');
+    const transactions = [];
+    let fees = 0n;
+    for (let index = 0; index < count; index++) {
+        const signed = await wallet.sign(startNonce + index + 1, to, amount);
+        fees += BigInt(await calculateFee(signed));
+        transactions.push(signed);
+        if ((index + 1) % 1000 === 0)
+            log(`Signed ${index + 1}/${count}`);
+    }
+    // Self-transfers recycle principal, but still need enough for a transfer plus
+    // every fee. Fees are not assumed to return as validator rewards.
+    const principal = to === wallet.account ? amount : amount * BigInt(count);
+    const required = principal + fees;
+    const balance = await wallet.balance();
+    log(`Total fees: ${wallet.formatAmount(fees)} LFC; required balance: ${wallet.formatAmount(required)} LFC.`);
+    if (balance < required)
+        throw new Error('Insufficient wallet balance for this batch including fees');
+    if ((await question(`Send ${count} testnet transactions now? Type SEND: `)).trim() !== 'SEND') {
+        log('Batch cancelled; no transactions sent.');
+        return;
+    }
+    if (!wallet.connected())
+        throw new Error('Node is no longer synced and connected; no transactions sent');
+    if (await wallet.nonce() !== startNonce)
+        throw new Error('Wallet nonce changed; no transactions sent. Stop other senders using this wallet');
+    if (await wallet.balance() < required)
+        throw new Error('Wallet balance changed; no transactions sent');
+    const journal = await (interaction.createJournal ?? createJournal)();
+    log(`Receipts: ${journal.path}`);
+    let next = 0;
+    let attempted = 0;
+    let admitted = 0;
+    let failed = false;
+    let failure;
+    try {
+        await journal.append({ status: 'prepared', account: wallet.account, to, count, amountAtoms: String(amount),
+            feeAtoms: String(fees), chainId: identity.chainId, firstNonce: startNonce + 1, lastNonce: startNonce + count });
+        const workers = await Promise.allSettled(Array.from({ length: Math.min(count, concurrency) }, async () => {
+            while (!failed && next < count) {
+                const index = next++;
+                const nonce = startNonce + index + 1;
+                let dispatched = false;
+                try {
+                    await journal.append({ status: 'attempting', nonce, from: wallet.account, contract: addresses.nativeToken,
+                        method: 'transfer', to, amountAtoms: String(amount), timestamp: transactions[index].timestamp,
+                        signature: String(transactions[index].signature) });
+                    dispatched = true;
+                    attempted++;
+                    const pending = await wallet.submit(transactions[index]);
+                    if (!pending?.hash || !pending.wait || typeof pending.wait.then !== 'function')
+                        throw new Error('Node returned an invalid admission handle');
+                    void pending.wait.catch(error => log(`Transaction ${pending.hash} failed after admission: ${String(error)}`));
+                    await journal.append({ status: 'admitted', nonce, hash: pending.hash });
+                    admitted++;
+                    if (admitted % 1000 === 0)
+                        log(`Admitted ${admitted}/${count}`);
+                }
+                catch (error) {
+                    failed = true;
+                    failure ??= error;
+                    await journal.append({ status: dispatched ? 'unknown' : 'not-sent', nonce,
+                        error: error instanceof Error ? error.message : String(error) });
+                }
+            }
+        }));
+        const rejected = workers.find(result => result.status === 'rejected');
+        if (rejected?.status === 'rejected') {
+            failed = true;
+            failure ??= rejected.reason;
+        }
+        await journal.append({ status: failed ? 'interrupted' : 'admitted', requested: count, attempted,
+            admitted, unsent: count - attempted, finalized: false });
+        log(`Batch: ${admitted}/${count} admitted; ${count - attempted} unsent. Not a finalization result.`);
+        if (failed)
+            throw new Error(`Batch stopped; reconcile ${journal.path} before retrying. Some transactions may still finalize`, { cause: failure });
+    }
+    finally {
+        await journal.close();
+    }
+}
+
+export { interactiveBatch };

package/exports/cli-options.d.ts

@@ -1,4 +1,4 @@
-export type CliCommand = 'node' | 'validator' | 'account' | 'balance' | 'status' | 'transfer' | 'help' | 'version';
+export type CliCommand = 'node' | 'validator' | 'account' | 'balance' | 'status' | 'transfer' | 'batch' | 'help' | 'version';
 export type CliOptions = {
     command: CliCommand;
     positionals: string[];

package/exports/cli-options.js

@@ -1,4 +1,4 @@
-const commands = new Set(['node', 'validator', 'account', 'balance', 'status', 'transfer', 'help', 'version']);
+const commands = new Set(['node', 'validator', 'account', 'balance', 'status', 'transfer', 'batch', 'help', 'version']);
 const port = (name, value) => {
     const parsed = Number(value);
     if (!Number.isSafeInteger(parsed) || parsed < 1 || parsed > 65_535)

package/exports/cli.d.ts

@@ -1,3 +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 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  leofcoin batch [options]                   Interactive testnet burst using the local wallet\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.\nIn the wallet shell, type batch for an interactive Peach transaction burst\nusing the already unlocked wallet (no separate wallet export or endpoint needed).\n";
 export declare const runCli: (args?: string[]) => Promise<undefined>;

package/exports/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { readFile } from 'node:fs/promises';
+import { lstat, readFile } from 'node:fs/promises';
 import { realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { resolve, isAbsolute, relative } from 'node:path';
+import { resolve, join, isAbsolute, relative } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { createInterface } from 'node:readline/promises';
 import { parseCliOptions } from './cli-options.js';
@@ -16,6 +16,9 @@ import '@leofcoin/chain/chain';
 import '@leofcoin/lib/node-config';
 import '@leofcoin/endpoint-clients/ws';
 import '@leofcoin/endpoint-clients/http';
+import './batch.js';
+import 'node:crypto';
+import '@leofcoin/lib/chain-identity';
 import '@leofcoin/addresses';
 
 const help = `Leofcoin command line
@@ -27,6 +30,7 @@ Usage:
   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
+  leofcoin batch [options]                   Interactive testnet burst using the local wallet
 
 Options:
   --network <name>        Network (default: leofcoin:peach)
@@ -44,6 +48,8 @@ Options:
 
 Passwords are never accepted as command-line values. Use --password-file,
 LEOFCOIN_PASSWORD_FILE, LEOFCOIN_PASSWORD, or the interactive password prompt.
+In the wallet shell, type batch for an interactive Peach transaction burst
+using the already unlocked wallet (no separate wallet export or endpoint needed).
 `;
 const packageVersion = async () => {
     const manifest = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8'));
@@ -105,12 +111,17 @@ const runShell = async (handle) => {
             }
             else if (command === 'status')
                 await showStatus(handle);
+            else if (command === 'batch')
+                await handle.batch({
+                    question: prompt => shell.question(prompt),
+                    log: message => process.stdout.write(`${message}\n`)
+                });
             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');
+                process.stdout.write('account | balance [address] | status | transfer <address> <LFC> | batch | exit\n');
             }
             else if (command === 'exit' || command === 'quit') {
                 shell.close();
@@ -130,6 +141,8 @@ const runCli = async (args = process.argv.slice(2)) => {
         return void process.stdout.write(help);
     if (options.command === 'version')
         return void process.stdout.write(`${await packageVersion()}\n`);
+    if (options.command === 'batch' && !process.stdin.isTTY)
+        throw new Error('Interactive batch requires a terminal; use the standalone script with explicit confirmation for automation');
     const common = {
         network: options.network ?? process.env.LEOFCOIN_NETWORK,
         root: dataRootFor(options.root ?? process.env.LEOFCOIN_DATA_ROOT),
@@ -138,6 +151,21 @@ const runCli = async (args = process.argv.slice(2)) => {
         httpPort: options.httpPort,
         wsPort: options.wsPort
     };
+    if (options.command === 'batch') {
+        if ((common.network ?? 'leofcoin:peach') !== 'leofcoin:peach')
+            throw new Error('Interactive batch is only available on Peach testnet');
+        const root = resolve(homedir(), common.root || '.leofcoin/peach');
+        for (const name of ['account', 'wallet']) {
+            const marker = join(root, name, 'CURRENT');
+            try {
+                if (!(await lstat(marker)).isFile())
+                    throw new Error(`Invalid existing ${name} store`);
+            }
+            catch (error) {
+                throw new Error(`Batch requires an existing local wallet at ${root}; it will not create a new wallet`, { cause: error });
+            }
+        }
+    }
     const handle = options.command === 'validator'
         ? await startValidator({ ...common, intervalMinutes: options.intervalMinutes })
         : await startNode(common);
@@ -165,6 +193,22 @@ const runCli = async (args = process.argv.slice(2)) => {
         const hash = await nodeHandle.transfer(to, amountFor(chain, options.positionals[1]));
         process.stdout.write(`transfer finalized: ${hash}\n`);
     }
+    else if (options.command === 'batch') {
+        const shell = createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            await nodeHandle.batch({ question: prompt => shell.question(prompt),
+                log: message => process.stdout.write(`${message}\n`) });
+        }
+        catch (error) {
+            process.exitCode = 1;
+            throw error;
+        }
+        finally {
+            shell.close();
+            nodeHandle.stop();
+            setTimeout(() => process.exit(process.exitCode ?? 0), 100);
+        }
+    }
     else {
         process.stdout.write(`${options.command} account: ${nodeHandle.account}\n`);
         if (options.shell && process.stdin.isTTY)

package/exports/node.d.ts

@@ -1,4 +1,5 @@
 import Chain from '@leofcoin/chain/chain';
+import { type BatchInteraction } from './batch.js';
 export type LocalNodeOptions = {
     network?: string;
     networkVersion?: string;
@@ -17,6 +18,8 @@ export type LocalNodeHandle = {
         ws: string[];
     };
     transfer: (to: string, amount: bigint) => Promise<string>;
+    batch: (interaction: BatchInteraction) => Promise<void>;
+    walletBusy: boolean;
     stop: () => void;
 };
 export declare const startNode: (options?: LocalNodeOptions) => Promise<LocalNodeHandle>;

package/exports/node.js

@@ -1,11 +1,18 @@
 import { signTransaction } from '@leofcoin/lib';
 import networks from '@leofcoin/networks';
 import launch from './index.js';
+import { interactiveBatch } from './batch.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 'node:fs/promises';
+import 'node:os';
+import 'node:path';
+import 'node:crypto';
+import '@leofcoin/lib/chain-identity';
+import '@leofcoin/addresses';
 
 const startNode = async (options = {}) => {
     const network = options.network ?? 'leofcoin:peach';
@@ -26,26 +33,65 @@ const startNode = async (options = {}) => {
     const account = peernet?.selectedAccount;
     if (!account)
         throw new Error('node identity has no selected account');
+    let batchActive = false;
+    let activeTransfers = 0;
     const transfer = async (to, amount) => {
+        if (batchActive)
+            throw new Error('Wallet is reserved for an interactive batch');
         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;
+        activeTransfers++;
+        try {
+            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 await pending.wait;
+        }
+        finally {
+            activeTransfers--;
+        }
     };
     return {
         account,
         chain,
         endpoints: launched.endpoints,
         transfer,
+        get walletBusy() { return batchActive; },
+        batch: async (interaction) => {
+            if (batchActive)
+                throw new Error('A wallet batch is already active');
+            if (activeTransfers)
+                throw new Error('Wait for the active wallet transfer to finish before starting a batch');
+            batchActive = true;
+            try {
+                await interactiveBatch({
+                    account,
+                    identity: () => chainRuntime.getChainIdentity(),
+                    connected: () => peernet.selectedAccount === account && chainRuntime.state?.sync === 'synced' &&
+                        Object.values(peernet.connections || {}).some(peer => !!peer && typeof peer === 'object' && 'connected' in peer && peer.connected === true),
+                    balance: async () => BigInt(await chainRuntime.balanceOf(account)),
+                    nonce: () => chainRuntime.getNonce(account),
+                    parseAmount: value => BigInt(chainRuntime.utils.parseUnits(value)),
+                    formatAmount: value => String(chainRuntime.utils.formatUnits(value)),
+                    sign: (nonce, to, amount) => {
+                        const raw = { from: account, to: chain.nativeToken, method: 'transfer',
+                            params: [to, amount], timestamp: Date.now(), nonce };
+                        return signTransaction(raw, peernet.identity);
+                    },
+                    submit: transaction => chainRuntime.sendTransaction(transaction)
+                }, interaction);
+            }
+            finally {
+                batchActive = false;
+            }
+        },
         stop: () => controller.abort(new Error('node stopped'))
     };
 };

package/exports/validator-cli.js

@@ -16,8 +16,11 @@ import '@leofcoin/chain/chain';
 import '@leofcoin/lib/node-config';
 import '@leofcoin/endpoint-clients/ws';
 import '@leofcoin/endpoint-clients/http';
-import './validator.js';
+import './batch.js';
+import 'node:crypto';
+import '@leofcoin/lib/chain-identity';
 import '@leofcoin/addresses';
+import './validator.js';
 
 runCli(['validator', ...process.argv.slice(2)]).catch((error) => {
     process.stderr.write(`leofcoin-validator: ${error?.message ?? error}\n`);

package/exports/validator.d.ts

@@ -21,6 +21,8 @@ export type ValidatorHandle = {
         ws: string[];
     };
     transfer: (to: string, amount: bigint) => Promise<string>;
+    batch: import('./node.js').LocalNodeHandle['batch'];
+    walletBusy: boolean;
     stop: () => void;
 };
 export declare const validateIntervalMinutes: (value: number) => number;

package/exports/validator.js

@@ -8,6 +8,12 @@ import '@leofcoin/chain/chain';
 import '@leofcoin/lib/node-config';
 import '@leofcoin/endpoint-clients/ws';
 import '@leofcoin/endpoint-clients/http';
+import './batch.js';
+import 'node:fs/promises';
+import 'node:os';
+import 'node:path';
+import 'node:crypto';
+import '@leofcoin/lib/chain-identity';
 
 const delay = (milliseconds, signal) => new Promise((resolve, reject) => {
     if (signal?.aborted)
@@ -81,7 +87,7 @@ const startValidator = async (options = {}) => {
     const transfer = node.transfer;
     let sending = false;
     const heartbeat = async () => {
-        if (controller.signal.aborted || sending)
+        if (controller.signal.aborted || sending || node.walletBusy)
             return;
         sending = true;
         try {
@@ -115,7 +121,8 @@ const startValidator = async (options = {}) => {
             clearInterval(interval);
     };
     controller.signal.addEventListener('abort', () => interval && clearInterval(interval), { once: true });
-    return { account, chain, endpoints: node.endpoints, transfer, stop };
+    return { account, chain, endpoints: node.endpoints, transfer,
+        batch: node.batch, get walletBusy() { return node.walletBusy; }, stop };
 };
 
 export { startValidator, validateIntervalMinutes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/launch-chain",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "",
   "exports": {
     ".": {