@bordrless/shared 0.1.0 → 0.2.0

package/README.md

@@ -27,8 +27,8 @@ TOKEN_HOOK_FLAGS.BEFORE_TRANSFER | TOKEN_HOOK_FLAGS.TRANSFER_RETURNS_DELTA;
 
 ## Where to read more
 
-- The SDK page: https://bordrless.xyz/sdk
-- The standard in full: https://bordrless.xyz/docs
+- The SDK page: https://bordrless.app/sdk
+- The standard in full: https://bordrless.app/docs
 
 Status: the programs run on localnet and devnet until they are deployed to mainnet; they keep an
 upgrade authority until audited.

package/dist/api.d.ts

@@ -143,6 +143,8 @@ export interface ConfigInspection {
     /** As `CustomHookInfo.upgradeable`; null without a hook or when its program could not be read. */
     hookUpgradeable: boolean | null;
     registryReady: boolean | null;
+    /** The hook is Half-Life: the launch prepares it for the mint and lights its furnace itself. */
+    halfLife?: boolean;
 }
 /** Live figures of a launch's token rules; each null when the launch lacks the rule or it is not tracked. */
 export interface RuleStats {
@@ -351,12 +353,27 @@ export interface PortfolioEntry {
     /** For a launch token with a creator's own hook (§5.8): the hook, so the row can say so; null otherwise (absent from backends that predate it). */
     customHook?: CustomHookInfo | null;
 }
+/** A launch the wallet created, with the creator fee waiting for it (`Portfolio.created`). */
+export interface CreatedLaunch {
+    mint: Address;
+    symbol: string;
+    name: string;
+    image: string | null;
+    status: LaunchStatus;
+    creatorFeeBps: number;
+    /** Lamports of bridged SOL accrued and not yet claimed (the launch's quote holding, what a claim pays); null when the chain could not be read. */
+    claimable: Amount | null;
+    /** Lamports claimed here, all time; null when not known. */
+    claimedTotal?: Amount | null;
+}
 export interface Portfolio {
     owner: Address;
     lamports: Amount;
     /** What the wallet holds, plus launches it no longer holds when it has holder rewards to claim there. */
     entries: PortfolioEntry[];
     totalUsd: number | null;
+    /** The launches this wallet created, those with fees to claim first (absent from backends that predate it). */
+    created: CreatedLaunch[];
 }
 /** Native SOL (bridged on the way in, unbridged on the way out) or bridged SOL already held. */
 export type SolMode = 'SOL' | 'BSOL';
@@ -518,6 +535,11 @@ export interface RewardsPrepareRequest {
     /** Unwrap the bridged SOL to SOL and close the temporary holding. */
     unwrap: boolean;
 }
+/** Claim the creator fees of launches the owner created: up to about 4 mints per transaction, paid as SOL. */
+export interface CreatorPrepareRequest {
+    owner: Address;
+    mints: Address[];
+}
 /** Share with holders: send SOL that every holder of the token receives pro rata. */
 export interface SharePrepareRequest {
     owner: Address;

package/dist/policy.d.ts

@@ -230,9 +230,14 @@ export declare const rewardsOn: (r: Pick<LaunchRulesInput, "holderFeeBuyBps" | "
 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. */
+/**
+ * The ways beside the presets (§7.1): Half-Life launches from Bordrless's own `LaunchConfig` with
+ * the Half-Life hook (programs/half_life), prepared and lit for the mint by the launch itself;
+ * 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 = 'Half-Life' | 'Custom' | 'Build your own';
+/** What the launch form's rules row can be set to: a preset, or one of the paths. */
 export type RuleModeName = RulePresetName | RulePathName;
 export interface RulePreset {
     name: RulePresetName;
@@ -259,7 +264,7 @@ export interface RulePath {
  * 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. */
+/** The 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;
@@ -332,7 +337,7 @@ export declare function launchBeforeSwap(side: Side, amountIn: bigint, p: Launch
 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. */
+    /** Bridged SOL to the creator: from a buy's input, or from a sell's output after the LP fee. */
     creatorFee: bigint;
     /** Bridged SOL to holders, likewise. */
     holderFee: bigint;
@@ -342,13 +347,13 @@ export interface LaunchSwap {
     holderFeeOn: boolean;
     /** What reached the input vault. */
     received: bigint;
-    /** The LP fee, in the input token, on what reached the vault. */
+    /** The LP fee, Bordrless's in bridged SOL (it never stays in a launch pool): on a buy from what reached the vault, on a sell from the curve's output. The DEX's event reports it inside `protocol_fee` with `lp_fee` 0. */
     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. */
+    /** What went into the curve: on a buy `received` less the LP fee and the protocol fee (negative when they take more than arrived); on a sell `received`. */
     netIn: bigint;
-    /** What the curve gave (on a sell, before the protocol fee and the creator and holder fees); null when the swap fails. */
+    /** What the curve gave (on a sell, before the LP fee, the creator and holder fees and the protocol fee); null when the swap fails. */
     amountOut: bigint | null;
     /** What reaches the recipient; null when the swap fails. */
     delivered: bigint | null;
@@ -362,21 +367,26 @@ export declare function curveOutput(r: Reserves, side: Side, netIn: bigint): big
  * §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`.
+ * A buy: the creator and holder fees from the input, Bordrless's share of them and the LP fee (both
+ * Bordrless's, in SOL) on what reached the vault, the curve, the burn from the output. A sell: the
+ * burn from the input, the curve on all the rest, the LP fee (Bordrless's) from the curve's output,
+ * then the creator and holder fees from what is left and Bordrless's share of them held back from the
+ * delivery. A launch pool's LP fee never stays in the pool (its LP is locked for ever). 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`).
+ * What a launch-pool swap adds to its input reserve (the Rust reference's `to_reserve_in`): on a buy
+ * what goes into the curve (what reached the vault less the LP fee and the share, both Bordrless's;
+ * 0 when they take it all), on a sell what reached the vault.
+ */
+export declare const launchSwapToReserve: (side: Side, q: Pick<LaunchSwap, "received" | "netIn">) => bigint;
+/**
+ * Whether a buy that lands leaves the launch ready to graduate, so `graduate` can follow it in the
+ * same transaction: the pool's quote reserve at or above the graduation threshold, or the curve sold
+ * out (the buy takes every token it has left). The LP fee does not compound, so the two come
+ * together, and a hook's cut on buys can keep the reserve just short of the threshold.
  */
 export declare function buyGraduates(r: Reserves, q: LaunchSwap, graduationQuote: bigint): boolean;
 /**

package/dist/policy.js

@@ -334,8 +334,9 @@ export const RULE_PRESETS = [
     { name: 'Burn', slug: 'burn', description: 'Burn 0.5% on buys and sells, holder rewards 0.5%, creator fee 0.5%.', creatorFeeBps: 50, rules: { ...NO_RULES, holderFeeBuyBps: 50, holderFeeSellBps: 50, burnBuyBps: 50, burnSellBps: 50 } },
     { name: 'Paid to hold', slug: 'paid-to-hold', description: 'Holder rewards 2% on sells only, creator wallet lock 30 d, creator fee 0.5%.', creatorFeeBps: 50, rules: { ...NO_RULES, holderFeeSellBps: 200, creatorLockDays: 30 } },
 ];
-/** The two paths beside the presets, in order, with the words the home console and the launch form print. */
+/** The paths beside the presets, in order, with the words the home console and the launch form print. */
 export const RULE_PATHS = [
+    { name: 'Half-Life', slug: 'half-life', description: 'An exit fee that halves every 6 hours held: 20% to sell at once, 0% after 2 days, burned. Buys are free.' },
     { name: 'Custom', slug: 'custom', description: 'Mix the rules by hand; holder rewards and burn can differ on buys and sells.' },
     { name: 'Build your own', slug: 'build-your-own', description: 'Write a hook with the SDK, make a launch config, paste its key.' },
 ];
@@ -482,23 +483,25 @@ export function curveOutput(r, side, netIn) {
  * §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`.
+ * A buy: the creator and holder fees from the input, Bordrless's share of them and the LP fee (both
+ * Bordrless's, in SOL) on what reached the vault, the curve, the burn from the output. A sell: the
+ * burn from the input, the curve on all the rest, the LP fee (Bordrless's) from the curve's output,
+ * then the creator and holder fees from what is left and Bordrless's share of them held back from the
+ * delivery. A launch pool's LP fee never stays in the pool (its LP is locked for ever). 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 function quoteLaunchSwap(r, side, amountIn, lpFeeBps, protocolShareBps, p) {
     const before = launchBeforeSwap(side, amountIn, p);
     const received = amountIn - before.creatorFee - before.holderFee - before.burn;
     const eligibleAtFees = side === 'sell' ? (p.eligible > amountIn ? p.eligible - amountIn : 0n) : p.eligible;
     const holderFeeOn = (side === 'buy' ? p.holderFeeBuyBps : p.holderFeeSellBps) > 0 && eligibleAtFees >= p.minEligible;
-    const lpFee = feeAmount(received, lpFeeBps);
+    // A buy's LP fee is on the SOL that reached the vault; a sell's on the curve's output.
+    const buyLpFee = side === 'buy' ? feeAmount(received, lpFeeBps) : 0n;
     // A buy's cuts are the hook's quote fees; a sell's input side cuts nothing (the burn is not a cut), so its share is taken from the output.
     const inputProtocolFee = side === 'buy' ? protocolShare(before.creatorFee + before.holderFee, protocolShareBps) : 0n;
-    const netIn = received - lpFee - inputProtocolFee;
-    const failed = (failure, protocolFee = inputProtocolFee) => ({ ...before, holderFeeOn, received, lpFee, protocolFee, netIn, amountOut: null, delivered: null, failure });
+    const netIn = received - buyLpFee - inputProtocolFee;
+    const failed = (failure, protocolFee = inputProtocolFee, carried = {}) => ({ ...before, holderFeeOn, received, lpFee: buyLpFee, protocolFee, netIn, amountOut: null, delivered: null, failure, ...carried });
     if (received <= 0n || netIn <= 0n)
         return failed('fees_exceed_input');
     const out = curveOutput(r, side, netIn);
@@ -508,24 +511,33 @@ export function quoteLaunchSwap(r, side, amountIn, lpFeeBps, protocolShareBps, p
         return failed('insufficient_liquidity');
     if (side === 'buy') {
         const after = launchAfterSwap('buy', out, p);
-        return { ...before, burn: after.burn, holderFeeOn, received, lpFee, protocolFee: inputProtocolFee, netIn, amountOut: out, delivered: out - after.burn, failure: null };
+        return { ...before, burn: after.burn, holderFeeOn, received, lpFee: buyLpFee, protocolFee: inputProtocolFee, netIn, amountOut: out, delivered: out - after.burn, failure: null };
     }
-    const after = launchAfterSwap('sell', out, { ...p, eligible: eligibleAtFees });
+    // A sell: the LP fee leaves the curve's output before the hook is told the rest.
+    const lpFee = feeAmount(out, lpFeeBps);
+    if (lpFee >= out)
+        return failed('no_output', 0n, { lpFee });
+    const told = out - lpFee;
+    const after = launchAfterSwap('sell', told, { ...p, eligible: eligibleAtFees });
     const protocolFee = protocolShare(after.creatorFee + after.holderFee, protocolShareBps);
-    if (after.creatorFee + after.holderFee + protocolFee >= out)
-        return failed('no_output', protocolFee);
-    return { creatorFee: after.creatorFee, holderFee: after.holderFee, burn: before.burn, holderFeeOn, received, lpFee, protocolFee, netIn, amountOut: out, delivered: out - after.creatorFee - after.holderFee - protocolFee, failure: null };
+    if (after.creatorFee + after.holderFee + protocolFee >= told)
+        return failed('no_output', protocolFee, { creatorFee: after.creatorFee, holderFee: after.holderFee, lpFee });
+    return { creatorFee: after.creatorFee, holderFee: after.holderFee, burn: before.burn, holderFeeOn, received, lpFee, protocolFee, netIn, amountOut: out, delivered: told - after.creatorFee - after.holderFee - protocolFee, failure: null };
 }
-/** 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 const launchSwapToReserve = (side, q) => (side === 'buy' ? q.received - q.protocolFee : q.received);
 /**
- * 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`).
+ * What a launch-pool swap adds to its input reserve (the Rust reference's `to_reserve_in`): on a buy
+ * what goes into the curve (what reached the vault less the LP fee and the share, both Bordrless's;
+ * 0 when they take it all), on a sell what reached the vault.
+ */
+export const launchSwapToReserve = (side, q) => (side === 'buy' ? (q.netIn > 0n ? q.netIn : 0n) : q.received);
+/**
+ * Whether a buy that lands leaves the launch ready to graduate, so `graduate` can follow it in the
+ * same transaction: the pool's quote reserve at or above the graduation threshold, or the curve sold
+ * out (the buy takes every token it has left). The LP fee does not compound, so the two come
+ * together, and a hook's cut on buys can keep the reserve just short of the threshold.
  */
 export function buyGraduates(r, q, graduationQuote) {
-    return q.failure === null && r.quoteReserve + launchSwapToReserve('buy', q) >= graduationQuote;
+    return q.failure === null && (r.quoteReserve + launchSwapToReserve('buy', q) >= graduationQuote || q.amountOut === r.baseReserve);
 }
 /**
  * §8.2 `maxAmountIn` on a curve pool: the largest buy the curve can still fill with these fees (one

package/dist/programs.d.ts

@@ -12,7 +12,33 @@ export declare const PROGRAM_IDS: {
     readonly taxHook: "8tjnVSreJGBRQFyDBf1SyyhBgLsdBxa2rHYh9sbxFyX7";
     /** The v2 token-rules hook (docs/hooks-v2.md §4): holder rewards, max wallet and the two locks. */
     readonly kit: "14RJQXPdJfkehit6ezktjd3xujamf8nVSKw2shKamaEH";
+    /** Half-Life (programs/half_life): an exit fee that halves every six hours a token is held, burned. */
+    readonly halfLife: "53SpmtkdPWQ63mWoDeXk8P9tuwiT4ed2Wx4fwfy5NSF8";
 };
+/**
+ * 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
+ * `flags`), and the fee curve the program has fixed: `maxFeePpm` for tokens that just arrived,
+ * halved every `halfLifeSecs`, linear within each, zero from `zeroAfterSecs`.
+ */
+export declare const HALF_LIFE: {
+    readonly program: "53SpmtkdPWQ63mWoDeXk8P9tuwiT4ed2Wx4fwfy5NSF8";
+    readonly launchConfig: "ABz5Je9FznnotUQxxaj28vn18t1Wv9SsDzEfDxGLRJY";
+    /** `BEFORE_TRANSFER | TRANSFER_RETURNS_DELTA | WRITES_HOOK_DATA`. */
+    readonly flags: 193;
+    readonly creatorFeeBps: 100;
+    readonly maxFeePpm: 200000;
+    readonly halfLifeSecs: 21600;
+    readonly zeroAfterSecs: 172800;
+    /** The token program's signer of the hook's callbacks (`["hook-authority", half_life]`). */
+    readonly tokenHookSigner: "FBZPj9PmV9dXL8U4qmRffXdXm11e23KEBnNgEVXxhfhF";
+    readonly readme: "https://github.com/BordrlessDex/bordrless-programs/tree/main/programs/half_life";
+};
+/**
+ * Half-Life's exit fee, in parts per million, for tokens `ageSecs` old: the program's `fee_ppm`
+ * (20% at 0, halved every six hours, linear within each, 0 from 48 h).
+ */
+export declare function halfLifeFeePpm(ageSecs: number): number;
 /** The wSOL mint, which stands for native SOL on the bridge. */
 export declare const NATIVE_MINT = "So11111111111111111111111111111111111111112";
 export declare const TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";

package/dist/programs.js

@@ -12,7 +12,43 @@ export const PROGRAM_IDS = {
     taxHook: '8tjnVSreJGBRQFyDBf1SyyhBgLsdBxa2rHYh9sbxFyX7',
     /** The v2 token-rules hook (docs/hooks-v2.md §4): holder rewards, max wallet and the two locks. */
     kit: '14RJQXPdJfkehit6ezktjd3xujamf8nVSKw2shKamaEH',
+    /** Half-Life (programs/half_life): an exit fee that halves every six hours a token is held, burned. */
+    halfLife: '53SpmtkdPWQ63mWoDeXk8P9tuwiT4ed2Wx4fwfy5NSF8',
 };
+/**
+ * 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
+ * `flags`), and the fee curve the program has fixed: `maxFeePpm` for tokens that just arrived,
+ * halved every `halfLifeSecs`, linear within each, zero from `zeroAfterSecs`.
+ */
+export const HALF_LIFE = {
+    program: PROGRAM_IDS.halfLife,
+    launchConfig: 'ABz5Je9FznnotUQxxaj28vn18t1Wv9SsDzEfDxGLRJY',
+    /** `BEFORE_TRANSFER | TRANSFER_RETURNS_DELTA | WRITES_HOOK_DATA`. */
+    flags: 193,
+    creatorFeeBps: 100,
+    maxFeePpm: 200_000,
+    halfLifeSecs: 21_600,
+    zeroAfterSecs: 172_800,
+    /** The token program's signer of the hook's callbacks (`["hook-authority", half_life]`). */
+    tokenHookSigner: 'FBZPj9PmV9dXL8U4qmRffXdXm11e23KEBnNgEVXxhfhF',
+    readme: 'https://github.com/BordrlessDex/bordrless-programs/tree/main/programs/half_life',
+};
+/**
+ * Half-Life's exit fee, in parts per million, for tokens `ageSecs` old: the program's `fee_ppm`
+ * (20% at 0, halved every six hours, linear within each, 0 from 48 h).
+ */
+export function halfLifeFeePpm(ageSecs) {
+    if (!(ageSecs > 0))
+        return HALF_LIFE.maxFeePpm;
+    const halvings = Math.floor(ageSecs / HALF_LIFE.halfLifeSecs);
+    if (halvings >= HALF_LIFE.zeroAfterSecs / HALF_LIFE.halfLifeSecs)
+        return 0;
+    const into = Math.floor(ageSecs) % HALF_LIFE.halfLifeSecs;
+    const hi = Math.floor(HALF_LIFE.maxFeePpm / 2 ** halvings);
+    const lo = Math.floor(HALF_LIFE.maxFeePpm / 2 ** (halvings + 1));
+    return hi - Math.floor(((hi - lo) * into) / HALF_LIFE.halfLifeSecs);
+}
 /** The wSOL mint, which stands for native SOL on the bridge. */
 export const NATIVE_MINT = 'So11111111111111111111111111111111111111112';
 export const TOKEN_PROGRAM_ID = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bordrless/shared",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "description": "Bordrless policy (the same math as crates/bordrless-core), program addresses and the API types shared by the server and the site. No Solana dependencies.",
   "license": "Apache-2.0",