@gabox-labs/sdk 0.1.1

package/dist/pump-D0K_0uiC.js

@@ -0,0 +1,1531 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { t as GABOX_V2_PROGRAM_ADDRESS } from "./gaboxV2-CV2XltqC.js";
+import { AccountRole, addEncoderSizePrefix, address, getAddressEncoder, getBase64Encoder, getBooleanEncoder, getStructEncoder, getU32Encoder, getU64Decoder, getU64Encoder, getUtf8Encoder } from "@solana/kit";
+import { GLOBAL_PDA, GLOBAL_VOLUME_ACCUMULATOR_PDA, PUMP_EVENT_AUTHORITY_PDA, PUMP_FEE_CONFIG_PDA, PUMP_SDK, bondingCurvePda, creatorVaultPda, feeSharingConfigPda, getBuySolAmountFromTokenAmount, getGlobalParamsPda, getMayhemStatePda, getSellSolAmountFromTokenAmount, getSolVaultPda, getTokenVaultPda, userVolumeAccumulatorPda } from "@pump-fun/pump-sdk";
+import { GLOBAL_CONFIG_PDA, GLOBAL_VOLUME_ACCUMULATOR_PDA as GLOBAL_VOLUME_ACCUMULATOR_PDA$1, PUMP_AMM_EVENT_AUTHORITY_PDA, PUMP_AMM_FEE_CONFIG_PDA, PUMP_AMM_SDK, buyBaseInput, canonicalPumpPoolPda, coinCreatorVaultAtaPda, coinCreatorVaultAuthorityPda, sellBaseInput, userVolumeAccumulatorPda as userVolumeAccumulatorPda$1 } from "@pump-fun/pump-swap-sdk";
+import { getAssociatedTokenAddressSync, unpackMint } from "@solana/spl-token";
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import { Buffer } from "buffer";
+//#region src/pump/abi.ts
+/**
+* Program addresses, taken from the two IDLs rather than typed here. `fee_program` and
+* `mayhem_program_id` are `address` constraints on accounts, so the IDL states them exactly.
+*/
+const PUMP_PROGRAM_ADDRESS = "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P";
+const PUMP_SWAP_PROGRAM_ADDRESS = "pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA";
+const PUMP_FEE_PROGRAM_ADDRESS = "pfeeUxB6jkeY1Hxd7CsFCAjcbHA9rWtchMGdZ6VojVZ";
+const MAYHEM_PROGRAM_ADDRESS = "MAyhSmzXzV1pTf7LsNkrNwkWKTo4ougAJ1PPg47MD4e";
+/** Pump `create_v2` always mints Token-2022. The IDL pins the program on the account. */
+const PUMP_CREATE_TOKEN_PROGRAM_ADDRESS = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
+const ASSOCIATED_TOKEN_PROGRAM_ADDRESS = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+const SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
+/** `create_v2` on `6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P` — not in interfaces.json (create only, the program reads two slots of it). */
+const PUMP_CREATE_V2 = {
+	name: "create_v2",
+	discriminator: new Uint8Array([
+		214,
+		144,
+		76,
+		236,
+		95,
+		139,
+		49,
+		180
+	]),
+	accounts: [
+		{
+			name: "mint",
+			writable: true,
+			signer: true
+		},
+		{
+			name: "mint_authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "bonding_curve",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "associated_bonding_curve",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "global",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "user",
+			writable: true,
+			signer: true
+		},
+		{
+			name: "system_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "associated_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "mayhem_program_id",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "global_params",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "sol_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "mayhem_state",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "mayhem_token_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "event_authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "program",
+			writable: false,
+			signer: false
+		}
+	]
+};
+/** `buy_v2` on `6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P` — cross-checked against interfaces.json. */
+const PUMP_BUY = {
+	name: "buy_v2",
+	discriminator: new Uint8Array([
+		184,
+		23,
+		238,
+		97,
+		103,
+		197,
+		211,
+		61
+	]),
+	accounts: [
+		{
+			name: "global",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "base_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "quote_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "base_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "quote_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "associated_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "fee_recipient",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "associated_quote_fee_recipient",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "buyback_fee_recipient",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "associated_quote_buyback_fee_recipient",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "bonding_curve",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "associated_base_bonding_curve",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "associated_quote_bonding_curve",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "user",
+			writable: true,
+			signer: true
+		},
+		{
+			name: "associated_base_user",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "associated_quote_user",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "creator_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "associated_creator_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "sharing_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "global_volume_accumulator",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "user_volume_accumulator",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "associated_user_volume_accumulator",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "fee_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "fee_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "system_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "event_authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "program",
+			writable: false,
+			signer: false
+		}
+	]
+};
+/** `sell_v2` on `6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P` — cross-checked against interfaces.json. */
+const PUMP_SELL = {
+	name: "sell_v2",
+	discriminator: new Uint8Array([
+		93,
+		246,
+		130,
+		60,
+		231,
+		233,
+		64,
+		178
+	]),
+	accounts: [
+		{
+			name: "global",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "base_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "quote_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "base_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "quote_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "associated_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "fee_recipient",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "associated_quote_fee_recipient",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "buyback_fee_recipient",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "associated_quote_buyback_fee_recipient",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "bonding_curve",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "associated_base_bonding_curve",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "associated_quote_bonding_curve",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "user",
+			writable: true,
+			signer: true
+		},
+		{
+			name: "associated_base_user",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "associated_quote_user",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "creator_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "associated_creator_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "sharing_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "user_volume_accumulator",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "associated_user_volume_accumulator",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "fee_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "fee_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "system_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "event_authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "program",
+			writable: false,
+			signer: false
+		}
+	]
+};
+/** `buy` on `pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA` — cross-checked against interfaces.json. */
+const SWAP_BUY = {
+	name: "buy",
+	discriminator: new Uint8Array([
+		102,
+		6,
+		61,
+		18,
+		1,
+		218,
+		235,
+		234
+	]),
+	accounts: [
+		{
+			name: "pool",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "user",
+			writable: true,
+			signer: true
+		},
+		{
+			name: "global_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "base_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "quote_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "user_base_token_account",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "user_quote_token_account",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "pool_base_token_account",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "pool_quote_token_account",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "protocol_fee_recipient",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "protocol_fee_recipient_token_account",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "base_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "quote_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "system_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "associated_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "event_authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "coin_creator_vault_ata",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "coin_creator_vault_authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "global_volume_accumulator",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "user_volume_accumulator",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "fee_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "fee_program",
+			writable: false,
+			signer: false
+		}
+	]
+};
+/** `sell` on `pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA` — cross-checked against interfaces.json. */
+const SWAP_SELL = {
+	name: "sell",
+	discriminator: new Uint8Array([
+		51,
+		230,
+		133,
+		164,
+		1,
+		127,
+		131,
+		173
+	]),
+	accounts: [
+		{
+			name: "pool",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "user",
+			writable: true,
+			signer: true
+		},
+		{
+			name: "global_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "base_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "quote_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "user_base_token_account",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "user_quote_token_account",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "pool_base_token_account",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "pool_quote_token_account",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "protocol_fee_recipient",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "protocol_fee_recipient_token_account",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "base_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "quote_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "system_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "associated_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "event_authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "coin_creator_vault_ata",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "coin_creator_vault_authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "fee_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "fee_program",
+			writable: false,
+			signer: false
+		}
+	]
+};
+//#endregion
+//#region src/ids.ts
+/** `declare_id!` in `programs/gabox-v2/src/lib.rs`. */
+const GABOX_PROGRAM_ID = GABOX_V2_PROGRAM_ADDRESS;
+/** Classic SPL Token. The quote side of every Pump trade uses it, because the quote is WSOL. */
+const TOKEN_PROGRAM_ADDRESS = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+/**
+* Token-2022. Pump `create_v2` mints here, so every coin a machine is built on is a Token-2022
+* mint and the pool vault ATA lives under this program.
+*/
+const TOKEN_2022_PROGRAM_ADDRESS = PUMP_CREATE_TOKEN_PROGRAM_ADDRESS;
+/** Wrapped SOL. The quote mint on both venues. */
+const WSOL_MINT = "So11111111111111111111111111111111111111112";
+/** MagicBlock's ephemeral VRF program. `vrf.rs` pins it and refuses any other. */
+const VRF_PROGRAM_ADDRESS = "Vrf1RNUjXmQGjmQrQLvJHs9SNkvDJEsRVFPkfSQUwGz";
+/**
+* MagicBlock's default oracle queue. The program pins this one address, so a pool creator cannot
+* point a draw at an oracle they control.
+*/
+const VRF_DEFAULT_QUEUE = "Cuj97ggrhhidhbu39TijNVqE74xvKJ69gDervRUXAxGh";
+/** The seed of both identity PDAs. See `pdas.ts` — there are two, under different programs. */
+const IDENTITY_SEED = new Uint8Array([
+	105,
+	100,
+	101,
+	110,
+	116,
+	105,
+	116,
+	121
+]);
+const SLOT_HASHES_SYSVAR = "SysvarS1otHashes111111111111111111111111111";
+const INSTRUCTIONS_SYSVAR = "Sysvar1nstructions1111111111111111111111111";
+/** `state.rs`. A retry may not run sooner than this after the last attempt. */
+const RETRY_SLOTS = 300n;
+/** `state.rs`. After this many slots from the purchase, anyone may expire the draw. */
+const TIMEOUT_SLOTS = 216000n;
+/** `state.rs`. Three requests in total, counting the one `buy_pack` makes. */
+const MAX_ATTEMPTS = 3;
+/**
+* `state.rs`. Tokens in one pack, in base units: 1,000,000 tokens at Pump's fixed 6 decimals, or
+* 0.1% of the 1,000,000,000 supply. Every pool sells packs of this size. The venue decides what a
+* pack costs, so the pack price follows the coin. Read `pool.packTokens` rather than this when a
+* pool is at hand: a later program version may change the constant.
+*/
+const PACK_TOKENS = 1000000n * 1000000n;
+/** `state.rs`. The creator's per-pack fee, in bps of what the venue charged, may not exceed this. */
+const MAX_FEE_BPS = 100;
+/** Referral reward: 1% of the creator fee, deducted from that fee. */
+const REFERRAL_FEE_BPS = 100n;
+/** `state.rs`. The protocol's share of every pack's venue cost and of every sale's proceeds, in bps. */
+const PROTOCOL_FEE_BPS = 100n;
+/**
+* `PROTOCOL_FEE_COLLECTOR` in `state.rs`. Every pack pays 1% of its venue cost here, on top of
+* that cost. Every sale through the program pays 1% of its proceeds here: SOL on Pump, WSOL (into the
+* collector's WSOL ATA) on PumpSwap. The same key holds the program's upgrade authority.
+*
+* The generated instructions pin it as an `address` constraint, and `test/instruction-data.test.ts`
+* checks this copy against the IDL.
+*/
+const PROTOCOL_FEE_COLLECTOR = "5WcPTEQ59UqpQzjZUPbU8QRGCbj7NeQNLDa7DbsLkLKT";
+//#endregion
+//#region src/pump/adapter.ts
+/**
+* The boundary with Pump's official SDKs.
+*
+* # Why this file exists, and why it is the only one like it
+*
+* `@pump-fun/pump-sdk` and `@pump-fun/pump-swap-sdk` are the maintained clients Pump publishes.
+* They carry two things worth having and expensive to reproduce: the exact seeds of every PDA a
+* trade touches, and the fee-tier and curve math that says how many tokens a given spend buys.
+* Getting either one slightly wrong shows a buyer a price the venue will not honour.
+*
+* Both packages are built on `@solana/web3.js` v1 and `bn.js`. This SDK and the app are on
+* `@solana/kit`. So the conversion happens here and nowhere else: `PublicKey` and `BN` do not
+* appear in any other file, and nothing this module exports carries them. Addresses go out as kit
+* `Address`, amounts as `bigint`.
+*
+* Pinned versions are in `sdk/package.json` and repeated in `sdk/README.md`. They are exact, not
+* ranges: a fee-math change in a patch release changes what a buyer is shown.
+*
+* # What this file does NOT do
+*
+* It does not build instructions. Both packages build their trades around `@solana/web3.js`
+* transactions, and `market.rs` takes the venue's account list as `remaining_accounts` instead.
+* So `accounts.ts` assembles the account lists from the generated `abi.ts` table, using the
+* addresses this file derives.
+*/
+const toAddress = (key) => address(key.toBase58());
+const toPublicKey = (a) => new PublicKey(a);
+const brand = (value) => value;
+const unbrand = (value) => value;
+const toBigint = (n) => BigInt(n.toString());
+const toBn = (n) => new BN(n.toString());
+/**
+* An `AccountInfo<Buffer>` shaped just enough for the packages' decoders. They read `.data` and
+* nothing else, so the rest is filler rather than a claim about the account.
+*/
+function accountInfo(data, owner = PublicKey.default) {
+	return {
+		data: Buffer.from(data),
+		executable: false,
+		lamports: 0,
+		owner
+	};
+}
+/** `["global"]` under Pump. Holds the fee recipient lists and the curve's initial reserves. */
+const PUMP_GLOBAL = toAddress(GLOBAL_PDA);
+const PUMP_EVENT_AUTHORITY = toAddress(PUMP_EVENT_AUTHORITY_PDA);
+/** `["fee_config", pump_program_id]` under the Pump fee program. */
+const PUMP_FEE_CONFIG = toAddress(PUMP_FEE_CONFIG_PDA);
+const PUMP_GLOBAL_VOLUME_ACCUMULATOR = toAddress(GLOBAL_VOLUME_ACCUMULATOR_PDA);
+/**
+* Mayhem mode is off for every gabox coin, but `create_v2` still takes all four accounts.
+*
+* The four mayhem accounts are derived under the **mayhem** program
+* (`MAyhSmzXzV1pTf7LsNkrNwkWKTo4ougAJ1PPg47MD4e`), not under Pump. Pump's IDL states the seeds but
+* omits the program on `global_params`, `sol_vault` and `mayhem_state`, so read literally it would
+* put all three under Pump and every `create_v2` would fail. `@pump-fun/pump-sdk`'s own
+* `createV2Instruction` derives them under the mayhem program, and that is what these follow.
+* Confirmed by a successful seeded machine creation on devnet on 2026-09-10.
+*/
+const MAYHEM_GLOBAL_PARAMS = toAddress(getGlobalParamsPda());
+const MAYHEM_SOL_VAULT = toAddress(getSolVaultPda());
+const pumpBondingCurve = (mint) => toAddress(bondingCurvePda(toPublicKey(mint)));
+const pumpCreatorVault = (creator) => toAddress(creatorVaultPda(toPublicKey(creator)));
+const pumpSharingConfig = (mint) => toAddress(feeSharingConfigPda(toPublicKey(mint)));
+const pumpUserVolumeAccumulator = (user) => toAddress(userVolumeAccumulatorPda(toPublicKey(user)));
+const pumpMayhemState = (mint) => toAddress(getMayhemStatePda(toPublicKey(mint)));
+const pumpMayhemTokenVault = (mint) => toAddress(getTokenVaultPda(toPublicKey(mint)));
+/**
+* `["mint-authority"]` under Pump.
+*
+* The one address here that comes from the IDL rather than the package: `pda.ts` has no helper for
+* it. The seed is in `create_v2`'s own `pda` metadata, so it is not a guess.
+*/
+const PUMP_MINT_AUTHORITY = toAddress(PublicKey.findProgramAddressSync([Buffer.from("mint-authority")], new PublicKey("6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"))[0]);
+const AMM_GLOBAL_CONFIG = toAddress(GLOBAL_CONFIG_PDA);
+const AMM_EVENT_AUTHORITY = toAddress(PUMP_AMM_EVENT_AUTHORITY_PDA);
+const AMM_FEE_CONFIG = toAddress(PUMP_AMM_FEE_CONFIG_PDA);
+const AMM_GLOBAL_VOLUME_ACCUMULATOR = toAddress(GLOBAL_VOLUME_ACCUMULATOR_PDA$1);
+/**
+* The canonical PumpSwap pool for a graduated Pump coin: index 0, owned by the coin's
+* `["pool-authority", mint]` PDA, quoted in WSOL. A coin can have other pools; the program lets the
+* user sign whichever pool they pass, and a client should pick this one.
+*/
+const ammCanonicalPool = (mint) => toAddress(canonicalPumpPoolPda(toPublicKey(mint)));
+const ammUserVolumeAccumulator = (user) => toAddress(userVolumeAccumulatorPda$1(toPublicKey(user)));
+const ammCoinCreatorVaultAuthority = (coinCreator) => toAddress(coinCreatorVaultAuthorityPda(toPublicKey(coinCreator)));
+const ammCoinCreatorVaultAta = (vaultAuthority, quoteMint, quoteTokenProgram) => toAddress(coinCreatorVaultAtaPda(toPublicKey(vaultAuthority), toPublicKey(quoteMint), toPublicKey(quoteTokenProgram)));
+/** An ATA, off-curve owners allowed. Pool PDAs and vault authorities are all off-curve. */
+const ata = (owner, mint, tokenProgram) => toAddress(getAssociatedTokenAddressSync(toPublicKey(mint), toPublicKey(owner), true, toPublicKey(tokenProgram)));
+function decodePumpGlobal(data) {
+	const g = PUMP_SDK.decodeGlobal(accountInfo(data));
+	return {
+		feeRecipient: toAddress(g.feeRecipient),
+		feeRecipients: g.feeRecipients.map(toAddress),
+		buybackFeeRecipients: (g.buybackFeeRecipients ?? []).map(toAddress),
+		reservedFeeRecipient: toAddress(g.reservedFeeRecipient),
+		reservedFeeRecipients: (g.reservedFeeRecipients ?? []).map(toAddress),
+		createV2Enabled: g.createV2Enabled,
+		mayhemModeEnabled: g.mayhemModeEnabled,
+		isCashbackEnabled: g.isCashbackEnabled,
+		feeBasisPoints: toBigint(g.feeBasisPoints),
+		creatorFeeBasisPoints: toBigint(g.creatorFeeBasisPoints),
+		tokenTotalSupply: toBigint(g.tokenTotalSupply),
+		initialVirtualTokenReserves: toBigint(g.initialVirtualTokenReserves),
+		initialVirtualSolReserves: toBigint(g.initialVirtualSolReserves),
+		initialRealTokenReserves: toBigint(g.initialRealTokenReserves),
+		raw: brand(g)
+	};
+}
+function decodeBondingCurve(data) {
+	const c = PUMP_SDK.decodeBondingCurve(accountInfo(data));
+	return {
+		virtualTokenReserves: toBigint(c.virtualTokenReserves),
+		virtualQuoteReserves: toBigint(c.virtualQuoteReserves),
+		realTokenReserves: toBigint(c.realTokenReserves),
+		realQuoteReserves: toBigint(c.realQuoteReserves),
+		tokenTotalSupply: toBigint(c.tokenTotalSupply),
+		complete: c.complete,
+		creator: toAddress(c.creator),
+		isMayhemMode: c.isMayhemMode,
+		isCashbackCoin: c.isCashbackCoin,
+		quoteMint: toAddress(c.quoteMint),
+		raw: brand(c)
+	};
+}
+function decodePumpFeeConfig(data) {
+	return brand(PUMP_SDK.decodeFeeConfig(accountInfo(data)));
+}
+function decodeAmmPool(data) {
+	const p = PUMP_AMM_SDK.decodePool(accountInfo(data));
+	return {
+		index: p.index,
+		creator: toAddress(p.creator),
+		baseMint: toAddress(p.baseMint),
+		quoteMint: toAddress(p.quoteMint),
+		poolBaseTokenAccount: toAddress(p.poolBaseTokenAccount),
+		poolQuoteTokenAccount: toAddress(p.poolQuoteTokenAccount),
+		coinCreator: toAddress(p.coinCreator),
+		virtualQuoteReserves: toBigint(p.virtualQuoteReserves ?? new BN(0)),
+		raw: brand(p)
+	};
+}
+function decodeAmmGlobalConfig(data) {
+	const g = PUMP_AMM_SDK.decodeGlobalConfig(accountInfo(data));
+	return {
+		protocolFeeRecipients: g.protocolFeeRecipients.map(toAddress),
+		raw: brand(g)
+	};
+}
+function decodeAmmFeeConfig(data) {
+	return brand(PUMP_AMM_SDK.decodeFeeConfig(accountInfo(data)));
+}
+/** Total supply of an SPL or Token-2022 mint. The AMM fee tiers are a function of it. */
+function decodeMintSupply(data, mint, owner) {
+	const program = toPublicKey(owner);
+	return unpackMint(toPublicKey(mint), accountInfo(data, program), program).supply;
+}
+/**
+* Lamports an exact-tokens-out buy of `tokens` costs on the Pump curve, fees included.
+*
+* This is the same function the Pump front end uses. The result is the whole debit — the curve's
+* price plus the venue's protocol and creator fees — which is what `buy_v2`'s `max_sol_cost` has
+* to cover, and what `buy_pack`'s `max_quote_in` caps.
+*/
+function curveBuyCost({ global, bondingCurve, feeConfig, mintSupply, tokens, quoteMint }) {
+	return toBigint(getBuySolAmountFromTokenAmount({
+		global: unbrand(global.raw),
+		feeConfig: feeConfig === null ? null : unbrand(feeConfig),
+		mintSupply: mintSupply === null ? null : toBn(mintSupply),
+		bondingCurve: bondingCurve ? unbrand(bondingCurve.raw) : null,
+		amount: toBn(tokens),
+		quoteMint: toPublicKey(quoteMint)
+	}));
+}
+/** Lamports a curve sale of `tokens` returns, net of fees. */
+function curveSellQuote({ global, bondingCurve, feeConfig, mintSupply, tokens }) {
+	return toBigint(getSellSolAmountFromTokenAmount({
+		global: unbrand(global.raw),
+		feeConfig: feeConfig === null ? null : unbrand(feeConfig),
+		mintSupply: toBn(mintSupply),
+		bondingCurve: unbrand(bondingCurve.raw),
+		amount: toBn(tokens)
+	}));
+}
+/** WSOL a PumpSwap exact-base-out buy of `tokens` costs, LP and protocol fees included. */
+function ammBuyCost({ pool, globalConfig, feeConfig, baseReserve, quoteReserve, baseMintSupply, tokens }) {
+	const result = buyBaseInput({
+		base: toBn(tokens),
+		slippage: 0,
+		baseReserve: toBn(baseReserve),
+		quoteReserve: toBn(quoteReserve),
+		virtualQuoteReserves: toBn(pool.virtualQuoteReserves),
+		globalConfig: unbrand(globalConfig.raw),
+		baseMintAccount: { supply: baseMintSupply },
+		baseMint: toPublicKey(pool.baseMint),
+		coinCreator: toPublicKey(pool.coinCreator),
+		creator: toPublicKey(pool.creator),
+		feeConfig: feeConfig === null ? null : unbrand(feeConfig)
+	});
+	return toBigint(result.uiQuote);
+}
+/** WSOL a PumpSwap sale of `tokens` returns, net of fees. */
+function ammSellQuote({ pool, globalConfig, feeConfig, baseReserve, quoteReserve, baseMintSupply, tokens }) {
+	const result = sellBaseInput({
+		base: toBn(tokens),
+		slippage: 0,
+		baseReserve: toBn(baseReserve),
+		quoteReserve: toBn(quoteReserve),
+		virtualQuoteReserves: toBn(pool.virtualQuoteReserves),
+		globalConfig: unbrand(globalConfig.raw),
+		baseMintAccount: { supply: baseMintSupply },
+		baseMint: toPublicKey(pool.baseMint),
+		coinCreator: toPublicKey(pool.coinCreator),
+		creator: toPublicKey(pool.creator),
+		feeConfig: feeConfig === null ? null : unbrand(feeConfig)
+	});
+	return toBigint(result.uiQuote);
+}
+//#endregion
+//#region src/pump/accounts.ts
+/**
+* The ordered account list of every Pump and PumpSwap instruction this SDK builds.
+*
+* # Why these are built here and not by the official SDK
+*
+* `market.rs` accepts four trade instructions and no others: Pump's `buy_v2` and `sell_v2`,
+* PumpSwap's `buy` and `sell`. The official packages build these around `@solana/web3.js`
+* transactions, and the program wants a bare account list as `remainingAccounts`. So the lists are
+* assembled here, from `abi.ts`, which `scripts/codegen.mjs` generated from the same IDLs the
+* program's `market_abi.rs` came from.
+*
+* Every address still comes from `adapter.ts`, which means from the official packages. Nothing here
+* invents a derivation.
+*
+* # How to read the output
+*
+* Each function returns `AccountMeta[]` in ABI order, with the `role` each slot's own ABI gives it.
+* That list goes into `buy_pack` (or `initialize_pool`, or `sell_prize`) as `remainingAccounts`,
+* unchanged. `market.rs` walks it position by position: a writable slot must be writable in the
+* outer transaction, and the one signer slot must be the purchaser and must sign.
+*
+* # The three addresses that need a chain read
+*
+* `fee_recipient` and `buyback_fee_recipient` on Pump, and `protocol_fee_recipient` on PumpSwap.
+* Each is one of a list held in an on-chain account, and the venue accepts any member. `state.ts`
+* reads those accounts and passes the choice in.
+*/
+/**
+* Turn `{name -> address}` into the ABI's ordered `AccountMeta[]`.
+*
+* The map is keyed by the IDL's own account names, so a missing entry names the slot it belongs to
+* rather than failing as an off-by-one further down. The role comes from the ABI table alone —
+* never from the caller — which is what keeps this list in step with `market_abi.rs`.
+*/
+function order(abi, byName) {
+	return abi.accounts.map((spec) => {
+		const address = byName[spec.name];
+		if (address === void 0) throw new Error(`${abi.name}: no address given for the "${spec.name}" account`);
+		return {
+			address,
+			role: spec.signer ? spec.writable ? AccountRole.WRITABLE_SIGNER : AccountRole.READONLY_SIGNER : spec.writable ? AccountRole.WRITABLE : AccountRole.READONLY
+		};
+	});
+}
+/**
+* `create_v2` on Pump. The mint is a fresh keypair and signs; the user pays.
+*
+* The four mayhem accounts are always present even with mayhem mode off. `create_v2` takes them
+* unconditionally, so a client cannot skip them.
+*/
+function pumpCreateV2Accounts(input) {
+	const { mint, user, tokenProgram } = input;
+	return order(PUMP_CREATE_V2, {
+		mint,
+		mint_authority: PUMP_MINT_AUTHORITY,
+		bonding_curve: pumpBondingCurve(mint),
+		associated_bonding_curve: ata(pumpBondingCurve(mint), mint, tokenProgram),
+		global: PUMP_GLOBAL,
+		user,
+		system_program: SYSTEM_PROGRAM_ADDRESS,
+		token_program: tokenProgram,
+		associated_token_program: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+		mayhem_program_id: MAYHEM_PROGRAM_ADDRESS,
+		global_params: MAYHEM_GLOBAL_PARAMS,
+		sol_vault: MAYHEM_SOL_VAULT,
+		mayhem_state: pumpMayhemState(mint),
+		mayhem_token_vault: pumpMayhemTokenVault(mint),
+		event_authority: PUMP_EVENT_AUTHORITY,
+		program: PUMP_PROGRAM_ADDRESS
+	});
+}
+function pumpTradeAccounts(abi, input) {
+	const { mint, user, tokenProgram, creator, feeRecipient, buybackFeeRecipient, quoteMint = WSOL_MINT, quoteTokenProgram = TOKEN_PROGRAM_ADDRESS } = input;
+	const curve = pumpBondingCurve(mint);
+	const creatorVault = pumpCreatorVault(creator);
+	const volume = pumpUserVolumeAccumulator(user);
+	return order(abi, {
+		global: PUMP_GLOBAL,
+		base_mint: mint,
+		quote_mint: quoteMint,
+		base_token_program: tokenProgram,
+		quote_token_program: quoteTokenProgram,
+		associated_token_program: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+		fee_recipient: feeRecipient,
+		associated_quote_fee_recipient: ata(feeRecipient, quoteMint, quoteTokenProgram),
+		buyback_fee_recipient: buybackFeeRecipient,
+		associated_quote_buyback_fee_recipient: ata(buybackFeeRecipient, quoteMint, quoteTokenProgram),
+		bonding_curve: curve,
+		associated_base_bonding_curve: ata(curve, mint, tokenProgram),
+		associated_quote_bonding_curve: ata(curve, quoteMint, quoteTokenProgram),
+		user,
+		associated_base_user: ata(user, mint, tokenProgram),
+		associated_quote_user: ata(user, quoteMint, quoteTokenProgram),
+		creator_vault: creatorVault,
+		associated_creator_vault: ata(creatorVault, quoteMint, quoteTokenProgram),
+		sharing_config: pumpSharingConfig(mint),
+		global_volume_accumulator: PUMP_GLOBAL_VOLUME_ACCUMULATOR,
+		user_volume_accumulator: volume,
+		associated_user_volume_accumulator: ata(volume, quoteMint, quoteTokenProgram),
+		fee_config: PUMP_FEE_CONFIG,
+		fee_program: PUMP_FEE_PROGRAM_ADDRESS,
+		system_program: SYSTEM_PROGRAM_ADDRESS,
+		event_authority: PUMP_EVENT_AUTHORITY,
+		program: PUMP_PROGRAM_ADDRESS
+	});
+}
+/** `buy_v2`. The first argument is tokens to receive; the second is the most SOL to pay. */
+const pumpBuyAccounts = (input) => pumpTradeAccounts(PUMP_BUY, input);
+/** `sell_v2`. One account shorter than the buy: it has no `global_volume_accumulator`. */
+const pumpSellAccounts = (input) => pumpTradeAccounts(PUMP_SELL, input);
+function swapTradeAccounts(abi, input) {
+	const { pool, mint, user, tokenProgram, poolBaseTokenAccount, poolQuoteTokenAccount, coinCreator, protocolFeeRecipient, quoteMint = WSOL_MINT, quoteTokenProgram = TOKEN_PROGRAM_ADDRESS } = input;
+	const vaultAuthority = ammCoinCreatorVaultAuthority(coinCreator);
+	return order(abi, {
+		pool,
+		user,
+		global_config: AMM_GLOBAL_CONFIG,
+		base_mint: mint,
+		quote_mint: quoteMint,
+		user_base_token_account: ata(user, mint, tokenProgram),
+		user_quote_token_account: ata(user, quoteMint, quoteTokenProgram),
+		pool_base_token_account: poolBaseTokenAccount,
+		pool_quote_token_account: poolQuoteTokenAccount,
+		protocol_fee_recipient: protocolFeeRecipient,
+		protocol_fee_recipient_token_account: ata(protocolFeeRecipient, quoteMint, quoteTokenProgram),
+		base_token_program: tokenProgram,
+		quote_token_program: quoteTokenProgram,
+		system_program: SYSTEM_PROGRAM_ADDRESS,
+		associated_token_program: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+		event_authority: AMM_EVENT_AUTHORITY,
+		program: PUMP_SWAP_PROGRAM_ADDRESS,
+		coin_creator_vault_ata: ammCoinCreatorVaultAta(vaultAuthority, quoteMint, quoteTokenProgram),
+		coin_creator_vault_authority: vaultAuthority,
+		global_volume_accumulator: AMM_GLOBAL_VOLUME_ACCUMULATOR,
+		user_volume_accumulator: ammUserVolumeAccumulator(user),
+		fee_config: AMM_FEE_CONFIG,
+		fee_program: PUMP_FEE_PROGRAM_ADDRESS
+	});
+}
+/** `buy` on PumpSwap. The spend is WSOL, so fund the user's WSOL ATA with `max_quote_in` first. */
+const swapBuyAccounts = (input) => swapTradeAccounts(SWAP_BUY, input);
+/** `sell` on PumpSwap. Proceeds land in the user's WSOL ATA; unwrap separately if wanted. */
+const swapSellAccounts = (input) => swapTradeAccounts(SWAP_SELL, input);
+/**
+* PumpSwap's optional cashback account, appended after the ABI list.
+*
+* `market.rs` allows exactly one extra account past the end of a PumpSwap list, and checks it is
+* this address and that it is writable. It is the WSOL ATA of the user's own volume accumulator.
+* Append it only when the coin is a cashback coin; otherwise leave the list at its ABI length.
+*/
+function swapCashbackAccount(user) {
+	const volume = ammUserVolumeAccumulator(user);
+	return {
+		address: ata(volume, WSOL_MINT, TOKEN_PROGRAM_ADDRESS),
+		role: AccountRole.WRITABLE
+	};
+}
+//#endregion
+//#region src/pump/venue.ts
+/**
+* Reading the venue: which one a coin trades on right now, what a pack costs there, and the
+* account list for the trade.
+*
+* One round trip does the whole job. `resolveVenue` reads every account the answer depends on,
+* decodes them through `adapter.ts`, and hands back a plain object whose methods are pure. A caller
+* that wants to re-price a different token count calls `quoteBuy` again with no further reads.
+*
+* # Choosing the venue
+*
+* The bonding curve's `complete` flag is the whole rule. `false` means the coin is still on the
+* curve, so trade Pump. `true` means it graduated, so trade the canonical PumpSwap pool. A caller
+* can force either one; forcing PumpSwap for a coin still on the curve simply fails on chain.
+*
+* A coin can graduate between the read and the send. `buy_pack` then fails and no draw is created,
+* which is the intended outcome — refresh and retry.
+*/
+const base64 = getBase64Encoder();
+const u64$1 = getU64Decoder();
+async function readAccounts(rpc, addresses) {
+	const { value } = await rpc.getMultipleAccounts(addresses, {
+		encoding: "base64",
+		commitment: "confirmed"
+	}).send();
+	return value.map((account) => {
+		if (!account) return null;
+		const [encoded] = account.data;
+		return {
+			data: new Uint8Array(base64.encode(encoded)),
+			owner: account.owner
+		};
+	});
+}
+/**
+* The `amount` field of an SPL or Token-2022 token account: bytes 64..72, little-endian.
+*
+* Both layouts share their first 165 bytes, so one reader covers both. Token-2022 extensions live
+* past that and do not move this field.
+*/
+function tokenAccountAmount(data) {
+	if (data.length < 72) throw new Error("not a token account: fewer than 72 bytes");
+	return u64$1.decode(data, 64);
+}
+function pick(list, index, what) {
+	if (list.length === 0) throw new Error(`the chain holds no ${what}`);
+	const i = index ?? Math.floor(Math.random() * list.length);
+	const chosen = list[i];
+	if (chosen === void 0) throw new Error(`${what} index ${i} is out of range (${list.length})`);
+	return chosen;
+}
+async function resolveVenue(client, options) {
+	const { mint, user } = options;
+	const curveAddress = pumpBondingCurve(mint);
+	const poolAddress = ammCanonicalPool(mint);
+	const [mintAccount, globalAccount, feeConfigAccount, curveAccount, poolAccount, ammConfigAccount, ammFeeAccount] = await readAccounts(client.rpc, [
+		mint,
+		PUMP_GLOBAL,
+		PUMP_FEE_CONFIG,
+		curveAddress,
+		poolAddress,
+		AMM_GLOBAL_CONFIG,
+		AMM_FEE_CONFIG
+	]);
+	if (!mintAccount) throw new Error(`no mint account at ${mint}`);
+	if (!globalAccount) throw new Error(`Pump's Global account is missing at ${PUMP_GLOBAL}`);
+	const tokenProgram = mintAccount.owner;
+	const mintSupply = decodeMintSupply(mintAccount.data, mint, tokenProgram);
+	const global = decodePumpGlobal(globalAccount.data);
+	const pumpFeeConfig = feeConfigAccount ? decodePumpFeeConfig(feeConfigAccount.data) : null;
+	const curve = curveAccount ? decodeBondingCurve(curveAccount.data) : null;
+	const kind = options.venue ?? (curve?.complete === true ? "pumpswap" : "pump");
+	if (kind === "pump") {
+		if (!curve) throw new Error(`no bonding curve at ${curveAddress}. The coin does not exist on Pump, or it was not created with \`create_v2\`.`);
+		const feeRecipient = pick([global.feeRecipient, ...global.feeRecipients], options.feeRecipientIndex, "Pump fee recipient");
+		const buybackFeeRecipient = pick(global.buybackFeeRecipients, options.buybackRecipientIndex, "Pump buyback fee recipient");
+		const shared = {
+			mint,
+			user,
+			tokenProgram,
+			creator: curve.creator,
+			feeRecipient,
+			buybackFeeRecipient
+		};
+		return {
+			kind,
+			program: PUMP_PROGRAM_ADDRESS,
+			mint,
+			tokenProgram,
+			complete: curve.complete,
+			creator: curve.creator,
+			buyAccounts: pumpBuyAccounts(shared),
+			sellAccounts: pumpSellAccounts(shared),
+			quoteBuy: (tokens) => curveBuyCost({
+				global,
+				bondingCurve: curve,
+				feeConfig: pumpFeeConfig,
+				mintSupply,
+				tokens,
+				quoteMint: WSOL_MINT
+			}),
+			quoteSell: (tokens) => curveSellQuote({
+				global,
+				bondingCurve: curve,
+				feeConfig: pumpFeeConfig,
+				mintSupply,
+				tokens
+			})
+		};
+	}
+	if (!poolAccount) throw new Error(`no canonical PumpSwap pool at ${poolAddress}. The coin has not graduated, or its pool is not the canonical one.`);
+	if (!ammConfigAccount) throw new Error(`PumpSwap's GlobalConfig is missing at ${AMM_GLOBAL_CONFIG}`);
+	const pool = decodeAmmPool(poolAccount.data);
+	const ammConfig = decodeAmmGlobalConfig(ammConfigAccount.data);
+	const ammFeeConfig = ammFeeAccount ? decodeAmmFeeConfig(ammFeeAccount.data) : null;
+	const [baseVault, quoteVault] = await readAccounts(client.rpc, [pool.poolBaseTokenAccount, pool.poolQuoteTokenAccount]);
+	if (!baseVault || !quoteVault) throw new Error("the PumpSwap pool has no reserve accounts");
+	const baseReserve = tokenAccountAmount(baseVault.data);
+	const quoteReserve = tokenAccountAmount(quoteVault.data);
+	const protocolFeeRecipient = pick(ammConfig.protocolFeeRecipients, options.feeRecipientIndex, "PumpSwap protocol fee recipient");
+	const shared = {
+		pool: poolAddress,
+		mint,
+		user,
+		tokenProgram,
+		poolBaseTokenAccount: pool.poolBaseTokenAccount,
+		poolQuoteTokenAccount: pool.poolQuoteTokenAccount,
+		coinCreator: pool.coinCreator,
+		protocolFeeRecipient,
+		quoteMint: WSOL_MINT,
+		quoteTokenProgram: TOKEN_PROGRAM_ADDRESS
+	};
+	return {
+		kind,
+		program: PUMP_SWAP_PROGRAM_ADDRESS,
+		mint,
+		tokenProgram,
+		complete: true,
+		creator: curve?.creator ?? pool.coinCreator,
+		buyAccounts: swapBuyAccounts(shared),
+		sellAccounts: swapSellAccounts(shared),
+		quoteBuy: (tokens) => ammBuyCost({
+			pool,
+			globalConfig: ammConfig,
+			feeConfig: ammFeeConfig,
+			baseReserve,
+			quoteReserve,
+			baseMintSupply: mintSupply,
+			tokens
+		}),
+		quoteSell: (tokens) => ammSellQuote({
+			pool,
+			globalConfig: ammConfig,
+			feeConfig: ammFeeConfig,
+			baseReserve,
+			quoteReserve,
+			baseMintSupply: mintSupply,
+			tokens
+		})
+	};
+}
+/**
+* Lamports an exact-tokens-out buy of `tokens` costs right now, on whichever venue the coin trades.
+* Pass `pool.packTokens` for the pack price.
+*
+* One read and one number. Use `resolveVenue` when you also need the account list, which every
+* transaction builder does — this is for a price display.
+*/
+async function curveQuote(client, mint, tokens, options = {}) {
+	return (await resolveVenue(client, {
+		mint,
+		user: options.user ?? mint,
+		...options.venue ? { venue: options.venue } : {},
+		feeRecipientIndex: 0,
+		buybackRecipientIndex: 0
+	})).quoteBuy(tokens);
+}
+/**
+* Lamports an exact-tokens-out buy of `tokens` would cost on a curve that does not exist yet,
+* fees included. This is what the seed costs: `initialize_pool` buys it in the same transaction
+* that creates the coin, so the curve is Pump's default new curve at that moment.
+*/
+async function newCurveBuyCost(client, tokens) {
+	const [globalAccount, feeConfigAccount] = await readAccounts(client.rpc, [PUMP_GLOBAL, PUMP_FEE_CONFIG]);
+	if (!globalAccount) throw new Error(`Pump's Global account is missing at ${PUMP_GLOBAL}`);
+	return curveBuyCost({
+		global: decodePumpGlobal(globalAccount.data),
+		bondingCurve: null,
+		feeConfig: feeConfigAccount ? decodePumpFeeConfig(feeConfigAccount.data) : null,
+		mintSupply: null,
+		tokens,
+		quoteMint: WSOL_MINT
+	});
+}
+/** Lamports a sale of `tokens` returns right now, net of the venue's fees. */
+async function sellQuote(client, mint, tokens, options = {}) {
+	return (await resolveVenue(client, {
+		mint,
+		user: options.user ?? mint,
+		...options.venue ? { venue: options.venue } : {},
+		feeRecipientIndex: 0,
+		buybackRecipientIndex: 0
+	})).quoteSell(tokens);
+}
+/**
+* The user's WSOL associated token account. PumpSwap spends WSOL rather than native SOL, so this
+* account must exist and hold enough before a pack is bought on a graduated coin.
+*/
+function wsolAccountFor(user) {
+	return ata(user, WSOL_MINT, TOKEN_PROGRAM_ADDRESS);
+}
+//#endregion
+//#region src/pump/create.ts
+/**
+* Pump's `create_v2`, built by hand.
+*
+* `@pump-fun/pump-sdk` has a `createV2Instruction`, but it returns a web3.js v1
+* `TransactionInstruction` built through Anchor. Converting that back into a kit instruction means
+* unpacking its account metas and re-deriving each role, which is more moving parts than encoding
+* six arguments. So the arguments are encoded here with kit codecs, and the account list still
+* comes from `accounts.ts`, which comes from the IDL.
+*
+* # The argument layout
+*
+* Borsh, in IDL order: three length-prefixed UTF-8 strings, a pubkey, a bool, and `OptionBool`.
+*
+* `OptionBool` is the one that catches people. It is **not** `Option<bool>`, which would be one or
+* two bytes depending on the tag. The IDL declares it as a struct with a single unnamed `bool`
+* field, so it is exactly one byte, always. `market.rs` hits the same thing on PumpSwap's buy and
+* says so in a comment.
+*/
+const ARGS_ENCODER = getStructEncoder([
+	["name", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+	["symbol", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+	["uri", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+	["creator", getAddressEncoder()],
+	["isMayhemMode", getBooleanEncoder()],
+	["isCashbackEnabled", getBooleanEncoder()]
+]);
+/**
+* `create_v2`. Put it **before** `initialize_pool` in the transaction.
+*
+* `market::require_created_here` reads the Instructions sysvar and looks for this instruction by
+* discriminator, checking that account 0 is the mint and that account 5 — the `user` slot — is the
+* gabox creator and signs. The order matters for a second reason too: the mint account has to exist
+* and deserialize before `initialize_pool`'s own account validation runs.
+*/
+function getPumpCreateV2Instruction(input) {
+	const { mint, user, name, symbol, uri, creator = user.address, mayhemMode = false, cashback = false } = input;
+	const metas = pumpCreateV2Accounts({
+		mint: mint.address,
+		user: user.address,
+		tokenProgram: PUMP_CREATE_TOKEN_PROGRAM_ADDRESS
+	});
+	const signerFor = /* @__PURE__ */ new Map([[mint.address, mint], [user.address, user]]);
+	const accounts = metas.map((meta) => {
+		const signer = signerFor.get(meta.address);
+		const isSigner = meta.role === 2 || meta.role === 3;
+		return signer && isSigner ? {
+			...meta,
+			signer
+		} : meta;
+	});
+	const data = new Uint8Array([...PUMP_CREATE_V2.discriminator, ...ARGS_ENCODER.encode({
+		name,
+		symbol,
+		uri,
+		creator,
+		isMayhemMode: mayhemMode,
+		isCashbackEnabled: cashback
+	})]);
+	return {
+		programAddress: PUMP_PROGRAM_ADDRESS,
+		accounts,
+		data
+	};
+}
+//#endregion
+//#region src/pump/trade.ts
+/**
+* A venue trade the caller sends on its own, outside a gabox instruction.
+*
+* `buy_pack`, `sell_tokens` and the legacy `sell_prize` take the venue's account list as
+* `remainingAccounts` and the program does the CPI. Standalone trades are used when funding with
+* SOL. A sale of a delivered prize goes through `sell_tokens` (see `tx/redeem.ts`) so that it pays
+* the protocol fee; `venueSellInstruction` stays for coins that have no pool.
+*
+* # The argument layout
+*
+* `market.rs` says it in one sentence: "Every supported venue instruction starts with the same two
+* u64 args." A buy is `(amount_out, max_quote_in)` — the caller fixes the token count and the
+* venue decides the cost. PumpSwap's buy carries one extra byte, `track_volume`, which is an
+* `OptionBool`: a one-field tuple struct, so exactly one byte, never `Option<bool>`'s one-or-two.
+*
+* The account list and the discriminator both come from `abi.ts`, which codegen took from the two
+* official Pump IDLs. Nothing here retypes either.
+*/
+const u64 = getU64Encoder();
+/** `track_volume` on PumpSwap's buy. Off: a donation is not a volume-accruing trade for the funder. */
+const TRACK_VOLUME_OFF = 0;
+/**
+* Buy tokens at the venue, as a standalone instruction.
+*
+* The signer is attached to the one slot the ABI marks as a signer, and only when its address
+* matches — the same rule `create.ts` follows. Passing a `user` that is not in the account list is
+* a mistake this catches here rather than on chain.
+*/
+function venueBuyInstruction(input) {
+	const { venue, user, tokens, maxQuoteIn } = input;
+	if (tokens <= 0n) throw new Error("tokens must be positive");
+	if (maxQuoteIn <= 0n) throw new Error("maxQuoteIn must be positive");
+	const abi = venue.kind === "pump" ? PUMP_BUY : SWAP_BUY;
+	const accounts = attachSigner(venue.buyAccounts, user);
+	const data = new Uint8Array([
+		...abi.discriminator,
+		...u64.encode(tokens),
+		...u64.encode(maxQuoteIn),
+		...venue.kind === "pumpswap" ? [TRACK_VOLUME_OFF] : []
+	]);
+	return {
+		programAddress: venue.program,
+		accounts,
+		data
+	};
+}
+/** Sell tokens the wallet already holds, as a standalone venue instruction. */
+function venueSellInstruction(input) {
+	const { venue, user, amount, minQuoteOutput } = input;
+	if (amount <= 0n) throw new Error("amount must be positive");
+	if (minQuoteOutput <= 0n) throw new Error("minQuoteOutput must be positive");
+	const abi = venue.kind === "pump" ? PUMP_SELL : SWAP_SELL;
+	return {
+		programAddress: venue.program,
+		accounts: attachSigner(venue.sellAccounts, user),
+		data: new Uint8Array([
+			...abi.discriminator,
+			...u64.encode(amount),
+			...u64.encode(minQuoteOutput)
+		])
+	};
+}
+/** Give the signer to the slots the ABI already marks as signing. Roles never change here. */
+function attachSigner(accounts, signer) {
+	let matched = false;
+	const withSigner = accounts.map((meta) => {
+		if (!(meta.role === 2 || meta.role === 3) || meta.address !== signer.address) return meta;
+		matched = true;
+		return {
+			...meta,
+			signer
+		};
+	});
+	if (!matched) throw new Error(`${signer.address} is not the signing account of this venue trade. Resolve the venue with the same wallet you are going to sign with.`);
+	return withSigner;
+}
+//#endregion
+//#region src/pump/index.ts
+var pump_exports = /* @__PURE__ */ __exportAll({
+	AMM_EVENT_AUTHORITY: () => AMM_EVENT_AUTHORITY,
+	AMM_FEE_CONFIG: () => AMM_FEE_CONFIG,
+	AMM_GLOBAL_CONFIG: () => AMM_GLOBAL_CONFIG,
+	AMM_GLOBAL_VOLUME_ACCUMULATOR: () => AMM_GLOBAL_VOLUME_ACCUMULATOR,
+	ASSOCIATED_TOKEN_PROGRAM_ADDRESS: () => ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+	MAYHEM_GLOBAL_PARAMS: () => MAYHEM_GLOBAL_PARAMS,
+	MAYHEM_PROGRAM_ADDRESS: () => MAYHEM_PROGRAM_ADDRESS,
+	MAYHEM_SOL_VAULT: () => MAYHEM_SOL_VAULT,
+	PUMP_BUY: () => PUMP_BUY,
+	PUMP_CREATE_TOKEN_PROGRAM_ADDRESS: () => PUMP_CREATE_TOKEN_PROGRAM_ADDRESS,
+	PUMP_CREATE_V2: () => PUMP_CREATE_V2,
+	PUMP_EVENT_AUTHORITY: () => PUMP_EVENT_AUTHORITY,
+	PUMP_FEE_CONFIG: () => PUMP_FEE_CONFIG,
+	PUMP_FEE_PROGRAM_ADDRESS: () => PUMP_FEE_PROGRAM_ADDRESS,
+	PUMP_GLOBAL: () => PUMP_GLOBAL,
+	PUMP_GLOBAL_VOLUME_ACCUMULATOR: () => PUMP_GLOBAL_VOLUME_ACCUMULATOR,
+	PUMP_MINT_AUTHORITY: () => PUMP_MINT_AUTHORITY,
+	PUMP_PROGRAM_ADDRESS: () => PUMP_PROGRAM_ADDRESS,
+	PUMP_SELL: () => PUMP_SELL,
+	PUMP_SWAP_PROGRAM_ADDRESS: () => PUMP_SWAP_PROGRAM_ADDRESS,
+	SWAP_BUY: () => SWAP_BUY,
+	SWAP_SELL: () => SWAP_SELL,
+	SYSTEM_PROGRAM_ADDRESS: () => SYSTEM_PROGRAM_ADDRESS,
+	ammBuyCost: () => ammBuyCost,
+	ammCanonicalPool: () => ammCanonicalPool,
+	ammCoinCreatorVaultAta: () => ammCoinCreatorVaultAta,
+	ammCoinCreatorVaultAuthority: () => ammCoinCreatorVaultAuthority,
+	ammSellQuote: () => ammSellQuote,
+	ammUserVolumeAccumulator: () => ammUserVolumeAccumulator,
+	ata: () => ata,
+	curveBuyCost: () => curveBuyCost,
+	curveQuote: () => curveQuote,
+	curveSellQuote: () => curveSellQuote,
+	decodeAmmFeeConfig: () => decodeAmmFeeConfig,
+	decodeAmmGlobalConfig: () => decodeAmmGlobalConfig,
+	decodeAmmPool: () => decodeAmmPool,
+	decodeBondingCurve: () => decodeBondingCurve,
+	decodeMintSupply: () => decodeMintSupply,
+	decodePumpFeeConfig: () => decodePumpFeeConfig,
+	decodePumpGlobal: () => decodePumpGlobal,
+	getPumpCreateV2Instruction: () => getPumpCreateV2Instruction,
+	newCurveBuyCost: () => newCurveBuyCost,
+	pumpBondingCurve: () => pumpBondingCurve,
+	pumpBuyAccounts: () => pumpBuyAccounts,
+	pumpCreateV2Accounts: () => pumpCreateV2Accounts,
+	pumpCreatorVault: () => pumpCreatorVault,
+	pumpMayhemState: () => pumpMayhemState,
+	pumpMayhemTokenVault: () => pumpMayhemTokenVault,
+	pumpSellAccounts: () => pumpSellAccounts,
+	pumpSharingConfig: () => pumpSharingConfig,
+	pumpUserVolumeAccumulator: () => pumpUserVolumeAccumulator,
+	resolveVenue: () => resolveVenue,
+	sellQuote: () => sellQuote,
+	swapBuyAccounts: () => swapBuyAccounts,
+	swapCashbackAccount: () => swapCashbackAccount,
+	swapSellAccounts: () => swapSellAccounts,
+	tokenAccountAmount: () => tokenAccountAmount,
+	venueBuyInstruction: () => venueBuyInstruction,
+	venueSellInstruction: () => venueSellInstruction,
+	wsolAccountFor: () => wsolAccountFor
+});
+//#endregion
+export { MAX_ATTEMPTS as $, ammCoinCreatorVaultAta as A, decodeBondingCurve as B, PUMP_EVENT_AUTHORITY as C, SWAP_SELL as Ct, PUMP_MINT_AUTHORITY as D, PUMP_GLOBAL_VOLUME_ACCUMULATOR as E, curveBuyCost as F, pumpCreatorVault as G, decodePumpFeeConfig as H, curveSellQuote as I, pumpSharingConfig as J, pumpMayhemState as K, decodeAmmFeeConfig as L, ammSellQuote as M, ammUserVolumeAccumulator as N, ammBuyCost as O, ata as P, INSTRUCTIONS_SYSVAR as Q, decodeAmmGlobalConfig as R, MAYHEM_SOL_VAULT as S, SWAP_BUY as St, PUMP_GLOBAL as T, decodePumpGlobal as U, decodeMintSupply as V, pumpBondingCurve as W, GABOX_PROGRAM_ID as X, pumpUserVolumeAccumulator as Y, IDENTITY_SEED as Z, AMM_EVENT_AUTHORITY as _, PUMP_CREATE_V2 as _t, curveQuote as a, RETRY_SLOTS as at, AMM_GLOBAL_VOLUME_ACCUMULATOR as b, PUMP_SELL as bt, sellQuote as c, TOKEN_2022_PROGRAM_ADDRESS as ct, pumpBuyAccounts as d, VRF_PROGRAM_ADDRESS as dt, MAX_FEE_BPS as et, pumpCreateV2Accounts as f, WSOL_MINT as ft, swapSellAccounts as g, PUMP_CREATE_TOKEN_PROGRAM_ADDRESS as gt, swapCashbackAccount as h, PUMP_BUY as ht, getPumpCreateV2Instruction as i, REFERRAL_FEE_BPS as it, ammCoinCreatorVaultAuthority as j, ammCanonicalPool as k, tokenAccountAmount as l, TOKEN_PROGRAM_ADDRESS as lt, swapBuyAccounts as m, MAYHEM_PROGRAM_ADDRESS as mt, venueBuyInstruction as n, PROTOCOL_FEE_BPS as nt, newCurveBuyCost as o, SLOT_HASHES_SYSVAR as ot, pumpSellAccounts as p, ASSOCIATED_TOKEN_PROGRAM_ADDRESS as pt, pumpMayhemTokenVault as q, venueSellInstruction as r, PROTOCOL_FEE_COLLECTOR as rt, resolveVenue as s, TIMEOUT_SLOTS as st, pump_exports as t, PACK_TOKENS as tt, wsolAccountFor as u, VRF_DEFAULT_QUEUE as ut, AMM_FEE_CONFIG as v, PUMP_FEE_PROGRAM_ADDRESS as vt, PUMP_FEE_CONFIG as w, SYSTEM_PROGRAM_ADDRESS as wt, MAYHEM_GLOBAL_PARAMS as x, PUMP_SWAP_PROGRAM_ADDRESS as xt, AMM_GLOBAL_CONFIG as y, PUMP_PROGRAM_ADDRESS as yt, decodeAmmPool as z };
+
+//# sourceMappingURL=pump-D0K_0uiC.js.map