Integrate Control tokens with direct on-chain Buy and Sell.

import { PublicKey } from '@solana/web3.js';
import {
  getAssociatedTokenAddressSync,
  TOKEN_2022_PROGRAM_ID,
} from '@solana/spl-token';

export const CONTROL_PROGRAM_ID = new PublicKey(
  'CTRL5CCEQw5zhhBeEV8n5GKZpf3E5tYQoXhhxzUAps27',
);

export function deriveConfig(): PublicKey {
  const [pda] = PublicKey.findProgramAddressSync(
    [Buffer.from('control-config')],
    CONTROL_PROGRAM_ID,
  );
  return pda;
}

export function deriveCurve(mint: PublicKey): PublicKey {
  const [pda] = PublicKey.findProgramAddressSync(
    [Buffer.from('control-curve'), mint.toBuffer()],
    CONTROL_PROGRAM_ID,
  );
  return pda;
}

export function deriveCreatorFeeVault(
  mint: PublicKey,
  creator: PublicKey,
): PublicKey {
  const [pda] = PublicKey.findProgramAddressSync(
    [Buffer.from('creator-fees'), mint.toBuffer(), creator.toBuffer()],
    CONTROL_PROGRAM_ID,
  );
  return pda;
}

export function deriveLpEscrow(mint: PublicKey): PublicKey {
  const [pda] = PublicKey.findProgramAddressSync(
    [Buffer.from('lp-escrow'), mint.toBuffer()],
    CONTROL_PROGRAM_ID,
  );
  return pda;
}

export function deriveCommunityPool(mint: PublicKey): PublicKey {
  const [pda] = PublicKey.findProgramAddressSync(
    [Buffer.from('community-pool'), mint.toBuffer()],
    CONTROL_PROGRAM_ID,
  );
  return pda;
}

// Anchor self-CPI signer for TradeEvent emission. Global, not per-mint.
// Required on every Buy and Sell.
export function deriveEventAuthority(): PublicKey {
  const [pda] = PublicKey.findProgramAddressSync(
    [Buffer.from('__event_authority')],
    CONTROL_PROGRAM_ID,
  );
  return pda;
}

export function deriveVaultAta(mint: PublicKey): PublicKey {
  const curve = deriveCurve(mint);
  return getAssociatedTokenAddressSync(
    mint,
    curve,
    true, // allowOwnerOffCurve — curve is a PDA
    TOKEN_2022_PROGRAM_ID,
  );
}

// BUY — user sends sol_in lamports, receives tokens_out
total_sol   = virtual_sol_reserve   + real_sol_reserve
total_token = virtual_token_reserve + real_token_reserve

tokens_out  = (total_token * sol_in) / (total_sol + sol_in)

// SELL — user sends token_in units, receives sol_out (before fees)
sol_out     = (total_sol * token_in) / (total_token + token_in)

total_fee_bps  = 200 + curve.extra_community_fee_bps   // = 300 for default mints
total_fee      = sol_amount * total_fee_bps / 10_000
curve_sol      = sol_amount − total_fee                // goes into the AMM

creator_fee         = config.creator_fee_bps          * curve_sol / 10_000
protocol_fee        = config.protocol_fee_bps         * curve_sol / 10_000
lp_fee              = config.lp_fee_bps               * curve_sol / 10_000
extra_community_fee = curve.extra_community_fee_bps   * curve_sol / 10_000
community_fee       = total_fee − (creator_fee + protocol_fee + lp_fee + extra_community_fee)
                      // community absorbs the integer-division rounding remainder

import {
  Connection,
  PublicKey,
  Transaction,
  TransactionInstruction,
  SystemProgram,
  Keypair,
  sendAndConfirmTransaction,
} from '@solana/web3.js';
import {
  TOKEN_2022_PROGRAM_ID,
  getAssociatedTokenAddressSync,
  createAssociatedTokenAccountIdempotentInstruction,
} from '@solana/spl-token';
import {
  CONTROL_PROGRAM_ID,
  deriveConfig,
  deriveCurve,
  deriveCommunityPool,
  deriveEventAuthority,
} from './pdas';
import { readCurveState, readProtocolFeeWallet } from './reads'; // from §10.3

const BUY_DISCRIMINANT = 2;

