@bordrless/shared 0.0.0-stage → 0.1.0

package/dist/policy.d.ts

@@ -0,0 +1,622 @@
+/**
+ * The launch policy and the pool math, mirroring `crates/bordrless-core` bit for bit (integer
+ * math in bigint), and the kit's reward accounting with its off-chain mirror, mirroring
+ * `bordrless_kit::math` and `bordrless_kit::mirror`. The numbers the site shows and the numbers
+ * the backend builds transactions from come from here. `vectors.test.ts` runs every case of
+ * `programs/tests/vectors/launch-fees.json`, which the Rust tests render from the reference the
+ * programs are held to, and requires exact equality.
+ */
+import type { LaunchRules, LaunchRulesInput, Side } from './api.ts';
+export declare const BPS = 10000n;
+export declare const WAD: bigint;
+/** The largest u64, where the programs' checked arithmetic stops. */
+export declare const U64_MAX: bigint;
+/** The largest u128 (the kit's `acc_per_share` and `rem`). */
+export declare const U128_MAX: bigint;
+/** Decimals of a launched token. */
+export declare const TOKEN_DECIMALS = 6;
+/** Supply of a launched token, base units: one billion whole tokens. */
+export declare const TOKEN_SUPPLY: bigint;
+/** Share of the supply sold on the curve; the rest is reserved for graduation. */
+export declare const CURVE_BPS = 7500n;
+/** LP fee of a launch pool, which stays in the pool for ever. */
+export declare const LP_FEE_BPS = 30;
+/** Protocol fee of an ordinary DEX pool (anyone's pool), in basis points of the quote side: the flat model (§3.1). */
+export declare const PROTOCOL_FEE_BPS = 100;
+/**
+ * Bordrless's take on a launch pool (its curve and the same pool after graduation), the share
+ * model of §3.1 (2026-10-07: "we earn 25% of their total fees, not 0.25%"): a quarter of what the
+ * launch's rules collect on each swap (the creator fee, holder rewards and any cut a creator's own
+ * hook takes), in SOL, rounded up, never more than the cuts. Burns and the pool's LP fee are not
+ * collected by anyone and are not shared. A launch whose rules collect nothing pays Bordrless
+ * nothing. Every launch-side figure uses this one; the flat rate above is for ordinary pools.
+ */
+export declare const LAUNCH_PROTOCOL_SHARE_BPS = 2500;
+/** The largest share the DEX config may set (`MAX_PROTOCOL_SHARE_BPS`): all of the cuts. */
+export declare const MAX_PROTOCOL_SHARE_BPS = 10000;
+/** Largest creator fee a launch may choose. */
+export declare const MAX_CREATOR_FEE_BPS = 200;
+/** The creator fee choices offered on the launch form. */
+export declare const CREATOR_FEE_CHOICES_BPS: readonly [0, 50, 100, 200];
+/** Seconds after creation during which the LP fee is elevated against snipers. */
+export declare const SNIPER_WINDOW_SECS = 30;
+/** LP fee at the first second of the sniper window, falling linearly to LP_FEE_BPS. */
+export declare const SNIPER_START_BPS = 8000;
+/** Paid by the creator to the treasury at launch. */
+export declare const LAUNCH_FEE_LAMPORTS = 10000000n;
+/** Bounds of the virtual quote reserve a launch may open with (bridged SOL, 9 decimals). */
+export declare const MIN_VIRTUAL_QUOTE = 1000000000n;
+export declare const MAX_VIRTUAL_QUOTE = 10000000000000n;
+/** LP units the pool keeps on the first deposit. */
+export declare const MINIMUM_LIQUIDITY = 1000n;
+/** Decimals of an LP mint. */
+export declare const LP_DECIMALS = 9;
+/** Decimals of bridged SOL. */
+export declare const SOL_DECIMALS = 9;
+/** The dollar market cap a launch opens at; the backend sets the virtual quote to hit it. */
+export declare const OPENING_MCAP_USD = 5000;
+/** Candle resolutions the API serves, in seconds. */
+export declare const CANDLE_RESOLUTIONS: {
+    readonly '1m': 60;
+    readonly '5m': 300;
+    readonly '15m': 900;
+    readonly '1h': 3600;
+    readonly '4h': 14400;
+    readonly '1d': 86400;
+};
+export type CandleResolution = keyof typeof CANDLE_RESOLUTIONS;
+export declare function mulDivFloor(a: bigint, b: bigint, d: bigint): bigint;
+export declare function mulDivCeil(a: bigint, b: bigint, d: bigint): bigint;
+/** A fee of `bps` on `amount`, rounded up. */
+export declare function feeAmount(amount: bigint, bps: number | bigint): bigint;
+/**
+ * Bordrless's share of `value`, the quote value of what a launch pool's hooks cut from one side of
+ * a swap (`bordrless_core::protocol_share`): `shareBps` of it, rounded up, never more than `value`
+ * (a share is at most 10,000). Pure: 0 in gives 0 out, so a launch whose rules collect nothing pays
+ * nothing.
+ */
+export declare function protocolShare(value: bigint, shareBps: number): bigint;
+/**
+ * The quote value of a base-side cut at the swap's own price (`bordrless_core::quote_value`):
+ * `ceil(cut * quoteLeg / baseLeg)` over the quote and base the curve exchanged; 0 for no cut.
+ * Only a creator's own token hook makes base-side cuts (the kit takes none); the launch quote math
+ * here does not model them.
+ */
+export declare function quoteValue(base: bigint, quoteLeg: bigint, baseLeg: bigint): bigint;
+export declare function isqrt(n: bigint): bigint;
+/** The reserves of a pool as the math sees them. */
+export interface Reserves {
+    baseReserve: bigint;
+    quoteReserve: bigint;
+    virtualBase: bigint;
+    virtualQuote: bigint;
+}
+/** Constant-product output of `amountIn` (after fees), or null when nothing comes out or the output would exceed the real reserve. */
+export declare function swapOut(amountIn: bigint, reserveIn: bigint, virtualIn: bigint, reserveOut: bigint, virtualOut: bigint): bigint | null;
+/**
+ * The input (after fees) that buys exactly `amountOut`, rounded up; null when `amountOut` is above
+ * the real reserve, when the curve can never give it (no virtual output reserve left beyond it), or
+ * when the input would not fit a u64 (`bordrless_core::swap_in_for_out`).
+ */
+export declare function swapInForOut(amountOut: bigint, reserveIn: bigint, virtualIn: bigint, reserveOut: bigint, virtualOut: bigint): bigint | null;
+/** The largest input (after fees) before the real output reserve is exhausted. */
+export declare function maxSwapIn(reserveIn: bigint, virtualIn: bigint, reserveOut: bigint, virtualOut: bigint): bigint | null;
+/** Spot price in quote base units per base base unit, times WAD. */
+export declare function spotPriceWad(r: Reserves): bigint;
+/** Spot price as a number: quote whole units per base whole unit. */
+export declare function spotPrice(r: Reserves, baseDecimals: number, quoteDecimals: number): number;
+/**
+ * The fees and the curve of one swap in the order of the v2 DEX (docs/hooks-v2.md §3.1),
+ * `bordrless_core::SwapAmounts`. The LP fee is on the input in both directions and stays in the
+ * pool; the protocol fee is always in the quote token, kept apart from the reserves: a buy's from
+ * what reached the vault, before the curve, a sell's from the curve's output.
+ */
+export interface SwapAmounts {
+    /** In the input token: `feeAmount(received, lpFeeBps)`. */
+    lpFee: bigint;
+    /** In the quote token: `feeAmount(received, protocolFeeBps)` on a buy, `feeAmount(outGross, protocolFeeBps)` on a sell. */
+    protocolFee: bigint;
+    /** What goes into the curve: what reached the vault less the LP fee and, on a buy, the protocol fee. */
+    netIn: bigint;
+    /** What the curve gives: it leaves the output reserve. */
+    outGross: bigint;
+    /** What the output side hands on: `outGross`, less a sell's protocol fee. A pool hook's `after_swap` is told this; without a hook it is delivered. */
+    amountOut: bigint;
+    /** What enters the input reserve: what reached the vault, less a buy's protocol fee. */
+    toReserveIn: bigint;
+}
+/** Why the DEX refuses a swap (`bordrless_core::SwapFailure`): `FeeExceedsInput`, `InsufficientLiquidity`, `FeeExceedsOutput`. */
+export type SwapFailure = 'fees_exceed_input' | 'insufficient_liquidity' | 'fee_exceeds_output';
+/**
+ * `bordrless_core::swap_amounts`: the amounts of a swap whose input vault received `received`
+ * (after any `before_swap` cut), or why the DEX refuses it. A fee that does not fit a u64 is larger
+ * than the amount it is taken from.
+ */
+export declare function swapAmounts(side: Side, received: bigint, lpFeeBps: number, protocolFeeBps: number, r: Reserves): (SwapAmounts & {
+    failure: null;
+}) | {
+    failure: SwapFailure;
+};
+/**
+ * A swap on a pool as the v2 DEX runs it (§3.1), `received` being what reached the input vault
+ * (the caller applies a hook's `before_swap` cut first, and its `after_swap` cut to `amountOut`).
+ * The protocol fee is in the quote token on both sides: a buy's from what reached the vault, a
+ * sell's from the curve's output, so a sell's `amountOut` is the curve's output less it. On a
+ * failure the fields are those computed up to it and `amountOut` is null.
+ */
+export declare function quoteSwap(r: Reserves, direction: Side, amountIn: bigint, lpFeeBps: number, protocolFeeBps: number): {
+    lpFee: bigint;
+    protocolFee: bigint;
+    netIn: bigint;
+    amountOut: bigint | null;
+    outGross: bigint | null;
+    toReserveIn: bigint;
+    failure: SwapFailure | null;
+};
+/** First LP: sqrt(base · quote), of which MINIMUM_LIQUIDITY stays with the pool. */
+export declare function initialLp(base: bigint, quote: bigint): {
+    toDepositor: bigint;
+    total: bigint;
+} | null;
+/** A later deposit: what is taken at the pool's ratio and the LP minted. */
+export declare function lpForDeposit(baseDesired: bigint, quoteDesired: bigint, baseReserve: bigint, quoteReserve: bigint, lpSupply: bigint): {
+    baseUsed: bigint;
+    quoteUsed: bigint;
+    lp: bigint;
+} | null;
+/** What `lp` shares withdraw. */
+export declare function withdrawForLp(lp: bigint, baseReserve: bigint, quoteReserve: bigint, lpSupply: bigint): {
+    base: bigint;
+    quote: bigint;
+} | null;
+export interface CurveParams {
+    curveTokens: bigint;
+    reserveTokens: bigint;
+    virtualQuote: bigint;
+    virtualBase: bigint;
+    graduationQuote: bigint;
+}
+/** The curve of a launch from the supply, the curve share and the virtual quote it opens with. */
+export declare function curveParams(supply: bigint, curveBps: bigint, virtualQuote: bigint): CurveParams | null;
+/** The market cap a curve opens at, in quote base units. */
+export declare function openingMcap(supply: bigint, p: CurveParams): bigint;
+/** The virtual quote that opens a curve at `mcap` quote base units (the inverse of openingMcap, rounded up). */
+export declare function virtualQuoteForMcap(supply: bigint, curveBps: bigint, mcap: bigint): bigint | null;
+/** Base to add at graduation so the price is continuous without the virtual offsets. */
+export declare function graduationTopup(r: Reserves): bigint;
+/** The LP fee during the sniper window. */
+export declare function sniperLpFee(now: number, createdAt: number, windowSecs: number, startBps: number, baseBps: number): number;
+/** The virtual quote for a launch opening at OPENING_MCAP_USD given the quote's dollar price, clamped to the bounds. */
+export declare function virtualQuoteForUsd(quoteUsd: number, quoteDecimals?: number, mcapUsd?: number): bigint;
+/** Bounds of token rules as the launch `Config` keeps them (§5.2); `create_launch` refuses anything outside them. */
+export interface RuleBounds {
+    maxHolderFeeBps: number;
+    maxBurnBps: number;
+    /** Creator + holders + burn on one side. */
+    maxRulesFeeBps: number;
+    minMaxWalletBps: number;
+    maxMaxWalletBps: number;
+    maxCreatorLockSecs: number;
+    maxEarlyWindowSecs: number;
+    maxEarlyLockSecs: number;
+}
+/** The policy every launch config is set to. */
+export declare const RULE_BOUNDS: Readonly<RuleBounds>;
+/** Ceilings `init_config` and `set_config` enforce, which no config can raise (max wallet stays below 10,000; 1 is the kit's own floor). */
+export declare const RULE_CEILINGS: Readonly<RuleBounds>;
+/** The smallest launch supply a config may set (a ceiling of §5.2), so `min_eligible` is at least 1. */
+export declare const MIN_LAUNCH_SUPPLY = 1000n;
+/** The largest launch supply a config may set: the kit installs on no larger supply (§4.11). */
+export declare const MAX_LAUNCH_SUPPLY = 10000000000000000n;
+/** Holder rewards offered on the launch form, per side (§7.1). */
+export declare const HOLDER_FEE_CHOICES_BPS: readonly [0, 50, 100, 200];
+/** Burn offered on the launch form, per side. */
+export declare const BURN_CHOICES_BPS: readonly [0, 25, 50, 100];
+/** Max wallet offered on the launch form, as a share of supply until graduation. */
+export declare const MAX_WALLET_CHOICES_BPS: readonly [0, 100, 200, 300, 500];
+/** Creator wallet lock offered on the launch form, in days. */
+export declare const CREATOR_LOCK_CHOICES_DAYS: readonly [0, 7, 30, 90];
+/** Early-buyer lock: buys this many seconds after the launch or sooner are locked. */
+export declare const EARLY_WINDOW_CHOICES_SECS: readonly [0, 30, 60, 300];
+/** Early-buyer lock: seconds after the launch when those tokens unlock (15 min, 1 h, 24 h). */
+export declare const EARLY_LOCK_CHOICES_SECS: readonly [900, 3600, 86400];
+/** No token rules. */
+export declare const NO_RULES: Readonly<LaunchRulesInput>;
+/** The §7.1 per-rule defaults the Custom path starts from when a rule is switched on: holder rewards 1% both sides, max wallet 2%, creator wallet lock 30 days, no burn, no early-buyer lock. (The preset the form starts on is Plain.) */
+export declare const DEFAULT_RULES: Readonly<LaunchRulesInput>;
+/** Holder rewards are on when either side takes a holder fee. */
+export declare const rewardsOn: (r: Pick<LaunchRulesInput, "holderFeeBuyBps" | "holderFeeSellBps">) => boolean;
+/** The default creator fee: 0.5% with holder rewards on, else 1%. */
+export declare const defaultCreatorFeeBps: (r: LaunchRulesInput) => number;
+/** The four presets of §7.1 (2026-10-07: Holders first, Fair start, Scorched and Community are gone). */
+export type RulePresetName = 'Plain' | 'Diamond hands' | 'Burn' | 'Paid to hold';
+/** The two ways beside the presets (§7.1): Custom mixes the rules by hand with the form's controls; Build your own launches from a `LaunchConfig` a creator made with the SDK (§5.7). */
+export type RulePathName = 'Custom' | 'Build your own';
+/** What the launch form's rules row can be set to: a preset, or one of the two paths. */
+export type RuleModeName = RulePresetName | RulePathName;
+export interface RulePreset {
+    name: RulePresetName;
+    /** How links name it: `/launch?preset=<slug>`. */
+    slug: string;
+    /** One line: what it sets. */
+    description: string;
+    /** The creator fee it sets. */
+    creatorFeeBps: number;
+    /** The rules it sets. */
+    rules: Readonly<LaunchRulesInput>;
+}
+export interface RulePath {
+    name: RulePathName;
+    /** How links name it: `/launch?preset=<slug>`. */
+    slug: string;
+    /** One line: what it is. */
+    description: string;
+}
+/**
+ * The presets of the launch form, in order (§7.1), the one list the launch page, the home page and
+ * the docs read; `bordrless_core::policy::presets::ALL` is the same list, and the fee vectors pin
+ * this one to it. Each stays within the §5.2 bounds and the 3%-per-side cap (the policy test checks
+ * every one). Holder rewards set "both sides" take the same rate on buys and sells.
+ */
+export declare const RULE_PRESETS: readonly RulePreset[];
+/** The two paths beside the presets, in order, with the words the home console and the launch form print. */
+export declare const RULE_PATHS: readonly RulePath[];
+/** The preset the launch form starts on. */
+export declare const DEFAULT_RULE_PRESET: RulePresetName;
+/** The preset of this name. */
+export declare function presetNamed(name: RulePresetName): RulePreset;
+/** Kit module bits (§4.2). */
+export declare const KIT_MODULES: {
+    readonly HOLDER_REWARDS: 1;
+    readonly MAX_WALLET: 2;
+    readonly CREATOR_LOCK: 4;
+    readonly EARLY_LOCK: 8;
+};
+/** The kit modules a launch with these rules installs (§5.1); 0 means no hook at all (a burn alone runs in the pool hook). */
+export declare function kitModules(r: LaunchRulesInput): number;
+/**
+ * The token hook flags a kit mint carries for `modules` (§4.2, `bordrless_kit::mint_flags`):
+ * `BEFORE_TRANSFER`, plus `BEFORE_BURN | WRITES_HOOK_DATA` with holder rewards or the early-buyer
+ * lock; 0 (no hook at all) without modules. So 1 for modules 2, 4 or 6, and 145 whenever 1 or 8 is
+ * among them. A mint naming the kit with other flags is not a kit token (§4.15).
+ */
+export declare function kitMintFlags(modules: number): number;
+/** The rules a launch made at `launchedAt` (unix seconds) carries, as the API shows them. */
+export declare function launchRulesAt(r: LaunchRulesInput, launchedAt: number): LaunchRules;
+/**
+ * Why `create_launch` would refuse these rules with this creator fee under `bounds`, as the sentence
+ * the launch form shows; null when it would take them. An early-buyer lock needs its window, and its
+ * tokens must unlock after the window ends.
+ */
+export declare function checkLaunchRules(r: LaunchRulesInput, creatorFeeBps: number, bounds?: Readonly<RuleBounds>): string | null;
+/**
+ * §8.1 `preset`: the §7.1 preset whose rules and creator fee a launch matches exactly, 'custom' for
+ * other rules (and for a config without a custom hook), 'custom-hook' for a launch made from a
+ * config with a creator's own hook, null for a launch without rules and without a hook.
+ */
+export declare function presetOf(r: LaunchRulesInput, creatorFeeBps: number, customHook?: boolean): string | null;
+/** §4.9: a buy from the launch pool landing at `now` inside the early window is locked until the early unlock; null when it is not. */
+export declare function buyLockedUntil(rules: Pick<LaunchRules, 'earlyWindowEndsAt' | 'earlyUnlockAt'>, now: number): number | null;
+/** A launch's fee rates and the holder-fee threshold, as its pool hook reads them. */
+export interface LaunchFeeParams {
+    creatorFeeBps: number;
+    holderFeeBuyBps: number;
+    holderFeeSellBps: number;
+    burnBuyBps: number;
+    burnSellBps: number;
+    /** `KitConfig.eligible` before the trade; 0 without holder rewards. */
+    eligible: bigint;
+    /** `KitConfig.min_eligible` (the supply / 1,000); 0 without holder rewards. */
+    minEligible: bigint;
+}
+/** What the launch hook takes in one callback: creator and holder fees in bridged SOL, the burn in tokens. */
+export interface HookCut {
+    creatorFee: bigint;
+    holderFee: bigint;
+    burn: bigint;
+}
+/**
+ * The creator and holder fees from `amount` of bridged SOL (a buy's input, a sell's output): each
+ * rounded up, the holder fee only while `eligible >= minEligible`, and neither when together they are
+ * not below the amount.
+ */
+export declare function creatorAndHolderFees(amount: bigint, creatorFeeBps: number, holderFeeBps: number, eligible: bigint, minEligible: bigint): {
+    creatorFee: bigint;
+    holderFee: bigint;
+};
+/** The burn from `amount` of tokens (a buy's output, a sell's input): rounded down, and none when it is not below the amount. */
+export declare function tradeBurn(amount: bigint, burnBps: number): bigint;
+/** The hook's `before_swap` cut from the input: a buy's creator and holder fees, a sell's burn. `p.eligible` is the count before the trade. */
+export declare function launchBeforeSwap(side: Side, amountIn: bigint, p: LaunchFeeParams): HookCut;
+/** The hook's `after_swap` cut from the output: a buy's burn, a sell's creator and holder fees. For a sell, `p.eligible` is the count once the input has left the seller. */
+export declare function launchAfterSwap(side: Side, amountOut: bigint, p: LaunchFeeParams): HookCut;
+/** A swap on a launch pool, step by step. */
+export interface LaunchSwap {
+    /** Bridged SOL to the creator: from a buy's input, or from a sell's output after the protocol fee. */
+    creatorFee: bigint;
+    /** Bridged SOL to holders, likewise. */
+    holderFee: bigint;
+    /** Tokens burned: from a buy's output, or a sell's input. */
+    burn: bigint;
+    /** The holder-fee threshold was met when the hook took this side's fees. */
+    holderFeeOn: boolean;
+    /** What reached the input vault. */
+    received: bigint;
+    /** The LP fee, in the input token, on what reached the vault. */
+    lpFee: bigint;
+    /** Bordrless's share of the creator and holder fees (`LAUNCH_PROTOCOL_SHARE_BPS` of them, rounded up; 0 when they are 0), always in bridged SOL: on a buy from what reached the vault, before the curve; on a sell held back from the delivery. */
+    protocolFee: bigint;
+    /** What went into the curve: `received` less the LP fee (and, on a buy, the protocol fee); negative when the fees take more than arrived. */
+    netIn: bigint;
+    /** What the curve gave (on a sell, before the protocol fee and the creator and holder fees); null when the swap fails. */
+    amountOut: bigint | null;
+    /** What reaches the recipient; null when the swap fails. */
+    delivered: bigint | null;
+    /** Why the swap fails: the fees take the whole input, nothing would reach the wallet, or the pool cannot fill it; null when it lands. */
+    failure: 'fees_exceed_input' | 'no_output' | 'insufficient_liquidity' | null;
+}
+/** The constant-product output for `netIn` going into the curve, rounded down, before the check against the real reserve. */
+export declare function curveOutput(r: Reserves, side: Side, netIn: bigint): bigint;
+/**
+ * A swap on a launch pool as the v2 DEX runs it with the launch hook under the share model (§3.1,
+ * §5.4; the Rust reference is `bordrless_program_tests::launch::quote_launch_swap`): Bordrless
+ * takes `protocolShareBps` of the creator and holder fees (the hooks' cuts; the kit takes none of
+ * its own, so the cuts are exactly those fees), in bridged SOL, and nothing when they are nothing.
+ * A buy: the creator and holder fees from the input, Bordrless's share of them and the LP fee on
+ * what reached the vault, the curve, the burn from the output. A sell: the burn from the input, the
+ * LP fee on what reached the vault, the curve, then the creator and holder fees from the output and
+ * Bordrless's share of them held back from the delivery. A sell takes its input out of the kit's
+ * eligible count before `after_swap` reads it (every seller is a holder: the pool and the launch
+ * never sell). An ordinary pool's flat rate is `quoteSwap`.
+ */
+export declare function quoteLaunchSwap(r: Reserves, side: Side, amountIn: bigint, lpFeeBps: number, protocolShareBps: number, p: LaunchFeeParams): LaunchSwap;
+/** What a launch-pool swap adds to its input reserve (the Rust reference's `to_reserve_in`): what reached the vault, less a buy's protocol fee. */
+export declare const launchSwapToReserve: (side: Side, q: Pick<LaunchSwap, "received" | "protocolFee">) => bigint;
+/**
+ * Whether a buy that lands leaves the pool's quote reserve at or above the graduation threshold, so
+ * `graduate` can follow it in the same transaction (§8.2: the input after the creator and holder
+ * fees, less the protocol fee, joins the reserve; the launch graduates once `quote_reserve >=
+ * graduation_quote`).
+ */
+export declare function buyGraduates(r: Reserves, q: LaunchSwap, graduationQuote: bigint): boolean;
+/**
+ * §8.2 `maxAmountIn` on a curve pool: the largest buy the curve can still fill with these fees (one
+ * lamport more and the DEX refuses it, `InsufficientLiquidity`), found with the quote itself rather
+ * than by dividing out the fees, so the rounding is the programs'. Only meaningful on a curve: a pool
+ * without virtual reserves can always fill a buy.
+ */
+export declare function curveMaxBuyIn(r: Reserves, lpFeeBps: number, protocolShareBps: number, p: LaunchFeeParams): bigint;
+/** `1 - Π(1 - fee_i)` in basis points, rounded up so the figure never understates. */
+export declare function compoundFeeBps(feesBps: readonly number[]): number;
+/**
+ * One side's fee rates. `holderFeeBps` is 0 while nobody is eligible; `lpFeeBps` is the current LP
+ * fee (the sniper fee while elevated), or the base rate for a launch's standing figure. How
+ * Bordrless is paid follows the pool's model (§3.1): `protocolShareBps` of the creator and holder
+ * fees on a launch pool (the share model; `LAUNCH_PROTOCOL_SHARE_BPS`), or a flat `protocolFeeBps`
+ * of the quote on an ordinary pool. Either left out counts as 0.
+ */
+export interface SideFees {
+    lpFeeBps: number;
+    creatorFeeBps: number;
+    holderFeeBps: number;
+    burnBps: number;
+    /** The share model: Bordrless's share of the cuts, in basis points. */
+    protocolShareBps?: number;
+    /** The flat model: a rate of the quote, in basis points. */
+    protocolFeeBps?: number;
+}
+/** What Bordrless's share comes to as a rate of the trade, in basis points (may be fractional: 150 bps of cuts at a quarter is 37.5). 0 when the rules collect nothing. */
+export declare function protocolShareBps(cutsBps: number, shareBps?: number): number;
+/**
+ * The total fee of one side as one figure (§7.3), in the order the v2 DEX charges it, rounded up to
+ * a basis point so the figure never understates. With `s` Bordrless's share of the cuts and `flat`
+ * an ordinary pool's rate (one of them 0):
+ * a buy `1 - (1 - (creator + holders)(1 + s))(1 - lp - flat)(1 - burn)`,
+ * a sell `1 - (1 - burn)(1 - lp)(1 - flat)(1 - (creator + holders)(1 + s))`.
+ * Plain on a launch pool (creator 1%, LP 0.3%, s = 0.25): 1 - 0.9875 · 0.997 = 1.5437%, 155 bps;
+ * Diamond hands (holders 1%, creator 0.5%): 1 - 0.98125 · 0.997 = 2.1694%, 217 bps a side.
+ */
+export declare function sideFeeBps(side: Side, f: SideFees): number;
+/** How far a swap's price on the curve (fees excluded) is from the spot price before it, in basis points, rounded to nearest. */
+export declare function curveImpactBps(r: Reserves, side: Side, netIn: bigint, amountOut: bigint): number;
+/** The max-wallet cap, fixed at launch (`bordrless_core::max_wallet_cap`): the launch supply times the bps, rounded down; 0 when off. */
+export declare function maxWalletCap(supplyAtLaunch: bigint, maxWalletBps: number): bigint;
+/** What a wallet holding `balance` can still receive: the kit refuses a transfer that would take it above `cap`. */
+export declare function maxWalletLeft(cap: bigint, balance: bigint): bigint;
+/**
+ * The largest buy the pool can fill whose delivery stays within `allowance` tokens; 0 when no buy
+ * does. Fees rounding up make the boundary ragged by a few base units, so this bisects on the exact
+ * quote and then looks a little past the boundary.
+ */
+export declare function maxBuyWithin(r: Reserves, lpFeeBps: number, protocolShareBps: number, p: LaunchFeeParams, allowance: bigint): bigint;
+/**
+ * §8.2 `devBuyMaxLamports`: the largest first buy, in lamports, whose tokens after the buy burn stay
+ * within max wallet at the opening reserves, with the fees of the creator's own first buy (the normal
+ * LP fee, the creator fee and Bordrless's share of it; no holder fee, as nobody is eligible yet).
+ * Null without max wallet. A bot that buys first only makes the creator receive less.
+ */
+export declare function devBuyMaxLamports(curve: CurveParams, supply: bigint, rules: LaunchRulesInput, creatorFeeBps: number, lpFeeBps: number, protocolShareBps: number): bigint | null;
+/** Scale of the reward accounting: `acc_per_share` is lamports per eligible base unit times SCALE. */
+export declare const SCALE: bigint;
+/** `min_eligible` is the supply / 1,000, set at init: holder fees wait until holders hold that much. */
+export declare const MIN_ELIGIBLE_DIVISOR = 1000n;
+export declare const minEligibleFor: (supply: bigint) => bigint;
+/** `min_eligible` at the policy supply: 1,000,000 whole tokens. */
+export declare const MIN_ELIGIBLE: bigint;
+/** The least "Share with holders" takes: 0.001 SOL. */
+export declare const MIN_SHARE_LAMPORTS = 1000000n;
+/** A share streams to holders over this many seconds of eligible holding: from when it is made, or from when the share streaming then ends (§4.10, the review fixes). */
+export declare const SHARE_STREAM_SECS = 3600;
+/** Claims below 0.0005 SOL (about 100 times a claim's network fee) are hidden by default (§7.3). */
+export declare const CLAIM_DUST_LAMPORTS = 500000n;
+/**
+ * The reward accounting `KitConfig` keeps (§4.3, with the review fixes); times are unix seconds.
+ * The SDK's `kitRewardsOf` reads it from a decoded `KitConfig`.
+ */
+export interface KitRewards {
+    /** Balances of every holding whose owner is not excluded (the pool and the launch are). */
+    eligible: bigint;
+    minEligible: bigint;
+    /** Lamports per eligible base unit, times SCALE. */
+    accPerShare: bigint;
+    /** Scaled remainder of the last division, below the eligible supply it was divided by. */
+    rem: bigint;
+    /** Lamports waiting while nobody or too little is eligible (direct donations only: the stream pauses then). */
+    held: bigint;
+    /** `reward_vault.amount + total_claimed` at the last sync, counting shares as seen when they arrive. */
+    seen: bigint;
+    /** The running stream's lamports not yet released to holders. */
+    streamRemaining: bigint;
+    /** The running stream's last release. */
+    streamLast: number;
+    /** The running stream's end. While nobody is eligible it moves on with the clock. */
+    streamEnd: number;
+    /** Lamports shared while the stream runs, waiting for it: they stream over the hour after `streamEnd`. */
+    streamNext: bigint;
+    totalDistributed: bigint;
+    totalClaimed: bigint;
+    totalShared: bigint;
+    /** `KitConfig.modules`: without holder rewards (bit 1) nothing is ever claimable. Absent counts as holder rewards on. */
+    modules?: number;
+}
+/** A holding's hook data under the kit (§4.4). */
+export interface KitHookData {
+    /** `acc_per_share` at the holder's last settle. */
+    snapshot: bigint;
+    /** Rewards earned and not claimed, lamports. */
+    owed: bigint;
+    /** Tokens bought in the early window. */
+    earlyLocked: bigint;
+}
+/** 64 bytes of hook data: snapshot u128, owed u64, early_locked u64, little-endian, then 32 reserved bytes. */
+export declare function decodeKitHookData(data: Uint8Array): KitHookData;
+/** The inverse of decodeKitHookData, reserved bytes zero. */
+export declare function encodeKitHookData(d: KitHookData): Uint8Array;
+/** Whether a sync divides among holders: `eligible > 0` and `eligible >= min_eligible` (`KitConfig::divides`). */
+export declare const kitDivides: (k: Pick<KitRewards, "eligible" | "minEligible">) => boolean;
+/**
+ * What a linear stream of `amount` over `[from, to]` releases at `now`, rounded down: all of it at or
+ * after `to`, nothing at or before `from` (`bordrless_kit::math::stream_release`, `mirror::linear`).
+ */
+export declare function linearRelease(amount: bigint, from: number, to: number, now: number): bigint;
+/** The stream at a moment: what it releases, and what is left running and waiting after it. */
+export interface KitStream {
+    released: bigint;
+    streamRemaining: bigint;
+    streamNext: bigint;
+}
+/**
+ * The shared stream at `now` (`bordrless_kit::mirror::stream_at`): the running stream's linear
+ * release; once it is out (`now >= streamEnd`), the waiting shares' release over the hour after its
+ * end. Nothing while holders hold less than `minEligible`. Null on an overflow.
+ */
+export declare function streamAt(k: Pick<KitRewards, 'eligible' | 'minEligible' | 'streamRemaining' | 'streamLast' | 'streamEnd' | 'streamNext'>, now: number): KitStream | null;
+/** What the shared stream releases at `now`, rounded down (`mirror::released_at`): 0 while nobody is eligible. */
+export declare function streamReleased(k: Pick<KitRewards, 'eligible' | 'minEligible' | 'streamRemaining' | 'streamLast' | 'streamEnd' | 'streamNext'>, now: number): bigint | null;
+/** The state a sync at `now` would leave, without writing anything (`bordrless_kit::mirror::Synced`). */
+export interface KitSynced {
+    /** What the shared stream releases at `now`. */
+    released: bigint;
+    /** What arrived since the last sync (`vault + total_claimed - seen`), plus `released`. */
+    pending: bigint;
+    /** Whether this sync divides: holders hold at least `minEligible`, and there is something to divide. */
+    divides: boolean;
+    accPerShare: bigint;
+    held: bigint;
+    /** The running stream's lamports not yet released, after the sync. */
+    streamRemaining: bigint;
+    /** Shares waiting for the running stream, after the sync. */
+    streamNext: bigint;
+    /** `total_distributed` after the sync. */
+    distributed: bigint;
+    /** Shared lamports not yet released: `streamRemaining + streamNext` (saturating), i.e. `stream_remaining + stream_next - released`. */
+    streaming: bigint;
+}
+/** The mirror's sync at `now` with the reward vault holding `vaultAmount` (`bordrless_kit::mirror::synced`). Null when the state is impossible. */
+export declare function kitSynced(k: KitRewards, vaultAmount: bigint, now: number): KitSynced | null;
+/**
+ * The off-chain mirror (§4.13) at `now` (`bordrless_kit::mirror::claimable`): what a holder could
+ * claim, from `KitConfig`, the reward vault's balance, the holding's balance and its hook data, and
+ * what a claim would pay (no more than the vault holds). 0 for the pool and the launch (`excluded`)
+ * and for a token without holder rewards. Null when the kit's state cannot be synced.
+ */
+export declare function rewardsClaimable(k: KitRewards, vaultAmount: bigint, now: number, balance: bigint, data: KitHookData, excluded?: boolean): {
+    claimable: bigint;
+    payable: bigint;
+} | null;
+/**
+ * §4.13 totals at `now`, lamports: distributed (with what the next sync would distribute), claimed,
+ * shared, and shared but still streaming (`rewardsStreaming`: `stream_remaining + stream_next -
+ * released`); also what the stream releases now and what waits in `held`. Null when the state
+ * cannot be synced.
+ */
+export declare function rewardTotals(k: KitRewards, vaultAmount: bigint, now: number): {
+    distributed: bigint;
+    claimed: bigint;
+    shared: bigint;
+    streaming: bigint;
+    released: bigint;
+    held: bigint;
+} | null;
+/**
+ * `KitConfig::release` at `now`, as the program runs it: the running stream releases linearly; once
+ * it is out the waiting shares become the running stream over the hour after its end, and the part
+ * of that hour already past is released with it. While nobody is eligible nothing is released and
+ * the end moves on by the time that passed. Null on an overflow.
+ */
+export declare function kitRelease(k: KitRewards, now: number): {
+    state: KitRewards;
+    released: bigint;
+} | null;
+/**
+ * The kit's sync at `now` as the program runs it (`KitConfig::sync`, §4.7 with the review fixes):
+ * the stream releases (`kitRelease`), then what reached the reward vault since the last sync plus
+ * what was released is spread over the eligible supply with the exact scaled remainder kept, or held
+ * while nobody or too little is eligible. Null when the vault and the claims fall short of what the
+ * accounting has seen, or on an overflow, which the program reverts on.
+ */
+export declare function kitSync(k: KitRewards, vaultAmount: bigint, now: number): KitRewards | null;
+/**
+ * `KitConfig::add_share`: a share of `received` lamports made at `now`, right after the sync at
+ * `now`, counted as seen and streamed over one hour at its own rate: at once when nothing streams or
+ * waits; joining the running stream when that stream's whole hour is still ahead; otherwise waiting
+ * with any shares already waiting, for the hour after the running stream. Null (the program's
+ * `MathOverflow`, a bug) when the stream was not synced at `now`, or on an overflow.
+ */
+export declare function kitAddShare(k: KitRewards, received: bigint, now: number): KitRewards | null;
+/**
+ * The kit's settle (§4.8, `bordrless_kit::math::settle`) of a holder at its balance before the
+ * operation: `owed += balance * (accPerShare - snapshot) / SCALE` (floor), then `snapshot =
+ * accPerShare`, or 0 when the balance after the operation is 0. Null when the snapshot is above the
+ * accumulator or on an overflow (the program's `MathOverflow`).
+ */
+export declare function kitSettle(d: KitHookData, balance: bigint, balanceAfter: bigint, accPerShare: bigint): KitHookData | null;
+/**
+ * The kit's `share(amount)` at `now` with the reward vault holding `vaultAmount`: refused (null) below
+ * MIN_SHARE_LAMPORTS, while nobody is eligible or without holder rewards; else the sync, the
+ * transfer into the vault (bridged SOL has no hook, so all of it arrives) and `kitAddShare`.
+ */
+export declare function kitShare(k: KitRewards, vaultAmount: bigint, amount: bigint, now: number): {
+    state: KitRewards;
+    vault: bigint;
+} | null;
+/**
+ * The kit's `claim` at `now` by a holder with `balance` and hook data `data`: the sync, the settle at
+ * the balance, then `min(owed, vault)` paid. Null when the kit refuses it: the pool or the launch
+ * (`excluded`), no holder rewards, nothing to pay, or a state it cannot sync. The early-buyer bytes
+ * of the hook data are kept as they are.
+ */
+export declare function kitClaim(k: KitRewards, vaultAmount: bigint, now: number, balance: bigint, data: KitHookData, excluded?: boolean): {
+    state: KitRewards;
+    vault: bigint;
+    data: KitHookData;
+    pay: bigint;
+} | null;
+/**
+ * When a share made at `now` starts streaming, unix seconds (§7.3's share copy, as the second round
+ * of review fixes words it): `now` when nothing streams or waits, or when the running stream's whole
+ * hour is still ahead (the share joins it); otherwise when the running stream ends, after the sync
+ * the share makes first. Null while nobody is eligible (the kit refuses a share then) or when the
+ * state cannot be synced.
+ */
+export declare function shareStartsAt(k: KitRewards, vaultAmount: bigint, now: number): number | null;