solana-mint-recovery-engine 1.0.0

package/dist/bin/smre.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/smre.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const scan_1 = require("../src/commands/scan");
+const inspect_1 = require("../src/commands/inspect");
+const build_1 = require("../src/commands/build");
+const sign_1 = require("../src/commands/sign");
+const simulate_1 = require("../src/commands/simulate");
+const submit_1 = require("../src/commands/submit");
+const recover_1 = require("../src/commands/recover");
+const config_1 = require("../src/commands/config");
+const doctor_1 = require("../src/commands/doctor");
+const program = new commander_1.Command();
+program
+    .name('smre')
+    .description('Solana Mint & Token Account Recovery Engine (SMRE) CLI')
+    .version('1.0.0')
+    .option('-c, --config <path>', 'Path to custom configuration JSON file');
+program
+    .command('scan <address-file>')
+    .description('Scan a list of addresses in a file for recoverable SOL above the rent floor')
+    .option('--json', 'Output results as JSON')
+    .action((addressFile, options) => {
+    (0, scan_1.runScan)(addressFile, { json: options.json, config: program.opts().config });
+});
+program
+    .command('inspect <address>')
+    .description('Inspect details of a single account (balance, rent floor, authority)')
+    .option('--json', 'Output results as JSON')
+    .action((address, options) => {
+    (0, inspect_1.runInspect)(address, { json: options.json, config: program.opts().config });
+});
+program
+    .command('build <address>')
+    .description('Build an unsigned transaction to withdraw excess lamports from an account')
+    .option('-d, --destination <address>', 'Recipient address for the recovered SOL')
+    .option('-o, --output <path>', 'Output transaction envelope JSON file path', 'unsigned_tx.json')
+    .option('--fee-wallet <address>', 'Wallet to receive the platform fee')
+    .option('--fee-percent <number>', 'Platform fee percentage (0-100)')
+    .option('--fee-payer <address>', 'Fee payer for the transaction')
+    .action((address, options) => {
+    (0, build_1.runBuild)(address, {
+        destination: options.destination,
+        output: options.output,
+        config: program.opts().config,
+        feeWallet: options.feeWallet,
+        feePercent: options.feePercent,
+        feePayer: options.feePayer,
+    });
+});
+program
+    .command('simulate <envelope-file>')
+    .description('Simulate the transaction envelope on-chain to verify safety')
+    .action((envelopeFile) => {
+    (0, simulate_1.runSimulate)(envelopeFile, { config: program.opts().config });
+});
+program
+    .command('sign <envelope-file>')
+    .description('Sign an offline transaction envelope using a local private key or keypair file')
+    .requiredOption('-k, --keypair <secret>', 'Path to keypair JSON file, base58 private key, or JSON array')
+    .option('-o, --output <path>', 'Output signed transaction envelope path (defaults to input file)')
+    .action((envelopeFile, options) => {
+    (0, sign_1.runSign)(envelopeFile, {
+        keypair: options.keypair,
+        output: options.output,
+    });
+});
+program
+    .command('submit <envelope-file>')
+    .description('Broadcast a fully signed transaction envelope to the Solana network')
+    .action((envelopeFile) => {
+    (0, submit_1.runSubmit)(envelopeFile, { config: program.opts().config });
+});
+program
+    .command('recover <address>')
+    .description('Convenience command to inspect, build, sign, and submit recovery in one online step')
+    .requiredOption('-k, --keypair <secret>', 'Signing keypair file, array, or base58 private key')
+    .option('-d, --destination <address>', 'Recipient address for the recovered SOL')
+    .option('--fee-wallet <address>', 'Wallet to receive the platform fee')
+    .option('--fee-percent <number>', 'Platform fee percentage (0-100)')
+    .action((address, options) => {
+    (0, recover_1.runRecover)(address, {
+        keypair: options.keypair,
+        destination: options.destination,
+        config: program.opts().config,
+        feeWallet: options.feeWallet,
+        feePercent: options.feePercent,
+    });
+});
+// Nested config commands
+const configCmd = program.command('config').description('Configure SMRE settings');
+configCmd
+    .command('init')
+    .description('Initialize a default config file in the current directory')
+    .option('-o, --output <path>', 'Output path for config file', 'smre.config.json')
+    .action((options) => {
+    (0, config_1.initConfig)(options.output);
+});
+program
+    .command('doctor')
+    .description('Run system health checks, verify RPC endpoints and latency')
+    .action(() => {
+    (0, doctor_1.runDoctor)(program.opts().config);
+});
+program.parse(process.argv);

