@venusprotocol/venus-periphery 1.2.0-dev.6 → 1.2.0-dev.7

package/dist/helpers/generateSafeEBrakeJson.js

@@ -0,0 +1,1302 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = exports.orchestrate = exports.exportJson = exports.generateCommands = exports.gatherInput = exports.parsePerPoolValuesJson = exports.parsePerMarketValuesJson = exports.parsePoolIdList = exports.getEBrakeAddress = exports.parseUint256String = exports.buildSafeBatch = exports.ALLOWED_PAUSE_ACTIONS = exports.retry = void 0;
+const fs = __importStar(require("fs"));
+const hardhat_1 = require("hardhat");
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+// ─── Terminal colors ─────────────────────────────────────────────────────────
+const colorEnabled = process.stdout.isTTY && !process.env.NO_COLOR;
+const colorWrap = (code) => (s) => colorEnabled ? `\x1b[${code}m${s}\x1b[0m` : s;
+const red = colorWrap("31");
+const green = colorWrap("32");
+const yellow = colorWrap("33");
+const cyan = colorWrap("36");
+const bold = colorWrap("1");
+// ─── Retry helper ────────────────────────────────────────────────────────────
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function retry(fn, retries = 3, delayMs = 1000) {
+    let lastError;
+    for (let attempt = 1; attempt <= retries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt < retries) {
+                console.log(`  RPC call failed (attempt ${attempt}/${retries}), retrying in ${delayMs / 1000}s...`);
+                await sleep(delayMs);
+            }
+        }
+    }
+    throw lastError;
+}
+exports.retry = retry;
+// ─── Configuration ──────────────────────────────────────────────────────────
+const OUTPUT_DIR = path.resolve(__dirname, "data");
+const EBRAKE_ABI = [
+    "function IS_ISOLATED_POOL() view returns (bool)",
+    "function COMPTROLLER() view returns (address)",
+    "function pauseActions(address[],uint8[])",
+    "function pauseSupply(address)",
+    "function pauseRedeem(address)",
+    "function pauseBorrow(address)",
+    "function pauseTransfer(address)",
+    "function pauseFlashLoan()",
+    "function disablePoolBorrow(uint96,address)",
+    "function revokeFlashLoanAccess(address)",
+    "function decreaseCF(address,uint256)",
+    "function decreaseCF(address,uint96,uint256)",
+    "function setMarketBorrowCaps(address[],uint256[])",
+    "function setMarketSupplyCaps(address[],uint256[])",
+];
+// ABIs used for on-chain queries (current CF / caps display)
+const BSC_COMPTROLLER_QUERY_ABI = [
+    "function getAllMarkets() view returns (address[])",
+    "function markets(address) view returns (bool isListed, uint256 collateralFactorMantissa, bool isVenus, uint256 liquidationThresholdMantissa, uint256 liquidationIncentiveMantissa, uint96 marketPoolId, bool isBorrowAllowed)",
+    "function poolMarkets(uint96,address) view returns (bool isListed, uint256 collateralFactorMantissa, bool isVenus, uint256 liquidationThresholdMantissa, uint256 liquidationIncentiveMantissa, uint96 marketPoolId, bool isBorrowAllowed)",
+    "function corePoolId() view returns (uint96)",
+    "function lastPoolId() view returns (uint96)",
+    "function borrowCaps(address) view returns (uint256)",
+    "function supplyCaps(address) view returns (uint256)",
+];
+const IL_COMPTROLLER_QUERY_ABI = [
+    "function getAllMarkets() view returns (address[])",
+    "function markets(address) view returns (bool isListed, uint256 collateralFactorMantissa, uint256 liquidationThresholdMantissa)",
+    "function borrowCaps(address) view returns (uint256)",
+    "function supplyCaps(address) view returns (uint256)",
+];
+// Only MINT, REDEEM, BORROW, TRANSFER are allowed by EBrake (REPAY/SEIZE/LIQUIDATE are forbidden)
+exports.ALLOWED_PAUSE_ACTIONS = {
+    MINT: 0,
+    REDEEM: 1,
+    BORROW: 2,
+    TRANSFER: 6,
+};
+// ─── Safe TX Builder JSON ────────────────────────────────────────────────────
+const buildSafeBatch = (safeAddress, transactions, chainId, blockNumber) => {
+    const createdAt = Date.now();
+    const txs = transactions.map(tx => ({
+        to: tx.to,
+        value: tx.value,
+        data: tx.data,
+        contractMethod: null,
+        contractInputsValues: null,
+    }));
+    const metaBase = {
+        name: "Transactions Batch",
+        description: "",
+        txBuilderVersion: "1.8.0",
+        createdFromSafeAddress: safeAddress,
+        createdFromOwnerAddress: "",
+    };
+    // Checksum matches the format expected by the Safe TX Builder UI
+    const checksum = hardhat_1.ethers.utils.id(JSON.stringify({ version: "1.0", chainId: chainId.toString(), createdAt, meta: metaBase, transactions: txs }));
+    return {
+        version: "1.0",
+        chainId: chainId.toString(),
+        createdAt,
+        meta: { ...metaBase, checksum },
+        transactions: txs,
+        blockNumber,
+    };
+};
+exports.buildSafeBatch = buildSafeBatch;
+// ─── CLI helpers ─────────────────────────────────────────────────────────────
+const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+const ask = (question) => new Promise(resolve => rl.question(question, answer => resolve(answer.trim())));
+const pickOne = async (prompt, options) => {
+    console.log(`\n${prompt}`);
+    options.forEach((opt, i) => console.log(`  ${i + 1}. ${opt}`));
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const answer = await ask("Enter number: ");
+        const idx = parseInt(answer, 10) - 1;
+        if (idx >= 0 && idx < options.length) {
+            return options[idx];
+        }
+        console.log(red(`Invalid selection "${answer}". Please enter a number between 1 and ${options.length}.`));
+    }
+};
+const pickMultiple = async (prompt, options, { allowAll = true, preserveOrder = false } = {}) => {
+    console.log(`\n${prompt}`);
+    options.forEach(opt => console.log(`  ${opt.value}. ${opt.name}`));
+    const validValues = new Set(options.map(o => o.value));
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        console.log(allowAll ? "Enter comma-separated values or 'all' for all:" : "Enter comma-separated values:");
+        const answer = await ask("> ");
+        if (allowAll && answer.toLowerCase() === "all")
+            return options.map(o => o.value);
+        const tokens = answer
+            .split(",")
+            .map(n => n.trim())
+            .filter(v => v.length > 0);
+        if (tokens.length === 0) {
+            console.log(red("No values entered. Please try again."));
+            continue;
+        }
+        const invalid = tokens.filter(v => !validValues.has(v));
+        if (invalid.length > 0) {
+            console.log(red(`Invalid value(s): ${invalid.join(", ")}. Valid options are: ${[...validValues].join(", ")}.`));
+            continue;
+        }
+        // preserveOrder=true keeps duplicates and caller's order (e.g., "1,3,2" stays [1,3,2]).
+        return preserveOrder ? tokens : [...new Set(tokens)];
+    }
+};
+const askYesNo = async (prompt) => {
+    console.log(`\n${prompt}`);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const answer = (await ask("(y/n): ")).toLowerCase();
+        if (answer === "y" || answer === "yes")
+            return true;
+        if (answer === "n" || answer === "no")
+            return false;
+        console.log(red(`Invalid input "${answer}". Please enter y or n.`));
+    }
+};
+const pickValidAddresses = async (prompt) => {
+    console.log(`\n${prompt}`);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const answer = await ask("> ");
+        const tokens = answer
+            .split(",")
+            .map(a => a.trim())
+            .filter(a => a.length > 0);
+        if (tokens.length === 0) {
+            console.log(red("No addresses entered. Please try again."));
+            continue;
+        }
+        const invalid = tokens.filter(a => !hardhat_1.ethers.utils.isAddress(a));
+        if (invalid.length > 0) {
+            console.log(red(`Invalid address(es): ${invalid.join(", ")}. Please enter valid Ethereum addresses.`));
+            continue;
+        }
+        return [...new Set(tokens)];
+    }
+};
+// Pure parser: validates a user-entered uint256 string. Returns normalized
+// decimal string or null if invalid / negative. Extracted so unit tests can
+// cover every reject path without driving readline.
+const parseUint256String = (raw) => {
+    try {
+        const bn = hardhat_1.ethers.BigNumber.from(raw);
+        if (bn.lt(0))
+            return null;
+        return bn.toString();
+    }
+    catch {
+        return null;
+    }
+};
+exports.parseUint256String = parseUint256String;
+const askUint256 = async (prompt) => {
+    console.log(`\n${prompt}`);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const answer = await ask("> ");
+        const parsed = (0, exports.parseUint256String)(answer);
+        if (parsed !== null)
+            return parsed;
+        console.log(red(`Invalid uint256 "${answer}". Please enter a non-negative integer.`));
+    }
+};
+// ─── On-chain query helpers ──────────────────────────────────────────────────
+const VTOKEN_ABI = ["function symbol() view returns (string)"];
+const fetchSymbol = async (vToken) => {
+    try {
+        const contract = new hardhat_1.ethers.Contract(vToken, VTOKEN_ABI, hardhat_1.ethers.provider);
+        return await retry(() => contract.symbol());
+    }
+    catch {
+        return `MARKET_${vToken.slice(2, 8).toUpperCase()}`;
+    }
+};
+const fetchAllMarkets = async (comptroller, isIsolatedPool) => {
+    const abi = isIsolatedPool ? IL_COMPTROLLER_QUERY_ABI : BSC_COMPTROLLER_QUERY_ABI;
+    const contract = new hardhat_1.ethers.Contract(comptroller, abi, hardhat_1.ethers.provider);
+    const allMarkets = await retry(() => contract.getAllMarkets());
+    console.log(`Found ${allMarkets.length} market(s) on comptroller.`);
+    return allMarkets;
+};
+const filterListedAndFetchSymbols = async (comptroller, isIsolatedPool, markets, logUnlisted) => {
+    const abi = isIsolatedPool ? IL_COMPTROLLER_QUERY_ABI : BSC_COMPTROLLER_QUERY_ABI;
+    const contract = new hardhat_1.ethers.Contract(comptroller, abi, hardhat_1.ethers.provider);
+    console.log(`Checking ${markets.length} market(s)...`);
+    const results = await Promise.all(markets.map(async (market) => {
+        const { isListed } = await retry(() => contract.markets(market));
+        if (isListed) {
+            const symbol = await fetchSymbol(market);
+            return { market, isListed: true, symbol };
+        }
+        return { market, isListed: false, symbol: "" };
+    }));
+    const addresses = [];
+    const symbols = new Map();
+    for (const { market, isListed, symbol } of results) {
+        if (isListed) {
+            addresses.push(market);
+            symbols.set(market, symbol);
+        }
+        else if (logUnlisted) {
+            console.log(yellow(`  Skipping unlisted market: ${market}`));
+        }
+    }
+    console.log(green(`  Found ${addresses.length} listed market(s)`));
+    return { addresses, symbols };
+};
+const fetchCurrentCF = async (comptroller, vToken, isIsolatedPool, poolId) => {
+    if (isIsolatedPool) {
+        const contract = new hardhat_1.ethers.Contract(comptroller, IL_COMPTROLLER_QUERY_ABI, hardhat_1.ethers.provider);
+        const data = await retry(() => contract.markets(vToken));
+        return { cf: data.collateralFactorMantissa, lt: data.liquidationThresholdMantissa };
+    }
+    else {
+        const contract = new hardhat_1.ethers.Contract(comptroller, BSC_COMPTROLLER_QUERY_ABI, hardhat_1.ethers.provider);
+        const actualPoolId = poolId !== undefined ? poolId : (await retry(() => contract.corePoolId())).toNumber();
+        const data = await retry(() => contract.poolMarkets(actualPoolId, vToken));
+        return { cf: data.collateralFactorMantissa, lt: data.liquidationThresholdMantissa };
+    }
+};
+const fetchCurrentCaps = async (comptroller, vToken, isIsolatedPool) => {
+    const abi = isIsolatedPool ? IL_COMPTROLLER_QUERY_ABI : BSC_COMPTROLLER_QUERY_ABI;
+    const contract = new hardhat_1.ethers.Contract(comptroller, abi, hardhat_1.ethers.provider);
+    const [borrowCap, supplyCap] = await Promise.all([
+        retry(() => contract.borrowCaps(vToken)),
+        retry(() => contract.supplyCaps(vToken)),
+    ]);
+    return { borrowCap, supplyCap };
+};
+const buildMarketsFromChain = async (comptroller, isIsolatedPool) => {
+    console.log("\nQuerying comptroller for all markets...");
+    const allMarkets = await fetchAllMarkets(comptroller, isIsolatedPool);
+    const { addresses, symbols } = await filterListedAndFetchSymbols(comptroller, isIsolatedPool, allMarkets, false);
+    const markets = {};
+    const collisions = [];
+    for (const addr of addresses) {
+        const sym = symbols.get(addr);
+        if (markets[sym]) {
+            collisions.push(`${sym}: ${markets[sym]} and ${addr}`);
+        }
+        else {
+            markets[sym] = addr;
+        }
+    }
+    if (collisions.length > 0) {
+        console.error(red("Symbol collision(s) detected:"));
+        collisions.forEach(c => console.error(red(`  ${c}`)));
+        console.error(red("Cannot build markets map with duplicate symbol keys."));
+        rl.close();
+        process.exit(1);
+    }
+    return markets;
+};
+// ─── Network helpers ─────────────────────────────────────────────────────────
+const getEBrakeAddress = async (networkName) => {
+    // Try to load from hardhat-deploy artifact
+    const artifactPath = path.resolve(__dirname, "..", "deployments", networkName, "EBrake.json");
+    if (fs.existsSync(artifactPath)) {
+        try {
+            const artifact = JSON.parse(fs.readFileSync(artifactPath, "utf-8"));
+            if (hardhat_1.ethers.utils.isAddress(artifact.address)) {
+                console.log(green(`EBrake address from deployment artifact: ${artifact.address}`));
+                return artifact.address;
+            }
+        }
+        catch {
+            // Fall through to manual prompt
+        }
+    }
+    console.log(`No EBrake deployment artifact found for network "${networkName}".`);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const entered = await ask("Enter EBrake proxy address manually: ");
+        if (hardhat_1.ethers.utils.isAddress(entered))
+            return entered;
+        console.log(red(`Invalid address "${entered}". Please enter a valid Ethereum address.`));
+    }
+};
+exports.getEBrakeAddress = getEBrakeAddress;
+const DEFAULT_SAFE_ADDRESS = "0xCCa5a587eBDBe80f23c8610F2e53B03158e62948";
+const askSafeAddress = async () => {
+    console.log("\nEnter the Gnosis Safe address that will sign this transaction.");
+    console.log(`Press Enter to use the default: ${DEFAULT_SAFE_ADDRESS}`);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const answer = (await ask("> ")).trim();
+        if (answer === "")
+            return DEFAULT_SAFE_ADDRESS;
+        if (hardhat_1.ethers.utils.isAddress(answer))
+            return answer;
+        console.log(red(`Invalid address "${answer}". Please enter a valid Ethereum address.`));
+    }
+};
+// ─── Market selection helper ─────────────────────────────────────────────────
+const pickSymbols = async (entries) => {
+    const validSymbols = new Set(entries.map(([s]) => s));
+    console.log("\nEnter comma-separated names or 'all':");
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const answer = await ask("> ");
+        if (answer.trim().toLowerCase() === "all")
+            return entries;
+        const tokens = answer
+            .split(",")
+            .map(n => n.trim())
+            .filter(v => v.length > 0);
+        if (tokens.length === 0) {
+            console.log(red("No names entered. Please try again."));
+            continue;
+        }
+        const invalid = tokens.filter(t => !validSymbols.has(t));
+        if (invalid.length > 0) {
+            console.log(red(`Unknown symbol(s): ${invalid.join(", ")}. Valid symbols: ${[...validSymbols].join(", ")}.`));
+            continue;
+        }
+        const dedup = [...new Set(tokens)];
+        return dedup.map(sym => entries.find(([s]) => s === sym));
+    }
+};
+// Pure parser: parses a pool-id list answer ("0,6" or "all") against the set
+// of available pools. Returns the picked pool IDs (deduped, order preserved)
+// or null if the answer is empty / contains unknown IDs. Extracted for unit
+// testing without driving readline.
+const parsePoolIdList = (answer, available) => {
+    const validSet = new Set(available);
+    const t = answer.trim().toLowerCase();
+    if (t === "all")
+        return available;
+    const tokens = answer
+        .split(",")
+        .map(s => s.trim())
+        .filter(v => v.length > 0);
+    if (tokens.length === 0)
+        return null;
+    const parsed = tokens.map(Number);
+    if (parsed.some(n => !Number.isInteger(n) || !validSet.has(n)))
+        return null;
+    return [...new Set(parsed)];
+};
+exports.parsePoolIdList = parsePoolIdList;
+// Asks operator to pick which pool IDs a market should act on. Called per
+// market after market selection — prevents blind fan-out to every pool the
+// market happens to be listed in when only a subset is intended.
+const pickPoolIds = async (sym, available) => {
+    console.log(cyan(`\n${sym} is listed in pool(s): [${available.join(", ")}]`));
+    console.log("Enter comma-separated pool IDs or 'all':");
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const answer = await ask("> ");
+        const picked = (0, exports.parsePoolIdList)(answer, available);
+        if (picked !== null)
+            return picked;
+        console.log(red(`Invalid pool ID entry "${answer}". Valid: ${available.join(", ")}.`));
+    }
+};
+const selectMarkets = async (ctx) => {
+    const { comptrollerAddress: comptroller, isIsolatedPool } = ctx;
+    const marketMode = await pickOne("How to load markets?", [
+        "Enter addresses manually in CLI",
+        "Select by name (auto-fetch all listed markets on first use, cached for this run)",
+    ]);
+    let marketAddresses = [];
+    let symbols = new Map();
+    if (marketMode.startsWith("Enter")) {
+        const entered = await pickValidAddresses("Enter market addresses (comma-separated):");
+        const result = await filterListedAndFetchSymbols(comptroller, isIsolatedPool, entered, true);
+        marketAddresses = result.addresses;
+        symbols = result.symbols;
+        console.log(`\nUsing ${marketAddresses.length} address(es):`);
+        marketAddresses.forEach(addr => console.log(`  ${symbols.get(addr)} (${addr})`));
+    }
+    else {
+        let networkMarkets = ctx.marketsCache;
+        if (!networkMarkets) {
+            networkMarkets = await buildMarketsFromChain(comptroller, isIsolatedPool);
+            ctx.marketsCache = networkMarkets;
+        }
+        else {
+            console.log(`Reusing ${Object.keys(networkMarkets).length} market(s) fetched earlier in this run.`);
+        }
+        const entries = Object.entries(networkMarkets);
+        console.log(`Available markets: ${entries.map(([sym]) => sym).join(", ")}`);
+        const selected = await pickSymbols(entries);
+        marketAddresses = selected.map(([, addr]) => addr);
+        symbols = new Map(selected.map(([sym, addr]) => [addr, sym]));
+        console.log(`\nSelected ${marketAddresses.length} market(s):`);
+        selected.forEach(([sym, addr]) => console.log(`  ${sym} (${addr})`));
+    }
+    if (marketAddresses.length === 0) {
+        console.error(red("\nNo listed markets found. Exiting."));
+        rl.close();
+        process.exit(1);
+    }
+    return { marketAddresses, symbols };
+};
+// A market can be listed in multiple pools (core + e-mode) with different
+// settings, so we walk every (poolId, market) pair via poolMarkets().isListed.
+// markets().marketPoolId only surfaces one pool per market and would miss the others.
+const enumerateBscPools = async (comptroller) => {
+    const contract = new hardhat_1.ethers.Contract(comptroller, BSC_COMPTROLLER_QUERY_ABI, hardhat_1.ethers.provider);
+    const [allMarkets, lastPoolIdBn] = await Promise.all([
+        retry(() => contract.getAllMarkets()),
+        retry(() => contract.lastPoolId()),
+    ]);
+    const lastPoolId = lastPoolIdBn.toNumber();
+    console.log(`Scanning ${allMarkets.length} market(s) across ${lastPoolId + 1} pool(s)...`);
+    // Fetch each symbol once — a market in multiple pools reuses the same symbol.
+    const symbolEntries = await Promise.all(allMarkets.map(async (m) => [m, await fetchSymbol(m)]));
+    const symbolMap = new Map(symbolEntries);
+    const pools = [];
+    for (let poolId = 0; poolId <= lastPoolId; poolId++) {
+        const listed = await Promise.all(allMarkets.map(async (market) => {
+            const data = await retry(() => contract.poolMarkets(poolId, market));
+            return data.isListed ? market : null;
+        }));
+        const addresses = listed.filter((m) => m !== null);
+        if (addresses.length === 0)
+            continue;
+        const poolSymbols = new Map();
+        addresses.forEach(a => poolSymbols.set(a, symbolMap.get(a) ?? a));
+        pools.push({ poolId, addresses, symbols: poolSymbols });
+    }
+    return pools;
+};
+// Lists pools for context, then asks the operator to pick markets from the
+// cross-pool union. Each picked market is mapped to the pool IDs it's listed in,
+// so commandsForStep can fan out one tx per (market, pool) pair. Pools without
+// the market are skipped automatically — they never appear in poolIdsByMarket.
+const pickBscMarketsFanOut = async (ctx) => {
+    let pools = ctx.bscPoolsCache;
+    if (!pools) {
+        pools = await enumerateBscPools(ctx.comptrollerAddress);
+        ctx.bscPoolsCache = pools;
+    }
+    else {
+        console.log(`Reusing ${pools.length} pool(s) fetched earlier in this run.`);
+    }
+    if (pools.length === 0) {
+        console.error(red("\nNo listed markets found on any pool. Exiting."));
+        rl.close();
+        process.exit(1);
+    }
+    // Build {market → [poolIds]} and {symbol ↔ address} across the union.
+    const poolsByMarket = new Map();
+    const addressToSymbol = new Map();
+    for (const p of pools) {
+        for (const addr of p.addresses) {
+            const list = poolsByMarket.get(addr) ?? [];
+            list.push(p.poolId);
+            poolsByMarket.set(addr, list);
+            addressToSymbol.set(addr, p.symbols.get(addr) ?? addr);
+        }
+    }
+    const lastPoolId = Math.max(...pools.map(p => p.poolId));
+    const allSymbols = Array.from(addressToSymbol.values()).join(", ");
+    console.log(cyan(`\n${pools.length} pools available (lastPoolId = ${lastPoolId})`));
+    console.log(`Available markets: ${allSymbols}`);
+    const entries = Array.from(addressToSymbol, ([addr, sym]) => [sym, addr]);
+    const selected = await pickSymbols(entries);
+    const marketAddresses = selected.map(([, addr]) => addr);
+    const symbols = new Map(selected.map(([sym, addr]) => [addr, sym]));
+    // Per-market pool picker: operator chooses which pool IDs to act on.
+    // Markets listed in a single pool skip the prompt (nothing to pick).
+    console.log(cyan("\n--- Pool selection per market ---"));
+    const poolIdsByMarket = new Map();
+    for (const addr of marketAddresses) {
+        const sym = symbols.get(addr) ?? addr;
+        const available = poolsByMarket.get(addr) ?? [];
+        if (available.length <= 1) {
+            poolIdsByMarket.set(addr, available);
+            if (available.length === 1) {
+                console.log(`${sym} → pool [${available[0]}] (only pool, no selection needed)`);
+            }
+            continue;
+        }
+        const picked = await pickPoolIds(sym, available);
+        poolIdsByMarket.set(addr, picked);
+    }
+    console.log(cyan("\nFan-out plan:"));
+    let totalTxs = 0;
+    for (const addr of marketAddresses) {
+        const sym = symbols.get(addr) ?? addr;
+        const ids = poolIdsByMarket.get(addr) ?? [];
+        totalTxs += ids.length;
+        console.log(`  ${sym} → pool(s) [${ids.join(", ")}]`);
+    }
+    // Guard against fat-finger 'all' on a market with many pools — explicit
+    // confirm before the batch is generated.
+    const proceed = await askYesNo(`About to fan out ${totalTxs} tx(s) across the selection. Proceed?`);
+    if (!proceed) {
+        console.log(yellow("Aborted by operator. No batch generated."));
+        rl.close();
+        process.exit(0);
+    }
+    return { marketAddresses, symbols, poolIdsByMarket };
+};
+const parsePerMarketValuesJson = (raw, markets, symbols) => {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+        return { kind: "notObject" };
+    const symbolToAddress = new Map();
+    symbols.forEach((sym, addr) => symbolToAddress.set(sym, addr));
+    const selectionSet = new Set(markets);
+    const values = new Map();
+    const ignored = [];
+    for (const [key, rawValue] of Object.entries(raw)) {
+        const addr = hardhat_1.ethers.utils.isAddress(key) ? key : symbolToAddress.get(key);
+        if (!addr || !selectionSet.has(addr)) {
+            ignored.push(key);
+            continue;
+        }
+        try {
+            const bn = hardhat_1.ethers.BigNumber.from(rawValue);
+            if (bn.lt(0))
+                throw new Error("neg");
+            values.set(addr, bn.toString());
+        }
+        catch {
+            return { kind: "invalidValue", key, rawValue };
+        }
+    }
+    const missingSymbols = markets.filter(m => !values.has(m)).map(m => symbols.get(m) || m);
+    if (missingSymbols.length > 0)
+        return { kind: "missing", missingSymbols, ignored };
+    return { kind: "ok", values, ignored };
+};
+exports.parsePerMarketValuesJson = parsePerMarketValuesJson;
+// Collect per-market values (CF or cap) via one of three modes: uniform, per-market CLI, or file.
+const gatherPerMarketValues = async (markets, symbols, cfg) => {
+    const mode = await pickOne(`Apply ${cfg.kind}:`, [
+        `Single value to ALL selected markets (e.g. 0 to block)`,
+        `Per-market values via CLI prompts`,
+        `Load values from a JSON file`,
+    ]);
+    const result = new Map();
+    const fetchAllCurrent = async () => {
+        const entries = await Promise.all(markets.map(async (m) => [m, await cfg.fetchCurrent(m)]));
+        return new Map(entries);
+    };
+    if (mode.startsWith("Single")) {
+        const value = await askUint256(`Enter new ${cfg.kind} for all selected markets:`);
+        markets.forEach(m => result.set(m, value));
+    }
+    else if (mode.startsWith("Per-market")) {
+        const current = await fetchAllCurrent();
+        for (const m of markets) {
+            const sym = symbols.get(m) || m;
+            const value = await askUint256(`  ${sym} [current: ${current.get(m)}]:`);
+            result.set(m, value);
+        }
+    }
+    else {
+        const defaultPath = path.resolve(OUTPUT_DIR, cfg.defaultFilename);
+        // Print expected file shape before asking for the path so operators can
+        // prepare the file rather than discovering the format by trial and error.
+        console.log(cyan(`\nExpected ${cfg.kind} file format:`));
+        console.log(`  JSON object mapping symbol (or address) → ${cfg.kind} value.`);
+        console.log(`  Example:`);
+        console.log(`    {`);
+        console.log(`      "vAAVE": "0",`);
+        console.log(`      "vBTCB": "500000000000000000"`);
+        console.log(`    }`);
+        console.log(`  Address keys are accepted too. Values must be non-negative integers.`);
+        console.log(`  If the file doesn't exist, a template pre-filled with current on-chain`);
+        console.log(`  values will be offered — edit it, save, re-run.`);
+        // Re-prompt on any validation failure so a typo in the path or the file's
+        // contents doesn't force the operator to restart the whole flow. The last
+        // entered path is remembered so the post-template-gen retry lands on the
+        // same file the operator just edited.
+        let stickyDefault = defaultPath;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            console.log(`\nEnter path to ${cfg.kind} values file (press enter for default: ${stickyDefault})`);
+            const entered = await ask("> ");
+            const filePath = entered.length > 0 ? entered : stickyDefault;
+            stickyDefault = filePath;
+            // Local helper: writes a fresh template for the current selection, backs
+            // up any prior content to .bak, then pauses for operator edit+resume.
+            const regenerateTemplateAndPause = async (reason) => {
+                if (reason === "missing" && fs.existsSync(filePath)) {
+                    const backup = `${filePath}.bak`;
+                    fs.copyFileSync(filePath, backup);
+                    console.log(yellow(`\nExisting file backed up to ${backup} before regeneration.`));
+                }
+                console.log(`\nGenerating template with current on-chain ${cfg.kind} values...`);
+                const current = await fetchAllCurrent();
+                const template = {};
+                for (const m of markets) {
+                    const sym = symbols.get(m) || m;
+                    template[sym] = current.get(m) ?? "0";
+                }
+                fs.mkdirSync(path.dirname(filePath), { recursive: true });
+                fs.writeFileSync(filePath, JSON.stringify(template, null, 2) + "\n");
+                console.log(green(`Template written to ${filePath}`));
+                console.log(`Edit the values (they currently match on-chain ${cfg.kind}), save, then press Enter to continue.`);
+                console.log("Type 'q' + Enter to quit.");
+                const resume = (await ask("> ")).trim().toLowerCase();
+                if (resume === "q") {
+                    rl.close();
+                    process.exit(0);
+                }
+            };
+            if (!fs.existsSync(filePath)) {
+                const confirm = await askYesNo(`${filePath} not found. Generate template there?`);
+                if (!confirm)
+                    continue;
+                await regenerateTemplateAndPause("new");
+                // Fall through: loop restarts. stickyDefault = filePath, so Enter keeps the same file.
+                continue;
+            }
+            let content;
+            try {
+                content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+            }
+            catch (error) {
+                console.error(red(`Failed to parse ${filePath}: ${error.message}`));
+                continue;
+            }
+            const parsed = (0, exports.parsePerMarketValuesJson)(content, markets, symbols);
+            if (parsed.kind === "notObject") {
+                console.error(red(`${filePath} must contain a JSON object mapping symbol-or-address → value.`));
+                continue;
+            }
+            if (parsed.kind === "invalidValue") {
+                console.error(red(`Invalid ${cfg.kind} value for "${parsed.key}": ${String(parsed.rawValue)}`));
+                continue;
+            }
+            if (parsed.kind === "missing") {
+                parsed.ignored.forEach(k => console.log(yellow(`  Ignoring "${k}" — not in current selection`)));
+                console.log(yellow(`\nFile stale — missing entries for: ${parsed.missingSymbols.join(", ")}.`));
+                console.log(yellow(`Regenerating template for current selection. Existing file will be backed up.`));
+                await regenerateTemplateAndPause("missing");
+                continue;
+            }
+            parsed.ignored.forEach(k => console.log(yellow(`  Ignoring "${k}" — not in current selection`)));
+            result.clear();
+            parsed.values.forEach((v, k) => result.set(k, v));
+            const current = await fetchAllCurrent();
+            console.log("\nWill apply:");
+            for (const m of markets) {
+                const sym = symbols.get(m) || m;
+                console.log(`  ${sym}  new=${result.get(m)}  [current: ${current.get(m)}]`);
+            }
+            break;
+        }
+    }
+    return result;
+};
+const parsePerPoolValuesJson = (raw, markets, symbols, poolIdsByMarket) => {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+        return { kind: "notObject" };
+    const symbolToAddress = new Map();
+    symbols.forEach((sym, addr) => symbolToAddress.set(sym, addr));
+    const selectionSet = new Set(markets);
+    const values = new Map();
+    const setVal = (addr, pid, val) => {
+        let inner = values.get(addr);
+        if (!inner) {
+            inner = new Map();
+            values.set(addr, inner);
+        }
+        inner.set(pid, val);
+    };
+    const ignoredKeys = [];
+    const ignoredPools = [];
+    for (const [key, rawInner] of Object.entries(raw)) {
+        const addr = hardhat_1.ethers.utils.isAddress(key) ? key : symbolToAddress.get(key);
+        if (!addr || !selectionSet.has(addr)) {
+            ignoredKeys.push(key);
+            continue;
+        }
+        if (typeof rawInner !== "object" || rawInner === null || Array.isArray(rawInner)) {
+            return { kind: "innerNotObject", key };
+        }
+        const allowedPools = new Set(poolIdsByMarket.get(addr) ?? []);
+        for (const [pidKey, rawValue] of Object.entries(rawInner)) {
+            const pid = Number(pidKey);
+            if (!Number.isInteger(pid) || !allowedPools.has(pid)) {
+                ignoredPools.push({ key, poolIdKey: pidKey });
+                continue;
+            }
+            try {
+                const bn = hardhat_1.ethers.BigNumber.from(rawValue);
+                if (bn.lt(0))
+                    throw new Error("neg");
+                setVal(addr, pid, bn.toString());
+            }
+            catch {
+                return { kind: "invalidValue", key, poolId: pid, rawValue };
+            }
+        }
+    }
+    const missing = [];
+    for (const m of markets) {
+        for (const pid of poolIdsByMarket.get(m) ?? []) {
+            if (!values.get(m)?.has(pid))
+                missing.push(`${symbols.get(m) || m} pool=${pid}`);
+        }
+    }
+    if (missing.length > 0)
+        return { kind: "missing", missing, ignoredKeys, ignoredPools };
+    return { kind: "ok", values, ignoredKeys, ignoredPools };
+};
+exports.parsePerPoolValuesJson = parsePerPoolValuesJson;
+// Collect per (market, poolId) values for ops that act on a market-in-pool tuple
+// (decrease_cf_pool). Without this, a market listed in N pools would reuse the
+// same value across all pools, making the per-pool op indistinguishable from the
+// all-pools variant.
+const gatherPerPoolValues = async (markets, symbols, poolIdsByMarket, cfg) => {
+    const pairs = [];
+    for (const m of markets) {
+        for (const pid of poolIdsByMarket.get(m) ?? [])
+            pairs.push({ market: m, poolId: pid });
+    }
+    const mode = await pickOne(`Apply ${cfg.kind}:`, [
+        `Single value to ALL selected (market, pool) pairs (e.g. 0 to block)`,
+        `Per-pair values via CLI prompts`,
+        `Load values from a JSON file`,
+    ]);
+    const result = new Map();
+    const setVal = (market, poolId, value) => {
+        let inner = result.get(market);
+        if (!inner) {
+            inner = new Map();
+            result.set(market, inner);
+        }
+        inner.set(poolId, value);
+    };
+    const fetchAllCurrent = async () => {
+        const out = new Map();
+        await Promise.all(pairs.map(async ({ market, poolId }) => {
+            const v = await cfg.fetchCurrent(market, poolId);
+            let inner = out.get(market);
+            if (!inner) {
+                inner = new Map();
+                out.set(market, inner);
+            }
+            inner.set(poolId, v);
+        }));
+        return out;
+    };
+    if (mode.startsWith("Single")) {
+        const value = await askUint256(`Enter new ${cfg.kind} for all selected (market, pool) pairs:`);
+        for (const { market, poolId } of pairs)
+            setVal(market, poolId, value);
+    }
+    else if (mode.startsWith("Per-pair")) {
+        const current = await fetchAllCurrent();
+        for (const { market, poolId } of pairs) {
+            const sym = symbols.get(market) || market;
+            const cur = current.get(market)?.get(poolId) ?? "(unknown)";
+            const value = await askUint256(`  ${sym} pool=${poolId} [current: ${cur}]:`);
+            setVal(market, poolId, value);
+        }
+    }
+    else {
+        const defaultPath = path.resolve(OUTPUT_DIR, cfg.defaultFilename);
+        // Print expected file shape before asking for the path so operators can
+        // prepare the file rather than discovering the format by trial and error.
+        console.log(cyan(`\nExpected ${cfg.kind} file format (per-pool):`));
+        console.log(`  JSON object: symbol (or address) → { poolId → ${cfg.kind} value }.`);
+        console.log(`  Example (vAAVE listed in pools 0 and 6):`);
+        console.log(`    {`);
+        console.log(`      "vAAVE": {`);
+        console.log(`        "0": "0",`);
+        console.log(`        "6": "700000000000000000"`);
+        console.log(`      }`);
+        console.log(`    }`);
+        console.log(`  Only poolIds the market is actually listed in are accepted.`);
+        console.log(`  Values must be non-negative integers.`);
+        console.log(`  If the file doesn't exist, a template pre-filled with current on-chain`);
+        console.log(`  values will be offered — edit it, save, re-run.`);
+        // The last entered path is remembered so the post-template-gen retry lands
+        // on the same file the operator just edited.
+        let stickyDefault = defaultPath;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            console.log(`\nEnter path to ${cfg.kind} values file (press enter for default: ${stickyDefault})`);
+            const entered = await ask("> ");
+            const filePath = entered.length > 0 ? entered : stickyDefault;
+            stickyDefault = filePath;
+            // Local helper: writes a fresh template for the current (market,pool)
+            // pairs, backs up prior content to .bak on overwrite, then pauses for
+            // operator edit+resume.
+            const regenerateTemplateAndPause = async (reason) => {
+                if (reason === "missing" && fs.existsSync(filePath)) {
+                    const backup = `${filePath}.bak`;
+                    fs.copyFileSync(filePath, backup);
+                    console.log(yellow(`\nExisting file backed up to ${backup} before regeneration.`));
+                }
+                console.log(`\nGenerating template with current on-chain ${cfg.kind} values...`);
+                const current = await fetchAllCurrent();
+                const template = {};
+                for (const { market, poolId } of pairs) {
+                    const sym = symbols.get(market) || market;
+                    template[sym] ?? (template[sym] = {});
+                    template[sym][String(poolId)] = current.get(market)?.get(poolId) ?? "0";
+                }
+                fs.mkdirSync(path.dirname(filePath), { recursive: true });
+                fs.writeFileSync(filePath, JSON.stringify(template, null, 2) + "\n");
+                console.log(green(`Template written to ${filePath}`));
+                console.log(`Edit the values (they currently match on-chain ${cfg.kind}), save, then press Enter to continue.`);
+                console.log("Type 'q' + Enter to quit.");
+                const resume = (await ask("> ")).trim().toLowerCase();
+                if (resume === "q") {
+                    rl.close();
+                    process.exit(0);
+                }
+            };
+            if (!fs.existsSync(filePath)) {
+                const confirm = await askYesNo(`${filePath} not found. Generate template there?`);
+                if (!confirm)
+                    continue;
+                await regenerateTemplateAndPause("new");
+                // Fall through: loop restarts, file now exists, same path prompt accepts Enter for default.
+                continue;
+            }
+            let content;
+            try {
+                content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+            }
+            catch (error) {
+                console.error(red(`Failed to parse ${filePath}: ${error.message}`));
+                continue;
+            }
+            const parsed = (0, exports.parsePerPoolValuesJson)(content, markets, symbols, poolIdsByMarket);
+            const logIgnored = (p) => {
+                if ("ignoredKeys" in p) {
+                    p.ignoredKeys.forEach(k => console.log(yellow(`  Ignoring "${k}" — not in current selection`)));
+                    p.ignoredPools.forEach(({ key, poolIdKey }) => console.log(yellow(`  Ignoring "${key}" poolId "${poolIdKey}" — market not listed in that pool`)));
+                }
+            };
+            if (parsed.kind === "notObject") {
+                console.error(red(`${filePath} must contain a JSON object mapping symbol-or-address → {poolId: value}.`));
+                continue;
+            }
+            if (parsed.kind === "innerNotObject") {
+                console.error(red(`Entry for "${parsed.key}" must be an object {poolId: value}.`));
+                continue;
+            }
+            if (parsed.kind === "invalidValue") {
+                console.error(red(`Invalid ${cfg.kind} value for "${parsed.key}" pool ${parsed.poolId}: ${String(parsed.rawValue)}`));
+                continue;
+            }
+            if (parsed.kind === "missing") {
+                logIgnored(parsed);
+                console.log(yellow(`\nFile stale — missing entries for: ${parsed.missing.join(", ")}.`));
+                console.log(yellow(`Regenerating template for current selection. Existing file will be backed up.`));
+                await regenerateTemplateAndPause("missing");
+                continue;
+            }
+            logIgnored(parsed);
+            result.clear();
+            parsed.values.forEach((inner, addr) => {
+                inner.forEach((v, pid) => setVal(addr, pid, v));
+            });
+            const current = await fetchAllCurrent();
+            console.log("\nWill apply:");
+            for (const { market, poolId } of pairs) {
+                const sym = symbols.get(market) || market;
+                const cur = current.get(market)?.get(poolId) ?? "(unknown)";
+                const val = result.get(market)?.get(poolId) ?? "";
+                console.log(`  ${sym} pool=${poolId}  new=${val}  [current: ${cur}]`);
+            }
+            break;
+        }
+    }
+    return result;
+};
+// Collect the per-operation inputs (markets, actions, CFs, caps, etc.) for a single step.
+const gatherStep = async (operation, ctx) => {
+    const { comptrollerAddress, isIsolatedPool } = ctx;
+    let marketAddresses = [];
+    let symbols = new Map();
+    let pauseActions;
+    let newCFs;
+    let newCFsByPool;
+    let poolIdsByMarket;
+    let newCaps;
+    let revokeAccounts;
+    if (operation === "pause_flash_loan") {
+        const confirmed = await askYesNo("Pause all flash loans on the core pool?");
+        if (!confirmed) {
+            console.log("Aborted.");
+            rl.close();
+            process.exit(0);
+        }
+    }
+    else if (operation === "revoke_flash_loan") {
+        revokeAccounts = await pickValidAddresses("Enter account address(es) to revoke flash loan access from (comma-separated):");
+        console.log(`\nRevoking flash loan access from ${revokeAccounts.length} account(s).`);
+    }
+    else {
+        if (operation === "decrease_cf_pool" || operation === "disable_pool_borrow") {
+            console.log(cyan("\n--- Pool & Market Selection ---"));
+            const picked = await pickBscMarketsFanOut(ctx);
+            poolIdsByMarket = picked.poolIdsByMarket;
+            marketAddresses = picked.marketAddresses;
+            symbols = picked.symbols;
+        }
+        else {
+            console.log(cyan("\n--- Market Selection ---"));
+            const result = await selectMarkets(ctx);
+            marketAddresses = result.marketAddresses;
+            symbols = result.symbols;
+        }
+        if (operation === "pause_actions") {
+            const actionOptions = Object.entries(exports.ALLOWED_PAUSE_ACTIONS).map(([name, value]) => ({
+                name,
+                value: String(value),
+            }));
+            const selected = await pickMultiple("Select actions to pause (only MINT/REDEEM/BORROW/TRANSFER are allowed by EBrake):", actionOptions);
+            pauseActions = selected.map(Number);
+            if (pauseActions.length === 0) {
+                console.error(red("No actions selected. Exiting."));
+                rl.close();
+                process.exit(1);
+            }
+        }
+        else if (operation === "decrease_cf") {
+            newCFs = await gatherPerMarketValues(marketAddresses, symbols, {
+                kind: "CF",
+                defaultFilename: "cf_values.json",
+                fetchCurrent: async (m) => {
+                    try {
+                        const { cf } = await fetchCurrentCF(comptrollerAddress, m, isIsolatedPool);
+                        return cf.toString();
+                    }
+                    catch {
+                        return "(not listed)";
+                    }
+                },
+            });
+        }
+        else if (operation === "decrease_cf_pool") {
+            if (!poolIdsByMarket)
+                throw new Error("poolIdsByMarket missing for decrease_cf_pool");
+            newCFsByPool = await gatherPerPoolValues(marketAddresses, symbols, poolIdsByMarket, {
+                kind: "CF",
+                defaultFilename: "cf_values_per_pool.json",
+                fetchCurrent: async (m, pid) => {
+                    try {
+                        const { cf } = await fetchCurrentCF(comptrollerAddress, m, isIsolatedPool, pid);
+                        return cf.toString();
+                    }
+                    catch {
+                        return "(not listed)";
+                    }
+                },
+            });
+        }
+        else if (operation === "set_borrow_caps") {
+            newCaps = await gatherPerMarketValues(marketAddresses, symbols, {
+                kind: "borrow cap",
+                defaultFilename: "borrow_caps.json",
+                fetchCurrent: async (m) => {
+                    const { borrowCap } = await fetchCurrentCaps(comptrollerAddress, m, isIsolatedPool);
+                    return borrowCap.toString();
+                },
+            });
+        }
+        else if (operation === "set_supply_caps") {
+            newCaps = await gatherPerMarketValues(marketAddresses, symbols, {
+                kind: "supply cap",
+                defaultFilename: "supply_caps.json",
+                fetchCurrent: async (m) => {
+                    const { supplyCap } = await fetchCurrentCaps(comptrollerAddress, m, isIsolatedPool);
+                    return supplyCap.toString();
+                },
+            });
+        }
+    }
+    return {
+        operation,
+        marketAddresses,
+        symbols,
+        pauseActions,
+        newCFs,
+        newCFsByPool,
+        poolIdsByMarket,
+        newCaps,
+        revokeAccounts,
+    };
+};
+const gatherInput = async () => {
+    const networkName = hardhat_1.network.name;
+    const chainId = hardhat_1.network.config.chainId;
+    if (!chainId) {
+        console.error(red(`No chainId configured for network "${networkName}".`));
+        rl.close();
+        process.exit(1);
+    }
+    console.log(cyan(`=== Safe EBrake JSON Generator (${networkName}, chain ${chainId}) ===\n`));
+    // 1. Resolve EBrake address + probe
+    const eBrakeAddress = await (0, exports.getEBrakeAddress)(networkName);
+    const eBrake = new hardhat_1.ethers.Contract(eBrakeAddress, EBRAKE_ABI, hardhat_1.ethers.provider);
+    const [isIsolatedPool, comptrollerAddress] = await Promise.all([
+        retry(() => eBrake.IS_ISOLATED_POOL()),
+        retry(() => eBrake.COMPTROLLER()),
+    ]);
+    console.log(`  IS_ISOLATED_POOL: ${isIsolatedPool}`);
+    console.log(`  COMPTROLLER:      ${comptrollerAddress}\n`);
+    // 2. Operation menu — BSC-only options shown only when !isIsolatedPool
+    const operationChoices = [
+        { label: "Pause actions on markets (pauseActions)", value: "pause_actions" },
+        { label: "Decrease collateral factor — all pools (decreaseCF)", value: "decrease_cf" },
+        { label: "Decrease borrow caps (setMarketBorrowCaps)", value: "set_borrow_caps" },
+        { label: "Decrease supply caps (setMarketSupplyCaps)", value: "set_supply_caps" },
+    ];
+    if (!isIsolatedPool) {
+        operationChoices.push({ label: "[BSC] Decrease CF — specific pool (decreaseCF with poolId)", value: "decrease_cf_pool" }, { label: "[BSC] Pause flash loans (pauseFlashLoan)", value: "pause_flash_loan" }, { label: "[BSC] Revoke flash loan access (revokeFlashLoanAccess)", value: "revoke_flash_loan" }, { label: "[BSC] Disable pool borrow (disablePoolBorrow)", value: "disable_pool_borrow" });
+    }
+    // 3. Upfront multi-select: pick ALL operations to batch.
+    //    Order-preserving + duplicates allowed (same op twice with different markets is valid).
+    const choiceOptions = operationChoices.map((c, i) => ({ name: c.label, value: String(i + 1) }));
+    const selectedIndices = await pickMultiple("Select operations (comma-separated, e.g. 1,2,5):", choiceOptions, {
+        allowAll: false,
+        preserveOrder: true,
+    });
+    const selectedOps = selectedIndices.map(i => operationChoices[parseInt(i, 10) - 1].value);
+    // 4. Iterate selected operations, collecting per-step inputs.
+    const ctx = { comptrollerAddress, isIsolatedPool };
+    const steps = [];
+    for (let i = 0; i < selectedOps.length; i++) {
+        const op = selectedOps[i];
+        console.log(cyan(`\n─── Step ${i + 1}/${selectedOps.length}: ${op} ───`));
+        steps.push(await gatherStep(op, ctx));
+    }
+    // 6. Ask for the Safe (once) using the first step's role hint.
+    const safeAddress = await askSafeAddress();
+    const blockNumber = await hardhat_1.ethers.provider.getBlockNumber();
+    return {
+        eBrakeAddress,
+        comptrollerAddress,
+        isIsolatedPool,
+        network: networkName,
+        chainId,
+        steps,
+        safeAddress,
+        blockNumber,
+    };
+};
+exports.gatherInput = gatherInput;
+// ─── Phase 2: Generate Commands ──────────────────────────────────────────────
+const commandsForStep = (step) => {
+    const { operation, marketAddresses, symbols, pauseActions, newCFs, newCFsByPool, poolIdsByMarket, newCaps, revokeAccounts, } = step;
+    const commands = [];
+    switch (operation) {
+        case "pause_actions": {
+            if (!pauseActions || pauseActions.length === 0)
+                break;
+            const actionNames = pauseActions
+                .map(a => Object.entries(exports.ALLOWED_PAUSE_ACTIONS).find(([, v]) => v === a)?.[0] || String(a))
+                .join(", ");
+            console.log(`\nAdding pauseActions for ${marketAddresses.length} market(s): [${actionNames}]`);
+            commands.push({
+                signature: "pauseActions(address[],uint8[])",
+                params: [marketAddresses, pauseActions],
+            });
+            break;
+        }
+        case "decrease_cf": {
+            if (!newCFs || newCFs.size === 0)
+                break;
+            for (const [vToken, cf] of newCFs) {
+                const symbol = symbols.get(vToken) || vToken;
+                console.log(`  ${symbol} → decreaseCF(${vToken}, ${cf})`);
+                commands.push({
+                    signature: "decreaseCF(address,uint256)",
+                    params: [vToken, cf],
+                });
+            }
+            break;
+        }
+        case "decrease_cf_pool": {
+            if (!newCFsByPool || newCFsByPool.size === 0)
+                break;
+            for (const [vToken, byPool] of newCFsByPool) {
+                const symbol = symbols.get(vToken) || vToken;
+                for (const [pid, cf] of byPool) {
+                    console.log(`  ${symbol} → decreaseCF(${vToken}, poolId=${pid}, ${cf})`);
+                    commands.push({
+                        signature: "decreaseCF(address,uint96,uint256)",
+                        params: [vToken, pid, cf],
+                    });
+                }
+            }
+            break;
+        }
+        case "set_borrow_caps": {
+            if (!newCaps || newCaps.size === 0)
+                break;
+            const markets = [...newCaps.keys()];
+            const caps = markets.map(m => newCaps.get(m));
+            console.log(`\nAdding setMarketBorrowCaps for ${markets.length} market(s)`);
+            commands.push({
+                signature: "setMarketBorrowCaps(address[],uint256[])",
+                params: [markets, caps],
+            });
+            break;
+        }
+        case "set_supply_caps": {
+            if (!newCaps || newCaps.size === 0)
+                break;
+            const markets = [...newCaps.keys()];
+            const caps = markets.map(m => newCaps.get(m));
+            console.log(`\nAdding setMarketSupplyCaps for ${markets.length} market(s)`);
+            commands.push({
+                signature: "setMarketSupplyCaps(address[],uint256[])",
+                params: [markets, caps],
+            });
+            break;
+        }
+        case "pause_flash_loan": {
+            console.log("\nAdding pauseFlashLoan()");
+            commands.push({ signature: "pauseFlashLoan()", params: [] });
+            break;
+        }
+        case "revoke_flash_loan": {
+            if (!revokeAccounts || revokeAccounts.length === 0)
+                break;
+            for (const account of revokeAccounts) {
+                console.log(`  → revokeFlashLoanAccess(${account})`);
+                commands.push({
+                    signature: "revokeFlashLoanAccess(address)",
+                    params: [account],
+                });
+            }
+            break;
+        }
+        case "disable_pool_borrow": {
+            if (!poolIdsByMarket)
+                break;
+            for (const vToken of marketAddresses) {
+                const symbol = symbols.get(vToken) || vToken;
+                const poolIds = poolIdsByMarket.get(vToken) ?? [];
+                for (const pid of poolIds) {
+                    console.log(`  ${symbol} → disablePoolBorrow(poolId=${pid}, ${vToken})`);
+                    commands.push({
+                        signature: "disablePoolBorrow(uint96,address)",
+                        params: [pid, vToken],
+                    });
+                }
+            }
+            break;
+        }
+    }
+    return commands;
+};
+const generateCommands = (batch) => batch.steps.flatMap((step, i) => {
+    console.log(`\n[Step ${i + 1}/${batch.steps.length}] ${step.operation}`);
+    return commandsForStep(step);
+});
+exports.generateCommands = generateCommands;
+// ─── Phase 3: Export JSON ─────────────────────────────────────────────────────
+const exportJson = async (commands, batch, safeAddress) => {
+    if (commands.length === 0) {
+        console.log("No commands generated. Skipping.");
+        return null;
+    }
+    const txBuilderFile = path.resolve(OUTPUT_DIR, `safeEBrakeTxBuilder.json`);
+    const metadataFile = path.resolve(OUTPUT_DIR, `safeEBrakeTxMetadata.json`);
+    // Direct calldata encoding — no governance VIP wrapper
+    const iface = new hardhat_1.ethers.utils.Interface(EBRAKE_ABI);
+    const txData = commands.map(cmd => ({
+        to: batch.eBrakeAddress,
+        value: "0",
+        data: iface.encodeFunctionData(cmd.signature, cmd.params),
+    }));
+    const outputJson = (0, exports.buildSafeBatch)(safeAddress, txData, batch.chainId, batch.blockNumber);
+    // Merge symbols across all steps (a given address may appear in multiple steps;
+    // last write wins, but they should be identical since symbols come from chain).
+    const symbolsRecord = {};
+    for (const step of batch.steps) {
+        step.symbols.forEach((sym, addr) => {
+            symbolsRecord[addr] = sym;
+        });
+    }
+    const metadata = {
+        eBrakeAddress: batch.eBrakeAddress,
+        comptrollerAddress: batch.comptrollerAddress,
+        network: batch.network,
+        operations: batch.steps.map(s => s.operation),
+        blockNumber: batch.blockNumber,
+        createdAt: new Date().toISOString(),
+        symbols: symbolsRecord,
+    };
+    fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+    fs.writeFileSync(txBuilderFile, JSON.stringify(outputJson, null, 2));
+    fs.writeFileSync(metadataFile, JSON.stringify(metadata, null, 2));
+    return { txBuilderFile, metadataFile, txCount: commands.length, safeAddress };
+};
+exports.exportJson = exportJson;
+// ─── Phase 4: Orchestration ──────────────────────────────────────────────────
+const printBatchSummary = (batch, txCount) => {
+    console.log(cyan("\n─── Batch summary ───"));
+    batch.steps.forEach((step, i) => {
+        console.log(`  [${i + 1}/${batch.steps.length}] ${step.operation}`);
+    });
+    console.log(`  Total transactions: ${txCount}`);
+    console.log(`  Network: ${batch.network} (chain ${batch.chainId})`);
+    console.log(`  EBrake:  ${batch.eBrakeAddress}`);
+    console.log(`  Safe:    ${batch.safeAddress}`);
+};
+const orchestrate = async (batch) => {
+    console.log(cyan("\n--- Generating commands ---"));
+    const commands = (0, exports.generateCommands)(batch);
+    printBatchSummary(batch, commands.length);
+    return (0, exports.exportJson)(commands, batch, batch.safeAddress);
+};
+exports.orchestrate = orchestrate;
+// ─── Main ─────────────────────────────────────────────────────────────────────
+const printResult = (r, networkName) => {
+    console.log(cyan("\n=== Output ==="));
+    console.log(`  Safe TX Builder JSON: ${r.txBuilderFile}`);
+    console.log(`  Metadata:             ${r.metadataFile}`);
+    console.log(`  Transactions:         ${r.txCount}`);
+    console.log(`  Safe address:         ${r.safeAddress}`);
+    console.log(`  Simulate:             ${bold(`npx hardhat test scripts/simulateSafeEBrakeTx.ts --fork ${networkName}`)}`);
+};
+const main = async () => {
+    const input = await (0, exports.gatherInput)();
+    console.log(cyan("\n--- Processing ---"));
+    const result = await (0, exports.orchestrate)(input);
+    if (result) {
+        printResult(result, input.network);
+    }
+    rl.close();
+};
+exports.main = main;
+if (require.main === module) {
+    (0, exports.main)().catch(err => {
+        console.error(err);
+        process.exit(1);
+    });
+}