Read state

git checkout rc4-audit-candidate        # aca5fcd3bbc9ecb1026de58bea431d406d8ecfff
forge build
python3 -c "import json,hashlib;b=bytes.fromhex(json.load(open('out/GeneLens.sol/GeneLens.json'))['bytecode']['object'][2:]);print(len(b),hashlib.sha256(b).hexdigest())"
# expected: 10610 d14ed67685d2ab52f47acf59f75d02abd9e8b72a76ff06654cf151a3948f8958

// read-state.mjs   (Node 18+, npm install viem)
// env: RPC_URL, HOOK_ADDRESS (after deployment), STATE_VIEW_ADDRESS (Uniswap v4 StateView), LENS_ARTIFACT
import { createPublicClient, http, parseAbi } from "viem";
import { readFileSync } from "node:fs";
import { createHash } from "node:crypto";

const { RPC_URL, HOOK_ADDRESS, STATE_VIEW_ADDRESS } = process.env;
const LENS_ARTIFACT = process.env.LENS_ARTIFACT ?? "out/GeneLens.sol/GeneLens.json";

const hookAbi = parseAbi([
  "function launched() view returns (bool)",
  "function genomeHash() view returns (bytes32)",
  "function poolId() view returns (bytes32)",
  "function token() view returns (address)",
  "function ethReserve() view returns (uint128)",
  "function regenReserve() view returns (uint128)",
  "function geneReserve() view returns (uint128)",
  "function ethCommitted() view returns (uint128)",
  "function geneCommitted() view returns (uint128)",
  "function massLiquidity() view returns (uint256)",
  "function ethBudget() view returns (uint256)",
  "function immunityActive() view returns (bool)",
]);

const lensAbi = parseAbi([
  "function currentEpoch(address hook) view returns (uint32)",
  "function blockState(address hook) view returns ((int24 lastStartTick, uint32 epoch, int24 epochMaxTick, int24 epochMinTick, int24 athTick, int24 atlTick) bs, (uint40 lastBlock, uint48 revenueGwei, int56 netGeneMicro, uint16 activeBlocks, uint32 pathTicks, uint32 blockVolumeGwei) acc)",
  "function geneStatus(address hook, uint8 g) view returns ((uint8 state, uint8 history, uint32 count, uint32 firstEvidenceEpoch, uint32 expressedEpoch, bytes32 evidenceHash))",
  "function epochRecord(address hook, uint32 e) view returns ((uint96 revenue, uint32 activeBlocks, uint32 pathTicks, uint88 ethCommitted, bool closed))",
  "function anchors(address hook) view returns (int24 atlTick, int24 athTick)",
  "function ethBudgets(address hook) view returns (uint256 bidLeft, uint256 immunityLeft, uint256 churnLeft)",
  "function report(address hook) view returns ((uint256 permanentMassLiquidity, uint256[3] reachableEthDown, uint256[3] reachableGeneUp, uint256 cumulativeEthCommitted, uint256 cumulativeGeneCommitted, uint256 positions))",
]);

const stateViewAbi = parseAbi([
  "function getSlot0(bytes32 poolId) view returns (uint160 sqrtPriceX96, int24 tick, uint24 protocolFee, uint24 lpFee)",
  "function getLiquidity(bytes32 poolId) view returns (uint128 liquidity)",
]);

// The frozen GeneLens creation code, checked against the freeze record before use.
const LENS_CREATION_CODE = JSON.parse(readFileSync(LENS_ARTIFACT, "utf8")).bytecode.object;
const sha = createHash("sha256").update(Buffer.from(LENS_CREATION_CODE.slice(2), "hex")).digest("hex");
if (sha !== "d14ed67685d2ab52f47acf59f75d02abd9e8b72a76ff06654cf151a3948f8958") throw new Error("not the frozen GeneLens");

const client = createPublicClient({ transport: http(RPC_URL) });
const blockNumber = await client.getBlockNumber();

const hook = (functionName) => client.readContract({ address: HOOK_ADDRESS, abi: hookAbi, functionName, blockNumber });
// Deployless read: viem executes the creation code in an eth_call; nothing is deployed.
const lens = (functionName, args = []) =>
  client.readContract({ code: LENS_CREATION_CODE, abi: lensAbi, functionName, args: [HOOK_ADDRESS, ...args], blockNumber });

if (!(await hook("launched"))) {
  console.log("not launched");
} else {
  const poolId = await hook("poolId");
  const [ethReserve, regenReserve, geneReserve, massLiquidity, ethCommitted, immunityActive] = await Promise.all(
    ["ethReserve", "regenReserve", "geneReserve", "massLiquidity", "ethCommitted", "immunityActive"].map(hook),
  );
  const [currentEpoch, [bs], [atlTick, athTick], budgets, report, metabolism] = await Promise.all([
    lens("currentEpoch"), lens("blockState"), lens("anchors"), lens("ethBudgets"), lens("report"), lens("geneStatus", [1]),
  ]);
  const [, spotTick, protocolFee, lpFee] = await client.readContract({
    address: STATE_VIEW_ADDRESS, abi: stateViewAbi, functionName: "getSlot0", args: [poolId], blockNumber,
  });

  // Epoch-dependent views describe the last touched epoch until the new epoch's first touch.
  const opened = Number(bs.epoch) === Number(currentEpoch);
  // Ticks are log1.0001(GENE per ETH): the ETH price of one GENE is 1.0001^(-tick).
  const ethPerGene = (tick) => Math.pow(1.0001, -Number(tick));

  console.log({
    block: blockNumber, currentEpoch, lastTouchedEpoch: bs.epoch, budgetsCurrent: opened,
    ethReserve, regenReserve, geneReserve, massLiquidity, ethCommitted,
    spotTick, lpFee, protocolFee, atlTick, athTick, atlEthPerGene: ethPerGene(atlTick),
    bidLeft: opened ? budgets[0] : "pending", immunityLeft: opened ? budgets[1] : "pending", churnLeft: opened ? budgets[2] : "pending",
    reachableEthDown: report.reachableEthDown, metabolismState: metabolism.state, immunityPressure: opened && immunityActive,
  });
}

# after deployment
B=$(cast block-number --rpc-url $RPC_URL)
cast call $HOOK_ADDRESS "launched()(bool)" --block $B --rpc-url $RPC_URL
cast call $HOOK_ADDRESS "massLiquidity()(uint256)" --block $B --rpc-url $RPC_URL
cast call $HOOK_ADDRESS "ethReserve()(uint128)" --block $B --rpc-url $RPC_URL
POOL_ID=$(cast call $HOOK_ADDRESS "poolId()(bytes32)" --rpc-url $RPC_URL)
cast call $STATE_VIEW_ADDRESS "getSlot0(bytes32)(uint160,int24,uint24,uint24)" $POOL_ID --block $B --rpc-url $RPC_URL
cast storage $HOOK_ADDRESS 0 --block $B --rpc-url $RPC_URL     # BlockState word

// continues read-state.mjs
const w = BigInt(await client.getStorageAt({ address: HOOK_ADDRESS, slot: "0x0", blockNumber }));
const int24 = (x) => Number(BigInt.asIntN(24, x & 0xffffffn));
console.log({ athTick: int24(w >> 104n), atlTick: int24(w >> 128n), epoch: Number((w >> 24n) & 0xffffffffn) });