package/dist/src/commands/build.d.ts

@@ -0,0 +1,8 @@
+export declare function runBuild(addressStr: string, options: {
+    destination?: string;
+    output: string;
+    config?: string;
+    feeWallet?: string;
+    feePercent?: string;
+    feePayer?: string;
+}): Promise<void>;

package/dist/src/commands/build.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBuild = runBuild;
+const web3_js_1 = require("@solana/web3.js");
+const rpc_1 = require("../io/rpc");
+const rent_1 = require("../core/rent");
+const transaction_1 = require("../core/transaction");
+const file_1 = require("../io/file");
+const chalk_1 = __importDefault(require("chalk"));
+async function runBuild(addressStr, options) {
+    try {
+        const config = (0, file_1.loadConfig)(options.config);
+        const rpc = new rpc_1.RpcAdapter(config.rpcUrl, config.commitment);
+        const source = new web3_js_1.PublicKey(addressStr);
+        // 1. Inspect account state
+        const account = await rpc.inspectAccount(source);
+        if (!account.isToken2022) {
+            throw new Error(`Account is not owned by the Token-2022 program. Recoveries are not supported.`);
+        }
+        const { excess, rentFloor } = (0, rent_1.calculateExcessLamports)(account.dataSize, account.balance);
+        if (excess <= 0n) {
+            throw new Error(`Account has no excess lamports above the rent floor (${rentFloor.toLocaleString()} lamports).`);
+        }
+        // 2. Resolve destination
+        const destinationStr = options.destination || config.defaultDestination;
+        if (!destinationStr) {
+            throw new Error(`No destination address specified. Use --destination <address> or define defaultDestination in config.`);
+        }
+        const destination = new web3_js_1.PublicKey(destinationStr);
+        // 3. Resolve authority
+        const authority = account.authority;
+        if (!authority) {
+            throw new Error(`No authority found for account. It is not recoverable.`);
+        }
+        // 4. Resolve fee payer
+        let feePayer = authority;
+        if (account.type === 'multisig' && account.multisigSigners && account.multisigSigners.length > 0) {
+            if (options.feePayer) {
+                feePayer = new web3_js_1.PublicKey(options.feePayer);
+            }
+            else {
+                // Default to the first co-signer for multisig accounts
+                feePayer = account.multisigSigners[0];
+            }
+        }
+        else if (options.feePayer) {
+            feePayer = new web3_js_1.PublicKey(options.feePayer);
+        }
+        // 5. Resolve platform fee wallet & percentage
+        const feeWalletStr = options.feeWallet || config.feeWallet;
+        const feePercentage = options.feePercent !== undefined
+            ? parseInt(options.feePercent, 10)
+            : config.feePercentage;
+        const feeWallet = feeWalletStr ? new web3_js_1.PublicKey(feeWalletStr) : undefined;
+        // 6. Fetch latest blockhash
+        const blockhash = await rpc.getLatestBlockhash();
+        // 7. Build instructions
+        const instructions = (0, transaction_1.buildRecoveryInstructions)({
+            source,
+            destination,
+            authority,
+            excessAmount: excess,
+            developerFeeWallet: feeWallet,
+            feePercentage,
+            multiSigners: account.multisigSigners,
+        });
+        // 8. Compile transaction
+        const tx = new web3_js_1.Transaction();
+        tx.add(...instructions);
+        tx.recentBlockhash = blockhash;
+        tx.feePayer = feePayer;
+        // Serialize unsigned transaction
+        const serialized = tx.serialize({
+            requireAllSignatures: false,
+            verifySignatures: false,
+        });
+        const rawTransactionB64 = serialized.toString('base64');
+        // 9. Create envelope JSON
+        const envelope = {
+            version: '1.0.0',
+            type: 'withdraw-excess-lamports',
+            metadata: {
+                sourceAddress: source.toBase58(),
+                sourceType: account.type,
+                destinationAddress: destination.toBase58(),
+                authorityAddress: authority.toBase58(),
+                excessLamports: excess.toString(),
+                rentFloor: rentFloor.toString(),
+                createdAt: new Date().toISOString(),
+                blockhash,
+            },
+            rawTransactionB64,
+            signatures: [],
+        };
+        if (account.type === 'multisig' && account.multisigSigners) {
+            envelope.metadata.multisigThreshold = account.multisigThreshold;
+            envelope.signatures = account.multisigSigners.map(signer => ({
+                pubkey: signer.toBase58(),
+                signature: null,
+            }));
+        }
+        else {
+            envelope.signatures = [
+                {
+                    pubkey: authority.toBase58(),
+                    signature: null,
+                },
+            ];
+        }
+        // Ensure feePayer is present in signatures
+        const feePayerStr = feePayer.toBase58();
+        if (!envelope.signatures.some(s => s.pubkey === feePayerStr)) {
+            envelope.signatures.push({
+                pubkey: feePayerStr,
+                signature: null,
+            });
+        }
+        // Write envelope file
+        (0, file_1.writeEnvelope)(options.output, envelope);
+        console.log(chalk_1.default.green(`✔ Built transaction envelope and saved to ${options.output}`));
+        console.log('\nTransaction Metadata:');
+        console.log(`  Source:      ${envelope.metadata.sourceAddress} (${envelope.metadata.sourceType})`);
+        console.log(`  Destination: ${envelope.metadata.destinationAddress}`);
+        console.log(`  Authority:   ${envelope.metadata.authorityAddress}`);
+        console.log(`  Fee Payer:   ${feePayer.toBase58()}`);
+        console.log(`  Recoverable: ${Number(excess) / 1e9} SOL`);
+        if (feeWallet) {
+            console.log(`  Fee Split:   ${feePercentage}% to ${feeWallet.toBase58()}`);
+        }
+        console.log(`  Blockhash:   ${envelope.metadata.blockhash}`);
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`✘ Failed to build transaction: ${err.message}`));
+        process.exit(1);
+    }
+}

