hookr-sdk 0.2.1 → 1.0.0

package/dist/core/vault.d.ts

@@ -0,0 +1,59 @@
+import { type Address, type Call, type DeploymentManifest, type Hash } from "./schema.js";
+import { type PoolKey } from "./wallet.js";
+/** HookrLiquidityVault.DepositParams. The vault charges exactly what the pool requires, never more than desired. */
+export interface VaultDeposit {
+    key: PoolKey;
+    tickLower: number;
+    tickUpper: number;
+    amount0Desired: bigint;
+    amount1Desired: bigint;
+    amount0Min: bigint;
+    amount1Min: bigint;
+    recipient: Address;
+    deadline: bigint;
+}
+/** HookrLiquidityVault.WithdrawParams. Minimums bound the principal returned, excluding fees. */
+export interface VaultWithdraw {
+    key: PoolKey;
+    tickLower: number;
+    tickUpper: number;
+    liquidity: bigint;
+    amount0Min: bigint;
+    amount1Min: bigint;
+    recipient: Address;
+    deadline: bigint;
+}
+/** Uniswap v4 PoolId of any pool key (static or dynamic fee): the vault serves every v4 pool. */
+export declare function v4PoolId(key: PoolKey): Hash;
+/** HookrLiquidityVault.rangeId: the ERC-6909 share id of (pool, tickLower, tickUpper). */
+export declare function vaultRangeId(poolId: Hash, tickLower: number, tickUpper: number): bigint;
+/**
+ * Deposits into a range and mints shares equal to the liquidity added. A native currency0 is paid as the call
+ * value (`amount0Desired`); the vault refunds what the pool did not take. ERC-20 amounts need an approval of the
+ * vault first.
+ */
+export declare function buildVaultDeposit(m: DeploymentManifest, p: VaultDeposit, now?: bigint): Call;
+/** Burns the caller's shares and pays the principal plus the caller's realised fees in the range. */
+export declare function buildVaultWithdraw(m: DeploymentManifest, p: VaultWithdraw, now?: bigint): Call;
+/** Realises the range's fees and pays the caller's fees to `to`. Principal is untouched. */
+export declare function buildVaultClaim(m: DeploymentManifest, key: PoolKey, tickLower: number, tickUpper: number, to: Address): Call;
+/** Realises the range's accrued fees into its per-share accumulators. Permissionless. */
+export declare function buildVaultPoke(m: DeploymentManifest, key: PoolKey, tickLower: number, tickUpper: number): Call;
+/** Pays the vault's skimmed fees in `currency` to its immutable protocol recipient. Permissionless. */
+export declare function buildVaultCollectProtocolFees(m: DeploymentManifest, currency: Address): Call;
+/** Pulls the treasury's claim from an admitted source (a pinned HookrRules or HookrLiquidityVault). Permissionless. */
+export declare function buildTreasuryCollect(m: DeploymentManifest, from: Address, currency: Address): Call;
+/** Pulls the treasury's claim from an admitted source straight to the treasury target. */
+export declare function buildTreasuryCollectTo(m: DeploymentManifest, from: Address, currency: Address): Call;
+/**
+ * Moves the treasury's HookrRules claim to the treasury target as PoolManager ERC-6909 claims of `currency`; the
+ * exit for a quote that stops delivering exact amounts. Only the treasury owner or the current target may send it.
+ */
+export declare function buildTreasuryCollectAsClaims(m: DeploymentManifest, rules: Address, currency: Address): Call;
+/** Retries deferred protocol funds, or forwards an unassigned balance, to the treasury target. */
+export declare function buildTreasuryForward(m: DeploymentManifest, currency: Address): Call;
+/**
+ * Pays the caller's whole HookrRules claim (royalty, refund or advisory fee) to `to` as PoolManager ERC-6909 claims.
+ * Moves no token; `to` redeems through any PoolManager unlock.
+ */
+export declare function buildRulesClaimAsClaims(m: DeploymentManifest, rules: Address, currency: Address, to: Address): Call;

package/dist/core/vault.js