function encodeBuyData(solAmount: bigint, minTokensOut: bigint): Buffer {
  const buf = Buffer.alloc(1 + 8 + 8);
  buf.writeUInt8(BUY_DISCRIMINANT, 0);
  buf.writeBigUInt64LE(solAmount, 1);
  buf.writeBigUInt64LE(minTokensOut, 9);
  return buf;
}

export async function buildBuyTx(params: {
  connection: Connection;
  user: PublicKey;
  mint: PublicKey;
  solAmountLamports: bigint;
  minTokensOut: bigint;
  // Optional override — pass it if you've cached it (it's a global config value).
  protocolFeeWallet?: PublicKey;
}): Promise<Transaction> {
  const { connection, user, mint, solAmountLamports, minTokensOut } = params;

  // 1. Read on-chain state. The curve gives us vaultAta, lpEscrow, creatorFeeVault
  //    pre-derived; the config gives us the protocol fee wallet (cache it).
  const curveState = await readCurveState(connection, mint);
  if (!curveState) throw new Error('Curve PDA not found — wrong cluster, or this mint was not launched on Control');
  if (curveState.isCompleted) throw new Error('Curve graduated — route via Meteora DAMM v2');
  if (curveState.isFrozen)    throw new Error('Curve frozen mid-migration — retry shortly');
  const protocolFeeWallet = params.protocolFeeWallet ?? await readProtocolFeeWallet(connection);

  // 2. Compute the remaining accounts (PDAs derived from the mint, plus the user ATA).
  const config = deriveConfig();
  const curve = deriveCurve(mint);
  const communityPool = deriveCommunityPool(mint);
  const eventAuthority = deriveEventAuthority();
  const userAta = getAssociatedTokenAddressSync(
    mint, user, false, TOKEN_2022_PROGRAM_ID,
  );

  // 3. Idempotent ATA creation for the user (Token-2022).
  const ataIx = createAssociatedTokenAccountIdempotentInstruction(
    user, userAta, user, mint, TOKEN_2022_PROGRAM_ID,
  );

  // 4. Build the Buy instruction (14 accounts — slots 12 and 13 are the self-CPI TradeEvent accounts).
  const buyIx = new TransactionInstruction({
    programId: CONTROL_PROGRAM_ID,
    keys: [
      { pubkey: user,                       isSigner: true,  isWritable: true  },
      { pubkey: config,                     isSigner: false, isWritable: false },
      { pubkey: curve,                      isSigner: false, isWritable: true  },
      { pubkey: mint,                       isSigner: false, isWritable: false },
      { pubkey: curveState.vaultAta,        isSigner: false, isWritable: true  },
      { pubkey: userAta,                    isSigner: false, isWritable: true  },
      { pubkey: curveState.creatorFeeVault, isSigner: false, isWritable: true  },
      { pubkey: protocolFeeWallet,          isSigner: false, isWritable: true  },
      { pubkey: curveState.lpEscrow,        isSigner: false, isWritable: true  },
      { pubkey: communityPool,              isSigner: false, isWritable: true  },
      { pubkey: TOKEN_2022_PROGRAM_ID,      isSigner: false, isWritable: false },
      { pubkey: SystemProgram.programId,    isSigner: false, isWritable: false },
      { pubkey: eventAuthority,             isSigner: false, isWritable: false },
      { pubkey: CONTROL_PROGRAM_ID,         isSigner: false, isWritable: false },
    ],
    data: encodeBuyData(solAmountLamports, minTokensOut),
  });

  const tx = new Transaction().add(ataIx, buyIx);
  tx.feePayer = user;
  tx.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
  return tx;
}

