protoscan 0.1.0

package/dist/index.js

@@ -0,0 +1,2648 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+
+// src/config.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+var CONFIG_FILE = "protoscan.config.json";
+var DEFAULT_CONFIG = {
+  chains: {
+    ethereum: {
+      rpc: "https://eth.llamarpc.com",
+      name: "Ethereum Mainnet"
+    }
+  },
+  contracts: {}
+};
+function loadConfig() {
+  if (!existsSync(CONFIG_FILE)) {
+    throw new Error(
+      `No ${CONFIG_FILE} found. Run "protoscan init" to create one.`
+    );
+  }
+  const raw = readFileSync(CONFIG_FILE, "utf-8");
+  return JSON.parse(raw);
+}
+function initConfig() {
+  if (existsSync(CONFIG_FILE)) {
+    throw new Error(`${CONFIG_FILE} already exists.`);
+  }
+  writeFileSync(CONFIG_FILE, JSON.stringify(DEFAULT_CONFIG, null, 2), "utf-8");
+  return CONFIG_FILE;
+}
+
+// src/scanner.ts
+import { createPublicClient, http } from "viem";
+
+// src/chains.ts
+import {
+  mainnet,
+  arbitrum,
+  optimism,
+  polygon,
+  base,
+  avalanche,
+  bsc,
+  gnosis,
+  scroll,
+  linea,
+  blast,
+  zkSync
+} from "viem/chains";
+var chainMap = {
+  ethereum: mainnet,
+  arbitrum,
+  optimism,
+  polygon,
+  base,
+  avalanche,
+  bsc,
+  gnosis,
+  scroll,
+  linea,
+  blast,
+  zksync: zkSync
+};
+function resolveChain(name) {
+  return chainMap[name.toLowerCase()];
+}
+
+// src/protocols/proxy.ts
+import { getAddress, pad, trim } from "viem";
+var IMPLEMENTATION_SLOT = "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
+var ADMIN_SLOT = "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103";
+var BEACON_SLOT = "0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50";
+var OZ_IMPL_SLOT = "0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3";
+async function readSlotAsAddress(client, address, slot) {
+  try {
+    const value = await client.getStorageAt({ address, slot });
+    if (!value || value === "0x0000000000000000000000000000000000000000000000000000000000000000") {
+      return null;
+    }
+    const trimmed = trim(value);
+    if (trimmed === "0x" || trimmed === "0x0") return null;
+    return getAddress(pad(trimmed, { size: 20 }));
+  } catch {
+    return null;
+  }
+}
+async function detectProxy(client, address) {
+  const [implementation, admin, beacon] = await Promise.all([
+    readSlotAsAddress(client, address, IMPLEMENTATION_SLOT),
+    readSlotAsAddress(client, address, ADMIN_SLOT),
+    readSlotAsAddress(client, address, BEACON_SLOT)
+  ]);
+  if (!implementation && !admin && !beacon) {
+    const ozImpl = await readSlotAsAddress(client, address, OZ_IMPL_SLOT);
+    if (ozImpl) {
+      return { implementation: ozImpl, admin: null, beacon: null };
+    }
+    return null;
+  }
+  return { implementation, admin, beacon };
+}
+
+// src/protocols/common.ts
+import { parseAbi } from "viem";
+var ownershipAbi = parseAbi([
+  "function owner() view returns (address)",
+  "function admin() view returns (address)",
+  "function guardian() view returns (address)",
+  "function pendingOwner() view returns (address)",
+  "function paused() view returns (bool)",
+  "function timelock() view returns (address)",
+  "function governance() view returns (address)"
+]);
+var tokenAbi = parseAbi([
+  "function name() view returns (string)",
+  "function symbol() view returns (string)",
+  "function decimals() view returns (uint8)",
+  "function totalSupply() view returns (uint256)"
+]);
+async function tryRead(client, address, abi, functionName) {
+  try {
+    const result = await client.readContract({
+      address,
+      abi,
+      functionName
+    });
+    return { key: functionName, value: String(result) };
+  } catch {
+    return null;
+  }
+}
+async function readCommonState(client, address) {
+  const reads = await Promise.all([
+    tryRead(client, address, ownershipAbi, "owner"),
+    tryRead(client, address, ownershipAbi, "admin"),
+    tryRead(client, address, ownershipAbi, "guardian"),
+    tryRead(client, address, ownershipAbi, "pendingOwner"),
+    tryRead(client, address, ownershipAbi, "paused"),
+    tryRead(client, address, ownershipAbi, "timelock"),
+    tryRead(client, address, ownershipAbi, "governance"),
+    tryRead(client, address, tokenAbi, "name"),
+    tryRead(client, address, tokenAbi, "symbol"),
+    tryRead(client, address, tokenAbi, "decimals"),
+    tryRead(client, address, tokenAbi, "totalSupply")
+  ]);
+  const result = {};
+  for (const read of reads) {
+    if (read) result[read.key] = read.value;
+  }
+  return result;
+}
+
+// src/registry/aave-v3.ts
+import { parseAbi as parseAbi2 } from "viem";
+var poolAbi = parseAbi2([
+  "function getReservesList() view returns (address[])",
+  "function getReserveData(address asset) view returns ((uint256 configuration, uint128 liquidityIndex, uint128 currentLiquidityRate, uint128 variableBorrowIndex, uint128 currentVariableBorrowRate, uint40 lastUpdateTimestamp, uint16 id, address aTokenAddress, address variableDebtTokenAddress, address interestRateStrategyAddress, uint128 accruedToTreasury, uint128 unbacked, uint128 isolationModeTotalDebt))",
+  "function FLASHLOAN_PREMIUM_TOTAL() view returns (uint128)",
+  "function FLASHLOAN_PREMIUM_TO_PROTOCOL() view returns (uint128)",
+  "function MAX_NUMBER_RESERVES() view returns (uint16)",
+  "function BRIDGE_PROTOCOL_FEE() view returns (uint256)"
+]);
+var poolConfiguratorAbi = parseAbi2([
+  "function getConfiguratorLogic() view returns (address)"
+]);
+var aclManagerAbi = parseAbi2([
+  "function isPoolAdmin(address admin) view returns (bool)",
+  "function isEmergencyAdmin(address admin) view returns (bool)",
+  "function isRiskAdmin(address admin) view returns (bool)",
+  "function isFlashBorrower(address borrower) view returns (bool)",
+  "function isAssetListingAdmin(address admin) view returns (bool)",
+  "function isBridge(address bridge) view returns (bool)",
+  "function DEFAULT_ADMIN_ROLE() view returns (bytes32)",
+  "function POOL_ADMIN_ROLE() view returns (bytes32)",
+  "function EMERGENCY_ADMIN_ROLE() view returns (bytes32)",
+  "function RISK_ADMIN_ROLE() view returns (bytes32)",
+  "function FLASH_BORROWER_ROLE() view returns (bytes32)",
+  "function ASSET_LISTING_ADMIN_ROLE() view returns (bytes32)",
+  "function getRoleAdmin(bytes32 role) view returns (bytes32)"
+]);
+var addressProviderAbi = parseAbi2([
+  "function getPool() view returns (address)",
+  "function getPoolConfigurator() view returns (address)",
+  "function getPriceOracle() view returns (address)",
+  "function getACLManager() view returns (address)",
+  "function getACLAdmin() view returns (address)",
+  "function getPoolDataProvider() view returns (address)",
+  "function owner() view returns (address)"
+]);
+var oracleAbi = parseAbi2([
+  "function getSourceOfAsset(address asset) view returns (address)",
+  "function getFallbackOracle() view returns (address)",
+  "function BASE_CURRENCY() view returns (address)",
+  "function BASE_CURRENCY_UNIT() view returns (uint256)"
+]);
+var ownerAbi = parseAbi2([
+  "function owner() view returns (address)"
+]);
+var aaveV3 = {
+  id: "aave-v3",
+  name: "Aave V3",
+  version: "3.0",
+  website: "https://aave.com",
+  description: "Decentralized non-custodial liquidity protocol",
+  contracts: {
+    PoolAddressesProvider: { name: "PoolAddressesProvider", role: "Registry for protocol addresses", type: "raw" },
+    Pool: { name: "Pool", role: "Main lending/borrowing pool", type: "proxy" },
+    PoolConfigurator: { name: "PoolConfigurator", role: "Protocol parameter configuration", type: "proxy" },
+    ACLManager: { name: "ACLManager", role: "Access control management", type: "raw" },
+    AaveOracle: { name: "AaveOracle", role: "Price oracle aggregator", type: "raw" },
+    PoolDataProvider: { name: "PoolDataProvider", role: "Data provider for protocol state", type: "raw" }
+  },
+  deployments: {
+    ethereum: {
+      PoolAddressesProvider: "0x2f39d218133AFaB8F2B819B1066c7E434Ad94E9e",
+      Pool: "0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2",
+      PoolConfigurator: "0x64b761D848206f447Fe2dd461b0c635Ec39EbB27",
+      ACLManager: "0xc2aaCf6553D20d1e9571216fA22D988C6Cb18E6",
+      AaveOracle: "0x54586bE62E3c3580375aE3723C145253060Ca0C2",
+      PoolDataProvider: "0x7B4EB56E7CD4b454BA8ff71E4518426c8A0EB0e3"
+    },
+    arbitrum: {
+      PoolAddressesProvider: "0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb",
+      Pool: "0x794a61358D6845594F94dc1DB02A252b5b4814aD",
+      PoolConfigurator: "0x8145eddDf43f50276641b55bd3AD95944510021",
+      ACLManager: "0xa72636CbcAa8F5FF95B2cc47Ed3D1dED7EF16cc",
+      AaveOracle: "0xb56c2F0B653B2e0b10C9b928C8580Ac5Df02C7C7",
+      PoolDataProvider: "0x69FA688f1Dc47d4B5d8029D5a35FB7a548310654"
+    },
+    base: {
+      PoolAddressesProvider: "0xe20fCBdBfFC4Dd138cE8b2E6FBb6CB49777ad64D",
+      Pool: "0xA238Dd80C259a72e81d7e4664a9801593F98d1c5",
+      PoolConfigurator: "0x5731a04B1E775f0fdd454Bf70f3335886e9A96be",
+      ACLManager: "0x43955b0899Ab7232E3a454cf84AedD22Ad46FD33",
+      AaveOracle: "0x2Cc0Fc26eD4563A5ce5e8bdcfe1A2878676Ae156",
+      PoolDataProvider: "0x2d8A3C5677189723C4cB8873CfC9C8976FDF38Ac"
+    },
+    optimism: {
+      PoolAddressesProvider: "0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb",
+      Pool: "0x794a61358D6845594F94dc1DB02A252b5b4814aD",
+      PoolConfigurator: "0x8145eddDf43f50276641b55bd3AD95944510021",
+      ACLManager: "0xa72636CbcAa8F5FF95B2cc47Ed3D1dED7EF16cc",
+      AaveOracle: "0xD81eb3728a631871a7eBBaD631b5f424909f0c77",
+      PoolDataProvider: "0x69FA688f1Dc47d4B5d8029D5a35FB7a548310654"
+    },
+    polygon: {
+      PoolAddressesProvider: "0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb",
+      Pool: "0x794a61358D6845594F94dc1DB02A252b5b4814aD",
+      PoolConfigurator: "0x8145eddDf43f50276641b55bd3AD95944510021",
+      ACLManager: "0xa72636CbcAa8F5FF95B2cc47Ed3D1dED7EF16cc",
+      AaveOracle: "0xb023e699F5a33916Ea823A16485e259257cA8Bd1",
+      PoolDataProvider: "0x69FA688f1Dc47d4B5d8029D5a35FB7a548310654"
+    }
+  },
+  params: [
+    {
+      name: "flashloanPremiumTotal",
+      description: "Total flashloan fee in bps",
+      contract: "Pool",
+      functionName: "FLASHLOAN_PREMIUM_TOTAL",
+      abi: poolAbi,
+      decode: "bps",
+      category: "config",
+      severity: "warning"
+    },
+    {
+      name: "flashloanPremiumToProtocol",
+      description: "Flashloan fee portion going to protocol treasury",
+      contract: "Pool",
+      functionName: "FLASHLOAN_PREMIUM_TO_PROTOCOL",
+      abi: poolAbi,
+      decode: "bps",
+      category: "config",
+      severity: "warning"
+    },
+    {
+      name: "bridgeProtocolFee",
+      description: "Bridge protocol fee",
+      contract: "Pool",
+      functionName: "BRIDGE_PROTOCOL_FEE",
+      abi: poolAbi,
+      decode: "uint",
+      category: "config",
+      severity: "warning"
+    },
+    {
+      name: "maxReserves",
+      description: "Maximum number of supported reserves",
+      contract: "Pool",
+      functionName: "MAX_NUMBER_RESERVES",
+      abi: poolAbi,
+      decode: "uint",
+      category: "config",
+      severity: "info"
+    },
+    {
+      name: "priceOracle",
+      description: "Active price oracle address",
+      contract: "PoolAddressesProvider",
+      functionName: "getPriceOracle",
+      abi: addressProviderAbi,
+      decode: "address",
+      category: "config",
+      severity: "critical"
+    },
+    {
+      name: "aclAdmin",
+      description: "ACL admin \u2014 can grant/revoke all roles",
+      contract: "PoolAddressesProvider",
+      functionName: "getACLAdmin",
+      abi: addressProviderAbi,
+      decode: "address",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "addressProviderOwner",
+      description: "Owner of PoolAddressesProvider \u2014 can replace all core contracts",
+      contract: "PoolAddressesProvider",
+      functionName: "owner",
+      abi: addressProviderAbi,
+      decode: "address",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "fallbackOracle",
+      description: "Fallback oracle used when primary source fails",
+      contract: "AaveOracle",
+      functionName: "getFallbackOracle",
+      abi: oracleAbi,
+      decode: "address",
+      category: "config",
+      severity: "warning"
+    },
+    {
+      name: "baseCurrency",
+      description: "Base currency for price quotes",
+      contract: "AaveOracle",
+      functionName: "BASE_CURRENCY",
+      abi: oracleAbi,
+      decode: "address",
+      category: "config",
+      severity: "warning"
+    },
+    {
+      name: "baseCurrencyUnit",
+      description: "Base currency unit (decimals)",
+      contract: "AaveOracle",
+      functionName: "BASE_CURRENCY_UNIT",
+      abi: oracleAbi,
+      decode: "uint",
+      category: "config",
+      severity: "info"
+    }
+  ],
+  access: [
+    {
+      role: "AddressesProvider Owner",
+      description: "Can replace Pool, Configurator, Oracle, ACLManager \u2014 god key",
+      contract: "PoolAddressesProvider",
+      functionName: "owner",
+      abi: ownerAbi,
+      severity: "critical"
+    },
+    {
+      role: "ACL Admin",
+      description: "Can grant/revoke PoolAdmin, EmergencyAdmin, RiskAdmin roles",
+      contract: "PoolAddressesProvider",
+      functionName: "getACLAdmin",
+      abi: addressProviderAbi,
+      severity: "critical"
+    },
+    {
+      role: "Oracle Owner",
+      description: "Can change price feed sources \u2014 oracle manipulation vector",
+      contract: "AaveOracle",
+      functionName: "owner",
+      abi: ownerAbi,
+      severity: "critical"
+    }
+  ]
+};
+
+// src/registry/compound-v3.ts
+import { parseAbi as parseAbi3 } from "viem";
+var cometAbi = parseAbi3([
+  "function governor() view returns (address)",
+  "function pauseGuardian() view returns (address)",
+  "function baseToken() view returns (address)",
+  "function baseTokenPriceFeed() view returns (address)",
+  "function extensionDelegate() view returns (address)",
+  "function supplyKink() view returns (uint256)",
+  "function supplyPerSecondInterestRateSlopeLow() view returns (uint256)",
+  "function supplyPerSecondInterestRateSlopeHigh() view returns (uint256)",
+  "function supplyPerSecondInterestRateBase() view returns (uint256)",
+  "function borrowKink() view returns (uint256)",
+  "function borrowPerSecondInterestRateSlopeLow() view returns (uint256)",
+  "function borrowPerSecondInterestRateSlopeHigh() view returns (uint256)",
+  "function borrowPerSecondInterestRateBase() view returns (uint256)",
+  "function storeFrontPriceFactor() view returns (uint256)",
+  "function baseTrackingSupplySpeed() view returns (uint256)",
+  "function baseTrackingBorrowSpeed() view returns (uint256)",
+  "function baseMinForRewards() view returns (uint256)",
+  "function baseBorrowMin() view returns (uint256)",
+  "function targetReserves() view returns (uint256)",
+  "function totalSupply() view returns (uint256)",
+  "function totalBorrow() view returns (uint256)",
+  "function isSupplyPaused() view returns (bool)",
+  "function isTransferPaused() view returns (bool)",
+  "function isWithdrawPaused() view returns (bool)",
+  "function isAbsorbPaused() view returns (bool)",
+  "function isBuyPaused() view returns (bool)",
+  "function numAssets() view returns (uint8)",
+  "function getAssetInfo(uint8 i) view returns ((uint8 offset, address asset, address priceFeed, uint64 scale, uint64 borrowCollateralFactor, uint64 liquidateCollateralFactor, uint64 liquidationFactor, uint128 supplyCap))"
+]);
+var configuratorAbi = parseAbi3([
+  "function governor() view returns (address)",
+  "function factory() view returns (address)"
+]);
+var ownerAbi2 = parseAbi3([
+  "function owner() view returns (address)"
+]);
+var compoundV3 = {
+  id: "compound-v3",
+  name: "Compound V3 (Comet)",
+  version: "3.0",
+  website: "https://compound.finance",
+  description: "Algorithmic money market protocol",
+  contracts: {
+    CometUSDC: { name: "Comet USDC", role: "Main USDC lending market", type: "proxy" },
+    CometWETH: { name: "Comet WETH", role: "Main WETH lending market", type: "proxy" },
+    Configurator: { name: "Configurator", role: "Protocol configuration manager", type: "proxy" },
+    Timelock: { name: "Timelock", role: "Governance timelock", type: "raw" }
+  },
+  deployments: {
+    ethereum: {
+      CometUSDC: "0xc3d688B66703497DAA19211EEdff47f25384cdc3",
+      CometWETH: "0xA17581A9E3356d9A858b789D68B4d866e593aE94",
+      Configurator: "0x316f9708bB98af7dA9c68C1C3b5e79039cD336E3",
+      Timelock: "0x6d903f6003cca6255D85CcA4D3B5E5146dC33925"
+    },
+    arbitrum: {
+      CometUSDC: "0xA5EDBDD9646f8dFF606d7448e414884C7d905dCA",
+      CometWETH: "0x9c4ec768c28520B50860ea7a15bd7213a9fF58bf",
+      Configurator: "0xb21b06D71c75973babdE35b49fFDAc3F82Ad3775",
+      Timelock: "0x3fB4d38ea7EC20D91c150F5e41C5a4652c6AE4AA"
+    },
+    base: {
+      CometUSDC: "0xb125E6687d4313864e53df431d5425969c15Eb2F",
+      CometWETH: "0x46e6b214b524310239732D51387075E0e70970bf",
+      Configurator: "0x45939657d1CA34A8FA39A924B71D28Fe8431e581",
+      Timelock: "0xCC3E7c85Bb0EE4f09380e041fee95a0caeDD4a02"
+    }
+  },
+  params: [
+    {
+      name: "governor",
+      description: "Protocol governor \u2014 can change all parameters",
+      contract: "CometUSDC",
+      functionName: "governor",
+      abi: cometAbi,
+      decode: "address",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "pauseGuardian",
+      description: "Can pause supply/withdraw/transfer/absorb/buy",
+      contract: "CometUSDC",
+      functionName: "pauseGuardian",
+      abi: cometAbi,
+      decode: "address",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "baseToken",
+      description: "Base token for this Comet market",
+      contract: "CometUSDC",
+      functionName: "baseToken",
+      abi: cometAbi,
+      decode: "address",
+      category: "config",
+      severity: "critical"
+    },
+    {
+      name: "baseTokenPriceFeed",
+      description: "Price feed for base token",
+      contract: "CometUSDC",
+      functionName: "baseTokenPriceFeed",
+      abi: cometAbi,
+      decode: "address",
+      category: "config",
+      severity: "critical"
+    },
+    {
+      name: "supplyKink",
+      description: "Utilization rate kink point for supply rate",
+      contract: "CometUSDC",
+      functionName: "supplyKink",
+      abi: cometAbi,
+      decode: "wad",
+      category: "rate",
+      severity: "warning"
+    },
+    {
+      name: "borrowKink",
+      description: "Utilization rate kink point for borrow rate",
+      contract: "CometUSDC",
+      functionName: "borrowKink",
+      abi: cometAbi,
+      decode: "wad",
+      category: "rate",
+      severity: "warning"
+    },
+    {
+      name: "targetReserves",
+      description: "Target reserve amount",
+      contract: "CometUSDC",
+      functionName: "targetReserves",
+      abi: cometAbi,
+      decode: "uint",
+      category: "config",
+      severity: "warning"
+    },
+    {
+      name: "isSupplyPaused",
+      description: "Whether supply operations are paused",
+      contract: "CometUSDC",
+      functionName: "isSupplyPaused",
+      abi: cometAbi,
+      decode: "bool",
+      category: "state",
+      severity: "critical"
+    },
+    {
+      name: "isWithdrawPaused",
+      description: "Whether withdraw operations are paused",
+      contract: "CometUSDC",
+      functionName: "isWithdrawPaused",
+      abi: cometAbi,
+      decode: "bool",
+      category: "state",
+      severity: "critical"
+    },
+    {
+      name: "isTransferPaused",
+      description: "Whether transfer operations are paused",
+      contract: "CometUSDC",
+      functionName: "isTransferPaused",
+      abi: cometAbi,
+      decode: "bool",
+      category: "state",
+      severity: "warning"
+    },
+    {
+      name: "totalSupply",
+      description: "Total supplied amount",
+      contract: "CometUSDC",
+      functionName: "totalSupply",
+      abi: cometAbi,
+      decode: "uint",
+      category: "state",
+      severity: "info"
+    },
+    {
+      name: "totalBorrow",
+      description: "Total borrowed amount",
+      contract: "CometUSDC",
+      functionName: "totalBorrow",
+      abi: cometAbi,
+      decode: "uint",
+      category: "state",
+      severity: "info"
+    },
+    {
+      name: "numAssets",
+      description: "Number of collateral assets",
+      contract: "CometUSDC",
+      functionName: "numAssets",
+      abi: cometAbi,
+      decode: "uint",
+      category: "config",
+      severity: "info"
+    }
+  ],
+  access: [
+    {
+      role: "Governor",
+      description: "Full control \u2014 can change all parameters, pause, upgrade",
+      contract: "CometUSDC",
+      functionName: "governor",
+      abi: cometAbi,
+      severity: "critical"
+    },
+    {
+      role: "Pause Guardian",
+      description: "Can pause supply/withdraw/transfer/absorb/buy operations",
+      contract: "CometUSDC",
+      functionName: "pauseGuardian",
+      abi: cometAbi,
+      severity: "critical"
+    },
+    {
+      role: "Configurator Governor",
+      description: "Can update Comet market configurations",
+      contract: "Configurator",
+      functionName: "governor",
+      abi: configuratorAbi,
+      severity: "critical"
+    }
+  ]
+};
+
+// src/registry/uniswap-v3.ts
+import { parseAbi as parseAbi4 } from "viem";
+var factoryAbi = parseAbi4([
+  "function owner() view returns (address)",
+  "function feeAmountTickSpacing(uint24 fee) view returns (int24)",
+  "function getPool(address tokenA, address tokenB, uint24 fee) view returns (address pool)"
+]);
+var swapRouterAbi = parseAbi4([
+  "function factory() view returns (address)",
+  "function factoryV2() view returns (address)",
+  "function positionManager() view returns (address)",
+  "function WETH9() view returns (address)"
+]);
+var positionManagerAbi = parseAbi4([
+  "function factory() view returns (address)",
+  "function WETH9() view returns (address)"
+]);
+var ownerAbi3 = parseAbi4([
+  "function owner() view returns (address)"
+]);
+var uniswapV3 = {
+  id: "uniswap-v3",
+  name: "Uniswap V3",
+  version: "3.0",
+  website: "https://uniswap.org",
+  description: "Concentrated liquidity automated market maker protocol",
+  contracts: {
+    Factory: { name: "UniswapV3Factory", role: "Deploys pools, controls fee tiers and protocol fee switch \u2014 sole admin surface in the protocol", type: "raw" },
+    SwapRouter: { name: "SwapRouter02", role: "Multicall swap router for exact-in/out swaps across V2 & V3 pools, immutable with no admin", type: "raw" },
+    NonfungiblePositionManager: { name: "NonfungiblePositionManager", role: "ERC-721 wrapper for concentrated liquidity positions, immutable with no admin", type: "raw" },
+    QuoterV2: { name: "QuoterV2", role: "Off-chain quote simulation via revert-based swap simulation, stateless", type: "raw" }
+  },
+  deployments: {
+    ethereum: {
+      Factory: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+      SwapRouter: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
+      NonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
+      QuoterV2: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e"
+    },
+    arbitrum: {
+      Factory: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+      SwapRouter: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
+      NonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
+      QuoterV2: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e"
+    },
+    optimism: {
+      Factory: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+      SwapRouter: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
+      NonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
+      QuoterV2: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e"
+    },
+    polygon: {
+      Factory: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
+      SwapRouter: "0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45",
+      NonfungiblePositionManager: "0xC36442b4a4522E871399CD717aBDD847Ab11FE88",
+      QuoterV2: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e"
+    },
+    base: {
+      Factory: "0x33128a8fC17869897dcE68Ed026d694621f6FDfD",
+      SwapRouter: "0x2626664c2603336E57B271c5C0b26F421741e481",
+      NonfungiblePositionManager: "0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1",
+      QuoterV2: "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a"
+    }
+  },
+  params: [
+    {
+      name: "factoryOwner",
+      description: "Factory owner \u2014 can enable fee tiers, transfer ownership, and set/collect protocol fee on any pool",
+      contract: "Factory",
+      functionName: "owner",
+      abi: factoryAbi,
+      decode: "address",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "feeTier100TickSpacing",
+      description: "Tick spacing for the 0.01% fee tier (1 = enabled, stable-stable pairs)",
+      contract: "Factory",
+      functionName: "feeAmountTickSpacing",
+      args: [100],
+      abi: factoryAbi,
+      decode: "uint",
+      category: "config",
+      severity: "info"
+    },
+    {
+      name: "feeTier500TickSpacing",
+      description: "Tick spacing for the 0.05% fee tier (10 = enabled, correlated pairs)",
+      contract: "Factory",
+      functionName: "feeAmountTickSpacing",
+      args: [500],
+      abi: factoryAbi,
+      decode: "uint",
+      category: "config",
+      severity: "info"
+    },
+    {
+      name: "feeTier3000TickSpacing",
+      description: "Tick spacing for the 0.3% fee tier (60 = enabled, default general pairs)",
+      contract: "Factory",
+      functionName: "feeAmountTickSpacing",
+      args: [3e3],
+      abi: factoryAbi,
+      decode: "uint",
+      category: "config",
+      severity: "info"
+    },
+    {
+      name: "feeTier10000TickSpacing",
+      description: "Tick spacing for the 1% fee tier (200 = enabled, exotic pairs)",
+      contract: "Factory",
+      functionName: "feeAmountTickSpacing",
+      args: [1e4],
+      abi: factoryAbi,
+      decode: "uint",
+      category: "config",
+      severity: "info"
+    },
+    {
+      name: "routerFactory",
+      description: "Factory address the SwapRouter02 is wired to \u2014 must match canonical Factory or swaps route to a rogue deployment",
+      contract: "SwapRouter",
+      functionName: "factory",
+      abi: swapRouterAbi,
+      decode: "address",
+      category: "config",
+      severity: "warning"
+    },
+    {
+      name: "routerPositionManager",
+      description: "NonfungiblePositionManager address referenced by SwapRouter02 (used for approve-and-call flows)",
+      contract: "SwapRouter",
+      functionName: "positionManager",
+      abi: swapRouterAbi,
+      decode: "address",
+      category: "config",
+      severity: "info"
+    },
+    {
+      name: "routerWETH9",
+      description: "Wrapped native token used by SwapRouter02 for ETH-in/out swaps",
+      contract: "SwapRouter",
+      functionName: "WETH9",
+      abi: swapRouterAbi,
+      decode: "address",
+      category: "config",
+      severity: "info"
+    },
+    {
+      name: "positionManagerFactory",
+      description: "Factory address the NonfungiblePositionManager is wired to \u2014 must match canonical Factory",
+      contract: "NonfungiblePositionManager",
+      functionName: "factory",
+      abi: positionManagerAbi,
+      decode: "address",
+      category: "config",
+      severity: "warning"
+    },
+    {
+      name: "positionManagerWETH9",
+      description: "Wrapped native token used by the NonfungiblePositionManager for mint/increase/decrease liquidity in native ETH",
+      contract: "NonfungiblePositionManager",
+      functionName: "WETH9",
+      abi: positionManagerAbi,
+      decode: "address",
+      category: "config",
+      severity: "info"
+    }
+  ],
+  access: [
+    {
+      role: "Factory Owner \u2014 Fee Tier Governance",
+      description: "Can permanently enable new fee tiers via enableFeeAmount (irreversible once set) and transfer factory ownership via setOwner",
+      contract: "Factory",
+      functionName: "owner",
+      abi: ownerAbi3,
+      severity: "critical"
+    },
+    {
+      role: "Factory Owner \u2014 Protocol Fee Switch",
+      description: "Can call the onlyFactoryOwner-gated setFeeProtocol and collectProtocol on ANY pool deployed by this factory \u2014 full economic control over the protocol-wide fee switch (up to 1/4 of LP swap fees) across every pool",
+      contract: "Factory",
+      functionName: "owner",
+      abi: ownerAbi3,
+      severity: "critical"
+    }
+  ]
+};
+
+// src/registry/maker.ts
+import { parseAbi as parseAbi5 } from "viem";
+var vatAbi = parseAbi5([
+  "function Line() view returns (uint256)",
+  "function live() view returns (uint256)",
+  "function debt() view returns (uint256)"
+]);
+var jugAbi = parseAbi5([
+  "function base() view returns (uint256)"
+]);
+var potAbi = parseAbi5([
+  "function dsr() view returns (uint256)",
+  "function chi() view returns (uint256)",
+  "function Pie() view returns (uint256)"
+]);
+var dogAbi = parseAbi5([
+  "function live() view returns (uint256)",
+  "function Hole() view returns (uint256)",
+  "function Dirt() view returns (uint256)"
+]);
+var pauseAbi = parseAbi5([
+  "function owner() view returns (address)",
+  "function authority() view returns (address)",
+  "function delay() view returns (uint256)"
+]);
+var ownerAbi4 = parseAbi5([
+  "function owner() view returns (address)"
+]);
+var maker = {
+  id: "maker",
+  name: "Maker (Sky)",
+  version: "MCD",
+  website: "https://makerdao.com",
+  description: "Multi-collateral DAI stablecoin system",
+  contracts: {
+    MCD_VAT: { name: "Vat", role: "Core vault engine \u2014 tracks all debt and collateral", type: "raw" },
+    MCD_JUG: { name: "Jug", role: "Stability fee accumulator", type: "raw" },
+    MCD_POT: { name: "Pot", role: "DAI Savings Rate module", type: "raw" },
+    MCD_DOG: { name: "Dog", role: "Liquidation engine", type: "raw" },
+    MCD_SPOT: { name: "Spotter", role: "Oracle and liquidation ratio manager", type: "raw" },
+    MCD_PAUSE: { name: "DSPause", role: "Governance timelock", type: "raw" },
+    MCD_ADM: { name: "DSChief", role: "Governance voting contract", type: "raw" }
+  },
+  deployments: {
+    ethereum: {
+      MCD_VAT: "0x35D1b3F3D7966A1DFe207aa4514C12a259A0492B",
+      MCD_JUG: "0x19c0976f590D67707E62397C87829d896Dc0f1F1",
+      MCD_POT: "0x197E90f9FAD81970bA7976f33CbD77088E5D7cf7",
+      MCD_DOG: "0x135954d155898D42C90D2a57824C690e0c7BEf1B",
+      MCD_SPOT: "0x65C79fcB50Ca1594B025960e539eD7A9a6D434A3",
+      MCD_PAUSE: "0xbE286431454714F511008713973d3B053A2d38f3",
+      MCD_ADM: "0x0a3f6849f78076aefaDf113F5BED87720274dDC0"
+    }
+  },
+  params: [
+    {
+      name: "globalDebtCeiling",
+      description: "Global debt ceiling (Line) \u2014 max DAI that can be minted",
+      contract: "MCD_VAT",
+      functionName: "Line",
+      abi: vatAbi,
+      decode: "ray",
+      category: "risk",
+      severity: "critical"
+    },
+    {
+      name: "totalDebt",
+      description: "Total system debt",
+      contract: "MCD_VAT",
+      functionName: "debt",
+      abi: vatAbi,
+      decode: "ray",
+      category: "state",
+      severity: "info"
+    },
+    {
+      name: "vatLive",
+      description: "Vat live status (1=live, 0=caged/emergency shutdown)",
+      contract: "MCD_VAT",
+      functionName: "live",
+      abi: vatAbi,
+      decode: "uint",
+      category: "state",
+      severity: "critical"
+    },
+    {
+      name: "baseRate",
+      description: "Base stability fee rate applied to all vaults",
+      contract: "MCD_JUG",
+      functionName: "base",
+      abi: jugAbi,
+      decode: "ray",
+      category: "rate",
+      severity: "warning"
+    },
+    {
+      name: "dsr",
+      description: "DAI Savings Rate \u2014 per-second accumulation rate",
+      contract: "MCD_POT",
+      functionName: "dsr",
+      abi: potAbi,
+      decode: "ray",
+      category: "rate",
+      severity: "warning"
+    },
+    {
+      name: "dsrTotalDeposits",
+      description: "Total DAI deposited in DSR (Pie)",
+      contract: "MCD_POT",
+      functionName: "Pie",
+      abi: potAbi,
+      decode: "wad",
+      category: "state",
+      severity: "info"
+    },
+    {
+      name: "dogLive",
+      description: "Liquidation engine live status",
+      contract: "MCD_DOG",
+      functionName: "live",
+      abi: dogAbi,
+      decode: "uint",
+      category: "state",
+      severity: "critical"
+    },
+    {
+      name: "globalLiquidationLimit",
+      description: "Max DAI needed to cover all active auctions (Hole)",
+      contract: "MCD_DOG",
+      functionName: "Hole",
+      abi: dogAbi,
+      decode: "ray",
+      category: "risk",
+      severity: "warning"
+    },
+    {
+      name: "timelockDelay",
+      description: "Governance timelock delay in seconds",
+      contract: "MCD_PAUSE",
+      functionName: "delay",
+      abi: pauseAbi,
+      decode: "uint",
+      category: "config",
+      severity: "critical"
+    }
+  ],
+  access: [
+    {
+      role: "Pause Owner",
+      description: "Owner of governance timelock \u2014 can schedule spells",
+      contract: "MCD_PAUSE",
+      functionName: "owner",
+      abi: pauseAbi,
+      severity: "critical"
+    },
+    {
+      role: "Pause Authority",
+      description: "Authority contract \u2014 typically DSChief governance",
+      contract: "MCD_PAUSE",
+      functionName: "authority",
+      abi: pauseAbi,
+      severity: "critical"
+    }
+  ]
+};
+
+// src/registry/eigenlayer.ts
+import { parseAbi as parseAbi6 } from "viem";
+var strategyManagerAbi = parseAbi6([
+  "function owner() view returns (address)",
+  "function paused() view returns (uint256)",
+  "function strategyWhitelister() view returns (address)"
+]);
+var delegationManagerAbi = parseAbi6([
+  "function owner() view returns (address)",
+  "function paused() view returns (uint256)",
+  "function minWithdrawalDelayBlocks() view returns (uint256)",
+  "function domainSeparator() view returns (bytes32)"
+]);
+var eigenPodManagerAbi = parseAbi6([
+  "function owner() view returns (address)",
+  "function paused() view returns (uint256)"
+]);
+var slasherAbi = parseAbi6([
+  "function owner() view returns (address)",
+  "function paused() view returns (uint256)"
+]);
+var avsDirectoryAbi = parseAbi6([
+  "function owner() view returns (address)",
+  "function paused() view returns (uint256)"
+]);
+var rewardsCoordinatorAbi = parseAbi6([
+  "function owner() view returns (address)",
+  "function paused() view returns (uint256)",
+  "function activationDelay() view returns (uint32)",
+  "function currRewardsCalculationEndTimestamp() view returns (uint32)",
+  "function rewardsUpdater() view returns (address)"
+]);
+var eigenLayer = {
+  id: "eigenlayer",
+  name: "EigenLayer",
+  version: "1.0",
+  website: "https://eigenlayer.xyz",
+  description: "Restaking protocol for Ethereum shared security",
+  contracts: {
+    StrategyManager: { name: "StrategyManager", role: "Manages staking strategies and deposits", type: "proxy" },
+    DelegationManager: { name: "DelegationManager", role: "Manages operator delegation and withdrawals", type: "proxy" },
+    EigenPodManager: { name: "EigenPodManager", role: "Manages native ETH restaking pods", type: "proxy" },
+    Slasher: { name: "Slasher", role: "Handles slashing conditions", type: "proxy" },
+    AVSDirectory: { name: "AVSDirectory", role: "Registry of Actively Validated Services", type: "proxy" },
+    RewardsCoordinator: { name: "RewardsCoordinator", role: "Distributes rewards to operators/stakers", type: "proxy" }
+  },
+  deployments: {
+    ethereum: {
+      StrategyManager: "0x858646372CC42E1A627fcE94aa7A7033e7CF075A",
+      DelegationManager: "0x39053D51B77DC0d36036Fc1fCc8Cb819df8Ef37A",
+      EigenPodManager: "0x91E677b07F7AF907ec9a428aafA9fc14a0d3A338",
+      Slasher: "0xD92145c07f8Ed1D392c1B88017934E301CC1c3Cd",
+      AVSDirectory: "0x135DDa560e946695d6f155dACaFC6f1F25C1F5AF",
+      RewardsCoordinator: "0x7750d328b314EfFa365A0402CcfD489B80B0adda"
+    }
+  },
+  params: [
+    {
+      name: "strategyManagerPaused",
+      description: "Pause state bitmap (0=unpaused, non-zero=paused operations)",
+      contract: "StrategyManager",
+      functionName: "paused",
+      abi: strategyManagerAbi,
+      decode: "uint",
+      category: "state",
+      severity: "critical"
+    },
+    {
+      name: "strategyWhitelister",
+      description: "Address authorized to whitelist new strategies",
+      contract: "StrategyManager",
+      functionName: "strategyWhitelister",
+      abi: strategyManagerAbi,
+      decode: "address",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "delegationPaused",
+      description: "Delegation manager pause state",
+      contract: "DelegationManager",
+      functionName: "paused",
+      abi: delegationManagerAbi,
+      decode: "uint",
+      category: "state",
+      severity: "critical"
+    },
+    {
+      name: "minWithdrawalDelayBlocks",
+      description: "Minimum blocks to wait for withdrawal completion",
+      contract: "DelegationManager",
+      functionName: "minWithdrawalDelayBlocks",
+      abi: delegationManagerAbi,
+      decode: "uint",
+      category: "config",
+      severity: "warning"
+    },
+    {
+      name: "eigenPodPaused",
+      description: "EigenPod manager pause state",
+      contract: "EigenPodManager",
+      functionName: "paused",
+      abi: eigenPodManagerAbi,
+      decode: "uint",
+      category: "state",
+      severity: "critical"
+    },
+    {
+      name: "rewardsUpdater",
+      description: "Address authorized to submit reward merkle roots",
+      contract: "RewardsCoordinator",
+      functionName: "rewardsUpdater",
+      abi: rewardsCoordinatorAbi,
+      decode: "address",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "rewardsActivationDelay",
+      description: "Delay before new rewards become claimable",
+      contract: "RewardsCoordinator",
+      functionName: "activationDelay",
+      abi: rewardsCoordinatorAbi,
+      decode: "uint",
+      category: "config",
+      severity: "warning"
+    }
+  ],
+  access: [
+    {
+      role: "StrategyManager Owner",
+      description: "Can pause, unpause, add/remove strategies",
+      contract: "StrategyManager",
+      functionName: "owner",
+      abi: strategyManagerAbi,
+      severity: "critical"
+    },
+    {
+      role: "DelegationManager Owner",
+      description: "Can pause delegation, modify withdrawal delays",
+      contract: "DelegationManager",
+      functionName: "owner",
+      abi: delegationManagerAbi,
+      severity: "critical"
+    },
+    {
+      role: "EigenPodManager Owner",
+      description: "Controls native ETH restaking pod creation",
+      contract: "EigenPodManager",
+      functionName: "owner",
+      abi: eigenPodManagerAbi,
+      severity: "critical"
+    },
+    {
+      role: "Slasher Owner",
+      description: "Controls slashing parameters",
+      contract: "Slasher",
+      functionName: "owner",
+      abi: slasherAbi,
+      severity: "critical"
+    },
+    {
+      role: "AVSDirectory Owner",
+      description: "Controls AVS registration",
+      contract: "AVSDirectory",
+      functionName: "owner",
+      abi: avsDirectoryAbi,
+      severity: "critical"
+    },
+    {
+      role: "RewardsCoordinator Owner",
+      description: "Controls reward distribution parameters",
+      contract: "RewardsCoordinator",
+      functionName: "owner",
+      abi: rewardsCoordinatorAbi,
+      severity: "critical"
+    }
+  ]
+};
+
+// src/registry/pendle.ts
+import { parseAbi as parseAbi7 } from "viem";
+var marketFactoryAbi = parseAbi7([
+  "function owner() view returns (address)",
+  "function pendingOwner() view returns (address)",
+  "function treasury() view returns (address)",
+  "function reserveFeePercent() view returns (uint256)",
+  "function vePendle() view returns (address)",
+  "function interestFeeRate() view returns (uint256)"
+]);
+var vePendleAbi = parseAbi7([
+  "function totalSupplyStored() view returns (uint128)",
+  "function lastSlopeChangeAppliedAt() view returns (uint128)",
+  "function pendle() view returns (address)"
+]);
+var routerAbi = parseAbi7([
+  "function owner() view returns (address)"
+]);
+var pendle = {
+  id: "pendle",
+  name: "Pendle",
+  version: "2.0",
+  website: "https://pendle.finance",
+  description: "Yield trading protocol \u2014 tokenize and trade future yield",
+  contracts: {
+    PendleMarketFactory: { name: "MarketFactory", role: "Creates PT/YT markets", type: "raw" },
+    vePENDLE: { name: "vePENDLE", role: "Vote-escrowed PENDLE for governance", type: "raw" },
+    PendleRouter: { name: "Router", role: "Main swap/liquidity router", type: "raw" }
+  },
+  deployments: {
+    ethereum: {
+      PendleMarketFactory: "0x1A6fCc85557BC4fB7B534ed835a03EF056c22E23",
+      vePENDLE: "0x4f30A9D41B80ecC5B94306AB4364951AE3170210",
+      PendleRouter: "0x888888888889758F76e7103c6CbF23ABbF58F946"
+    },
+    arbitrum: {
+      PendleMarketFactory: "0x2FCb47B58350cD377f94d3a40c938fB1CF7e5Dd5",
+      vePENDLE: "0x3209E9412cca80B18338f2a56ADA59c484c39644",
+      PendleRouter: "0x888888888889758F76e7103c6CbF23ABbF58F946"
+    }
+  },
+  params: [
+    {
+      name: "treasury",
+      description: "Protocol treasury address \u2014 receives fees",
+      contract: "PendleMarketFactory",
+      functionName: "treasury",
+      abi: marketFactoryAbi,
+      decode: "address",
+      category: "config",
+      severity: "critical"
+    },
+    {
+      name: "reserveFeePercent",
+      description: "Fee percentage taken from yield as protocol revenue",
+      contract: "PendleMarketFactory",
+      functionName: "reserveFeePercent",
+      abi: marketFactoryAbi,
+      decode: "uint",
+      category: "config",
+      severity: "warning"
+    },
+    {
+      name: "interestFeeRate",
+      description: "Interest fee rate applied to markets",
+      contract: "PendleMarketFactory",
+      functionName: "interestFeeRate",
+      abi: marketFactoryAbi,
+      decode: "uint",
+      category: "rate",
+      severity: "warning"
+    },
+    {
+      name: "vePendleTotalSupply",
+      description: "Total vePENDLE supply (governance power)",
+      contract: "vePENDLE",
+      functionName: "totalSupplyStored",
+      abi: vePendleAbi,
+      decode: "wad",
+      category: "state",
+      severity: "info"
+    },
+    {
+      name: "pendingOwner",
+      description: "Pending ownership transfer target",
+      contract: "PendleMarketFactory",
+      functionName: "pendingOwner",
+      abi: marketFactoryAbi,
+      decode: "address",
+      category: "access",
+      severity: "critical"
+    }
+  ],
+  access: [
+    {
+      role: "MarketFactory Owner",
+      description: "Can create markets, set fees, set treasury",
+      contract: "PendleMarketFactory",
+      functionName: "owner",
+      abi: marketFactoryAbi,
+      severity: "critical"
+    },
+    {
+      role: "Router Owner",
+      description: "Can update router configuration",
+      contract: "PendleRouter",
+      functionName: "owner",
+      abi: routerAbi,
+      severity: "critical"
+    }
+  ]
+};
+
+// src/registry/lido.ts
+import { parseAbi as parseAbi8 } from "viem";
+var lidoAbi = parseAbi8([
+  "function totalSupply() view returns (uint256)",
+  "function getTotalPooledEther() view returns (uint256)",
+  "function getTotalShares() view returns (uint256)",
+  "function getBufferedEther() view returns (uint256)",
+  "function isStakingPaused() view returns (bool)",
+  "function getCurrentStakeLimit() view returns (uint256)",
+  "function getStakeLimitFullInfo() view returns (bool isStakingPaused, bool isStakeLimitSet, uint256 currentStakeLimit, uint256 maxStakeLimit, uint256 maxStakeLimitGrowthBlocks, uint256 prevStakeLimit, uint256 prevStakeBlockNumber)",
+  "function getFee() view returns (uint16)",
+  "function getFeeDistribution() view returns (uint16 treasuryFeeBasisPoints, uint16 insuranceFeeBasisPoints, uint16 operatorsFeeBasisPoints)",
+  "function getWithdrawalCredentials() view returns (bytes32)",
+  "function getTreasury() view returns (address)",
+  "function getLidoLocator() view returns (address)",
+  "function getBeaconStat() view returns (uint256 depositedValidators, uint256 beaconValidators, uint256 beaconBalance)"
+]);
+var wstEthAbi = parseAbi8([
+  "function stEthPerToken() view returns (uint256)",
+  "function tokensPerStEth() view returns (uint256)",
+  "function getStETHByWstETH(uint256 _wstETHAmount) view returns (uint256)",
+  "function getWstETHByStETH(uint256 _stETHAmount) view returns (uint256)",
+  "function stETH() view returns (address)"
+]);
+var norAbi = parseAbi8([
+  "function getNodeOperatorsCount() view returns (uint256)",
+  "function getActiveNodeOperatorsCount() view returns (uint256)",
+  "function getNodeOperator(uint256 _nodeOperatorId, bool _fullInfo) view returns (bool active, string name, address rewardAddress, uint64 totalVettedValidators, uint64 totalExitedValidators, uint64 totalAddedValidators, uint64 totalDepositedValidators)",
+  "function getNodeOperatorIsActive(uint256 _nodeOperatorId) view returns (bool)",
+  "function getNonce() view returns (uint256)",
+  "function getType() view returns (bytes32)",
+  "function getLocator() view returns (address)"
+]);
+var withdrawalQueueAbi = parseAbi8([
+  "function isBunkerModeActive() view returns (bool)",
+  "function bunkerModeSinceTimestamp() view returns (uint256)",
+  "function getLastRequestId() view returns (uint256)",
+  "function getLastFinalizedRequestId() view returns (uint256)",
+  "function getLastCheckpointIndex() view returns (uint256)",
+  "function MIN_STETH_WITHDRAWAL_AMOUNT() view returns (uint256)",
+  "function MAX_STETH_WITHDRAWAL_AMOUNT() view returns (uint256)"
+]);
+var dsmAbi = parseAbi8([
+  "function getOwner() view returns (address)",
+  "function getGuardianQuorum() view returns (uint256)",
+  "function getGuardians() view returns (address[])",
+  "function isGuardian(address addr) view returns (bool)",
+  "function canDeposit(uint256 stakingModuleId) view returns (bool)",
+  "function getPauseIntentValidityPeriodBlocks() view returns (uint256)",
+  "function getMaxOperatorsPerUnvetting() view returns (uint256)",
+  "function getLastDepositBlock() view returns (uint256)"
+]);
+var accountingOracleAbi = parseAbi8([
+  "function getConsensusContract() view returns (address)",
+  "function getConsensusVersion() view returns (uint256)",
+  "function getLastProcessingRefSlot() view returns (uint256)",
+  "function getConsensusReport() view returns (bytes32 hash, uint256 refSlot, uint256 processingDeadlineTime, bool processingStarted)",
+  "function SECONDS_PER_SLOT() view returns (uint256)",
+  "function GENESIS_TIME() view returns (uint256)"
+]);
+var hashConsensusAbi = parseAbi8([
+  "function getQuorum() view returns (uint256)",
+  "function getMembers() view returns (address[] addresses, uint256[] lastReportedRefSlots)",
+  "function getFastLaneMembers() view returns (address[] addresses, uint256[] lastReportedRefSlots)",
+  "function getCurrentFrame() view returns (uint256 refSlot, uint256 reportProcessingDeadlineSlot)",
+  "function getChainConfig() view returns (uint256 slotsPerEpoch, uint256 secondsPerSlot, uint256 genesisTime)",
+  "function getFrameConfig() view returns (uint256 initialEpoch, uint256 epochsPerFrame, uint256 fastLaneLengthSlots)",
+  "function getReportProcessor() view returns (address)"
+]);
+var locatorAbi = parseAbi8([
+  "function lido() view returns (address)",
+  "function accountingOracle() view returns (address)",
+  "function stakingRouter() view returns (address)",
+  "function withdrawalQueue() view returns (address)",
+  "function withdrawalVault() view returns (address)",
+  "function elRewardsVault() view returns (address)",
+  "function treasury() view returns (address)",
+  "function oracleReportSanityChecker() view returns (address)",
+  "function burner() view returns (address)",
+  "function validatorsExitBusOracle() view returns (address)",
+  "function depositSecurityModule() view returns (address)",
+  "function oracleDaemonConfig() view returns (address)",
+  "function postTokenRebaseReceiver() view returns (address)"
+]);
+var votingAbi = parseAbi8([
+  "function supportRequiredPct() view returns (uint64)",
+  "function minAcceptQuorumPct() view returns (uint64)",
+  "function voteTime() view returns (uint64)",
+  "function objectionPhaseTime() view returns (uint64)",
+  "function votesLength() view returns (uint256)"
+]);
+var agentAbi = parseAbi8([
+  "function kernel() view returns (address)",
+  "function isForwarder() view returns (bool)"
+]);
+var lido = {
+  id: "lido",
+  name: "Lido",
+  version: "2.0",
+  website: "https://lido.fi",
+  description: "Liquid staking protocol for Ethereum \u2014 stake ETH, receive rebasing stETH",
+  contracts: {
+    Lido: { name: "Lido (stETH)", role: "Core staking pool + rebasing stETH token \u2014 accepts ETH deposits, mints stETH, tracks total pooled ether", type: "proxy" },
+    WstETH: { name: "wstETH", role: "Non-rebasing wrapped stETH \u2014 fixed balance, accrues value via exchange rate", type: "raw" },
+    NodeOperatorsRegistry: { name: "NodeOperatorsRegistry", role: "Curated staking module \u2014 manages node operators and validator signing keys", type: "proxy" },
+    WithdrawalQueue: { name: "WithdrawalQueueERC721", role: "stETH withdrawal request queue \u2014 NFT claim tickets, bunker mode tracking", type: "proxy" },
+    DepositSecurityModule: { name: "DepositSecurityModule", role: "Guardian committee gate for validator deposits \u2014 prevents deposit front-running/DoS", type: "raw" },
+    AccountingOracle: { name: "AccountingOracle", role: "Reports consensus-layer state (balances, exited validators) each epoch, drives stETH rebase", type: "proxy" },
+    HashConsensus: { name: "HashConsensus (Accounting)", role: "Oracle committee consensus module \u2014 quorum + member management for AccountingOracle reports", type: "raw" },
+    LidoLocator: { name: "LidoLocator", role: "DAO-controlled pointer registry for every core protocol component \u2014 repointing it repoints the whole protocol", type: "proxy" },
+    Voting: { name: "Aragon Voting", role: "Lido DAO governance \u2014 token-weighted voting, approves everything Agent executes", type: "proxy" },
+    Agent: { name: "Aragon Agent", role: "DAO treasury + privileged executor \u2014 holds funds, executes DAO-approved calls against any contract", type: "proxy" }
+  },
+  deployments: {
+    ethereum: {
+      Lido: "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84",
+      WstETH: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0",
+      NodeOperatorsRegistry: "0x55032650b14df07b85bF18A3a3eC8E0Af2e028d5",
+      WithdrawalQueue: "0x889edC2eDab5f40e902b864aD4d7AdE8E412F9B1",
+      DepositSecurityModule: "0xC77F8768774E1c9244BEed705C4354f2113CFc09",
+      AccountingOracle: "0x852deD011285fe67063a08005c71a85690503Cee",
+      HashConsensus: "0xD624B08C83bAECF0807Dd2c6880C3154a5F0B288",
+      LidoLocator: "0xC1d0b3DE6792Bf6b4b37EccdcC24e45978Cfd2Eb",
+      Voting: "0x2e59A20f205bB85a89C53f1936454680651E618e",
+      Agent: "0x3e40D73EB977Dc6a537aF587D48316feE66E9C8c"
+    }
+  },
+  params: [
+    // -- core pool state --
+    {
+      name: "totalPooledEther",
+      description: "Total ETH controlled by the protocol (buffered + beacon chain + EL rewards)",
+      contract: "Lido",
+      functionName: "getTotalPooledEther",
+      abi: lidoAbi,
+      decode: "uint",
+      category: "state",
+      severity: "info"
+    },
+    {
+      name: "totalShares",
+      description: "Total stETH shares outstanding \u2014 denominator used to compute every account balance via rebase",
+      contract: "Lido",
+      functionName: "getTotalShares",
+      abi: lidoAbi,
+      decode: "uint",
+      category: "state",
+      severity: "info"
+    },
+    {
+      name: "bufferedEther",
+      description: "Unstaked ETH sitting in the Lido contract awaiting deposit to validators",
+      contract: "Lido",
+      functionName: "getBufferedEther",
+      abi: lidoAbi,
+      decode: "uint",
+      category: "state",
+      severity: "info"
+    },
+    {
+      name: "isStakingPaused",
+      description: "Whether new ETH deposits into Lido are paused",
+      contract: "Lido",
+      functionName: "isStakingPaused",
+      abi: lidoAbi,
+      decode: "bool",
+      category: "state",
+      severity: "critical"
+    },
+    {
+      name: "currentStakeLimit",
+      description: "Remaining ETH that can be staked right now before hitting the anti-frontrun stake rate limit",
+      contract: "Lido",
+      functionName: "getCurrentStakeLimit",
+      abi: lidoAbi,
+      decode: "uint",
+      category: "risk",
+      severity: "warning"
+    },
+    // -- fees --
+    {
+      name: "protocolFee",
+      description: "Legacy total protocol fee taken from staking rewards (treasury + node operators), in bps",
+      contract: "Lido",
+      functionName: "getFee",
+      abi: lidoAbi,
+      decode: "bps",
+      category: "config",
+      severity: "warning"
+    },
+    {
+      name: "feeDistribution",
+      description: "Legacy fee split between treasury, insurance and node operators (bps each) \u2014 module-level splits now live on StakingRouter",
+      contract: "Lido",
+      functionName: "getFeeDistribution",
+      abi: lidoAbi,
+      category: "config",
+      severity: "info"
+    },
+    // -- withdrawal credentials / treasury / locator pointer --
+    {
+      name: "withdrawalCredentials",
+      description: "Withdrawal credentials validators are deposited with \u2014 controls where exited/skimmed ETH lands",
+      contract: "Lido",
+      functionName: "getWithdrawalCredentials",
+      abi: lidoAbi,
+      decode: "string",
+      category: "config",
+      severity: "critical"
+    },
+    {
+      name: "treasury",
+      description: "Address receiving the treasury share of staking rewards (Aragon Agent)",
+      contract: "Lido",
+      functionName: "getTreasury",
+      abi: lidoAbi,
+      decode: "address",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "lidoLocator",
+      description: "LidoLocator address the core contract resolves every peer component through",
+      contract: "Lido",
+      functionName: "getLidoLocator",
+      abi: lidoAbi,
+      decode: "address",
+      category: "config",
+      severity: "info"
+    },
+    // -- wstETH --
+    {
+      name: "wstEthExchangeRate",
+      description: "stETH redeemable for 1 wstETH \u2014 reflects accumulated staking rewards since wrap",
+      contract: "WstETH",
+      functionName: "stEthPerToken",
+      abi: wstEthAbi,
+      decode: "wad",
+      category: "rate",
+      severity: "info"
+    },
+    // -- node operators --
+    {
+      name: "nodeOperatorsCount",
+      description: "Total registered node operators in the curated staking module",
+      contract: "NodeOperatorsRegistry",
+      functionName: "getNodeOperatorsCount",
+      abi: norAbi,
+      decode: "uint",
+      category: "state",
+      severity: "info"
+    },
+    {
+      name: "activeNodeOperatorsCount",
+      description: "Node operators currently active and eligible for new deposits",
+      contract: "NodeOperatorsRegistry",
+      functionName: "getActiveNodeOperatorsCount",
+      abi: norAbi,
+      decode: "uint",
+      category: "state",
+      severity: "info"
+    },
+    {
+      name: "norNonce",
+      description: "Increments on any change to operator keys/limits \u2014 used to detect stale/front-run deposit data",
+      contract: "NodeOperatorsRegistry",
+      functionName: "getNonce",
+      abi: norAbi,
+      decode: "uint",
+      category: "state",
+      severity: "info"
+    },
+    // -- withdrawal queue --
+    {
+      name: "isBunkerModeActive",
+      description: "Whether the withdrawal queue is in bunker mode (CL-level slashing/penalty event) \u2014 changes stETH:ETH withdrawal accounting",
+      contract: "WithdrawalQueue",
+      functionName: "isBunkerModeActive",
+      abi: withdrawalQueueAbi,
+      decode: "bool",
+      category: "risk",
+      severity: "critical"
+    },
+    {
+      name: "bunkerModeSinceTimestamp",
+      description: "Timestamp bunker mode was activated",
+      contract: "WithdrawalQueue",
+      functionName: "bunkerModeSinceTimestamp",
+      abi: withdrawalQueueAbi,
+      decode: "uint",
+      category: "state",
+      severity: "warning"
+    },
+    {
+      name: "lastRequestId",
+      description: "Highest withdrawal request id issued",
+      contract: "WithdrawalQueue",
+      functionName: "getLastRequestId",
+      abi: withdrawalQueueAbi,
+      decode: "uint",
+      category: "state",
+      severity: "info"
+    },
+    {
+      name: "lastFinalizedRequestId",
+      description: "Highest withdrawal request id finalized and claimable \u2014 gap vs lastRequestId is the unfinalized withdrawal backlog",
+      contract: "WithdrawalQueue",
+      functionName: "getLastFinalizedRequestId",
+      abi: withdrawalQueueAbi,
+      decode: "uint",
+      category: "state",
+      severity: "warning"
+    },
+    {
+      name: "minWithdrawalAmount",
+      description: "Minimum stETH amount per withdrawal request",
+      contract: "WithdrawalQueue",
+      functionName: "MIN_STETH_WITHDRAWAL_AMOUNT",
+      abi: withdrawalQueueAbi,
+      decode: "uint",
+      category: "config",
+      severity: "info"
+    },
+    {
+      name: "maxWithdrawalAmount",
+      description: "Maximum stETH amount per withdrawal request",
+      contract: "WithdrawalQueue",
+      functionName: "MAX_STETH_WITHDRAWAL_AMOUNT",
+      abi: withdrawalQueueAbi,
+      decode: "uint",
+      category: "config",
+      severity: "info"
+    },
+    // -- deposit security module (guardian committee) --
+    {
+      name: "guardianQuorum",
+      description: "Guardian signatures required for DepositSecurityModule to authorize a deposit or emergency pause",
+      contract: "DepositSecurityModule",
+      functionName: "getGuardianQuorum",
+      abi: dsmAbi,
+      decode: "uint",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "dsmOwner",
+      description: "Can add/remove guardians and change the quorum \u2014 controls who gates validator deposits",
+      contract: "DepositSecurityModule",
+      functionName: "getOwner",
+      abi: dsmAbi,
+      decode: "address",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "pauseIntentValidityPeriodBlocks",
+      description: "Block window during which a guardian pause signature remains valid",
+      contract: "DepositSecurityModule",
+      functionName: "getPauseIntentValidityPeriodBlocks",
+      abi: dsmAbi,
+      decode: "uint",
+      category: "config",
+      severity: "info"
+    },
+    {
+      name: "maxOperatorsPerUnvetting",
+      description: "Max node operators guardians can unvet keys for in a single report",
+      contract: "DepositSecurityModule",
+      functionName: "getMaxOperatorsPerUnvetting",
+      abi: dsmAbi,
+      decode: "uint",
+      category: "config",
+      severity: "info"
+    },
+    // -- accounting oracle / consensus --
+    {
+      name: "accountingConsensusVersion",
+      description: "Report schema version AccountingOracle expects from HashConsensus reports \u2014 bumping it invalidates old reporter software",
+      contract: "AccountingOracle",
+      functionName: "getConsensusVersion",
+      abi: accountingOracleAbi,
+      decode: "uint",
+      category: "config",
+      severity: "info"
+    },
+    {
+      name: "accountingLastProcessingRefSlot",
+      description: "Last beacon chain reference slot processed by AccountingOracle \u2014 staleness indicator for the whole rebase pipeline",
+      contract: "AccountingOracle",
+      functionName: "getLastProcessingRefSlot",
+      abi: accountingOracleAbi,
+      decode: "uint",
+      category: "state",
+      severity: "warning"
+    },
+    {
+      name: "oracleQuorum",
+      description: "Oracle committee members required to agree before an AccountingOracle report is considered final \u2014 directly controls the reported stETH rebase",
+      contract: "HashConsensus",
+      functionName: "getQuorum",
+      abi: hashConsensusAbi,
+      decode: "uint",
+      category: "access",
+      severity: "critical"
+    },
+    // -- LidoLocator pointer registry (god-pointer) --
+    {
+      name: "locatorLido",
+      description: "Lido core contract the locator resolves to \u2014 every module trusts this pointer",
+      contract: "LidoLocator",
+      functionName: "lido",
+      abi: locatorAbi,
+      decode: "address",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "locatorAccountingOracle",
+      description: "AccountingOracle the locator resolves to \u2014 repointing it swaps out the entire rebase reporting pipeline",
+      contract: "LidoLocator",
+      functionName: "accountingOracle",
+      abi: locatorAbi,
+      decode: "address",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "locatorStakingRouter",
+      description: "StakingRouter the locator resolves to \u2014 owns module registration and per-module fee routing",
+      contract: "LidoLocator",
+      functionName: "stakingRouter",
+      abi: locatorAbi,
+      decode: "address",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "locatorDepositSecurityModule",
+      description: "DepositSecurityModule the locator resolves to \u2014 repointing it swaps out the guardian committee gating deposits",
+      contract: "LidoLocator",
+      functionName: "depositSecurityModule",
+      abi: locatorAbi,
+      decode: "address",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "locatorTreasury",
+      description: "Treasury address the locator resolves to \u2014 where protocol fee revenue ultimately flows",
+      contract: "LidoLocator",
+      functionName: "treasury",
+      abi: locatorAbi,
+      decode: "address",
+      category: "access",
+      severity: "critical"
+    },
+    // -- DAO governance parameters --
+    {
+      name: "votingSupportRequiredPct",
+      description: "Percentage of yes-votes required for a DAO vote to pass",
+      contract: "Voting",
+      functionName: "supportRequiredPct",
+      abi: votingAbi,
+      decode: "percent",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "votingMinAcceptQuorumPct",
+      description: "Minimum participation quorum required for a DAO vote to be valid",
+      contract: "Voting",
+      functionName: "minAcceptQuorumPct",
+      abi: votingAbi,
+      decode: "percent",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "voteTime",
+      description: "Duration a vote remains open before it can be executed",
+      contract: "Voting",
+      functionName: "voteTime",
+      abi: votingAbi,
+      decode: "uint",
+      category: "config",
+      severity: "info"
+    },
+    {
+      name: "objectionPhaseTime",
+      description: 'Trailing window of a vote during which only "no" votes are accepted \u2014 guards against last-block vote flipping',
+      contract: "Voting",
+      functionName: "objectionPhaseTime",
+      abi: votingAbi,
+      decode: "uint",
+      category: "config",
+      severity: "warning"
+    }
+  ],
+  access: [
+    {
+      role: "Aragon Voting",
+      description: "Token-weighted DAO vote \u2014 required to trigger any Agent-executed protocol change (fees, oracle members, guardians, LidoLocator updates)",
+      contract: "Voting",
+      functionName: "supportRequiredPct",
+      abi: votingAbi,
+      severity: "critical"
+    },
+    {
+      role: "Aragon Agent (Treasury/Executor)",
+      description: "Executes DAO-approved calls against every contract resolved via LidoLocator \u2014 holds treasury funds and is the ultimate admin of the protocol",
+      contract: "Agent",
+      functionName: "kernel",
+      abi: agentAbi,
+      severity: "critical"
+    },
+    {
+      role: "DepositSecurityModule Owner",
+      description: "Can add/remove guardians and change the guardian quorum \u2014 controls who gates validator deposits and emergency pauses",
+      contract: "DepositSecurityModule",
+      functionName: "getOwner",
+      abi: dsmAbi,
+      severity: "critical"
+    },
+    {
+      role: "Oracle Committee (HashConsensus)",
+      description: "Guardian-style committee whose quorum determines the accepted consensus-layer report \u2014 directly drives the stETH rebase rate every day",
+      contract: "HashConsensus",
+      functionName: "getQuorum",
+      abi: hashConsensusAbi,
+      severity: "critical"
+    }
+  ]
+};
+
+// src/registry/morpho-blue.ts
+import { parseAbi as parseAbi9 } from "viem";
+var morphoAbi = parseAbi9([
+  "function owner() view returns (address)",
+  "function feeRecipient() view returns (address)",
+  "function isIrmEnabled(address irm) view returns (bool)",
+  "function isLltvEnabled(uint256 lltv) view returns (bool)",
+  "function isAuthorized(address authorizer, address authorized) view returns (bool)",
+  "function nonce(address authorizer) view returns (uint256)",
+  "function market(bytes32 id) view returns ((uint128 totalSupplyAssets, uint128 totalSupplyShares, uint128 totalBorrowAssets, uint128 totalBorrowShares, uint128 lastUpdate, uint128 fee))",
+  "function idToMarketParams(bytes32 id) view returns ((address loanToken, address collateralToken, address oracle, address irm, uint256 lltv))",
+  "function position(bytes32 id, address user) view returns ((uint256 supplyShares, uint128 borrowShares, uint128 collateral))",
+  "function DOMAIN_SEPARATOR() view returns (bytes32)"
+]);
+var irmAbi = parseAbi9([
+  "function MORPHO() view returns (address)",
+  "function rateAtTarget(bytes32 id) view returns (int256)"
+]);
+var metaMorphoFactoryAbi = parseAbi9([
+  "function isMetaMorpho(address target) view returns (bool)"
+]);
+var publicAllocatorAbi = parseAbi9([
+  "function admin(address vault) view returns (address)",
+  "function fee(address vault) view returns (uint256)",
+  "function accruedFee(address vault) view returns (uint256)"
+]);
+var chainlinkOracleFactoryAbi = parseAbi9([
+  "function isMorphoChainlinkOracleV2(address target) view returns (bool)"
+]);
+var vaultAbi = parseAbi9([
+  "function owner() view returns (address)",
+  "function curator() view returns (address)",
+  "function guardian() view returns (address)",
+  "function isAllocator(address target) view returns (bool)",
+  "function timelock() view returns (uint256)",
+  "function fee() view returns (uint96)",
+  "function feeRecipient() view returns (address)",
+  "function skimRecipient() view returns (address)",
+  "function asset() view returns (address)",
+  "function totalAssets() view returns (uint256)",
+  "function supplyQueueLength() view returns (uint256)",
+  "function withdrawQueueLength() view returns (uint256)",
+  "function config(bytes32 id) view returns ((uint184 cap, bool enabled, uint64 removableAt))",
+  "function DECIMALS_OFFSET() view returns (uint8)",
+  "function MORPHO() view returns (address)"
+]);
+var morphoBlue = {
+  id: "morpho-blue",
+  name: "Morpho Blue",
+  version: "1.0",
+  website: "https://morpho.org",
+  description: "Immutable, oracle-agnostic isolated lending primitive with a permissionless MetaMorpho vault curation layer",
+  contracts: {
+    Morpho: { name: "Morpho", role: "Core immutable lending singleton \u2014 isolated markets, no upgradeability", type: "raw" },
+    AdaptiveCurveIrm: { name: "AdaptiveCurveIrm", role: "Default interest rate model targeting ~90% utilization", type: "raw" },
+    MetaMorphoFactory: { name: "MetaMorpho Factory (v1.0)", role: "Original factory deploying MetaMorpho vault instances", type: "raw" },
+    MetaMorphoFactoryV1_1: { name: "MetaMorpho Factory v1.1", role: "Current factory deploying MetaMorphoV1_1 vault instances", type: "raw" },
+    PublicAllocator: { name: "Public Allocator", role: "Permissionless reallocation of vault liquidity within curator-set flow caps", type: "raw" },
+    ChainlinkOracleFactory: { name: "MorphoChainlinkOracleV2 Factory", role: "Deploys Chainlink-backed market oracle adaptors", type: "raw" },
+    BundlerV2: { name: "Bundler V2", role: "Multicall router for atomic supply/borrow/flashloan bundles", type: "raw" },
+    Bundler3: { name: "Bundler3", role: "Successor multicall router with generalized adapters", type: "raw" },
+    FlagshipUsdcVault: { name: "Steakhouse USDC Vault", role: "Representative MetaMorpho vault instance (flagship USDC market)", type: "raw" }
+  },
+  deployments: {
+    ethereum: {
+      Morpho: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
+      AdaptiveCurveIrm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+      MetaMorphoFactory: "0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101",
+      MetaMorphoFactoryV1_1: "0x1897A8997241C1cD4bD0698647e4EB7213535c24",
+      PublicAllocator: "0xfd32fA2ca22c76dD6E550706Ad913FC6CE91c75D",
+      ChainlinkOracleFactory: "0x3A7bB36Ee3f3eE32A60e9f2b33c1e5f2E83ad766",
+      BundlerV2: "0x4095F064B8d3c3548A3bebfd0Bbfd04750E30077",
+      Bundler3: "0x6566194141eefa99Af43Bb5Aa71460Ca2Dc90245",
+      FlagshipUsdcVault: "0xBEEF01735c132Ada46AA9aA4c54623cAA92A64CB"
+    },
+    base: {
+      Morpho: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
+      AdaptiveCurveIrm: "0x46415998764C29aB2a25CbeA6254146D50D22687",
+      MetaMorphoFactoryV1_1: "0xFf62A7c278C62eD665133147129245053Bbf5918",
+      PublicAllocator: "0xA090dD1a701408Df1d4d0B85b716c87565f90467",
+      ChainlinkOracleFactory: "0x2DC205F24BCb6B311E5cdf0745B0741648Aebd3d",
+      BundlerV2: "0x23055618898e202386e6c13955a58D3C68200BFB",
+      Bundler3: "0x6BFd8137e702540E7A42B74178A4a49Ba43920C4",
+      FlagshipUsdcVault: "0xCBeeF01994E24a60f7DCB8De98e75AD8BD4Ad60d"
+    }
+  },
+  params: [
+    {
+      name: "morphoOwner",
+      description: "Morpho core owner \u2014 can enable new IRMs/LLTVs and set the fee recipient, but cannot touch existing market params (immutable by design)",
+      contract: "Morpho",
+      functionName: "owner",
+      abi: morphoAbi,
+      decode: "address",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "morphoFeeRecipient",
+      description: "Recipient of protocol fees accrued across all markets",
+      contract: "Morpho",
+      functionName: "feeRecipient",
+      abi: morphoAbi,
+      decode: "address",
+      category: "config",
+      severity: "warning"
+    },
+    {
+      name: "adaptiveCurveIrmEnabled",
+      description: "Whether AdaptiveCurveIrm is whitelisted as an approved IRM on Ethereum mainnet",
+      contract: "Morpho",
+      functionName: "isIrmEnabled",
+      args: ["0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC"],
+      abi: morphoAbi,
+      decode: "bool",
+      category: "config",
+      severity: "info"
+    },
+    {
+      name: "lltv86PercentEnabled",
+      description: "Whether the 86% LLTV tier is whitelisted (one of the standard risk tiers)",
+      contract: "Morpho",
+      functionName: "isLltvEnabled",
+      args: [860000000000000000n],
+      abi: morphoAbi,
+      decode: "bool",
+      category: "risk",
+      severity: "info"
+    },
+    {
+      name: "irmMorphoRef",
+      description: "Morpho core address the AdaptiveCurveIrm is bound to \u2014 must match the deployed Morpho singleton",
+      contract: "AdaptiveCurveIrm",
+      functionName: "MORPHO",
+      abi: irmAbi,
+      decode: "address",
+      category: "config",
+      severity: "info"
+    },
+    {
+      name: "factoryRecognizesFlagshipVault",
+      description: "Confirms the flagship USDC vault (deployed pre-v1.1) was created by the original MetaMorphoFactory \u2014 sanity check against spoofed vault UIs",
+      contract: "MetaMorphoFactory",
+      functionName: "isMetaMorpho",
+      args: ["0xBEEF01735c132Ada46AA9aA4c54623cAA92A64CB"],
+      abi: metaMorphoFactoryAbi,
+      decode: "bool",
+      category: "config",
+      severity: "info"
+    },
+    {
+      name: "cbbtcUsdcOracleIsFactoryDeployed",
+      description: "Confirms the oracle used by the flagship vault's first supply-queue market (cbBTC/USDC, 86% LLTV) was deployed by the canonical MorphoChainlinkOracleV2Factory \u2014 sanity check against a spoofed/malicious oracle",
+      contract: "ChainlinkOracleFactory",
+      functionName: "isMorphoChainlinkOracleV2",
+      args: ["0xA6D6950c9F177F1De7f7757FB33539e3Ec60182a"],
+      abi: chainlinkOracleFactoryAbi,
+      decode: "bool",
+      category: "risk",
+      severity: "info"
+    },
+    {
+      name: "publicAllocatorAdmin",
+      description: "Address allowed to set flow caps for the flagship vault on the Public Allocator \u2014 can trigger instant reallocation within curator-approved caps",
+      contract: "PublicAllocator",
+      functionName: "admin",
+      args: ["0xBEEF01735c132Ada46AA9aA4c54623cAA92A64CB"],
+      abi: publicAllocatorAbi,
+      decode: "address",
+      category: "access",
+      severity: "warning"
+    },
+    {
+      name: "publicAllocatorFee",
+      description: "Fee (wei) charged by the Public Allocator for reallocating the flagship vault",
+      contract: "PublicAllocator",
+      functionName: "fee",
+      args: ["0xBEEF01735c132Ada46AA9aA4c54623cAA92A64CB"],
+      abi: publicAllocatorAbi,
+      decode: "uint",
+      category: "config",
+      severity: "info"
+    },
+    {
+      name: "vaultOwner",
+      description: "Vault owner \u2014 can set curator, guardian, timelock and allocators; ultimate control over vault configuration",
+      contract: "FlagshipUsdcVault",
+      functionName: "owner",
+      abi: vaultAbi,
+      decode: "address",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "vaultCurator",
+      description: "Curator \u2014 whitelists markets and sets/lowers supply caps for the vault",
+      contract: "FlagshipUsdcVault",
+      functionName: "curator",
+      abi: vaultAbi,
+      decode: "address",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "vaultGuardian",
+      description: "Guardian \u2014 can revoke pending timelocked changes (cap increases, guardian/timelock changes, market removals)",
+      contract: "FlagshipUsdcVault",
+      functionName: "guardian",
+      abi: vaultAbi,
+      decode: "address",
+      category: "access",
+      severity: "critical"
+    },
+    {
+      name: "vaultTimelock",
+      description: "Timelock delay (seconds) applied to risk-sensitive vault changes",
+      contract: "FlagshipUsdcVault",
+      functionName: "timelock",
+      abi: vaultAbi,
+      decode: "uint",
+      category: "config",
+      severity: "warning"
+    },
+    {
+      name: "vaultFee",
+      description: "Performance fee taken from vault yield (WAD-scaled fraction)",
+      contract: "FlagshipUsdcVault",
+      functionName: "fee",
+      abi: vaultAbi,
+      decode: "wad",
+      category: "config",
+      severity: "warning"
+    },
+    {
+      name: "vaultFeeRecipient",
+      description: "Recipient of the vault performance fee",
+      contract: "FlagshipUsdcVault",
+      functionName: "feeRecipient",
+      abi: vaultAbi,
+      decode: "address",
+      category: "config",
+      severity: "warning"
+    },
+    {
+      name: "vaultSkimRecipient",
+      description: "Receives non-asset token dust skimmed from the vault",
+      contract: "FlagshipUsdcVault",
+      functionName: "skimRecipient",
+      abi: vaultAbi,
+      decode: "address",
+      category: "config",
+      severity: "info"
+    },
+    {
+      name: "vaultAsset",
+      description: "Underlying ERC-4626 asset held by the vault",
+      contract: "FlagshipUsdcVault",
+      functionName: "asset",
+      abi: vaultAbi,
+      decode: "address",
+      category: "config",
+      severity: "info"
+    },
+    {
+      name: "vaultTotalAssets",
+      description: "Total assets under management in the vault",
+      contract: "FlagshipUsdcVault",
+      functionName: "totalAssets",
+      abi: vaultAbi,
+      decode: "uint",
+      category: "state",
+      severity: "info"
+    },
+    {
+      name: "vaultSupplyQueueLength",
+      description: "Number of markets in the vault supply queue",
+      contract: "FlagshipUsdcVault",
+      functionName: "supplyQueueLength",
+      abi: vaultAbi,
+      decode: "uint",
+      category: "state",
+      severity: "info"
+    },
+    {
+      name: "vaultWithdrawQueueLength",
+      description: "Number of markets in the vault withdraw queue",
+      contract: "FlagshipUsdcVault",
+      functionName: "withdrawQueueLength",
+      abi: vaultAbi,
+      decode: "uint",
+      category: "state",
+      severity: "info"
+    }
+  ],
+  access: [
+    {
+      role: "Morpho Core Owner",
+      description: "Can enable new IRMs/LLTVs and change the fee recipient. Cannot alter existing market params or seize funds \u2014 Morpho Blue markets are immutable once created",
+      contract: "Morpho",
+      functionName: "owner",
+      abi: morphoAbi,
+      severity: "critical"
+    },
+    {
+      role: "Vault Owner",
+      description: "Full control over a MetaMorpho vault \u2014 sets curator, guardian, timelock, allocators, fee recipient",
+      contract: "FlagshipUsdcVault",
+      functionName: "owner",
+      abi: vaultAbi,
+      severity: "critical"
+    },
+    {
+      role: "Vault Curator",
+      description: "Decides which markets the vault can allocate to and the supply cap per market \u2014 primary risk-management role",
+      contract: "FlagshipUsdcVault",
+      functionName: "curator",
+      abi: vaultAbi,
+      severity: "critical"
+    },
+    {
+      role: "Vault Guardian",
+      description: "Can revoke pending timelocked changes (malicious cap increases, curator/guardian/timelock swaps) before they execute",
+      contract: "FlagshipUsdcVault",
+      functionName: "guardian",
+      abi: vaultAbi,
+      severity: "critical"
+    }
+    // Note: Public Allocator's admin/fee are per-vault (take an `address vault`
+    // argument), so they're only tracked as `params` (which support `args`) —
+    // `access` entries are always read with zero arguments by the scanner.
+  ]
+};
+
+// src/registry/index.ts
+var protocols = {
+  "aave-v3": aaveV3,
+  "compound-v3": compoundV3,
+  "uniswap-v3": uniswapV3,
+  "maker": maker,
+  "eigenlayer": eigenLayer,
+  "pendle": pendle,
+  "lido": lido,
+  "morpho-blue": morphoBlue
+};
+function getProtocol(id) {
+  return protocols[id];
+}
+function listProtocols() {
+  return Object.values(protocols);
+}
+function getProtocolForChain(id, chain) {
+  const protocol = protocols[id];
+  if (!protocol) return void 0;
+  const addresses = protocol.deployments[chain];
+  if (!addresses) return void 0;
+  return { protocol, addresses };
+}
+
+// src/scanner.ts
+function createClient(chainName, config) {
+  const chain = resolveChain(chainName);
+  return createPublicClient({
+    chain,
+    transport: http(config.rpc),
+    batch: { multicall: true }
+  });
+}
+async function scanContract(client, chainName, name, entry) {
+  const address = entry.address;
+  const [blockNumber, block, proxyInfo, publicReads] = await Promise.all([
+    client.getBlockNumber(),
+    client.getBlock({ blockTag: "latest" }),
+    entry.type === "proxy" ? detectProxy(client, address) : Promise.resolve(null),
+    readCommonState(client, address)
+  ]);
+  if (proxyInfo?.implementation) {
+    const implReads = await readCommonState(client, proxyInfo.implementation);
+    for (const [key, value] of Object.entries(implReads)) {
+      if (!(key in publicReads)) {
+        publicReads[`impl.${key}`] = value;
+      }
+    }
+  }
+  return {
+    address,
+    chain: chainName,
+    blockNumber,
+    timestamp: Number(block.timestamp),
+    proxyInfo,
+    storageSlots: [],
+    publicReads
+  };
+}
+async function readParam(client, address, param) {
+  try {
+    const result = await client.readContract({
+      address,
+      abi: param.abi,
+      functionName: param.functionName,
+      args: param.args || []
+    });
+    let value = String(result);
+    if (param.decode === "bps" && typeof result === "bigint") {
+      value = `${result} (${(Number(result) / 100).toFixed(2)}%)`;
+    } else if (param.decode === "ray" && typeof result === "bigint") {
+      value = `${(Number(result) / 1e27).toFixed(6)}`;
+    } else if (param.decode === "wad" && typeof result === "bigint") {
+      value = `${(Number(result) / 1e18).toFixed(6)}`;
+    } else if (param.decode === "percent" && typeof result === "bigint") {
+      value = `${Number(result)}%`;
+    }
+    return { name: param.name, value, description: param.description };
+  } catch {
+    return null;
+  }
+}
+async function readAccess(client, address, access) {
+  try {
+    const result = await client.readContract({
+      address,
+      abi: access.abi,
+      functionName: access.functionName
+    });
+    return { role: access.role, holder: String(result), description: access.description };
+  } catch {
+    return null;
+  }
+}
+async function scanProtocol(client, protocolId, chainName) {
+  const found = getProtocolForChain(protocolId, chainName);
+  if (!found) return null;
+  const { protocol, addresses } = found;
+  const [blockNumber, block] = await Promise.all([
+    client.getBlockNumber(),
+    client.getBlock({ blockTag: "latest" })
+  ]);
+  const contracts = {};
+  for (const [key, def] of Object.entries(protocol.contracts)) {
+    const addr = addresses[key];
+    if (!addr) continue;
+    const proxyInfo = def.type === "proxy" ? await detectProxy(client, addr) : null;
+    contracts[key] = {
+      address: addr,
+      role: def.role,
+      proxyInfo: proxyInfo ? {
+        implementation: proxyInfo.implementation,
+        admin: proxyInfo.admin
+      } : null
+    };
+  }
+  const params = {};
+  for (const paramDef of protocol.params) {
+    const contractAddr = addresses[paramDef.contract];
+    if (!contractAddr) continue;
+    const result = await readParam(client, contractAddr, paramDef);
+    if (result) {
+      params[result.name] = {
+        value: result.value,
+        description: result.description,
+        category: paramDef.category,
+        severity: paramDef.severity
+      };
+    }
+  }
+  const access = [];
+  for (const accessDef of protocol.access) {
+    const contractAddr = addresses[accessDef.contract];
+    if (!contractAddr) continue;
+    const result = await readAccess(client, contractAddr, accessDef);
+    if (result) {
+      access.push({ ...result, severity: accessDef.severity });
+    }
+  }
+  return {
+    protocolId,
+    protocolName: protocol.name,
+    chain: chainName,
+    blockNumber,
+    timestamp: Number(block.timestamp),
+    contracts,
+    params,
+    access
+  };
+}
+
+// src/snapshot.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync, existsSync as existsSync2, readdirSync } from "fs";
+import { join } from "path";
+var SNAPSHOT_DIR = ".protoscan";
+function ensureDir(dir) {
+  if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
+}
+function snapshotPath(dir, chain, label) {
+  return join(dir, `${chain}_${label}.json`);
+}
+function serializeSnapshot(snap) {
+  return JSON.stringify(
+    snap,
+    (_, value) => typeof value === "bigint" ? value.toString() : value,
+    2
+  );
+}
+function saveSnapshot(contracts, chain, label) {
+  const dir = SNAPSHOT_DIR;
+  ensureDir(dir);
+  const now = /* @__PURE__ */ new Date();
+  const autoLabel = label || now.toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const firstContract = Object.values(contracts)[0];
+  const snapshot = {
+    version: "1",
+    createdAt: now.toISOString(),
+    chain,
+    blockNumber: firstContract ? firstContract.blockNumber.toString() : "0",
+    contracts
+  };
+  const filePath = snapshotPath(dir, chain, autoLabel);
+  writeFileSync2(filePath, serializeSnapshot(snapshot), "utf-8");
+  return filePath;
+}
+function loadSnapshot(filePath) {
+  const raw = readFileSync2(filePath, "utf-8");
+  return JSON.parse(raw);
+}
+function listSnapshots(chain) {
+  if (!existsSync2(SNAPSHOT_DIR)) return [];
+  const files = readdirSync(SNAPSHOT_DIR).filter((f) => f.endsWith(".json"));
+  if (chain) return files.filter((f) => f.startsWith(`${chain}_`));
+  return files;
+}
+function resolveSnapshotFile(nameOrPath, chain) {
+  if (existsSync2(nameOrPath)) return nameOrPath;
+  const inDir = join(SNAPSHOT_DIR, nameOrPath);
+  if (existsSync2(inDir)) return inDir;
+  if (chain) {
+    const withChain = join(SNAPSHOT_DIR, `${chain}_${nameOrPath}.json`);
+    if (existsSync2(withChain)) return withChain;
+  }
+  throw new Error(`Snapshot not found: ${nameOrPath}`);
+}
+
+// src/diff.ts
+var CRITICAL_FIELDS = /* @__PURE__ */ new Set([
+  "erc1967.implementation",
+  "erc1967.admin",
+  "owner",
+  "admin",
+  "guardian",
+  "governance",
+  "timelock",
+  "pendingOwner"
+]);
+var WARNING_FIELDS = /* @__PURE__ */ new Set([
+  "paused",
+  "erc1967.beacon"
+]);
+function severity(field) {
+  if (CRITICAL_FIELDS.has(field)) return "critical";
+  if (WARNING_FIELDS.has(field)) return "warning";
+  return "info";
+}
+function diffSnapshots(from, to) {
+  const entries = [];
+  const allContracts = /* @__PURE__ */ new Set([
+    ...Object.keys(from.contracts),
+    ...Object.keys(to.contracts)
+  ]);
+  for (const name of allContracts) {
+    const fromContract = from.contracts[name];
+    const toContract = to.contracts[name];
+    if (!fromContract && toContract) {
+      entries.push({
+        contract: name,
+        field: "_contract",
+        before: "(not present)",
+        after: toContract.address,
+        severity: "warning"
+      });
+      continue;
+    }
+    if (fromContract && !toContract) {
+      entries.push({
+        contract: name,
+        field: "_contract",
+        before: fromContract.address,
+        after: "(removed)",
+        severity: "critical"
+      });
+      continue;
+    }
+    if (!fromContract || !toContract) continue;
+    if (fromContract.proxyInfo || toContract.proxyInfo) {
+      const fp = fromContract.proxyInfo || { implementation: null, admin: null, beacon: null };
+      const tp = toContract.proxyInfo || { implementation: null, admin: null, beacon: null };
+      for (const key of ["implementation", "admin", "beacon"]) {
+        const fromVal = fp[key] || "(none)";
+        const toVal = tp[key] || "(none)";
+        if (fromVal !== toVal) {
+          entries.push({
+            contract: name,
+            field: `erc1967.${key}`,
+            before: fromVal,
+            after: toVal,
+            severity: severity(`erc1967.${key}`)
+          });
+        }
+      }
+    }
+    const allKeys = /* @__PURE__ */ new Set([
+      ...Object.keys(fromContract.publicReads),
+      ...Object.keys(toContract.publicReads)
+    ]);
+    for (const key of allKeys) {
+      const fromVal = fromContract.publicReads[key] ?? "(none)";
+      const toVal = toContract.publicReads[key] ?? "(none)";
+      if (fromVal !== toVal) {
+        entries.push({
+          contract: name,
+          field: key,
+          before: fromVal,
+          after: toVal,
+          severity: severity(key)
+        });
+      }
+    }
+  }
+  entries.sort((a, b) => {
+    const sev = { critical: 0, warning: 1, info: 2 };
+    return sev[a.severity] - sev[b.severity];
+  });
+  return {
+    from: from.createdAt,
+    to: to.createdAt,
+    chain: to.chain,
+    entries
+  };
+}
+
+// src/index.ts
+var program = new Command();
+program.name("protoscan").description("On-chain protocol state tracker and diff tool for DeFi teams").version("0.1.0");
+program.command("init").description("Initialize protoscan config in current directory").action(() => {
+  try {
+    const path = initConfig();
+    console.log(chalk.green(`Created ${path}`));
+    console.log(chalk.dim("Edit it to add your chains and contracts.\n"));
+    console.log("Or use built-in protocol definitions:");
+    console.log(chalk.cyan("  protoscan protocols           # list supported protocols"));
+    console.log(chalk.cyan("  protoscan scan aave-v3 -c ethereum  # scan Aave V3"));
+  } catch (e) {
+    console.error(chalk.red(e.message));
+    process.exit(1);
+  }
+});
+program.command("protocols").description("List supported protocols in the built-in registry").action(() => {
+  const protos = listProtocols();
+  console.log(chalk.bold("\nSupported protocols:\n"));
+  for (const p of protos) {
+    const chains = Object.keys(p.deployments).join(", ");
+    const paramCount = p.params.length;
+    const accessCount = p.access.length;
+    console.log(`  ${chalk.cyan(p.id.padEnd(16))} ${p.name} v${p.version}`);
+    console.log(chalk.dim(`${"".padEnd(18)}chains: ${chains}`));
+    console.log(chalk.dim(`${"".padEnd(18)}${paramCount} params, ${accessCount} access roles, ${Object.keys(p.contracts).length} contracts
+`));
+  }
+  console.log(chalk.dim("Usage: protoscan scan <protocol-id> -c <chain>"));
+});
+program.command("scan").description("Scan a known protocol using built-in definitions").argument("<protocol>", "Protocol ID (e.g. aave-v3, compound-v3)").option("-c, --chain <chain>", "Chain to scan", "ethereum").option("-l, --label <label>", "Label for saved snapshot").action(async (protocolId, opts) => {
+  const proto = getProtocol(protocolId);
+  if (!proto) {
+    console.error(chalk.red(`Unknown protocol: ${protocolId}`));
+    console.log(chalk.dim('Run "protoscan protocols" to see available protocols.'));
+    process.exit(1);
+  }
+  const chainName = opts.chain;
+  if (!proto.deployments[chainName]) {
+    console.error(chalk.red(`${proto.name} is not deployed on ${chainName}`));
+    console.log(chalk.dim(`Available: ${Object.keys(proto.deployments).join(", ")}`));
+    process.exit(1);
+  }
+  const config = loadConfig();
+  const chainConfig = config.chains[chainName];
+  if (!chainConfig) {
+    console.error(chalk.red(`Chain "${chainName}" not in config. Add an RPC URL first.`));
+    process.exit(1);
+  }
+  const spinner = ora(`Scanning ${proto.name} on ${chainName}...`).start();
+  const client = createClient(chainName, chainConfig);
+  try {
+    const result = await scanProtocol(client, protocolId, chainName);
+    if (!result) {
+      spinner.fail("Scan returned no results");
+      process.exit(1);
+    }
+    spinner.succeed(`${proto.name} on ${chainName} @ block ${result.blockNumber}
+`);
+    console.log(chalk.bold.underline("Contracts"));
+    for (const [key, info] of Object.entries(result.contracts)) {
+      const proxyTag = info.proxyInfo ? chalk.dim(" (proxy)") : "";
+      console.log(`  ${chalk.bold(key)}${proxyTag}: ${info.address}`);
+      console.log(chalk.dim(`    ${info.role}`));
+      if (info.proxyInfo?.implementation) {
+        console.log(`    impl: ${chalk.cyan(info.proxyInfo.implementation)}`);
+      }
+      if (info.proxyInfo?.admin) {
+        console.log(`    admin: ${chalk.yellow(info.proxyInfo.admin)}`);
+      }
+    }
+    if (result.access.length > 0) {
+      console.log(chalk.bold.underline("\nAccess Control"));
+      for (const a of result.access) {
+        const icon = a.severity === "critical" ? chalk.red("\u2717") : chalk.yellow("!");
+        console.log(`  ${icon} ${chalk.bold(a.role)}`);
+        console.log(`    holder: ${chalk.yellow(a.holder)}`);
+        console.log(chalk.dim(`    ${a.description}`));
+      }
+    }
+    const categories = ["risk", "rate", "config", "state", "access"];
+    for (const cat of categories) {
+      const catParams = Object.entries(result.params).filter(([_, v]) => v.category === cat);
+      if (catParams.length === 0) continue;
+      console.log(chalk.bold.underline(`
+${cat.charAt(0).toUpperCase() + cat.slice(1)} Parameters`));
+      for (const [name, info] of catParams) {
+        const icon = info.severity === "critical" ? chalk.red("\u2717") : info.severity === "warning" ? chalk.yellow("!") : chalk.dim("~");
+        console.log(`  ${icon} ${name}: ${chalk.cyan(info.value)}`);
+        console.log(chalk.dim(`    ${info.description}`));
+      }
+    }
+    const snapData = {
+      _protocol: { id: protocolId, name: proto.name, chain: chainName },
+      _block: result.blockNumber.toString(),
+      _timestamp: result.timestamp,
+      contracts: result.contracts,
+      params: result.params,
+      access: result.access
+    };
+    const label = opts.label || (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const { writeFileSync: writeFileSync3, mkdirSync: mkdirSync2, existsSync: existsSync3 } = await import("fs");
+    const dir = ".protoscan";
+    if (!existsSync3(dir)) mkdirSync2(dir, { recursive: true });
+    const filePath = `${dir}/${protocolId}_${chainName}_${label}.json`;
+    writeFileSync3(filePath, JSON.stringify(snapData, null, 2), "utf-8");
+    console.log(chalk.dim(`
+Saved: ${filePath}`));
+  } catch (e) {
+    spinner.fail(`Scan failed: ${e.message}`);
+    process.exit(1);
+  }
+});
+program.command("snapshot").description("Snapshot custom contracts from config").option("-c, --chain <chain>", "Chain to snapshot (default: all)").option("-l, --label <label>", "Snapshot label").action(async (opts) => {
+  const config = loadConfig();
+  const targetChains = opts.chain ? [opts.chain] : Object.keys(config.chains);
+  for (const chainName of targetChains) {
+    const chainConfig = config.chains[chainName];
+    if (!chainConfig) {
+      console.error(chalk.red(`Chain "${chainName}" not in config.`));
+      continue;
+    }
+    const spinner = ora(`Scanning ${chainName}...`).start();
+    const client = createClient(chainName, chainConfig);
+    const results = {};
+    const contractEntries = Object.entries(config.contracts).filter(
+      ([_, entry]) => entry.chains.includes(chainName)
+    );
+    if (contractEntries.length === 0) {
+      spinner.warn(`No contracts configured for ${chainName}`);
+      continue;
+    }
+    for (const [name, entry] of contractEntries) {
+      spinner.text = `Scanning ${chainName} / ${name}...`;
+      try {
+        results[name] = await scanContract(client, chainName, name, entry);
+      } catch (e) {
+        spinner.warn(`Failed to scan ${name}: ${e.message}`);
+      }
+    }
+    const filePath = saveSnapshot(results, chainName, opts.label);
+    spinner.succeed(`${chainName}: ${Object.keys(results).length} contracts \u2192 ${filePath}`);
+  }
+});
+program.command("diff").description("Compare two snapshots").argument("<from>", "First snapshot").argument("<to>", "Second snapshot").option("-c, --chain <chain>", "Chain filter").action((fromArg, toArg, opts) => {
+  try {
+    const fromFile = resolveSnapshotFile(fromArg, opts.chain);
+    const toFile = resolveSnapshotFile(toArg, opts.chain);
+    const fromSnap = loadSnapshot(fromFile);
+    const toSnap = loadSnapshot(toFile);
+    const result = diffSnapshots(fromSnap, toSnap);
+    if (result.entries.length === 0) {
+      console.log(chalk.green("No changes detected."));
+      return;
+    }
+    console.log(chalk.bold(`
+Changes: ${result.from} \u2192 ${result.to} (${result.chain})
+`));
+    for (const entry of result.entries) {
+      const icon = entry.severity === "critical" ? chalk.red("\u2717") : entry.severity === "warning" ? chalk.yellow("!") : chalk.dim("~");
+      console.log(`  ${icon} ${chalk.bold(`${entry.contract}.${entry.field}`)}`);
+      console.log(chalk.dim(`    ${entry.before}`));
+      console.log(chalk.green(`    ${entry.after}`));
+      console.log();
+    }
+    const critCount = result.entries.filter((e) => e.severity === "critical").length;
+    const warnCount = result.entries.filter((e) => e.severity === "warning").length;
+    const infoCount = result.entries.filter((e) => e.severity === "info").length;
+    console.log(`${chalk.red(`${critCount} critical`)} | ${chalk.yellow(`${warnCount} warning`)} | ${chalk.dim(`${infoCount} info`)}`);
+  } catch (e) {
+    console.error(chalk.red(e.message));
+    process.exit(1);
+  }
+});
+program.command("list").description("List saved snapshots").option("-c, --chain <chain>", "Filter by chain").action((opts) => {
+  const snapshots = listSnapshots(opts.chain);
+  if (snapshots.length === 0) {
+    console.log(chalk.dim("No snapshots found."));
+    return;
+  }
+  for (const s of snapshots) console.log(`  ${s}`);
+});
+program.command("show").description("Display a snapshot").argument("<snapshot>", "Snapshot file or label").option("-c, --chain <chain>", "Chain filter").action((snapArg, opts) => {
+  try {
+    const file = resolveSnapshotFile(snapArg, opts.chain);
+    const snap = loadSnapshot(file);
+    console.log(chalk.bold(`
+Snapshot: ${snap.chain} @ block ${snap.blockNumber}`));
+    console.log(chalk.dim(`Created: ${snap.createdAt}
+`));
+    for (const [name, contract] of Object.entries(snap.contracts)) {
+      console.log(chalk.bold.underline(name));
+      console.log(`  address: ${contract.address}`);
+      if (contract.proxyInfo) {
+        if (contract.proxyInfo.implementation) console.log(`  implementation: ${chalk.cyan(contract.proxyInfo.implementation)}`);
+        if (contract.proxyInfo.admin) console.log(`  proxy admin: ${chalk.yellow(contract.proxyInfo.admin)}`);
+      }
+      for (const [key, value] of Object.entries(contract.publicReads)) {
+        console.log(`  ${key}: ${value}`);
+      }
+      console.log();
+    }
+  } catch (e) {
+    console.error(chalk.red(e.message));
+    process.exit(1);
+  }
+});
+program.parse();