trac-msb 0.2.26 → 0.3.0-beta.2

package/SECURITY.md

@@ -6,9 +6,9 @@ The following table shows which versions of this project are currently receiving
 
 | Version  | Supported          | Pear compatibility |
 | -------- | ------------------ | ------------------ |
-| 0.2.21   | :white_check_mark: | Pear v2 and v3     |
+| 0.3.0   | :white_check_mark: | Pear v2 and v3     |
 | main     | :warning: unstable | Pear v2 and v3     |
-| < 0.2.21 | :x:                | N/A                |
+| < 0.3.0 | :x:                | N/A                |
 
 Versions older than 0.2.21 are deprecated.
 Please upgrade to the latest release to ensure you receive security fixes.

package/cli/commandHandler.js

@@ -1,7 +1,23 @@
 import { randomBytes } from "hypercore-crypto";
+import _ from "lodash";
 import { Handlers } from "./handlers.js";
 import { isHexString } from "../src/utils/helpers.js";
 import { bigIntToDecimalString } from "../src/utils/amountSerialization.js";
+import {
+    MAX_VDF_DIFFICULTY,
+    VDF_PROOF_BYTE_LENGTHS
+} from "../src/utils/constants.js";
+
+const OPERATIONS = {
+    CONFIRMATION: "confirmation",
+    GENESIS_DIFFICULTY: "genesis-difficulty",
+    GENESIS_DISCRIMINANT_BIT_SIZE: "genesis-discriminant-bit-size",
+    CONSENSUS_CONFIG: "consensus-config",
+    VDF_DIFFICULTY: "vdf-difficulty",
+    VDF_DISCRIMINANT_BIT_SIZE: "vdf-discriminant-bit-size",
+    GENESIS_PREFIX: "genesis-",
+    VDF_PREFIX: "vdf-"
+};
 
 export const COMMANDS = {
     HELP: "/help",
@@ -14,6 +30,7 @@ export const COMMANDS = {
     CORE: "/core",
     INDEXERS_LIST: "/indexers_list",
     VALIDATOR_POOL: "/validator_pool",
+    INDEXER_POOL: "/indexer_pool",
     STATS: "/stats",
     BALANCE_MIGRATION: "/balance_migration",
     DISABLE_INITIALIZATION: "/disable_initialization",
@@ -36,7 +53,10 @@ export const COMMANDS = {
     UNCONFIRMED_LENGTH: "/unconfirmed_length",
     GET_TXS_HASHES: "/get_txs_hashes",
     GET_TX_DETAILS: "/get_tx_details",
-    GET_EXTENDED_TX_DETAILS: "/get_extended_tx_details"
+    GET_EXTENDED_TX_DETAILS: "/get_extended_tx_details",
+    EPOCH_GENESIS_INITIALIZATION: "/init_genesis",
+    SET_CONSENSUS_CONFIG: "/set_consensus_config",
+    SET_VDF_PARAMS: "/set_vdf_params"
 };
 
 export class CommandHandler {
@@ -44,7 +64,6 @@ export class CommandHandler {
     #closeCli;
     #wallet;
     #handlers;
-    #pendingConfirmation = null;
 
     constructor({ config, msb, handleClose, wallet }) {
         this.#msb = msb;
@@ -53,23 +72,35 @@ export class CommandHandler {
         this.#handlers = new Handlers(msb, config);
     }
 
-    async handle(input) {
-        if (this.#pendingConfirmation !== null) {
-            return this.#handlePendingConfirmation(input);
-        }
-
+    async handle(input, context) {
         const [command, ...parts] = input.split(" ");
-        const context = { command, input, parts };
+        const handlerContext = { command, input, parts, context };
         const handlers = this.#getHandlers();
-        const handler = handlers.find(({ evaluate }) => evaluate(context));
+        const handler = handlers.find(({ evaluate }) => evaluate(handlerContext));
 
         if (handler) {
-            return handler.process(context);
+            return handler.process(handlerContext);
         }
     }
 
     #getHandlers() {
         return [
+            {
+                evaluate: ({ context }) => context.pending?.op === OPERATIONS.CONFIRMATION,
+                process: async ({ input, context }) => this.#handlePendingConfirmation(input, context)
+            },
+            {
+                evaluate: ({ context }) => context.pending?.op.startsWith(OPERATIONS.GENESIS_PREFIX),
+                process: async ({ input, context }) => this.#handlePendingGenesisInitialization(input, context)
+            },
+            {
+                evaluate: ({ context }) => context.pending?.op === OPERATIONS.CONSENSUS_CONFIG,
+                process: async ({ input, context }) => this.#handlePendingSetConsensusConfig(input, context)
+            },
+            {
+                evaluate: ({ context }) => context.pending?.op.startsWith(OPERATIONS.VDF_PREFIX),
+                process: async ({ input, context }) => this.#handlePendingSetVdfParams(input, context)
+            },
             {
                 evaluate: ({ command }) => command === COMMANDS.HELP,
                 process: async () => {
@@ -115,6 +146,10 @@ export class CommandHandler {
                 evaluate: ({ command }) => command === COMMANDS.VALIDATOR_POOL,
                 process: async () => this.#msb.network.validatorConnectionManager.prettyPrint()
             },
+            {
+                evaluate: ({ command }) => command === COMMANDS.INDEXER_POOL,
+                process: async () => this.#msb.network.indexerConnectionManager.prettyPrint()
+            },
             {
                 evaluate: ({ command }) => command === COMMANDS.STATS,
                 process: async () => this.#msb.verifyDag()
@@ -167,7 +202,7 @@ export class CommandHandler {
             },
             {
                 evaluate: ({ input }) => input.startsWith(COMMANDS.TRANSFER),
-                process: async ({ parts }) => this.#queueTransferConfirmation(parts[0], parts[1])
+                process: async ({ parts, context }) => this.#queueTransferConfirmation(parts[0], parts[1], context)
             },
             {
                 evaluate: ({ input }) => input.startsWith(COMMANDS.GET_BALANCE),
@@ -215,16 +250,28 @@ export class CommandHandler {
             {
                 evaluate: ({ input }) => input.startsWith(COMMANDS.GET_EXTENDED_TX_DETAILS),
                 process: async ({ parts }) => this.#handlers.handleExtendedTxDetails(parts[0], parts[1] === "true")
+            },
+            {
+                evaluate: ({ input }) => input.startsWith(COMMANDS.EPOCH_GENESIS_INITIALIZATION),
+                process: async ({ context }) => this.#queueEpochGenesisInitialization(context)
+            },
+            {
+                evaluate: ({ command }) => command === COMMANDS.SET_CONSENSUS_CONFIG,
+                process: async ({ context }) => this.#queueSetConsensusConfig(context)
+            },
+            {
+                evaluate: ({ command }) => command === COMMANDS.SET_VDF_PARAMS,
+                process: async ({ context }) => this.#queueSetVdfParams(context)
             }
         ];
     }
 
-    async #handlePendingConfirmation(input) {
+    async #handlePendingConfirmation(input, context) {
         const normalizedInput = input.trim().toLowerCase();
-        const pendingConfirmation = this.#pendingConfirmation;
+        const pendingConfirmation = context.pending;
 
         if (normalizedInput === "y" || normalizedInput === "yes") {
-            this.#pendingConfirmation = null;
+            context.pending = null;
 
             try {
                 return await pendingConfirmation.onConfirm();
@@ -232,7 +279,8 @@ export class CommandHandler {
                 const errorMessage = typeof error === "object" && error !== null && "message" in error
                     ? error.message
                     : `${error}`;
-                console.error(`Transaction submission failed: ${errorMessage}`);
+                const failureMessage = pendingConfirmation.failureMessage || "Transaction submission failed";
+                console.error(`${failureMessage}: ${errorMessage}`);
                 console.log("Try again or use /help.");
             }
 
@@ -240,15 +288,15 @@ export class CommandHandler {
         }
 
         if (normalizedInput === "n" || normalizedInput === "no") {
-            this.#pendingConfirmation = null;
+            context.pending = null;
             return pendingConfirmation.onDecline();
         }
 
-        console.log('Invalid input. Please answer "y" or "n".');
+        console.log(pendingConfirmation.invalidMessage || 'Invalid input. Please answer "y" or "n".');
         console.log(pendingConfirmation.prompt);
     }
 
-    async #queueTransferConfirmation(recipientAddress, amount) {
+    async #queueTransferConfirmation(recipientAddress, amount, context) {
         const preparedTransfer = await this.#msb.prepareTransferOperation(recipientAddress, amount);
 
         console.info("Transfer Details:");
@@ -261,12 +309,261 @@ export class CommandHandler {
         console.info(`Current balance: ${bigIntToDecimalString(preparedTransfer.senderBalance)}`);
         console.info(`Balance after transaction: ${bigIntToDecimalString(preparedTransfer.expectedNewBalance)}`);
 
-        this.#pendingConfirmation = {
+        context.pending = {
+            op: OPERATIONS.CONFIRMATION,
             prompt: "Do you want to proceed? (y/n)",
             onConfirm: async () => this.#msb.submitPreparedTransferOperation(preparedTransfer),
             onDecline: async () => this.#msb.printHelp()
         };
 
-        console.log(this.#pendingConfirmation.prompt);
+        console.log(context.pending.prompt);
+    }
+
+    #queueEpochGenesisInitialization(context) {
+        context.pending = {
+            op: OPERATIONS.GENESIS_DIFFICULTY
+        };
+
+        console.log(this.#getGenesisDifficultyPrompt());
+    }
+
+    #handlePendingGenesisInitialization(input, context) {
+        const pendingGenesisInitialization = context.pending;
+
+        if (pendingGenesisInitialization.op === OPERATIONS.GENESIS_DIFFICULTY) {
+            const difficulty = this.#parsePositiveInteger(input, BigInt(MAX_VDF_DIFFICULTY));
+            if (!difficulty) {
+                console.log("Invalid difficulty. Please enter a positive integer (example 55_000_000).");
+                console.log(this.#getGenesisDifficultyPrompt());
+                return;
+            }
+
+            pendingGenesisInitialization.difficulty = difficulty;
+            pendingGenesisInitialization.op = OPERATIONS.GENESIS_DISCRIMINANT_BIT_SIZE;
+            console.log(this.#getGenesisDiscriminantBitSizePrompt());
+            return;
+        }
+
+        const discriminantBitSize = this.#parseVdfDiscriminantBitSize(input);
+        if (!discriminantBitSize) {
+            console.log("Invalid discriminant bit size. Please enter one of: 1024, 2048, 4096.");
+            console.log(this.#getGenesisDiscriminantBitSizePrompt());
+            return;
+        }
+
+        const difficulty = pendingGenesisInitialization.difficulty;
+        context.pending = null;
+
+        return this.#queueEpochGenesisConfirmation({
+            difficulty,
+            discriminantBitSize
+        }, context);
+    }
+
+    #queueEpochGenesisConfirmation({ difficulty, discriminantBitSize }, context) {
+        const consensusConfig = {
+            schemaVersion: 1,
+            configData: {
+                difficulty: Number(difficulty.value),
+                discriminantBitSize: Number(discriminantBitSize.value)
+            }
+        };
+
+        console.info("Genesis Epoch Initialization Parameters:");
+        console.info(`VDF difficulty: ${difficulty.display}`);
+        console.info(`VDF discriminant bit size: ${discriminantBitSize.display}`);
+
+        context.pending = {
+            op: OPERATIONS.CONFIRMATION,
+            prompt: "Do you want to proceed? (yes/no)",
+            invalidMessage: 'Invalid input. Please answer "yes" or "no".',
+            failureMessage: "Genesis epoch initialization failed",
+            onConfirm: async () => this.#handlers.handleEpochGenesisInitialization(consensusConfig),
+            onDecline: async () => console.log("Genesis epoch initialization cancelled.")
+        };
+
+        console.log(context.pending.prompt);
+    }
+
+    #queueSetConsensusConfig(context) {
+        context.pending = { op: OPERATIONS.CONSENSUS_CONFIG };
+
+        console.log(this.#getSetConsensusConfigPrompt());
+    }
+
+    #handlePendingSetConsensusConfig(input, context) {
+        if (input.trim().toLowerCase() === "/cancel") {
+            context.pending = null;
+            console.log("Consensus config update cancelled.");
+            return;
+        }
+
+        const consensusConfig = this.#parseConsensusConfig(input);
+        if (!consensusConfig) {
+            console.log(
+                'Invalid consensus config. Please enter a JSON object containing only "schemaVersion" and "configData".'
+            );
+            console.log(this.#getSetConsensusConfigPrompt());
+            return;
+        }
+
+        context.pending = null;
+        return this.#queueSetConsensusConfigConfirmation(consensusConfig, context);
+    }
+
+    #queueSetConsensusConfigConfirmation(consensusConfig, context) {
+        console.info("Consensus Config Update:");
+        console.info(JSON.stringify(consensusConfig, null, 2));
+
+        context.pending = {
+            op: OPERATIONS.CONFIRMATION,
+            prompt: "Do you want to proceed? (yes/no)",
+            invalidMessage: 'Invalid input. Please answer "yes" or "no".',
+            failureMessage: "Consensus config update failed",
+            onConfirm: async () => this.#handlers.handleSetConsensusConfig(consensusConfig),
+            onDecline: async () => console.log("Consensus config update cancelled.")
+        };
+
+        console.log(context.pending.prompt);
+    }
+
+    #queueSetVdfParams(context) {
+        context.pending = {
+            op: OPERATIONS.VDF_DIFFICULTY
+        };
+
+        console.log(this.#getSetVdfParamsDifficultyPrompt());
+    }
+
+    #handlePendingSetVdfParams(input, context) {
+        if (input.trim().toLowerCase() === "/cancel") {
+            context.pending = null;
+            console.log("VDF params update cancelled.");
+            return;
+        }
+
+        const pendingSetVdfParams = context.pending;
+
+        if (pendingSetVdfParams.op === OPERATIONS.VDF_DIFFICULTY) {
+            const difficulty = this.#parsePositiveInteger(input, BigInt(MAX_VDF_DIFFICULTY));
+            if (!difficulty) {
+                console.log(
+                    "Invalid difficulty. Please enter an integer between 1 and 4_294_967_295."
+                );
+                console.log(this.#getSetVdfParamsDifficultyPrompt());
+                return;
+            }
+
+            pendingSetVdfParams.difficulty = difficulty;
+            pendingSetVdfParams.op = OPERATIONS.VDF_DISCRIMINANT_BIT_SIZE;
+            console.log(this.#getSetVdfParamsDiscriminantBitSizePrompt());
+            return;
+        }
+
+        const discriminantBitSize = this.#parseVdfDiscriminantBitSize(input);
+        if (!discriminantBitSize) {
+            console.log(
+                "Invalid discriminant bit size. Please enter one of: 1024, 2048, 4096."
+            );
+            console.log(this.#getSetVdfParamsDiscriminantBitSizePrompt());
+            return;
+        }
+
+        const difficulty = pendingSetVdfParams.difficulty;
+        context.pending = null;
+        return this.#queueSetVdfParamsConfirmation({
+            difficulty,
+            discriminantBitSize
+        }, context);
+    }
+
+    #queueSetVdfParamsConfirmation({ difficulty, discriminantBitSize }, context) {
+        const consensusConfig = {
+            schemaVersion: 1,
+            configData: {
+                difficulty: Number(difficulty.value),
+                discriminantBitSize: Number(discriminantBitSize.value)
+            }
+        };
+
+        console.info("VDF Params Update:");
+        console.info(`VDF difficulty: ${difficulty.display}`);
+        console.info(`VDF discriminant bit size: ${discriminantBitSize.display}`);
+
+        context.pending = {
+            op: OPERATIONS.CONFIRMATION,
+            prompt: "Do you want to proceed? (yes/no)",
+            invalidMessage: 'Invalid input. Please answer "yes" or "no".',
+            failureMessage: "VDF params update failed",
+            onConfirm: async () => this.#handlers.handleSetConsensusConfig(consensusConfig),
+            onDecline: async () => console.log("VDF params update cancelled.")
+        };
+
+        console.log(context.pending.prompt);
+    }
+
+    #parseConsensusConfig(input) {
+        try {
+            const parsed = JSON.parse(input);
+            if (
+                !_.isPlainObject(parsed) ||
+                Object.keys(parsed).length !== 2 ||
+                !Object.hasOwn(parsed, "schemaVersion") ||
+                !Object.hasOwn(parsed, "configData")
+            ) {
+                return null;
+            }
+
+            return parsed;
+        } catch {
+            return null;
+        }
+    }
+
+    #parsePositiveInteger(input, maximum = null) {
+        const display = input.trim();
+        if (!/^[0-9]+(?:_[0-9]+)*$/.test(display)) {
+            return null;
+        }
+
+        const value = display.replaceAll("_", "");
+        const integer = BigInt(value);
+        if (integer <= 0n || (maximum !== null && integer > maximum)) {
+            return null;
+        }
+
+        return { display, value };
+    }
+
+    #parseVdfDiscriminantBitSize(input) {
+        const parsed = this.#parsePositiveInteger(input);
+        if (
+            parsed === null ||
+            !Object.hasOwn(VDF_PROOF_BYTE_LENGTHS, Number(parsed.value))
+        ) {
+            return null;
+        }
+
+        return parsed;
+    }
+
+    #getGenesisDifficultyPrompt() {
+        return "Set VDF difficulty (example 55_000_000):";
+    }
+
+    #getGenesisDiscriminantBitSizePrompt() {
+        return "Set VDF discriminant bit size (example 2048):";
+    }
+
+    #getSetConsensusConfigPrompt() {
+        return 'Set consensus config as JSON, or enter /cancel (example {"schemaVersion":1,"configData":{"difficulty":60000000,"discriminantBitSize":2048}}):';
+    }
+
+    #getSetVdfParamsDifficultyPrompt() {
+        return "Set new VDF difficulty (example 55_000_000):";
+    }
+
+    #getSetVdfParamsDiscriminantBitSizePrompt() {
+        return "Set new VDF discriminant bit size (example 2048):";
     }
 }