// Usage — signer is the end user's wallet (Phantom, Backpack, etc.).
// For Node, use a Keypair:
async function example() {
  const connection = new Connection('https://api.devnet.solana.com', 'confirmed');
  const user = Keypair.generate(); // replace with wallet keypair

  const tx = await buildBuyTx({
    connection,
    user: user.publicKey,
    mint: new PublicKey('<CONTROL_TOKEN_MINT>'),
    solAmountLamports: 100_000_000n, // 0.1 SOL
    minTokensOut: 1n,                  // set based on quoteBuy(state, in) + your slippage tolerance
    // protocolFeeWallet: cachedProtocolFeeWallet, // optional: pass cached value to skip the config read
  });

  const sig = await sendAndConfirmTransaction(connection, tx, [user]);
  console.log('Buy landed:', sig);

  // Verify the resulting balance. NOTE: pass TOKEN_2022_PROGRAM_ID as the 4th
  // arg of getAccount — Control mints are Token-2022, the SPL-token default
  // SPL Token program ID will return AccountInvalidOwner / wrong-program errors.
  const { getAccount } = await import('@solana/spl-token');
  const userAta = getAssociatedTokenAddressSync(
    new PublicKey('<CONTROL_TOKEN_MINT>'), user.publicKey, false, TOKEN_2022_PROGRAM_ID,
  );
  const ataState = await getAccount(
    connection, userAta, 'confirmed', TOKEN_2022_PROGRAM_ID, // ← critical 4th arg
  );
  console.log('Tokens received:', ataState.amount.toString());
}

import {
  Connection,
  PublicKey,
  Transaction,
  TransactionInstruction,
} from '@solana/web3.js';
import {
  TOKEN_2022_PROGRAM_ID,
  getAssociatedTokenAddressSync,
} from '@solana/spl-token';
import {
  CONTROL_PROGRAM_ID,
  deriveConfig,
  deriveCurve,
  deriveCommunityPool,
  deriveEventAuthority,
} from './pdas';
import { readCurveState, readProtocolFeeWallet } from './reads'; // from §10.3

const SELL_DISCRIMINANT = 3;

function encodeSellData(tokenAmount: bigint, minSolOut: bigint): Buffer {
  const buf = Buffer.alloc(1 + 8 + 8);
  buf.writeUInt8(SELL_DISCRIMINANT, 0);
  buf.writeBigUInt64LE(tokenAmount, 1);
  buf.writeBigUInt64LE(minSolOut, 9);
  return buf;
}

export async function buildSellTx(params: {
  connection: Connection;
  user: PublicKey;
  mint: PublicKey;
  tokenAmount: bigint;     // raw base units (respects mint decimals)
  minSolOut: bigint;       // lamports, slippage-protected floor
  // Optional override — pass it if you've cached it (it's a global config value).
  protocolFeeWallet?: PublicKey;
}): Promise<Transaction> {
  const { connection, user, mint, tokenAmount, minSolOut } = params;

  // 1. Read on-chain state — same pattern as Buy.
  const curveState = await readCurveState(connection, mint);
  if (!curveState) throw new Error('Curve PDA not found — wrong cluster, or this mint was not launched on Control');
  if (curveState.isCompleted) throw new Error('Curve graduated — route via Meteora DAMM v2');
  if (curveState.isFrozen)    throw new Error('Curve frozen mid-migration — retry shortly');
  const protocolFeeWallet = params.protocolFeeWallet ?? await readProtocolFeeWallet(connection);

  // 2. Compute the remaining accounts.
  const config = deriveConfig();
  const curve = deriveCurve(mint);
  const communityPool = deriveCommunityPool(mint);
  const eventAuthority = deriveEventAuthority();
  const userAta = getAssociatedTokenAddressSync(
    mint, user, false, TOKEN_2022_PROGRAM_ID,
  );

  // 3. Build the Sell instruction (13 accounts — Buy's first 10 + token2022 +
  //    eventAuthority + program. system_program is omitted; self-CPI accounts
  //    sit at slots 11 and 12 instead of 12 and 13).
  const sellIx = new TransactionInstruction({
    programId: CONTROL_PROGRAM_ID,
    keys: [
      { pubkey: user,                       isSigner: true,  isWritable: true  },
      { pubkey: config,                     isSigner: false, isWritable: false },
      { pubkey: curve,                      isSigner: false, isWritable: true  },
      { pubkey: mint,                       isSigner: false, isWritable: false },
      { pubkey: curveState.vaultAta,        isSigner: false, isWritable: true  },
      { pubkey: userAta,                    isSigner: false, isWritable: true  },
      { pubkey: curveState.creatorFeeVault, isSigner: false, isWritable: true  },
      { pubkey: protocolFeeWallet,          isSigner: false, isWritable: true  },
      { pubkey: curveState.lpEscrow,        isSigner: false, isWritable: true  },
      { pubkey: communityPool,              isSigner: false, isWritable: true  },
      { pubkey: TOKEN_2022_PROGRAM_ID,      isSigner: false, isWritable: false },
      { pubkey: eventAuthority,             isSigner: false, isWritable: false },
      { pubkey: CONTROL_PROGRAM_ID,         isSigner: false, isWritable: false },
    ],
    data: encodeSellData(tokenAmount, minSolOut),
  });

  const tx = new Transaction().add(sellIx);
  tx.feePayer = user;
  tx.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
  return tx;
}

