@panoptic-eng/sdk 1.0.20 → 1.0.22

package/dist/zodiac/index.js

@@ -0,0 +1,949 @@
+import { keccak256, toBytes, toFunctionSelector } from "viem";
+
+//#region src/zodiac/rolesAbi.ts
+/** Minimal Zodiac Roles v2 modifier ABI used by the scoping/apply flows. */
+const rolesV2Abi = [
+	{
+		type: "function",
+		name: "assignRoles",
+		stateMutability: "nonpayable",
+		inputs: [
+			{
+				name: "module",
+				type: "address"
+			},
+			{
+				name: "roleKeys",
+				type: "bytes32[]"
+			},
+			{
+				name: "memberOf",
+				type: "bool[]"
+			}
+		],
+		outputs: []
+	},
+	{
+		type: "function",
+		name: "scopeTarget",
+		stateMutability: "nonpayable",
+		inputs: [{
+			name: "roleKey",
+			type: "bytes32"
+		}, {
+			name: "targetAddress",
+			type: "address"
+		}],
+		outputs: []
+	},
+	{
+		type: "function",
+		name: "scopeFunction",
+		stateMutability: "nonpayable",
+		inputs: [
+			{
+				name: "roleKey",
+				type: "bytes32"
+			},
+			{
+				name: "targetAddress",
+				type: "address"
+			},
+			{
+				name: "selector",
+				type: "bytes4"
+			},
+			{
+				name: "conditions",
+				type: "tuple[]",
+				components: [
+					{
+						name: "parent",
+						type: "uint8"
+					},
+					{
+						name: "paramType",
+						type: "uint8"
+					},
+					{
+						name: "operator",
+						type: "uint8"
+					},
+					{
+						name: "compValue",
+						type: "bytes"
+					}
+				]
+			},
+			{
+				name: "options",
+				type: "uint8"
+			}
+		],
+		outputs: []
+	},
+	{
+		type: "function",
+		name: "allowFunction",
+		stateMutability: "nonpayable",
+		inputs: [
+			{
+				name: "roleKey",
+				type: "bytes32"
+			},
+			{
+				name: "targetAddress",
+				type: "address"
+			},
+			{
+				name: "selector",
+				type: "bytes4"
+			},
+			{
+				name: "options",
+				type: "uint8"
+			}
+		],
+		outputs: []
+	},
+	{
+		type: "function",
+		name: "setTransactionUnwrapper",
+		stateMutability: "nonpayable",
+		inputs: [
+			{
+				name: "to",
+				type: "address"
+			},
+			{
+				name: "selector",
+				type: "bytes4"
+			},
+			{
+				name: "adapter",
+				type: "address"
+			}
+		],
+		outputs: []
+	}
+];
+
+//#endregion
+//#region src/zodiac/applySteps.ts
+/**
+* Apply scope steps to a Roles v2 modifier sequentially, aborting on the
+* first revert so a partially-applied role is never silently left behind.
+* The wallet must be the modifier's owner.
+*/
+async function applyScopeSteps(params) {
+	const { publicClient, walletClient, rolesModifier, steps, log = console.log } = params;
+	for (const step of steps) {
+		log(`→ ${step.name}`);
+		const hash = await walletClient.writeContract({
+			address: rolesModifier,
+			abi: rolesV2Abi,
+			functionName: step.functionName,
+			args: step.args,
+			...params.fees ?? {}
+		});
+		const receipt = await publicClient.waitForTransactionReceipt({
+			hash,
+			...params.timeoutMs ? { timeout: params.timeoutMs } : {}
+		});
+		log(`  ${receipt.status} ${hash}`);
+		if (receipt.status !== "success") throw new Error(`step "${step.name}" reverted (tx ${hash}); aborting before later steps`);
+	}
+}
+
+//#endregion
+//#region src/zodiac/conditions.ts
+/** True for a 0x-prefixed, 20-byte (40 hex char) address. */
+function isHexAddress(v) {
+	return /^0x[0-9a-fA-F]{40}$/.test(v);
+}
+/** 32-byte left-padded address as an EqualTo Static compValue. */
+function addressEqualCompValue(addr) {
+	if (!isHexAddress(addr)) throw new Error(`addressEqualCompValue: expected a 20-byte hex address, got "${addr}"`);
+	return `0x${addr.slice(2).toLowerCase().padStart(64, "0")}`;
+}
+/**
+* Operator.Custom compValue: adapter address in the leading 20 bytes, the
+* trailing 12 bytes are passed to the adapter verbatim as `extra`.
+*/
+function customCompValue(adapter, extra = "0x") {
+	if (!isHexAddress(adapter)) throw new Error(`customCompValue: adapter must be a 20-byte hex address, got "${adapter}"`);
+	if (!/^0x([0-9a-fA-F]{2})*$/.test(extra)) throw new Error(`customCompValue: extra must be 0x-prefixed, even-length hex, got "${extra}"`);
+	if (extra.length - 2 > 24) throw new Error("customCompValue: extra must be at most 12 bytes");
+	const extraHex = extra.slice(2).padEnd(24, "0");
+	return `0x${adapter.slice(2).toLowerCase()}${extraHex}`;
+}
+/**
+* Encode a uint96 mint-size cap as the `bytes12 extra` of a pair-condition
+* compValue (0n = uncapped). The adapters read it as `uint96(extra)`, i.e.
+* big-endian right-aligned in the 12 bytes.
+*/
+function sizeCapExtra(cap) {
+	if (cap < 0n || cap >= 1n << 96n) throw new Error("size cap must fit in uint96");
+	return `0x${cap.toString(16).padStart(24, "0")}`;
+}
+
+//#endregion
+//#region src/zodiac/constants.ts
+/**
+* Zodiac Roles Modifier v2 enum ordinals.
+*
+* Verified against gnosisguild/zodiac-modifier-roles `contracts/Types.sol`
+* (commit c343958ab7317b31d8c4aec790606d950ea21eed) and the deployed v2.1
+* mastercopy 0x9646fDAD06d3e24444381f44362a3B0eB343D337. Keep in sync with the
+* modifier version the Safe actually runs.
+*/
+const ParameterType = {
+	None: 0,
+	Static: 1,
+	Dynamic: 2,
+	Tuple: 3,
+	Array: 4,
+	Calldata: 5,
+	AbiEncoded: 6
+};
+const Operator = {
+	Pass: 0,
+	And: 1,
+	Or: 2,
+	Nor: 3,
+	Matches: 5,
+	ArraySome: 6,
+	ArrayEvery: 7,
+	ArraySubset: 8,
+	EqualToAvatar: 15,
+	EqualTo: 16,
+	GreaterThan: 17,
+	LessThan: 18,
+	SignedIntGreaterThan: 19,
+	SignedIntLessThan: 20,
+	Bitmask: 21,
+	Custom: 22,
+	WithinAllowance: 28,
+	EtherWithinAllowance: 29,
+	CallWithinAllowance: 30
+};
+/**
+* Canonical adapter addresses — deterministic CREATE2 (factory
+* 0x4e59b44847b379578588920cA78FbF26c0B4956C, salt
+* keccak256("panoptic.zodiac-modules.v1")), so they depend only on the
+* bytecode: same on every chain, deployer-independent, verifiable with
+* `cast code` against a local `forge build`. The adapters are stateless and
+* immutable (no owner/storage/upgradability). Recompute via
+* `forge script scripts/DeployAdapters.s.sol` after any source change.
+*/
+const CANONICAL_ADAPTERS = {
+	RollerCondition: "0x7b2402F7Ff7fFe0970D383dE1C6AF8892B87523a",
+	SizeAdjusterCondition: "0x72494B2A0C5a69Dd0154386c2F4Af0b38a24C400"
+};
+const ExecutionOptions = {
+	None: 0,
+	Send: 1,
+	DelegateCall: 2,
+	Both: 3
+};
+
+//#endregion
+//#region src/zodiac/roles/dispatchCustomRole.ts
+/** PanopticPool.dispatch — TokenId is a uint256 value type. */
+const DISPATCH_SELECTOR = toFunctionSelector("dispatch(uint256[],uint256[],uint128[],int24[3][],bool,uint256)");
+/** Deterministic per-role keys; override via env/config if a Safe needs several instances. */
+function roleKey(name) {
+	return keccak256(toBytes(`panoptic.role.${name}.v1`));
+}
+/**
+* ConditionFlat tree for a dispatch-scoped role whose whole authorization
+* logic lives in an on-chain `ICustomCondition` adapter (Operator.Custom).
+*
+* The Custom node is attached to arg0 (`positionIdList`): Roles hands the
+* adapter the FULL calldata regardless of attachment point, and the adapter
+* decodes `positionIdList`/`positionSizes` itself. The remaining nodes are the
+* structural template `Integrity.sol` requires (Calldata and Array nodes must
+* describe their children; see buildLoanOnlyDispatchConditions for the shape).
+*/
+function buildDispatchCustomConditions(adapter, extra = "0x") {
+	const compValue = customCompValue(adapter, extra);
+	return [
+		{
+			parent: 0,
+			paramType: ParameterType.Calldata,
+			operator: Operator.Matches,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Array,
+			operator: Operator.Custom,
+			compValue
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Array,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Array,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Array,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 1,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 2,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 3,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 4,
+			paramType: ParameterType.Tuple,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 10,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 10,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 10,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		}
+	];
+}
+/** assignRoles → scopeTarget → scopeFunction steps for an adapter-gated dispatch role. */
+function buildDispatchCustomRoleSteps(params) {
+	const { roleName, member, pool, adapter, extra } = params;
+	return [
+		{
+			name: `assignRoles(${roleName} member)`,
+			functionName: "assignRoles",
+			args: [
+				member,
+				[params.roleKey],
+				[true]
+			]
+		},
+		{
+			name: "scopeTarget(pool)",
+			functionName: "scopeTarget",
+			args: [params.roleKey, pool]
+		},
+		{
+			name: `scopeFunction(dispatch, ${roleName} custom adapter)`,
+			functionName: "scopeFunction",
+			args: [
+				params.roleKey,
+				pool,
+				DISPATCH_SELECTOR,
+				buildDispatchCustomConditions(adapter, extra),
+				ExecutionOptions.None
+			]
+		}
+	];
+}
+
+//#endregion
+//#region src/zodiac/roles/deleverager.ts
+/**
+* Deleverager role: burn the Safe's existing positions only — never mint.
+*
+* Enforced with plain static conditions, no adapter and no state oracle:
+* every `positionSizes` entry must be 0. A size-0 entry either burns a held
+* position or reverts the whole dispatch — a size-0 mint is impossible
+* (option legs trip `ChunkHasZeroLiquidity` in the SFPM; pure-loan tokenIds
+* die in the end-of-dispatch solvency pass / positions-hash validation).
+*
+* Trade-off vs an oracle-based check: the key cannot settle premium (settle
+* requires `sizes[i] == storedSize`, unknowable pre-execution). Strictly a
+* risk-reduction key: safe for a watchdog keeper or dead-man's-switch.
+*/
+const DELEVERAGER_ROLE_KEY = roleKey("deleverager");
+const ZERO_WORD = `0x${"0".repeat(64)}`;
+function buildDeleveragerDispatchConditions() {
+	return [
+		{
+			parent: 0,
+			paramType: ParameterType.Calldata,
+			operator: Operator.Matches,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Array,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Array,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Array,
+			operator: Operator.ArrayEvery,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Array,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 1,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 2,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 3,
+			paramType: ParameterType.Static,
+			operator: Operator.EqualTo,
+			compValue: ZERO_WORD
+		},
+		{
+			parent: 4,
+			paramType: ParameterType.Tuple,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 10,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 10,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 10,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		}
+	];
+}
+function buildDeleveragerRoleSteps(params) {
+	const key = params.roleKey ?? DELEVERAGER_ROLE_KEY;
+	return [
+		{
+			name: "assignRoles(deleverager member)",
+			functionName: "assignRoles",
+			args: [
+				params.member,
+				[key],
+				[true]
+			]
+		},
+		{
+			name: "scopeTarget(pool)",
+			functionName: "scopeTarget",
+			args: [key, params.pool]
+		},
+		{
+			name: "scopeFunction(dispatch, burn-only: all sizes == 0)",
+			functionName: "scopeFunction",
+			args: [
+				key,
+				params.pool,
+				DISPATCH_SELECTOR,
+				buildDeleveragerDispatchConditions(),
+				ExecutionOptions.None
+			]
+		}
+	];
+}
+
+//#endregion
+//#region src/zodiac/tokenIdMask.ts
+/**
+* Bit-field masks over the Panoptic v2 tokenId layout, mirroring
+* `contracts/lib/TokenIdMasks.sol` (kept in lockstep by golden unit tests).
+*
+* Layout (packages/panoptic-v2-core/contracts/types/TokenId.sol):
+*   - bits [0, 64)        poolId
+*   - each leg is 48 bits, starting at 64 + legIndex*48, packing
+*     asset(+0,1b) | optionRatio(+1,7b) | isLong(+8) | tokenType(+9)
+*     | riskPartner(+10,2b) | strike(+12,24b) | width(+36,12b)
+*/
+const POOL_ID_SIZE = 64n;
+const LEG_SIZE = 48n;
+const MAX_LEGS = 4n;
+/** Mask with 1-bits over a `bits`-wide field at `fieldOffset` in every leg. */
+function legFieldMask(fieldOffset, bits) {
+	const field = (1n << bits) - 1n;
+	let mask = 0n;
+	for (let leg = 0n; leg < MAX_LEGS; leg++) mask |= field << POOL_ID_SIZE + leg * LEG_SIZE + fieldOffset;
+	return mask;
+}
+/** Mask with 1-bits over every leg's 12-bit width field. */
+function loanWidthFieldsMask() {
+	return legFieldMask(36n, 12n);
+}
+/** Mask with 1-bits over every leg's 24-bit strike field. */
+function strikeFieldsMask() {
+	return legFieldMask(12n, 24n);
+}
+/** Mask with 1-bits over every leg's 7-bit optionRatio field. */
+function optionRatioFieldsMask() {
+	return legFieldMask(1n, 7n);
+}
+/** True iff every leg of the tokenId has width == 0 (a pure loan/credit). */
+function isPureLoanTokenId(tokenId) {
+	return (tokenId & loanWidthFieldsMask()) === 0n;
+}
+/** The 32-byte mask + expected value for a Zodiac Roles v2 Bitmask condition. */
+function loanBitmaskCondition() {
+	const mask = loanWidthFieldsMask();
+	const toBytes32 = (v) => `0x${v.toString(16).padStart(64, "0")}`;
+	return {
+		mask: toBytes32(mask),
+		expected: toBytes32(0n)
+	};
+}
+
+//#endregion
+//#region src/zodiac/roles/loanHedger.ts
+/**
+* Loan-only hedger role scope (migrated from apps/hedger-bot scripts/lib).
+*
+* ⚠️  VALIDATE ON A FORK BEFORE MAINNET. The ConditionFlat encoding below is
+* security-critical. Dry-run `scopeFunction` on an anvil/Tenderly fork and
+* assert that the role CAN mint/burn a pure width=0 loan via dispatch and
+* CANNOT dispatch a tokenId with any width>0 leg.
+*
+* The scope constrains PanopticPool.dispatch(positionIdList, finalPositionIdList,
+* positionSizes, tickAndSpreadLimits, usePremiaAsCollateral, builderCode) so that
+* EVERY element of `positionIdList` (arg 0 — the tokenIds actually minted/burned)
+* is a pure loan: `tokenId & widthFieldsMask == 0`. All other args pass freely;
+* `finalPositionIdList` is intentionally NOT constrained (it legitimately contains
+* the user's option positions that remain open).
+*/
+/**
+* Bitmask compValue layout (Roles v2 `PermissionChecker._bitmask`): a 32-byte
+* word packing `uint16 shift | bytes15 mask | bytes15 expected`, where `shift`
+* is a BYTE offset from the start (left / most-significant end) of the value
+* and the 15-byte mask is applied LEFT-aligned to `bytes32(value[shift:])`.
+*
+* The four 12-bit width fields span tokenId bits 100–255 (leg 3's width sits in
+* the top two bytes), which is wider than one 15-byte window. So the loan
+* constraint is expressed as TWO windows AND-ed together:
+*   - shift 0:  tokenId bytes 0..14  (bits 136–255) — covers legs 1, 2, 3
+*   - shift 17: tokenId bytes 17..31 (bits 0–119)   — covers leg 0
+* Bytes 15–16 (bits 120–135) contain no width bits.
+*/
+const LOAN_BITMASK_WINDOW_SHIFTS = [0, 17];
+function loanBitmaskCompValueAt(shiftBytes) {
+	const { mask } = loanBitmaskCondition();
+	const maskBytes = mask.slice(2);
+	const window = maskBytes.slice(shiftBytes * 2, shiftBytes * 2 + 30).padEnd(30, "0");
+	const shift = shiftBytes.toString(16).padStart(4, "0");
+	return `0x${shift}${window}${"0".repeat(30)}`;
+}
+/**
+* Build the ConditionFlat[] tree scoping dispatch to loan-only positionIdList.
+*
+* Roles v2 `Integrity.sol` requirements honored here:
+*   - BFS order: parent indices must be non-decreasing (NotBFS).
+*   - Every Array-typed node needs >=1 child describing the element type
+*     (UnsuitableChildCount); ArrayEvery needs exactly 1.
+*   - And nodes use ParameterType.None and an empty compValue.
+*/
+function buildLoanOnlyDispatchConditions() {
+	return [
+		{
+			parent: 0,
+			paramType: ParameterType.Calldata,
+			operator: Operator.Matches,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Array,
+			operator: Operator.ArrayEvery,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Array,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Array,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Array,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 1,
+			paramType: ParameterType.None,
+			operator: Operator.And,
+			compValue: "0x"
+		},
+		{
+			parent: 2,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 3,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 4,
+			paramType: ParameterType.Tuple,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 7,
+			paramType: ParameterType.Static,
+			operator: Operator.Bitmask,
+			compValue: loanBitmaskCompValueAt(LOAN_BITMASK_WINDOW_SHIFTS[0])
+		},
+		{
+			parent: 7,
+			paramType: ParameterType.Static,
+			operator: Operator.Bitmask,
+			compValue: loanBitmaskCompValueAt(LOAN_BITMASK_WINDOW_SHIFTS[1])
+		},
+		{
+			parent: 10,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 10,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 10,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		}
+	];
+}
+/** ERC4626 CollateralTracker withdraw(uint256 assets, address receiver, address owner). */
+const WITHDRAW_SELECTOR = "0xb460af94";
+/** ERC4626 CollateralTracker deposit(uint256 assets, address receiver). */
+const DEPOSIT_SELECTOR = "0x6e553f65";
+/** Uniswap UniversalRouter execute(bytes,bytes[],uint256). */
+const EXECUTE_SELECTOR = "0x3593564c";
+/**
+* Scope CT.withdraw so tokens can only be pulled to the Safe: receiver == owner
+* == Safe. Without this, a compromised bot key could withdraw the Safe's
+* collateral to an arbitrary address — this is the critical cross-pool scope.
+*/
+function buildWithdrawConditions(safe) {
+	const safeEq = addressEqualCompValue(safe);
+	return [
+		{
+			parent: 0,
+			paramType: ParameterType.Calldata,
+			operator: Operator.Matches,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Static,
+			operator: Operator.EqualTo,
+			compValue: safeEq
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Static,
+			operator: Operator.EqualTo,
+			compValue: safeEq
+		}
+	];
+}
+/** Scope CT.deposit so the shares are credited to the Safe: receiver == Safe. */
+function buildDepositConditions(safe) {
+	return [
+		{
+			parent: 0,
+			paramType: ParameterType.Calldata,
+			operator: Operator.Matches,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Static,
+			operator: Operator.EqualTo,
+			compValue: addressEqualCompValue(safe)
+		}
+	];
+}
+/**
+* Router `execute` is scoped with a calldata template — see
+* apps/hedger-bot/scripts/lib/routerScope.ts (hedging-specific, not migrated).
+*/
+const ROUTER_EXECUTE_SELECTOR_ONLY = EXECUTE_SELECTOR;
+
+//#endregion
+//#region src/zodiac/roles/maintenance.ts
+/**
+* Maintenance role: full `dispatchFrom` access — settle premium on, force-
+* exercise, and liquidate third-party accounts using the Safe's capital.
+* No adapter needed; the pool itself hash-validates the position lists.
+*
+* The only pin is `account != Safe` (Nor(EqualTo(safe))) so the maintenance
+* key can never force-exercise or liquidate the Safe's own book.
+* `positionIdListFrom` (the caller's solvency list) is intentionally
+* unconstrained — the Safe may legitimately hold option positions.
+*
+* dispatchFrom is payable ⇒ ExecutionOptions.Send.
+*/
+const MAINTENANCE_ROLE_KEY = roleKey("maintenance");
+/** LeftRightUnsigned is a uint256 value type. */
+const DISPATCH_FROM_SELECTOR = toFunctionSelector("dispatchFrom(uint256[],address,uint256[],uint256[],uint256)");
+function buildDispatchFromConditions(safe) {
+	return [
+		{
+			parent: 0,
+			paramType: ParameterType.Calldata,
+			operator: Operator.Matches,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Array,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.None,
+			operator: Operator.Nor,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Array,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Array,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 0,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 1,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 2,
+			paramType: ParameterType.Static,
+			operator: Operator.EqualTo,
+			compValue: addressEqualCompValue(safe)
+		},
+		{
+			parent: 3,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		},
+		{
+			parent: 4,
+			paramType: ParameterType.Static,
+			operator: Operator.Pass,
+			compValue: "0x"
+		}
+	];
+}
+function buildMaintenanceRoleSteps(params) {
+	const key = params.roleKey ?? MAINTENANCE_ROLE_KEY;
+	return [
+		{
+			name: "assignRoles(maintenance member)",
+			functionName: "assignRoles",
+			args: [
+				params.member,
+				[key],
+				[true]
+			]
+		},
+		{
+			name: "scopeTarget(pool)",
+			functionName: "scopeTarget",
+			args: [key, params.pool]
+		},
+		{
+			name: "scopeFunction(dispatchFrom, account != safe, Send)",
+			functionName: "scopeFunction",
+			args: [
+				key,
+				params.pool,
+				DISPATCH_FROM_SELECTOR,
+				buildDispatchFromConditions(params.safe),
+				ExecutionOptions.Send
+			]
+		}
+	];
+}
+
+//#endregion
+//#region src/zodiac/roles/roller.ts
+/**
+* Roller role: close one position and reopen it identical-except-strike (roll
+* out-of-range positions back into range). Enforced on-chain by the stateless
+* `RollerCondition` adapter (strike-mask equality + one-burn-one-mint shape).
+*
+* The reopened size is bounded by `sizeCap` (0n = uncapped, leaving only
+* dispatch's solvency check as the ceiling) — there is no pre-state oracle,
+* so "same size as before" cannot be enforced.
+*/
+const ROLLER_ROLE_KEY = roleKey("roller");
+function buildRollerRoleSteps(params) {
+	return buildDispatchCustomRoleSteps({
+		roleName: "roller",
+		roleKey: params.roleKey ?? ROLLER_ROLE_KEY,
+		member: params.member,
+		pool: params.pool,
+		adapter: params.adapter,
+		extra: sizeCapExtra(params.sizeCap ?? 0n)
+	});
+}
+
+//#endregion
+//#region src/zodiac/roles/sizeAdjuster.ts
+/**
+* Size-adjuster role: replace one position with an identical-except-optionRatio
+* one — reduce a short whose long side was purchased, or grow a long as more
+* options are sold. Enforced on-chain by the stateless `SizeAdjusterCondition`
+* adapter (ratio-mask equality + one-burn-one-mint shape).
+*
+* Without a pre-state oracle the relative notional cap is not enforceable;
+* set `sizeCap` (uint96, 0n = uncapped) to bound the mint size absolutely.
+*/
+const SIZE_ADJUSTER_ROLE_KEY = roleKey("size-adjuster");
+function buildSizeAdjusterRoleSteps(params) {
+	return buildDispatchCustomRoleSteps({
+		roleName: "size-adjuster",
+		roleKey: params.roleKey ?? SIZE_ADJUSTER_ROLE_KEY,
+		member: params.member,
+		pool: params.pool,
+		adapter: params.adapter,
+		extra: sizeCapExtra(params.sizeCap ?? 0n)
+	});
+}
+
+//#endregion
+export { CANONICAL_ADAPTERS, DELEVERAGER_ROLE_KEY, DEPOSIT_SELECTOR, DISPATCH_FROM_SELECTOR, DISPATCH_SELECTOR, EXECUTE_SELECTOR, ExecutionOptions, LOAN_BITMASK_WINDOW_SHIFTS, MAINTENANCE_ROLE_KEY, Operator, ParameterType, ROLLER_ROLE_KEY, ROUTER_EXECUTE_SELECTOR_ONLY, SIZE_ADJUSTER_ROLE_KEY, WITHDRAW_SELECTOR, addressEqualCompValue, applyScopeSteps, buildDeleveragerDispatchConditions, buildDeleveragerRoleSteps, buildDepositConditions, buildDispatchCustomConditions, buildDispatchCustomRoleSteps, buildDispatchFromConditions, buildLoanOnlyDispatchConditions, buildMaintenanceRoleSteps, buildRollerRoleSteps, buildSizeAdjusterRoleSteps, buildWithdrawConditions, customCompValue, isPureLoanTokenId, legFieldMask, loanBitmaskCompValueAt, loanBitmaskCondition, loanWidthFieldsMask, optionRatioFieldsMask, roleKey, rolesV2Abi, sizeCapExtra, strikeFieldsMask };
+//# sourceMappingURL=index.js.map