package/dist/src/commands/config.d.ts

@@ -0,0 +1 @@
+export declare function initConfig(outputPath?: string): void;

package/dist/src/commands/config.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initConfig = initConfig;
+const file_1 = require("../io/file");
+const validation_1 = require("../core/validation");
+const chalk_1 = __importDefault(require("chalk"));
+function initConfig(outputPath = 'smre.config.json') {
+    try {
+        const defaultConfig = validation_1.ConfigSchema.parse({});
+        (0, file_1.writeConfig)(outputPath, defaultConfig);
+        console.log(chalk_1.default.green(`✔ Initialized default configuration at ${outputPath}`));
+        console.log(JSON.stringify(defaultConfig, null, 2));
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`✘ Failed to initialize configuration: ${err.message}`));
+        process.exit(1);
+    }
+}

package/dist/src/commands/doctor.d.ts

@@ -0,0 +1 @@
+export declare function runDoctor(configPath?: string): Promise<void>;

package/dist/src/commands/doctor.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctor = runDoctor;
+const web3_js_1 = require("@solana/web3.js");
+const file_1 = require("../io/file");
+const chalk_1 = __importDefault(require("chalk"));
+async function runDoctor(configPath) {
+    console.log(chalk_1.default.bold('Running SMRE Doctor Diagnostics...'));
+    let isHealthy = true;
+    // 1. Validate Config Load
+    try {
+        const config = (0, file_1.loadConfig)(configPath);
+        console.log(chalk_1.default.green(`✔ Configuration loaded successfully.`));
+        console.log(`  RPC Endpoint: ${config.rpcUrl}`);
+        console.log(`  Commitment: ${config.commitment}`);
+        console.log(`  Default Destination: ${config.defaultDestination || 'None specified'}`);
+        console.log(`  Platform Fee %: ${config.feePercentage}%`);
+        // 2. Validate RPC Connectivity
+        console.log('\nTesting RPC connectivity...');
+        const startTime = Date.now();
+        const connection = new web3_js_1.Connection(config.rpcUrl, config.commitment);
+        const version = await connection.getVersion();
+        const latency = Date.now() - startTime;
+        console.log(chalk_1.default.green(`✔ Connected to Solana node version: ${version['solana-core']}`));
+        console.log(`  Latency: ${latency}ms`);
+        const slot = await connection.getSlot();
+        console.log(chalk_1.default.green(`✔ Latest confirmed slot: ${slot}`));
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`✘ Diagnostic failed: ${err.message}`));
+        isHealthy = false;
+    }
+    if (isHealthy) {
+        console.log(chalk_1.default.bold.green('\n✔ Environment is healthy! You are ready to run SMRE.'));
+        process.exit(0);
+    }
+    else {
+        console.log(chalk_1.default.bold.red('\n✘ Some checks failed. Please review your settings.'));
+        process.exit(1);
+    }
+}

