@sm-lab/recipes 0.2.0 → 0.3.0

package/dist/{cl-activate-CPqr6v_D.mjs → exit-request-c0CS5wKu.mjs}

@@ -1,6 +1,6 @@
-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 { C as roleMember, E as resolveGate, S as actAs, T as contract, _ as SETTLE_GENERAL_DELAYED_PENALTY_ROLE, c as getPubkey, g as RESUME_ROLE, h as REPORT_GENERAL_DELAYED_PENALTY_ROLE, m as PAUSE_ROLE, o as getKeyBalance, p as DEFAULT_ADMIN_ROLE, v as SET_TREE_ROLE, x as randomSeed } from "./topup-CuqmB14u.mjs";
+import { encodeAbiParameters, encodePacked, keccak256, maxUint256, numberToHex, parseAbiParameters, parseEther, toBytes, toHex } from "viem";
+import { curatedGateAbi, feeDistributorAbi, feeOracleAbi, hashConsensusAbi, lidoAbi, stakingRouterAbi, vEBOAbi, 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`.) */
@@ -37,6 +37,48 @@ function snapshot(ctx) {
 async function revert(ctx, id) {
 	await ctx.client.revert({ id });
 }
+/**
+* Fund an account on the fork by setting its balance (anvil_setBalance). `amountWei` defaults to
+* 100 ETH. Port of `NodeOperators` `topup`.
+*/
+async function topUpAccount(ctx, opts) {
+	const amountWei = opts.amountWei ?? 100n * 10n ** 18n;
+	await ctx.client.setBalance({
+		address: opts.address,
+		value: amountWei
+	});
+	return {
+		address: opts.address,
+		amountWei
+	};
+}
+//#endregion
+//#region src/recipes/target-limit.ts
+/**
+* Set an operator's target validator limit (StakingRouter-gated). Port of
+* `NodeOperators.targetLimit` → `updateTargetValidatorsLimits(noId, mode, limit)`.
+*/
+async function setTargetLimit(ctx, opts) {
+	if (opts.mode !== 0 && opts.mode !== 1 && opts.mode !== 2) throw new Error(`@sm-lab/recipes: target limit mode must be 0, 1, or 2 (got ${opts.mode})`);
+	const limit = opts.mode === 0 ? 0n : opts.limit ?? 0n;
+	const m = contract(ctx, "module");
+	await actAs(ctx, ctx.addresses.stakingRouter, (from) => ctx.client.writeContract({
+		...m,
+		functionName: "updateTargetValidatorsLimits",
+		args: [
+			opts.noId,
+			BigInt(opts.mode),
+			limit
+		],
+		account: from,
+		chain: null
+	}));
+	return {
+		noId: opts.noId,
+		mode: opts.mode,
+		limit
+	};
+}
 //#endregion
 //#region src/recipes/address-changes.ts
 /** Propose a new manager address for an operator (signed by the current manager). */
@@ -133,6 +175,32 @@ async function exit(ctx, opts) {
 		chain: null
 	}));
 }
+/** Remove `count` keys (default 1) from operator `noId` starting at `keyIndex`, as the operator's manager. */
+async function removeKey(ctx, opts) {
+	const count = opts.count ?? 1n;
+	const m = contract(ctx, "module");
+	const manager = (await ctx.client.readContract({
+		...m,
+		functionName: "getNodeOperator",
+		args: [opts.noId]
+	})).managerAddress;
+	await actAs(ctx, manager, (from) => ctx.client.writeContract({
+		...m,
+		functionName: "removeKeys",
+		args: [
+			opts.noId,
+			opts.keyIndex,
+			count
+		],
+		account: from,
+		chain: null
+	}));
+	return {
+		noId: opts.noId,
+		keyIndex: opts.keyIndex,
+		count
+	};
+}
 //#endregion
 //#region src/recipes/validators.ts
 /** Report a validator slashing for an operator's key (Verifier-gated). `keyIndex` is the storage index. */
@@ -165,6 +233,89 @@ async function withdraw(ctx, opts) {
 		chain: null
 	}));
 }
+/** Effective balance the source reports to mark a key active: 32 ETH + 1 gwei. */
+const ACTIVE_BALANCE = 32n * 10n ** 18n + 10n ** 9n;
+/**
+* Activate `count` deposited-but-not-yet-active keys of an operator (Verifier-gated) by reporting
+* an effective balance of 32 ETH + 1 gwei on each. Skips keys that already have a confirmed
+* balance or are withdrawn. Port of `NodeOperators.activateKeys`. Returns the count activated.
+*/
+async function activateKeys(ctx, opts) {
+	const m = contract(ctx, "module");
+	const { noId, count } = opts;
+	const total = (await ctx.client.readContract({
+		...m,
+		functionName: "getNodeOperator",
+		args: [noId]
+	})).totalDepositedKeys;
+	const eligible = (await Promise.all(Array.from({ length: total }, (_, i) => i).map(async (i) => ({
+		i,
+		confirmed: await ctx.client.readContract({
+			...m,
+			functionName: "getKeyConfirmedBalances",
+			args: [
+				noId,
+				BigInt(i),
+				1n
+			]
+		}),
+		withdrawn: await ctx.client.readContract({
+			...m,
+			functionName: "isValidatorWithdrawn",
+			args: [noId, BigInt(i)]
+		})
+	})))).filter((s) => s.confirmed[0] === 0n && !s.withdrawn).slice(0, count);
+	if (eligible.length < count) throw new Error(`@sm-lab/recipes: operator ${noId} has only ${eligible.length} activatable key(s), need ${count}`);
+	await actAs(ctx, ctx.addresses.Verifier, async (from) => {
+		for (const { i } of eligible) await ctx.client.writeContract({
+			...m,
+			functionName: "reportValidatorBalance",
+			args: [
+				noId,
+				BigInt(i),
+				ACTIVE_BALANCE
+			],
+			account: from,
+			chain: null
+		});
+	});
+	return { activated: eligible.length };
+}
+/**
+* Report an arbitrary CL balance (wei) for one deposited key (Verifier-gated). Validates the key
+* index is in range and not withdrawn. Port of `NodeOperators.reportBalance`.
+*/
+async function reportBalance(ctx, opts) {
+	const m = contract(ctx, "module");
+	const { noId, keyIndex, balanceWei } = opts;
+	const total = (await ctx.client.readContract({
+		...m,
+		functionName: "getNodeOperator",
+		args: [noId]
+	})).totalDepositedKeys;
+	if (keyIndex >= BigInt(total)) throw new Error(`@sm-lab/recipes: key index ${keyIndex} out of bounds (operator ${noId} has ${total} deposited keys)`);
+	if (await ctx.client.readContract({
+		...m,
+		functionName: "isValidatorWithdrawn",
+		args: [noId, keyIndex]
+	})) throw new Error(`@sm-lab/recipes: key ${keyIndex} of operator ${noId} is withdrawn`);
+	await actAs(ctx, ctx.addresses.Verifier, (from) => ctx.client.writeContract({
+		...m,
+		functionName: "reportValidatorBalance",
+		args: [
+			noId,
+			keyIndex,
+			balanceWei
+		],
+		account: from,
+		chain: null
+	}));
+	return {
+		noId,
+		keyIndex,
+		balanceWei
+	};
+}
 //#endregion
 //#region src/recipes/penalties.ts
 /** Report a general delayed penalty against an operator (penalty-reporter role). */
@@ -268,7 +419,7 @@ async function createBondDebt(ctx, opts) {
 }
 //#endregion
 //#region src/recipes/set-gate.ts
-/** Default gate selector per module: cm → 'po' (CuratedGates[0]); csm → 'ics' (VettedGate). */
+/** Default gate selector per module: cm → 'po' (CuratedGatePO); csm → 'ics' (IcsGate). */
 function defaultSelector(ctx) {
 	return ctx.module === "cm" ? "po" : "ics";
 }
@@ -444,7 +595,7 @@ const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 * 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)");
+const REPORT_DATA_PARAMS$1 = 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
@@ -581,7 +732,7 @@ async function submitRewards(ctx, report) {
 }
 /** 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]));
+	return keccak256(encodeAbiParameters(REPORT_DATA_PARAMS$1, [data]));
 }
 /**
 * Mock strikes root: `keccak256(abi.encode("mock-strikes", refSlot))` — TWO top-level params
@@ -626,6 +777,14 @@ async function setClValidator(clMockUrl, input) {
 const GWEI_PER_ETH = 1000000000n;
 const BASE_ETH_GWEI = 32n * GWEI_PER_ETH;
 /**
+* Effective balance of an active validator, in gwei: 32 ETH + the key's on-chain allocated balance
+* (sub-gwei dust floored). Shared by `clActivate` (`active_ongoing`) and `exitRequest`'s optional
+* cl-mock flip (`active_exiting`) so both bridges report the same balance for the same key.
+*/
+async function activeEffectiveBalanceGwei(ctx, opts) {
+	return BASE_ETH_GWEI + await getKeyBalance(ctx, opts) / 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
@@ -635,7 +794,7 @@ const BASE_ETH_GWEI = 32n * GWEI_PER_ETH;
 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;
+	const effectiveBalanceGwei = await activeEffectiveBalanceGwei(ctx, opts);
 	await setClValidator(ctx.clMockUrl, {
 		pubkey,
 		status: "active_ongoing",
@@ -648,6 +807,255 @@ async function clActivate(ctx, opts) {
 	};
 }
 //#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 };
+//#region src/recipes/pause.ts
+/**
+* Resolve a pause target keyword to a contract handle. `module` and `accounting` are reserved;
+* anything else is a gate selector resolved via `resolveGate` (ics/idvtc for csm; po…iodcp/index
+* for cm; 0x… for either).
+*/
+function resolveTarget(ctx, target) {
+	if (target === "module") {
+		const m = contract(ctx, "module");
+		return {
+			address: m.address,
+			abi: m.abi
+		};
+	}
+	if (target === "accounting") {
+		const a = contract(ctx, "Accounting");
+		return {
+			address: a.address,
+			abi: a.abi
+		};
+	}
+	const abi = ctx.module === "cm" ? curatedGateAbi : vettedGateAbi;
+	return {
+		address: resolveGate(ctx, target),
+		abi
+	};
+}
+/** Pause a target (module | accounting | gate selector). Idempotent: no-op if already paused. */
+async function pause(ctx, opts) {
+	const t = resolveTarget(ctx, opts.target);
+	if (await ctx.client.readContract({
+		...t,
+		functionName: "isPaused"
+	})) return {
+		target: opts.target,
+		address: t.address,
+		paused: true
+	};
+	const admin = await roleMember(ctx, t, DEFAULT_ADMIN_ROLE);
+	await actAs(ctx, admin, async (from) => {
+		await ctx.client.writeContract({
+			...t,
+			functionName: "grantRole",
+			args: [PAUSE_ROLE, admin],
+			account: from,
+			chain: null
+		});
+		await ctx.client.writeContract({
+			...t,
+			functionName: "pauseFor",
+			args: [maxUint256],
+			account: from,
+			chain: null
+		});
+	});
+	return {
+		target: opts.target,
+		address: t.address,
+		paused: true
+	};
+}
+/** Resume a target (module | accounting | gate selector). Idempotent: no-op if not paused. */
+async function resume(ctx, opts) {
+	const t = resolveTarget(ctx, opts.target);
+	if (!await ctx.client.readContract({
+		...t,
+		functionName: "isPaused"
+	})) return {
+		target: opts.target,
+		address: t.address,
+		paused: false
+	};
+	const admin = await roleMember(ctx, t, DEFAULT_ADMIN_ROLE);
+	await actAs(ctx, admin, async (from) => {
+		await ctx.client.writeContract({
+			...t,
+			functionName: "grantRole",
+			args: [RESUME_ROLE, admin],
+			account: from,
+			chain: null
+		});
+		await ctx.client.writeContract({
+			...t,
+			functionName: "resume",
+			account: from,
+			chain: null
+		});
+	});
+	return {
+		target: opts.target,
+		address: t.address,
+		paused: false
+	};
+}
+//#endregion
+//#region src/recipes/exit-request.ts
+/** DATA_FORMAT_LIST — the single supported VEBO exit-request data format. */
+const DATA_FORMAT = 1n;
+/** processing deadline offset — `block.timestamp + 1 days` (matches the source). */
+const ONE_DAY = 86400n;
+/**
+* The VEBO `ReportData` struct as ONE tuple parameter (components in declaration order, verified
+* against `fixtures/receipts/src/abi/VEBO.ts`). `abi.encode(report)` for a single struct ==
+* ABI-encoding one tuple parameter — do NOT flatten into 5 top-level params (that drops the tuple
+* offset and changes the hash). Same trap `rewards.ts` documents for the fee-oracle report.
+*/
+const REPORT_DATA_PARAMS = parseAbiParameters("(uint256 consensusVersion, uint256 refSlot, uint256 requestsCount, uint256 dataFormat, bytes data)");
+/**
+* Request a single validator exit via the Validators Exit Bus Oracle. Port of
+* `NodeOperators.s.sol:_exitRequest`. Reads the key pubkey + discovers the module id, packs the
+* 64-byte exit request, then fakes VEBO consensus by impersonating the consensus contract
+* (`submitConsensusReport`) and submits the data as the VEBO admin (`grantRole` + `submitReportData`).
+*
+* Module-agnostic: `contract(ctx,'module')` picks CSModule/CuratedModule by `ctx.module`, and the
+* module-id scan matches that same address — no csm/cm branching.
+*
+* Optional cl-mock reflection (beyond the source): when `ctx.clMockUrl` is set, the validator is
+* additionally marked `active_exiting` on the running cl-mock (mirroring `clActivate`); skipped
+* silently otherwise.
+*
+* Deliberate divergences from the source (identical on-chain effect):
+* - reuses the VEBO admin as the `submitReportData` submitter (source grants a fresh address);
+*   `grantRole` is idempotent so re-granting the admin never reverts.
+* - scans ALL staking-module ids (source's `for (i=len-1; i>0; i--)` skips index 0).
+*/
+async function exitRequest(ctx, opts) {
+	const validatorIndex = opts.validatorIndex ?? 900000n;
+	const m = contract(ctx, "module");
+	const vebo = {
+		address: ctx.addresses.vebo,
+		abi: vEBOAbi
+	};
+	const pubkey = await ctx.client.readContract({
+		...m,
+		functionName: "getSigningKeys",
+		args: [
+			opts.noId,
+			opts.keyIndex,
+			1n
+		]
+	});
+	const moduleId = await resolveModuleId(ctx, m.address);
+	const data = encodePacked([
+		"bytes3",
+		"bytes5",
+		"bytes8",
+		"bytes"
+	], [
+		numberToHex(moduleId, { size: 3 }),
+		numberToHex(opts.noId, { size: 5 }),
+		numberToHex(validatorIndex, { size: 8 }),
+		pubkey
+	]);
+	const refSlot = (await ctx.client.readContract({
+		...vebo,
+		functionName: "getConsensusReport"
+	}))[1] + 1n;
+	const report = {
+		consensusVersion: await ctx.client.readContract({
+			...vebo,
+			functionName: "getConsensusVersion"
+		}),
+		refSlot,
+		requestsCount: 1n,
+		dataFormat: DATA_FORMAT,
+		data
+	};
+	const reportHash = keccak256(encodeAbiParameters(REPORT_DATA_PARAMS, [report]));
+	const consensus = await ctx.client.readContract({
+		...vebo,
+		functionName: "getConsensusContract"
+	});
+	const deadline = (await ctx.client.getBlock()).timestamp + ONE_DAY;
+	await actAs(ctx, consensus, (from) => ctx.client.writeContract({
+		...vebo,
+		functionName: "submitConsensusReport",
+		args: [
+			reportHash,
+			refSlot,
+			deadline
+		],
+		account: from,
+		chain: null
+	}));
+	const admin = await roleMember(ctx, vebo, DEFAULT_ADMIN_ROLE);
+	const submitRole = await ctx.client.readContract({
+		...vebo,
+		functionName: "SUBMIT_DATA_ROLE"
+	});
+	const contractVersion = await ctx.client.readContract({
+		...vebo,
+		functionName: "getContractVersion"
+	});
+	await actAs(ctx, admin, async (from) => {
+		await ctx.client.writeContract({
+			...vebo,
+			functionName: "grantRole",
+			args: [submitRole, admin],
+			account: from,
+			chain: null
+		});
+		await ctx.client.writeContract({
+			...vebo,
+			functionName: "submitReportData",
+			args: [report, contractVersion],
+			account: from,
+			chain: null
+		});
+	});
+	let clStatus;
+	if (ctx.clMockUrl) {
+		const effectiveBalanceGwei = await activeEffectiveBalanceGwei(ctx, opts);
+		await setClValidator(ctx.clMockUrl, {
+			pubkey,
+			status: "active_exiting",
+			effectiveBalanceGwei
+		});
+		clStatus = "active_exiting";
+	}
+	return {
+		noId: opts.noId,
+		keyIndex: opts.keyIndex,
+		validatorIndex,
+		moduleId,
+		refSlot,
+		reportHash,
+		pubkey,
+		clStatus
+	};
+}
+/** Find the staking-module id whose registered address is `moduleAddress` (scans ALL ids). */
+async function resolveModuleId(ctx, moduleAddress) {
+	const sr = {
+		address: ctx.addresses.stakingRouter,
+		abi: stakingRouterAbi
+	};
+	const ids = await ctx.client.readContract({
+		...sr,
+		functionName: "getStakingModuleIds"
+	});
+	const idx = (await Promise.all(ids.map((id) => ctx.client.readContract({
+		...sr,
+		functionName: "getStakingModule",
+		args: [id]
+	})))).findIndex((mod) => mod.stakingModuleAddress.toLowerCase() === moduleAddress.toLowerCase());
+	if (idx === -1) throw new Error(`@sm-lab/recipes: module ${moduleAddress} not registered in the StakingRouter`);
+	return ids[idx];
+}
+//#endregion
+export { snapshot as A, nodeOperatorIdBytes as C, proposeReward as D, proposeManager as E, warpBy as M, warpTo as N, setTargetLimit as O, operatorInfo as P, keyCountBytes as S, confirmReward as T, slash as _, setClValidator as a, removeKey as b, setGateAddrs as c, cancelPenalty as d, compensatePenalty as f, reportBalance as g, activateKeys as h, clActivate as i, topUpAccount as j, revert as k, addBond as l, settlePenalty as m, pause as n, makeRewards$1 as o, reportPenalty as p, resume as r, submitRewards as s, exitRequest as t, createBondDebt as u, withdraw as v, confirmManager as w, unvet as x, exit as y };
 
-//# sourceMappingURL=cl-activate-CPqr6v_D.mjs.map
+//# sourceMappingURL=exit-request-c0CS5wKu.mjs.map