@gabox-labs/sdk 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -3,6 +3,49 @@
 All notable changes to `@gabox-labs/sdk`. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and the project uses [Semantic Versioning](https://semver.org/) with the `0.x` rule from `CONTRIBUTING.md`.
 
+## [0.8.0] - 2026-09-19
+
+The platform's own fees, so the app can show them and claim them.
+
+### Added
+
+- `raydium.fetchPlatformFees(client, { quoteMint })` reads the LaunchLab platform fee vault for one
+  quote asset, and `raydium.claimPlatformFee(client, { feeWallet, quoteMint })` claims it with
+  `claim_platform_fee_from_vault`. Only the wallet the platform config names can sign it.
+- `raydium.fetchLockedPositions(client, owner)` lists every locked CPMM position a wallet holds the
+  fee NFT of, with the pool behind it and what it may withdraw now. `raydium.harvestLockedFees`
+  builds the lock program's `collect_cp_fees` for one of them. `raydium.lockedFeeLp` is the math,
+  checked against the lock program's own event on devnet.
+- `raydiumIds` now carries Raydium's lock program and its authority per cluster, as `lock` and
+  `lockAuthority`. `decodeLockedCpLiquidity` reads a lock record, and `CpmmPoolState` gains
+  `lpMint` and `lpSupply`.
+- `HARVEST_COMPUTE_UNITS`, measured at `102,221` on devnet.
+
+### Changed
+
+- `RaydiumIds` is now the generated cluster table plus the lock ids. A caller that passed
+  `RAYDIUM_DEVNET_IDS` straight from `abi.ts` into a builder passes `raydiumIds('devnet')` instead.
+
+## [0.7.1] - 2026-09-18
+
+A product correction. Paying in SOL is for buyers, not for creators.
+
+### Removed
+
+- The seed-in-SOL option on `createMachine`: the creator pays the seed in the quote token. The
+  `payWith` input is gone, and with it the swap leg, the route safety check and the extra compute
+  units that creation used to ask for. A machine quoted in USDC now needs its creator to hold at
+  least `maxSeedQuoteIn` of USDC before the transaction runs, and `seedCostEstimate` says how much
+  that is.
+
+### Changed
+
+- `SeedCostEstimate.solAmount` stays, and it is a display. It is what the seed is worth in SOL
+  through the route provider, not an amount any instruction spends. The create page shows it beside
+  the quote-token cost.
+- `buyPack` keeps `payWith` and `sellTokens` keeps `receive`, both unchanged. Only a buyer arrives
+  holding SOL alone, so only a pack buy and a sale swap.
+
 ## [0.7.0] - 2026-09-18
 
 Any quote token Raydium enabled, a price shown in SOL, and payment in SOL through a swap that runs

package/README.md

@@ -19,7 +19,9 @@ this SDK shows is the venue's own price with the venue's own fees already inside
 | coin creator | 0.5% of every trade | the pool's `creator_fee_rate` |
 
 Those shares come out of Raydium's revenue, not out of an extra charge Gabox adds. The creator
-collects theirs with `raydium.claimCreatorFee` and `raydium.collectCreatorFee`.
+collects theirs with `raydium.claimCreatorFee` and `raydium.collectCreatorFee`. The platform
+collects its curve share with `raydium.claimPlatformFee`, and after graduation it holds the locked
+LP of every pool, whose trade fees `raydium.harvestLockedFees` pays out.
 
 ## The quote asset
 
@@ -46,6 +48,9 @@ Buyers pay in SOL whatever the pool is priced in.
   splits the two, because a swap that settled on its own would leave the buyer holding a token they
   never asked for.
 
+This is for packs and sales only. **A machine's seed is always paid by its creator, in the
+machine's own quote token**, so `createMachine` never swaps. See "Create a machine" below.
+
 ```ts
 import { createClient, raydiumCpmmRoute } from '@gabox-labs/sdk';
 
@@ -56,9 +61,8 @@ const client = createClient({
 });
 ```
 
-`payWith: 'quote'` on `buyPack` and `createMachine` skips the swap and spends the token the wallet
-already holds. `receive: 'quote'` does the same for a sale. A WSOL pool ignores both: its quote
-token is SOL.
+`payWith: 'quote'` on `buyPack` skips the swap and spends the token the wallet already holds.
+`receive: 'quote'` does the same for a sale. A WSOL pool ignores both: its quote token is SOL.
 
 The swap has to fit in the same 1,232-byte transaction as the buy. When it does not, the builder
 fails with a clear error rather than splitting the work; supply more address lookup tables, or pay
@@ -96,9 +100,9 @@ Everything else is fixed: 6 decimals, 1,000,000,000 coins, 793,100,000 of them s
 graduate into a CPMM pool, no vesting, the CPMM creator fee paid in the quote token. Metaplex limits
 the three strings to 32, 10 and 200 UTF-8 bytes.
 
-`maxSeedQuoteIn` is both the slippage cap on the seed buy and the amount of the quote token put in
-the creator's quote account before it. `maxSeedNativeDebit` is separate and small: it caps the
-lamports of rent LaunchLab charges for the fee vaults it creates on a coin's first trade.
+`maxSeedQuoteIn` is the slippage cap on the seed buy, in the quote token, and the creator must
+already hold that much. `maxSeedNativeDebit` is separate and small: it caps the lamports of rent
+LaunchLab charges for the fee vaults it creates on a coin's first trade.
 
 ### Another quote asset
 
@@ -112,21 +116,24 @@ const message = await createMachine(client, {
   uri: 'https://example.com/metadata.json',
   quote: { mint: usdc },
   raise,                       // total_quote_fund_raising, in USDC base units
-  payWith: 'sol',              // the default: the seed is bought with a swap
   maxSeedQuoteIn: (estimate.quoteAmount * 110n) / 100n,
   maxSeedNativeDebit: 100_000_000n,
 });
 ```
 
+**The creator pays the seed, in the machine's own quote token.** There is no swap here: a machine
+quoted in USDC needs the creator to hold at least `maxSeedQuoteIn` of USDC before this transaction
+runs. Only a buyer arrives holding SOL alone, so only `buyPack` and `sellTokens` swap.
+
 `raise` is how much the curve must take in before the coin graduates, in the quote's own base units.
 A WSOL pool has it pinned by the program — 85 SOL on mainnet, 3 SOL on devnet — so leave it out
 there. Any other quote has no default, because the same number means a different amount in every
 token. LaunchLab refuses a raise below `min_quote_fund_raising` in that quote's config, and
 `createMachine` checks the same thing before it builds anything.
 
-`seedCostEstimate` reports `quoteAmount` in the quote token, `quoteDecimals`, `quoteSymbol`, the
-`raise` it would use, and `solAmount`: the same cost in lamports through the route provider, or
-`null` when nothing can price it.
+`seedCostEstimate` reports `quoteAmount` in the quote token — what the creator actually pays —
+plus `quoteDecimals`, `quoteSymbol` and the `raise` it would use. `solAmount` is what that cost is
+worth in lamports through the route provider, for a display, or `null` when nothing can price it.
 
 ### The seed
 
@@ -217,6 +224,25 @@ reads the quote off the Gabox pool itself.
 Both pay into the creator's account for the quote mint. When that is WSOL the builders close it, so
 the creator receives SOL; any other quote arrives as that token.
 
+## Platform fees
+
+```ts
+const owed = await raydium.fetchPlatformFees(client, { quoteMint });   // owed.curveQuote
+await raydium.claimPlatformFee(client, { feeWallet, quoteMint });      // every coin on that quote
+
+const positions = await raydium.fetchLockedPositions(client, feeWallet.address);
+// position.poolAddress, position.claimableLp, position.claimableToken0, position.claimableToken1
+await raydium.harvestLockedFees(client, { owner: feeWallet, position });  // one graduated coin
+```
+
+The platform's curve share waits in one LaunchLab vault per quote asset, and only the wallet the
+platform config names as `platform_fee_wallet` can claim it. At graduation LaunchLab locks the
+whole CPMM pool's LP under Raydium's lock program and mints one fee NFT to the platform NFT wallet.
+`fetchLockedPositions` finds every such NFT in a wallet, reads the lock record and the pool behind
+each, and computes what the position may withdraw now: the LP growth since the last harvest, as
+`lockedFeeLp` works it out from the pool's `x * y` and LP supply. `harvestLockedFees` withdraws
+that LP and pays both sides of the pair into the owner's accounts, closing the WSOL one.
+
 ## Wallet activity
 
 `buyPack` keeps a `WalletActivity` account per buyer, at the PDA `findActivityPda({ purchaser })`

package/dist/{index-C4at2cZ_.d.ts → index-CQcBMEah.d.ts}

@@ -68,8 +68,9 @@ type ClientConfig = {
    *
    * Mainnet defaults to Jupiter, which is where the liquidity is. Devnet and localnet default to
    * none, because Jupiter does not serve them: pass `raydiumCpmmRoute(pool)` with a CPMM pool that
-   * holds the SOL/quote pair. `null` disables the swap leg, and `payWith: 'sol'` then fails on a
-   * pool quoted in anything but WSOL.
+   * holds the SOL/quote pair. `null` disables the swap leg, and `buyPack`'s `payWith: 'sol'` then
+   * fails on a pool quoted in anything but WSOL. Creating a machine never needs it: the creator
+   * pays the seed in the machine's own quote token.
    */
   route?: RouteProvider | null;
 };
@@ -228,6 +229,10 @@ declare const LAUNCHLAB_SELL_EXACT_IN: VenueInstructionAbi;
  * `claim_creator_fee` on `LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj` — not in interfaces.json (the program never builds it).
  */
 declare const LAUNCHLAB_CLAIM_CREATOR_FEE: VenueInstructionAbi;
+/**
+ * `claim_platform_fee_from_vault` on `LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj` — not in interfaces.json (the program never builds it).
+ */
+declare const LAUNCHLAB_CLAIM_PLATFORM_FEE_FROM_VAULT: VenueInstructionAbi;
 /**
  * `swap_base_output` on `CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C` — cross-checked against interfaces.json.
  */
@@ -244,8 +249,22 @@ declare const CPMM_SWAP_BASE_INPUT: VenueInstructionAbi;
 declare const CPMM_COLLECT_CREATOR_FEE: VenueInstructionAbi;
 //#endregion
 //#region src/raydium/ids.d.ts
+/**
+ * Raydium's liquidity lock program and its authority, per cluster.
+ *
+ * LaunchLab locks every graduated pool's LP under this program and mints one fee NFT to the
+ * platform NFT wallet. The Gabox program never calls it, so these two addresses are not in the Rust
+ * `ids.rs` and are typed here instead. Verified 2026-09-19: the devnet migration of a Gabox coin
+ * called the devnet program below, and `test/raydium-pdas.test.ts` derives both authorities.
+ */
+type LockIds = {
+  /** The lock program. `collect_cp_fees` on it pays the fee NFT holder. */
+  lock: Address;
+  /** `["lock_cp_authority_seed"]` under `lock`. It owns the vault that holds the locked LP. */
+  lockAuthority: Address;
+};
 /** The name the rest of the SDK uses for one cluster's Raydium deployment. */
-type RaydiumIds = RaydiumClusterIds;
+type RaydiumIds = RaydiumClusterIds & LockIds;
 /**
  * The decimals every Gabox coin is launched with. `venue/launch.rs` refuses any other value, and
  * `tokens.rs` refuses a pool mint that does not have exactly this many.
@@ -277,6 +296,8 @@ declare const LAUNCHLAB_SEEDS: {
   readonly vault: "pool_vault";
   /** `["creator_fee_vault_auth_seed"]`, the authority over every creator fee vault. */
   readonly creatorFeeVaultAuthority: "creator_fee_vault_auth_seed";
+  /** `["platform_fee_vault_auth_seed"]`, the authority over every platform fee vault. */
+  readonly platformFeeVaultAuthority: "platform_fee_vault_auth_seed";
 };
 /** CPMM's PDA seeds. */
 declare const CPMM_SEEDS: {
@@ -291,6 +312,15 @@ declare const CPMM_SEEDS: {
   /** `["creator_fee_share", creator, amm_config]`. */
   readonly creatorFeeShare: "creator_fee_share";
 };
+/** The SPL Memo program. The lock program's `collect_cp_fees` lists it and never writes to it. */
+declare const MEMO_PROGRAM_ADDRESS: Address;
+/** The lock program's PDA seeds. */
+declare const LOCK_SEEDS: {
+  /** `["lock_cp_authority_seed"]`. */
+  readonly authority: "lock_cp_authority_seed";
+  /** `["locked_liquidity", fee_nft_mint]`. One record per locked position. */
+  readonly lockedLiquidity: "locked_liquidity";
+};
 /** Metaplex's metadata PDA seed: `["metadata", metaplex, mint]`. */
 declare const METADATA_SEED = "metadata";
 /**
@@ -435,6 +465,8 @@ type CpmmPoolState = {
   poolCreator: Address;
   token0Vault: Address;
   token1Vault: Address;
+  /** The LP token. A graduated coin's LP is locked, and its fee NFT holder harvests the fees. */
+  lpMint: Address;
   token0Mint: Address;
   token1Mint: Address;
   token0Program: Address;
@@ -442,6 +474,8 @@ type CpmmPoolState = {
   observationKey: Address;
   /** Bit flags. Bit 2 set (value 4) means swaps are switched off. */
   status: number;
+  /** LP tokens in circulation. The pool keeps this equal to the LP mint's supply. */
+  lpSupply: bigint;
   mint0Decimals: number;
   mint1Decimals: number;
   /** Fees the pool owes and a swap must not spend. Subtract them from the vault balances. */
@@ -490,6 +524,36 @@ type CpmmAmmConfig = {
 };
 declare const CPMM_AMM_CONFIG_HEAD_SIZE = 116;
 declare function decodeCpmmAmmConfig(data: Uint8Array): CpmmAmmConfig;
+/**
+ * One locked CPMM position, as Raydium's lock program records it.
+ *
+ * LaunchLab locks a graduated pool's LP here and mints one fee NFT for it. Whoever holds the NFT
+ * harvests the fees. Layout from `LockedCpLiquidityState` in the `pinocchio-raydium-locking-program`
+ * crate, checked against a devnet record on 2026-09-19: six numbers, four addresses, then padding.
+ */
+type LockedCpLiquidity = {
+  /** LP tokens still locked. A harvest withdraws some of them and lowers this. */
+  lockedLpAmount: bigint;
+  /** LP tokens every past harvest withdrew, in total. */
+  claimedLpAmount: bigint;
+  unclaimedLpAmount: bigint;
+  /** The LP supply at the last checkpoint: the lock itself, or the last harvest. */
+  lastLp: bigint;
+  /** The pool's `x * y` at that checkpoint, on the balances that belong to LPs. */
+  lastK: bigint;
+  recentEpoch: bigint;
+  /** The CPMM pool the LP belongs to. */
+  poolId: Address;
+  /** The NFT whose holder may harvest. */
+  feeNftMint: Address;
+  lockedOwner: Address;
+  lockedLpMint: Address;
+};
+/** `sha256("account:LockedCpLiquidityState")[0..8]`. */
+declare const LOCKED_CP_LIQUIDITY_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+/** Six numbers and four addresses after the discriminator. The account itself is 256 bytes. */
+declare const LOCKED_CP_LIQUIDITY_HEAD_SIZE: number;
+declare function decodeLockedCpLiquidity(data: Uint8Array): LockedCpLiquidity;
 //#endregion
 //#region src/raydium/curve.d.ts
 /**
@@ -1053,6 +1117,11 @@ declare const platformFeeVaultAddress: (launchlab: Address, platformConfig: Addr
 declare const creatorFeeVaultAddress: (launchlab: Address, creator: Address, quoteMint: Address) => Promise<Address>;
 /** `["creator_fee_vault_auth_seed"]`. The authority `claim_creator_fee` signs the payout with. */
 declare const creatorFeeVaultAuthority: (launchlab: Address) => Promise<Address>;
+/**
+ * `["platform_fee_vault_auth_seed"]`. The authority `claim_platform_fee_from_vault` signs the
+ * payout with.
+ */
+declare const platformFeeVaultAuthority: (launchlab: Address) => Promise<Address>;
 /** `["metadata", metaplex, mint]` under Metaplex. LaunchLab's create instruction writes it. */
 declare const metadataAddress: (mint: Address) => Promise<Address>;
 /** `["vault_and_lp_mint_auth_seed"]`. */
@@ -1079,9 +1148,126 @@ declare const cpmmPoolAddress: (cpmm: Address, ammConfig: Address, mintA: Addres
  * (3005) when it is missing. One account per creator per fee tier, not one per pool.
  */
 declare const cpmmCreatorFeeShare: (cpmm: Address, creator: Address, ammConfig: Address) => Promise<Address>;
+/** `["lock_cp_authority_seed"]`. The lock program's authority, which owns every locked LP vault. */
+declare const lockAuthority: (lock: Address) => Promise<Address>;
+/**
+ * `["locked_liquidity", fee_nft_mint]`. The record of one locked position: which pool, how much LP,
+ * and the checkpoint the next fee harvest is measured from.
+ */
+declare const lockedLiquidityAddress: (lock: Address, feeNftMint: Address) => Promise<Address>;
 /** An associated token account. Off-curve owners are allowed: pool PDAs are all off-curve. */
 declare const ata: (owner: Address, mint: Address, tokenProgram?: Address) => Promise<Address>;
 //#endregion
+//#region src/raydium/platform.d.ts
+/**
+ * The instructions of a platform fee claim, for one quote asset: create the quote account, claim,
+ * and close it again when the quote is WSOL.
+ *
+ * This sweeps **every** coin launched against that quote, because LaunchLab keeps one platform
+ * vault per quote asset. `feeWallet` must be the wallet the platform config names, or LaunchLab
+ * refuses the claim.
+ */
+declare function getClaimPlatformFeeInstructions(feeWallet: TransactionSigner, ids: RaydiumIds, quote: {
+  mint: Address;
+  tokenProgram: Address;
+}): Promise<Instruction[]>;
+type ClaimPlatformFeeInput = {
+  /** The platform fee wallet. It signs, and it receives the payout. */
+  feeWallet: TransactionSigner;
+  /** The quote asset to claim. Defaults to wrapped SOL. One claim per quote asset. */
+  quoteMint?: Address;
+} & Partial<BuildOptions>;
+/**
+ * Claim the curve platform fee for one quote asset.
+ *
+ * A WSOL claim arrives as SOL, because the builder closes the WSOL account. Any other quote arrives
+ * as that token, in the fee wallet's own account.
+ */
+declare function claimPlatformFee(client: GaboxClient, input: ClaimPlatformFeeInput): Promise<GaboxTransactionMessage>;
+/**
+ * What the platform can claim from the curve right now, for one quote asset, in base units.
+ *
+ * `quoteMint` defaults to wrapped SOL. One vault per quote asset, so a platform with coins on two
+ * quotes reads this twice. A vault that does not exist yet reads as zero.
+ */
+declare function fetchPlatformFees(client: GaboxClient, input?: {
+  quoteMint?: Address;
+}): Promise<{
+  quoteMint: Address;
+  curveQuote: bigint;
+}>;
+/**
+ * `collect_cp_fees` on the lock program. There is no public IDL for it. The account list and the
+ * discriminator come from Raydium's own SDK and from the `pinocchio-raydium-locking-program`
+ * client crate, and the devnet harvest in `test/devnet.e2e.test.ts` runs it.
+ */
+declare const LOCK_COLLECT_CP_FEES: VenueInstructionAbi;
+/** One locked CPMM position a wallet holds the fee NFT of, with what it can harvest right now. */
+type LockedPosition = {
+  /** The fee NFT. Holding it is the right to harvest. */
+  feeNftMint: Address;
+  /** The lock program's record for this position. */
+  record: Address;
+  lock: LockedCpLiquidity;
+  /** The CPMM pool the LP belongs to. */
+  poolAddress: Address;
+  pool: CpmmPoolState;
+  /** The pool's balances that belong to LPs: each vault less the fees the pool still owes. */
+  vault0: bigint;
+  vault1: bigint;
+  /** LP tokens the position may withdraw now. Zero until the pool trades. */
+  claimableLp: bigint;
+  /** What those LP tokens are worth in the pool's two tokens, rounded down. */
+  claimableToken0: bigint;
+  claimableToken1: bigint;
+};
+/**
+ * The LP tokens a locked position may withdraw as fees.
+ *
+ * Every swap leaves its fee in the vaults, so one LP token buys a little more of the pool after
+ * each trade than before it. The record keeps the pool's `x * y` and LP supply from its last
+ * checkpoint. The LP tokens that still hold exactly the checkpoint's liquidity are
+ * `locked * sqrt(last_k) / last_lp * supply / sqrt(k)`; everything above that is fee growth.
+ *
+ * The division rounds the kept part up, so the answer never claims a unit the pool does not owe.
+ */
+declare function lockedFeeLp(lock: Pick<LockedCpLiquidity, 'lockedLpAmount' | 'lastLp' | 'lastK'>, pool: {
+  vault0: bigint;
+  vault1: bigint;
+  lpSupply: bigint;
+}): bigint;
+/**
+ * Every locked CPMM position `owner` holds a fee NFT for, with what each one can harvest.
+ *
+ * Three reads: the wallet's token accounts, then the lock record behind every NFT-shaped one, then
+ * the pool and the two vaults of every record found. A token account of one unit and zero decimals
+ * is not always a lock NFT, so the record decides: no record, not a position.
+ */
+declare function fetchLockedPositions(client: GaboxClient, owner: Address, ids?: RaydiumIds): Promise<LockedPosition[]>;
+/**
+ * The instructions of one harvest: create the two token accounts, collect, and close the WSOL one
+ * when a side is WSOL.
+ *
+ * `feeLp` defaults to everything the position can withdraw now. The lock program refuses more than
+ * that, so a caller that passes its own number keeps it at or below `position.claimableLp`.
+ */
+declare function getHarvestLockedFeesInstructions(owner: TransactionSigner, ids: RaydiumIds, position: LockedPosition, feeLp?: bigint): Promise<Instruction[]>;
+type HarvestLockedFeesInput = {
+  /** The wallet holding the fee NFT. It signs, and it receives both tokens. */
+  owner: TransactionSigner;
+  /** The position, as `fetchLockedPositions` returned it. */
+  position: LockedPosition;
+  /** LP tokens to withdraw. Defaults to everything harvestable now. */
+  feeLp?: bigint;
+} & Partial<BuildOptions>;
+/**
+ * Harvest one locked position's fees.
+ *
+ * A pool with WSOL on one side pays that side out as SOL, because the builder closes the WSOL
+ * account. The other side arrives as that token, in the owner's own account.
+ */
+declare function harvestLockedFees(client: GaboxClient, input: HarvestLockedFeesInput): Promise<GaboxTransactionMessage>;
+//#endregion
 //#region src/raydium/quote.d.ts
 /** LaunchLab's settings for one quote, and the address they were read from. */
 type QuoteConfig = LaunchlabGlobalConfig & {
@@ -1177,8 +1363,8 @@ type CurveBuyExactInInput = {
  */
 declare function getCurveBuyExactInInstruction(client: GaboxClient, input: CurveBuyExactInInput, ids?: RaydiumIds): Promise<Instruction>;
 declare namespace index_d_exports {
-  export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, CONSTANT_CURVE_TAG, CPMM_AMM_CONFIG_DISCRIMINATOR, CPMM_AMM_CONFIG_HEAD_SIZE, CPMM_COLLECT_CREATOR_FEE, CPMM_POOL_OFFSETS, CPMM_POOL_STATE_DISCRIMINATOR, CPMM_POOL_STATE_HEAD_SIZE, CPMM_POOL_STATE_SIZE, CPMM_SEEDS, CPMM_SWAP_BASE_INPUT, CPMM_SWAP_BASE_OUTPUT, CREATOR_FEE_ON_QUOTE, ClaimCreatorFeeInput, CollectCreatorFeeInput, CpmmAmmConfig, CpmmFeeRates, CpmmPoolState, CpmmSwapSides, CpmmTradeAccountsInput, CreatorFees, CurveBuyExactInInput, CurveFeeRates, CurveReserves, CurveSettings, FindCpmmPoolOptions, LAUNCHLAB_BUY_EXACT_IN, LAUNCHLAB_BUY_EXACT_OUT, LAUNCHLAB_CLAIM_CREATOR_FEE, LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR, LAUNCHLAB_GLOBAL_CONFIG_HEAD_SIZE, LAUNCHLAB_INITIALIZE, LAUNCHLAB_PLATFORM_CONFIG_DISCRIMINATOR, LAUNCHLAB_PLATFORM_CONFIG_HEAD_SIZE, LAUNCHLAB_POOL_STATE_DISCRIMINATOR, LAUNCHLAB_POOL_STATE_HEAD_SIZE, LAUNCHLAB_SEEDS, LAUNCHLAB_SELL_EXACT_IN, LAUNCHLAB_STATUS_FUND, LAUNCHLAB_STATUS_MIGRATE, LAUNCHLAB_STATUS_TRADE, LAUNCH_DECIMALS, LAUNCH_SUPPLY, LAUNCH_TOTAL_BASE_SELL, LaunchInput, LaunchParams, LaunchlabGlobalConfig, LaunchlabPlatformConfig, LaunchlabPoolState, LaunchlabTradeAccountsInput, METADATA_LIMITS, METADATA_SEED, METAPLEX_PROGRAM_ADDRESS, MIGRATE_TO_CPMM, MaybeAccount$1 as MaybeAccount, MigratedCpmmPool, PLATFORM_ADMIN, QuoteAsset, QuoteBinding, QuoteConfig, QuoteDisplay, RATE_DENOMINATOR, RAYDIUM_DEVNET_IDS, RAYDIUM_IDS, RAYDIUM_MAINNET_IDS, RENT_SYSVAR_ADDRESS, RaydiumClusterIds, RaydiumIds, ResolveVenueOptions, ResolvedVenue, SHARE_FEE_RATE, SYSTEM_PROGRAM_ADDRESS, TOKEN_2022_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS, VenueAccountSpec, VenueInstructionAbi, VenueKind, WSOL_MINT, ata, ceilDiv, ceilDivRate, claimCreatorFee, collectCreatorFee, compareAddresses, cpmmAuthority, cpmmBuyAccounts, cpmmCreatorFeeShare, cpmmPoolAddress, cpmmPoolMatches, cpmmSellAccounts, cpmmSwapBaseInput, cpmmSwapBaseOutput, creatorFeeOnInput, creatorFeeVaultAddress, creatorFeeVaultAuthority, curveBuyExactIn, curveBuyExactOut, curveQuote, curveSellExactIn, decodeBase64, decodeCpmmAmmConfig, decodeCpmmPool, decodeLaunchlabGlobalConfig, decodeLaunchlabPlatformConfig, decodeLaunchlabPool, fetchCreatorFees, fetchCurveSettings, fetchQuoteAsset, fetchQuoteBinding, fetchQuoteConfig, fetchQuoteDisplay, findCpmmPool, getClaimCreatorFeeInstructions, getCollectCreatorFeeInstructions, getCurveBuyExactInInstruction, getLaunchInstruction, initialCurve, isQuoteSupported, launchlabAuthority, launchlabBuyAccounts, launchlabBuyExactInAccounts, launchlabEventAuthority, launchlabGlobalConfig, launchlabPlatformConfig, launchlabPoolAddress, launchlabSellAccounts, launchlabVaultAddress, metadataAddress, metaplexSymbol, mintDecimals, newCurveBuyCost, newCurveReserves, order, platformFeeVaultAddress, preFeeAmount, quoteAccountFor, raydiumIds, readAccounts, remainingBase, resolveVenue, sellQuote, sortedMints, token2022Symbol, tokenAccountAmount, tokenAccountOwnerAndMint, totalCurveFeeRate, wsolAccountFor };
+  export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, CONSTANT_CURVE_TAG, CPMM_AMM_CONFIG_DISCRIMINATOR, CPMM_AMM_CONFIG_HEAD_SIZE, CPMM_COLLECT_CREATOR_FEE, CPMM_POOL_OFFSETS, CPMM_POOL_STATE_DISCRIMINATOR, CPMM_POOL_STATE_HEAD_SIZE, CPMM_POOL_STATE_SIZE, CPMM_SEEDS, CPMM_SWAP_BASE_INPUT, CPMM_SWAP_BASE_OUTPUT, CREATOR_FEE_ON_QUOTE, ClaimCreatorFeeInput, ClaimPlatformFeeInput, CollectCreatorFeeInput, CpmmAmmConfig, CpmmFeeRates, CpmmPoolState, CpmmSwapSides, CpmmTradeAccountsInput, CreatorFees, CurveBuyExactInInput, CurveFeeRates, CurveReserves, CurveSettings, FindCpmmPoolOptions, HarvestLockedFeesInput, LAUNCHLAB_BUY_EXACT_IN, LAUNCHLAB_BUY_EXACT_OUT, LAUNCHLAB_CLAIM_CREATOR_FEE, LAUNCHLAB_CLAIM_PLATFORM_FEE_FROM_VAULT, LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR, LAUNCHLAB_GLOBAL_CONFIG_HEAD_SIZE, LAUNCHLAB_INITIALIZE, LAUNCHLAB_PLATFORM_CONFIG_DISCRIMINATOR, LAUNCHLAB_PLATFORM_CONFIG_HEAD_SIZE, LAUNCHLAB_POOL_STATE_DISCRIMINATOR, LAUNCHLAB_POOL_STATE_HEAD_SIZE, LAUNCHLAB_SEEDS, LAUNCHLAB_SELL_EXACT_IN, LAUNCHLAB_STATUS_FUND, LAUNCHLAB_STATUS_MIGRATE, LAUNCHLAB_STATUS_TRADE, LAUNCH_DECIMALS, LAUNCH_SUPPLY, LAUNCH_TOTAL_BASE_SELL, LOCKED_CP_LIQUIDITY_DISCRIMINATOR, LOCKED_CP_LIQUIDITY_HEAD_SIZE, LOCK_COLLECT_CP_FEES, LOCK_SEEDS, LaunchInput, LaunchParams, LaunchlabGlobalConfig, LaunchlabPlatformConfig, LaunchlabPoolState, LaunchlabTradeAccountsInput, LockIds, LockedCpLiquidity, LockedPosition, MEMO_PROGRAM_ADDRESS, METADATA_LIMITS, METADATA_SEED, METAPLEX_PROGRAM_ADDRESS, MIGRATE_TO_CPMM, MaybeAccount$1 as MaybeAccount, MigratedCpmmPool, PLATFORM_ADMIN, QuoteAsset, QuoteBinding, QuoteConfig, QuoteDisplay, RATE_DENOMINATOR, RAYDIUM_DEVNET_IDS, RAYDIUM_IDS, RAYDIUM_MAINNET_IDS, RENT_SYSVAR_ADDRESS, RaydiumClusterIds, RaydiumIds, ResolveVenueOptions, ResolvedVenue, SHARE_FEE_RATE, SYSTEM_PROGRAM_ADDRESS, TOKEN_2022_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS, VenueAccountSpec, VenueInstructionAbi, VenueKind, WSOL_MINT, ata, ceilDiv, ceilDivRate, claimCreatorFee, claimPlatformFee, collectCreatorFee, compareAddresses, cpmmAuthority, cpmmBuyAccounts, cpmmCreatorFeeShare, cpmmPoolAddress, cpmmPoolMatches, cpmmSellAccounts, cpmmSwapBaseInput, cpmmSwapBaseOutput, creatorFeeOnInput, creatorFeeVaultAddress, creatorFeeVaultAuthority, curveBuyExactIn, curveBuyExactOut, curveQuote, curveSellExactIn, decodeBase64, decodeCpmmAmmConfig, decodeCpmmPool, decodeLaunchlabGlobalConfig, decodeLaunchlabPlatformConfig, decodeLaunchlabPool, decodeLockedCpLiquidity, fetchCreatorFees, fetchCurveSettings, fetchLockedPositions, fetchPlatformFees, fetchQuoteAsset, fetchQuoteBinding, fetchQuoteConfig, fetchQuoteDisplay, findCpmmPool, getClaimCreatorFeeInstructions, getClaimPlatformFeeInstructions, getCollectCreatorFeeInstructions, getCurveBuyExactInInstruction, getHarvestLockedFeesInstructions, getLaunchInstruction, harvestLockedFees, initialCurve, isQuoteSupported, launchlabAuthority, launchlabBuyAccounts, launchlabBuyExactInAccounts, launchlabEventAuthority, launchlabGlobalConfig, launchlabPlatformConfig, launchlabPoolAddress, launchlabSellAccounts, launchlabVaultAddress, lockAuthority, lockedFeeLp, lockedLiquidityAddress, metadataAddress, metaplexSymbol, mintDecimals, newCurveBuyCost, newCurveReserves, order, platformFeeVaultAddress, platformFeeVaultAuthority, preFeeAmount, quoteAccountFor, raydiumIds, readAccounts, remainingBase, resolveVenue, sellQuote, sortedMints, token2022Symbol, tokenAccountAmount, tokenAccountOwnerAndMint, totalCurveFeeRate, wsolAccountFor };
 }
 //#endregion
-export { QuoteBinding as $, assertClusterUrl as $n, CONSTANT_CURVE_TAG as $t, ClaimCreatorFeeInput as A, LAUNCHLAB_SELL_EXACT_IN as An, totalCurveFeeRate as At, cpmmBuyAccounts as B, TOKEN_2022_PROGRAM_ADDRESS as Bn, LaunchlabGlobalConfig as Bt, launchlabPlatformConfig as C, LAUNCHLAB_BUY_EXACT_IN as Cn, cpmmSwapBaseOutput as Ct, platformFeeVaultAddress as D, LAUNCHLAB_INITIALIZE as Dn, initialCurve as Dt, metadataAddress as E, LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR as En, curveSellExactIn as Et, fetchCreatorFees as F, RAYDIUM_DEVNET_IDS as Fn, CpmmAmmConfig as Ft, order as G, CLUSTER_ENDPOINTS as Gn, decodeLaunchlabGlobalConfig as Gt, launchlabBuyAccounts as H, VenueAccountSpec as Hn, LaunchlabPoolState as Ht, getClaimCreatorFeeInstructions as I, RAYDIUM_MAINNET_IDS as In, CpmmPoolState as It, buildMessage as J, DEVNET_HTTP as Jn, metaplexSymbol as Jt, BuildOptions as K, ClientConfig as Kn, decodeLaunchlabPlatformConfig as Kt, getCollectCreatorFeeInstructions as L, RENT_SYSVAR_ADDRESS as Ln, LAUNCHLAB_GLOBAL_CONFIG_HEAD_SIZE as Lt, CreatorFees as M, LAUNCH_TOTAL_BASE_SELL as Mn, CPMM_POOL_OFFSETS as Mt, claimCreatorFee as N, METAPLEX_PROGRAM_ADDRESS as Nn, CPMM_POOL_STATE_HEAD_SIZE as Nt, LaunchInput as O, LAUNCHLAB_PLATFORM_CONFIG_DISCRIMINATOR as On, preFeeAmount as Ot, collectCreatorFee as P, PLATFORM_ADMIN as Pn, CPMM_POOL_STATE_SIZE as Pt, MigratedCpmmPool as Q, GaboxRpcSubscriptions as Qn, tokenAccountOwnerAndMint as Qt, CpmmTradeAccountsInput as R, RaydiumClusterIds as Rn, LAUNCHLAB_PLATFORM_CONFIG_HEAD_SIZE as Rt, launchlabGlobalConfig as S, CPMM_SWAP_BASE_OUTPUT as Sn, cpmmSwapBaseInput as St, launchlabVaultAddress as T, LAUNCHLAB_CLAIM_CREATOR_FEE as Tn, curveBuyExactOut as Tt, launchlabBuyExactInAccounts as U, VenueInstructionAbi as Un, decodeCpmmAmmConfig as Ut, cpmmSellAccounts as V, TOKEN_PROGRAM_ADDRESS as Vn, LaunchlabPlatformConfig as Vt, launchlabSellAccounts as W, WSOL_MINT as Wn, decodeCpmmPool as Wt, CurveSettings as X, GaboxClient as Xn, token2022Symbol as Xt, withRemainingAccounts as Y, DEVNET_WS as Yn, mintDecimals as Yt, FindCpmmPoolOptions as Z, GaboxRpc as Zn, tokenAccountAmount as Zt, cpmmPoolAddress as _, ASSOCIATED_TOKEN_PROGRAM_ADDRESS as _n, CurveFeeRates as _t, decodeBase64 as a, LAUNCHLAB_STATUS_TRADE as an, RouteMode as ar, curveQuote as at, launchlabAuthority as b, CPMM_POOL_STATE_DISCRIMINATOR as bn, ceilDiv as bt, QuoteConfig as c, METADATA_SEED as cn, findCpmmPool as ct, fetchQuoteConfig as d, RAYDIUM_IDS as dn, quoteAccountFor as dt, CPMM_SEEDS as en, clusterNamedBy as er, ResolveVenueOptions as et, fetchQuoteDisplay as f, RaydiumIds as fn, resolveVenue as ft, cpmmCreatorFeeShare as g, sortedMints as gn, CpmmSwapSides as gt, cpmmAuthority as h, raydiumIds as hn, CpmmFeeRates as ht, MaybeAccount$1 as i, LAUNCHLAB_STATUS_MIGRATE as in, Route as ir, creatorFeeOnInput as it, CollectCreatorFeeInput as j, LAUNCH_SUPPLY as jn, CPMM_AMM_CONFIG_HEAD_SIZE as jt, getLaunchInstruction as k, LAUNCHLAB_POOL_STATE_DISCRIMINATOR as kn, remainingBase as kt, QuoteDisplay as l, MIGRATE_TO_CPMM as ln, newCurveBuyCost as lt, ata as m, compareAddresses as mn, wsolAccountFor as mt, CurveBuyExactInInput as n, LAUNCHLAB_SEEDS as nn, defaultRoute as nr, VenueKind as nt, readAccounts as o, LAUNCH_DECIMALS as on, RouteProvider as or, fetchCurveSettings as ot, isQuoteSupported as p, SHARE_FEE_RATE as pn, sellQuote as pt, GaboxTransactionMessage as q, Cluster as qn, decodeLaunchlabPool as qt, getCurveBuyExactInInstruction as r, LAUNCHLAB_STATUS_FUND as rn, websocketUrlFor as rr, cpmmPoolMatches as rt, QuoteAsset as s, METADATA_LIMITS as sn, fetchQuoteBinding as st, index_d_exports as t, CREATOR_FEE_ON_QUOTE as tn, createClient as tr, ResolvedVenue as tt, fetchQuoteAsset as u, RATE_DENOMINATOR as un, newCurveReserves as ut, creatorFeeVaultAddress as v, CPMM_AMM_CONFIG_DISCRIMINATOR as vn, CurveReserves as vt, launchlabPoolAddress as w, LAUNCHLAB_BUY_EXACT_OUT as wn, curveBuyExactIn as wt, launchlabEventAuthority as x, CPMM_SWAP_BASE_INPUT as xn, ceilDivRate as xt, creatorFeeVaultAuthority as y, CPMM_COLLECT_CREATOR_FEE as yn, LaunchParams as yt, LaunchlabTradeAccountsInput as z, SYSTEM_PROGRAM_ADDRESS as zn, LAUNCHLAB_POOL_STATE_HEAD_SIZE as zt };
-//# sourceMappingURL=index-C4at2cZ_.d.ts.map
+export { LaunchlabTradeAccountsInput as $, LAUNCH_SUPPLY as $n, LAUNCHLAB_POOL_STATE_HEAD_SIZE as $t, creatorFeeVaultAuthority as A, MIGRATE_TO_CPMM as An, CpmmSwapSides as At, platformFeeVaultAddress as B, CPMM_COLLECT_CREATOR_FEE as Bn, curveSellExactIn as Bt, harvestLockedFees as C, LAUNCHLAB_STATUS_TRADE as Cn, createClient as Cr, newCurveBuyCost as Ct, cpmmCreatorFeeShare as D, MEMO_PROGRAM_ADDRESS as Dn, RouteMode as Dr, sellQuote as Dt, cpmmAuthority as E, LockIds as En, Route as Er, resolveVenue as Et, launchlabPoolAddress as F, compareAddresses as Fn, ceilDivRate as Ft, CollectCreatorFeeInput as G, LAUNCHLAB_BUY_EXACT_OUT as Gn, CPMM_AMM_CONFIG_HEAD_SIZE as Gt, LaunchInput as H, CPMM_SWAP_BASE_INPUT as Hn, preFeeAmount as Ht, launchlabVaultAddress as I, raydiumIds as In, cpmmSwapBaseInput as It, collectCreatorFee as J, LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR as Jn, CPMM_POOL_STATE_SIZE as Jt, CreatorFees as K, LAUNCHLAB_CLAIM_CREATOR_FEE as Kn, CPMM_POOL_OFFSETS as Kt, lockAuthority as L, sortedMints as Ln, cpmmSwapBaseOutput as Lt, launchlabEventAuthority as M, RAYDIUM_IDS as Mn, CurveReserves as Mt, launchlabGlobalConfig as N, RaydiumIds as Nn, LaunchParams as Nt, cpmmPoolAddress as O, METADATA_LIMITS as On, RouteProvider as Or, wsolAccountFor as Ot, launchlabPlatformConfig as P, SHARE_FEE_RATE as Pn, ceilDiv as Pt, CpmmTradeAccountsInput as Q, LAUNCHLAB_SELL_EXACT_IN as Qn, LAUNCHLAB_PLATFORM_CONFIG_HEAD_SIZE as Qt, lockedLiquidityAddress as R, ASSOCIATED_TOKEN_PROGRAM_ADDRESS as Rn, curveBuyExactIn as Rt, getHarvestLockedFeesInstructions as S, LAUNCHLAB_STATUS_MIGRATE as Sn, clusterNamedBy as Sr, findCpmmPool as St, ata as T, LOCK_SEEDS as Tn, websocketUrlFor as Tr, quoteAccountFor as Tt, getLaunchInstruction as U, CPMM_SWAP_BASE_OUTPUT as Un, remainingBase as Ut, platformFeeVaultAuthority as V, CPMM_POOL_STATE_DISCRIMINATOR as Vn, initialCurve as Vt, ClaimCreatorFeeInput as W, LAUNCHLAB_BUY_EXACT_IN as Wn, totalCurveFeeRate as Wt, getClaimCreatorFeeInstructions as X, LAUNCHLAB_PLATFORM_CONFIG_DISCRIMINATOR as Xn, CpmmPoolState as Xt, fetchCreatorFees as Y, LAUNCHLAB_INITIALIZE as Yn, CpmmAmmConfig as Yt, getCollectCreatorFeeInstructions as Z, LAUNCHLAB_POOL_STATE_DISCRIMINATOR as Zn, LAUNCHLAB_GLOBAL_CONFIG_HEAD_SIZE as Zt, LockedPosition as _, CONSTANT_CURVE_TAG as _n, DEVNET_WS as _r, cpmmPoolMatches as _t, decodeBase64 as a, LockedCpLiquidity as an, RENT_SYSVAR_ADDRESS as ar, order as at, fetchPlatformFees as b, LAUNCHLAB_SEEDS as bn, GaboxRpcSubscriptions as br, fetchCurveSettings as bt, QuoteConfig as c, decodeLaunchlabGlobalConfig as cn, TOKEN_2022_PROGRAM_ADDRESS as cr, buildMessage as ct, fetchQuoteConfig as d, decodeLockedCpLiquidity as dn, VenueInstructionAbi as dr, FindCpmmPoolOptions as dt, LOCKED_CP_LIQUIDITY_DISCRIMINATOR as en, LAUNCH_TOTAL_BASE_SELL as er, cpmmBuyAccounts as et, fetchQuoteDisplay as f, metaplexSymbol as fn, WSOL_MINT as fr, MigratedCpmmPool as ft, LOCK_COLLECT_CP_FEES as g, tokenAccountOwnerAndMint as gn, DEVNET_HTTP as gr, VenueKind as gt, HarvestLockedFeesInput as h, tokenAccountAmount as hn, Cluster as hr, ResolvedVenue as ht, MaybeAccount$1 as i, LaunchlabPoolState as in, RAYDIUM_MAINNET_IDS as ir, launchlabSellAccounts as it, launchlabAuthority as j, RATE_DENOMINATOR as jn, CurveFeeRates as jt, creatorFeeVaultAddress as k, METADATA_SEED as kn, CpmmFeeRates as kt, QuoteDisplay as l, decodeLaunchlabPlatformConfig as ln, TOKEN_PROGRAM_ADDRESS as lr, withRemainingAccounts as lt, ClaimPlatformFeeInput as m, token2022Symbol as mn, ClientConfig as mr, ResolveVenueOptions as mt, CurveBuyExactInInput as n, LaunchlabGlobalConfig as nn, PLATFORM_ADMIN as nr, launchlabBuyAccounts as nt, readAccounts as o, decodeCpmmAmmConfig as on, RaydiumClusterIds as or, BuildOptions as ot, isQuoteSupported as p, mintDecimals as pn, CLUSTER_ENDPOINTS as pr, QuoteBinding as pt, claimCreatorFee as q, LAUNCHLAB_CLAIM_PLATFORM_FEE_FROM_VAULT as qn, CPMM_POOL_STATE_HEAD_SIZE as qt, getCurveBuyExactInInstruction as r, LaunchlabPlatformConfig as rn, RAYDIUM_DEVNET_IDS as rr, launchlabBuyExactInAccounts as rt, QuoteAsset as s, decodeCpmmPool as sn, SYSTEM_PROGRAM_ADDRESS as sr, GaboxTransactionMessage as st, index_d_exports as t, LOCKED_CP_LIQUIDITY_HEAD_SIZE as tn, METAPLEX_PROGRAM_ADDRESS as tr, cpmmSellAccounts as tt, fetchQuoteAsset as u, decodeLaunchlabPool as un, VenueAccountSpec as ur, CurveSettings as ut, claimPlatformFee as v, CPMM_SEEDS as vn, GaboxClient as vr, creatorFeeOnInput as vt, lockedFeeLp as w, LAUNCH_DECIMALS as wn, defaultRoute as wr, newCurveReserves as wt, getClaimPlatformFeeInstructions as x, LAUNCHLAB_STATUS_FUND as xn, assertClusterUrl as xr, fetchQuoteBinding as xt, fetchLockedPositions as y, CREATOR_FEE_ON_QUOTE as yn, GaboxRpc as yr, curveQuote as yt, metadataAddress as z, CPMM_AMM_CONFIG_DISCRIMINATOR as zn, curveBuyExactOut as zt };
+//# sourceMappingURL=index-CQcBMEah.d.ts.map

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { DRAW_DISCRIMINATOR, Draw, DrawResolvedEvent, POOL_DISCRIMINATOR, PackBoughtEvent, Pool, PoolCreatedEvent, PrizesFundedEvent, RandomnessRetriedEvent, TokensSoldEvent, WALLET_ACTIVITY_DISCRIMINATOR, WalletActivity, decodeDraw, decodePool, decodeWalletActivity, findActivityPda, findDrawPda, findIdentityPda, findPoolPda, t as index_d_exports } from "./generated/index.js";
-import { $n as assertClusterUrl, Gn as CLUSTER_ENDPOINTS, J as buildMessage, Jn as DEVNET_HTTP, K as BuildOptions, Kn as ClientConfig, Nn as METAPLEX_PROGRAM_ADDRESS, Pn as PLATFORM_ADMIN, Qn as GaboxRpcSubscriptions, Vn as TOKEN_PROGRAM_ADDRESS, Wn as WSOL_MINT, Xn as GaboxClient, Y as withRemainingAccounts, Yn as DEVNET_WS, Zn as GaboxRpc, _n as ASSOCIATED_TOKEN_PROGRAM_ADDRESS, ar as RouteMode, er as clusterNamedBy, ir as Route, nr as defaultRoute, nt as VenueKind, on as LAUNCH_DECIMALS, or as RouteProvider, q as GaboxTransactionMessage, qn as Cluster, rr as websocketUrlFor, t as index_d_exports$1, tr as createClient, tt as ResolvedVenue, zn as SYSTEM_PROGRAM_ADDRESS } from "./index-C4at2cZ_.js";
+import { Cr as createClient, Dr as RouteMode, Er as Route, Or as RouteProvider, Rn as ASSOCIATED_TOKEN_PROGRAM_ADDRESS, Sr as clusterNamedBy, Tr as websocketUrlFor, _r as DEVNET_WS, br as GaboxRpcSubscriptions, ct as buildMessage, fr as WSOL_MINT, gr as DEVNET_HTTP, gt as VenueKind, hr as Cluster, ht as ResolvedVenue, lr as TOKEN_PROGRAM_ADDRESS, lt as withRemainingAccounts, mr as ClientConfig, nr as PLATFORM_ADMIN, ot as BuildOptions, pr as CLUSTER_ENDPOINTS, sr as SYSTEM_PROGRAM_ADDRESS, st as GaboxTransactionMessage, t as index_d_exports$1, tr as METAPLEX_PROGRAM_ADDRESS, vr as GaboxClient, wn as LAUNCH_DECIMALS, wr as defaultRoute, xr as assertClusterUrl, yr as GaboxRpc } from "./index-CQcBMEah.js";
 import { Address, AddressesByLookupTableAddress, Instruction, InstructionWithData, ProgramDerivedAddress, ReadonlyUint8Array, TransactionSigner } from "@solana/kit";
 //#region src/math.d.ts
 /**
@@ -209,6 +209,15 @@ export declare const REDEEM_COMPUTE_UNITS = 125000;
  * on a pool quoted in another token is cheaper, `17,635`, because nothing has to be unwrapped.
  */
 export declare const CLAIM_COMPUTE_UNITS = 55000;
+/**
+ * A harvest of one locked CPMM position: `collect_cp_fees` on the lock program, which withdraws
+ * LP through CPMM and pays both sides out.
+ *
+ * Measured at `102,221` on devnet on 2026-09-19 (tx `5s7xvy23…`), with both token accounts
+ * created in the same transaction and the WSOL one closed again. `82,697` of that is the lock
+ * program itself.
+ */
+export declare const HARVEST_COMPUTE_UNITS = 150000;
 /** An instruction for the compute budget program: no accounts, all of it in the data. */
 export type ComputeBudgetInstruction = Instruction<string, readonly []> & InstructionWithData<ReadonlyUint8Array>;
 export declare function getSetComputeUnitLimitInstruction(units: number): ComputeBudgetInstruction;
@@ -594,6 +603,17 @@ export type QuoteLeg = {
 export type GaboxAccounts = readonly Address[];
 /** Create the wallet's quote account if it is missing. Idempotent, so a second create is free. */
 export declare function createQuoteAccount(owner: TransactionSigner, venue: Pick<ResolvedVenue, 'quoteMint' | 'quoteTokenProgram' | 'userQuoteToken'>): Instruction;
+/**
+ * The leg for a wallet that already holds what it is about to spend. No swap.
+ *
+ * A WSOL pool is the one case where "already holds it" means lamports, so those are wrapped and the
+ * account is closed again afterwards. Any other quote only needs its account to exist; closing it
+ * would throw away a real balance.
+ *
+ * `createMachine` uses this and nothing else: the seed is always the creator's own money, in the
+ * machine's quote token.
+ */
+export declare function quoteLegFromWallet(venue: Pick<ResolvedVenue, 'quoteMint' | 'quoteTokenProgram' | 'userQuoteToken'>, payer: TransactionSigner, maxQuoteIn: bigint): Promise<QuoteLeg>;
 /**
  * The leg that puts `maxQuoteIn` of the quote token in the buyer's quote account.
  *
@@ -698,15 +718,9 @@ export type CreateMachineInput = {
    */
   raise?: bigint;
   /**
-   * Pay for the seed in SOL through a swap, or in the quote token the creator already holds.
-   * Defaults to `'sol'`. A WSOL pool ignores it: its quote token is SOL.
-   */
-  payWith?: PayWith;
-  /**
-   * Seed slippage cap in the quote token, for `mandatory + extraSeedTokens` together. The
-   * transaction puts this much of the quote token in the creator's quote account before the buy, so
-   * it must cover the real cost. Anything left over stays there, or comes back as SOL on a WSOL
-   * pool.
+   * Seed slippage cap in the quote token, for `mandatory + extraSeedTokens` together. The creator
+   * must already hold this much of the quote token, so it has to cover the real cost. Anything left
+   * over stays in their quote account, or comes back as SOL on a WSOL pool.
    */
   maxSeedQuoteIn: bigint;
   /**
@@ -747,8 +761,11 @@ export type SeedCostEstimate = {
   /** `total_quote_fund_raising` the launch would use, in the quote's base units. */
   raise: bigint;
   /**
-   * What `quoteAmount` costs in SOL through the client's route provider, or `null` when there is
-   * no provider or no route. Equal to `quoteAmount` on a WSOL pool.
+   * What `quoteAmount` is worth in SOL through the client's route provider, or `null` when there is
+   * no provider or no route. Equal to `quoteAmount` on a WSOL machine.
+   *
+   * A display only. The creator pays the seed in the quote token, not in SOL, so this says what
+   * that costs them in familiar money; it is not an amount any instruction spends.
    */
   solAmount: bigint | null;
 };
@@ -760,9 +777,9 @@ export type SeedCostEstimate = {
  * same transaction, so this is exact up to a change in Raydium's fee rates between the read and the
  * send.
  *
- * `solAmount` is the same cost in SOL, priced through the client's route provider. It is `null`
- * when the client has no provider, or when no route exists: a devnet client has none unless the
- * caller passes `raydiumCpmmRoute(pool)`.
+ * `solAmount` is what that cost is worth in SOL, priced through the client's route provider. It is
+ * a display: the creator pays in the quote token. It is `null` when the client has no provider, or
+ * when no route exists: a devnet client has none unless the caller passes `raydiumCpmmRoute(pool)`.
  *
  * Defaults to `DEFAULT_TIERS`, wrapped SOL and no extra seed. Throws if `tiers` fails
  * `validateTiers`/`validatePack`, if `extraSeedTokens` is negative, if the total seed is bigger