@sm-lab/recipes 0.2.0

package/dist/context-BiYdAnKn.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-BiYdAnKn.d.mts","names":[],"sources":["../src/client.ts","../src/context.ts"],"mappings":";;;;;;AAQA;;;iBAAgB,UAAA,CAAW,MAAA,0BAAc,MAAA,gBAAA,aAAA,yDAAA,aAAA;;;;;;oFAQkwQ,yBAAA,CAAA,OAAA,MAAA,OAAA,gBAAA,yBAAA,CAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;msBAAmgI,2BAAA,CAAA,QAAA,EAAA,SAAA,EAAA,MAAA,EAAA,SAAA,EAAA,OAAA,EAAA,UAAA,EAAA,KAAA,kBAAA,OAAA,gBAAA,2BAAA,CAAA,QAAA,EAAA,SAAA,EAAA,MAAA,EAAA,SAAA,EAAA,OAAA,EAAA,UAAA,EAAA,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAA6iT,wBAAA,iBAAA,OAAA,gBAAA,wBAAA;mDAA8lC,kCAAA,iBAAA,OAAA,gBAAA,kCAAA;;;;;;;;;;;;;;;;;2fAAwmoB,iBAAA,CAAA,QAAA,EAAA,SAAA,EAAA,MAAA,EAAA,SAAA,EAAA,OAAA,kBAAA,OAAA,gBAAA,iBAAA,CAAA,QAAA,EAAA,SAAA,EAAA,MAAA,EAAA,SAAA,EAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KADrh2C,YAAA,GAAe,UAAU,QAAQ,UAAA;;;AAP7C;AAAA,KCWY,iBAAA,GAAoB,WAAA;EAC9B,aAAA,EAAe,GAAA;EACf,IAAA,EAAM,GAAA;EACN,IAAA,EAAM,GAAA;EACN,eAAA,EAAiB,GAAA;EACjB,MAAA,EAAQ,GAAA;AAAA;AAAA,UAGO,GAAA;EACf,MAAA,EAAQ,YAAA;EACR,MAAA,EAAQ,UAAA;EACR,SAAA,EAAW,iBAAA;EACX,SAAA;AAAA;AAAA,UAGe,cAAA;EACf,MAAA,EAAQ,UAAA;;EAER,MAAA;;EAEA,MAAA,GAAS,YAAA;;EAET,SAAA,GAAY,WAAA;EACZ,SAAA;AAAA;AAAA,KAGU,eAAA;AAAA,KACA,cAAA;AAAA,KACA,YAAA,GAAe,eAAA,GAAkB,cAAc;;;;;;iBA4BrC,OAAA,CAAQ,IAAA,EAAM,cAAA,GAAiB,OAAA,CAAQ,GAAA;AAAA,cA4CvD,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMD,UAAA,gBAA0B,MAAM;AAAA,iBAErB,QAAA,CAAS,GAAA,EAAK,GAAA,EAAK,IAAA;EAAmB,OAAA,EAAS,GAAA;EAAK,GAAA,SAAY,WAAA;AAAA;AAAA,iBAChE,QAAA,WAAmB,UAAA,EACjC,GAAA,EAAK,GAAA,EACL,IAAA,EAAM,CAAA;EACH,OAAA,EAAS,GAAA;EAAK,GAAA,UAAa,MAAA,EAAQ,CAAA;AAAA;;;;;;;iBAuBxB,WAAA,CAAY,GAAA,EAAK,GAAA,EAAK,QAAA,WAAmB,GAAG"}

package/dist/index.d.mts