import { Connection, PublicKey } from '@solana/web3.js';
import { deriveCurve, deriveConfig } from './pdas';

// Field offsets inside the 344-byte ControlCurve account (repr(C, packed)).
const OFFSET_MINT                     = 0;     // pubkey (32) — the token mint this curve trades
const OFFSET_AUTHORITY                = 32;    // pubkey (32) — curve authority (admin); rarely needed by integrators
const OFFSET_VIRTUAL_SOL              = 64;
const OFFSET_VIRTUAL_TOKEN            = 72;
const OFFSET_REAL_SOL                 = 80;
const OFFSET_REAL_TOKEN               = 88;
const OFFSET_INITIAL_TOKEN_RESERVE    = 96;
const OFFSET_TOTAL_SUPPLY             = 104;
const OFFSET_REQUIRED_LIQ             = 112;
const OFFSET_IS_COMPLETED             = 120;
const OFFSET_BUMP                     = 121;   // curve PDA bump (u8)
const OFFSET_IS_FROZEN                = 122;
// 123..144: pad + created_at + max_user_tokens — not exposed below.
const OFFSET_VAULT_ATA                = 144;   // pubkey (32) — pre-derived vaultAta, you can use this directly
const OFFSET_CREATOR                  = 176;   // pubkey (32) — token creator wallet (NOT the same as authority)
const OFFSET_LP_ESCROW                = 208;   // pubkey (32) — pre-derived lpEscrow PDA
const OFFSET_EXTRA_COMMUNITY_FEE_BPS  = 240;   // u16 LE — addon to community_fee_bps (in addition to the 1.00% base)
// 242..312: pad + meteora_pool + position_nft_mint — only set after graduation.
const OFFSET_CREATOR_FEE_VAULT        = 312;   // pubkey (32) — pre-derived creatorFeeVault PDA

export interface CurveState {
  mint: PublicKey;
  creator: PublicKey;             // token creator (use to derive creatorFeeVault — or read OFFSET_CREATOR_FEE_VAULT directly)
  vaultAta: PublicKey;             // pre-derived
  lpEscrow: PublicKey;             // pre-derived
  creatorFeeVault: PublicKey;      // pre-derived — saves a findProgramAddressSync call
  bump: number;
  virtualSolReserve: bigint;
  virtualTokenReserve: bigint;
  realSolReserve: bigint;
  realTokenReserve: bigint;
  initialTokenReserve: bigint;
  totalSupply: bigint;
  requiredLiquidity: bigint;       // graduation threshold (lamports)
  extraCommunityFeeBps: number;    // per-mint addon over the base community fee
  isCompleted: boolean;            // true once migrated to Meteora DAMM v2
  isFrozen: boolean;               // true while migration is in flight
}

