@bordrless/shared 0.9.0 → 0.10.0

package/dist/policy.js

@@ -757,7 +757,28 @@ export function scriptRequestOf(companion) {
     const initData = r.initData === undefined || r.initData === null ? '' : r.initData;
     if (typeof initData !== 'string' || scriptInitDataLength(initData) === null)
         return 'malformed';
-    return { potBps: r.potBps, program: r.program, interval: r.interval, initData, stateLen: r.stateLen };
+    const payout = payoutTermsRequestOf(r.payout);
+    if (payout === 'malformed')
+        return 'malformed';
+    return { potBps: r.potBps, program: r.program, interval: r.interval, initData, stateLen: r.stateLen, ...(payout ? { payout } : {}) };
+}
+/** The companion program's bounds on payout terms (`PayoutTermsArgs::valid`): each share 1 to 10,000 basis points, the window 10 seconds to a day. */
+export const PAYOUT_TERMS_BOUNDS = { minWindowSecs: 10, maxWindowSecs: 86_400 };
+/** A script's payout terms as a request names them (`script.payout`); null without them; `'malformed'` when they are there and not four whole numbers. */
+function payoutTermsRequestOf(raw) {
+    if (raw === undefined || raw === null)
+        return null;
+    if (typeof raw !== 'object')
+        return 'malformed';
+    const r = raw;
+    if (![r.stepBps, r.holdingBps, r.windowBps].every(isShare) || typeof r.windowSecs !== 'number' || !Number.isInteger(r.windowSecs))
+        return 'malformed';
+    return { stepBps: r.stepBps, holdingBps: r.holdingBps, windowBps: r.windowBps, windowSecs: r.windowSecs };
+}
+/** Whether payout terms are within the companion program's bounds (`create_script_v2` refuses them otherwise, `BadPayoutTerms`). */
+export function payoutTermsWithin(t) {
+    const share = (v) => Number.isInteger(v) && v >= 1 && v <= 10_000;
+    return share(t.stepBps) && share(t.holdingBps) && share(t.windowBps) && Number.isInteger(t.windowSecs) && t.windowSecs >= PAYOUT_TERMS_BOUNDS.minWindowSecs && t.windowSecs <= PAYOUT_TERMS_BOUNDS.maxWindowSecs;
 }
 /**
  * Why a custom companion with this split can't run these rules at this fee, in the words the launch
@@ -779,6 +800,8 @@ export function scriptProblem(s, split, rules, creatorFeeBps) {
         return `The script’s init data is at most ${B.maxInitLen} bytes.`;
     if (!Number.isInteger(s.stateLen) || s.stateLen < 0 || s.stateLen > B.maxStateLen)
         return `The script’s state is 0 to ${B.maxStateLen.toLocaleString('en-US')} bytes.`;
+    if (s.payout && !payoutTermsWithin(s.payout))
+        return 'The script’s payout limits are each 0.01% to 100%, over a window of 10 seconds to a day.';
     if (rules.creatorLockDays > 0)
         return 'A creator fee run by a program can’t come with the creator wallet lock: the program vests your first buy instead.';
     if (creatorFeeBps === 0)
@@ -787,6 +810,217 @@ export function scriptProblem(s, split, rules, creatorFeeBps) {
         return 'A share of the creator fee for holders needs holder rewards on.';
     return null;
 }
+// ---- Payees and wallet payouts (2026-10-13, docs/payees-and-wallet-payouts.md) ---------------------
+/** The most wallets that share a launcher's part (`set_payees`; the SDK's `MAX_PAYEES`). */
+export const MAX_PAYEES = 10;
+/** The system program's id, the default key: never a payee. */
+const DEFAULT_KEY = '11111111111111111111111111111111';
+/** The payees a launch request's `companion` names (`companion.payees`); null without any (absent, null or empty); `'malformed'` when they are there and not a list of `{ wallet, bps }` with an address and a whole number. */
+export function payeesRequestOf(companion) {
+    if (typeof companion !== 'object' || companion === null)
+        return null;
+    const raw = companion.payees;
+    if (raw === undefined || raw === null)
+        return null;
+    if (!Array.isArray(raw))
+        return 'malformed';
+    if (raw.length === 0)
+        return null;
+    const out = [];
+    for (const entry of raw) {
+        if (typeof entry !== 'object' || entry === null)
+            return 'malformed';
+        const e = entry;
+        if (typeof e.wallet !== 'string' || !BASE58_ADDRESS.test(e.wallet) || typeof e.bps !== 'number' || !Number.isInteger(e.bps))
+            return 'malformed';
+        out.push({ wallet: e.wallet, bps: e.bps });
+    }
+    return out;
+}
+/** What the payees leave the launcher of their part, basis points of it (10,000 with none). */
+export const payeesLeaveBps = (payees) => 10_000 - payees.reduce((sum, p) => sum + p.bps, 0);
+/**
+ * Why `set_payees` would refuse these payees (`BadPayees`), in the words the launch form and the
+ * backend use (`companion_rules`); null when it would take them: 1 to 10 wallets, each named once,
+ * each 0.01% to 100% of the launcher's part and 100% in all at most; none the default key, the
+ * launcher (`beneficiary`) or one of `reserved` (the companion and its creator address, which the
+ * backend derives for the mint). A split with no part for the launcher has nothing to share.
+ */
+export function payeesProblem(payees, split, beneficiary, reserved = []) {
+    if (payees.length === 0 || payees.length > MAX_PAYEES)
+        return `Up to ${MAX_PAYEES} wallets can share your part.`;
+    if (split.beneficiaryBps <= 0)
+        return 'The wallets share your part of the creator fee, and this split leaves you none.';
+    if (payees.some((p) => !Number.isInteger(p.bps) || p.bps < 1 || p.bps > 10_000))
+        return 'Each wallet gets 0.01% to 100% of your part.';
+    if (payeesLeaveBps(payees) < 0)
+        return 'The wallets’ shares add up to more than 100% of your part.';
+    const seen = new Set();
+    for (const p of payees) {
+        if (!BASE58_ADDRESS.test(p.wallet) || p.wallet === DEFAULT_KEY)
+            return `${p.wallet} is not a wallet.`;
+        if (seen.has(p.wallet))
+            return 'Name each wallet once.';
+        seen.add(p.wallet);
+        if (p.wallet === beneficiary)
+            return 'You keep what the wallets don’t take: name wallets other than your own.';
+        if (reserved.includes(p.wallet))
+            return 'A wallet can’t be the hook’s own account.';
+    }
+    return null;
+}
+/**
+ * Why a request's `allowWalletPayouts` can't be taken (`companion_rules`); null when it can, or it
+ * is off: only a custom hook's script with payout terms (`script.payout`, `create_script_v2`) may
+ * pay wallets, never Lossback's (its script pays holders under water, and nothing else).
+ */
+export function walletPayoutsProblem(allow, script) {
+    if (!allow)
+        return null;
+    if (!script)
+        return 'Only a custom hook’s script can pay wallets.';
+    if (!script.payout)
+        return 'A script pays wallets only within payout limits: set them.';
+    return null;
+}
+// ---- Loss cover (2026-10-12; the site says Lossback): the pot pays holders who are under water (docs/loss-cover.md) ----
+/**
+ * The bounds a Lossback coin's terms keep within, as the site offers them: the programs' own
+ * (`loss_cover_script::CoverTerms::valid`, the companion's `PayoutTermsArgs::valid`) and the
+ * policy's tighter ones (the step at least 10 s and at most a quarter of the round, a holding of
+ * at most 1% of the supply, a loss of at least 0.0001 SOL, a wait of at most a day). The keeper's
+ * batches (`batchPaying`, `batchMeasuring`) are what one step carries within the runtime's
+ * instruction trace, measured by the programs' `loss_cover_vectors` (a measuring step carries one
+ * fewer on a coin's first step, when the creator's holding is made on the way).
+ */
+export const LOSS_COVER_LIMITS = {
+    minRoundSecs: 60,
+    maxRoundSecs: DAY_SECS,
+    minStepSecs: 10,
+    maxStepSecs: 3_600,
+    /** The step is at most this part of the round: a round has at least four steps. */
+    stepsPerRoundMin: 4,
+    minBps: 100,
+    maxBps: 10_000,
+    minCoverBps: 1_000,
+    maxCoverBps: 10_000,
+    /** The least holding that counts, at most this part of the supply (basis points). */
+    maxMinHoldingBps: 100,
+    minMinLossLamports: 100000n,
+    maxMinAgeSecs: DAY_SECS,
+    maxMinPotLamports: 100000000000n,
+    batchPaying: 7,
+    batchMeasuring: 13,
+};
+/**
+ * The terms the site launches a Lossback coin with: rounds of 5 minutes stepped every 15 seconds,
+ * the whole pot available to each step, each holding and each round, the whole loss covered when
+ * the pot can, a holding of 100,000 tokens (6 decimals: base units) and a loss of 0.001 SOL at
+ * least, a minute after its last buy (the owner, 2026-10-12; the first coin, LIFEVEST, was made with
+ * half an hour, fixed in its script state), a round only once the pot holds 1 SOL, the hook's whole
+ * fee row to the pot (the launcher's row 0: `potBps` is 10,000 less the launcher's part). The
+ * launcher sets `roundSecs`, `minPotLamports`, `coverBps` and `minHolding` (`LossCoverRequest`);
+ * the rest is fixed here. There is no cooldown: a holding is measured or paid once a round.
+ */
+/** A holding's wait in words: "45 seconds", "1 minute", "30 minutes". */
+export function ageWords(secs) {
+    if (secs % 60 !== 0 || secs < 60)
+        return `${secs} second${secs === 1 ? '' : 's'}`;
+    const m = secs / 60;
+    return `${m} minute${m === 1 ? '' : 's'}`;
+}
+export const LOSS_COVER_DEFAULTS = {
+    potBps: 10_000,
+    roundSecs: 300,
+    stepSecs: 15,
+    roundBps: 10_000,
+    stepBps: 10_000,
+    holdingBps: 10_000,
+    coverBps: 10_000,
+    minHolding: '100000000000',
+    minLossLamports: '1000000',
+    minAgeSecs: 60,
+    minPotLamports: '1000000000',
+};
+/** The round lengths the launch form offers (seconds): 5, 10, 30 and 60 minutes. */
+export const LOSS_COVER_ROUND_CHOICES_SECS = [300, 600, 1_800, 3_600];
+/** The cover shares the launch form offers: the whole loss, half, a quarter. */
+export const LOSS_COVER_COVER_CHOICES_BPS = [10_000, 5_000, 2_500];
+/** The minimum pots the launch form offers, lamports: none, 0.5, 1, 5 SOL. */
+export const LOSS_COVER_MIN_POT_CHOICES_LAMPORTS = ['0', '500000000', '1000000000', '5000000000'];
+const LAMPORTS = /^\d{1,20}$/;
+/** The Lossback terms a launch request's `companion` names (`companion.lossCover`); null without them; `'malformed'` when they are there and not whole numbers and lamport strings. */
+export function lossCoverRequestOf(companion) {
+    if (typeof companion !== 'object' || companion === null)
+        return null;
+    const raw = companion.lossCover;
+    if (raw === undefined || raw === null)
+        return null;
+    if (typeof raw !== 'object')
+        return 'malformed';
+    const r = raw;
+    if (typeof r.roundSecs !== 'number' || !Number.isInteger(r.roundSecs) || !isShare(r.coverBps))
+        return 'malformed';
+    if (typeof r.minPotLamports !== 'string' || !LAMPORTS.test(r.minPotLamports) || typeof r.minHolding !== 'string' || !LAMPORTS.test(r.minHolding))
+        return 'malformed';
+    return { roundSecs: r.roundSecs, minPotLamports: r.minPotLamports, coverBps: r.coverBps, minHolding: r.minHolding };
+}
+/** The full terms a request launches with: what it names, the rest from `LOSS_COVER_DEFAULTS`. */
+export function lossCoverTermsOf(s) {
+    const D = LOSS_COVER_DEFAULTS;
+    return { roundSecs: s.roundSecs, stepSecs: D.stepSecs, stepBps: D.stepBps, holdingBps: D.holdingBps, roundBps: D.roundBps, coverBps: s.coverBps, minHolding: s.minHolding, minLossLamports: D.minLossLamports, minAgeSecs: D.minAgeSecs, minPotLamports: s.minPotLamports };
+}
+/** The pot's part of every fee claim for a Lossback coin: what the launcher's part of the split leaves (the hook's whole fee row). */
+export const lossCoverPotBps = (split) => 10_000 - split.buybackBps - split.holdersBps - split.beneficiaryBps;
+/**
+ * Why a Lossback coin with these terms can't launch with this split on these rules at this fee, in
+ * the words the launch form and the backend use (`companion_rules`); null when it can: a creator
+ * fee to fill the pot, no other token rules (it launches from Bordrless's Loss cover config, which
+ * has none, and runs its own hook in the kit's place), nothing bought back and no holders' part (the
+ * pot and the launcher only), a part for the pot, and the terms within `LOSS_COVER_LIMITS` (the
+ * programs refuse anything outside their own bounds at the setup's dry run). `supply` is the
+ * launch's, for the least holding's cap.
+ */
+export function lossCoverProblem(s, split, rules, creatorFeeBps, supply = TOKEN_SUPPLY) {
+    const L = LOSS_COVER_LIMITS;
+    const D = LOSS_COVER_DEFAULTS;
+    if (creatorFeeBps === 0)
+        return 'There is no creator fee to fill the pot with: set one.';
+    if (Object.keys(NO_RULES).some((k) => rules[k] !== 0))
+        return 'A Lossback coin has no other token rules: its hook keeps each holding’s entry price.';
+    if (split.buybackBps !== 0 || split.holdersBps !== 0)
+        return 'A Lossback coin’s creator fee goes to its pot and to the launcher: nothing bought back, no holders’ part.';
+    const potBps = lossCoverPotBps(split);
+    if (!(potBps > 0) || !isShare(split.beneficiaryBps))
+        return 'The pot’s part and the launcher’s must add up to 100%, with a part for the pot.';
+    if (!Number.isInteger(s.roundSecs) || s.roundSecs < L.minRoundSecs || s.roundSecs > L.maxRoundSecs)
+        return 'A round lasts a minute to a day.';
+    if (s.roundSecs < D.stepSecs * L.stepsPerRoundMin)
+        return `A round holds at least ${L.stepsPerRoundMin} steps of ${D.stepSecs} seconds.`;
+    if (!Number.isInteger(s.coverBps) || s.coverBps < L.minCoverBps || s.coverBps > L.maxCoverBps)
+        return 'The pot covers 10% to 100% of a loss.';
+    const minHolding = BigInt(s.minHolding);
+    if (minHolding < 1n || minHolding > (supply * BigInt(L.maxMinHoldingBps)) / BPS)
+        return 'The least holding that counts is at least one base unit and at most 1% of the supply.';
+    const minPot = BigInt(s.minPotLamports);
+    if (minPot > L.maxMinPotLamports)
+        return 'The minimum pot is at most 100 SOL.';
+    return null;
+}
+/**
+ * The review step's sentence for a Lossback coin, in numbers: what it does, never that it protects
+ * anyone (docs/loss-cover.md §5).
+ */
+export function lossCoverSentence(s, decimals = TOKEN_DECIMALS) {
+    const D = LOSS_COVER_DEFAULTS;
+    const minutes = Math.round(s.roundSecs / 60);
+    const pot = Number(BigInt(s.minPotLamports)) / 1e9;
+    const holding = Number(BigInt(s.minHolding)) / 10 ** decimals;
+    const loss = Number(BigInt(D.minLossLamports)) / 1e9;
+    const share = s.coverBps === 10_000 ? 'the same share of what they are down' : `the same share of ${s.coverBps / 100}% of what they are down`;
+    const once = pot > 0 ? `, once the pot holds ${pot} SOL,` : '';
+    return `Every ${minutes} minutes${once} it pays every holder under water ${share}, as much as the pot allows, in steps of ${D.stepSecs} seconds; a holding counts from ${holding.toLocaleString('en-US')} tokens and ${loss} SOL of loss, ${ageWords(D.minAgeSecs)} after it bought.`;
+}
 /** The template whose split this is, or null for any other split. */
 export function companionTemplateOf(split) {
     return COMPANION_TEMPLATE_LIST.find((t) => {

package/dist/programs.d.ts

@@ -34,6 +34,22 @@ export declare const PROGRAM_IDS: {
      * permissionless crank under the companion's buyback guards. Not deployed yet (2026-10-09).
      */
     readonly hookVault: "5cojoUStG7WFhHJiSncCUEwTqDuhDLKu4a9BqTbF8jzG";
+    /**
+     * The Loss cover hook (programs/loss_cover_hook, docs/loss-cover.md §2; the site says Lossback):
+     * a Lossback coin's token hook, which keeps each holding's average entry price, the cover it was
+     * paid and the round it was last recorded in. Keypair generated 2026-10-12.
+     */
+    readonly lossCoverHook: "6KMdXC3Fxovp3pnUsdQuUbderPzZtTA4t6R1jacYJWQr";
+    /**
+     * The Loss cover script (programs/loss_cover_script, docs/loss-cover.md §3): the companion script
+     * of a Lossback coin, which names the holders under water and what each gets; the companion pays.
+     */
+    readonly lossCoverScript: "9mRXU9gpWY3B13AyuCCtNjHnKt1pUFBQ6vJDLTwgakhm";
+    /**
+     * The router (programs/bordrless_router, docs/router.md, 2026-10-13): an app's integrator fee on
+     * any DEX swap, at most 1% of the quote side, 20% of it to the DEX treasury.
+     */
+    readonly router: "7M5GTuzhByzBbrJURzLtbBrFjcsC8aHu816qWTXAYD85";
 };
 /**
  * Bordrless Studio's attester (phase 3a, docs/phase3a.md §6): a hot key of Studio's build worker,
@@ -64,6 +80,67 @@ export declare const LOTTERY_HOOK: {
 };
 /** The creator fees (basis points) a lottery coin can launch with: those with a `LaunchConfig` in `LOTTERY_HOOK.launchConfigs`. */
 export declare const lotteryFeeChoices: () => number[];
+/**
+ * The Loss cover hook's fixed facts (programs/loss_cover_hook, docs/loss-cover.md §2; the site
+ * says Lossback): the flags a `LaunchConfig` names for it (`BEFORE_TRANSFER | BEFORE_BURN |
+ * WRITES_HOOK_DATA`, the lottery hook's), the token program's signer of its callbacks
+ * (`["hook-authority", hook]` under the token program), its own `["hook-authority"]` (which signs
+ * the token program's `write_hook_data` in `record_payout`) with its bump, and the `LaunchConfig`s
+ * a Lossback coin launches from, one per creator fee, made by `pnpm admin loss-cover-configs`
+ * (which prints the lines to paste here); the backend lays
+ * `LOSS_COVER_LAUNCH_CONFIGS` over it.
+ */
+export declare const LOSS_COVER_HOOK: {
+    readonly program: "6KMdXC3Fxovp3pnUsdQuUbderPzZtTA4t6R1jacYJWQr";
+    readonly flags: 145;
+    readonly tokenHookSigner: "A2WKjdKC4PurtabNwhvKJvWdxKXLvt79qrzre7GE8XTe";
+    readonly hookAuthority: "J7duBVXCMbN1BLp4mt7myzVvRsvXRPU3BAhFyksDSPAm";
+    readonly hookAuthorityBump: 252;
+    readonly readme: "https://github.com/BordrlessDex/bordrless-programs/tree/main/programs/loss_cover_hook";
+    readonly launchConfigs: Readonly<Partial<Record<number, string>>>;
+};
+/**
+ * The rules engine's program id (`programs/rules_hook`, its keypair `keys/mainnet/rules_hook-keypair.json`):
+ * BUILT, NOT DEPLOYED YET (2026-10-12). The SDK builds `bind` and `prepare` for it; the lane opens
+ * only when `RULES_HOOK_PROGRAM` below is set to it, after the deploy lands.
+ */
+export declare const RULES_HOOK_PROGRAM_ID_MAINNET = "AfDhsethmkoimbyoSWnRfLtjFXZteRNtbFMioR9qWMjD";
+/**
+ * The rules engine (`programs/rules_hook`, docs/rules-lane.md): Bordrless's one token hook that
+ * runs a composed rule set bound to a launch config (`RuleSet` at `["rules", config]` under it).
+ * The lane's switch: a placeholder, the system program's id, until the engine is deployed, so
+ * nothing can name it as a hook (the launch program refuses the protocol's own programs), every
+ * check that compares a hook with it is false and the API answers `rules_closed`. Set to
+ * `RULES_HOOK_PROGRAM_ID_MAINNET` once the deploy lands; `RULES_HOOK.flags` are per rule set
+ * (`rulesFlagsOf`), never fixed.
+ */
+export declare const RULES_HOOK_PROGRAM: string;
+/** The engine's fixed facts, as the other hooks have them; `deployed` tells the site and the API whether the lane is live on chain (false while the id is the placeholder, the system program's). */
+export declare const RULES_HOOK: {
+    readonly program: string;
+    readonly deployed: boolean;
+    /** `RuleSet` seed under the engine, with the launch config. */
+    readonly ruleSetSeed: "rules";
+    /** The per-mint state seed, the template's. */
+    readonly stateSeed: "state";
+    /** The engine's id once deployed (`RULES_HOOK_PROGRAM_ID_MAINNET`), and its PDAs: the token program's signer of its callbacks, and its `["hook-authority"]` (signs `write_hook_data` in `record_payout`). */
+    readonly programId: "AfDhsethmkoimbyoSWnRfLtjFXZteRNtbFMioR9qWMjD";
+    readonly tokenHookSigner: "FaU6drNBY2nayBkXiirtk5c29Hw3rqXMtv2K1La5V4cG";
+    readonly hookAuthority: "9SydDjwfgWaG8akwwsEpTpRpdoVZCtMYSeiqf6EkMdkK";
+    readonly hookAuthorityBump: 254;
+    /** The accounts' sizes: the `RuleSet` and the per-mint state. */
+    readonly ruleSetLen: 447;
+    readonly stateLen: 628;
+    readonly readme: "https://github.com/BordrlessDex/bordrless-programs/tree/main/programs/rules_hook";
+};
+/** The Loss cover script's fixed facts (programs/loss_cover_script, docs/loss-cover.md §3): its program and the size of the state `create_script_v2` must ask for. */
+export declare const LOSS_COVER_SCRIPT: {
+    readonly program: "9mRXU9gpWY3B13AyuCCtNjHnKt1pUFBQ6vJDLTwgakhm";
+    readonly stateLen: 128;
+    readonly readme: "https://github.com/BordrlessDex/bordrless-programs/tree/main/programs/loss_cover_script";
+};
+/** The creator fees (basis points) a Lossback coin can launch with: those with a `LaunchConfig` in `LOSS_COVER_HOOK.launchConfigs` (the backend's env adds to them). */
+export declare const lossCoverFeeChoices: () => number[];
 /**
  * Half-Life, Bordrless's own token hook (programs/half_life/README.md): the `LaunchConfig` the
  * launch form's Half-Life path launches from (no kit rules, creator fee 1%, the hook with
@@ -160,6 +237,8 @@ export declare const FIXED_ADDRESSES: {
     readonly kitHookAuthority: "2repKA1JgDkBo4AffscVee342dcBcH6c2yfpUTRrAiEN";
     /** `["__event_authority"]` under the companion program. */
     readonly companionEventAuthority: "7QuoYRuD9MHzX5EN7qqj62iwNPVqfy74RzmwJ524cgDt";
+    /** `["payout-authority"]` under the companion program (bump 251): the one signer of a hook's `record_payout` (docs/loss-cover.md §1); it signs nothing else. */
+    readonly companionPayoutAuthority: "8XJcBCYmYyggTQBNvK3RausfyRMpmtjJTjKd53W3StkG";
 };
 /**
  * The protocol lookup table (docs/hooks-v2.md §6; programs-summary §2.7): the 22 fixed addresses

package/dist/programs.js

@@ -34,6 +34,22 @@ export const PROGRAM_IDS = {
      * permissionless crank under the companion's buyback guards. Not deployed yet (2026-10-09).
      */
     hookVault: '5cojoUStG7WFhHJiSncCUEwTqDuhDLKu4a9BqTbF8jzG',
+    /**
+     * The Loss cover hook (programs/loss_cover_hook, docs/loss-cover.md §2; the site says Lossback):
+     * a Lossback coin's token hook, which keeps each holding's average entry price, the cover it was
+     * paid and the round it was last recorded in. Keypair generated 2026-10-12.
+     */
+    lossCoverHook: '6KMdXC3Fxovp3pnUsdQuUbderPzZtTA4t6R1jacYJWQr',
+    /**
+     * The Loss cover script (programs/loss_cover_script, docs/loss-cover.md §3): the companion script
+     * of a Lossback coin, which names the holders under water and what each gets; the companion pays.
+     */
+    lossCoverScript: '9mRXU9gpWY3B13AyuCCtNjHnKt1pUFBQ6vJDLTwgakhm',
+    /**
+     * The router (programs/bordrless_router, docs/router.md, 2026-10-13): an app's integrator fee on
+     * any DEX swap, at most 1% of the quote side, 20% of it to the DEX treasury.
+     */
+    router: '7M5GTuzhByzBbrJURzLtbBrFjcsC8aHu816qWTXAYD85',
 };
 /**
  * Bordrless Studio's attester (phase 3a, docs/phase3a.md §6): a hot key of Studio's build worker,
@@ -68,6 +84,72 @@ export const LOTTERY_HOOK = {
 };
 /** The creator fees (basis points) a lottery coin can launch with: those with a `LaunchConfig` in `LOTTERY_HOOK.launchConfigs`. */
 export const lotteryFeeChoices = () => Object.keys(LOTTERY_HOOK.launchConfigs).map(Number).filter((bps) => bps > 0);
+/**
+ * The Loss cover hook's fixed facts (programs/loss_cover_hook, docs/loss-cover.md §2; the site
+ * says Lossback): the flags a `LaunchConfig` names for it (`BEFORE_TRANSFER | BEFORE_BURN |
+ * WRITES_HOOK_DATA`, the lottery hook's), the token program's signer of its callbacks
+ * (`["hook-authority", hook]` under the token program), its own `["hook-authority"]` (which signs
+ * the token program's `write_hook_data` in `record_payout`) with its bump, and the `LaunchConfig`s
+ * a Lossback coin launches from, one per creator fee, made by `pnpm admin loss-cover-configs`
+ * (which prints the lines to paste here); the backend lays
+ * `LOSS_COVER_LAUNCH_CONFIGS` over it.
+ */
+export const LOSS_COVER_HOOK = {
+    program: PROGRAM_IDS.lossCoverHook,
+    flags: 145,
+    tokenHookSigner: 'A2WKjdKC4PurtabNwhvKJvWdxKXLvt79qrzre7GE8XTe',
+    hookAuthority: 'J7duBVXCMbN1BLp4mt7myzVvRsvXRPU3BAhFyksDSPAm',
+    hookAuthorityBump: 252,
+    readme: 'https://github.com/BordrlessDex/bordrless-programs/tree/main/programs/loss_cover_hook',
+    // Made 2026-10-12 22:26 UTC by `pnpm admin loss-cover-configs --send` (5xsib), no token rules, the Loss cover hook with flags 145.
+    launchConfigs: {
+        50: 'DCNLF3jvZvo6SMTa9dG8y2E7CgB7VZr2C5tQrs83HR84',
+        100: '8E1UWZ8PXYrWvfBNRxVSzceR4ywLmHQYAXvWZ4JkUhQZ',
+        200: '8PLEsXW4hbEfYXgtRWxZhe7nTvjeYR1XdY5ehKj8z3Xr',
+    },
+};
+/**
+ * The rules engine's program id (`programs/rules_hook`, its keypair `keys/mainnet/rules_hook-keypair.json`):
+ * BUILT, NOT DEPLOYED YET (2026-10-12). The SDK builds `bind` and `prepare` for it; the lane opens
+ * only when `RULES_HOOK_PROGRAM` below is set to it, after the deploy lands.
+ */
+export const RULES_HOOK_PROGRAM_ID_MAINNET = 'AfDhsethmkoimbyoSWnRfLtjFXZteRNtbFMioR9qWMjD';
+/**
+ * The rules engine (`programs/rules_hook`, docs/rules-lane.md): Bordrless's one token hook that
+ * runs a composed rule set bound to a launch config (`RuleSet` at `["rules", config]` under it).
+ * The lane's switch: a placeholder, the system program's id, until the engine is deployed, so
+ * nothing can name it as a hook (the launch program refuses the protocol's own programs), every
+ * check that compares a hook with it is false and the API answers `rules_closed`. Set to
+ * `RULES_HOOK_PROGRAM_ID_MAINNET` once the deploy lands; `RULES_HOOK.flags` are per rule set
+ * (`rulesFlagsOf`), never fixed.
+ */
+export const RULES_HOOK_PROGRAM = RULES_HOOK_PROGRAM_ID_MAINNET;
+/** The engine's fixed facts, as the other hooks have them; `deployed` tells the site and the API whether the lane is live on chain (false while the id is the placeholder, the system program's). */
+export const RULES_HOOK = {
+    program: RULES_HOOK_PROGRAM,
+    deployed: RULES_HOOK_PROGRAM !== '11111111111111111111111111111111',
+    /** `RuleSet` seed under the engine, with the launch config. */
+    ruleSetSeed: 'rules',
+    /** The per-mint state seed, the template's. */
+    stateSeed: 'state',
+    /** The engine's id once deployed (`RULES_HOOK_PROGRAM_ID_MAINNET`), and its PDAs: the token program's signer of its callbacks, and its `["hook-authority"]` (signs `write_hook_data` in `record_payout`). */
+    programId: RULES_HOOK_PROGRAM_ID_MAINNET,
+    tokenHookSigner: 'FaU6drNBY2nayBkXiirtk5c29Hw3rqXMtv2K1La5V4cG',
+    hookAuthority: '9SydDjwfgWaG8akwwsEpTpRpdoVZCtMYSeiqf6EkMdkK',
+    hookAuthorityBump: 254,
+    /** The accounts' sizes: the `RuleSet` and the per-mint state. */
+    ruleSetLen: 447,
+    stateLen: 628,
+    readme: 'https://github.com/BordrlessDex/bordrless-programs/tree/main/programs/rules_hook',
+};
+/** The Loss cover script's fixed facts (programs/loss_cover_script, docs/loss-cover.md §3): its program and the size of the state `create_script_v2` must ask for. */
+export const LOSS_COVER_SCRIPT = {
+    program: PROGRAM_IDS.lossCoverScript,
+    stateLen: 128,
+    readme: 'https://github.com/BordrlessDex/bordrless-programs/tree/main/programs/loss_cover_script',
+};
+/** The creator fees (basis points) a Lossback coin can launch with: those with a `LaunchConfig` in `LOSS_COVER_HOOK.launchConfigs` (the backend's env adds to them). */
+export const lossCoverFeeChoices = () => Object.keys(LOSS_COVER_HOOK.launchConfigs).map(Number).filter((bps) => bps > 0);
 /**
  * Half-Life, Bordrless's own token hook (programs/half_life/README.md): the `LaunchConfig` the
  * launch form's Half-Life path launches from (no kit rules, creator fee 1%, the hook with
@@ -176,6 +258,8 @@ export const FIXED_ADDRESSES = {
     kitHookAuthority: '2repKA1JgDkBo4AffscVee342dcBcH6c2yfpUTRrAiEN',
     /** `["__event_authority"]` under the companion program. */
     companionEventAuthority: '7QuoYRuD9MHzX5EN7qqj62iwNPVqfy74RzmwJ524cgDt',
+    /** `["payout-authority"]` under the companion program (bump 251): the one signer of a hook's `record_payout` (docs/loss-cover.md §1); it signs nothing else. */
+    companionPayoutAuthority: '8XJcBCYmYyggTQBNvK3RausfyRMpmtjJTjKd53W3StkG',
 };
 /**
  * The protocol lookup table (docs/hooks-v2.md §6; programs-summary §2.7): the 22 fixed addresses