@@ -0,0 +1,112 @@
+import { encodeAbiParameters, keccak256 } from "viem";
+import { ARTIFACT_ABIS } from "./generated.js";
+import { address, assert, hash, uint, ZERO, } from "./schema.js";
+import { buildCall, buildCallTo, contract, pinned } from "./wallet.js";
+const vaultAbi = ARTIFACT_ABIS.HookrLiquidityVault;
+const MAX_AMOUNT = (1n << 127n) - 1n;
+/** Uniswap v4 PoolId of any pool key (static or dynamic fee): the vault serves every v4 pool. */
+export function v4PoolId(key) {
+    const c0 = address(key.currency0, true);
+    const c1 = address(key.currency1);
+    assert(BigInt(c0) < BigInt(c1), "Unsorted pool currencies");
+    assert(Number.isInteger(key.fee) && key.fee >= 0 && key.fee <= 0x800000, "Invalid pool fee");
+    assert(Number.isInteger(key.tickSpacing) && key.tickSpacing > 0 && key.tickSpacing <= 32767, "Invalid tick spacing");
+    return keccak256(encodeAbiParameters([{ type: "address" }, { type: "address" }, { type: "uint24" }, { type: "int24" }, { type: "address" }], [c0, c1, key.fee, key.tickSpacing, address(key.hooks, true)]));
+}
+/** HookrLiquidityVault.rangeId: the ERC-6909 share id of (pool, tickLower, tickUpper). */
+export function vaultRangeId(poolId, tickLower, tickUpper) {
+    checkRange(tickLower, tickUpper);
+    return BigInt(keccak256(encodeAbiParameters([{ type: "bytes32" }, { type: "int24" }, { type: "int24" }], [hash(poolId), tickLower, tickUpper])));
+}
+function checkRange(tickLower, tickUpper) {
+    assert(Number.isInteger(tickLower) && Number.isInteger(tickUpper) && tickLower >= -887272 && tickUpper <= 887272, "Tick out of range");
+    assert(tickLower < tickUpper, "Invalid range");
+}
+/** The vault refuses the zero address, itself and the PoolManager as recipient. */
+function recipient(m, to) {
+    const r = address(to);
+    assert(r !== contract(m, "liquidityVault"), "Vault cannot receive");
+    assert(!m.contracts.some((c) => c.role === "poolManager" && c.address === r), "PoolManager cannot receive");
+    return r;
+}
+function deadline(value, now) {
+    assert(uint(value) >= now, "Deadline passed");
+    return value;
+}
+/**
+ * Deposits into a range and mints shares equal to the liquidity added. A native currency0 is paid as the call
+ * value (`amount0Desired`); the vault refunds what the pool did not take. ERC-20 amounts need an approval of the
+ * vault first.
+ */
+export function buildVaultDeposit(m, p, now = BigInt(Math.floor(Date.now() / 1000))) {
+    v4PoolId(p.key);
+    checkRange(p.tickLower, p.tickUpper);
+    for (const v of [p.amount0Desired, p.amount1Desired])
+        assert(uint(v) <= MAX_AMOUNT, "Amount above int128");
+    assert(p.amount0Desired > 0n || p.amount1Desired > 0n, "Empty deposit");
+    assert(uint(p.amount0Min) <= p.amount0Desired && uint(p.amount1Min) <= p.amount1Desired, "Minimum above desired");
+    const params = { ...p, recipient: recipient(m, p.recipient), deadline: deadline(p.deadline, now) };
+    const value = address(p.key.currency0, true) === ZERO ? p.amount0Desired : 0n;
+    return buildCall(m, "liquidityVault", vaultAbi, "deposit", [params], value);
+}
+/** Burns the caller's shares and pays the principal plus the caller's realised fees in the range. */
+export function buildVaultWithdraw(m, p, now = BigInt(Math.floor(Date.now() / 1000))) {
+    v4PoolId(p.key);
+    checkRange(p.tickLower, p.tickUpper);
+    assert(uint(p.liquidity, 128) > 0n, "Empty withdrawal");
+    uint(p.amount0Min);
+    uint(p.amount1Min);
+    const params = { ...p, recipient: recipient(m, p.recipient), deadline: deadline(p.deadline, now) };
+    return buildCall(m, "liquidityVault", vaultAbi, "withdraw", [params]);
+}
+/** Realises the range's fees and pays the caller's fees to `to`. Principal is untouched. */
+export function buildVaultClaim(m, key, tickLower, tickUpper, to) {
+    v4PoolId(key);
+    checkRange(tickLower, tickUpper);
+    return buildCall(m, "liquidityVault", vaultAbi, "claim", [key, tickLower, tickUpper, recipient(m, to)]);
+}
+/** Realises the range's accrued fees into its per-share accumulators. Permissionless. */
+export function buildVaultPoke(m, key, tickLower, tickUpper) {
+    v4PoolId(key);
+    checkRange(tickLower, tickUpper);
+    return buildCall(m, "liquidityVault", vaultAbi, "poke", [key, tickLower, tickUpper]);
+}
+/** Pays the vault's skimmed fees in `currency` to its immutable protocol recipient. Permissionless. */
+export function buildVaultCollectProtocolFees(m, currency) {
+    return buildCall(m, "liquidityVault", vaultAbi, "collectProtocolFees", [address(currency, true)]);
+}
+const treasuryAbi = ARTIFACT_ABIS.HookrTreasury;
+function source(m, s) {
+    const a = address(s);
+    assert(m.contracts.some((c) => (c.role === "rules" || c.role === "liquidityVault") && c.address === a), "Unqualified treasury source");
+    return a;
+}
+/** Pulls the treasury's claim from an admitted source (a pinned HookrRules or HookrLiquidityVault). Permissionless. */
+export function buildTreasuryCollect(m, from, currency) {
+    return buildCall(m, "treasury", treasuryAbi, "collect", [source(m, from), address(currency, true)]);
+}
+/** Pulls the treasury's claim from an admitted source straight to the treasury target. */
+export function buildTreasuryCollectTo(m, from, currency) {
+    return buildCall(m, "treasury", treasuryAbi, "collectTo", [source(m, from), address(currency, true)]);
+}
+/**
+ * Moves the treasury's HookrRules claim to the treasury target as PoolManager ERC-6909 claims of `currency`; the
+ * exit for a quote that stops delivering exact amounts. Only the treasury owner or the current target may send it.
+ */
+export function buildTreasuryCollectAsClaims(m, rules, currency) {
+    return buildCall(m, "treasury", treasuryAbi, "collectAsClaims", [pinned(m, "rules", rules), address(currency, true)]);
+}
+/** Retries deferred protocol funds, or forwards an unassigned balance, to the treasury target. */
+export function buildTreasuryForward(m, currency) {
+    return buildCall(m, "treasury", treasuryAbi, "forwardBalance", [address(currency, true)]);
+}
+/**
+ * Pays the caller's whole HookrRules claim (royalty, refund or advisory fee) to `to` as PoolManager ERC-6909 claims.
+ * Moves no token; `to` redeems through any PoolManager unlock.
+ */
+export function buildRulesClaimAsClaims(m, rules, currency, to) {
+    const r = pinned(m, "rules", rules);
+    const recipient = address(to);
+    assert(recipient !== r && !m.contracts.some((c) => c.role === "poolManager" && c.address === recipient), "Invalid claim recipient");
+    return buildCallTo(m, r, ARTIFACT_ABIS.HookrRules, "claimAsClaims", [address(currency, true), recipient]);
+}

