@sm-lab/recipes 0.2.0

package/dist/cl-activate-CPqr6v_D.mjs

@@ -0,0 +1,653 @@
+import { _ as contract, h as roleMember, i as getPubkey, l as SETTLE_GENERAL_DELAYED_PENALTY_ROLE, m as actAs, o as DEFAULT_ADMIN_ROLE, p as randomSeed, r as getKeyBalance, s as REPORT_GENERAL_DELAYED_PENALTY_ROLE, u as SET_TREE_ROLE, v as resolveGate } from "./topup-B2NzJV7_.mjs";
+import { encodeAbiParameters, keccak256, maxUint256, parseAbiParameters, parseEther, toBytes, toHex } from "viem";
+import { curatedGateAbi, feeDistributorAbi, feeOracleAbi, hashConsensusAbi, lidoAbi, vettedGateAbi } from "@sm-lab/receipts";
+import { buildAddressesTree, ipfsOptionsFromEnv, makeRewards, pinJsonToIpfs, shouldAttemptPin } from "@sm-lab/merkle";
+//#region src/recipes/operator-info.ts
+/** Typed read of a node operator's on-chain record. (Port of `NodeOperators.operatorInfo`.) */
+async function operatorInfo(ctx, opts) {
+	const m = contract(ctx, "module");
+	return await ctx.client.readContract({
+		...m,
+		functionName: "getNodeOperator",
+		args: [opts.noId]
+	});
+}
+//#endregion
+//#region src/recipes/chain.ts
+/** Advance fork time by `seconds` and mine a block (evm_increaseTime + evm_mine). */
+async function warpBy(ctx, seconds) {
+	await ctx.client.increaseTime({ seconds: Number(seconds) });
+	await ctx.client.mine({ blocks: 1 });
+}
+/**
+* Warp fork time to an absolute unix timestamp and mine a block
+* (evm_setNextBlockTimestamp + evm_mine). The absolute counterpart of `warpBy` — used by
+* `submitRewards`'s consensus-frame wait. Over RPC, `setNextBlockTimestamp` + `mine` reproduces
+* Foundry's `vm.warp(ts)` (the post-warp `block.timestamp` settles automatically after mining).
+*/
+async function warpTo(ctx, timestamp) {
+	await ctx.client.setNextBlockTimestamp({ timestamp: BigInt(timestamp) });
+	await ctx.client.mine({ blocks: 1 });
+}
+/** Take an anvil state snapshot; returns the snapshot id (evm_snapshot). */
+function snapshot(ctx) {
+	return ctx.client.snapshot();
+}
+/** Revert the fork to a snapshot id (evm_revert). */
+async function revert(ctx, id) {
+	await ctx.client.revert({ id });
+}
+//#endregion
+//#region src/recipes/address-changes.ts
+/** Propose a new manager address for an operator (signed by the current manager). */
+async function proposeManager(ctx, opts) {
+	const m = contract(ctx, "module");
+	await actAs(ctx, (await ctx.client.readContract({
+		...m,
+		functionName: "getNodeOperator",
+		args: [opts.noId]
+	})).managerAddress, (from) => ctx.client.writeContract({
+		...m,
+		functionName: "proposeNodeOperatorManagerAddressChange",
+		args: [opts.noId, opts.proposed],
+		account: from,
+		chain: null
+	}));
+}
+/** Confirm the proposed manager address (signed by the proposed manager). */
+async function confirmManager(ctx, opts) {
+	const m = contract(ctx, "module");
+	await actAs(ctx, (await ctx.client.readContract({
+		...m,
+		functionName: "getNodeOperator",
+		args: [opts.noId]
+	})).proposedManagerAddress, (from) => ctx.client.writeContract({
+		...m,
+		functionName: "confirmNodeOperatorManagerAddressChange",
+		args: [opts.noId],
+		account: from,
+		chain: null
+	}));
+}
+/** Propose a new reward address (signed by the MANAGER, per the on-chain access rule). */
+async function proposeReward(ctx, opts) {
+	const m = contract(ctx, "module");
+	await actAs(ctx, (await ctx.client.readContract({
+		...m,
+		functionName: "getNodeOperator",
+		args: [opts.noId]
+	})).managerAddress, (from) => ctx.client.writeContract({
+		...m,
+		functionName: "proposeNodeOperatorRewardAddressChange",
+		args: [opts.noId, opts.proposed],
+		account: from,
+		chain: null
+	}));
+}
+/** Confirm the proposed reward address (signed by the proposed reward address). */
+async function confirmReward(ctx, opts) {
+	const m = contract(ctx, "module");
+	await actAs(ctx, (await ctx.client.readContract({
+		...m,
+		functionName: "getNodeOperator",
+		args: [opts.noId]
+	})).proposedRewardAddress, (from) => ctx.client.writeContract({
+		...m,
+		functionName: "confirmNodeOperatorRewardAddressChange",
+		args: [opts.noId],
+		account: from,
+		chain: null
+	}));
+}
+//#endregion
+//#region src/encode.ts
+/** A node-operator id packed as the on-chain `bytes8(uint64)` (big-endian). */
+function nodeOperatorIdBytes(noId) {
+	return toHex(noId, { size: 8 });
+}
+/** A key count packed as the on-chain `bytes16(uint128)` (big-endian). */
+function keyCountBytes(count) {
+	return toHex(count, { size: 16 });
+}
+//#endregion
+//#region src/recipes/vetting.ts
+/** Set an operator's vetted-keys count (StakingRouter-gated). `vettedKeys` is the new absolute count. */
+async function unvet(ctx, opts) {
+	const m = contract(ctx, "module");
+	await actAs(ctx, ctx.addresses.stakingRouter, (from) => ctx.client.writeContract({
+		...m,
+		functionName: "decreaseVettedSigningKeysCount",
+		args: [nodeOperatorIdBytes(opts.noId), keyCountBytes(opts.vettedKeys)],
+		account: from,
+		chain: null
+	}));
+}
+/** Set an operator's exited-keys count (StakingRouter-gated). `exitedKeys` is the new absolute total. */
+async function exit(ctx, opts) {
+	const m = contract(ctx, "module");
+	await actAs(ctx, ctx.addresses.stakingRouter, (from) => ctx.client.writeContract({
+		...m,
+		functionName: "updateExitedValidatorsCount",
+		args: [nodeOperatorIdBytes(opts.noId), keyCountBytes(opts.exitedKeys)],
+		account: from,
+		chain: null
+	}));
+}
+//#endregion
+//#region src/recipes/validators.ts
+/** Report a validator slashing for an operator's key (Verifier-gated). `keyIndex` is the storage index. */
+async function slash(ctx, opts) {
+	const m = contract(ctx, "module");
+	await actAs(ctx, ctx.addresses.Verifier, (from) => ctx.client.writeContract({
+		...m,
+		functionName: "reportValidatorSlashing",
+		args: [opts.noId, opts.keyIndex],
+		account: from,
+		chain: null
+	}));
+}
+/** Report a regular validator withdrawal for one key (Verifier-gated). isSlashed = slashingPenalty > 0. */
+async function withdraw(ctx, opts) {
+	const m = contract(ctx, "module");
+	const slashingPenalty = opts.slashingPenalty ?? 0n;
+	const info = {
+		nodeOperatorId: opts.noId,
+		keyIndex: opts.keyIndex,
+		exitBalance: opts.exitBalance,
+		slashingPenalty,
+		isSlashed: slashingPenalty > 0n
+	};
+	await actAs(ctx, ctx.addresses.Verifier, (from) => ctx.client.writeContract({
+		...m,
+		functionName: "reportRegularWithdrawnValidators",
+		args: [[info]],
+		account: from,
+		chain: null
+	}));
+}
+//#endregion
+//#region src/recipes/penalties.ts
+/** Report a general delayed penalty against an operator (penalty-reporter role). */
+async function reportPenalty(ctx, opts) {
+	const m = contract(ctx, "module");
+	const reporter = await roleMember(ctx, m, REPORT_GENERAL_DELAYED_PENALTY_ROLE);
+	const penaltyType = opts.penaltyType ?? toHex(1n, { size: 32 });
+	const details = opts.details ?? "fork-penalty";
+	await actAs(ctx, reporter, (from) => ctx.client.writeContract({
+		...m,
+		functionName: "reportGeneralDelayedPenalty",
+		args: [
+			opts.noId,
+			penaltyType,
+			opts.amount,
+			details
+		],
+		account: from,
+		chain: null
+	}));
+}
+/** Cancel a previously-reported general delayed penalty (penalty-reporter role). */
+async function cancelPenalty(ctx, opts) {
+	const m = contract(ctx, "module");
+	await actAs(ctx, await roleMember(ctx, m, REPORT_GENERAL_DELAYED_PENALTY_ROLE), (from) => ctx.client.writeContract({
+		...m,
+		functionName: "cancelGeneralDelayedPenalty",
+		args: [opts.noId, opts.amount],
+		account: from,
+		chain: null
+	}));
+}
+/**
+* Settle (process) an operator's general delayed penalty (penalty-settler role).
+* The `maxAmount` option is the per-operator settlement cap passed as the contract's 2nd array arg (confusingly named `bondLockNonces` in the ABI); the default `maxUint256` settles the penalty fully.
+*/
+async function settlePenalty(ctx, opts) {
+	const m = contract(ctx, "module");
+	await actAs(ctx, await roleMember(ctx, m, SETTLE_GENERAL_DELAYED_PENALTY_ROLE), (from) => ctx.client.writeContract({
+		...m,
+		functionName: "settleGeneralDelayedPenalty",
+		args: [[opts.noId], [opts.maxAmount ?? maxUint256]],
+		account: from,
+		chain: null
+	}));
+}
+/** Compensate (pay off) an operator's general delayed penalty — signed by the operator manager. */
+async function compensatePenalty(ctx, opts) {
+	const m = contract(ctx, "module");
+	await actAs(ctx, (await ctx.client.readContract({
+		...m,
+		functionName: "getNodeOperator",
+		args: [opts.noId]
+	})).managerAddress, (from) => ctx.client.writeContract({
+		...m,
+		functionName: "compensateGeneralDelayedPenalty",
+		args: [opts.noId],
+		account: from,
+		chain: null
+	}));
+}
+//#endregion
+//#region src/recipes/bond.ts
+/** Top up an operator's bond with ETH (permissionless `depositETH`), signed by the manager. */
+async function addBond(ctx, opts) {
+	const m = contract(ctx, "module");
+	const acc = contract(ctx, "Accounting");
+	await actAs(ctx, (await ctx.client.readContract({
+		...m,
+		functionName: "getNodeOperator",
+		args: [opts.noId]
+	})).managerAddress, (from) => ctx.client.writeContract({
+		...acc,
+		functionName: "depositETH",
+		args: [opts.noId],
+		account: from,
+		value: opts.amount,
+		chain: null
+	}));
+}
+/**
+* Charge a penalty against an operator's bond (creating bond debt if uncovered). `Accounting.penalize`
+* is module-only, so we impersonate the module address. Returns whether the penalty was fully covered.
+*/
+async function createBondDebt(ctx, opts) {
+	const moduleAddress = contract(ctx, "module").address;
+	const acc = contract(ctx, "Accounting");
+	return actAs(ctx, moduleAddress, async (from) => {
+		const { result, request } = await ctx.client.simulateContract({
+			...acc,
+			functionName: "penalize",
+			args: [opts.noId, opts.amount],
+			account: from
+		});
+		await ctx.client.writeContract({
+			...request,
+			chain: null
+		});
+		return { penaltyCovered: result };
+	});
+}
+//#endregion
+//#region src/recipes/set-gate.ts
+/** Default gate selector per module: cm → 'po' (CuratedGates[0]); csm → 'ics' (VettedGate). */
+function defaultSelector(ctx) {
+	return ctx.module === "cm" ? "po" : "ics";
+}
+/**
+* Build a gate addresses tree (OZ ['address'], via @sm-lab/merkle) and install it on the gate
+* (`setTreeParams(root, cid)`), impersonating the gate admin. The cid is pinned to IPFS
+* (env-configured: a local @sm-lab/ipfs or Pinata) unless `cid` is supplied.
+*
+* Module-agnostic (port of fork.just `set-gate-addrs` + `update-gate-tree`, both selector-driven):
+* the csm VettedGate and cm CuratedGate share a byte-identical grantRole/setTreeParams/getRoleMember
+* surface, so the only per-module differences are the resolved address, the default selector, and
+* which gate ABI carries the fragments.
+*/
+async function setGateAddrs(ctx, opts) {
+	const selector = opts.selector ?? defaultSelector(ctx);
+	const abi = ctx.module === "cm" ? curatedGateAbi : vettedGateAbi;
+	const gate = {
+		address: resolveGate(ctx, selector),
+		abi
+	};
+	const tree = buildAddressesTree(opts.addresses);
+	const treeRoot = tree.root;
+	const treeCid = opts.cid ?? await pinTree(tree.dump(), selector);
+	const admin = await roleMember(ctx, gate, DEFAULT_ADMIN_ROLE);
+	await actAs(ctx, admin, async (from) => {
+		await ctx.client.writeContract({
+			...gate,
+			functionName: "grantRole",
+			args: [SET_TREE_ROLE, admin],
+			account: from,
+			chain: null
+		});
+		await ctx.client.writeContract({
+			...gate,
+			functionName: "setTreeParams",
+			args: [treeRoot, treeCid],
+			account: from,
+			chain: null
+		});
+	});
+	return {
+		treeRoot,
+		treeCid
+	};
+}
+async function pinTree(dump, selector) {
+	if (!shouldAttemptPin()) throw new Error("@sm-lab/recipes: could not pin the gate tree — set IPFS_API_URL (a local @sm-lab/ipfs) or PINATA_* credentials, or pass opts.cid");
+	return pinJsonToIpfs(dump, `gate-${selector}`, ipfsOptionsFromEnv());
+}
+//#endregion
+//#region src/recipes/rewards.ts
+/** Reward draw bounds (mirrors `mock-rewards.mjs`): per active key, in wei. */
+const REWARD_MIN_WEI = 100000000000000000n;
+const REWARD_SPAN = 200000000000000000n - REWARD_MIN_WEI;
+/** type(uint64).max — padding id for a lone real operator (FeeDistributor non-empty-proof rule). */
+const PAD_NO_ID = (1n << 64n) - 1n;
+/** Empty-tree sentinel root: 32 zero bytes. */
+const ZERO_ROOT = `0x${"00".repeat(32)}`;
+/**
+* Build the cumulative FeeDistributor rewards tree off on-chain operator state and a seeded mock
+* reward per active key, pin the tree + report log to IPFS (guarded), and return a typed in-memory
+* `RewardsReport`. Port of `mock-rewards.mjs` — but the OUTPUT path stays bigint-typed (no bare
+* `JSON.stringify` of bigints), and the per-key draw is fully seeded (no `Math.random`) so tests can
+* pin `treeRoot`/`distributed`.
+*
+* Carry-forward is via `opts.previousCumulatives` only (option (a) of the design). The pure
+* carry-forward logic — carry every prior leaf forward except the pad, then add this frame's deltas —
+* is identical no matter where the prior Map came from, so the fork path chains calls:
+* `makeRewards(ctx, { previousCumulatives: prev.cumulatives })`.
+* TODO(6f?): on-chain `treeRoot()` → `treeCid()` → IPFS fetch of the prior tree as a default source.
+*/
+async function makeRewards$1(ctx, opts = {}) {
+	const seed = opts.seed ?? randomSeed();
+	const m = contract(ctx, "module");
+	const count = await ctx.client.readContract({
+		...m,
+		functionName: "getNodeOperatorsCount"
+	});
+	const ids = Array.from({ length: Number(count) }, (_, i) => BigInt(i));
+	const infos = await Promise.all(ids.map((noId) => operatorInfo(ctx, { noId })));
+	const reportOperators = {};
+	const frameDeltas = /* @__PURE__ */ new Map();
+	let distributed = 0n;
+	for (const [i, noId] of ids.entries()) {
+		const info = infos[i];
+		const activeKeys = info.totalDepositedKeys - info.totalWithdrawnKeys;
+		if (activeKeys <= 0) continue;
+		let opDistributed = 0n;
+		for (let k = 0; k < activeKeys; k++) opDistributed += REWARD_MIN_WEI + seededUint(seed, `reward:${noId}:${k}`, REWARD_SPAN);
+		reportOperators[noId.toString()] = { distributed_rewards: opDistributed };
+		frameDeltas.set(noId, opDistributed);
+		distributed += opDistributed;
+	}
+	const rebate = 0n;
+	const cumulatives = /* @__PURE__ */ new Map();
+	for (const [noId, shares] of normalizePrevious(opts.previousCumulatives)) if (noId !== PAD_NO_ID) cumulatives.set(noId, shares);
+	for (const [noId, delta] of frameDeltas) cumulatives.set(noId, (cumulatives.get(noId) ?? 0n) + delta);
+	const leaves = [...cumulatives.entries()].map(([noId, shares]) => [noId, shares]);
+	if (leaves.length === 1) leaves.push([PAD_NO_ID, 0n]);
+	if (leaves.length === 0) return {
+		treeRoot: ZERO_ROOT,
+		treeCid: "",
+		logCid: "",
+		distributed,
+		rebate,
+		cumulatives
+	};
+	if ((opts.treeCid === void 0 || opts.logCid === void 0) && !shouldAttemptPin()) throw new Error("@sm-lab/recipes: could not pin the rewards tree/log — set IPFS_API_URL (a local @sm-lab/ipfs) or PINATA_* credentials, or pass opts.treeCid + opts.logCid");
+	const log = {
+		blockstamp: { block_timestamp: opts.now ?? Math.floor(Date.now() / 1e3) },
+		distributable: distributed,
+		distributed_rewards: distributed,
+		rebate_to_protocol: rebate,
+		operators: reportOperators
+	};
+	let treeRoot;
+	let treeCid;
+	let logCid;
+	let treeDump;
+	if (opts.treeCid !== void 0 && opts.logCid !== void 0) {
+		const result = await makeRewards(leaves, { noUpload: true });
+		treeRoot = result.treeRoot;
+		treeDump = result.treeDump;
+		treeCid = opts.treeCid;
+		logCid = opts.logCid;
+	} else if (opts.treeCid !== void 0) {
+		const result = await makeRewards(leaves, {
+			log,
+			noUpload: false
+		});
+		treeRoot = result.treeRoot;
+		treeDump = result.treeDump;
+		treeCid = opts.treeCid;
+		logCid = result.logCid ?? "";
+	} else if (opts.logCid !== void 0) {
+		const result = await makeRewards(leaves, { noUpload: false });
+		treeRoot = result.treeRoot;
+		treeDump = result.treeDump;
+		treeCid = result.treeCid ?? "";
+		logCid = opts.logCid;
+	} else {
+		const result = await makeRewards(leaves, { log });
+		treeRoot = result.treeRoot;
+		treeDump = result.treeDump;
+		treeCid = result.treeCid ?? "";
+		logCid = result.logCid ?? "";
+	}
+	return {
+		treeRoot,
+		treeCid,
+		logCid,
+		distributed,
+		rebate,
+		treeDump,
+		cumulatives
+	};
+}
+/** Deterministic uint in `[0, span)` from `keccak256(toBytes(\`${seed}:${label}\`)) % span`. */
+function seededUint(seed, label, span) {
+	return BigInt(keccak256(toBytes(`${seed}:${label}`))) % span;
+}
+/** Normalize the carry-forward input (Map or entries) to an iterable of [noId, shares]. */
+function normalizePrevious(prev) {
+	if (!prev) return [];
+	return prev instanceof Map ? prev.entries() : prev;
+}
+const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+/**
+* The `IFeeOracle.ReportData` struct as ONE tuple parameter — components in declaration order
+* (verified against `fixtures/receipts/src/abi/FeeOracle.ts`). `abi.encode(data)` for a single
+* struct == ABI-encoding one tuple parameter (head/tail offsets for the dynamic `string` fields);
+* passing the tuple type as a single param to `encodeAbiParameters` reproduces it. Do NOT flatten
+* into 9 top-level params — that drops the tuple offset and changes the hash. This is the exact
+* reportHash transcription trap.
+*/
+const REPORT_DATA_PARAMS = parseAbiParameters("(uint256 consensusVersion, uint256 refSlot, bytes32 treeRoot, string treeCid, string logCid, uint256 distributed, uint256 rebate, bytes32 strikesTreeRoot, string strikesTreeCid)");
+/**
+* Submit a `RewardsReport` (from `makeRewards`) on-chain: fund the FeeDistributor, warp to the next
+* consensus frame, build the `ReportData` tuple, reach consensus across the fast-lane members (with
+* a `getMembers` fallback), and submit the report data. Port of `OracleReport.s.sol:submitRewards`.
+*
+* Fork-only in practice (it WRITES + warps); the hermetic tests assert the call sequence, the funding
+* literals, the warp arguments, and the reportHash, not real frame advancement.
+*
+* A zero-root report (no active keys this frame) is a graceful no-op: returns `{ submitted: false }`
+* with no reads/writes, so `submitRewards(ctx, await makeRewards(ctx))` composes on an empty fork.
+*/
+async function submitRewards(ctx, report) {
+	if (report.treeRoot === ZERO_ROOT) return { submitted: false };
+	const feeDistributor = {
+		address: ctx.addresses.FeeDistributor,
+		abi: feeDistributorAbi
+	};
+	const oracle = {
+		address: ctx.addresses.FeeOracle,
+		abi: feeOracleAbi
+	};
+	const hashConsensus = {
+		address: ctx.addresses.HashConsensus,
+		abi: hashConsensusAbi
+	};
+	const lido = {
+		address: ctx.addresses.lido,
+		abi: lidoAbi
+	};
+	const pending = await ctx.client.readContract({
+		...feeDistributor,
+		functionName: "pendingSharesToDistribute"
+	});
+	if (pending < report.distributed + report.rebate) {
+		const neededShares = report.distributed + report.rebate - pending;
+		const x = await ctx.client.readContract({
+			...lido,
+			functionName: "getPooledEthByShares",
+			args: [neededShares]
+		});
+		const submitValue = x + parseEther("1");
+		const fd = feeDistributor.address;
+		await ctx.client.setBalance({
+			address: fd,
+			value: x + parseEther("2")
+		});
+		await ctx.client.impersonateAccount({ address: fd });
+		try {
+			await ctx.client.writeContract({
+				...lido,
+				functionName: "submit",
+				args: [ZERO_ADDRESS],
+				value: submitValue,
+				account: fd,
+				chain: null
+			});
+		} finally {
+			await ctx.client.stopImpersonatingAccount({ address: fd });
+		}
+	}
+	const [slotsPerEpoch, secondsPerSlot, genesisTime] = await ctx.client.readContract({
+		...hashConsensus,
+		functionName: "getChainConfig"
+	});
+	const [initialEpoch, epochsPerFrame] = await ctx.client.readContract({
+		...hashConsensus,
+		functionName: "getFrameConfig"
+	});
+	if (((await ctx.client.getBlock()).timestamp - genesisTime) / secondsPerSlot / slotsPerEpoch < initialEpoch) await warpTo(ctx, genesisTime + 1n + initialEpoch * slotsPerEpoch * secondsPerSlot);
+	const [frameRefSlot] = await ctx.client.readContract({
+		...hashConsensus,
+		functionName: "getCurrentFrame"
+	});
+	const frameStart = genesisTime + (frameRefSlot + slotsPerEpoch * epochsPerFrame + 1n) * secondsPerSlot;
+	if (frameStart > (await ctx.client.getBlock()).timestamp) await warpTo(ctx, frameStart);
+	const [refSlot] = await ctx.client.readContract({
+		...hashConsensus,
+		functionName: "getCurrentFrame"
+	});
+	const consensusVersion = await ctx.client.readContract({
+		...oracle,
+		functionName: "getConsensusVersion"
+	});
+	const data = {
+		consensusVersion,
+		refSlot,
+		treeRoot: report.treeRoot,
+		treeCid: report.treeCid,
+		logCid: report.logCid,
+		distributed: report.distributed,
+		rebate: report.rebate,
+		strikesTreeRoot: strikesTreeRoot(refSlot),
+		strikesTreeCid: `mock-strikes-${refSlot}`
+	};
+	const hash = reportHash(data);
+	let [members] = await ctx.client.readContract({
+		...hashConsensus,
+		functionName: "getFastLaneMembers"
+	});
+	if (members.length === 0) [members] = await ctx.client.readContract({
+		...hashConsensus,
+		functionName: "getMembers"
+	});
+	if (members.length === 0) throw new Error("@sm-lab/recipes: no consensus members to reach quorum");
+	for (const member of members) await actAs(ctx, member, (from) => ctx.client.writeContract({
+		...hashConsensus,
+		functionName: "submitReport",
+		args: [
+			refSlot,
+			hash,
+			consensusVersion
+		],
+		account: from,
+		chain: null
+	}));
+	const contractVersion = await ctx.client.readContract({
+		...oracle,
+		functionName: "getContractVersion"
+	});
+	await actAs(ctx, members[0], (from) => ctx.client.writeContract({
+		...oracle,
+		functionName: "submitReportData",
+		args: [data, contractVersion],
+		account: from,
+		chain: null
+	}));
+	return {
+		submitted: true,
+		refSlot,
+		treeRoot: report.treeRoot,
+		reportHash: hash,
+		members
+	};
+}
+/** keccak256(abi.encode(data)) — encode the 9-field struct as ONE tuple param (see REPORT_DATA_PARAMS). */
+function reportHash(data) {
+	return keccak256(encodeAbiParameters(REPORT_DATA_PARAMS, [data]));
+}
+/**
+* Mock strikes root: `keccak256(abi.encode("mock-strikes", refSlot))` — TWO top-level params
+* (`string`, `uint256`), NOT a tuple. Matches the source's `abi.encode(a, b)`.
+*/
+function strikesTreeRoot(refSlot) {
+	return keccak256(encodeAbiParameters(parseAbiParameters("string, uint256"), ["mock-strikes", refSlot]));
+}
+//#endregion
+//#region src/cl-mock.ts
+/**
+* POST one validator to a running `@sm-lab/cl` `/admin/validators`. Surfaces the mock's
+* `errors[]` and throws unless the single item was accepted.
+*
+* cl-mock returns 200 (clean), 207 (partial — only when `errors.length > 0` AND `accepted > 0`,
+* which is impossible for a single item), or 400 (all rejected, no `accepted` field). For one
+* item the realistic failure is 400, caught by the `!res.ok` clause. The `(accepted ?? 0) < 1`
+* guard is defensive belt-and-braces for a synthetic accepted:0 / missing-`accepted` body the mock
+* never actually emits — the `?? 0` is load-bearing, since a bare `accepted < 1` is `false` for
+* `undefined` and would let such a body through as a silent success.
+*/
+async function setClValidator(clMockUrl, input) {
+	const url = `${clMockUrl.replace(/\/+$/, "")}/admin/validators`;
+	const body = JSON.stringify({
+		pubkey: input.pubkey,
+		status: input.status,
+		...input.effectiveBalanceGwei !== void 0 ? { effective_balance: input.effectiveBalanceGwei.toString() } : {}
+	});
+	const res = await fetch(url, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body
+	});
+	const json = await res.json().catch(() => void 0);
+	if (!res.ok || !json || (json.accepted ?? 0) < 1) {
+		const errs = json?.errors?.length ? ` — ${json.errors.join("; ")}` : "";
+		throw new Error(`@sm-lab/recipes: cl-mock rejected validator (${res.status} ${res.statusText})${errs}`);
+	}
+}
+//#endregion
+//#region src/recipes/cl-activate.ts
+const GWEI_PER_ETH = 1000000000n;
+const BASE_ETH_GWEI = 32n * GWEI_PER_ETH;
+/**
+* Read a key's pubkey + allocated balance on-chain, then mark it `active_ongoing` on a running
+* cl-mock with effective balance = 32 ETH + allocated balance, in gwei. Port of
+* `cl-mock.just:cl-activate`. Diverges from the Solidity helper's integer-ETH truncation
+* (`balances[0] / 1 ether`) by keeping full gwei precision (cl-mock stores `effective_balance`
+* in gwei) — the spec-blessed divergence.
+*/
+async function clActivate(ctx, opts) {
+	if (!ctx.clMockUrl) throw new Error("@sm-lab/recipes: clActivate needs ctx.clMockUrl (a running cl-mock)");
+	const pubkey = await getPubkey(ctx, opts);
+	const effectiveBalanceGwei = BASE_ETH_GWEI + await getKeyBalance(ctx, opts) / GWEI_PER_ETH;
+	await setClValidator(ctx.clMockUrl, {
+		pubkey,
+		status: "active_ongoing",
+		effectiveBalanceGwei
+	});
+	return {
+		pubkey,
+		status: "active_ongoing",
+		effectiveBalanceGwei
+	};
+}
+//#endregion
+export { snapshot as C, operatorInfo as E, revert as S, warpTo as T, nodeOperatorIdBytes as _, setGateAddrs as a, proposeManager as b, cancelPenalty as c, settlePenalty as d, slash as f, keyCountBytes as g, unvet as h, submitRewards as i, compensatePenalty as l, exit as m, setClValidator as n, addBond as o, withdraw as p, makeRewards$1 as r, createBondDebt as s, clActivate as t, reportPenalty as u, confirmManager as v, warpBy as w, proposeReward as x, confirmReward as y };
+
+//# sourceMappingURL=cl-activate-CPqr6v_D.mjs.map