blueprint-tsa 1.0.4 → 1.1.1

package/README.md

@@ -0,0 +1,31 @@
+# blueprint-tsa
+
+A plugin for the [Blueprint Framework](https://github.com/ton-org/blueprint/) that simplifies your workflow with the [TON Symbolic Analyzer](https://tonsec.dev/).
+
+## Getting Started
+
+1. Add this plugin as a dependency of your Blueprint project:
+
+```bash
+yarn add blueprint-tsa
+```
+
+2. Add this configuration to `blueprint.config.ts`:
+
+```ts
+import { TsaPlugin } from "blueprint-tsa";
+
+export const config = {
+  plugins: [new TsaPlugin()],
+};
+```
+
+## Usage
+
+Run the following command:
+
+```bash
+yarn blueprint tsa help
+```
+
+More more information, visit [documentation](https://tonsec.dev/docs).

package/dist/cli.js

@@ -19,24 +19,16 @@ const bounce_check_js_1 = require("./commands/bounce-check.js");
 const createCLI = (context) => {
     const { args, ui } = context;
     const argv = args._.slice(1);
-    const drainCheckConfig = (0, drain_check_js_1.configureDrainCheckCommand)(context);
-    const replayAttackCheckConfig = (0, replay_attack_check_js_1.configureReplayAttackCheckCommand)(context);
-    const cleanConfig = (0, clean_js_1.configureCleanCommand)();
-    const reproduceCommand = (0, reproduce_js_1.configureReproduceCommand)(context);
-    const ownerHijackConfig = (0, owner_hijack_check_js_1.configureOwnerHijackCommand)(context);
-    const opcodeInfoConfig = (0, opcode_info_js_1.configureOpcodeInfoCommand)(context);
-    const auditConfig = (0, audit_js_1.configureAuditCommand)(context);
-    const bounceCheckConfig = (0, bounce_check_js_1.configureBounceCheckCommand)(context);
     return (0, yargs_1.default)(argv)
         .scriptName("tsa")
-        .command(drainCheckConfig.command, drainCheckConfig.description, drainCheckConfig.builder, drainCheckConfig.handler)
-        .command(replayAttackCheckConfig.command, replayAttackCheckConfig.description, replayAttackCheckConfig.builder, replayAttackCheckConfig.handler)
-        .command(cleanConfig.command, cleanConfig.description, cleanConfig.builder, cleanConfig.handler)
-        .command(ownerHijackConfig.command, ownerHijackConfig.description, ownerHijackConfig.builder, ownerHijackConfig.handler)
-        .command(reproduceCommand.command, reproduceCommand.description, reproduceCommand.builder, reproduceCommand.handler)
-        .command(opcodeInfoConfig.command, opcodeInfoConfig.description, opcodeInfoConfig.builder, opcodeInfoConfig.handler)
-        .command(auditConfig.command, auditConfig.description, auditConfig.builder, auditConfig.handler)
-        .command(bounceCheckConfig.command, bounceCheckConfig.description, bounceCheckConfig.builder, bounceCheckConfig.handler)
+        .command((0, drain_check_js_1.createDrainCheckCommand)(context))
+        .command((0, owner_hijack_check_js_1.createOwnerHijackCheckCommand)(context))
+        .command((0, replay_attack_check_js_1.createReplayAttackCheckCommand)(context))
+        .command((0, bounce_check_js_1.createBounceCheckCommand)(context))
+        .command((0, clean_js_1.createCleanCommand)())
+        .command((0, reproduce_js_1.createReproduceCommand)(context))
+        .command((0, opcode_info_js_1.createOpcodeInfoCommand)(context))
+        .command((0, audit_js_1.createAuditCommand)(context))
         .demandCommand(1, "Please specify a subcommand")
         .help()
         .alias("help", "h")

package/dist/commands/audit.d.ts

@@ -1,19 +1,52 @@
-import { Argv } from "yargs";
-import yargs from "yargs";
+import { CommandModule, InferredOptionTypes } from "yargs";
 import { CommandContext } from "../cli.js";
-export declare const configureAuditCommand: (context: CommandContext) => {
-    command: string;
-    description: string;
-    builder: (yargs: Argv) => Argv<{
-        contract: string;
-    } & {
-        timeout: number | undefined;
-    } & {
-        "owner-method": string | undefined;
-    } & {
-        "disable-opcode-extraction": boolean | undefined;
-    } & {
-        verbose: boolean | undefined;
-    }>;
-    handler: (argv: yargs.ArgumentsCamelCase) => Promise<void>;
+declare const auditOptions: {
+    readonly "disable-opcode-extraction": {
+        readonly type: "boolean";
+        readonly description: "Disable opcode extraction. This affects path selection strategy and default timeout.";
+    };
+    readonly timeout: {
+        readonly alias: "t";
+        readonly type: "number";
+        readonly description: "Overall analysis timeout in seconds";
+    };
+    readonly verbose: {
+        readonly alias: "v";
+        readonly type: "boolean";
+        readonly description: "Use debug output in TSA log";
+    };
+    readonly contract: {
+        readonly alias: "c";
+        readonly type: "string";
+        readonly description: "Contract name";
+        readonly demandOption: true;
+    };
+    readonly "iteration-limit": {
+        readonly type: "number";
+        readonly description: "Iteration limit";
+        readonly default: 2;
+    };
+    readonly "max-recursion-depth": {
+        readonly type: "number";
+        readonly description: "Recursion limit";
+        readonly default: 1;
+    };
+    readonly interactive: {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly description: "Enable interactive confirmations";
+    };
+    readonly "verbose-analysis-artifacts": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly description: "Keep TSA exported inputs in the verbose multi-file directory layout";
+    };
+    readonly "owner-method": {
+        readonly alias: "m";
+        readonly type: "string";
+        readonly description: "The method name of get_owner getter (optional, enables owner hijack check)";
+    };
 };
+type AuditSchema = InferredOptionTypes<typeof auditOptions>;
+export declare const createAuditCommand: (context: CommandContext) => CommandModule<object, AuditSchema>;
+export {};

package/dist/commands/audit.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.configureAuditCommand = void 0;
+exports.createAuditCommand = void 0;
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 const constants_js_1 = require("../common/constants.js");
@@ -18,7 +18,16 @@ const replay_attack_check_js_1 = require("./replay-attack-check.js");
 const owner_hijack_check_js_1 = require("./owner-hijack-check.js");
 const bounce_check_js_1 = require("./bounce-check.js");
 const opcode_info_js_1 = require("./opcode-info.js");
-const ONE_MINUTE_SECONDS = 60;
+const common_analyzer_args_js_1 = require("./common-analyzer-args.js");
+const command_utils_js_1 = require("./command-utils.js");
+const auditOptions = {
+    "owner-method": {
+        alias: "m",
+        type: "string",
+        description: "The method name of get_owner getter (optional, enables owner hijack check)",
+    },
+    ...common_analyzer_args_js_1.commonAnalyzerRecvInternalCliOptions,
+};
 function getCheckCommand(checkName, contractName, timeout, ownerMethod) {
     let commandId;
     if (checkName === constants_js_1.DRAIN_CHECK_NAME) {
@@ -69,16 +78,18 @@ function buildCheckResult(checkName, analyzer, passedMessage, failedMessage, con
         checkCommand: getCheckCommand(checkName, contractName, timeout, ownerMethod),
     };
     if (vulnerability) {
-        const vulnDesc = analyzer.getVulnerability();
+        const vulnDesc = analyzer.getVulnerabilityFromReport();
         if (vulnDesc) {
-            result.vulnerabilityPath = (0, paths_js_1.getInputsPath)(analyzer.id, vulnDesc.executionIndex);
+            result.vulnerabilityPath = analyzer.usesVerboseAnalysisArtifacts()
+                ? (0, paths_js_1.getInputsPath)(analyzer.id, vulnDesc.executionIndex)
+                : (0, paths_js_1.getCompactTypedInputPath)(analyzer.id);
             result.analyzerId = analyzer.id;
         }
         result.descriptionUrl = getCheckDescriptionUrl(checkName);
     }
     return result;
 }
-async function runOpcodeInfoCheck(contractName, contractPath, ui, timeout, opcodes, verbose) {
+async function runOpcodeInfoCheck(contractName, contractPath, ui, timeout, opcodes, verbose, legacyAnalysisArtifacts, iterationLimit, recursionLimit, interactive) {
     // Calculate timeout per opcode
     let opcodeTimeout = null;
     if (timeout !== null && opcodes.length > 0) {
@@ -86,31 +97,48 @@ async function runOpcodeInfoCheck(contractName, contractPath, ui, timeout, opcod
         ui.write("");
         ui.write(`Opcode authorization check: using timeout of ${opcodeTimeout} seconds per opcode (${timeout} / ${opcodes.length})`);
     }
+    const commonArgs = {
+        timeout: opcodeTimeout,
+        verbose,
+        contract: contractName,
+        iterationLimit,
+        recursionLimit,
+        interactive,
+        legacyAnalysisArtifacts,
+    };
     const results = [];
     for (const opcode of opcodes) {
-        const info = await (0, opcode_info_js_1.runOpcodeAuthorizationCheckAnalysis)(opcode, contractName, contractPath, ui, opcodeTimeout, `Authorization check for ${(0, format_utils_js_1.formatOpcodeHex)(opcode)} completed.`, verbose);
+        const info = await (0, opcode_info_js_1.runOpcodeAuthorizationCheckAnalysis)(opcode, contractPath, ui, commonArgs, `Authorization check for ${(0, format_utils_js_1.formatOpcodeHex)(opcode)} completed.`);
         if (info !== null) {
             results.push(info);
         }
     }
     return results;
 }
-async function runDrainCheck(contractName, contractPath, ui, timeout, opcodes, verbose) {
-    const analyzer = await (0, drain_check_js_1.runDrainCheckAnalysis)(contractName, contractPath, ui, timeout, opcodes, verbose, `${constants_js_1.DRAIN_CHECK_NAME} completed.`);
-    return buildCheckResult(constants_js_1.DRAIN_CHECK_NAME, analyzer, "No drain vulnerabilities detected", "Vulnerability found - contract may be vulnerable to drain attacks", contractName, timeout);
+async function runDrainCheck(contractName, contractPath, ui, commonArgs) {
+    const analyzer = await (0, drain_check_js_1.runDrainCheckAnalysis)(ui, contractPath, commonArgs, `${constants_js_1.DRAIN_CHECK_NAME} completed.`);
+    return buildCheckResult(constants_js_1.DRAIN_CHECK_NAME, analyzer, "No drain vulnerabilities detected", "Vulnerability found - contract may be vulnerable to drain attacks", contractName, commonArgs.timeout);
 }
-async function runReplayAttackCheck(contractName, contractPath, ui, timeout, verbose) {
-    const analyzer = await (0, replay_attack_check_js_1.runReplayAttackCheckAnalysis)(contractName, contractPath, ui, timeout, verbose, `${constants_js_1.REPLAY_ATTACK_CHECK_NAME} completed.`);
+async function runReplayAttackCheck(contractName, contractPath, ui, timeout, verbose, iterationLimit, recursionLimit, legacyAnalysisArtifacts, interactive) {
+    const analyzer = await (0, replay_attack_check_js_1.runReplayAttackCheckAnalysis)(ui, contractPath, {
+        timeout,
+        verbose,
+        contract: contractName,
+        iterationLimit,
+        recursionLimit,
+        interactive,
+        legacyAnalysisArtifacts,
+    }, null, `${constants_js_1.REPLAY_ATTACK_CHECK_NAME} completed.`);
     return buildCheckResult(constants_js_1.REPLAY_ATTACK_CHECK_NAME, analyzer, "No replay attack vulnerabilities detected", "Vulnerability found - contract may be vulnerable to replay attacks", contractName, timeout);
 }
-async function runOwnerHijackCheck(contractName, contractPath, ui, timeout, methodName, opcodes, verbose) {
+async function runOwnerHijackCheck(contractName, contractPath, ui, methodName, commonArgs) {
     const methodId = BigInt((0, core_1.getMethodId)(methodName));
-    const analyzer = await (0, owner_hijack_check_js_1.runOwnerHijackCheckAnalysis)(contractName, contractPath, ui, timeout, methodId, opcodes, verbose, `${constants_js_1.OWNER_HIJACK_CHECK_NAME} completed.`);
-    return buildCheckResult(constants_js_1.OWNER_HIJACK_CHECK_NAME, analyzer, "No owner hijack vulnerabilities detected", "Vulnerability found - contract owner may be hijackable", contractName, timeout, methodName);
+    const analyzer = await (0, owner_hijack_check_js_1.runOwnerHijackCheckAnalysis)(ui, contractPath, methodId, commonArgs, `${constants_js_1.OWNER_HIJACK_CHECK_NAME} completed.`);
+    return buildCheckResult(constants_js_1.OWNER_HIJACK_CHECK_NAME, analyzer, "No owner hijack vulnerabilities detected", "Vulnerability found - contract owner may be hijackable", contractName, commonArgs.timeout, methodName);
 }
-async function runBounceCheck(contractName, contractPath, ui, timeout, opcodes, verbose) {
-    const analyzer = await (0, bounce_check_js_1.runBounceCheckAnalysis)(contractName, contractPath, ui, timeout, opcodes, verbose, `${constants_js_1.BOUNCE_CHECK_NAME} completed.`);
-    return buildCheckResult(constants_js_1.BOUNCE_CHECK_NAME, analyzer, "No bounce message handling vulnerabilities detected", "Vulnerability found - contract may not handle bounced messages correctly", contractName, timeout);
+async function runBounceCheck(contractName, contractPath, ui, commonArgs) {
+    const analyzer = await (0, bounce_check_js_1.runBounceCheckAnalysis)(ui, contractPath, commonArgs, `${constants_js_1.BOUNCE_CHECK_NAME} completed.`);
+    return buildCheckResult(constants_js_1.BOUNCE_CHECK_NAME, analyzer, "No bounce message handling vulnerabilities detected", "Vulnerability found - contract may not handle bounced messages correctly", contractName, commonArgs.timeout);
 }
 function buildAuditReport(summary) {
     const lines = [];
@@ -191,61 +219,104 @@ function saveAuditReport(summary, ui) {
     ui.write(`${constants_js_1.Sym.OK} Report saved to: ${filePath}`);
     return filePath;
 }
-const auditHandler = async (context, args) => {
-    const { ui } = context;
-    const { timeout, contract, ownerMethod, disableOpcodeExtraction, verbose } = args;
-    await (0, build_utils_js_1.buildContracts)(ui);
-    const contractPath = (0, paths_js_1.findCompiledContract)(contract);
+const auditCommand = async (ui, parsedArgs) => {
+    const contractName = parsedArgs.contract;
+    const ownerMethod = parsedArgs["owner-method"];
+    const disableOpcodeExtraction = parsedArgs["disable-opcode-extraction"];
+    const verbose = parsedArgs.verbose;
+    await (0, build_utils_js_1.buildAllContracts)(ui, parsedArgs.interactive);
+    const contractPath = (0, paths_js_1.findCompiledContract)(contractName);
     if (!(0, fs_1.existsSync)(contractPath)) {
-        ui.write(`\n${constants_js_1.Sym.ERR} Contract ${contract} not found`);
+        ui.write(`\n${constants_js_1.Sym.ERR} Contract ${contractName} not found`);
         process.exit(1);
     }
+    const checkCount = ownerMethod ? 5 : 4;
+    const explicitTimeout = parsedArgs.timeout ?? null;
+    const hasUserProvidedTimeout = (0, command_utils_js_1.hasExplicitTimeout)(explicitTimeout);
+    if (hasUserProvidedTimeout && explicitTimeout !== null) {
+        await (0, command_utils_js_1.confirmLongRunningAnalysis)(ui, {
+            commandLabel: constants_js_1.AUDIT_ID,
+            contractName,
+            timeoutSeconds: explicitTimeout * checkCount,
+            checkCount,
+            interactive: parsedArgs.interactive,
+        });
+    }
     // Extract opcodes if not disabled
     let opcodes = [];
     if (!disableOpcodeExtraction) {
+        if (!hasUserProvidedTimeout) {
+            await (0, command_utils_js_1.confirmOpcodeExtractionWait)(ui, {
+                commandLabel: constants_js_1.AUDIT_ID,
+                contractName,
+                interactive: parsedArgs.interactive,
+            });
+        }
         opcodes = await (0, opcode_extractor_js_1.extractOpcodes)({
             ui,
             codePath: contractPath,
-            contractName: contract,
+            contractName,
+            interactive: parsedArgs.interactive,
         });
     }
     // Calculate timeout if not provided
     // Timeout is per analyzer run (except for opcode-info where it's divided by number of opcodes)
-    let effectiveTimeout = timeout ?? null;
+    let effectiveTimeout = parsedArgs.timeout ?? null;
     if (effectiveTimeout === null && opcodes.length > 0) {
-        effectiveTimeout = ONE_MINUTE_SECONDS * (opcodes.length + 1);
+        effectiveTimeout = command_utils_js_1.ONE_MINUTE_SECONDS * (opcodes.length + 1);
         ui.write("");
         ui.write(`Timeout was calculated automatically: ${effectiveTimeout} seconds per analyzer run (based on ${opcodes.length} opcodes)`);
     }
+    const totalEstimatedTimeout = effectiveTimeout === null ? null : effectiveTimeout * checkCount;
+    if (!hasUserProvidedTimeout) {
+        await (0, command_utils_js_1.confirmLongRunningAnalysis)(ui, {
+            commandLabel: constants_js_1.AUDIT_ID,
+            contractName,
+            timeoutSeconds: totalEstimatedTimeout,
+            opcodeCount: opcodes.length,
+            checkCount,
+            interactive: parsedArgs.interactive,
+        });
+    }
     const summary = {
-        contract: contract,
+        contract: contractName,
         checks: [],
         opcodeInfo: [],
     };
     // Run opcode-info check
     ui.write("");
-    ui.write(`${constants_js_1.Sym.WAIT} Running opcode authorization analysis...`);
-    summary.opcodeInfo = await runOpcodeInfoCheck(contract, contractPath, ui, effectiveTimeout, opcodes, verbose);
+    ui.write(`${constants_js_1.Sym.WAIT} Step 1/${checkCount}: running opcode authorization analysis...`);
+    summary.opcodeInfo = await runOpcodeInfoCheck(contractName, contractPath, ui, effectiveTimeout, opcodes, verbose ?? false, parsedArgs[common_analyzer_args_js_1.VERBOSE_ANALYSIS_ARTIFACTS_OPTION], parsedArgs[common_analyzer_args_js_1.ITERATION_LIMIT_OPTION], parsedArgs[common_analyzer_args_js_1.RECURSION_LIMIT_OPTION], parsedArgs.interactive);
     // Run drain-check
     ui.write("");
-    ui.write(`${constants_js_1.Sym.WAIT} Running drain check...`);
-    const drainResult = await runDrainCheck(contract, contractPath, ui, effectiveTimeout, opcodes, verbose);
+    ui.write(`${constants_js_1.Sym.WAIT} Step 2/${checkCount}: running drain check...`);
+    const commonArgs = {
+        timeout: effectiveTimeout,
+        opcodes,
+        verbose,
+        contract: contractName,
+        iterationLimit: parsedArgs[common_analyzer_args_js_1.ITERATION_LIMIT_OPTION],
+        recursionLimit: parsedArgs[common_analyzer_args_js_1.RECURSION_LIMIT_OPTION],
+        interactive: parsedArgs.interactive,
+        legacyAnalysisArtifacts: parsedArgs[common_analyzer_args_js_1.VERBOSE_ANALYSIS_ARTIFACTS_OPTION],
+    };
+    const drainResult = await runDrainCheck(contractName, contractPath, ui, commonArgs);
     summary.checks.push(drainResult);
     // Run replay-attack-check
     ui.write("");
-    ui.write(`${constants_js_1.Sym.WAIT} Running replay attack check...`);
-    const replayResult = await runReplayAttackCheck(contract, contractPath, ui, effectiveTimeout, verbose);
+    ui.write(`${constants_js_1.Sym.WAIT} Step 3/${checkCount}: running replay attack check...`);
+    const replayResult = await runReplayAttackCheck(contractName, contractPath, ui, effectiveTimeout, verbose ?? false, commonArgs.iterationLimit, commonArgs.recursionLimit, commonArgs.legacyAnalysisArtifacts ?? false, parsedArgs.interactive);
     summary.checks.push(replayResult);
     // Run bounce-check
     ui.write("");
-    ui.write(`${constants_js_1.Sym.WAIT} Running bounce check...`);
-    const bounceResult = await runBounceCheck(contract, contractPath, ui, effectiveTimeout, opcodes, verbose);
+    ui.write(`${constants_js_1.Sym.WAIT} Step 4/${checkCount}: running bounce check...`);
+    const bounceResult = await runBounceCheck(contractName, contractPath, ui, commonArgs);
     summary.checks.push(bounceResult);
     // Run owner-hijack-check if owner method is provided
     if (ownerMethod) {
         ui.write("");
-        ui.write(`${constants_js_1.Sym.WAIT} Running owner hijack check...`);
-        const ownerResult = await runOwnerHijackCheck(contract, contractPath, ui, effectiveTimeout, ownerMethod, opcodes, verbose);
+        ui.write(`${constants_js_1.Sym.WAIT} Step 5/${checkCount}: running owner hijack check...`);
+        const ownerResult = await runOwnerHijackCheck(contractName, contractPath, ui, ownerMethod, commonArgs);
         summary.checks.push(ownerResult);
     }
     else {
@@ -258,39 +329,14 @@ const auditHandler = async (context, args) => {
     saveAuditReport(summary, ui);
     (0, utils_js_1.printCleanupInstructions)(ui);
 };
-const configureAuditCommand = (context) => {
+const createAuditCommand = (context) => {
     return {
         command: constants_js_1.AUDIT_ID,
-        description: "Run all available security checks and print a summary",
-        builder: (yargs) => yargs
-            .option("contract", {
-            alias: "c",
-            type: "string",
-            description: "Contract name",
-            demandOption: true,
-        })
-            .option("timeout", {
-            alias: "t",
-            type: "number",
-            description: "Analysis timeout in seconds per analyzer run (for opcode-info, divided by number of opcodes)",
-        })
-            .option("owner-method", {
-            alias: "m",
-            type: "string",
-            description: "The method name of get_owner getter (optional, enables owner hijack check)",
-        })
-            .option("disable-opcode-extraction", {
-            type: "boolean",
-            description: "Disable opcode extraction. This affects path selection strategy and default timeout.",
-        })
-            .option("verbose", {
-            alias: "v",
-            type: "boolean",
-            description: "Use debug output in TSA log",
-        }),
+        describe: "Run all available security checks and print a summary",
+        builder: auditOptions,
         handler: async (argv) => {
-            await auditHandler(context, argv);
+            await auditCommand(context.ui, argv);
         },
     };
 };
-exports.configureAuditCommand = configureAuditCommand;
+exports.createAuditCommand = createAuditCommand;

package/dist/commands/bounce-check.d.ts

@@ -1,15 +1,59 @@
+import { CommandModule, InferredOptionTypes } from "yargs";
 import { UIProvider } from "@ton/blueprint";
 import { CommandContext } from "../cli.js";
 import { AnalyzerWrapper } from "../common/analyzer-wrapper.js";
-export declare const configureBounceCheckCommand: (context: CommandContext) => any;
+import { CommonAnalyzerRecvInternalArgs } from "./common-analyzer-args.js";
+declare const bounceCheckOptions: {
+    readonly "disable-opcode-extraction": {
+        readonly type: "boolean";
+        readonly description: "Disable opcode extraction. This affects path selection strategy and default timeout.";
+    };
+    readonly timeout: {
+        readonly alias: "t";
+        readonly type: "number";
+        readonly description: "Overall analysis timeout in seconds";
+    };
+    readonly verbose: {
+        readonly alias: "v";
+        readonly type: "boolean";
+        readonly description: "Use debug output in TSA log";
+    };
+    readonly contract: {
+        readonly alias: "c";
+        readonly type: "string";
+        readonly description: "Contract name";
+        readonly demandOption: true;
+    };
+    readonly "iteration-limit": {
+        readonly type: "number";
+        readonly description: "Iteration limit";
+        readonly default: 2;
+    };
+    readonly "max-recursion-depth": {
+        readonly type: "number";
+        readonly description: "Recursion limit";
+        readonly default: 1;
+    };
+    readonly interactive: {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly description: "Enable interactive confirmations";
+    };
+    readonly "verbose-analysis-artifacts": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly description: "Keep TSA exported inputs in the verbose multi-file directory layout";
+    };
+};
+type BounceCheckSchema = InferredOptionTypes<typeof bounceCheckOptions>;
+export declare const createBounceCheckCommand: (context: CommandContext) => CommandModule<object, BounceCheckSchema>;
 /**
  * Runs bounce check analysis and returns the analyzer wrapper
- * @param contractName - Name of the contract
- * @param contractPath - Path to the compiled contract
  * @param ui - UI provider
- * @param timeout - Analysis timeout in seconds
- * @param opcodes - List of opcodes to analyze
- * @param verbose - Enable verbose output
+ * @param contractPath - Path to the compiled contract
+ * @param commonArgs
+ * @param completionMessage
  * @returns AnalyzerWrapper instance
  */
-export declare const runBounceCheckAnalysis: (contractName: string, contractPath: string, ui: UIProvider, timeout: number | null, opcodes: number[], verbose?: boolean, completionMessage?: string) => Promise<AnalyzerWrapper>;
+export declare const runBounceCheckAnalysis: (ui: UIProvider, contractPath: string, commonArgs: CommonAnalyzerRecvInternalArgs, completionMessage?: string) => Promise<AnalyzerWrapper>;
+export {};