@floorlaunchpad/sdk-solana 0.0.0-stage → 0.1.0

package/dist/layouts.d.ts

@@ -0,0 +1,666 @@
+/**
+ * FLOOR's accounts (`floor_hook`, `floor_launch`, `floor_holders`), decoded from their bytes on `@floorlaunchpad/carpenter-sdk`'s codec
+ * (`decodeAccount`, `encodeAccount`, `FieldKind`, `LayoutDef`).
+ *
+ * The field tables are transcriptions of the programs' `layout!` lists: STRUCT offsets, discriminator outside.
+ * `test/rust-parity.test.ts` requires the same names, offsets and sizes when the program source is present.
+ * ⛔ Account offset = struct offset + 8. ⛔ 128-bit fields are two LE u64 limbs (low first).
+ * ⛔ Decoders check the discriminator AND the length; a wrong account is an error, never zeros.
+ */
+import type { Address } from '@solana/kit';
+import { type PayeeSlots } from './slots.ts';
+import { type FieldKind, type LayoutDef } from '@floorlaunchpad/carpenter-sdk';
+export declare const HOOK_CONFIG: LayoutDef;
+export declare const FLOOR_POOL: LayoutDef;
+export declare const LAUNCH_CONFIG: LayoutDef;
+export declare const REGISTRY_ENTRY: LayoutDef;
+export declare const LAUNCH: LayoutDef;
+/**
+ * `["quote", quote_mint]` under `floor_hook` — the FLOOR quote roster. The
+ * bounds a pool on this quote must sit in AND the VALUES a launch on it is registered with: `min_bid` / `max_bounty` in the quote's own base units,
+ * governance-set at `list_quote`, retuned by `set_quote_economics`, read by `create_launch`.
+ */
+export declare const QUOTE_POLICY: LayoutDef;
+export declare const BUYER_POSITION: LayoutDef;
+/**
+ * `["holder_book", mint]` — one launch's tally. Struct 200 B, account 208 B.
+ * `acc` is a WRAPPING Q64.64 reward-per-share; `indexed` the lifetime `holder_owed + holder_paid_eth`
+ * already folded; `unallocated` what could not be distributed yet (no eligible holder, the rounding
+ * remainder, a burn clip) — it rides into the next fold.
+ */
+export declare const HOLDER_BOOK: LayoutDef;
+/**
+ * `["holder", mint, token_account]` — ONE holder's record. Struct 160 B, account 168 B; its rent is the
+ * holder's own deposit, refunded to the holder when it closes.
+ * ⛔ Keyed by the TOKEN ACCOUNT, never the wallet.
+ * `owner` sits at ACCOUNT offset 80 — the `getProgramAccounts` memcmp a wallet's records are listed by.
+ */
+export declare const HOLDER_RECORD: LayoutDef;
+/**
+ * `["platform_treasury"]` under `floor_hook` —. ?").
+ * The program-owned platform treasury: its ADDRESS owns every token account the platform cut is
+ * swept into, its DATA the governance that alone may withdraw (rotatable in two steps). Created by
+ * `initialize_hook_config`.
+ */
+export declare const PLATFORM_TREASURY: LayoutDef;
+/**
+ * `["floor_platform_pool"]` under `floor_hook` — `$FLOOR` NATIVE TO SOLANA. `$FLOOR`'s
+ * pool, recorded ONCE by `designate_floor_pool`, and `received`: the lifetime wSOL cut credited into its backing
+ * by `credit_floor_pool` (the EVM's `platformReceivedEth` of `$FLOOR`'s pool). `floor_types::layout::FloorPlatformPool`.
+ */
+export declare const FLOOR_PLATFORM_POOL: LayoutDef;
+/**
+ * `["trader_link", trader]` under `floor_launch` — the
+ * attestor's link, written ONCE by `link_trader` and never changed. A tier is the zero key when unset (no gaps).
+ */
+export declare const TRADER_LINK: LayoutDef;
+/**
+ * `["trader_ref", trader, quote_mint]` under `floor_hook` — what a trader's trades owe
+ * each tier in one quote, `owed[i]` for tier `i + 1`; the tiers are COPIED from the `TraderLink` when the bucket opens.
+ */
+export declare const TRADER_BUCKET: LayoutDef;
+/**
+ * `["stair", floor_pool]` under `floor_hook` — a staircase pool's own record. Created EMPTY (`version` 0) ahead of the graduating buy and FILLED by it: every step's planned range, step 0's position, the RESERVE (every step from `placed` on,
+ * one position), the open tail, the cushion and the POL re-list, the lifetime meters, and THE FEED's (the vault's
+ * bought-back tokens: `vaultListedTokens` / `vaultListedCost`, and the bought tokens they carried, `vaultFedBought`).
+ */
+export declare const STAIR_STATE: LayoutDef;
+/** Every account layout, Carpenter's first (`@floorlaunchpad/carpenter-sdk` `LAYOUTS`), then FLOOR's in the original order. */
+export declare const LAYOUTS: readonly LayoutDef[];
+export interface HookConfig {
+    version: number;
+    bump: number;
+    maxRounds: number;
+    callbackAccounts: number;
+    flags: number;
+    authorityBump: number;
+    governance: Address;
+    platformDestination: Address;
+    launchProgram: Address;
+    launchAuthority: Address;
+    /**
+     * ⛔ The `["platform_treasury"]` PDA ({@link findPlatformTreasury}), which `initialize_hook_config` names. A config naming anything else is swept NOTHING (`TreasuryNotMigrated`, 7031).
+     */
+    hookAuthority: Address;
+    platformOwner: Address;
+    /** The candidate `governance` named by `set_hook_governance`; the zero address when none is pending. */
+    pendingGovernance: Address;
+}
+export interface FloorPool {
+    /** THE POOL-PRICE TWAP's oracle, the account's 216-byte tail (`decodeFloorPoolTwap`), set by `decodeFloorPool`; `null` on a
+     *  792-byte account. Optional: `encodeAccount` and hand-built fixtures never write it. */
+    twap?: TwapOracleView | null;
+    version: number;
+    bump: number;
+    poolBound: number;
+    quoteIsToken1: number;
+    ladderSeeded: number;
+    needsRatchet: number;
+    mode: number;
+    quoteSuspended: number;
+    tickSpacing: number;
+    floorTick: number;
+    ammPool: Address;
+    poolInitializer: Address;
+    baseMint: Address;
+    /** The creator-fee recipients and the team-buy payees — the account's `PayeeSlots` tail
+     *  ({@link decodePayeeSlots}), set by `decodeFloorPool`; `null` on an account shorter than 1,576 B. Optional: `encodeAccount`
+     *  and hand-built fixtures never write it. ⛔ The single `creator` / `pendingRecipientId` fields are GONE (dead padding). */
+    payeeSlots?: PayeeSlots | null;
+    quoteMint: Address;
+    skimBuyFarBps: number;
+    skimSellFarBps: number;
+    creatorBuyBps: number;
+    creatorSellBps: number;
+    holderBuyBps: number;
+    holderSellBps: number;
+    /** The wall's offset from the floor in ticks, `wallTicksCenti(k)`. */
+    wallTicks: number;
+    platformBps: number;
+    minBid: bigint;
+    minSellable: bigint;
+    /** @240 / @248: the team steps payee's owed quote and the lifetime
+     *  paid. Meaningful only where `stairOwner != 0`. */
+    ownerOwed: bigint;
+    ownerPaid: bigint;
+    vaultEth: bigint;
+    bidEthDeployed: bigint;
+    unpaidSkim: bigint;
+    cumulativeVolumeEth: bigint;
+    inventoryTokens: bigint;
+    inventoryCostEth: bigint;
+    askTokensDeployed: bigint;
+    ladderTokensRemaining: bigint;
+    bidLower: number;
+    askUpper: number;
+    askWidth: number;
+    seedLower: number;
+    seedUpper: number;
+    ladderLower: number;
+    ladderUpper: number;
+    /** The band's dear edge = the tail's cheap edge. ⛔ Meaningful ONLY while
+     *  `wallTailLiq !== 0n` — a real split can be tick 0, so never test this for "is there a tail?". */
+    wallSplitTick: number;
+    bidLiquidity: bigint;
+    askLiquidity: bigint;
+    seedLiq: bigint;
+    ladderLiq: bigint;
+    creatorFeesOwed: bigint;
+    platformOwed: bigint;
+    holderOwed: bigint;
+    /** The tail position's liquidity (salt 101); `0n` = the wall is ONE position. */
+    wallTailLiq: bigint;
+    /** THE LIST SHARE's HELD tokens: not for sale until the next ratchet, outside circulating supply. The
+     *  wall's tokens are `ladderTokensRemaining` (listed) + this. */
+    wallHeldTokens: bigint;
+    seedFeesSweptEth: bigint;
+    seedFeesSweptTokens: bigint;
+    ladderProceedsEth: bigint;
+    platformPaidEth: bigint;
+    platformSwept: bigint;
+    creatorFeesPaid: bigint;
+    holderPaidEth: bigint;
+    lastRatchetSlot: bigint;
+    bidWidth: number;
+    skimBuyAtFloorBps: number;
+    skimSellAtFloorBps: number;
+    maxBounty: bigint;
+    bountyBps: number;
+    /** THE WALL'S SHAPE, written once by `register_pool`: the band's raw width `wallTicks(W)` (0 = open), the
+     *  tail's share of the listed tokens, the list share (⛔ 0 = list everything). */
+    wallBandTicks: number;
+    wallTailBps: number;
+    wallListBps: number;
+    /**
+     * Lamports split off this pool's creator fees and NOT YET MOVED to the distributor — a quote
+     * LIABILITY on the pool's claims until `claim_referral_fees` moves it.
+     * 0 on an unreferred pool, for ever.
+     */
+    referralOwed: bigint;
+    /**
+     * The CUMULATIVE ACCRUED meter: `referralOwed` plus everything `claim_referral_fees` has already
+     * moved out. Raised at every split, NEVER by the claim, and it only ever rises. ⚠ Named `_paid`
+     * for EVM parity, where the wei really does leave inside the swap; here "paid" == "accrued", and
+     * what has actually LEFT the pool is `referralFeesPaid - referralOwed`. 0 on an unreferred pool.
+     */
+    referralFeesPaid: bigint;
+    /**
+     * The share of a GROSS creator fee that goes to `referrer`, in bips (1000 = 10 %).
+     * ⛔ NOT the gate: it is 0 on an unreferred pool too, but the zero KEY is what `take_fees` and
+     * `claim_referral_fees` test; read `referralDestination` for "does this pool fund referrals".
+     */
+    referralShareBps: number;
+    /** @634: the staircase's step count (0 = no staircase), `stairReady` 1 from the graduating buy on, and the step weighting in bps. */
+    stairSteps: number;
+    stairReady: number;
+    stairGrowthBps: number;
+    /** The staircase's parameter set — 0 the presets', 1 `$FLOOR`'s. */
+    stairKind: number;
+    /** 0 none, 1 `$FLOOR`'s team steps, 2 a launch's team steps. */
+    stairOwner: number;
+    /**
+     * Where this pool's share of every creator fee goes, or `null` when it funds none. Derived by
+     * {@link decodeFloorPool}; the all-zero key is the absent sentinel.
+     * ⚠ `null` does not distinguish "opted out" from "written before referrals existed" -- the
+     * bytes are identical and both mean the pool funds nobody and never can (no setter exists).
+     */
+    referralDestination: Address | null;
+    /**
+     * ⛔ RAW — the referrer's WALLET, or 32 zero bytes (the System Program's
+     * spelling) on an unreferred pool. Read {@link FloorPool.referralDestination}.
+     */
+    referrer: Address;
+    /** 1 iff the base mint carries FLOOR's transfer-hook slot. */
+    holdersHooked: number;
+    /** ⛔ RAW — tier 2's wallet or 32 zero bytes. Read {@link FloorPool.referralTiers}. */
+    referrerT2: Address;
+    /** ⛔ RAW — tier 3's wallet or 32 zero bytes. Read {@link FloorPool.referralTiers}. */
+    referrerT3: Address;
+    /** Lifetime quote paid OUT to tier 2. */
+    referralPaidT2: bigint;
+    /** Lifetime quote paid OUT to tier 3. */
+    referralPaidT3: bigint;
+    /** The trader-referral slices booked on this pool and not yet swept into the vault — a
+     *  quote liability. */
+    traderRefOwed: bigint;
+    /** The lifetime trader-referral slices booked on this pool (owed included). */
+    traderRefBooked: bigint;
+    /**
+     * DERIVED by {@link decodeFloorPool}: the three tier wallets `[t1, t2, t3]`,
+     * `null` where unset — `t1` is {@link FloorPool.referralDestination}. The chain keeps them pairwise
+     * distinct, so a wallet names at most one tier of a pool.
+     */
+    referralTiers: [Address | null, Address | null, Address | null];
+    /**
+     * DERIVED by {@link decodeFloorPool}: each tier's due RIGHT NOW, `[due1, due2, due3]` — what
+     * `claim_referral_fees(tier)` pays (`referralTierDuesOf`, the port of `floor_math::referral_tier_dues`).
+     * ⛔ Show THIS per tier, never `referralOwed` (which overstates tier 1 by up to 10 % on a multi-tier launch).
+     */
+    referralTierDues: [bigint, bigint, bigint];
+    /** FLOOR Platform fees this pool took (and a sale's, handed over at graduation) not yet swept — a quote LIABILITY, never backing. */
+    teamOwed: bigint;
+    /** The cumulative meter `sweep_platform_cut`'s team leg raises; only ever rises. */
+    teamFeesPaid: bigint;
+    /** This pool's FLOOR Platform fee rate — the config's pool SETTING at the launch's creation, kept for life; 0 on an older pool, which pays none. Every pool figure uses THIS. */
+    teamFeeBps: number;
+}
+export interface LaunchConfig {
+    version: number;
+    bump: number;
+    cluster: number;
+    governance: Address;
+    attestor: Address;
+    hookProgram: Address;
+    ammProgram: Address;
+    platformBps: number;
+    tickSpacing: number;
+    minBidLamports: bigint;
+    minSellable: bigint;
+    registryCount: bigint;
+    maxBountyLamports: bigint;
+    metadataBaseSetSlot: bigint;
+    bountyBps: number;
+    metadataBaseLen: number;
+    metadataBase: Uint8Array;
+    /** ⛔ RAW: read {@link launchConfigTeamSaleBps}. Meaningful only when `teamBpsSet` is non-zero. */
+    teamSaleBpsRaw: number;
+    /** ⛔ RAW: read {@link launchConfigTeamPoolBps}. Meaningful only when `teamBpsSet` is non-zero. */
+    teamPoolBpsRaw: number;
+    /** 0 = never set (the defaults 100 / 25 apply); non-zero = the two raw rates. */
+    teamBpsSet: number;
+    /** The two-step handover: the candidate `governance` named by `set_governance`, which it must sign `accept_governance` to become (zeroed there); the zero address when none is pending. */
+    pendingGovernance: Address;
+}
+export interface RegistryEntry {
+    index: bigint;
+    launch: Address;
+    mint: Address;
+    ammPool: Address;
+    mode: number;
+    createdSlot: bigint;
+}
+export interface Launch {
+    version: number;
+    bump: number;
+    saleVaultBump: number;
+    lockBump: number;
+    state: number;
+    mode: number;
+    /** The creator-fee recipients are the POOL's `PayeeSlots` tail ({@link FloorPool.payeeSlots}). */
+    mintAuthorityBump: number;
+    mint: Address;
+    creator: Address;
+    ammPool: Address;
+    floorPool: Address;
+    tokenVault: Address;
+    wsolVault: Address;
+    priceX64: bigint;
+    quoteUsdCents: bigint;
+    mcapUsd: bigint;
+    createdSlot: bigint;
+    nonce: bigint;
+    saleTokens: bigint;
+    polTokens: bigint;
+    ladderTokens: bigint;
+    sold: bigint;
+    raised: bigint;
+    buyers: bigint;
+    openTick: number;
+    /** The wallet part's cliffs paid PER TEAM SLOT — slot i owns bits 4i..4i+3 (bit k = cliff
+     *  k paid to it). Read through {@link teamCliffsPaidForSlot}. */
+    teamCliffsPaidBySlot: number;
+    /** Trader referrals: the bump of `["trader_ref_sale", launch]`, the launch's sale referral account. */
+    traderRefSaleBump: number;
+    skimBuyFar: number;
+    skimSellFar: number;
+    creatorBuy: number;
+    creatorSell: number;
+    holderBuy: number;
+    holderSell: number;
+    registryIndex: bigint;
+    graduatedSlot: bigint;
+    /** ⛔ Zeros on a `version < 3` account — read {@link launchQuoteMint}, never this field raw. */
+    quoteMint: Address;
+    /** This sale's FLOOR Platform fee rate — the config's sale SETTING copied at `create_launch`, kept for the sale's life; 0 on an older launch. Every sale figure uses THIS, never a constant. */
+    teamBps: number;
+    /** The sale's FLOOR Platform fees not yet handed to its pool (escrowed beside `raised`, never part of it). */
+    teamOwed: bigint;
+    /** Tokens on team steps (≥ 80 %) and for the deployer's wallet (≤ 20 %). */
+    teamStepTokens: bigint;
+    teamWalletTokens: bigint;
+    /** The graduation's unix seconds (the wallet's cliffs and the steps' lock count from here); 0 before graduation. */
+    teamAnchor: bigint;
+    /** The team steps' lock in days (≥ 90) and the wallet's four cliffs in days after `teamAnchor` (25 % each). */
+    teamLockDays: number;
+    teamVestDays: number[];
+    /** LAMPORTS of the staircase budget `create_launch` prepaid into `["grad_rent", launch]`, still to move to the pool's `["stair_rent", amm_pool]`; `fund_stair_rent` moves it after graduation and writes 0. 0 = nothing owed. */
+    stairRentBudget: number;
+}
+export interface BuyerPosition {
+    bump: number;
+    allocation: bigint;
+    contributed: bigint;
+}
+export interface QuotePolicy {
+    version: number;
+    bump: number;
+    decimals: number;
+    retired: number;
+    quoteMint: Address;
+    tokenProgram: Address;
+    minBidFloor: bigint;
+    minBidCeil: bigint;
+    maxBountyCeil: bigint;
+    minBid: bigint;
+    maxBounty: bigint;
+}
+/** `["holder_book", mint]` under `floor_holders`. */
+export interface HolderBook {
+    version: number;
+    bump: number;
+    metasBump: number;
+    mint: Address;
+    floorPool: Address;
+    quoteMint: Address;
+    acc: bigint;
+    eligible: bigint;
+    indexed: bigint;
+    unallocated: bigint;
+    paid: bigint;
+    records: bigint;
+    createdSlot: bigint;
+    /** Holder tax indexed in `lastSlot`, shared at a later slot. */
+    pending: bigint;
+    lastSlot: bigint;
+}
+/** `["holder", mint, token_account]` under `floor_holders`. */
+export interface HolderRecord {
+    version: number;
+    bump: number;
+    mint: Address;
+    tokenAccount: Address;
+    owner: Address;
+    shares: bigint;
+    snapshot: bigint;
+    owed: bigint;
+    paid: bigint;
+    openedSlot: bigint;
+}
+/**
+ * `governance` alone signs `withdraw_platform`; `pendingGovernance` is the
+ * key a `set_treasury_governance` proposed, or the zero key — which decodes to
+ * `11111111111111111111111111111111` — when nothing is pending.
+ */
+export interface PlatformTreasury {
+    version: number;
+    bump: number;
+    /** (R5): 1 = allow-all quotes on (the platform treasury only). */
+    allowAllQuotes: number;
+    governance: Address;
+    pendingGovernance: Address;
+}
+/**  `$FLOOR`'s pool record. `received` is lamports credited into its backing, lifetime. */
+export interface FloorPlatformPool {
+    version: number;
+    bump: number;
+    floorPool: Address;
+    ammPool: Address;
+    baseMint: Address;
+    quoteMint: Address;
+    received: bigint;
+    credits: bigint;
+    designatedSlot: bigint;
+}
+/** See {@link STAIR_STATE}. Ticks are numbers, liquidity and amounts bigints. */
+export interface StairState {
+    version: number;
+    bump: number;
+    steps: number;
+    placed: number;
+    firstOpen: number;
+    tailPlaced: number;
+    growthBps: number;
+    openEdge: number;
+    tailLower: number;
+    tailUpper: number;
+    cushionLower: number;
+    cushionUpper: number;
+    relistLower: number;
+    relistUpper: number;
+    /** ⛔ H1: the re-list's cushion-bought tokens' ORIGINAL cost line, ticks; 0 = none. */
+    relistCostTick: number;
+    stairTotal: bigint;
+    tailTotal: bigint;
+    collectedTotal: bigint;
+    toPolTotal: bigint;
+    toFloorTotal: bigint;
+    cushionQuote: bigint;
+    tailLiq: bigint;
+    cushionLiq: bigint;
+    relistLiq: bigint;
+    stepLower: number[];
+    stepUpper: number[];
+    stepLiq: bigint[];
+    reserveLower: number;
+    reserveUpper: number;
+    reserveLiq: bigint;
+    vaultListedTokens: bigint;
+    vaultListedCost: bigint;
+    vaultFedBought: bigint;
+    /** The pool's own numbers; 0 = the presets' (floor_hook's `StairState::params`; `predict.ts` falls back to `CUSHION_TICKS`). */
+    cushionBottomBps: number;
+    polToMcapBps: number;
+    cushionTicks: number;
+    /** Step money `sweep_stair_fees` collected, for the next ratchet to split. */
+    sweptQuote: bigint;
+}
+/** A trader's link ({@link TRADER_LINK}); an unset tier is the zero key. */
+export interface TraderLink {
+    trader: Address;
+    tier1: Address;
+    tier2: Address;
+    tier3: Address;
+    bump: number;
+}
+/** A trader's bucket in one quote ({@link TRADER_BUCKET}); `owed[i]` is tier `i + 1`'s. */
+export interface TraderBucket {
+    trader: Address;
+    quoteMint: Address;
+    tier1: Address;
+    tier2: Address;
+    tier3: Address;
+    owed: bigint[];
+    bump: number;
+}
+/**
+ * The mint a launch is quoted in — the TS twin of
+ * `floor_types::layout::Launch::quote_mint`, and the same branch: offset 400 is zeros on every
+ * account written before `version` 3, and those launches are wSOL-quoted because nothing else could
+ * be created then. Every builder that needs the quote (`buildBuy`, `buildSellBack`,
+ * `graduationAccounts`) is handed it through this, never the raw field.
+ */
+export declare function launchQuoteMint(l: Pick<Launch, 'version' | 'quoteMint'>): Address;
+export declare const decodeHookConfig: (data: Uint8Array) => HookConfig;
+/**
+ * ⛔ The all-zero key is ABSENT, never a destination. `decodeAccount`
+ * turns 32 zero bytes into `11111111111111111111111111111111` like any other key -- the assertion
+ * in `test/layouts.test.ts` that a zero `creator` "decodes as the default address" is that same
+ * behaviour, written down -- so an unreferred pool would otherwise report the System Program as
+ * its referral distributor. `referralDestination` is the only honest read.
+ */
+export declare const decodeFloorPool: (data: Uint8Array) => FloorPool;
+/**
+ *  each tier's due, `[due1, due2, due3]` — a BYTE-FOR-BYTE
+ * port of `floor_math::referral_tier_dues` (`crates/floor-math/src/referral.rs`), the ONE spelling the
+ * program's `claim_referral_fees` runs; `test/referral-tiers.test.ts` pins the two with the same vectors.
+ *
+ * ```text
+ * L = referralFeesPaid // Solana: the lifetime BOOKED meter (owed included)
+ * up2 = t2 set ? L / 10: 0; up3 = t2 && t3 set ? up2 / 10: 0
+ * earned = [L − up2, up2 − up3, up3] // exact: Σ == L; monotone in L
+ * paid1 = L − owed − paidT2 − paidT3 // DERIVED, never stored
+ * due_i = max(earned_i − paid_i, 0), each ≤ owed
+ * ```
+ * ⛔ Computed from the RUNNING TOTAL, never by splitting each accrual event (the sum of floors is not the
+ *    floor of the sum). An inconsistent pool (owed + paid2 + paid3 > L) is due nothing, as on chain.
+ */
+export declare function referralTierDuesOf(p: Pick<FloorPool, 'referralFeesPaid' | 'referralOwed' | 'referralPaidT2' | 'referralPaidT3' | 'referrerT2' | 'referrerT3'>): [bigint, bigint, bigint];
+/**
+ * The ONE derived field reads the
+ * pool's `referrer` WALLET — exactly as
+ * `floor_types::layout::FloorPool::referral_destination` does (the zero key is the gate `take_fees`
+ * tests). What it MEANS is unchanged ("where this pool's referral share goes, or `null` when it funds
+ * none"); what it NAMES moved from a distributor to a wallet, whose quote ATA `claim_referral_fees` pays.
+ */
+export declare function referralDestinationOf(p: Pick<FloorPool, 'referrer'>): Address | null;
+/**
+ * The transfer-hook program a pool (or an approved hook) ADMITS armed on its base mint, or `null` (the
+ * stored zero key). ⛔ Read this, never `baseTransferHook` raw: 32 zero bytes decode to the System Program.
+ */
+export declare function admittedBaseTransferHook(p: {
+    baseTransferHook: Address;
+}): Address | null;
+export declare const decodeLaunchConfig: (data: Uint8Array) => LaunchConfig;
+/**
+ * The TS twin of `floor_types::layout::team_rate_setting`, the ONE
+ * reading of `LaunchConfig`'s platform-fee setting: `set == 0` is the default; otherwise the raw rate,
+ * never above `cap`. `test/layouts.test.ts` holds it to the Rust function's cases.
+ */
+export declare function teamRateSetting(set: number, raw: number, dflt: number, cap: number): number;
+/**
+ * The FLOOR Platform fee a sale created NOW charges on every buy and sell-back (what `create_launch` copies into
+ * `Launch.teamBps`): the default 100 until `set_team_fees` runs. ⛔ A RUNNING sale charges its own `teamBps`,
+ * never this.
+ */
+export declare function launchConfigTeamSaleBps(c: Pick<LaunchConfig, 'teamBpsSet' | 'teamSaleBpsRaw'>): number;
+/**
+ * The FLOOR Platform fee a pool created NOW charges on every swap after graduation (what `create_launch` hands
+ * `register_pool`): the default 25 until `set_team_fees` runs. ⛔ An EXISTING pool charges its own `teamFeeBps`.
+ */
+export declare function launchConfigTeamPoolBps(c: Pick<LaunchConfig, 'teamBpsSet' | 'teamPoolBpsRaw'>): number;
+export declare const decodeRegistryEntry: (data: Uint8Array) => RegistryEntry;
+export declare const decodeLaunch: (data: Uint8Array) => Launch;
+export declare const decodeQuotePolicy: (data: Uint8Array) => QuotePolicy;
+export declare const decodePlatformTreasury: (data: Uint8Array) => PlatformTreasury;
+export declare const decodeFloorPlatformPool: (data: Uint8Array) => FloorPlatformPool;
+export declare const decodeBuyerPosition: (data: Uint8Array) => BuyerPosition;
+/**  `["floor_platform_pool"]` (exactly 232 B). */
+/** `["trader_link", trader]` (exactly 144 B). */
+export declare const decodeTraderLink: (data: Uint8Array) => TraderLink;
+/** `["trader_ref", trader, quote_mint]` (exactly 200 B). */
+export declare const decodeTraderBucket: (data: Uint8Array) => TraderBucket;
+/** An owner pool's `StairState` account carries the owner books as a 440-byte
+ *  TAIL; the struct itself is unchanged, so both lengths decode. */
+export declare const decodeStairState: (data: Uint8Array) => StairState;
+/** The owner books' ACCOUNT offset in a `StairState` account: 8 + 584. */
+export declare const STAIR_OWNERS_OFFSET = 592;
+/** `size_of::<floor_types::owners::StairOwners>`. */
+export declare const STAIR_OWNERS_SIZE = 440;
+/** A `StairState` account carrying the owner tail: 592 + 440. */
+export declare const STAIR_STATE_ACCOUNT_LEN_WITH_OWNERS: number;
+/**
+ * `floor_types::owners::StairOwners`, the owner books of a
+ * staircase pool whose `FloorPool.stairOwner != 0` — `$FLOOR`'s TEAM steps (kind 1) or a launch's TEAM-BUY steps (kind 2).
+ * Offsets are within the tail.
+ */
+export declare const STAIR_OWNERS_FIELDS: readonly (readonly [string, number, FieldKind])[];
+export interface StairOwners {
+    /** 0 while only sized (before graduation), 1 once graduation filled it. */
+    version: number;
+    /** 1 `$FLOOR`'s team, 2 a launch's deployer. */
+    kind: number;
+    /** 1: the owner's standing tokens count against the floor — withdrawal is free. */
+    counted: number;
+    /** The lowest step holding owner tokens at graduation — the first to unlock. */
+    firstStep: number;
+    /** The payee's share of what the owner's tokens sell for, after FLOOR FIRST (team 4,000; deployer 8,000). */
+    payeeBps: number;
+    /** Seconds after `anchor` the first step unlocks; then one more step every `everySecs` (0 = every step at once). */
+    firstUnlockSecs: number;
+    everySecs: number;
+    anchor: bigint;
+    ownerTotal: bigint;
+    ownerSold: bigint;
+    ownerWithdrawn: bigint;
+    ownerProceeds: bigint;
+    owedTotal: bigint;
+    forfeited: bigint;
+    /** Lifetime keepers' tips out of `sweep_stair_payee`. */
+    feesToFloor: bigint;
+    tipsPaid: bigint;
+    /** Owner tokens still standing on step i, and what withdrawals cut out of steps riding the reserve. */
+    tokens: bigint[];
+    cut: bigint[];
+    /** Unix seconds of the last `sweep_stair_payee` that PAID a tip; 0 = never. */
+    lastTipAt: bigint;
+    /** ⛔ The team's HELD tokens: owner tokens whose step
+     *  left the staircase unsold, set aside for the payee — counted against the floor, paid by `withdraw_stair_tokens(STAIR_HELD_STEP)`
+     *  ({@link buildWithdrawHeldTokens}). */
+    held: bigint;
+    /** The protocol's (vault-fed) tokens riding the reserve; a close sells them first. */
+    reserveFed: bigint;
+    /** Lifetime: owner tokens dropped as placement rounding (never paid, never sold). */
+    clamped: bigint;
+}
+/** The owner books of a `StairState` ACCOUNT's bytes, or `null` when the account carries none (shorter than 1,032). */
+export declare function decodeStairOwners(account: Uint8Array): StairOwners | null;
+export declare const decodeHolderBook: (data: Uint8Array) => HolderBook;
+export declare const decodeHolderRecord: (data: Uint8Array) => HolderRecord;
+export declare const TWAP_ORACLE_OFFSET = 792;
+export declare const TWAP_ORACLE_SIZE = 216;
+export declare const FLOOR_POOL_ACCOUNT_LEN_WITH_TWAP: number;
+export declare const TWAP_CHECKPOINTS = 8;
+export declare const TWAP_CHECKPOINT_SPACING_SECS = 300;
+/** `TwapOracle::older_surplus_held`'s offset inside the tail (`floor_types::twap` pins 152). */
+export declare const TWAP_OLDER_SURPLUS_HELD_OFFSET = 152;
+/**
+ * THE GAP BUY SKIM's cache:
+ * `TwapOracle::cushion_top_set` (u8) at tail byte 153 and `cushion_top_tick` (i32) at 156 — the cushion's top in PRICE
+ * (its LOWER tick) as the last ratchet placed it. The wasm quoter reads it off the same account bytes itself.
+ */
+export declare const TWAP_CUSHION_TOP_SET_OFFSET = 153;
+export declare const TWAP_CUSHION_TOP_TICK_OFFSET = 156;
+/** `TwapOracle::flow_a` (i128 LE) at tail byte 160 and
+ *  `flow_b` (u64 LE) at 176, written by `after_swap` while the switch is ON (`STAIR_CUSHION_NETFLOW_BPS`). */
+export declare const TWAP_NETFLOW_A_OFFSET = 160;
+export declare const TWAP_NETFLOW_B_OFFSET = 176;
+export interface TwapCheckpointView {
+    readonly tickCumulative: bigint;
+    readonly timestamp: number;
+}
+export interface TwapOracleView {
+    /** 0 = never written; 1 after the first write. */
+    readonly version: number;
+    /** Ring index of the newest checkpoint. */
+    readonly newest: number;
+    /** Checkpoints written so far, at most 8. */
+    readonly count: number;
+    /** The current observation: Σ tick × seconds up to `timestamp`, and the tick that write saw. */
+    readonly current: {
+        readonly tickCumulative: bigint;
+        readonly timestamp: number;
+        readonly lastTick: number;
+    };
+    /** The ring, in slot order (index `newest` is the newest; unwritten slots are zero). */
+    readonly checkpoints: readonly TwapCheckpointView[];
+    /**
+     * 1 when the last ratchet held older surplus back at the settled stand line.
+     */
+    readonly olderSurplusHeld: number;
+    /** 1 when the last ratchet left a cushion standing. */
+    readonly cushionTopSet?: number;
+    /** Its top in price (the cushion's LOWER tick), byte 156; read only while `cushionTopSet` is 1. */
+    readonly cushionTopTick?: number;
+    /** The net-flow meter, bytes 160..184: `a` = Σ quote × tick, `b` = Σ quote. */
+    readonly netFlow?: {
+        readonly a: bigint;
+        readonly b: bigint;
+    };
+}
+/**
+ * The TWAP tail of a `FloorPool` ACCOUNT's bytes (the whole account, discriminator included), or `null` for a
+ * pool without one. Reads only; the window
+ * arithmetic is the program's (`twap_tick`, simulated), never re-derived here.
+ */
+export declare function decodeFloorPoolTwap(account: Uint8Array): TwapOracleView | null;
+//# sourceMappingURL=layouts.d.ts.map