Anala

        let cpi_accounts = Transfer {            from: ctx.accounts.user_token_account.to_account_info(),            to: ctx.accounts.collateral_vault.to_account_info(),            authority: ctx.accounts.user.to_account_info(),        };        let cpi_program = ctx.accounts.token_program.to_account_info();        let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);        token::transfer(cpi_ctx, amount)?;         // Update position        let position = &mut ctx.accounts.user_position;        if position.owner == Pubkey::default() {            position.owner = ctx.accounts.user.key();            position.pool = ctx.accounts.lending_pool.key();            position.collateral_amount = 0;            position.borrowed_amount = 0;            position.borrowed_at = 0;            position.last_interest_update = Clock::get()?.unix_timestamp;            position.bump = ctx.bumps.user_position;        }        position.collateral_amount = position.collateral_amount.checked_add(amount)            .ok_or(ErrorCode::Overflow)?;         // Update pool

1. Line 91 let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);: Makes a cross-program invocation into another program.
2. Line 92 token::transfer(cpi_ctx, amount)?;: An SPL token transfer through the Token Program.
3. Line 102 position.last_interest_update = Clock::get()?.unix_timestamp;: Reads on-chain time from the Clock sysvar.
4. Line 103 position.bump = ctx.bumps.user_position;: Uses the bump seed, the extra byte that pushes the derived address off the ed25519 curve.
5. Line 105 position.collateral_amount = position.collateral_amount.checked_add(amount): Uses checked arithmetic so overflow fails instead of wrapping.

    OPENAI: process.env.NEXT_PUBLIC_OPENAI_MINT || '',    SPACEX: process.env.NEXT_PUBLIC_SPACEX_MINT || '',  };} function poolPda(collateralMint: PublicKey): PublicKey {  return PublicKey.findProgramAddressSync(    [Buffer.from('lending_pool'), collateralMint.toBuffer()],    PROGRAM_ID,  )[0];} async function send(connection: Connection, wallet: Keypair, ix: TransactionInstruction): Promise<string> {  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();  const tx = new Transaction({ feePayer: wallet.publicKey, blockhash, lastValidBlockHeight }).add(ix);  const sig = await connection.sendTransaction(tx, [wallet], { preflightCommitment: 'confirmed' });  await connection.confirmTransaction({ signature: sig, blockhash, lastValidBlockHeight }, 'confirmed');  return sig;} /** Best-effort refreshed LTV (bps), clamped to the on-chain [3000, 7500] bounds. */async function ltvBpsFor(symbol: string): Promise<number | null> {  const withTimeout = <T>(p: Promise<T>, ms: number) =>    Promise.race([p, new Promise<T>((_, r) => setTimeout(() => r(new Error(`timeout after ${ms}ms`)), ms))]);

1. Line 67 return PublicKey.findProgramAddressSync(: Derives a PDA from seeds and the program ID and returns the address with its canonical bump.
2. Line 74 const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();: Fetches a recent blockhash. Transactions expire if it gets too old.
3. Line 76 const sig = await connection.sendTransaction(tx, [wallet], { preflightCommitment: 'confirm: Submits the signed transaction to the cluster.

    return 0; // no ATA yet, or RPC hiccup — treat as zero balance  }} // --- transaction context supplied by the wallet adapter ---export interface WalletCtx {  connection: Connection;  publicKey: PublicKey;  sendTransaction: (tx: Transaction, connection: Connection) => Promise<TransactionSignature>;} async function sendIxs(ctx: WalletCtx, instructions: TransactionInstruction[]): Promise<string> {  const { connection, publicKey, sendTransaction } = ctx;  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();  const tx = new Transaction({ feePayer: publicKey, blockhash, lastValidBlockHeight });  tx.add(...instructions);  const signature = await sendTransaction(tx, connection);  await connection.confirmTransaction({ signature, blockhash, lastValidBlockHeight }, 'confirmed');  return signature;} /** Prepend an ATA-creation instruction when `owner` has no token account for `mint`. */async function ensureAtaIx(  connection: Connection,

1. Line 249 sendTransaction: (tx: Transaction, connection: Connection) => Promise<TransactionSignature: Submits the signed transaction to the cluster.
2. Line 254 const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();: Fetches a recent blockhash. Transactions expire if it gets too old.

): Promise<{ pool: PublicKey; borrowVault: PublicKey; created: boolean }> {  const { pool, collateralVault, borrowVault } = derivePdas(collateralMint);  if (await connection.getAccountInfo(pool)) {    console.log('  pool already initialized:', pool.toBase58());    return { pool, borrowVault, created: false };  }  const data = Buffer.concat([disc('initialize_pool'), u16(ltvBps), u16(interestBps), u64(priceBase)]);  const keys = [    { pubkey: pool, isSigner: false, isWritable: true },    { pubkey: collateralMint, isSigner: false, isWritable: false },    { pubkey: usdcMint, isSigner: false, isWritable: false },    { pubkey: collateralVault, isSigner: false, isWritable: true },    { pubkey: borrowVault, isSigner: false, isWritable: true },    { pubkey: wallet.publicKey, isSigner: true, isWritable: true },    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },    { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },    { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },  ];  const ix = new TransactionInstruction({ programId: PROGRAM_ID, keys, data });  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();  const tx = new Transaction({ feePayer: wallet.publicKey, blockhash, lastValidBlockHeight }).add(ix);  const sig = await connection.sendTransaction(tx, [wallet], { preflightCommitment: 'confirmed' });  await connection.confirmTransaction({ signature: sig, blockhash, lastValidBlockHeight }, 'confirmed');  console.log('  ✓ pool initialized:', pool.toBase58(), 'tx', sig);

1. Line 152 const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();: Fetches a recent blockhash. Transactions expire if it gets too old.
2. Line 154 const sig = await connection.sendTransaction(tx, [wallet], { preflightCommitment: 'confirm: Submits the signed transaction to the cluster.