@metadaoproject/programs 0.1.1-alpha.0 → 0.1.1-relaunch-demo.0

package/dist/relaunch/v0.1/RelaunchClient.js

@@ -0,0 +1,733 @@
+import { Program } from "@coral-xyz/anchor";
+import { ComputeBudgetProgram, Keypair, PublicKey, SystemProgram, Transaction, } from "@solana/web3.js";
+import { AccountLayout, ASSOCIATED_TOKEN_PROGRAM_ID, createAssociatedTokenAccountIdempotentInstruction, createInitializeMint2Instruction, createSyncNativeInstruction, getAssociatedTokenAddressSync, MINT_SIZE, NATIVE_MINT, TOKEN_PROGRAM_ID, } from "@solana/spl-token";
+import BN from "bn.js";
+import * as multisig from "@sqds/multisig";
+import { FUTARCHY_V0_6_PROGRAM_ID, MAINNET_USDC, MPL_TOKEN_METADATA_PROGRAM_ID, PUMP_AMM_PROGRAM_ID, PUMP_FEES_PROGRAM_ID, RELAUNCH_V0_1_PROGRAM_ID, SQUADS_PROGRAM_CONFIG, SQUADS_PROGRAM_CONFIG_TREASURY, SQUADS_PROGRAM_ID, WHIRLPOOL_PROGRAM_ID, } from "../../constants.js";
+import { getDaoAddr } from "../../futarchy/v0.6/index.js";
+import { RelaunchIDL, } from "./types/index.js";
+import { getRelaunchAddr, getRelaunchSignerAddr, getDepositRecordAddr, } from "./pda.js";
+import { fetchPumpPool, getPumpCreatorVaultAuthorityAddr, getPumpFeeRecipients, getPumpPoolV2Addr, getPumpUserVolumeAccumulatorAddr, PUMP_AMM_EVENT_AUTHORITY, PUMP_AMM_FEE_CONFIG, PUMP_AMM_GLOBAL_CONFIG, PUMP_AMM_GLOBAL_VOLUME_ACCUMULATOR, } from "./pumpAmm.js";
+import { fetchRaydiumPool, parseRaydiumPool, RAYDIUM_AMM_AUTHORITY, RAYDIUM_AMM_PROGRAM_ID, } from "./raydiumAmm.js";
+import { fetchWhirlpool, getWhirlpoolOracleAddr, getWhirlpoolSwapTickArrayAddrs, MEMO_PROGRAM_ID, USDC_SWAP_POOL, } from "./whirlpool.js";
+import { getEventAuthorityAddr, getMetadataAddr } from "../../pda.js";
+function ceilDiv(a, b) {
+    return (a + b - 1n) / b;
+}
+export class RelaunchClient {
+    provider;
+    relaunchProgram;
+    programId;
+    constructor(provider, relaunchProgramId) {
+        this.provider = provider;
+        this.programId = relaunchProgramId;
+        this.relaunchProgram = new Program(RelaunchIDL, relaunchProgramId, provider);
+    }
+    static createClient(createRelaunchClientParams) {
+        let { provider, relaunchProgramId } = createRelaunchClientParams;
+        return new RelaunchClient(provider, relaunchProgramId || RELAUNCH_V0_1_PROGRAM_ID);
+    }
+    getProgramId() {
+        return this.programId;
+    }
+    initializeRelaunchIx({ newMint, oldMint, oldTokenProgram, sourcePool, 
+    // Required for Raydium sources (the pool's LP mint), null for PumpSwap.
+    sourcePoolLpMint = null, sourceQuoteMint, tokenName, tokenSymbol, tokenUri, secondsForDeposits, gracePeriodSeconds, thresholdBps, 
+    // Zero amount with no members initializes without a spending limit.
+    monthlySpendingLimitAmount = new BN(0), monthlySpendingLimitMembers = [], teamAddress, mintAuthority = this.provider.publicKey, admin = this.provider.publicKey, payer = this.provider.publicKey, }) {
+        const relaunch = this.getRelaunchAddress({ newMint });
+        const relaunchSigner = this.getRelaunchSignerAddress({ relaunch });
+        const oldTokenVault = getAssociatedTokenAddressSync(oldMint, relaunchSigner, true, oldTokenProgram);
+        const newTokenVault = getAssociatedTokenAddressSync(newMint, relaunchSigner, true);
+        const sourceQuoteVault = getAssociatedTokenAddressSync(sourceQuoteMint, relaunchSigner, true);
+        const usdcVault = getAssociatedTokenAddressSync(MAINNET_USDC, relaunchSigner, true);
+        const [tokenMetadata] = getMetadataAddr(newMint);
+        return this.relaunchProgram.methods
+            .initializeRelaunch({
+            tokenName,
+            tokenSymbol,
+            tokenUri,
+            secondsForDeposits,
+            gracePeriodSeconds,
+            thresholdBps,
+            monthlySpendingLimitAmount,
+            monthlySpendingLimitMembers,
+            teamAddress,
+        })
+            .accounts({
+            relaunch,
+            newMint,
+            mintAuthority,
+            relaunchSigner,
+            oldMint,
+            sourcePool,
+            sourcePoolLpMint,
+            sourceQuoteMint,
+            usdcMint: MAINNET_USDC,
+            oldTokenVault,
+            newTokenVault,
+            sourceQuoteVault,
+            usdcVault,
+            tokenMetadata,
+            admin,
+            payer,
+            oldTokenProgram,
+            tokenProgram: TOKEN_PROGRAM_ID,
+            tokenMetadataProgram: MPL_TOKEN_METADATA_PROGRAM_ID,
+        })
+            .preInstructions([
+            ComputeBudgetProgram.setComputeUnitLimit({ units: 400_000 }),
+        ]);
+    }
+    startDepositsIx({ relaunch, admin = this.provider.publicKey, }) {
+        return this.relaunchProgram.methods.startDeposits().accounts({
+            relaunch,
+            admin,
+        });
+    }
+    depositIx({ relaunch, oldMint, oldTokenProgram, amount, depositor = this.provider.publicKey, payer = this.provider.publicKey, }) {
+        const relaunchSigner = this.getRelaunchSignerAddress({ relaunch });
+        const depositRecord = this.getDepositRecordAddress({
+            relaunch,
+            depositor,
+        });
+        const oldTokenVault = getAssociatedTokenAddressSync(oldMint, relaunchSigner, true, oldTokenProgram);
+        const depositorTokenAccount = getAssociatedTokenAddressSync(oldMint, depositor, false, oldTokenProgram);
+        return this.relaunchProgram.methods.deposit({ amount }).accounts({
+            relaunch,
+            depositRecord,
+            oldMint,
+            oldTokenVault,
+            depositor,
+            depositorTokenAccount,
+            payer,
+            oldTokenProgram,
+        });
+    }
+    closeDepositsIx({ relaunch }) {
+        return this.relaunchProgram.methods.closeDeposits().accounts({
+            relaunch,
+        });
+    }
+    depositViaBuyIx({ relaunch, oldMint, oldTokenProgram, sourceQuoteMint, sourcePool, poolBaseTokenAccount, poolQuoteTokenAccount, coinCreator, protocolFeeRecipient, buybackFeeRecipient, baseOut, maxQuoteIn, depositor = this.provider.publicKey, payer = this.provider.publicKey, depositorQuoteAccount = getAssociatedTokenAddressSync(sourceQuoteMint, depositor), }) {
+        const relaunchSigner = this.getRelaunchSignerAddress({ relaunch });
+        const depositRecord = this.getDepositRecordAddress({
+            relaunch,
+            depositor,
+        });
+        const oldTokenVault = getAssociatedTokenAddressSync(oldMint, relaunchSigner, true, oldTokenProgram);
+        const sourceQuoteVault = getAssociatedTokenAddressSync(sourceQuoteMint, relaunchSigner, true);
+        const coinCreatorVaultAuthority = getPumpCreatorVaultAuthorityAddr(coinCreator);
+        return this.relaunchProgram.methods
+            .depositViaBuy({ baseOut, maxQuoteIn })
+            .accounts({
+            relaunch,
+            depositRecord,
+            depositor,
+            payer,
+            relaunchSigner,
+            oldMint,
+            sourceQuoteMint,
+            oldTokenVault,
+            sourceQuoteVault,
+            depositorQuoteAccount,
+            sourcePool,
+            pumpGlobalConfig: PUMP_AMM_GLOBAL_CONFIG,
+            protocolFeeRecipient,
+            protocolFeeRecipientTokenAccount: getAssociatedTokenAddressSync(sourceQuoteMint, protocolFeeRecipient, true),
+            poolBaseTokenAccount,
+            poolQuoteTokenAccount,
+            coinCreatorVaultAta: getAssociatedTokenAddressSync(sourceQuoteMint, coinCreatorVaultAuthority, true),
+            coinCreatorVaultAuthority,
+            globalVolumeAccumulator: PUMP_AMM_GLOBAL_VOLUME_ACCUMULATOR,
+            userVolumeAccumulator: getPumpUserVolumeAccumulatorAddr(relaunchSigner),
+            pumpFeeConfig: PUMP_AMM_FEE_CONFIG,
+            pumpFeeProgram: PUMP_FEES_PROGRAM_ID,
+            poolV2: getPumpPoolV2Addr(oldMint),
+            buybackFeeRecipient,
+            buybackFeeRecipientTokenAccount: getAssociatedTokenAddressSync(sourceQuoteMint, buybackFeeRecipient, true),
+            pumpEventAuthority: PUMP_AMM_EVENT_AUTHORITY,
+            pumpAmmProgram: PUMP_AMM_PROGRAM_ID,
+            baseTokenProgram: oldTokenProgram,
+            quoteTokenProgram: TOKEN_PROGRAM_ID,
+            associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: SystemProgram.programId,
+        })
+            .preInstructions([
+            ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 }),
+        ]);
+    }
+    depositViaBuyRaydiumIx({ relaunch, oldMint, sourceQuoteMint, sourcePool, ammCoinVault, ammPcVault, baseOut, maxQuoteIn, depositor = this.provider.publicKey, payer = this.provider.publicKey, depositorQuoteAccount = getAssociatedTokenAddressSync(sourceQuoteMint, depositor), }) {
+        const relaunchSigner = this.getRelaunchSignerAddress({ relaunch });
+        const depositRecord = this.getDepositRecordAddress({
+            relaunch,
+            depositor,
+        });
+        const oldTokenVault = getAssociatedTokenAddressSync(oldMint, relaunchSigner, true);
+        const sourceQuoteVault = getAssociatedTokenAddressSync(sourceQuoteMint, relaunchSigner, true);
+        return this.relaunchProgram.methods
+            .depositViaBuyRaydium({ baseOut, maxQuoteIn })
+            .accounts({
+            relaunch,
+            depositRecord,
+            depositor,
+            payer,
+            relaunchSigner,
+            sourceQuoteMint,
+            oldTokenVault,
+            sourceQuoteVault,
+            depositorQuoteAccount,
+            sourcePool,
+            ammAuthority: RAYDIUM_AMM_AUTHORITY,
+            ammCoinVault,
+            ammPcVault,
+            raydiumAmmProgram: RAYDIUM_AMM_PROGRAM_ID,
+            tokenProgram: TOKEN_PROGRAM_ID,
+            systemProgram: SystemProgram.programId,
+        });
+    }
+    executeSellIx({ relaunch, oldMint, oldTokenProgram, sourceQuoteMint, sourcePool, poolBaseTokenAccount, poolQuoteTokenAccount, coinCreator, protocolFeeRecipient, buybackFeeRecipient, minQuoteOut, admin = this.provider.publicKey, }) {
+        const relaunchSigner = this.getRelaunchSignerAddress({ relaunch });
+        const oldTokenVault = getAssociatedTokenAddressSync(oldMint, relaunchSigner, true, oldTokenProgram);
+        const sourceQuoteVault = getAssociatedTokenAddressSync(sourceQuoteMint, relaunchSigner, true);
+        const coinCreatorVaultAuthority = getPumpCreatorVaultAuthorityAddr(coinCreator);
+        return this.relaunchProgram.methods
+            .executeSell({ minQuoteOut })
+            .accounts({
+            relaunch,
+            admin,
+            relaunchSigner,
+            oldMint,
+            sourceQuoteMint,
+            oldTokenVault,
+            sourceQuoteVault,
+            sourcePool,
+            pumpGlobalConfig: PUMP_AMM_GLOBAL_CONFIG,
+            protocolFeeRecipient,
+            protocolFeeRecipientTokenAccount: getAssociatedTokenAddressSync(sourceQuoteMint, protocolFeeRecipient, true),
+            poolBaseTokenAccount,
+            poolQuoteTokenAccount,
+            coinCreatorVaultAta: getAssociatedTokenAddressSync(sourceQuoteMint, coinCreatorVaultAuthority, true),
+            coinCreatorVaultAuthority,
+            pumpFeeConfig: PUMP_AMM_FEE_CONFIG,
+            pumpFeeProgram: PUMP_FEES_PROGRAM_ID,
+            poolV2: getPumpPoolV2Addr(oldMint),
+            buybackFeeRecipient,
+            buybackFeeRecipientTokenAccount: getAssociatedTokenAddressSync(sourceQuoteMint, buybackFeeRecipient, true),
+            pumpEventAuthority: PUMP_AMM_EVENT_AUTHORITY,
+            pumpAmmProgram: PUMP_AMM_PROGRAM_ID,
+            baseTokenProgram: oldTokenProgram,
+            quoteTokenProgram: TOKEN_PROGRAM_ID,
+            associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: SystemProgram.programId,
+        })
+            .preInstructions([
+            ComputeBudgetProgram.setComputeUnitLimit({ units: 250_000 }),
+        ]);
+    }
+    executeSellRaydiumIx({ relaunch, oldMint, sourceQuoteMint, sourcePool, ammCoinVault, ammPcVault, minQuoteOut, admin = this.provider.publicKey, }) {
+        const relaunchSigner = this.getRelaunchSignerAddress({ relaunch });
+        const oldTokenVault = getAssociatedTokenAddressSync(oldMint, relaunchSigner, true);
+        const sourceQuoteVault = getAssociatedTokenAddressSync(sourceQuoteMint, relaunchSigner, true);
+        return this.relaunchProgram.methods
+            .executeSellRaydium({ minQuoteOut })
+            .accounts({
+            relaunch,
+            admin,
+            relaunchSigner,
+            oldTokenVault,
+            sourceQuoteVault,
+            sourcePool,
+            ammAuthority: RAYDIUM_AMM_AUTHORITY,
+            ammCoinVault,
+            ammPcVault,
+            raydiumAmmProgram: RAYDIUM_AMM_PROGRAM_ID,
+            tokenProgram: TOKEN_PROGRAM_ID,
+        });
+    }
+    executeUsdcSwapIx({ relaunch, whirlpoolWsolVault, whirlpoolUsdcVault, tickArrays, minUsdcOut, whirlpool = USDC_SWAP_POOL, admin = this.provider.publicKey, }) {
+        const relaunchSigner = this.getRelaunchSignerAddress({ relaunch });
+        const sourceQuoteVault = getAssociatedTokenAddressSync(NATIVE_MINT, relaunchSigner, true);
+        const usdcVault = getAssociatedTokenAddressSync(MAINNET_USDC, relaunchSigner, true);
+        return this.relaunchProgram.methods
+            .executeUsdcSwap({ minUsdcOut })
+            .accounts({
+            relaunch,
+            admin,
+            relaunchSigner,
+            sourceQuoteVault,
+            usdcVault,
+            whirlpool,
+            wsolMint: NATIVE_MINT,
+            usdcMint: MAINNET_USDC,
+            whirlpoolWsolVault,
+            whirlpoolUsdcVault,
+            tickArray0: tickArrays[0],
+            tickArray1: tickArrays[1],
+            tickArray2: tickArrays[2],
+            oracle: getWhirlpoolOracleAddr(whirlpool),
+            memoProgram: MEMO_PROGRAM_ID,
+            whirlpoolProgram: WHIRLPOOL_PROGRAM_ID,
+            tokenProgram: TOKEN_PROGRAM_ID,
+        });
+    }
+    // Swaps the whole WSOL vault to USDC as the admin (the provider wallet),
+    // deriving the whirlpool account set from the pinned pool's live state.
+    // When minUsdcOut is not given, it is computed from the pool's spot price
+    // minus slippageBps (which must also cover the swap fee + price impact).
+    async executeUsdcSwap({ relaunch, minUsdcOut, slippageBps = 100, }) {
+        const whirlpool = await fetchWhirlpool(this.provider.connection);
+        if (minUsdcOut === undefined) {
+            const relaunchSigner = this.getRelaunchSignerAddress({ relaunch });
+            const wsolIn = await this.fetchTokenBalance(getAssociatedTokenAddressSync(NATIVE_MINT, relaunchSigner, true));
+            // Spot price in USDC-raw per WSOL-raw is (sqrtPrice / 2^64)^2.
+            const spotOut = (wsolIn * whirlpool.sqrtPrice * whirlpool.sqrtPrice) >> 128n;
+            const floor = (spotOut * (10000n - BigInt(slippageBps))) / 10000n;
+            minUsdcOut = new BN(floor.toString());
+        }
+        return this.executeUsdcSwapIx({
+            relaunch,
+            whirlpoolWsolVault: whirlpool.tokenVaultA,
+            whirlpoolUsdcVault: whirlpool.tokenVaultB,
+            tickArrays: getWhirlpoolSwapTickArrayAddrs(USDC_SWAP_POOL, whirlpool.tickCurrentIndex, whirlpool.tickSpacing, true),
+            minUsdcOut,
+        }).rpc();
+    }
+    completeRelaunchIx({ relaunch, newMint, payer = this.provider.publicKey, }) {
+        const relaunchSigner = this.getRelaunchSignerAddress({ relaunch });
+        const newTokenVault = getAssociatedTokenAddressSync(newMint, relaunchSigner, true);
+        const usdcVault = getAssociatedTokenAddressSync(MAINNET_USDC, relaunchSigner, true);
+        const [tokenMetadata] = getMetadataAddr(newMint);
+        const [dao] = getDaoAddr({ nonce: new BN(0), daoCreator: relaunchSigner });
+        const [futarchyEventAuthority] = getEventAuthorityAddr(FUTARCHY_V0_6_PROGRAM_ID);
+        const [multisigPda] = multisig.getMultisigPda({ createKey: dao });
+        const [multisigVault] = multisig.getVaultPda({ multisigPda, index: 0 });
+        const [spendingLimit] = multisig.getSpendingLimitPda({
+            multisigPda,
+            createKey: dao,
+        });
+        const [ammPosition] = PublicKey.findProgramAddressSync([Buffer.from("amm_position"), dao.toBuffer(), multisigVault.toBuffer()], FUTARCHY_V0_6_PROGRAM_ID);
+        return this.relaunchProgram.methods
+            .completeRelaunch()
+            .accounts({
+            relaunch,
+            payer,
+            relaunchSigner,
+            newMint,
+            usdcMint: MAINNET_USDC,
+            newTokenVault,
+            usdcVault,
+            tokenMetadata,
+            dao,
+            futarchyAmmBaseVault: getAssociatedTokenAddressSync(newMint, dao, true),
+            futarchyAmmQuoteVault: getAssociatedTokenAddressSync(MAINNET_USDC, dao, true),
+            ammPosition,
+            squadsMultisig: multisigPda,
+            squadsMultisigVault: multisigVault,
+            spendingLimit,
+            squadsProgramConfig: SQUADS_PROGRAM_CONFIG,
+            squadsProgramConfigTreasury: SQUADS_PROGRAM_CONFIG_TREASURY,
+            futarchyProgram: FUTARCHY_V0_6_PROGRAM_ID,
+            futarchyEventAuthority,
+            squadsProgram: SQUADS_PROGRAM_ID,
+            tokenMetadataProgram: MPL_TOKEN_METADATA_PROGRAM_ID,
+            tokenProgram: TOKEN_PROGRAM_ID,
+            associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: SystemProgram.programId,
+        })
+            .preInstructions([
+            ComputeBudgetProgram.setComputeUnitLimit({ units: 500_000 }),
+        ]);
+    }
+    // Completes the relaunch as any cranker (the provider wallet), reading the
+    // new mint from the stored relaunch.
+    async completeRelaunch({ relaunch, }) {
+        const storedRelaunch = await this.fetchRelaunch(relaunch);
+        if (storedRelaunch === null) {
+            throw new Error(`relaunch ${relaunch.toBase58()} does not exist`);
+        }
+        return this.completeRelaunchIx({
+            relaunch,
+            newMint: storedRelaunch.newMint,
+        }).rpc();
+    }
+    markFailedIx({ relaunch }) {
+        return this.relaunchProgram.methods.markFailed().accounts({
+            relaunch,
+        });
+    }
+    claimRefundIx({ relaunch, oldMint, oldTokenProgram, depositor = this.provider.publicKey, }) {
+        const relaunchSigner = this.getRelaunchSignerAddress({ relaunch });
+        const depositRecord = this.getDepositRecordAddress({
+            relaunch,
+            depositor,
+        });
+        const oldTokenVault = getAssociatedTokenAddressSync(oldMint, relaunchSigner, true, oldTokenProgram);
+        const depositorTokenAccount = getAssociatedTokenAddressSync(oldMint, depositor, false, oldTokenProgram);
+        return this.relaunchProgram.methods.claimRefund().accounts({
+            relaunch,
+            depositRecord,
+            oldMint,
+            oldTokenVault,
+            relaunchSigner,
+            depositor,
+            depositorTokenAccount,
+            oldTokenProgram,
+        });
+    }
+    claimIx({ relaunch, newMint, depositor = this.provider.publicKey, payer = this.provider.publicKey, }) {
+        const relaunchSigner = this.getRelaunchSignerAddress({ relaunch });
+        const depositRecord = this.getDepositRecordAddress({
+            relaunch,
+            depositor,
+        });
+        const newTokenVault = getAssociatedTokenAddressSync(newMint, relaunchSigner, true);
+        const depositorTokenAccount = getAssociatedTokenAddressSync(newMint, depositor, false);
+        return this.relaunchProgram.methods
+            .claim()
+            .accounts({
+            relaunch,
+            depositRecord,
+            newMint,
+            newTokenVault,
+            relaunchSigner,
+            depositor,
+            depositorTokenAccount,
+            tokenProgram: TOKEN_PROGRAM_ID,
+        })
+            .preInstructions([
+            createAssociatedTokenAccountIdempotentInstruction(payer, depositorTokenAccount, depositor, newMint),
+        ]);
+    }
+    // Deposits from the provider wallet, reading the old mint and its owner
+    // program from the stored relaunch.
+    async deposit({ relaunch, amount, }) {
+        const storedRelaunch = await this.fetchRelaunch(relaunch);
+        if (storedRelaunch === null) {
+            throw new Error(`relaunch ${relaunch.toBase58()} does not exist`);
+        }
+        const oldMintAccount = await this.provider.connection.getAccountInfo(storedRelaunch.oldMint);
+        if (oldMintAccount === null) {
+            throw new Error(`old mint ${storedRelaunch.oldMint.toBase58()} does not exist`);
+        }
+        return this.depositIx({
+            relaunch,
+            oldMint: storedRelaunch.oldMint,
+            oldTokenProgram: oldMintAccount.owner,
+            amount,
+        }).rpc();
+    }
+    // Tops the provider wallet's WSOL ATA up to maxQuoteIn, wrapping any
+    // shortfall from SOL in a separate preparatory transaction
+    async wrapWsolShortfall(maxQuoteIn) {
+        const wsolAta = getAssociatedTokenAddressSync(NATIVE_MINT, this.provider.publicKey);
+        let wsolAtaAccount = null;
+        try {
+            wsolAtaAccount = await this.provider.connection.getAccountInfo(wsolAta);
+        }
+        catch {
+            // anchor-bankrun's connection proxy throws for missing accounts
+            // instead of returning null.
+        }
+        const wsolBalance = wsolAtaAccount === null
+            ? 0n
+            : AccountLayout.decode(wsolAtaAccount.data).amount;
+        const shortfall = BigInt(maxQuoteIn.toString()) - wsolBalance;
+        if (shortfall > 0n) {
+            await this.provider.sendAndConfirm(new Transaction().add(createAssociatedTokenAccountIdempotentInstruction(this.provider.publicKey, wsolAta, this.provider.publicKey, NATIVE_MINT), SystemProgram.transfer({
+                fromPubkey: this.provider.publicKey,
+                toPubkey: wsolAta,
+                lamports: Number(shortfall),
+            }), createSyncNativeInstruction(wsolAta)));
+        }
+    }
+    // Buys baseOut old tokens off the source pool as the provider wallet and
+    // credits them as a deposit, dispatching on the relaunch's stored source
+    // venue and deriving the venue's account set like executeSell. When
+    // maxQuoteIn is not given, it is computed live from the pool reserves: the
+    // constant-product input for the exact output plus slippageBps. Pump's
+    // swap fees are not modeled, so slippageBps must also cover them;
+    // Raydium's flat 25 bps fee is modeled exactly, so slippageBps only covers
+    // price movement. For WSOL-quoted pools, any shortfall in the depositor's
+    // WSOL ATA is wrapped from SOL in a separate preparatory transaction.
+    async depositViaBuy({ relaunch, baseOut, maxQuoteIn, slippageBps = 100, }) {
+        const storedRelaunch = await this.fetchRelaunch(relaunch);
+        if (storedRelaunch === null) {
+            throw new Error(`relaunch ${relaunch.toBase58()} does not exist`);
+        }
+        if (storedRelaunch.sourceVenue.raydiumAmmV4 !== undefined) {
+            const pool = await fetchRaydiumPool(this.provider.connection, storedRelaunch.sourcePool);
+            if (maxQuoteIn === undefined) {
+                const tokenIsCoin = pool.coinMint.equals(storedRelaunch.oldMint);
+                const [tokenReserve, quoteReserve] = await Promise.all([
+                    tokenIsCoin ? pool.coinVault : pool.pcVault,
+                    tokenIsCoin ? pool.pcVault : pool.coinVault,
+                ].map((address) => this.fetchTokenBalance(address)));
+                const baseOutBig = BigInt(baseOut.toString());
+                if (baseOutBig >= tokenReserve) {
+                    throw new Error(`baseOut ${baseOutBig} exceeds the pool's token reserve ${tokenReserve}`);
+                }
+                // The exact-out input is ceil-rounded, with the 25 bps fee
+                // ceil-rounded on top of it (the fee stays in the pool).
+                const inBeforeFee = ceilDiv(quoteReserve * baseOutBig, tokenReserve - baseOutBig);
+                const grossIn = ceilDiv(inBeforeFee * 10000n, 9975n);
+                const cap = (grossIn * (10000n + BigInt(slippageBps))) / 10000n;
+                maxQuoteIn = new BN(cap.toString());
+            }
+            // Raydium sources are WSOL-quoted by construction.
+            await this.wrapWsolShortfall(maxQuoteIn);
+            return this.depositViaBuyRaydiumIx({
+                relaunch,
+                oldMint: storedRelaunch.oldMint,
+                sourceQuoteMint: storedRelaunch.sourceQuoteMint,
+                sourcePool: storedRelaunch.sourcePool,
+                ammCoinVault: pool.coinVault,
+                ammPcVault: pool.pcVault,
+                baseOut,
+                maxQuoteIn,
+            }).rpc();
+        }
+        const oldMintAccount = await this.provider.connection.getAccountInfo(storedRelaunch.oldMint);
+        if (oldMintAccount === null) {
+            throw new Error(`old mint ${storedRelaunch.oldMint.toBase58()} does not exist`);
+        }
+        const pool = await fetchPumpPool(this.provider.connection, storedRelaunch.sourcePool);
+        const { protocolFeeRecipient, buybackFeeRecipient } = await getPumpFeeRecipients(this.provider.connection);
+        if (maxQuoteIn === undefined) {
+            const [baseReserve, quoteReserve] = await Promise.all([pool.poolBaseTokenAccount, pool.poolQuoteTokenAccount].map((address) => this.fetchTokenBalance(address)));
+            const baseOutBig = BigInt(baseOut.toString());
+            if (baseOutBig >= baseReserve) {
+                throw new Error(`baseOut ${baseOutBig} exceeds the pool's base reserve ${baseReserve}`);
+            }
+            const grossIn = (quoteReserve * baseOutBig) / (baseReserve - baseOutBig);
+            const cap = (grossIn * (10000n + BigInt(slippageBps))) / 10000n;
+            maxQuoteIn = new BN(cap.toString());
+        }
+        if (storedRelaunch.sourceQuoteMint.equals(NATIVE_MINT)) {
+            await this.wrapWsolShortfall(maxQuoteIn);
+        }
+        return this.depositViaBuyIx({
+            relaunch,
+            oldMint: storedRelaunch.oldMint,
+            oldTokenProgram: oldMintAccount.owner,
+            sourceQuoteMint: storedRelaunch.sourceQuoteMint,
+            sourcePool: storedRelaunch.sourcePool,
+            poolBaseTokenAccount: pool.poolBaseTokenAccount,
+            poolQuoteTokenAccount: pool.poolQuoteTokenAccount,
+            coinCreator: pool.coinCreator,
+            protocolFeeRecipient,
+            buybackFeeRecipient,
+            baseOut,
+            maxQuoteIn,
+        }).rpc();
+    }
+    // Sells the whole old-token vault as the admin (the provider wallet),
+    // dispatching on the relaunch's stored source venue and deriving the
+    // venue's account set from the stored relaunch and its pool. When
+    // minQuoteOut is not given, it is computed live from the pool reserves:
+    // the constant-product output of the sell minus slippageBps. Pump's swap
+    // fees are not modeled, so slippageBps must also cover them; Raydium's
+    // flat 25 bps fee is exact, so slippageBps only covers price movement.
+    async executeSell({ relaunch, minQuoteOut, slippageBps = 100, }) {
+        const storedRelaunch = await this.fetchRelaunch(relaunch);
+        if (storedRelaunch === null) {
+            throw new Error(`relaunch ${relaunch.toBase58()} does not exist`);
+        }
+        if (storedRelaunch.sourceVenue.raydiumAmmV4 !== undefined) {
+            const pool = await fetchRaydiumPool(this.provider.connection, storedRelaunch.sourcePool);
+            if (minQuoteOut === undefined) {
+                const tokenIsCoin = pool.coinMint.equals(storedRelaunch.oldMint);
+                const [baseIn, tokenReserve, quoteReserve] = await Promise.all([
+                    storedRelaunch.oldTokenVault,
+                    tokenIsCoin ? pool.coinVault : pool.pcVault,
+                    tokenIsCoin ? pool.pcVault : pool.coinVault,
+                ].map((address) => this.fetchTokenBalance(address)));
+                // The 25 bps fee is ceil-rounded off the input and stays in the pool.
+                const netIn = baseIn - (baseIn * 25n + 9999n) / 10000n;
+                const grossOut = (quoteReserve * netIn) / (tokenReserve + netIn);
+                const floor = (grossOut * (10000n - BigInt(slippageBps))) / 10000n;
+                minQuoteOut = new BN(floor.toString());
+            }
+            return this.executeSellRaydiumIx({
+                relaunch,
+                oldMint: storedRelaunch.oldMint,
+                sourceQuoteMint: storedRelaunch.sourceQuoteMint,
+                sourcePool: storedRelaunch.sourcePool,
+                ammCoinVault: pool.coinVault,
+                ammPcVault: pool.pcVault,
+                minQuoteOut,
+            }).rpc();
+        }
+        const oldMintAccount = await this.provider.connection.getAccountInfo(storedRelaunch.oldMint);
+        if (oldMintAccount === null) {
+            throw new Error(`old mint ${storedRelaunch.oldMint.toBase58()} does not exist`);
+        }
+        const pool = await fetchPumpPool(this.provider.connection, storedRelaunch.sourcePool);
+        const { protocolFeeRecipient, buybackFeeRecipient } = await getPumpFeeRecipients(this.provider.connection);
+        if (minQuoteOut === undefined) {
+            const [baseIn, baseReserve, quoteReserve] = await Promise.all([
+                storedRelaunch.oldTokenVault,
+                pool.poolBaseTokenAccount,
+                pool.poolQuoteTokenAccount,
+            ].map((address) => this.fetchTokenBalance(address)));
+            const grossOut = (quoteReserve * baseIn) / (baseReserve + baseIn);
+            const floor = (grossOut * (10000n - BigInt(slippageBps))) / 10000n;
+            minQuoteOut = new BN(floor.toString());
+        }
+        return this.executeSellIx({
+            relaunch,
+            oldMint: storedRelaunch.oldMint,
+            oldTokenProgram: oldMintAccount.owner,
+            sourceQuoteMint: storedRelaunch.sourceQuoteMint,
+            sourcePool: storedRelaunch.sourcePool,
+            poolBaseTokenAccount: pool.poolBaseTokenAccount,
+            poolQuoteTokenAccount: pool.poolQuoteTokenAccount,
+            coinCreator: pool.coinCreator,
+            protocolFeeRecipient,
+            buybackFeeRecipient,
+            minQuoteOut,
+        }).rpc();
+    }
+    async fetchTokenBalance(address) {
+        const accountInfo = await this.provider.connection.getAccountInfo(address);
+        if (accountInfo === null) {
+            throw new Error(`token account ${address.toBase58()} does not exist`);
+        }
+        return AccountLayout.decode(accountInfo.data).amount;
+    }
+    // Claims a refund for the given depositor (the provider wallet by default),
+    // reading the old mint and its owner program from the stored relaunch.
+    async claimRefund({ relaunch, depositor = this.provider.publicKey, }) {
+        const storedRelaunch = await this.fetchRelaunch(relaunch);
+        if (storedRelaunch === null) {
+            throw new Error(`relaunch ${relaunch.toBase58()} does not exist`);
+        }
+        const oldMintAccount = await this.provider.connection.getAccountInfo(storedRelaunch.oldMint);
+        if (oldMintAccount === null) {
+            throw new Error(`old mint ${storedRelaunch.oldMint.toBase58()} does not exist`);
+        }
+        return this.claimRefundIx({
+            relaunch,
+            oldMint: storedRelaunch.oldMint,
+            oldTokenProgram: oldMintAccount.owner,
+            depositor,
+        }).rpc();
+    }
+    // Claims the depositor's pro-rata share of the new token (the provider
+    // wallet by default), reading the new mint from the stored relaunch.
+    async claim({ relaunch, depositor = this.provider.publicKey, }) {
+        const storedRelaunch = await this.fetchRelaunch(relaunch);
+        if (storedRelaunch === null) {
+            throw new Error(`relaunch ${relaunch.toBase58()} does not exist`);
+        }
+        return this.claimIx({
+            relaunch,
+            newMint: storedRelaunch.newMint,
+            depositor,
+        }).rpc();
+    }
+    // Builds the create-mint-to-self pre-instructions: a `createAccountWithSeed`
+    // + `initializeMint2` pair with the payer as mint authority, so
+    // `initialize_relaunch` can take the authority from a mint the payer
+    // provably controls.
+    async createNewMintIxs({ payer = this.provider.publicKey, seed = Keypair.generate().publicKey.toBase58().slice(0, 32), } = {}) {
+        const newMint = await PublicKey.createWithSeed(payer, seed, TOKEN_PROGRAM_ID);
+        const lamports = await this.provider.connection.getMinimumBalanceForRentExemption(MINT_SIZE);
+        const instructions = [
+            SystemProgram.createAccountWithSeed({
+                fromPubkey: payer,
+                basePubkey: payer,
+                seed,
+                newAccountPubkey: newMint,
+                lamports,
+                space: MINT_SIZE,
+                programId: TOKEN_PROGRAM_ID,
+            }),
+            createInitializeMint2Instruction(newMint, 6, payer, null),
+        ];
+        return { newMint, instructions };
+    }
+    // Creates the new mint and initializes the relaunch in a single
+    // transaction, signed entirely by the provider wallet.
+    async initializeRelaunch({ oldMint, sourcePool, sourceQuoteMint, tokenName, tokenSymbol, tokenUri, secondsForDeposits, gracePeriodSeconds, thresholdBps, monthlySpendingLimitAmount, monthlySpendingLimitMembers, teamAddress, admin, }) {
+        const { newMint, instructions } = await this.createNewMintIxs();
+        const oldMintAccount = await this.provider.connection.getAccountInfo(oldMint);
+        if (oldMintAccount === null) {
+            throw new Error(`old mint ${oldMint.toBase58()} does not exist`);
+        }
+        const sourcePoolAccount = await this.provider.connection.getAccountInfo(sourcePool);
+        if (sourcePoolAccount === null) {
+            throw new Error(`source pool ${sourcePool.toBase58()} does not exist`);
+        }
+        // Raydium sources need the pool's LP mint alongside for the burned-LP
+        // check; PumpSwap sources are validated purely from the pool account.
+        const sourcePoolLpMint = sourcePoolAccount.owner.equals(RAYDIUM_AMM_PROGRAM_ID)
+            ? parseRaydiumPool(sourcePoolAccount.data).lpMint
+            : null;
+        const txSignature = await this.initializeRelaunchIx({
+            newMint,
+            oldMint,
+            oldTokenProgram: oldMintAccount.owner,
+            sourcePool,
+            sourcePoolLpMint,
+            sourceQuoteMint,
+            tokenName,
+            tokenSymbol,
+            tokenUri,
+            secondsForDeposits,
+            gracePeriodSeconds,
+            thresholdBps,
+            monthlySpendingLimitAmount,
+            monthlySpendingLimitMembers,
+            teamAddress,
+            admin,
+        })
+            .preInstructions(instructions)
+            .rpc();
+        return {
+            newMint,
+            relaunch: this.getRelaunchAddress({ newMint }),
+            txSignature,
+        };
+    }
+    async fetchRelaunch(relaunch) {
+        return this.relaunchProgram.account.relaunch.fetchNullable(relaunch);
+    }
+    async deserializeRelaunch(accountInfo) {
+        return this.relaunchProgram.coder.accounts.decode("relaunch", accountInfo.data);
+    }
+    async fetchDepositRecord(depositRecord) {
+        return this.relaunchProgram.account.depositRecord.fetchNullable(depositRecord);
+    }
+    async deserializeDepositRecord(accountInfo) {
+        return this.relaunchProgram.coder.accounts.decode("depositRecord", accountInfo.data);
+    }
+    async getRelaunch({ newMint, }) {
+        const relaunch = this.getRelaunchAddress({ newMint });
+        return this.fetchRelaunch(relaunch);
+    }
+    async getDepositRecord({ relaunch, depositor, }) {
+        const depositRecord = this.getDepositRecordAddress({
+            relaunch,
+            depositor,
+        });
+        return this.fetchDepositRecord(depositRecord);
+    }
+    getRelaunchAddress({ newMint }) {
+        return getRelaunchAddr({ programId: this.programId, newMint })[0];
+    }
+    getRelaunchSignerAddress({ relaunch, }) {
+        return getRelaunchSignerAddr({ programId: this.programId, relaunch })[0];
+    }
+    getDepositRecordAddress({ relaunch, depositor, }) {
+        return getDepositRecordAddr({
+            programId: this.programId,
+            relaunch,
+            depositor,
+        })[0];
+    }
+    getEventAuthorityAddress() {
+        return getEventAuthorityAddr(this.programId)[0];
+    }
+}
+//# sourceMappingURL=RelaunchClient.js.map