package/dist/core/wallet.d.ts

@@ -0,0 +1,142 @@
+import { type Abi, type Hex } from "viem";
+import { type Address, type Call, type ContractRole, type DeploymentManifest, type Hash } from "./schema.js";
+export interface PoolKey {
+    currency0: Address;
+    currency1: Address;
+    fee: number;
+    tickSpacing: number;
+    hooks: Address;
+}
+export interface Swap {
+    key: PoolKey;
+    zeroForOne: boolean;
+    amountSpecified: bigint;
+    amountBound: bigint;
+    sqrtPriceLimitX96: bigint;
+    recipient: Address;
+    deadline: bigint;
+}
+export declare function poolId(key: PoolKey): Hash;
+export declare function contract(m: DeploymentManifest, role: ContractRole): Address;
+/** Returns `target` when the manifest pins it under `role` (roles such as `root` and `rules` may repeat). */
+export declare function pinned(m: DeploymentManifest, role: ContractRole, target: Address): Address;
+export declare function buildCall(m: DeploymentManifest, role: ContractRole, abi: Abi, name: string, args: readonly unknown[], value?: bigint): Call;
+/** buildCall for an explicit pinned address; callers check the pin (`pinned`). */
+export declare function buildCallTo(m: DeploymentManifest, to: Address, abi: Abi, name: string, args: readonly unknown[], value?: bigint): Call;
+export declare function buildSwap(m: DeploymentManifest, s: Swap, programIds?: bigint[], now?: bigint): Call;
+export declare function buildQuote(m: DeploymentManifest, s: Swap, payer: Address, now?: bigint): Call;
+export declare function buildLaunch(m: DeploymentManifest, token: {
+    existing: Address;
+    name: string;
+    symbol: string;
+    supply: bigint;
+    salt: Hash;
+}, root: Address, members: readonly Record<string, unknown>[], nativeBudget: bigint, deadline: bigint, launchFee: bigint): Call;
+/**
+ * launch, where member i binds its admitted advisory with the exact bytes `advisoryConfigs[i]` (for example
+ * `encodeFeeAdvisoryConfig` or `encodeSessionSchedule`). A member without an advisory passes "0x".
+ */
+export declare function buildLaunchAdvised(m: DeploymentManifest, token: {
+    existing: Address;
+    name: string;
+    symbol: string;
+    supply: bigint;
+    salt: Hash;
+}, root: Address, members: readonly Record<string, unknown>[], advisoryConfigs: readonly Hash[], nativeBudget: bigint, deadline: bigint, launchFee: bigint): Call;
+/** HookrLaunchChecks.MAX_LAUNCH_FEE: the most a launch fee can be, 0.01 of the native currency. */
+export declare const MAX_LAUNCH_FEE: bigint;
+/**
+ * The launch fee a launch's native value carries on top of its native budgets (r31, IHookrLaunchFee): HookrLauncher
+ * refuses any other value (InvalidFunding). Read it at the launch block (`encodeLaunchFeeCall`, `decodeLaunchFee`);
+ * it is zero at genesis and changes only by the registry owner's timelocked proposal, at most MAX_LAUNCH_FEE.
+ */
+export declare function checkLaunchFee(launchFee: bigint): bigint;
+/** HookrLauncher.launchFee() (IHookrLaunchFee, served by the launcher's fallback): the fee now and a pending change. */
+export interface LaunchFee {
+    fee: bigint;
+    treasury: Address;
+    pendingFee: bigint;
+    pendingTreasury: Address;
+    readyAt: bigint;
+}
+/** The eth_call data that reads the launch fee from the launcher (`decodeLaunchFee` reads the answer). */
+export declare function encodeLaunchFeeCall(): Hex;
+/** Decodes launchFee()'s five words, refusing a fee above MAX_LAUNCH_FEE. */
+export declare function decodeLaunchFee(data: Hex): LaunchFee;
+/** Refuses advisory configs launchAdvised and launchWithBuy would refuse: one per member, "0x" without an advisory. */
+export declare function checkAdvisoryConfigs(members: readonly Record<string, unknown>[], advisoryConfigs: readonly Hash[]): void;
+/**
+ * Refuses a launch the Launcher would refuse before any pool opens: an unqualified root, a family of 0 or more than 8,
+ * a malformed token, an expired deadline, an empty member, or a native budget other than the native members' maxima.
+ */
+/**
+ * HookrLauncher.Member.recapture that launches a member without the recapture lane. Any config with `on` set makes the
+ * member's pool freeze the root's open lane at initialization, and the launch reverts while the root has none.
+ */
+export declare const RECAPTURE_OFF: Readonly<{
+    on: false;
+    traderBps: 0;
+    lpBps: 0;
+    period: 0;
+    maxPrizeBps: 0;
+    potReleaseBps: 0;
+    minBuyQuote: 0n;
+    releaseBlocks: 0;
+}>;
+/**
+ * HookrRecapture's release period bounds and default (RecaptureConfig.releaseBlocks), in L2 blocks: Robinhood Chain's
+ * own block number (ArbSys.arbBlockNumber), about 10 a second, so about 2 minutes, 24 hours and, by default, an hour.
+ * The release also counts at most `l2PerSecond` L2 blocks per second of block time. A member with recapture on and a
+ * period outside the bounds is refused at bind (InvalidConfig).
+ */
+export declare const RECAPTURE_RELEASE_BLOCKS: Readonly<{
+    min: number;
+    default: number;
+    max: number;
+    l2PerSecond: number;
+}>;
+export declare function checkLaunch(m: DeploymentManifest, token: {
+    existing: Address;
+    name: string;
+    symbol: string;
+    supply: bigint;
+    salt: Hash;
+}, root: Address, members: readonly Record<string, unknown>[], nativeBudget: bigint, deadline: bigint): void;
+export declare function buildWithdraw(m: DeploymentManifest, family: Hash, member: number, liquidity: bigint, min0: bigint, min1: bigint, to: Address, deadline: bigint): Call;
+/**
+ * Starts a two-step family transfer; `to` must then send buildFamilyAccept. The zero address cancels.
+ * `claims` is the current owner's own fee form on acceptance: bits (2i, 2i+1) pay member i's currency0/currency1
+ * fees to the current owner as PoolManager ERC-6909 claims instead of tokens. Only the current owner chooses it.
+ */
+export declare function buildFamilyTransfer(m: DeploymentManifest, family: Hash, to: Address, claims?: number): Call;
+/** Completes a pending family transfer; accrued fees go to the old owner in the form it chose. */
+export declare function buildFamilyAccept(m: DeploymentManifest, family: Hash): Call;
+/** withdraw, delivering currency0 (bit 0) and/or currency1 (bit 1) as PoolManager ERC-6909 claims. */
+export declare function buildWithdrawWithClaims(m: DeploymentManifest, family: Hash, member: number, liquidity: bigint, min0: bigint, min1: bigint, to: Address, claims: number, deadline: bigint): Call;
+/**
+ * Burns the sender's own ERC-6909 claim and pays `to` exactly `amount`. The sender must first approve the
+ * Launcher on the PoolManager (approve or setOperator). A fee-bearing currency is refused (exact delivery).
+ */
+export declare function buildRedeem(m: DeploymentManifest, currency: Address, amount: bigint, to: Address): Call;
+/** Moves the Launcher's whole idle (mistakenly sent) balance of `currency` to `to`. Reverts on zero. */
+export declare function buildSweep(m: DeploymentManifest, currency: Address, to: Address): Call;
+/**
+ * The sorted PoolKey the Launcher uses for a member (HookrLauncher.memberKey without the availability read).
+ * Read the contract's memberKey (or PoolManager slot0) for this key before signing a launch: an initialized key
+ * blocks the launch whatever its creator or role order.
+ */
+export declare function launcherMemberKey(subject: Address, quote: Address, tickSpacing: number, root: Address): PoolKey;
+export declare function buildDayClaim(m: DeploymentManifest, id: bigint, day: bigint, beneficiary: Address, weight: bigint, proof: Hash[]): Call;
+export declare function buildAddLiquidity(m: DeploymentManifest, family: Hash, member: number, liquidity: bigint, max0: bigint, max1: bigint, deadline: bigint, nativeValue: bigint): Call;
+export declare function buildPredictToken(m: DeploymentManifest, creator: Address, token: {
+    existing: Address;
+    name: string;
+    symbol: string;
+    supply: bigint;
+    salt: Hash;
+}): Call;
+export declare function buildReferralDayClaim(m: DeploymentManifest, id: bigint, day: bigint, payer: Address, referrer: Address, firstActivityBlock: bigint, weight: bigint, proof: Hash[]): Call;
+export declare function buildCommissionCredit(m: DeploymentManifest, id: bigint, day: bigint, payer: Address, referrer: Address, firstActivityBlock: bigint, eligibleFees: bigint, proof: Hash[]): Call;
+export declare function buildCommissionClaim(m: DeploymentManifest, currency: Address, beneficiary: Address, to: Address, amount?: bigint): Call;
+export declare function buildCashClaim(m: DeploymentManifest, id: bigint, beneficiary: Address, to: Address, amount?: bigint): Call;
+export declare function buildNFTClaim(m: DeploymentManifest, id: bigint, beneficiary: Address, milestone: bigint, to: Address): Call;