export async function readCurveState(
  connection: Connection,
  mint: PublicKey,
): Promise<CurveState | null> {
  const info = await connection.getAccountInfo(deriveCurve(mint));
  if (!info) return null; // account doesn't exist (wrong cluster or mint never launched on Control) — not a graduation signal; the curve PDA stays on chain even after graduation

  const d = info.data;
  return {
    mint:                  new PublicKey(d.slice(OFFSET_MINT, OFFSET_MINT + 32)),
    creator:               new PublicKey(d.slice(OFFSET_CREATOR, OFFSET_CREATOR + 32)),
    vaultAta:              new PublicKey(d.slice(OFFSET_VAULT_ATA, OFFSET_VAULT_ATA + 32)),
    lpEscrow:              new PublicKey(d.slice(OFFSET_LP_ESCROW, OFFSET_LP_ESCROW + 32)),
    creatorFeeVault:       new PublicKey(d.slice(OFFSET_CREATOR_FEE_VAULT, OFFSET_CREATOR_FEE_VAULT + 32)),
    bump:                  d[OFFSET_BUMP],
    virtualSolReserve:     d.readBigUInt64LE(OFFSET_VIRTUAL_SOL),
    virtualTokenReserve:   d.readBigUInt64LE(OFFSET_VIRTUAL_TOKEN),
    realSolReserve:        d.readBigUInt64LE(OFFSET_REAL_SOL),
    realTokenReserve:      d.readBigUInt64LE(OFFSET_REAL_TOKEN),
    initialTokenReserve:   d.readBigUInt64LE(OFFSET_INITIAL_TOKEN_RESERVE),
    totalSupply:           d.readBigUInt64LE(OFFSET_TOTAL_SUPPLY),
    requiredLiquidity:     d.readBigUInt64LE(OFFSET_REQUIRED_LIQ),
    extraCommunityFeeBps:  d.readUInt16LE(OFFSET_EXTRA_COMMUNITY_FEE_BPS),
    isCompleted: d[OFFSET_IS_COMPLETED] === 1,
    isFrozen:    d[OFFSET_IS_FROZEN]    === 1,
  };
}

// Total trading fee bps (always taken from the input side):
// creator(15) + protocol(60) + lp(25) + community_base(100) + extra_community(per-mint)
// = 200 bps fixed + extra_community_fee_bps from the curve. Default mints carry
// extra_community = 100 → 300 bps total = 3.00%, but per-mint values vary.
const FIXED_FEE_BPS = 200n;    // 15 + 60 + 25 + 100 (base community)
const BPS_DENOM     = 10_000n;

function totalFeeBps(state: CurveState): bigint {
  return FIXED_FEE_BPS + BigInt(state.extraCommunityFeeBps);
}

export function quoteBuy(state: CurveState, solInLamports: bigint): bigint {
  const totalSol   = state.virtualSolReserve   + state.realSolReserve;
  const totalToken = state.virtualTokenReserve + state.realTokenReserve;
  const fee   = (solInLamports * totalFeeBps(state)) / BPS_DENOM;
  const netIn = solInLamports - fee;
  return (totalToken * netIn) / (totalSol + netIn);
}

export function quoteSell(state: CurveState, tokenIn: bigint): bigint {
  const totalSol   = state.virtualSolReserve   + state.realSolReserve;
  const totalToken = state.virtualTokenReserve + state.realTokenReserve;
  const grossOut = (totalSol * tokenIn) / (totalToken + tokenIn);
  return grossOut - (grossOut * totalFeeBps(state)) / BPS_DENOM;
}

// ---------- Read the config account ----------
// ControlConfig layout (80 bytes, repr(C, packed)):
//   0..32   admin                (pubkey)
//   32..64  protocol_fee_wallet  (pubkey)   ← what integrators need for Buy/Sell
//   64..66  creator_fee_bps      (u16 LE)   = 15  → 0.15%
//   66..68  protocol_fee_bps     (u16 LE)   = 60  → 0.60%
//   68..70  lp_fee_bps           (u16 LE)   = 25  → 0.25%
//   70..72  community_fee_bps    (u16 LE)   = 100 → 1.00%
//   72..80  create_fee           (u64 LE)
const OFFSET_PROTOCOL_FEE_WALLET = 32;

export async function readProtocolFeeWallet(
  connection: Connection,
): Promise<PublicKey> {
  const info = await connection.getAccountInfo(deriveConfig());
  if (!info) throw new Error('Control config PDA not found — wrong cluster?');
  return new PublicKey(info.data.slice(OFFSET_PROTOCOL_FEE_WALLET, OFFSET_PROTOCOL_FEE_WALLET + 32));
}

