hookr-sdk 0.2.0 → 1.0.0

package/dist/core/abi.js

@@ -0,0 +1,455 @@
+import { parseAbi } from "viem";
+import { ARTIFACT_ABIS } from "./generated.js";
+export const CORE_STRUCTS = [
+    "struct PoolKey { address currency0; address currency1; uint24 fee; int24 tickSpacing; address hooks; }",
+    "struct Caps { uint24 maxLpFeePips; uint24 maxQuoteTakePips; uint16 maxSubjectTakeBps; }",
+    "struct PoolConfig { address subject; address quote; address rules; address advisory; address liquidityOwner; uint24 baseLpFeePips; Caps caps; uint32 rulesGasLimit; uint32 advisoryGasLimit; uint8 advisoryPhases; bool advisoryFailOpen; bytes32 policyId; }",
+    "struct RulesConfig { uint40 guardEndBlock; uint24 maxFeePips; uint24 snipeTaxPips; uint24 snipeFloorPips; uint16 snipeDecaySeconds; uint16 dynamicFeeSens; uint16 burnBps; uint16 lpBps; uint16 potBps; uint16 royaltyBps; uint16 protocolShareBps; uint32 potEveryNBuys; uint128 maxBuyQuoteAmount; uint128 potMinBuyQuote; address royaltyTo; address integrator; }",
+    "struct Swap { PoolKey key; bool zeroForOne; int128 amountSpecified; uint128 amountBound; uint160 sqrtPriceLimitX96; address recipient; uint256 deadline; }",
+    "struct Token { address existing; string name; string symbol; uint256 supply; bytes32 salt; }",
+    "struct RecaptureConfig { bool on; uint16 traderBps; uint16 lpBps; uint32 period; uint16 maxPrizeBps; uint16 potReleaseBps; uint128 minBuyQuote; uint32 releaseBlocks; }",
+    "struct Member { address quote; int24 tickSpacing; uint160 sqrtPriceX96; int24 tickLower; int24 tickUpper; uint128 liquidity; uint128 amount0Max; uint128 amount1Max; PoolConfig config; RulesConfig rules; RecaptureConfig recapture; }",
+    "struct Position { PoolKey key; int24 tickLower; int24 tickUpper; uint128 liquidity; }",
+    "struct CoreReceipt { bytes32 id; bytes32 policyHash; address payer; address beneficiary; address inputCurrency; address outputCurrency; uint256 inputAmount; uint256 outputAmount; uint256 actualQuote; uint256 quoteFee; uint256 quoteRefund; uint256 subjectBurn; uint24 lpFeePips; }",
+];
+export const launcherAbi = parseAbi([
+    ...CORE_STRUCTS,
+    "function launch(Token token,address rootAddress,Member[] members,uint256 deadline) payable returns(bytes32 familyId,address subject)",
+    "function launchAdvised(Token token,address rootAddress,Member[] members,bytes[] advisoryConfigs,uint256 deadline) payable returns(bytes32 familyId,address subject)",
+    "struct DevBuy { uint8 member; uint128 quoteIn; uint128 minSubjectOut; uint32 lockBlocks; }",
+    "function launchWithBuy(Token token,address rootAddress,Member[] members,bytes[] advisoryConfigs,DevBuy buy,uint256 deadline) payable returns(bytes32 familyId,address subject,uint256 subjectOut)",
+    // r31: the Multi-pool launch with each member's knobs, up to one dev buy per member, a retained cap and an opening
+    // check.
+    "struct MemberKnobs { uint16 subjectWeightBps; uint16 dynamicFeeLiquidityDivisor; uint64 lockEndBlock; uint16 windowSeconds; uint16 resetSeconds; uint16 carryBps; uint24 moveTicks; uint8 snipeCurve; }",
+    "struct OpeningCheck { uint16 toleranceBps; PoolKey[] references; }",
+    "struct LaunchParams { Token token; address root; Member[] members; MemberKnobs[] knobs; bytes[] advisoryConfigs; DevBuy[] buys; uint16 maxRetainedBps; OpeningCheck opening; uint256 deadline; string tagline; string logoURI; }",
+    "function launchFamily(LaunchParams p) payable returns(bytes32 familyId,address subject,uint256 subjectOut)",
+    "event FamilyWeights(bytes32 indexed familyId,uint16[8] weightsBps)",
+    "event FamilyRetained(bytes32 indexed familyId,uint256 retained,uint256 cap)",
+    "event FamilyOpeningChecked(bytes32 indexed familyId,uint16 toleranceBps,bytes32 referencesHash)",
+    "event LaunchFeePaid(bytes32 indexed familyId,address indexed target,uint256 fee)",
+    "error InvalidFamily()",
+    "error InvalidFunding()",
+    "error InvalidRetainedCap(uint256 maxRetainedBps)",
+    "error RetainedAboveCap(uint256 held,uint256 cap)",
+    "error InvalidWeights()",
+    "error WeightMismatch(uint8 member,uint256 budget,uint256 expected)",
+    "error InvalidDivisor(uint8 member,uint256 divisor)",
+    "error InvalidLockEnd(uint8 member,uint256 lockEndBlock)",
+    "error OpeningToleranceOutOfRange(uint16 toleranceBps)",
+    "error OpeningReferenceMismatch(uint8 member)",
+    "error OpeningReferenceUninitialized(uint8 member)",
+    "error OpeningOutsideTolerance(uint8 member,uint256 converted,uint256 low,uint256 high)",
+    "function launchBuyPool() view returns(bytes32)",
+    "event DevBuyExecuted(bytes32 indexed familyId,bytes32 indexed poolId,address indexed buyer,uint8 member,uint256 quoteIn,uint256 subjectOut,uint160 sqrtPriceX96,uint160 sqrtPriceAfterX96,uint256 lockedUntil)",
+    "error InvalidDevBuy()",
+    "error DevBuyAboveCap(uint256 held,uint256 cap)",
+    "error DevBuySlippage(uint256 subjectOut,uint256 minSubjectOut)",
+    "error DevBuyPartialFill(uint256 paid,uint256 quoteIn)",
+    "function releaseId() pure returns(uint256)",
+    "function DYNAMIC_FEE_LIQUIDITY_DIVISOR() view returns(uint256)",
+    "function withdraw(bytes32 familyId,uint8 member,uint128 liquidity,uint256 min0,uint256 min1,address recipient,uint256 deadline) returns(uint256 amount0,uint256 amount1)",
+    "function withdrawWithClaims(bytes32 familyId,uint8 member,uint128 liquidity,uint256 min0,uint256 min1,address recipient,uint8 claims,uint256 deadline) returns(uint256 amount0,uint256 amount1)",
+    "function transferFamily(bytes32 familyId,address newOwner,uint16 claims)",
+    "function acceptFamily(bytes32 familyId)",
+    "function pendingFamilyOwner(bytes32 familyId) view returns(address pendingOwner,uint16 claims)",
+    "function principalLockedUntil(bytes32 familyId) view returns(uint256)",
+    "function memberKey(address subject,address quote,int24 tickSpacing,address rootAddress) view returns(PoolKey key,bool available)",
+    "function redeem(address currency,uint256 amount,address recipient)",
+    "function sweep(address currency,address recipient) returns(uint256 amount)",
+    "function position(bytes32 familyId,uint8 member) view returns(Position)",
+    "function predictToken(address creator,Token token) view returns(address)",
+    "function addLiquidity(bytes32 familyId,uint8 member,uint128 liquidity,uint128 max0,uint128 max1,uint256 deadline) payable returns(uint256 amount0,uint256 amount1)",
+    "event LiquidityAdded(bytes32 indexed familyId,uint8 member,uint128 liquidity,uint256 amount0,uint256 amount1)",
+    "event LPFeesCollected(bytes32 indexed familyId,uint8 member,bytes32 indexed poolId,address indexed owner,address recipient,uint256 amount0,uint256 amount1)",
+    "function familyOwner(bytes32) view returns(address)",
+    "event FamilyLaunched(bytes32 indexed familyId,address indexed owner,address indexed subject,address root)",
+    "event MemberLaunched(bytes32 indexed familyId,uint8 member,bytes32 indexed poolId,address quote,uint128 liquidity)",
+    "event FamilyTransferStarted(bytes32 indexed familyId,address indexed owner,address indexed pendingOwner,uint16 claims)",
+    "event FamilyTransferred(bytes32 indexed familyId,address indexed owner)",
+    "event LiquidityRemoved(bytes32 indexed familyId,uint8 member,uint128 liquidity,uint256 amount0,uint256 amount1)",
+]);
+/**
+ * IHookrLaunchFee (r31): the launch fee every launch's native value carries, served by HookrLauncher's fallback from its
+ * linked library HookrLaunchChecks (so outside the launcher's ABI), with the registry owner's propose and accept and
+ * the owner's or guardian's clear.
+ */
+export const launchFeeAbi = parseAbi([
+    "function launchFee() view returns(uint256 fee,address treasury,uint256 pendingFee,address pendingTreasury,uint256 readyAt)",
+    "function proposeLaunchFee(uint96 fee,address treasury)",
+    "function acceptLaunchFee()",
+    "function clearLaunchFee()",
+]);
+export const routerAbi = parseAbi([
+    ...CORE_STRUCTS,
+    "function swap(Swap params,address engagement,uint256[] campaigns) payable returns(uint256 amountIn,uint256 amountOut)",
+    "event SwapExecuted(bytes32 indexed poolId,address indexed payer,address indexed recipient,uint256 amountIn,uint256 amountOut)",
+    "function swapFor(Swap params,address payer,uint256 outputFee,address feeRecipient,address engagement,uint256[] campaigns) returns(uint256 amountIn,uint256 amountOut)",
+    // A swap for `payer` vouched by the root's admitted GATE (r31; HookrFamilyRouter is the release's gate). `data` goes to
+    // the gate only.
+    "function swapGated(Swap params,address payer,address gate,bytes data,address engagement,uint256[] campaigns) payable returns(uint256 amountIn,uint256 amountOut)",
+    "function sweep(address currency,address to) returns(uint256 amount)",
+    "function forwarder() view returns(address)",
+    "function forwarderCodeHash() view returns(bytes32)",
+    "function releaseId() pure returns(uint256)",
+]);
+export const quoterAbi = parseAbi([
+    ...CORE_STRUCTS,
+    "function quote(Swap params,address payer) returns(CoreReceipt receipt)",
+    // `quote` with the payer's arb recapture claim and the simulation's gas (a cost, not a gas limit).
+    "function quoteDetailed(Swap params,address payer) returns(CoreReceipt receipt,uint256 traderClaim,uint256 gasEstimate)",
+    // Uniswap IV4Quoter's single-pool shape for aggregators: `msg.sender` is the payer and the recipient, and hookData
+    // must be empty.
+    "struct QuoteExactSingleParams { PoolKey poolKey; bool zeroForOne; uint128 exactAmount; bytes hookData; }",
+    "function quoteExactInputSingle(QuoteExactSingleParams params) returns(uint256 amountOut,uint256 gasEstimate)",
+    "function quoteExactOutputSingle(QuoteExactSingleParams params) returns(uint256 amountIn,uint256 gasEstimate)",
+    // The committed simulation; only the quoter itself can call it, inside its own unlock.
+    "struct Request { Swap params; address payer; }",
+    "function simulate(Request request) returns(CoreReceipt receipt)",
+    "error InvalidQuote()",
+    "error InvalidHookData()",
+    "error NotEnoughLiquidity(bytes32 poolId)",
+    "error QuoteDetail(CoreReceipt receipt,uint256 traderClaim)",
+    "function releaseId() pure returns(uint256)",
+]);
+/** PoolManager's IPoolManager.SwapParams, as HookrRoot.quoteLeg takes it. */
+export const SWAP_PARAMS_STRUCT = "struct SwapParams { bool zeroForOne; int256 amountSpecified; uint160 sqrtPriceLimitX96; }";
+/**
+ * HookrRoot.quoteLeg (selector 0xba835629): the LP fee, quote take and recipient the pool's advisory asks of the
+ * caller's recapture leg, refusing where the leg would be refused. Only the pool's lane executor may ask, and only a
+ * staticcall inside the frame right before the leg sees the leg's state; an eth_call is an estimate. `amount0` and
+ * `amount1` are the pool's own swap delta; both zero skip the after phase (`afterSkipped`), and `afterPreSwap` flags
+ * an after phase asked on the state before the swap.
+ */
+const QUOTE_LEG = "function quoteLeg(PoolKey key,SwapParams params,int128 amount0,int128 amount1) returns(uint24 lpFeePips,uint24 takePips,address recipient,bool fullPath,bool afterSkipped,bool afterPreSwap)";
+export const rootAbi = parseAbi([
+    ...CORE_STRUCTS,
+    SWAP_PARAMS_STRUCT,
+    QUOTE_LEG,
+    "function poolConfig(bytes32 id) view returns(PoolConfig)",
+    "function policyHash(bytes32 id) view returns(bytes32)",
+    "function curatedRouter() view returns(address)",
+    "function releaseId() pure returns(uint256)",
+    "event PoolOpened(bytes32 indexed id,address indexed launcher,bytes32 indexed policyHash,address rules,address advisory)",
+]);
+/**
+ * The recapture lane surface HookrRoot answers (IHookrLaneRoot): laneOf and the lane module through its fallback,
+ * quoteLeg as its own function, and the lane events. The mechanism is an arb recapture; the event names keep the
+ * contracts' identifiers.
+ */
+export const laneRootAbi = parseAbi([
+    ...CORE_STRUCTS,
+    SWAP_PARAMS_STRUCT,
+    QUOTE_LEG,
+    "function laneOf(bytes32 id) view returns(address executor,bytes32 codeHash,uint16 partnerBps,bytes32 family,bool on,uint32 gasCap,uint256 gasFloor)",
+    "function laneModule() view returns(address module,bytes32 codeHash)",
+    "event PoolLane(bytes32 indexed id,address indexed executor,bytes32 codeHash,uint16 partnerBps,bytes32 family)",
+    "event CorrectionSucceeded(bytes32 indexed id,uint8 indexed phase,address indexed trader,uint256 reportedProfit,uint256 pushed,address currency)",
+    "event CorrectionFailed(bytes32 indexed id,uint8 indexed phase,address indexed trader,bytes4 reason)",
+    "event LaneCodeChanged(bytes32 indexed id,uint8 indexed phase)",
+]);
+/**
+ * IHookrLaneExecutor: the call a lane makes, selector 0x488301cd, in both phases of a lane pool's swap (before the
+ * swap is quoted and after it settles). `rebateRecipient` is the swap's authenticated payer in the after phase, zero
+ * in the before phase and for an unauthenticated swap. An executor on the three-argument ABI of r19 to r21
+ * (`uint256 swappedQuote` third, 0x481c5bd1) fails every frame. Since r30 (`docs/security/audits/r30.md`; r29's view,
+ * 0x0c1cd60a, had no direction) the root asks `checkV3PoolsMev(subject, quote, swapper, zeroForOne)` (0x9e97c424) by
+ * staticcall with at most 200,000 gas right after the before-phase call, `zeroForOne` being the swap's own direction on
+ * the lane pool in its key's order, and refuses the swap (`MevCallbackRefused`) only on a clean true.
+ */
+export const laneExecutorAbi = parseAbi([
+    ...CORE_STRUCTS,
+    "function executeArbitrage(PoolKey triggeringPool,address rebateRecipient) returns(uint256 realizedProfitQuote)",
+    "function checkV3PoolsMev(address subject,address quote,address swapper,bool zeroForOne) view returns(bool)",
+]);
+/**
+ * An arb recapture leg on a dynamic fee pool carries the pool's dynamic fee state (since r27,
+ * `docs/security/audits/r27.md`): after the leg's swap the root's afterSwap DELEGATECALLs its lane module's
+ * `updateLegDynamicFee()` (selector 0xfb86cbca; only while the PoolManager is the caller, so it is refused for anyone
+ * else the root's fallback forwards it for), which calls the Rules' `carryLeg(context, simulation, quoteAmount)`
+ * (IHookrLaneRules, selector 0xff341722, root only, answered from HookrRules' fallback before the recapture module, so
+ * it is in neither the HookrRules nor the HookrRecapture ABI). Both are fail-open, charge and credit nothing and emit
+ * nothing: the Rules step the reference and move the anchor as for an ordinary swap from the leg's start to its end
+ * that paid `quoteAmount` of the quote, so the next trader is priced from where the leg left the price. A leg's own LP
+ * fee, take and swap are unchanged. Nothing outside the root calls either; they are here for decoders and review.
+ */
+export const LANE_CARRY_STRUCTS = [
+    "struct SwapContext { bytes32 id; address sender; address payer; address beneficiary; address subject; address quote; bool authenticated; bool isBuy; bool exactInput; bool zeroForOne; int256 amountSpecified; uint160 sqrtPriceLimitX96; uint24 baseLpFeePips; }",
+    "struct SwapSimulation { uint160 sqrtPriceBeforeX96; int24 tickBefore; uint160 sqrtPriceAfterX96; int24 tickAfter; }",
+];
+export const laneRulesAbi = parseAbi([
+    ...LANE_CARRY_STRUCTS,
+    "function carryLeg(SwapContext context,SwapSimulation simulation,uint256 quoteAmount)",
+]);
+export const laneModuleAbi = parseAbi(["function updateLegDynamicFee()"]);
+/**
+ * HookrRecapture, reached through HookrRules' fallback: the pool's recapture config and its bounds, the pending LP
+ * share, and settleLeg (selector 0x4f735c09, root only), which credits a recapture leg's advisory take to its
+ * recipient and emits FeesAllocated(id, quote, 0, 0, 0, recipient, take). The release counts L2 blocks
+ * (ArbSys.arbBlockNumber) and at most RECAPTURE_L2_PER_SECOND of them per second of block time. settleRecapture
+ * (selector 0xe2ee7083, root only) splits one arb recapture's push: RECAPTURE_PROTOCOL_BPS (2,500, 25%) of
+ * `reportedProfit`, the profit the root reads back from the push at the pool's frozen partner share, to the protocol,
+ * at most the push, on every pool alike and never shared with an integrator (`recaptureSplit` in rules.ts). prizeBound
+ * is the King of the Pool prize ceiling on a share, which a pool with an integrator takes on the share the protocol
+ * keeps; prizeBoundFor (r26) takes the integrator's rate and computes that kept share as the bind does.
+ * protocolShareFloor (r26) is the effective floor a bind checks: the larger of the Rules' minProtocolShareBps and the
+ * treasury's governed floor.
+ * minimumFee (r25) is the Hookr minimum a pool froze at bind, for every pool; since r31 only a Hookr token's pool with
+ * no arb recapture and no rule that earns Hookr a share binds a nonzero one, so no arb recapture leg pays a top-up.
+ * RecaptureSplit (r31) carries `reportedProfit` last: the profit the executor's push reports at the pool's frozen
+ * partner share, which the split is computed from, not proof of payment.
+ */
+export const recaptureAbi = parseAbi([
+    ...CORE_STRUCTS,
+    "function settleLeg(bytes32 id,address recipient,uint256 amount) returns(uint256)",
+    "function settleRecapture(PoolKey key,address currency,address trader,uint256 amount,uint256 traderBasis,uint256 reportedProfit) returns(uint256)",
+    "function RECAPTURE_PROTOCOL_BPS() view returns(uint16)",
+    "function prizeBound(uint16 lpBps,uint16 burnBps,uint16 protocolShareBps) pure returns(uint256)",
+    "function prizeBoundFor(uint16 lpBps,uint16 burnBps,uint16 protocolShareBps,uint16 integratorBps) pure returns(uint256)",
+    "function protocolShareFloor() view returns(uint16)",
+    "function recaptureDefaults() pure returns(RecaptureConfig rc,uint16 potBps)",
+    "function recaptureConfig(bytes32 id) view returns(RecaptureConfig rc,uint16 potBps,uint16 protocolShareBps)",
+    "function recaptureMode(bytes32 id) view returns(uint256)",
+    "function pendingDonation(bytes32 id) view returns(uint256 due0,uint256 due1,uint256 fresh0,uint256 fresh1,uint256 freshBlock)",
+    "function MIN_RELEASE_BLOCKS() view returns(uint32)",
+    "function DEFAULT_RELEASE_BLOCKS() view returns(uint32)",
+    "function MAX_RELEASE_BLOCKS() view returns(uint32)",
+    "function minimumFee(bytes32 id) view returns(uint16)",
+    "event RecaptureSplit(bytes32 indexed id,address indexed trader,uint256 traderAmount,uint256 lp,uint256 pot,uint256 protocol,address currency,uint256 reportedProfit)",
+    "event LpShareDonated(bytes32 indexed id,uint256 amount0,uint256 amount1)",
+    "event FeesAllocated(bytes32 indexed id,address indexed quote,uint256 protocol,uint256 royalty,uint256 refund,address advisoryRecipient,uint256 advisoryFee)",
+]);
+export const registryAbi = parseAbi([
+    "function isRoot(address root) view returns(bool)",
+    "function rootOpen(address root) view returns(bool)",
+    "function isQuote(address asset) view returns(bool)",
+    "function quoteAssets() view returns(address[])",
+    "function newMarketsPaused() view returns(bool)",
+    "function queue(bytes32 kind,bytes arguments) returns(bytes32 operation)",
+    "function operationHash(bytes32 kind,bytes arguments) view returns(bytes32)",
+    "function readyAt(bytes32 operation) view returns(uint48)",
+    "function expiresAt(bytes32 operation) view returns(uint48)",
+    "function delay() view returns(uint48)",
+    "function isLauncher(address account) view returns(bool)",
+    "function isRootFactory(address factory) view returns(bool)",
+    "function rootFactoryOf(address root) view returns(address)",
+    "function rootFactoryCodeHash(address factory) view returns(bytes32)",
+    "function rootStatus(address root) view returns(address advisory,bool verified)",
+    "function isRevokedAdmission(address scope,address implementation) view returns(bool)",
+    "function revokeFactoryAdmissions(address factory,address[] implementations)",
+    "function releaseId() pure returns(uint256)",
+    "event OperationQueued(bytes32 indexed operation,bytes32 indexed kind,bytes arguments,uint48 readyAt,uint48 expiresAt)",
+    "event RootRegistered(address indexed root)",
+    "event RootFactorySet(address indexed factory,bytes32 codeHash,bool active)",
+    "event FactoryRootRegistered(address indexed factory,address indexed root)",
+    "event AdmissionRevoked(address indexed scope,address indexed implementation,address indexed by)",
+]);
+export const managerAbi = parseAbi([
+    "event Initialize(bytes32 indexed id,address indexed currency0,address indexed currency1,uint24 fee,int24 tickSpacing,address hooks,uint160 sqrtPriceX96,int24 tick)",
+    "event ModifyLiquidity(bytes32 indexed id,address indexed sender,int24 tickLower,int24 tickUpper,int256 liquidityDelta,bytes32 salt)",
+    "event Swap(bytes32 indexed id,address indexed sender,int128 amount0,int128 amount1,uint160 sqrtPriceX96,uint128 liquidity,int24 tick,uint24 fee)",
+    "event Donate(bytes32 indexed id,address indexed sender,uint256 amount0,uint256 amount1)",
+    "event ProtocolFeeUpdated(bytes32 indexed id,uint24 protocolFee)",
+    "function extsload(bytes32 startSlot,uint256 nSlots) view returns(bytes32[])",
+]);
+export const positionManagerAbi = parseAbi([
+    "event Transfer(address indexed from,address indexed to,uint256 indexed tokenId)",
+    "function ownerOf(uint256) view returns(address)",
+]);
+export const rulesAbi = parseAbi([
+    ...CORE_STRUCTS,
+    "function protocolRecipient() view returns(address)",
+    "function trustedRoot() view returns(address)",
+    "function protocolFeePaid(address payer,address quote) view returns(uint256 amount)",
+    "function removalLockedUntil(bytes32 id) view returns(uint256 untilBlock)",
+    "function claim(address currency) returns(uint256)",
+    "function claimTo(address currency,address to) returns(uint256)",
+    "function claimAsClaims(address currency,address to) returns(uint256 amount)",
+    "function claimable(address currency,address beneficiary) view returns(uint256)",
+    "function config(bytes32 id) view returns(RulesConfig)",
+    "function integration(bytes32 id) view returns(address integrator,uint16 integratorBps)",
+    "function feeOnlyFrom(bytes32 id) view returns(uint256)",
+    "function minProtocolShareBps() view returns(uint16)",
+    "function configSchemaHash() pure returns(bytes32)",
+    "function rootSimulates() view returns(bool)",
+    "function poolHasDynamicFee(bytes32 id) view returns(bool)",
+    "function dynamicFeeParameters() pure returns(uint256 window,uint256 reset,uint256 carryBps,uint256 moveTicks)",
+    "function referenceState(bytes32 id) view returns(uint256 minLiquidity,int24 referenceTick,int24 anchorTick,uint40 movedAt,uint40 referenceAt,int24 movedTick)",
+    "function releaseId() pure returns(uint256)",
+    "event RulesBound(bytes32 indexed id,address indexed root,bytes32 configHash,bytes config)",
+    "event FeesAllocated(bytes32 indexed id,address indexed quote,uint256 protocol,uint256 royalty,uint256 refund,address advisoryRecipient,uint256 advisoryFee)",
+    "event Claimed(address indexed quote,address indexed beneficiary,address indexed to,uint256 amount)",
+    "event IntegratorPaid(bytes32 indexed id,address indexed quote,address indexed integrator,uint256 amount)",
+    "error UnknownIntegrator(address integrator)",
+]);
+/**
+ * HookrTreasury: protocol collection and, since r23, the fee terms every Rules paying it reads once when it binds a
+ * pool (`feeTerms(integrator, recapture, id)`, r25): the governed rule-share floor (0 to 5,000 bps), the integrator
+ * list (1 to 5,000 bps of Hookr's rule-fee share each, 5,000 pre-filled) and the Hookr minimum (r25): a rate for
+ * pools without arb recapture and one for pools with it (0 to 10,000 pips, 1,000 at deployment) and a per-integrator
+ * override (0 to 10,000, or NO_MIN_FEE_OVERRIDE to remove it) that reaches only the pool ids the integrator approved
+ * with its own `approveMinFeePool`. Owner only, except approveMinFeePool; every change waits TERMS_DELAY (30 minutes)
+ * after its proposal and lapses TERMS_GRACE (14 days) after maturing; removeIntegrator is immediate and also removes
+ * the integrator's override. Since r26 the pending views report a proposal only until it lapses; acceptIntegrator
+ * re-checks the proposal's refusals (the zero address, the treasury, the PoolManager, an admitted source) and
+ * admitSource refuses a listed or pending integrator; removeIntegrator emits the cancellation of each proposal it
+ * voids, and a change of owner emits the floor's and both rates' cancellations and FeeTermsProposalsVoided(epoch) for
+ * the per-account proposals it voids.
+ */
+export const treasuryAbi = parseAbi([
+    "event ProtocolCollected(address indexed source,address indexed currency,address indexed to,uint256 amount)",
+    "event ProtocolForwarded(address indexed currency,address indexed target,uint256 amount)",
+    "event ProtocolForwardDeferred(address indexed currency,address indexed target,uint256 amount)",
+    "function collect(address source,address currency) returns(uint256)",
+    "function collectTo(address source,address currency) returns(uint256)",
+    "function collectAsClaims(address source,address currency) returns(uint256)",
+    "function forwardBalance(address currency) returns(uint256,bool)",
+    "function target() view returns(address)",
+    "function sourceCodeHash(address source) view returns(bytes32)",
+    "function releaseId() pure returns(uint256)",
+    "function TERMS_DELAY() view returns(uint256)",
+    "function TERMS_GRACE() view returns(uint256)",
+    "function MAX_RULE_SHARE_FLOOR_BPS() view returns(uint16)",
+    "function MAX_INTEGRATOR_BPS() view returns(uint16)",
+    "function DEFAULT_INTEGRATOR_BPS() view returns(uint16)",
+    "function MAX_MIN_FEE_PIPS() view returns(uint16)",
+    "function DEFAULT_MIN_FEE_PIPS() view returns(uint16)",
+    "function NO_MIN_FEE_OVERRIDE() view returns(uint16)",
+    "function feeTerms(address integrator,bool recapture,bytes32 id) view returns(uint16 ruleShareFloorBps,uint16 integratorBps,uint16 minFeePips)",
+    "function minFeePips(bool recapture) view returns(uint16)",
+    "function pendingMinFee(bool recapture) view returns(uint16 pips,uint256 readyAt)",
+    "function integratorMinFee(address account) view returns(uint16 pips,uint16 pendingPips,uint256 readyAt)",
+    "function minFeePoolApproved(address account,bytes32 id) view returns(bool)",
+    "function approveMinFeePool(bytes32 id,bool approved)",
+    "function proposeMinFee(bool recapture,uint16 pips)",
+    "function cancelMinFee(bool recapture)",
+    "function acceptMinFee(bool recapture)",
+    "function proposeIntegratorMinFee(address account,uint16 pips)",
+    "function cancelIntegratorMinFee(address account)",
+    "function acceptIntegratorMinFee(address account)",
+    "function ruleShareFloorBps() view returns(uint16)",
+    "function pendingRuleShareFloor() view returns(uint16 floorBps,uint256 readyAt)",
+    "function integrator(address account) view returns(uint16 rateBps,uint16 pendingRateBps,uint256 readyAt)",
+    "function proposeRuleShareFloor(uint16 floorBps)",
+    "function cancelRuleShareFloor()",
+    "function acceptRuleShareFloor()",
+    "function proposeIntegrator(address account,uint16 rateBps)",
+    "function cancelIntegrator(address account)",
+    "function acceptIntegrator(address account)",
+    "function removeIntegrator(address account)",
+    "event RuleShareFloorProposed(uint16 current,uint16 proposed,uint256 readyAt)",
+    "event RuleShareFloorProposalCancelled(uint16 proposed)",
+    "event RuleShareFloorSet(uint16 previous,uint16 current)",
+    "event IntegratorProposed(address indexed account,uint16 current,uint16 proposed,uint256 readyAt)",
+    "event IntegratorProposalCancelled(address indexed account,uint16 proposed)",
+    "event IntegratorSet(address indexed account,uint16 previous,uint16 current)",
+    "event IntegratorRemoved(address indexed account,uint16 previous)",
+    "event MinFeeProposed(bool indexed recapture,uint16 current,uint16 proposed,uint256 readyAt)",
+    "event MinFeeProposalCancelled(bool indexed recapture,uint16 proposed)",
+    "event MinFeeSet(bool indexed recapture,uint16 previous,uint16 current)",
+    "event IntegratorMinFeeProposed(address indexed account,uint16 current,uint16 proposed,uint256 readyAt)",
+    "event IntegratorMinFeeProposalCancelled(address indexed account,uint16 proposed)",
+    "event IntegratorMinFeeSet(address indexed account,uint16 previous,uint16 current)",
+    "event MinFeePoolApproved(address indexed account,bytes32 indexed id,bool approved)",
+    "event FeeTermsProposalsVoided(uint64 indexed epoch)",
+]);
+/** HookrForwarder: the gasless swap-intent relay the router pins (read surface only; the SDK signs nothing). */
+export const forwarderAbi = parseAbi([
+    "function router() view returns(address)",
+    "function registry() view returns(address)",
+    "function permit2() view returns(address)",
+    "function isNonceUsed(address owner,uint256 intentNonce) view returns(bool)",
+    "function releaseId() pure returns(uint256)",
+    "event IntentExecuted(bytes32 indexed intentHash,address indexed owner,address indexed relayer,bytes32 poolId,uint256 amountIn,uint256 amountOut,uint256 relayerFee,bool feeFromInput)",
+]);
+export const PROGRAM_STRUCTS = [
+    "struct Terms { uint8 mode; bool globalBux; uint64 start; uint64 end; uint128 pointBudget; uint128 walletPointCap; uint128 pointNumerator; uint128 pointDenominator; uint128 dailyPointBudget; address rewardToken; uint128 cashBudget; uint128 walletCashCap; uint128 cashNumerator; uint128 cashDenominator; uint128 dailyCashBudget; address attestor; address reviewer; uint64 reviewDelay; bytes32 sourcePolicyHash; string name; string metadataURI; uint8 pointDecimals; address referralRegistry; uint256 baseProgramId; }",
+    "struct Scope { address root; bytes32 poolId; bytes32 configHash; address quoteAsset; uint128 numerator; uint128 denominator; uint128 subjectNumerator; uint128 subjectDenominator; }",
+    "struct Milestone { uint128 pointsRequired; uint32 maxAwards; }",
+    "struct NFTMetadata { string name; string symbol; string baseURI; bool transferable; }",
+    "struct Receipt { uint256 chainId; address root; bytes32 poolId; bytes32 configHash; address quoteAsset; address participant; uint256 quoteVolume; bytes32 executionId; uint64 executedAt; uint8 flowType; }",
+];
+export const programsAbi = parseAbi([
+    ...PROGRAM_STRUCTS,
+    "struct Program { Terms terms; address creator; bytes32 termsHash; address collection; uint256 pointsIssued; uint256 cashAllocated; uint256 cashPaid; uint256 cashRefunded; uint256 nextTokenId; uint32 openDays; bool buxApproved; bool buxReleased; bool cancelled; bool immediateCashReleased; }",
+    "struct Epoch { bytes32 merkleRoot; bytes32 coverageHash; bytes32 evidenceHash; uint256 totalWeight; uint256 claimedWeight; uint256 pointsAllocated; uint256 cashAllocated; uint64 finalizeAfter; uint64 version; bool challenged; bool finalized; bool closed; bool remainderReleased; }",
+    "function referrals() view returns(address)",
+    "function trustedRouter() view returns(address)",
+    "function poolManager() view returns(address)",
+    "function releaseId() pure returns(uint256)",
+    "function program(uint256 id) view returns(Program)",
+    "function scopes(uint256 id) view returns(Scope[])",
+    "function milestones(uint256 id) view returns(Milestone[])",
+    "function epoch(uint256 id,uint256 day) view returns(Epoch)",
+    "function points(uint256 id,address participant) view returns(uint256)",
+    "function buxBalance(address participant) view returns(uint256)",
+    "function claimableCash(uint256 id,address participant) view returns(uint256)",
+    "function reservedNFT(uint256 id,address participant,uint256 milestone) view returns(uint256)",
+    "function deliveredNFT(uint256 id,address participant) view returns(uint256)",
+    "function referralProgramKey(uint256 id) view returns(bytes32)",
+    "function dayClaimed(uint256 id,uint256 day,address participant) view returns(bool)",
+    "function createProgram(Terms terms,Scope[] scopes,Milestone[] milestones,NFTMetadata metadata) returns(uint256)",
+    "event ProgramCreated(uint256 indexed id,address indexed creator,bytes32 indexed termsHash,bool globalBux,bytes termsData,bytes scopesData,bytes milestonesData,bytes metadataData)",
+    "event ExecutionAccepted(bytes32 indexed executionId,address indexed participant,bytes receiptData)",
+    "function claimReferralDay(uint256 id,uint256 day,address payer,address referrer,uint64 firstActivityBlock,uint128 weight,bytes32[] proof)",
+    "event ReferralDayClaimed(uint256 indexed id,uint256 indexed day,address indexed payer,address referrer,uint128 weight,uint256 pointsAward)",
+    "event DailyActivityAccepted(uint256 indexed id,uint256 indexed day,bytes32 indexed executionId,address participant)",
+    "event BuxProgramApproved(uint256 indexed id,uint256 reserved)",
+    "event EpochChallenged(uint256 indexed id,uint256 indexed day,bytes32 reasonHash)",
+    "event EpochFinalized(uint256 indexed id,uint256 indexed day,uint64 version)",
+    "event DayClaimed(uint256 indexed id,uint256 indexed day,address indexed beneficiary,uint128 weight,uint256 pointsAward,uint256 cashAward)",
+    "event CashClaimed(uint256 indexed id,address indexed beneficiary,address indexed to,uint256 amount)",
+    "event MilestoneReserved(uint256 indexed id,address indexed beneficiary,uint256 indexed milestone,uint256 tokenId)",
+    "event NFTDelivered(uint256 indexed id,address indexed beneficiary,uint256 indexed milestone,address to)",
+    "function claimCash(uint256 id,address beneficiary,address to,uint256 amount)",
+    "function claimNFT(uint256 id,address beneficiary,uint256 milestone,address to) returns(bool)",
+    "function finalizeDay(uint256 id,uint256 day)",
+    "function challengeDay(uint256 id,uint256 day,bytes32 reasonHash)",
+    "event ActivityCredited(uint256 indexed id,address indexed participant,uint256 weight,uint256 pointsAward,uint256 cashAward)",
+    "event EpochProposed(uint256 indexed id,uint256 indexed day,uint64 version,bytes32 merkleRoot,uint256 totalWeight,bytes32 coverageHash,bytes32 evidenceHash,uint64 finalizeAfter)",
+    "function proposeDay(uint256 id,uint256 day,bytes32 merkleRoot,uint256 totalWeight,bytes32 coverageHash,bytes32 evidenceHash)",
+    "function claimDay(uint256 id,uint256 day,address beneficiary,uint128 weight,bytes32[] proof)",
+]);
+export const referralsAbi = parseAbi([
+    "event ReferralCodeRegistered(bytes32 indexed codeHash,address indexed referrer)",
+    "event ReferralBound(bytes32 indexed programKey,address indexed payer,address indexed referrer,bytes32 codeHash,uint64 eligibleFromBlock)",
+    "function registerCode(bytes32 codeHash)",
+    "function register(bytes32 programKey,address referrer,bytes32 codeHash)",
+    "function registerSigned(address payer,address referrer,bytes32 programKey,bytes32 codeHash,uint256 nonce,uint256 deadline,bytes signature)",
+    "function binding(bytes32 programKey,address payer) view returns(address referrer,uint64 eligibleFromBlock,bytes32 codeHash)",
+    "function codeOwner(bytes32 codeHash) view returns(address)",
+    "function contractBlockNumber() view returns(uint256)",
+    "function nonces(address payer) view returns(uint256)",
+    "function releaseId() pure returns(uint256)",
+]);
+export const COMMISSION_STRUCTS = [
+    "struct CommissionTerms { address root; address rules; bytes32 poolId; bytes32 configHash; address currency; uint8 feeSource; uint64 start; uint64 end; uint16 referrerBps; uint16 cashbackBps; uint128 dailyBudget; uint128 walletFeeCap; address attestor; address reviewer; uint64 reviewDelay; bytes32 sourcePolicyHash; }",
+];
+export const commissionsAbi = parseAbi([
+    ...COMMISSION_STRUCTS,
+    "struct Campaign { CommissionTerms terms; address creator; bytes32 termsHash; bytes32 programKey; }",
+    "struct Epoch { bytes32 merkleRoot; bytes32 coverageHash; bytes32 collectionsHash; uint256 totalFees; uint256 claimedFees; uint256 allocated; uint64 finalizeAfter; uint64 version; bool challenged; bool finalized; bool released; }",
+    "function referrals() view returns(address)",
+    "function campaign(uint256 id) view returns(Campaign)",
+    "function attestor() view returns(address)",
+    "function releaseId() pure returns(uint256)",
+    "function epoch(uint256 id,uint256 day) view returns(Epoch)",
+    "function claimable(address currency,address beneficiary) view returns(uint256)",
+    "function createCampaign(CommissionTerms t) payable returns(uint256 id)",
+    "event CampaignCreated(uint256 indexed id,address indexed creator,bytes32 indexed programKey,bytes32 termsHash,bytes termsData)",
+    "event EpochProposed(uint256 indexed id,uint256 indexed day,uint64 version,bytes32 root,uint256 totalFees,bytes32 coverageHash,bytes32 collectionsHash,uint64 finalizeAfter)",
+    "event EpochChallenged(uint256 indexed id,uint256 indexed day,bytes32 reasonHash)",
+    "event EpochFinalized(uint256 indexed id,uint256 indexed day,uint64 version)",
+    "event CommissionCredited(uint256 indexed id,uint256 indexed day,address indexed payer,address referrer,uint128 eligibleFees,uint256 commission,uint256 cashback)",
+    "event Claimed(address indexed currency,address indexed beneficiary,address indexed to,uint256 amount)",
+    "function proposeDay(uint256 id,uint256 day,bytes32 root,uint256 totalFees,bytes32 coverageHash,bytes32 collectionsHash)",
+    "function finalizeDay(uint256 id,uint256 day)",
+    "function creditDay(uint256 id,uint256 day,address payer,address referrer,uint64 firstActivityBlock,uint128 eligibleFees,bytes32[] proof)",
+    "function claim(address currency,address beneficiary,address to,uint256 amount)",
+]);
+/** Later-stage contracts: full ABIs generated from the release artifacts (scripts/sync-artifacts.ts). */
+export const rootFactoryAbi = ARTIFACT_ABIS.HookrRootFactory;
+export const pairRootAbi = ARTIFACT_ABIS.HookrPairRoot;
+export const feeAdvisoryAbi = ARTIFACT_ABIS.HookrFeeAdvisory;
+export const sessionAdvisoryAbi = ARTIFACT_ABIS.HookrSessionAdvisory;
+export const liquidityVaultAbi = ARTIFACT_ABIS.HookrLiquidityVault;