package/dist/core/wallet.js

@@ -0,0 +1,304 @@
+import { decodeFunctionResult, encodeFunctionData, encodeAbiParameters, keccak256 } from "viem";
+import { address, assert, deployment, uint, hash, ZERO, } from "./schema.js";
+import { launcherAbi, launchFeeAbi, routerAbi, quoterAbi, programsAbi, commissionsAbi } from "./abi.js";
+import { RELEASE_CONSTANTS } from "./generated.js";
+export function poolId(key) {
+    address(key.currency0, true);
+    address(key.currency1);
+    address(key.hooks);
+    assert(BigInt(key.currency0) < BigInt(key.currency1), "Unsorted pool currencies");
+    assert(key.fee === 0x800000, "Expected dynamic pool");
+    assert(Number.isInteger(key.tickSpacing) && key.tickSpacing > 0 && key.tickSpacing <= 32767, "Invalid tick spacing");
+    return keccak256(encodeAbiParameters([{ type: "address" }, { type: "address" }, { type: "uint24" }, { type: "int24" }, { type: "address" }], [key.currency0, key.currency1, key.fee, key.tickSpacing, key.hooks]));
+}
+export function contract(m, role) {
+    const pins = m.contracts.filter((c) => c.role === role);
+    assert(pins.length === 1, `Ambiguous/missing ${role}`);
+    return pins[0].address;
+}
+/** Returns `target` when the manifest pins it under `role` (roles such as `root` and `rules` may repeat). */
+export function pinned(m, role, target) {
+    const a = address(target);
+    assert(m.contracts.some((c) => c.role === role && c.address === a), `Unpinned ${role}`);
+    return a;
+}
+export function buildCall(m, role, abi, name, args, value = 0n) {
+    return buildCallTo(m, contract(m, role), abi, name, args, value);
+}
+/** buildCall for an explicit pinned address; callers check the pin (`pinned`). */
+export function buildCallTo(m, to, abi, name, args, value = 0n) {
+    deployment(m);
+    uint(value);
+    assert(uint(m.chainId) <= BigInt(Number.MAX_SAFE_INTEGER), "Chain overflow");
+    return {
+        chainId: Number(m.chainId),
+        to,
+        data: encodeFunctionData({ abi, functionName: name, args }),
+        value,
+    };
+}
+function checkSwap(m, s, now) {
+    poolId(s.key);
+    assert(m.contracts.some((c) => c.role === "root" && c.address.toLowerCase() === s.key.hooks.toLowerCase()), "Unqualified root");
+    address(s.recipient);
+    assert(s.amountSpecified !== 0n && s.amountSpecified > -(1n << 127n) && s.amountSpecified < 1n << 127n, "Bad amount");
+    assert(uint(s.amountBound, 128) > 0n, "Missing amount bound");
+    assert(uint(s.sqrtPriceLimitX96, 160) > 0n, "Missing price bound");
+    assert(s.deadline > now && s.deadline <= now + 3600n, "Deadline outside one-hour window");
+}
+export function buildSwap(m, s, programIds = [], now = BigInt(Math.floor(Date.now() / 1000))) {
+    checkSwap(m, s, now);
+    assert(programIds.length <= 8 && new Set(programIds.map(String)).size === programIds.length, "Invalid program set");
+    programIds.forEach((x) => assert(uint(x) > 0n, "Invalid program"));
+    const input = s.zeroForOne ? s.key.currency0 : s.key.currency1;
+    const value = input === ZERO ? (s.amountSpecified < 0n ? -s.amountSpecified : s.amountBound) : 0n;
+    return buildCall(m, "router", routerAbi, "swap", [s, programIds.length ? contract(m, "programs") : ZERO, programIds], value);
+}
+export function buildQuote(m, s, payer, now = BigInt(Math.floor(Date.now() / 1000))) {
+    checkSwap(m, s, now);
+    address(payer);
+    return buildCall(m, "quoter", quoterAbi, "quote", [s, payer]);
+}
+export function buildLaunch(m, token, root, members, nativeBudget, deadline, launchFee) {
+    checkLaunch(m, token, root, members, nativeBudget, deadline);
+    return buildCall(m, "launcher", launcherAbi, "launch", [token, root, members, deadline], nativeBudget + checkLaunchFee(launchFee));
+}
+/**
+ * launch, where member i binds its admitted advisory with the exact bytes `advisoryConfigs[i]` (for example
+ * `encodeFeeAdvisoryConfig` or `encodeSessionSchedule`). A member without an advisory passes "0x".
+ */
+export function buildLaunchAdvised(m, token, root, members, advisoryConfigs, nativeBudget, deadline, launchFee) {
+    checkLaunch(m, token, root, members, nativeBudget, deadline);
+    checkAdvisoryConfigs(members, advisoryConfigs);
+    return buildCall(m, "launcher", launcherAbi, "launchAdvised", [token, root, members, advisoryConfigs, deadline], nativeBudget + checkLaunchFee(launchFee));
+}
+/** HookrLaunchChecks.MAX_LAUNCH_FEE: the most a launch fee can be, 0.01 of the native currency. */
+export const MAX_LAUNCH_FEE = BigInt(RELEASE_CONSTANTS.LAUNCH_MAX_LAUNCH_FEE);
+/**
+ * The launch fee a launch's native value carries on top of its native budgets (r31, IHookrLaunchFee): HookrLauncher
+ * refuses any other value (InvalidFunding). Read it at the launch block (`encodeLaunchFeeCall`, `decodeLaunchFee`);
+ * it is zero at genesis and changes only by the registry owner's timelocked proposal, at most MAX_LAUNCH_FEE.
+ */
+export function checkLaunchFee(launchFee) {
+    assert(typeof launchFee === "bigint" && launchFee >= 0n && launchFee <= MAX_LAUNCH_FEE, "Launch fee outside 0 to 0.01 ether");
+    return launchFee;
+}
+/** The eth_call data that reads the launch fee from the launcher (`decodeLaunchFee` reads the answer). */
+export function encodeLaunchFeeCall() {
+    return encodeFunctionData({ abi: launchFeeAbi, functionName: "launchFee" });
+}
+/** Decodes launchFee()'s five words, refusing a fee above MAX_LAUNCH_FEE. */
+export function decodeLaunchFee(data) {
+    const [fee, treasury, pendingFee, pendingTreasury, readyAt] = decodeFunctionResult({
+        abi: launchFeeAbi,
+        functionName: "launchFee",
+        data,
+    });
+    checkLaunchFee(fee);
+    return {
+        fee,
+        treasury: address(treasury, true),
+        pendingFee,
+        pendingTreasury: address(pendingTreasury, true),
+        readyAt,
+    };
+}
+/** Refuses advisory configs launchAdvised and launchWithBuy would refuse: one per member, "0x" without an advisory. */
+export function checkAdvisoryConfigs(members, advisoryConfigs) {
+    assert(advisoryConfigs.length === members.length, "One advisory config per member");
+    members.forEach((member, i) => {
+        assert(/^0x([\da-fA-F]{2})*$/.test(advisoryConfigs[i]), "Invalid advisory config bytes");
+        const advisory = member.config?.advisory;
+        assert(advisoryConfigs[i] === "0x" || (typeof advisory === "string" && address(advisory, true) !== ZERO), "Advisory config without an advisory");
+        assert(advisoryConfigs[i].length <= 2 + 2 * 4096, "Advisory config above 4096 bytes");
+    });
+}
+/**
+ * Refuses a launch the Launcher would refuse before any pool opens: an unqualified root, a family of 0 or more than 8,
+ * a malformed token, an expired deadline, an empty member, or a native budget other than the native members' maxima.
+ */
+/**
+ * HookrLauncher.Member.recapture that launches a member without the recapture lane. Any config with `on` set makes the
+ * member's pool freeze the root's open lane at initialization, and the launch reverts while the root has none.
+ */
+export const RECAPTURE_OFF = Object.freeze({
+    on: false,
+    traderBps: 0,
+    lpBps: 0,
+    period: 0,
+    maxPrizeBps: 0,
+    potReleaseBps: 0,
+    minBuyQuote: 0n,
+    releaseBlocks: 0,
+});
+/**
+ * HookrRecapture's release period bounds and default (RecaptureConfig.releaseBlocks), in L2 blocks: Robinhood Chain's
+ * own block number (ArbSys.arbBlockNumber), about 10 a second, so about 2 minutes, 24 hours and, by default, an hour.
+ * The release also counts at most `l2PerSecond` L2 blocks per second of block time. A member with recapture on and a
+ * period outside the bounds is refused at bind (InvalidConfig).
+ */
+export const RECAPTURE_RELEASE_BLOCKS = Object.freeze({
+    min: Number(RELEASE_CONSTANTS.RECAPTURE_MIN_RELEASE_BLOCKS),
+    default: Number(RELEASE_CONSTANTS.RECAPTURE_DEFAULT_RELEASE_BLOCKS),
+    max: Number(RELEASE_CONSTANTS.RECAPTURE_MAX_RELEASE_BLOCKS),
+    l2PerSecond: Number(RELEASE_CONSTANTS.RECAPTURE_L2_PER_SECOND),
+});
+export function checkLaunch(m, token, root, members, nativeBudget, deadline) {
+    assert(m.contracts.some((c) => c.role === "root" && c.address.toLowerCase() === address(root)), "Unqualified root");
+    assert(members.length > 0 && members.length <= 8, "Invalid family size");
+    assert(token.existing === ZERO ? uint(token.supply) > 0n : token.supply === 0n && BigInt(token.salt) === 0n, "Invalid token supply");
+    address(token.existing, true);
+    assert(deadline > BigInt(Math.floor(Date.now() / 1000)), "Expired launch");
+    let expected = 0n;
+    for (const member of members) {
+        const q = address(member.quote, true);
+        if (q === ZERO)
+            expected += uint(member.amount0Max);
+        assert(uint(member.liquidity, 128) > 0n, "Empty liquidity");
+        const recapture = member.recapture;
+        assert(recapture !== null && typeof recapture === "object" && typeof recapture.on === "boolean", "Each launch member names its RecaptureConfig: RECAPTURE_OFF, or the Rules' recaptureDefaults() while the root's lane is open");
+        if (recapture.on) {
+            const period = Number(recapture.releaseBlocks);
+            assert(Number.isInteger(period) && period >= RECAPTURE_RELEASE_BLOCKS.min && period <= RECAPTURE_RELEASE_BLOCKS.max, "Recapture releaseBlocks outside 1,200 to 864,000 L2 blocks");
+        }
+    }
+    assert(nativeBudget === expected, "Native family budget must match native member maxima");
+}
+export function buildWithdraw(m, family, member, liquidity, min0, min1, to, deadline) {
+    assert(Number.isInteger(member) && member >= 0 && member < 8, "Invalid member");
+    uint(liquidity, 128);
+    uint(min0);
+    uint(min1);
+    address(to);
+    return buildCall(m, "launcher", launcherAbi, "withdraw", [family, member, liquidity, min0, min1, to, deadline]);
+}
+function claimsMask(claims, bits) {
+    assert(Number.isInteger(claims) && claims >= 0 && claims < 1 << bits, "Invalid claims mask");
+    return claims;
+}
+/**
+ * Starts a two-step family transfer; `to` must then send buildFamilyAccept. The zero address cancels.
+ * `claims` is the current owner's own fee form on acceptance: bits (2i, 2i+1) pay member i's currency0/currency1
+ * fees to the current owner as PoolManager ERC-6909 claims instead of tokens. Only the current owner chooses it.
+ */
+export function buildFamilyTransfer(m, family, to, claims = 0) {
+    return buildCall(m, "launcher", launcherAbi, "transferFamily", [family, address(to, true), claimsMask(claims, 16)]);
+}
+/** Completes a pending family transfer; accrued fees go to the old owner in the form it chose. */
+export function buildFamilyAccept(m, family) {
+    return buildCall(m, "launcher", launcherAbi, "acceptFamily", [family]);
+}
+/** withdraw, delivering currency0 (bit 0) and/or currency1 (bit 1) as PoolManager ERC-6909 claims. */
+export function buildWithdrawWithClaims(m, family, member, liquidity, min0, min1, to, claims, deadline) {
+    assert(Number.isInteger(member) && member >= 0 && member < 8, "Invalid member");
+    uint(liquidity, 128);
+    uint(min0);
+    uint(min1);
+    uint(deadline);
+    return buildCall(m, "launcher", launcherAbi, "withdrawWithClaims", [
+        family,
+        member,
+        liquidity,
+        min0,
+        min1,
+        address(to),
+        claimsMask(claims, 2),
+        deadline,
+    ]);
+}
+/**
+ * Burns the sender's own ERC-6909 claim and pays `to` exactly `amount`. The sender must first approve the
+ * Launcher on the PoolManager (approve or setOperator). A fee-bearing currency is refused (exact delivery).
+ */
+export function buildRedeem(m, currency, amount, to) {
+    assert(uint(amount) > 0n, "Empty redemption");
+    return buildCall(m, "launcher", launcherAbi, "redeem", [address(currency, true), amount, address(to)]);
+}
+/** Moves the Launcher's whole idle (mistakenly sent) balance of `currency` to `to`. Reverts on zero. */
+export function buildSweep(m, currency, to) {
+    return buildCall(m, "launcher", launcherAbi, "sweep", [address(currency, true), address(to)]);
+}
+/**
+ * The sorted PoolKey the Launcher uses for a member (HookrLauncher.memberKey without the availability read).
+ * Read the contract's memberKey (or PoolManager slot0) for this key before signing a launch: an initialized key
+ * blocks the launch whatever its creator or role order.
+ */
+export function launcherMemberKey(subject, quote, tickSpacing, root) {
+    const s = address(subject);
+    const q = address(quote, true);
+    assert(s !== q, "Subject equals quote");
+    const subjectFirst = BigInt(s) < BigInt(q);
+    const key = {
+        currency0: subjectFirst ? s : q,
+        currency1: subjectFirst ? q : s,
+        fee: 0x800000,
+        tickSpacing,
+        hooks: address(root),
+    };
+    poolId(key);
+    return key;
+}
+export function buildDayClaim(m, id, day, beneficiary, weight, proof) {
+    assert(proof.length <= 32, "Proof too long");
+    uint(weight, 128);
+    return buildCall(m, "programs", programsAbi, "claimDay", [id, day, address(beneficiary), weight, proof]);
+}
+export function buildAddLiquidity(m, family, member, liquidity, max0, max1, deadline, nativeValue) {
+    uint(liquidity, 128);
+    uint(max0, 128);
+    uint(max1, 128);
+    assert(nativeValue === 0n || nativeValue === max0, "Native funding must match currency0 bound");
+    return buildCall(m, "launcher", launcherAbi, "addLiquidity", [family, member, liquidity, max0, max1, deadline], nativeValue);
+}
+export function buildPredictToken(m, creator, token) {
+    address(creator);
+    address(token.existing, true);
+    hash(token.salt);
+    uint(token.supply);
+    return buildCall(m, "launcher", launcherAbi, "predictToken", [creator, token]);
+}
+export function buildReferralDayClaim(m, id, day, payer, referrer, firstActivityBlock, weight, proof) {
+    assert(proof.length <= 32, "Proof too long");
+    uint(firstActivityBlock, 64);
+    uint(weight, 128);
+    return buildCall(m, "programs", programsAbi, "claimReferralDay", [
+        id,
+        day,
+        address(payer),
+        address(referrer),
+        firstActivityBlock,
+        weight,
+        proof,
+    ]);
+}
+export function buildCommissionCredit(m, id, day, payer, referrer, firstActivityBlock, eligibleFees, proof) {
+    assert(proof.length <= 32, "Proof too long");
+    uint(firstActivityBlock, 64);
+    uint(eligibleFees, 128);
+    return buildCall(m, "commissions", commissionsAbi, "creditDay", [
+        id,
+        day,
+        address(payer),
+        address(referrer),
+        firstActivityBlock,
+        eligibleFees,
+        proof,
+    ]);
+}
+export function buildCommissionClaim(m, currency, beneficiary, to, amount = 0n) {
+    uint(amount);
+    return buildCall(m, "commissions", commissionsAbi, "claim", [
+        address(currency, true),
+        address(beneficiary),
+        address(to),
+        amount,
+    ]);
+}
+export function buildCashClaim(m, id, beneficiary, to, amount = 0n) {
+    uint(amount);
+    return buildCall(m, "programs", programsAbi, "claimCash", [id, address(beneficiary), address(to), amount]);
+}
+export function buildNFTClaim(m, id, beneficiary, milestone, to) {
+    uint(milestone);
+    return buildCall(m, "programs", programsAbi, "claimNFT", [id, address(beneficiary), milestone, address(to)]);
+}