@@ -0,0 +1,393 @@
+import { a as GateSelector, c as contract, d as makeClient, i as Ctx, l as resolveGate, n as ConnectOptions, o as ResolvedAddresses, r as CsmGateSelector, s as connect, t as CmGateSelector, u as RecipeClient } from "./context-BiYdAnKn.mjs";
+import { Abi } from "viem";
+import { Hex } from "@sm-lab/receipts";
+import { TreeDump } from "@sm-lab/merkle";
+
+//#region src/act-as.d.ts
+/**
+ * Run `fn` as a privileged account `who` on the fork. Funds it (anvil_setBalance),
+ * unlocks it (anvil_impersonateAccount), runs the body, and always stops impersonating.
+ * Replaces every Solidity `broadcast*` modifier. `who` is a RAW address — pass a contract
+ * address (e.g. the module, verifier, stakingRouter) or a role member resolved via roleMember.
+ */
+declare function actAs<T>(ctx: Ctx, who: Hex, fn: (from: Hex) => Promise<T>): Promise<T>;
+/** Read `getRoleMember(role, 0)` — the canonical admin/governance member of an AccessControl role. */
+declare function roleMember(ctx: Ctx, target: {
+  address: Hex;
+  abi: Abi;
+}, role: Hex): Promise<Hex>;
+//#endregion
+//#region src/keys.d.ts
+/**
+ * Deterministic real BLS validator keys derived from a fixed mnemonic at a seed-derived
+ * startIndex. Produces genuine 48-byte G1 pubkeys + 96-byte G2 BLS signatures — NOT
+ * keccak-expanded pseudo-keys. Pass a fixed `seed` for reproducible tests.
+ *
+ * The seed maps to a `startIndex` via `keccak256(seed) % 2^20` so different seeds yield
+ * non-overlapping key ranges (1M range >> any realistic `count`).
+ */
+declare function randomKeys(count: number, seed?: Hex): Promise<{
+  publicKeys: Hex[];
+  signatures: Hex[];
+  packedKeys: Hex;
+  packedSignatures: Hex;
+}>;
+//#endregion
+//#region src/recipes/add-keys.d.ts
+interface AddKeysOptions {
+  noId: bigint;
+  count: number;
+  /** Injectable seed for reproducible keys. */
+  seed?: Hex;
+}
+interface AddKeysResult {
+  publicKeys: Hex[];
+}
+/**
+ * Add `count` fresh validator keys to operator `noId`, paying the required bond, as the
+ * operator's manager. Returns the generated pubkeys. (Port of `NodeOperators.addKeys`.)
+ */
+declare function addKeys(ctx: Ctx, opts: AddKeysOptions): Promise<AddKeysResult>;
+//#endregion
+//#region src/recipes/operator-info.d.ts
+/** Decoded NodeOperator (abitype: uint32/uint8 → number, address → Hex, bool → boolean). */
+interface OperatorInfo {
+  totalAddedKeys: number;
+  totalWithdrawnKeys: number;
+  totalDepositedKeys: number;
+  totalVettedKeys: number;
+  stuckValidatorsCount: number;
+  depositableValidatorsCount: number;
+  targetLimit: number;
+  targetLimitMode: number;
+  totalExitedKeys: number;
+  enqueuedCount: number;
+  managerAddress: Hex;
+  proposedManagerAddress: Hex;
+  rewardAddress: Hex;
+  proposedRewardAddress: Hex;
+  extendedManagerPermissions: boolean;
+  usedPriorityQueue: boolean;
+}
+/** Typed read of a node operator's on-chain record. (Port of `NodeOperators.operatorInfo`.) */
+declare function operatorInfo(ctx: Ctx, opts: {
+  noId: bigint;
+}): Promise<OperatorInfo>;
+//#endregion
+//#region src/recipes/chain.d.ts
+/** Advance fork time by `seconds` and mine a block (evm_increaseTime + evm_mine). */
+declare function warpBy(ctx: Ctx, seconds: number | bigint): Promise<void>;
+/**
+ * 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).
+ */
+declare function warpTo(ctx: Ctx, timestamp: number | bigint): Promise<void>;
+/** Take an anvil state snapshot; returns the snapshot id (evm_snapshot). */
+declare function snapshot(ctx: Ctx): Promise<Hex>;
+/** Revert the fork to a snapshot id (evm_revert). */
+declare function revert(ctx: Ctx, id: Hex): Promise<void>;
+//#endregion
+//#region src/roles.d.ts
+/** OZ AccessControl default admin role (all-zero bytes32). */
+declare const DEFAULT_ADMIN_ROLE: Hex;
+/** MerkleGate: keccak256("SET_TREE_ROLE"). */
+declare const SET_TREE_ROLE: `0x${string}`;
+/** PausableWithRoles: keccak256("RESUME_ROLE"). */
+declare const RESUME_ROLE: `0x${string}`;
+/** BaseModule: keccak256("REPORT_GENERAL_DELAYED_PENALTY_ROLE"). */
+declare const REPORT_GENERAL_DELAYED_PENALTY_ROLE: `0x${string}`;
+/** BaseModule: keccak256("SETTLE_GENERAL_DELAYED_PENALTY_ROLE"). */
+declare const SETTLE_GENERAL_DELAYED_PENALTY_ROLE: `0x${string}`;
+//#endregion
+//#region src/recipes/address-changes.d.ts
+/** Propose a new manager address for an operator (signed by the current manager). */
+declare function proposeManager(ctx: Ctx, opts: {
+  noId: bigint;
+  proposed: Hex;
+}): Promise<void>;
+/** Confirm the proposed manager address (signed by the proposed manager). */
+declare function confirmManager(ctx: Ctx, opts: {
+  noId: bigint;
+}): Promise<void>;
+/** Propose a new reward address (signed by the MANAGER, per the on-chain access rule). */
+declare function proposeReward(ctx: Ctx, opts: {
+  noId: bigint;
+  proposed: Hex;
+}): Promise<void>;
+/** Confirm the proposed reward address (signed by the proposed reward address). */
+declare function confirmReward(ctx: Ctx, opts: {
+  noId: bigint;
+}): Promise<void>;
+//#endregion
+//#region src/encode.d.ts
+/** A node-operator id packed as the on-chain `bytes8(uint64)` (big-endian). */
+declare function nodeOperatorIdBytes(noId: bigint): Hex;
+/** A key count packed as the on-chain `bytes16(uint128)` (big-endian). */
+declare function keyCountBytes(count: bigint): Hex;
+//#endregion
+//#region src/recipes/vetting.d.ts
+/** Set an operator's vetted-keys count (StakingRouter-gated). `vettedKeys` is the new absolute count. */
+declare function unvet(ctx: Ctx, opts: {
+  noId: bigint;
+  vettedKeys: bigint;
+}): Promise<void>;
+/** Set an operator's exited-keys count (StakingRouter-gated). `exitedKeys` is the new absolute total. */
+declare function exit(ctx: Ctx, opts: {
+  noId: bigint;
+  exitedKeys: bigint;
+}): Promise<void>;
+//#endregion
+//#region src/recipes/deposit.d.ts
+/**
+ * Deposit up to `count` of an operator's depositable keys (StakingRouter-gated). Flushes pending
+ * deposit-info, caps to the module's depositable count, and returns the number actually deposited
+ * (derived from the keys `obtainDepositData` hands back). Throws if a positive request finds nothing
+ * depositable — the Solidity helper silently no-ops there. (Port of `NodeOperators.deposit`.)
+ */
+declare function deposit(ctx: Ctx, opts: {
+  count: number | bigint;
+}): Promise<{
+  deposited: bigint;
+}>;
+//#endregion
+//#region src/recipes/topup.d.ts
+/**
+ * Top up the allocated balance of a single deposited key (StakingRouter-gated). Validates the key
+ * exists and is not withdrawn, then writes a one-element `allocateDeposits` for it. Port of
+ * `NodeOperators.increaseAllocatedBalance` — returns the `amountWei` it allocated.
+ */
+declare function increaseAllocatedBalance(ctx: Ctx, opts: {
+  noId: bigint;
+  keyIndex: bigint;
+  amountWei: bigint;
+}): Promise<{
+  amountWei: bigint;
+}>;
+/**
+ * Top up every not-yet-allocated, not-withdrawn deposited key of an operator, one at a time in
+ * strict ascending key-index order — `TopUpQueueOps` enforces a global FIFO queue head, so the
+ * writes must be sequential and ordered (capped at `MAX_TOPUP_PER_KEY` per key). Port of
+ * `NodeOperators.topUpActiveKeys` — returns the count it topped up.
+ */
+declare function topUpActiveKeys(ctx: Ctx, opts: {
+  noId: bigint;
+}): Promise<{
+  toppedUp: number;
+}>;
+//#endregion
+//#region src/recipes/validators.d.ts
+/** One withdrawn-validator record for `reportRegularWithdrawnValidators`. */
+interface WithdrawnValidatorInfo {
+  nodeOperatorId: bigint;
+  keyIndex: bigint;
+  exitBalance: bigint;
+  slashingPenalty: bigint;
+  isSlashed: boolean;
+}
+/** Report a validator slashing for an operator's key (Verifier-gated). `keyIndex` is the storage index. */
+declare function slash(ctx: Ctx, opts: {
+  noId: bigint;
+  keyIndex: bigint;
+}): Promise<void>;
+/** Report a regular validator withdrawal for one key (Verifier-gated). isSlashed = slashingPenalty > 0. */
+declare function withdraw(ctx: Ctx, opts: {
+  noId: bigint;
+  keyIndex: bigint;
+  exitBalance: bigint;
+  slashingPenalty?: bigint;
+}): Promise<void>;
+//#endregion
+//#region src/recipes/penalties.d.ts
+/** Report a general delayed penalty against an operator (penalty-reporter role). */
+declare function reportPenalty(ctx: Ctx, opts: {
+  noId: bigint;
+  amount: bigint;
+  penaltyType?: Hex;
+  details?: string;
+}): Promise<void>;
+/** Cancel a previously-reported general delayed penalty (penalty-reporter role). */
+declare function cancelPenalty(ctx: Ctx, opts: {
+  noId: bigint;
+  amount: bigint;
+}): Promise<void>;
+/**
+ * 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.
+ */
+declare function settlePenalty(ctx: Ctx, opts: {
+  noId: bigint;
+  maxAmount?: bigint;
+}): Promise<void>;
+/** Compensate (pay off) an operator's general delayed penalty — signed by the operator manager. */
+declare function compensatePenalty(ctx: Ctx, opts: {
+  noId: bigint;
+}): Promise<void>;
+//#endregion
+//#region src/recipes/bond.d.ts
+/** Top up an operator's bond with ETH (permissionless `depositETH`), signed by the manager. */
+declare function addBond(ctx: Ctx, opts: {
+  noId: bigint;
+  amount: bigint;
+}): Promise<void>;
+/**
+ * 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.
+ */
+declare function createBondDebt(ctx: Ctx, opts: {
+  noId: bigint;
+  amount: bigint;
+}): Promise<{
+  penaltyCovered: boolean;
+}>;
+//#endregion
+//#region src/recipes/set-gate.d.ts
+interface SetGateAddrsOptions {
+  /** Whitelisted addresses to encode into the gate's merkle tree. */
+  addresses: Hex[];
+  /**
+   * Gate selector passed to resolveGate. csm: 'ics' (default) | 'idvtc'; cm:
+   * 'po'|'pto'|'pgo'|'do'|'eeo'|'iodc'|'iodcp' (default 'po') or a gate index; any: a raw 0x… address.
+   */
+  selector?: GateSelector | string;
+  /** Skip IPFS pinning by supplying a precomputed cid (hermetic tests do this). */
+  cid?: string;
+}
+interface SetGateAddrsResult {
+  treeRoot: Hex;
+  treeCid: string;
+}
+/**
+ * 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.
+ */
+declare function setGateAddrs(ctx: Ctx, opts: SetGateAddrsOptions): Promise<SetGateAddrsResult>;
+//#endregion
+//#region src/recipes/rewards.d.ts
+interface RewardsReport {
+  /** tree.root, or ZERO_ROOT when there are no leaves. */
+  treeRoot: Hex;
+  /** pinned (or opts.treeCid); '' when treeRoot is zero. */
+  treeCid: string;
+  /** pinned (or opts.logCid); '' when treeRoot is zero. */
+  logCid: string;
+  /** Sum of all per-operator distributed rewards this frame. */
+  distributed: bigint;
+  /** Always 0n in the mock (matches the source). */
+  rebate: bigint;
+  /** In-memory OZ tree dump (uint256-as-string → JSON-safe) for tests / re-pin. Undefined when empty. */
+  treeDump?: TreeDump;
+  /** Cumulative leaves AFTER carry-forward + this frame's deltas, EXCLUDING the pad. */
+  cumulatives: Map<bigint, bigint>;
+}
+interface MakeRewardsOptions {
+  /** Injectable seed → deterministic per-key reward draw. Omit for fresh randomness. */
+  seed?: Hex;
+  /** Carry-forward input: the previous cumulative tree as a Map (or [noId, shares][]). */
+  previousCumulatives?: Map<bigint, bigint> | [bigint, bigint][];
+  /** Hermetic escape hatch: skip pinning the tree, use this cid. */
+  treeCid?: string;
+  /** Hermetic escape hatch: skip pinning the log, use this cid. */
+  logCid?: string;
+  /** Injectable clock (unix seconds) for the report log's block_timestamp. Defaults Date.now()/1000. */
+  now?: number;
+}
+/**
+ * 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.
+ */
+declare function makeRewards(ctx: Ctx, opts?: MakeRewardsOptions): Promise<RewardsReport>;
+interface SubmitRewardsResult {
+  /** false when treeRoot is zero (a legitimate empty-report skip). */
+  submitted: boolean;
+  /** present when submitted: the consensus frame's refSlot. */
+  refSlot?: bigint;
+  /** echo of report.treeRoot when submitted. */
+  treeRoot?: Hex;
+  /** the keccak256(abi.encode(data)) reached consensus on. */
+  reportHash?: Hex;
+  /** the consensus members that submitted (fast-lane, or the getMembers fallback). */
+  members?: Hex[];
+}
+/**
+ * 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.
+ */
+declare function submitRewards(ctx: Ctx, report: RewardsReport): Promise<SubmitRewardsResult>;
+//#endregion
+//#region src/recipes/cl-activate.d.ts
+interface ClActivateResult {
+  pubkey: Hex;
+  status: 'active_ongoing';
+  effectiveBalanceGwei: bigint;
+}
+/**
+ * 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.
+ */
+declare function clActivate(ctx: Ctx, opts: {
+  noId: bigint;
+  keyIndex: bigint;
+}): Promise<ClActivateResult>;
+//#endregion
+//#region src/recipes/reads.d.ts
+/** One key's 48-byte pubkey from on-chain storage. Throws if no key exists at `keyIndex`. */
+declare function getPubkey(ctx: Ctx, opts: {
+  noId: bigint;
+  keyIndex: bigint;
+}): Promise<Hex>;
+/** Allocated balance (wei) for one key. */
+declare function getKeyBalance(ctx: Ctx, opts: {
+  noId: bigint;
+  keyIndex: bigint;
+}): Promise<bigint>;
+//#endregion
+//#region src/cl-mock.d.ts
+interface SetValidatorInput {
+  pubkey: Hex;
+  /** Only status clActivate sets; cl-mock's full union lives in the app, not here. */
+  status: 'active_ongoing';
+  /** Serialized to a gwei integer string on the wire; omitted when undefined. */
+  effectiveBalanceGwei?: bigint;
+}
+/**
+ * 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.
+ */
+declare function setClValidator(clMockUrl: string, input: SetValidatorInput): Promise<void>;
+//#endregion
+export { type AddKeysOptions, type AddKeysResult, type ClActivateResult, type CmGateSelector, type ConnectOptions, type CsmGateSelector, type Ctx, DEFAULT_ADMIN_ROLE, type GateSelector, type MakeRewardsOptions, type OperatorInfo, REPORT_GENERAL_DELAYED_PENALTY_ROLE, RESUME_ROLE, type RecipeClient, type ResolvedAddresses, type RewardsReport, SETTLE_GENERAL_DELAYED_PENALTY_ROLE, SET_TREE_ROLE, type SetGateAddrsOptions, type SetGateAddrsResult, type SetValidatorInput, type SubmitRewardsResult, type WithdrawnValidatorInfo, actAs, addBond, addKeys, cancelPenalty, clActivate, compensatePenalty, confirmManager, confirmReward, connect, contract, createBondDebt, deposit, exit, getKeyBalance, getPubkey, increaseAllocatedBalance, keyCountBytes, makeClient, makeRewards, nodeOperatorIdBytes, operatorInfo, proposeManager, proposeReward, randomKeys, reportPenalty, resolveGate, revert, roleMember, setClValidator, setGateAddrs, settlePenalty, slash, snapshot, submitRewards, topUpActiveKeys, unvet, warpBy, warpTo, withdraw };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/act-as.ts","../src/keys.ts","../src/recipes/add-keys.ts","../src/recipes/operator-info.ts","../src/recipes/chain.ts","../src/roles.ts","../src/recipes/address-changes.ts","../src/encode.ts","../src/recipes/vetting.ts","../src/recipes/deposit.ts","../src/recipes/topup.ts","../src/recipes/validators.ts","../src/recipes/penalties.ts","../src/recipes/bond.ts","../src/recipes/set-gate.ts","../src/recipes/rewards.ts","../src/recipes/cl-activate.ts","../src/recipes/reads.ts","../src/cl-mock.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { _ as contract, a as deposit, c as RESUME_ROLE, d as addKeys, f as randomKeys, g as connect, h as roleMember, i as getPubkey, l as SETTLE_GENERAL_DELAYED_PENALTY_ROLE, m as actAs, n as topUpActiveKeys, o as DEFAULT_ADMIN_ROLE, r as getKeyBalance, s as REPORT_GENERAL_DELAYED_PENALTY_ROLE, t as increaseAllocatedBalance, u as SET_TREE_ROLE, v as resolveGate, y as makeClient } from "./topup-B2NzJV7_.mjs";
+import { C as snapshot, E as operatorInfo, S as revert, T as warpTo, _ as nodeOperatorIdBytes, a as setGateAddrs, b as proposeManager, c as cancelPenalty, d as settlePenalty, f as slash, g as keyCountBytes, h as unvet, i as submitRewards, l as compensatePenalty, m as exit, n as setClValidator, o as addBond, p as withdraw, r as makeRewards, s as createBondDebt, t as clActivate, u as reportPenalty, v as confirmManager, w as warpBy, x as proposeReward, y as confirmReward } from "./cl-activate-CPqr6v_D.mjs";
+export { DEFAULT_ADMIN_ROLE, REPORT_GENERAL_DELAYED_PENALTY_ROLE, RESUME_ROLE, SETTLE_GENERAL_DELAYED_PENALTY_ROLE, SET_TREE_ROLE, actAs, addBond, addKeys, cancelPenalty, clActivate, compensatePenalty, confirmManager, confirmReward, connect, contract, createBondDebt, deposit, exit, getKeyBalance, getPubkey, increaseAllocatedBalance, keyCountBytes, makeClient, makeRewards, nodeOperatorIdBytes, operatorInfo, proposeManager, proposeReward, randomKeys, reportPenalty, resolveGate, revert, roleMember, setClValidator, setGateAddrs, settlePenalty, slash, snapshot, submitRewards, topUpActiveKeys, unvet, warpBy, warpTo, withdraw };