Buy

0xef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d

7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE

pub fn buy(
    ctx: Context<Buy>,
    lamports_amount: u64,
    expected_total_raised_usd_e2: u64,
    expected_total_sold_tokens_e6: u64,
    slippage_bps: u16,
) -> Result<()>

#[derive(Accounts)]
#[instruction(
    lamports_amount: u64,
    expected_total_raised_usd_e2: u64,
    expected_total_sold_tokens_e6: u64,
    slippage_bps: u16
)]
pub struct Buy<'info> {
    /// The user sending SOL
    #[account(mut)]
    pub buyer: Signer<'info>,

    /// The token mint being sold
    #[account(
        constraint = mint.key() == bonding_curve_pda.token_mint_address
    )]
    pub mint: Account<'info, Mint>,

    #[account(
        seeds = [b"admin-states"],
        bump
    )]
    pub admin_states_pda: Box<Account<'info, AdminStatesPDA>>,

    /// Global states PDA (tracks global sale settings)
    #[account(
        seeds = [b"global-states"],
        bump,
    )]
    pub global_states_pda: Account<'info, GlobalStatesPDA>,

    /// Bonding curve PDA (tracks state for this token sale)
    #[account(
        mut,
        seeds = [b"bonding-curve", mint.key().as_ref()],
        bump,
    )]
    pub bonding_curve_pda: Account<'info, BondingCurvePDA>,

    /// Bonding curve vault (SOL vault for this bonding curve)
    #[account(
        mut,
        seeds = [b"bonding-curve-vault", mint.key().as_ref()],
        bump,
    )]
    pub bonding_curve_vault: SystemAccount<'info>,

    /// Buyer accumulation PDA (tracks how much this buyer has purchased)
    #[account(
        init_if_needed,
        payer = buyer,
        space = BuyerAccumulationPDA::LEN,
        seeds = [
            b"buyer-accumulation",
            bonding_curve_pda.key().as_ref(),
            buyer.key().as_ref(),
        ],
        bump,
    )]
    pub buyer_accumulation_pda: Account<'info, BuyerAccumulationPDA>,

    /// Platform fee vault (validated against seeds)
    #[account(
        mut,
        seeds = [b"platform-fee-vault"],
        bump,
    )]
    pub platform_fee_vault: SystemAccount<'info>,

    // Pyth SOL/USD price feed account
    pub sol_usd_price_feed: Account<'info, PriceUpdateV2>,

    /// Programs
    pub system_program: Program<'info, System>,
}

import { Program } from "@coral-xyz/anchor";
import {
  PublicKey,
  SystemProgram,
  TransactionMessage,
  VersionedTransaction,
} from "@solana/web3.js";
import BN from "bn.js";

// Your configured Anchor program, connection, and wallet
const program = new Program(IDL, provider);

const PROGRAM_ID = new PublicKey("RUGFREEPUMP_PROGRAM_ID");
const mint = new PublicKey("TOKEN_MINT_ADDRESS");
const buyer = wallet.publicKey;

const lamportsAmount = new BN("1000000000"); // 1 SOL
const slippageBps = 200; // 2%

// Derive required PDAs
const [adminStatesPda] = PublicKey.findProgramAddressSync(
  [Buffer.from("admin-states")],
  PROGRAM_ID,
);

const [globalStatesPda] = PublicKey.findProgramAddressSync(
  [Buffer.from("global-states")],
  PROGRAM_ID,
);

const [bondingCurvePda] = PublicKey.findProgramAddressSync(
  [
    Buffer.from("bonding-curve"),
    mint.toBuffer(),
  ],
  PROGRAM_ID,
);

const [bondingCurveVault] = PublicKey.findProgramAddressSync(
  [
    Buffer.from("bonding-curve-vault"),
    mint.toBuffer(),
  ],
  PROGRAM_ID,
);

const [buyerAccumulationPda] = PublicKey.findProgramAddressSync(
  [
    Buffer.from("buyer-accumulation"),
    bondingCurvePda.toBuffer(),
    buyer.toBuffer(),
  ],
  PROGRAM_ID,
);

const [platformFeeVault] = PublicKey.findProgramAddressSync(
  [Buffer.from("platform-fee-vault")],
  PROGRAM_ID,
);

// Fetch the current bonding-curve state
const bondingCurveAccount = await program.account.bondingCurvePda.fetch(bondingCurvePda);

// Read the state snapshot required for slippage protection
const expectedTotalRaisedUsdE2 = new BN(
  bondingCurveAccount.totalRaisedUsdE2.toString(),
);

const expectedTotalSoldTokensE6 = new BN(
  bondingCurveAccount.totalSoldTokensE6.toString(),
);

// Construct the buy instruction
const buyInstruction = await program.methods
  .buy(
    lamportsAmount,
    expectedTotalRaisedUsdE2,
    expectedTotalSoldTokensE6,
    slippageBps,
  )
  .accounts({
    buyer,
    mint,
    adminStatesPda,
    globalStatesPda,
    bondingCurvePda,
    bondingCurveVault,
    buyerAccumulationPda,
    platformFeeVault,
    solUsdPriceFeed: SOL_USD_PRICE_FEED_ACCOUNT,
    systemProgram: SystemProgram.programId,
  })
  .instruction();

// Fetch a recent blockhash
const { blockhash } = await provider.connection.getLatestBlockhash("confirmed");

// Build the versioned transaction
const messageV0 = new TransactionMessage({
  payerKey: buyer,
  recentBlockhash: blockhash,
  instructions: [buyInstruction],
}).compileToV0Message();

const transaction = new VersionedTransaction(messageV0);

// Sign and submit
transaction.sign([wallet.payer]);

const signature = await provider.connection.sendTransaction(transaction);

console.log(signature);