package/dist/deployments.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Each release's deployment as its verified app manifest records it: the start block and that block's hash, every
+ * manifest role's runtime code hash, and the hash of the release's source verification on Blockscout.
+ * `scripts/release-deployment.mjs` writes this file from that manifest. A release stays null until every contract of
+ * it is deployed and its source verified.
+ */
+import type { HookrReleaseId, ReleaseDeployment } from "./releases.js";
+export declare const DEPLOYMENTS: Readonly<Record<HookrReleaseId, ReleaseDeployment | null>>;

package/dist/deployments.js

@@ -0,0 +1,26 @@
+export const DEPLOYMENTS = {
+    "hookr-1": {
+        startBlock: "82536327",
+        parentHash: "0xe77f49e3ad06e4d93c91a233449a290cfa3ad392b9ea980d822b8bbc0ba8e3b7",
+        runtimeHashes: {
+            poolManager: "0xbd3881180b547f5fe817545743cfb4343e96b1bc6640dcd70c106b0066e95626",
+            registry: "0xc16e7681583d8d9af8e8c54962f7e890b967687dee4cf32dbd676d4d547d2359",
+            root: "0xd336de325837e60a74cea11d87b5ebd1cc8961911f611f38de0508d23b6e779f",
+            rules: "0x4b6d50b40981b8082f3ee5a7ebf57e48489f71c94c2a3b94032a1d1a382b515b",
+            router: "0x855177b2017e7b73a79cb0c7b3027044beb5e726fbdc0fd2937229e32ecd7e0b",
+            quoter: "0x1623e56a309a31e3626b854cd87623d62e39f743e2943d1f36ba13d677cef67a",
+            launcher: "0x96b8c338c38a072ceef8b947ad93d3d7a46d2d7c70189d2b4ee92efb2a5e1d5d",
+            treasury: "0x95d1784c555685e9ccbc0ba9f6d1e6facea864fd1de77ebbc98862dcf2c13454",
+            programs: "0xedd6b1c99617bd0bb5cb1e6d1088144c579fe5ca0e21d3e4254ade8f4249a19f",
+            referrals: "0xc576e1b1254a8d1e0100f541d3f6d4fbe27029aa8a7eb55607db697543fd6894",
+            commissions: "0x66b72c0818a51f1f22b8d7e2c053e02606dc170754917d6fbd815fc42701ba9d",
+            forwarder: "0x3242bd3dea1be9c1ffd17b23475f2d1d11fb5ee9cdbe8328b309b7adb8427043",
+            rootFactory: "0xed0774e92af31e9799c7b91b764c4508d33fee4323a564801713714897183849",
+            feeAdvisory: "0x9b3c56e0749889dd01ab6c1a5247c1fb2f47bf92da5d08737f6570ed48fead74",
+            sessionAdvisory: "0x0e33fd89175de3909a2a51a4d93c0bd359b17dd9396dd49faeea0d49370d6e18",
+            liquidityVault: "0x6632211514f82b2f0fe6d9016cbdc5a7e2c688bc576a75d4ab1384fcc0344827",
+        },
+        evidenceHash: "0xd11146db666e226b65fc27ff225a777c076ab91fbf68f31ee27c3a6a4d30a85d",
+    },
+    "canary-hookr-1-a": null,
+};