package/dist/src/commands/inspect.d.ts

@@ -0,0 +1,4 @@
+export declare function runInspect(addressStr: string, options: {
+    json?: boolean;
+    config?: string;
+}): Promise<void>;

package/dist/src/commands/inspect.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInspect = runInspect;
+const web3_js_1 = require("@solana/web3.js");
+const rpc_1 = require("../io/rpc");
+const rent_1 = require("../core/rent");
+const file_1 = require("../io/file");
+const chalk_1 = __importDefault(require("chalk"));
+async function runInspect(addressStr, options) {
+    try {
+        const config = (0, file_1.loadConfig)(options.config);
+        const rpc = new rpc_1.RpcAdapter(config.rpcUrl, config.commitment);
+        const address = new web3_js_1.PublicKey(addressStr);
+        const account = await rpc.inspectAccount(address);
+        const { excess, rentFloor } = (0, rent_1.calculateExcessLamports)(account.dataSize, account.balance);
+        const solBalance = Number(account.balance) / 1e9;
+        const solRentFloor = Number(rentFloor) / 1e9;
+        const solExcess = Number(excess) / 1e9;
+        if (options.json) {
+            console.log(JSON.stringify({
+                address: account.address.toBase58(),
+                type: account.type,
+                programOwner: account.ownerProgram.toBase58(),
+                balance: account.balance.toString(),
+                solBalance,
+                rentFloor: rentFloor.toString(),
+                solRentFloor,
+                excessLamports: excess.toString(),
+                solExcess,
+                authority: account.authority ? account.authority.toBase58() : null,
+                isToken2022: account.isToken2022,
+                isRecoverable: excess > 0n && account.isToken2022,
+                multisigSigners: account.multisigSigners?.map(s => s.toBase58()),
+                multisigThreshold: account.multisigThreshold,
+            }, null, 2));
+            process.exit(excess > 0n && account.isToken2022 ? 0 : 3);
+        }
+        console.log(chalk_1.default.bold(`\nAccount Check: ${address.toBase58()}`));
+        console.log('------------------------------------------------------');
+        console.log(`Program Owner:  ${account.isToken2022 ? chalk_1.default.green('Token-2022') : chalk_1.default.yellow('Legacy Token')} (${account.ownerProgram.toBase58()})`);
+        console.log(`Account Type:   ${chalk_1.default.blue(account.type.toUpperCase())}`);
+        console.log(`Total Balance:  ${chalk_1.default.cyan(solBalance.toFixed(9) + ' SOL')} (${account.balance.toLocaleString()} lamports)`);
+        console.log(`Rent Floor:     ${solRentFloor.toFixed(9)} SOL (${rentFloor.toLocaleString()} lamports)`);
+        console.log(`Recoverable:    ${excess > 0n ? chalk_1.default.green(solExcess.toFixed(9) + ' SOL') : chalk_1.default.grey('0.000000000 SOL')} (${excess.toLocaleString()} lamports)`);
+        if (account.authority) {
+            console.log(`Authority:      ${account.authority.toBase58()}`);
+        }
+        else {
+            console.log(`Authority:      ${chalk_1.default.red('NONE (Mint authority disabled)')}`);
+        }
+        if (account.type === 'multisig') {
+            console.log(`Threshold:      ${account.multisigThreshold} of ${account.multisigSigners?.length}`);
+            console.log('Co-signers:');
+            account.multisigSigners?.forEach((signer, index) => {
+                console.log(`  - [${index + 1}] ${signer.toBase58()}`);
+            });
+        }
+        if (!account.isToken2022) {
+            console.log(chalk_1.default.red('\n⚠ ERROR: Legacy Token accounts do not support WithdrawExcessLamports.'));
+            process.exit(1);
+        }
+        if (excess === 0n) {
+            console.log(chalk_1.default.yellow('\nℹ Account has no excess lamports above the rent floor.'));
+            process.exit(3);
+        }
+        console.log(chalk_1.default.green('\n✔ STATUS: RECOVERABLE'));
+        process.exit(0);
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`\n✘ Error inspecting account: ${err.message}`));
+        process.exit(1);
+    }
+}