0..8     ANCHOR_LOG_DISC      sha256("anchor:event")[..8]   = [228, 69,165, 46, 81,203,154, 29]
8..16    TRADE_EVENT_DISC     sha256("event:TradeEvent")[..8] = [189,219,127,211, 78,230, 97,238]
16..48   mint                 pubkey (32)
48..56   solAmount            u64 LE  Buy: post-fee net into AMM. Sell: pre-fee gross out of AMM. See callout below.
56..64   tokenAmount          u64 LE (raw base units moved)
64..65   isBuy                u8     (1 = Buy, 0 = Sell)
65..97   user                 pubkey (32)
97..105  virtualSolReserves   u64 LE (post-trade)
105..113 virtualTokenReserves u64 LE (post-trade)
113..121 realSolReserves      u64 LE (post-trade)
121..129 realTokenReserves    u64 LE (post-trade)
129..137 fee                  u64 LE (total fee taken from the trade)
137..145 creatorFee           u64 LE (creator's slice of `fee`)
145..153 solToUser            u64 LE (Sell only — net SOL credited to the seller)

// Tested with @solana/web3.js@1.x, @solana/spl-token@0.4.x, bs58@5+ (default-export style).
// On bs58@4 swap to: import * as bs58 from 'bs58';
import { Connection, PublicKey } from '@solana/web3.js';
import bs58 from 'bs58';
import { CONTROL_PROGRAM_ID } from './pdas';

// sha256("anchor:event")[..8] — every Anchor self-CPI log starts with this.
const ANCHOR_LOG_DISC = Buffer.from([228, 69, 165, 46, 81, 203, 154, 29]);
// sha256("event:TradeEvent")[..8] — TradeEvent's per-event discriminator.
const TRADE_EVENT_DISC = Buffer.from([189, 219, 127, 211, 78, 230, 97, 238]);
const TRADE_EVENT_LEN = 153;

export interface TradeEvent {
  mint: PublicKey;
  user: PublicKey;
  isBuy: boolean;
  solAmount: bigint;
  tokenAmount: bigint;
  fee: bigint;
  creatorFee: bigint;
  solToUser: bigint;
  virtualSolReserves: bigint;
  virtualTokenReserves: bigint;
  realSolReserves: bigint;
  realTokenReserves: bigint;
}

function decodeTradeEvent(buf: Buffer): TradeEvent {
  if (buf.length !== TRADE_EVENT_LEN) throw new Error(`bad event length: ${buf.length}`);
  if (!buf.slice(0, 8).equals(ANCHOR_LOG_DISC))   throw new Error('not an anchor self-CPI log');
  if (!buf.slice(8, 16).equals(TRADE_EVENT_DISC)) throw new Error('not a TradeEvent');

  return {
    mint:                 new PublicKey(buf.slice(16, 48)),
    solAmount:            buf.readBigUInt64LE(48),
    tokenAmount:          buf.readBigUInt64LE(56),
    isBuy:                buf[64] === 1,
    user:                 new PublicKey(buf.slice(65, 97)),
    virtualSolReserves:   buf.readBigUInt64LE(97),
    virtualTokenReserves: buf.readBigUInt64LE(105),
    realSolReserves:      buf.readBigUInt64LE(113),
    realTokenReserves:    buf.readBigUInt64LE(121),
    fee:                  buf.readBigUInt64LE(129),
    creatorFee:           buf.readBigUInt64LE(137),
    solToUser:            buf.readBigUInt64LE(145),
  };
}

// Walk the inner instructions emitted by the Control program and return
// every TradeEvent. Most txs have exactly one; batched ones may have more.
export async function parseTradeEvents(
  connection: Connection,
  signature: string,
): Promise<TradeEvent[]> {
  const tx = await connection.getTransaction(signature, {
    commitment: 'confirmed',
    maxSupportedTransactionVersion: 0,
  });
  if (!tx || !tx.meta) throw new Error('Transaction not found or missing meta');
  if (tx.meta.err)    throw new Error(`Transaction failed: ${JSON.stringify(tx.meta.err)}`);

  const staticKeys = tx.transaction.message.getAccountKeys().staticAccountKeys;
  const programIdx = staticKeys.findIndex((k) => k.equals(CONTROL_PROGRAM_ID));
  if (programIdx < 0) return [];

  const events: TradeEvent[] = [];
  for (const innerSet of tx.meta.innerInstructions ?? []) {
    for (const ix of innerSet.instructions) {
      if (ix.programIdIndex !== programIdx) continue;
      const data = Buffer.from(bs58.decode(ix.data));
      if (data.length !== TRADE_EVENT_LEN) continue;
      if (!data.slice(0, 8).equals(ANCHOR_LOG_DISC)) continue;
      events.push(decodeTradeEvent(data));
    }
  }
  return events;
}