package/cli/handlers.js

@@ -3,7 +3,7 @@ import { bigIntToDecimalString, bufferToBigInt } from "../src/utils/amountSerial
 import { EntryType } from "../src/utils/constants.js";
 import { bufferToAddress } from "../src/core/state/utils/address.js";
 import deploymentEntryUtils from "../src/core/state/utils/deploymentEntry.js";
-import { safeDecodeApplyOperation } from "../src/utils/protobuf/operationHelpers.js";
+import { safeDecodeApplyOperation } from "../src/codecs/apply/applyOperationCodec.js";
 
 export class Handlers {
     #msb
@@ -207,4 +207,12 @@ export class Handlers {
 
         return txDetails;
     }
+
+    async handleEpochGenesisInitialization(consensusConfig) {
+        return this.#msb.handleEpochGenesisInitialization(consensusConfig);
+    }
+
+    async handleSetConsensusConfig(consensusConfig) {
+        return this.#msb.handleSetConsensusConfig(consensusConfig);
+    }
 }

package/cli/interactive.js

@@ -59,6 +59,7 @@ class Cli extends ReadyResource {
 
     startInteractiveMode() {
         console.log('RPC server will not be started.');
+        const context = { pending: null };
 
         this.#commandHandlers = new CommandHandler({
             config: this.#config,
@@ -71,7 +72,7 @@ class Cli extends ReadyResource {
 
         this.#readlineInstance.on("line", async (input) => {
             try {
-                await this.#handleCommand(input.trim());
+                await this.#handleCommand(input.trim(), context);
             } catch (err) {
                 console.error(`${err}`);
             }
@@ -81,8 +82,8 @@ class Cli extends ReadyResource {
         this.#readlineInstance.prompt();
     }
 
-    async #handleCommand(input) {
-        return this.#commandHandlers.handle(input);
+    async #handleCommand(input, context) {
+        return this.#commandHandlers.handle(input, context);
     }
 
     #completeCommand(line) {

package/cli/tokenSupplyAudit.js

@@ -0,0 +1,90 @@
+import fs from 'fs';
+import path from 'path';
+import { decimalStringToBigInt } from '../src/utils/amountSerialization.js';
+import { auditJSON, formatAuditAmount } from '../src/core/state/audit/supply.js';
+
+let running = false;
+
+export async function runTokenSupplyAudit(msb, expectedNetIssuedText) {
+    if (running) throw new Error('A TNK supply audit is already running');
+    const expectedNetIssued = expectedNetIssuedText === undefined ? undefined : decimalStringToBigInt(expectedNetIssuedText);
+    running = true;
+    const reportPath = path.resolve(`tnk-supply-audit-${Date.now()}.jsonl`);
+    let output;
+    let fileError;
+    let lines = [];
+    const flush = async () => {
+        if (fileError) throw fileError;
+        if (!lines.length) return;
+        const text = lines.join('');
+        lines = [];
+        await new Promise((resolve, reject) => output.write(text, error => error ? reject(error) : resolve()));
+    };
+    const record = async value => {
+        lines.push(auditJSON(value) + '\n');
+        if (lines.length >= 100 || ['header', 'current-supply', 'summary', 'incomplete'].includes(value.kind)) await flush();
+        if (value.kind === 'current-supply') {
+            console.log(`Current confirmed supply: ${formatAuditAmount(value.actualSupply)} TNK ` +
+                `(spendable ${formatAuditAmount(value.spendableSupply)}, staked ${formatAuditAmount(value.stakedSupply)}). ` +
+                'History reconciliation is still pending.');
+        }
+    };
+    try {
+        output = fs.createWriteStream(reportPath, { flags: 'wx' });
+        output.on('error', error => { fileError = error; });
+        console.log(`TNK supply audit report: ${reportPath}`);
+        console.log('Checking one signed snapshot. All amounts use exact 18-decimal TNK arithmetic.');
+        const audit = await msb.getTokenSupplyAudit({
+            expectedNetIssued,
+            onRecord: record,
+            progressInterval: 1_000,
+            onProgress: event => {
+                if (event.phase === 'start') console.log(`Confirmed length: ${event.confirmedLength}`);
+                if (event.phase === 'state') console.log(`Scanning state: ${event.currentEntries} entries, ${event.nodeEntries} accounts.`);
+                if (event.phase === 'history') console.log(`Checking history: ${event.historyEntries}/${event.confirmedLength - 1}, ${event.receipts} receipts.`);
+                if (event.phase === 'waiting' && event.idleMs >= 5_000) console.log(`Waiting for ${event.scan} data (${Math.floor(event.idleMs / 1000)}s), next ${event.cursor ?? '(start)'}.`);
+                if (event.phase === 'read-retry') console.log(`Retrying ${event.scan} read at ${event.cursor ?? '(start)'} (${event.retry}/${event.maxRetries}); processed entries are retained.`);
+                if (event.phase === 'process-pause') console.log(`Detected a process pause (${Math.floor(event.pauseMs / 1000)}s); continuing ${event.scan} from ${event.cursor ?? '(start)'}.`);
+                if (event.phase === 'report-error') console.error(`Could not complete the audit report: ${event.message}`);
+            }
+        });
+        await flush();
+        await new Promise((resolve, reject) => {
+            output.once('error', reject);
+            output.end(resolve);
+        });
+        if (fileError) throw fileError;
+        console.log('TNK Supply Audit:', {
+            Status: audit.status,
+            ConfirmedLength: audit.confirmedLength,
+            Accounts: audit.nodeEntries,
+            VerifiedReceipts: audit.receipts,
+            SpendableTNK: formatAuditAmount(audit.spendableSupply),
+            StakedTNK: formatAuditAmount(audit.stakedSupply),
+            ActualSupplyTNK: formatAuditAmount(audit.actualSupply),
+            NetIssuedTNK: formatAuditAmount(audit.netIssued),
+            ReceiptFeeBurnTNK: formatAuditAmount(audit.feeBurn),
+            ExpectedSupplyAfterReceiptFeesTNK: formatAuditAmount(audit.expectedSupplyAfterReceiptFees),
+            UnexplainedDifferenceTNK: formatAuditAmount(audit.unexplainedDifference),
+            PositiveOperationDifferencesTNK: formatAuditAmount(audit.positiveOperationDifferences),
+            NegativeOperationDifferencesTNK: formatAuditAmount(audit.negativeOperationDifferences),
+            MismatchingOperations: audit.mismatchingOperations,
+            AccountsWithUnverifiedAdjustments: audit.accountsWithUnverifiedAdjustments,
+            MismatchingAccounts: audit.mismatchingAccounts,
+            TrailingUnreceiptedChanges: audit.trailingUnreceiptedChanges.length,
+            ApprovedNetIssuanceMatches: audit.approvedNetIssuanceMatches ?? 'NOT PROVIDED',
+            Report: reportPath,
+        });
+        console.log(audit.status === 'RECONCILED'
+            ? 'All checked receipt economics and account balances reconcile at this signed height.'
+            : 'Review required. Inspect operation/account differences in the report; this is not a clean supply verdict.');
+        for (const limitation of audit.limitations) console.log(limitation);
+        return audit;
+    } catch (error) {
+        console.error(`TNK audit INCOMPLETE: ${error.message}. No complete supply verdict. Report path: ${reportPath}`);
+        throw error;
+    } finally {
+        output?.destroy();
+        running = false;
+    }
+}

package/msb.mjs

@@ -13,3 +13,4 @@ const start = async () => {
 }
 
 start()
+// WIP

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trac-msb",
   "main": "msb.mjs",
-  "version": "0.2.26",
+  "version": "0.3.0-beta.2",
   "pear": {
     "name": "trac-msb",
     "type": "terminal"
@@ -26,23 +26,35 @@
     "lint:fix": "eslint . --fix",
     "protobuf": "node scripts/generate-protobufs.js",
     "docs:check": "node scripts/docs/docs-checker.js",
-    "test:acceptance": "node --experimental-vm-modules node_modules/jest/bin/jest.js --testTimeout=200000 tests/acceptance/v1/rpc.test.mjs --runInBand",
+    "test:acceptance": "node --experimental-vm-modules node_modules/jest/bin/jest.js --testTimeout=200000 tests/acceptance/v1/rpc.test.mjs tests/acceptance/v1/htlc/htlc-routing.test.mjs tests/acceptance/v1/current-epoch/current-epoch-routing.test.mjs tests/acceptance/v1/consensus-config/consensus-config-routing.test.mjs --runInBand",
     "test:integration": "brittle-node -t 1200000 tests/integration/integration.test.js",
     "test:unit:node": "brittle-node -t 60000 tests/unit/unit.test.js",
     "test:unit:bare": "brittle-bare -t 60000 tests/unit/unit.test.js",
     "test:unit:pear": "BRITTLE='-t 60000' brittle-pear tests/unit/unit.test.js",
     "test:pear-runner": "node --test tests/runner/pear-runner.test.js",
     "test:unit:all": "(npm run test:unit:node && npm run test:unit:bare && npm run test:pear-runner) || exit 1",
-    "test:unit:node:cov": "brittle-node -c -t 60000 tests/unit/unit.test.js"
+    "test:unit:node:cov": "brittle-node -c -t 60000 tests/unit/unit.test.js",
+    "test:integration:consensus:node": "brittle-node -t 180000 tests/integration/consensus/consensus.test.js",
+    "test:integration:consensus:bare": "brittle-bare -t 180000 tests/integration/consensus/consensus.test.js",
+    "test:integration:consensus": "npm run test:integration:consensus:node && npm run test:integration:consensus:bare"
   },
   "dependencies": {
+    "@tracsystems/trac-vdf": "^0.0.3",
     "autobase": "7.20.1",
     "b4a": "1.6.7",
+    "bare-channel": "^5.2.3",
     "bare-crypto": "1.12.0",
     "bare-fs": "4.5.0",
+    "bare-hrtime": "^2.1.1",
     "bare-http1": "4.1.5",
+    "bare-os": "^3.6.1",
+    "bare-pipe": "^4.1.0",
     "bare-readline": "1.0.7",
+    "bare-runtime": "^1.31.0",
+    "bare-subprocess": "^5.1.5",
+    "bare-thread": "^1.2.2",
     "bare-tty": "5.0.2",
+    "bare-url": "^2.4.3",
     "bare-utils": "1.5.1",
     "bech32": "2.0.0",
     "compact-encoding": "2.18.0",
@@ -62,7 +74,6 @@
     "pear-runtime": "1.3.1",
     "process": "npm:bare-process@4.2.2",
     "protobufjs": "^7.5.4",
-    "protocol-buffers-encodings": "1.2.0",
     "protomux": "3.10.1",
     "protomux-wakeup": "2.4.0",
     "readline": "npm:bare-node-readline",
@@ -74,14 +85,12 @@
   },
   "devDependencies": {
     "bare-module": "^6.1.3",
-    "bare-os": "^3.6.1",
     "bip39-mnemonic": "^2.4.0",
     "brittle": "^3.19.1",
     "eslint": "^9.39.4",
     "esmock": "^2.7.2",
     "jest": "^30.1.3",
     "protobufjs-cli": "^1.2.0",
-    "protocol-buffers": "^4.2.0",
     "sinon": "^21.0.0",
     "supertest": "^7.1.4"
   },