package/dist/src/commands/recover.d.ts

@@ -0,0 +1,7 @@
+export declare function runRecover(addressStr: string, options: {
+    keypair: string;
+    destination?: string;
+    config?: string;
+    feeWallet?: string;
+    feePercent?: string;
+}): Promise<void>;

package/dist/src/commands/recover.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRecover = runRecover;
+const web3_js_1 = require("@solana/web3.js");
+const rpc_1 = require("../io/rpc");
+const rent_1 = require("../core/rent");
+const transaction_1 = require("../core/transaction");
+const file_1 = require("../io/file");
+const signer_1 = require("../signers/signer");
+const chalk_1 = __importDefault(require("chalk"));
+async function runRecover(addressStr, options) {
+    try {
+        const config = (0, file_1.loadConfig)(options.config);
+        const rpc = new rpc_1.RpcAdapter(config.rpcUrl, config.commitment);
+        const source = new web3_js_1.PublicKey(addressStr);
+        console.log(chalk_1.default.bold('Executing End-to-End Lamport Recovery...'));
+        // 1. Inspect target account
+        console.log('Inspecting target account...');
+        const account = await rpc.inspectAccount(source);
+        if (!account.isToken2022) {
+            throw new Error(`Account is not owned by the Token-2022 program. Only Token-2022 is supported.`);
+        }
+        const { excess, rentFloor } = (0, rent_1.calculateExcessLamports)(account.dataSize, account.balance);
+        if (excess <= 0n) {
+            throw new Error(`Account has no excess lamports above the rent floor (${rentFloor.toLocaleString()} lamports).`);
+        }
+        const solExcess = Number(excess) / 1e9;
+        console.log(chalk_1.default.green(`✔ Found ${solExcess.toFixed(9)} SOL recoverable.`));
+        // 2. Resolve destination
+        const destinationStr = options.destination || config.defaultDestination;
+        if (!destinationStr) {
+            throw new Error(`No destination address specified. Use --destination <address> or define defaultDestination in config.`);
+        }
+        const destination = new web3_js_1.PublicKey(destinationStr);
+        // 3. Load signing keypair
+        console.log('Loading keypair...');
+        const keypair = (0, signer_1.loadKeypair)(options.keypair);
+        const authority = account.authority;
+        if (!authority) {
+            throw new Error(`No authority found for account. Recovery not possible.`);
+        }
+        if (!keypair.publicKey.equals(authority)) {
+            // In multisig, the keypair might be a co-signer
+            if (account.type === 'multisig' && account.multisigSigners) {
+                const isCoSigner = account.multisigSigners.some(s => s.equals(keypair.publicKey));
+                if (!isCoSigner) {
+                    throw new Error(`Loaded keypair ${keypair.publicKey.toBase58()} is not a valid signer for this multisig account.`);
+                }
+            }
+            else {
+                throw new Error(`Loaded keypair ${keypair.publicKey.toBase58()} does not match authority ${authority.toBase58()}`);
+            }
+        }
+        // 4. Resolve developer/platform fee wallet
+        const feeWalletStr = options.feeWallet || config.feeWallet;
+        const feePercentage = options.feePercent !== undefined
+            ? parseInt(options.feePercent, 10)
+            : config.feePercentage;
+        const feeWallet = feeWalletStr ? new web3_js_1.PublicKey(feeWalletStr) : undefined;
+        // 5. Fetch blockhash
+        console.log('Fetching latest blockhash...');
+        const blockhash = await rpc.getLatestBlockhash();
+        // 6. Build instructions
+        console.log('Assembling transaction instructions...');
+        const instructions = (0, transaction_1.buildRecoveryInstructions)({
+            source,
+            destination,
+            authority,
+            excessAmount: excess,
+            developerFeeWallet: feeWallet,
+            feePercentage,
+            multiSigners: account.multisigSigners,
+        });
+        // 7. Compile and sign
+        const tx = new web3_js_1.Transaction();
+        tx.add(...instructions);
+        tx.recentBlockhash = blockhash;
+        tx.feePayer = keypair.publicKey;
+        console.log(`Signing transaction with authority ${keypair.publicKey.toBase58()}...`);
+        tx.sign(keypair);
+        const rawTxBuf = tx.serialize();
+        // 8. Simulate on-chain
+        console.log('Simulating transaction...');
+        const simResult = await rpc.simulateTransaction(rawTxBuf);
+        if (simResult.value.err) {
+            console.error(chalk_1.default.red('✘ Simulation failed!'));
+            console.error(chalk_1.default.red(`Error details: ${JSON.stringify(simResult.value.err)}`));
+            if (simResult.value.logs) {
+                simResult.value.logs.forEach((log) => console.log(chalk_1.default.gray(`  ${log}`)));
+            }
+            process.exit(5);
+        }
+        console.log(chalk_1.default.green('✔ Simulation succeeded.'));
+        // 9. Broadcast
+        console.log('Broadcasting transaction to network...');
+        const signature = await rpc.submitTransaction(rawTxBuf);
+        console.log(chalk_1.default.bold.green('\n✔ Recovery completed successfully!'));
+        console.log(`Signature: ${signature}`);
+        console.log(chalk_1.default.cyan(`Explorer Link: https://explorer.solana.com/tx/${signature}?cluster=custom&customUrl=${encodeURIComponent(config.rpcUrl)}`));
+        process.exit(0);
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`\n✘ Recovery failed: ${err.message}`));
+        process.exit(1);
+    }
+}

package/dist/src/commands/scan.d.ts

@@ -0,0 +1,4 @@
+export declare function runScan(addressListFile: string, options: {
+    json?: boolean;
+    config?: string;
+}): Promise<void>;

package/dist/src/commands/scan.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runScan = runScan;
+const rpc_1 = require("../io/rpc");
+const rent_1 = require("../core/rent");
+const file_1 = require("../io/file");
+const chalk_1 = __importDefault(require("chalk"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+async function runScan(addressListFile, options) {
+    try {
+        const config = (0, file_1.loadConfig)(options.config);
+        const rpc = new rpc_1.RpcAdapter(config.rpcUrl, config.commitment);
+        const addresses = (0, file_1.loadAddresses)(addressListFile);
+        if (addresses.length === 0) {
+            console.error(chalk_1.default.yellow('⚠ No addresses found in input file.'));
+            process.exit(3);
+        }
+        if (!options.json) {
+            console.log(chalk_1.default.bold(`Scanning ${addresses.length} target accounts...`));
+        }
+        const results = [];
+        let totalRecoverable = 0n;
+        for (const address of addresses) {
+            try {
+                const account = await rpc.inspectAccount(address);
+                const { excess, rentFloor } = (0, rent_1.calculateExcessLamports)(account.dataSize, account.balance);
+                if (excess > 0n && account.isToken2022) {
+                    totalRecoverable += excess;
+                }
+                results.push({
+                    address: address.toBase58(),
+                    type: account.type,
+                    ownerProgram: account.ownerProgram.toBase58(),
+                    isToken2022: account.isToken2022,
+                    balance: account.balance,
+                    rentFloor,
+                    excess,
+                    authority: account.authority ? account.authority.toBase58() : null,
+                    status: !account.isToken2022
+                        ? 'UNSUPPORTED_LEGACY'
+                        : excess > 0n
+                            ? 'RECOVERABLE'
+                            : 'RENT_EXEMPT_MIN',
+                });
+            }
+            catch (err) {
+                results.push({
+                    address: address.toBase58(),
+                    status: 'ERROR',
+                    error: err.message,
+                });
+            }
+        }
+        if (options.json) {
+            console.log(JSON.stringify({
+                scannedAt: new Date().toISOString(),
+                summary: {
+                    totalAccounts: addresses.length,
+                    totalRecoverableLamports: totalRecoverable.toString(),
+                    totalRecoverableSol: Number(totalRecoverable) / 1e9,
+                },
+                accounts: results.map(res => ({
+                    ...res,
+                    balance: res.balance?.toString(),
+                    rentFloor: res.rentFloor?.toString(),
+                    excess: res.excess?.toString(),
+                })),
+            }, null, 2));
+            process.exit(totalRecoverable > 0n ? 0 : 3);
+        }
+        // Print table output
+        const table = new cli_table3_1.default({
+            head: ['Address', 'Type', 'Program', 'Balance (SOL)', 'Rent Floor (SOL)', 'Excess (SOL)', 'Status'],
+            colWidths: [46, 12, 12, 16, 18, 16, 20]
+        });
+        for (const res of results) {
+            if (res.status === 'ERROR') {
+                table.push([
+                    res.address,
+                    '-',
+                    '-',
+                    '-',
+                    '-',
+                    '-',
+                    chalk_1.default.red(`ERROR: ${res.error}`),
+                ]);
+            }
+            else {
+                const solBal = Number(res.balance ?? 0n) / 1e9;
+                const solRent = Number(res.rentFloor ?? 0n) / 1e9;
+                const solExcess = Number(res.excess ?? 0n) / 1e9;
+                let statusText = res.status;
+                if (res.status === 'RECOVERABLE') {
+                    statusText = chalk_1.default.green('RECOVERABLE');
+                }
+                else if (res.status === 'UNSUPPORTED_LEGACY') {
+                    statusText = chalk_1.default.yellow('LEGACY PROGRAM');
+                }
+                else {
+                    statusText = chalk_1.default.gray('RENT EXEMPT');
+                }
+                table.push([
+                    res.address,
+                    res.type?.toUpperCase() ?? '-',
+                    res.isToken2022 ? 'Token-2022' : 'Legacy',
+                    solBal.toFixed(5),
+                    solRent.toFixed(5),
+                    (res.excess ?? 0n) > 0n && res.isToken2022 ? chalk_1.default.green(solExcess.toFixed(5)) : '0.00000',
+                    statusText,
+                ]);
+            }
+        }
+        console.log(table.toString());
+        console.log('\n' + chalk_1.default.bold('Summary Report:'));
+        console.log(`  Total Accounts Scanned: ${addresses.length}`);
+        console.log(`  Total Recoverable SOL:  ${chalk_1.default.green((Number(totalRecoverable) / 1e9).toFixed(9) + ' SOL')} (${totalRecoverable.toLocaleString()} lamports)`);
+        process.exit(totalRecoverable > 0n ? 0 : 3);
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`\n✘ Scan failed: ${err.message}`));
+        process.exit(1);
+    }
+}