@coinbarrel/sdk 1.0.1 → 1.2.0

package/dist/metadata.js

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ * Token Metadata Fetching
+ * Read Metaplex token metadata for CoinBarrel tokens
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetadataPda = getMetadataPda;
+exports.parseMetaplexMetadata = parseMetaplexMetadata;
+exports.getTokenMetadata = getTokenMetadata;
+exports.getTokenMetadataJson = getTokenMetadataJson;
+exports.batchGetTokenMetadata = batchGetTokenMetadata;
+const web3_js_1 = require("@solana/web3.js");
+const constants_js_1 = require("./constants.js");
+// ============= PDA =============
+/**
+ * Derive Metaplex metadata PDA for a token mint
+ */
+function getMetadataPda(mint) {
+    const [pda] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('metadata'), constants_js_1.TOKEN_METADATA_PROGRAM_ID.toBuffer(), mint.toBuffer()], constants_js_1.TOKEN_METADATA_PROGRAM_ID);
+    return pda;
+}
+// ============= Parsing =============
+/**
+ * Read a length-prefixed string from buffer
+ */
+function readLengthPrefixedString(data, offset) {
+    const length = data.readUInt32LE(offset);
+    const start = offset + 4;
+    const end = start + length;
+    const value = data
+        .subarray(start, end)
+        .toString('utf8')
+        .replace(/\0/g, '')
+        .trim();
+    return { value, nextOffset: end };
+}
+/**
+ * Parse Metaplex metadata from raw account data
+ *
+ * Layout:
+ * - key: 1 byte
+ * - update_authority: 32 bytes
+ * - mint: 32 bytes
+ * - name: 4 bytes length + string
+ * - symbol: 4 bytes length + string
+ * - uri: 4 bytes length + string
+ */
+function parseMetaplexMetadata(data) {
+    try {
+        if (!data || data.length < 65)
+            return null;
+        // Skip: key (1) + update_authority (32) + mint (32) = 65 bytes
+        let offset = 1 + 32 + 32;
+        // Name
+        const name = readLengthPrefixedString(data, offset);
+        offset = name.nextOffset;
+        // Symbol
+        const symbol = readLengthPrefixedString(data, offset);
+        offset = symbol.nextOffset;
+        // URI
+        const uri = readLengthPrefixedString(data, offset);
+        return {
+            name: name.value,
+            symbol: symbol.value,
+            uri: uri.value,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// ============= Fetching =============
+/**
+ * Fetch on-chain token metadata from Metaplex
+ *
+ * Returns the name, symbol, and URI stored on-chain.
+ * Use `getTokenMetadataJson` to also fetch the off-chain JSON.
+ *
+ * @example
+ * ```typescript
+ * const metadata = await getTokenMetadata(connection, tokenMint);
+ * if (metadata) {
+ *   console.log(metadata.name);    // "My Token"
+ *   console.log(metadata.symbol);  // "MTK"
+ *   console.log(metadata.uri);     // "https://..."
+ * }
+ * ```
+ */
+async function getTokenMetadata(connection, mint) {
+    try {
+        const metadataPda = getMetadataPda(mint);
+        const accountInfo = await connection.getAccountInfo(metadataPda);
+        if (!accountInfo || !accountInfo.data || accountInfo.data.length === 0) {
+            return null;
+        }
+        return parseMetaplexMetadata(accountInfo.data);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Fetch on-chain Metaplex metadata and then fetch the off-chain JSON pointed to by the URI.
+ */
+async function getTokenMetadataJson(connection, mint, options) {
+    const meta = await getTokenMetadata(connection, mint);
+    if (!meta)
+        return null;
+    const uri = (meta.uri ?? '').replace(/\0/g, '').trim();
+    if (!uri)
+        return { ...meta };
+    try {
+        const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
+        const timeoutMs = options?.timeoutMs;
+        const timeout = controller && typeof timeoutMs === 'number' && timeoutMs > 0
+            ? setTimeout(() => controller.abort(), timeoutMs)
+            : null;
+        const resp = await fetch(uri, {
+            signal: controller?.signal,
+            headers: { accept: 'application/json' },
+        });
+        if (!resp.ok)
+            return { ...meta };
+        const json = (await resp.json());
+        if (timeout)
+            clearTimeout(timeout);
+        // Best-effort map of common social fields
+        const properties = json.properties && typeof json.properties === 'object'
+            ? json.properties
+            : undefined;
+        const extensions = (json.extensions && typeof json.extensions === 'object'
+            ? json.extensions
+            : undefined) ||
+            (properties?.extensions && typeof properties.extensions === 'object'
+                ? properties.extensions
+                : undefined);
+        const twitter = (typeof json.twitter === 'string' && json.twitter) ||
+            (typeof extensions?.twitter === 'string' && extensions.twitter) ||
+            undefined;
+        const telegram = (typeof json.telegram === 'string' && json.telegram) ||
+            (typeof extensions?.telegram === 'string' && extensions.telegram) ||
+            undefined;
+        const website = (typeof json.website === 'string' && json.website) ||
+            (typeof extensions?.website === 'string' && extensions.website) ||
+            undefined;
+        return {
+            ...meta,
+            ...json,
+            // ensure we always surface these normalized keys when available
+            twitter,
+            telegram,
+            website,
+        };
+    }
+    catch {
+        return { ...meta };
+    }
+}
+/**
+ * Batch fetch metadata for multiple tokens
+ *
+ * More efficient than calling getTokenMetadata individually.
+ *
+ * @param connection - Solana RPC connection
+ * @param mints - Array of token mint addresses
+ * @returns Map of mint address string to metadata
+ *
+ * @example
+ * ```typescript
+ * const mints = [mint1, mint2, mint3];
+ * const metadataMap = await batchGetTokenMetadata(connection, mints);
+ *
+ * for (const [mintStr, metadata] of metadataMap) {
+ *   console.log(`${mintStr}: ${metadata?.name}`);
+ * }
+ * ```
+ */
+async function batchGetTokenMetadata(connection, mints) {
+    const results = new Map();
+    if (mints.length === 0) {
+        return results;
+    }
+    // Derive all metadata PDAs
+    const pdas = mints.map((mint) => ({
+        mint,
+        pda: getMetadataPda(mint),
+    }));
+    // Batch fetch all accounts
+    try {
+        const accountInfos = await connection.getMultipleAccountsInfo(pdas.map((p) => p.pda));
+        // Parse each result
+        for (let i = 0; i < pdas.length; i++) {
+            const mintStr = pdas[i].mint.toBase58();
+            const accountInfo = accountInfos[i];
+            if (accountInfo && accountInfo.data && accountInfo.data.length > 0) {
+                const metadata = parseMetaplexMetadata(accountInfo.data);
+                results.set(mintStr, metadata);
+            }
+            else {
+                results.set(mintStr, null);
+            }
+        }
+    }
+    catch {
+        // If batch fails, set all to null
+        for (const { mint } of pdas) {
+            results.set(mint.toBase58(), null);
+        }
+    }
+    return results;
+}

package/dist/pda.js

@@ -1,77 +1,90 @@
+"use strict";
 /**
  * PDA Derivation Helpers
  * All Program Derived Addresses for CoinBarrel AMM
  */
-import { PublicKey } from '@solana/web3.js';
-import { SEEDS, NATIVE_MINT } from './constants.js';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBondingCurvePda = getBondingCurvePda;
+exports.getBondingAuthorityPda = getBondingAuthorityPda;
+exports.getSolEscrowPda = getSolEscrowPda;
+exports.getPoolPda = getPoolPda;
+exports.getPoolAuthorityPda = getPoolAuthorityPda;
+exports.getVaultPda = getVaultPda;
+exports.getPoolWsolVaultPda = getPoolWsolVaultPda;
+exports.getPoolTokenVaultPda = getPoolTokenVaultPda;
+exports.getLpMintPda = getLpMintPda;
+exports.getLpVaultPda = getLpVaultPda;
+exports.getHolderRewardPda = getHolderRewardPda;
+const web3_js_1 = require("@solana/web3.js");
+const constants_js_1 = require("./constants.js");
 // ============= Bonding Curve PDAs =============
 /**
  * Derive bonding curve PDA for a token mint
  */
-export function getBondingCurvePda(mint, programId) {
-    const [pda] = PublicKey.findProgramAddressSync([SEEDS.BONDING, mint.toBuffer()], programId);
+function getBondingCurvePda(mint, programId) {
+    const [pda] = web3_js_1.PublicKey.findProgramAddressSync([constants_js_1.SEEDS.BONDING, mint.toBuffer()], programId);
     return pda;
 }
 /**
  * Derive bonding authority PDA (signs transfers from curve)
  */
-export function getBondingAuthorityPda(bondingCurve, programId) {
-    const [pda] = PublicKey.findProgramAddressSync([SEEDS.BONDING_AUTHORITY, bondingCurve.toBuffer()], programId);
+function getBondingAuthorityPda(bondingCurve, programId) {
+    const [pda] = web3_js_1.PublicKey.findProgramAddressSync([constants_js_1.SEEDS.BONDING_AUTHORITY, bondingCurve.toBuffer()], programId);
     return pda;
 }
 /**
  * Derive SOL escrow PDA for bonding curve
  */
-export function getSolEscrowPda(bondingCurve, programId) {
-    const [pda] = PublicKey.findProgramAddressSync([SEEDS.BONDING_SOL, bondingCurve.toBuffer()], programId);
+function getSolEscrowPda(bondingCurve, programId) {
+    const [pda] = web3_js_1.PublicKey.findProgramAddressSync([constants_js_1.SEEDS.BONDING_SOL, bondingCurve.toBuffer()], programId);
     return pda;
 }
 // ============= AMM Pool PDAs =============
 /**
  * Derive pool PDA for a WSOL <-> Token pair
  */
-export function getPoolPda(tokenMint, programId) {
-    const [pda] = PublicKey.findProgramAddressSync([SEEDS.POOL, NATIVE_MINT.toBuffer(), tokenMint.toBuffer()], programId);
+function getPoolPda(tokenMint, programId) {
+    const [pda] = web3_js_1.PublicKey.findProgramAddressSync([constants_js_1.SEEDS.POOL, constants_js_1.NATIVE_MINT.toBuffer(), tokenMint.toBuffer()], programId);
     return pda;
 }
 /**
  * Derive pool authority PDA (signs transfers from pool vaults)
  */
-export function getPoolAuthorityPda(pool, programId) {
-    const [pda] = PublicKey.findProgramAddressSync([SEEDS.AUTHORITY, pool.toBuffer()], programId);
+function getPoolAuthorityPda(pool, programId) {
+    const [pda] = web3_js_1.PublicKey.findProgramAddressSync([constants_js_1.SEEDS.AUTHORITY, pool.toBuffer()], programId);
     return pda;
 }
 /**
  * Derive vault PDA for a pool + mint
  */
-export function getVaultPda(pool, mint, programId) {
-    const [pda] = PublicKey.findProgramAddressSync([SEEDS.VAULT, pool.toBuffer(), mint.toBuffer()], programId);
+function getVaultPda(pool, mint, programId) {
+    const [pda] = web3_js_1.PublicKey.findProgramAddressSync([constants_js_1.SEEDS.VAULT, pool.toBuffer(), mint.toBuffer()], programId);
     return pda;
 }
 /**
  * Derive WSOL vault PDA for a pool
  */
-export function getPoolWsolVaultPda(pool, programId) {
-    return getVaultPda(pool, NATIVE_MINT, programId);
+function getPoolWsolVaultPda(pool, programId) {
+    return getVaultPda(pool, constants_js_1.NATIVE_MINT, programId);
 }
 /**
  * Derive token vault PDA for a pool
  */
-export function getPoolTokenVaultPda(pool, tokenMint, programId) {
+function getPoolTokenVaultPda(pool, tokenMint, programId) {
     return getVaultPda(pool, tokenMint, programId);
 }
 /**
  * Derive LP mint PDA for a pool
  */
-export function getLpMintPda(pool, programId) {
-    const [pda] = PublicKey.findProgramAddressSync([SEEDS.LP_MINT, pool.toBuffer()], programId);
+function getLpMintPda(pool, programId) {
+    const [pda] = web3_js_1.PublicKey.findProgramAddressSync([constants_js_1.SEEDS.LP_MINT, pool.toBuffer()], programId);
     return pda;
 }
 /**
  * Derive LP vault PDA (holds burned/locked LP tokens)
  */
-export function getLpVaultPda(pool, programId) {
-    const [pda] = PublicKey.findProgramAddressSync([SEEDS.LP_VAULT, pool.toBuffer()], programId);
+function getLpVaultPda(pool, programId) {
+    const [pda] = web3_js_1.PublicKey.findProgramAddressSync([constants_js_1.SEEDS.LP_VAULT, pool.toBuffer()], programId);
     return pda;
 }
 // ============= Holder Reward PDAs =============
@@ -79,8 +92,7 @@ export function getLpVaultPda(pool, programId) {
  * Derive holder reward account PDA for a user + token
  * Used for tracking holder rewards across buys/sells
  */
-export function getHolderRewardPda(tokenMint, holder, programId) {
-    const [pda] = PublicKey.findProgramAddressSync([SEEDS.HOLDER_REWARD, tokenMint.toBuffer(), holder.toBuffer()], programId);
+function getHolderRewardPda(tokenMint, holder, programId) {
+    const [pda] = web3_js_1.PublicKey.findProgramAddressSync([constants_js_1.SEEDS.HOLDER_REWARD, tokenMint.toBuffer(), holder.toBuffer()], programId);
     return pda;
 }
-//# sourceMappingURL=pda.js.map

package/dist/pool.js

@@ -1,12 +1,19 @@
+"use strict";
 /**
  * AMM Pool Operations
  * Swap tokens on graduated AMM pools
  */
-import { SystemProgram, TransactionInstruction, } from "@solana/web3.js";
-import { TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, createAssociatedTokenAccountInstruction, createCloseAccountInstruction, getAccount, } from "@solana/spl-token";
-import { DISCRIMINATORS, NATIVE_MINT } from "./constants.js";
-import { getPoolPda, getPoolAuthorityPda, getHolderRewardPda, } from "./pda.js";
-import { getPoolState, getPoolBalances } from "./accounts.js";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSwapSolToTokenQuote = getSwapSolToTokenQuote;
+exports.getSwapTokenToSolQuote = getSwapTokenToSolQuote;
+exports.buildSwapSolToTokenInstruction = buildSwapSolToTokenInstruction;
+exports.buildSwapTokenToSolInstruction = buildSwapTokenToSolInstruction;
+exports.buildSwapTokenToSolMaxInstruction = buildSwapTokenToSolMaxInstruction;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const constants_js_1 = require("./constants.js");
+const pda_js_1 = require("./pda.js");
+const accounts_js_1 = require("./accounts.js");
 // ============= Buffer Helpers =============
 function writeU64LE(n) {
     const b = Buffer.alloc(8);
@@ -17,9 +24,9 @@ function writeU64LE(n) {
 /**
  * Calculate swap quote for SOL -> Token
  */
-export async function getSwapSolToTokenQuote(connection, tokenMint, solIn, programId) {
-    const balances = await getPoolBalances(connection, tokenMint, programId);
-    const state = await getPoolState(connection, tokenMint, programId);
+async function getSwapSolToTokenQuote(connection, tokenMint, solIn, programId) {
+    const balances = await (0, accounts_js_1.getPoolBalances)(connection, tokenMint, programId);
+    const state = await (0, accounts_js_1.getPoolState)(connection, tokenMint, programId);
     if (!balances || !state)
         return null;
     const { solBalance, tokenBalance } = balances;
@@ -48,9 +55,9 @@ export async function getSwapSolToTokenQuote(connection, tokenMint, solIn, progr
 /**
  * Calculate swap quote for Token -> SOL
  */
-export async function getSwapTokenToSolQuote(connection, tokenMint, tokensIn, programId) {
-    const balances = await getPoolBalances(connection, tokenMint, programId);
-    const state = await getPoolState(connection, tokenMint, programId);
+async function getSwapTokenToSolQuote(connection, tokenMint, tokensIn, programId) {
+    const balances = await (0, accounts_js_1.getPoolBalances)(connection, tokenMint, programId);
+    const state = await (0, accounts_js_1.getPoolState)(connection, tokenMint, programId);
     if (!balances || !state)
         return null;
     const { solBalance, tokenBalance } = balances;
@@ -83,31 +90,31 @@ export async function getSwapTokenToSolQuote(connection, tokenMint, tokensIn, pr
  * IMPORTANT: Fee recipients are read from on-chain state and cannot be modified.
  * The program enforces that fees go to the correct recipients.
  */
-export async function buildSwapSolToTokenInstruction(connection, params, programId) {
+async function buildSwapSolToTokenInstruction(connection, params, programId) {
     const { tokenMint, user, lamportsIn, minimumAmountOut } = params;
     // Fetch pool state to get fee recipients and vault addresses (enforced on-chain)
-    const state = await getPoolState(connection, tokenMint, programId);
+    const state = await (0, accounts_js_1.getPoolState)(connection, tokenMint, programId);
     if (!state) {
         throw new Error("Pool not found for this token");
     }
     // Determine which vault is WSOL and which is the token based on stored mints
-    const isTokenANative = state.tokenAMint.equals(NATIVE_MINT);
+    const isTokenANative = state.tokenAMint.equals(constants_js_1.NATIVE_MINT);
     const wsolVault = isTokenANative ? state.tokenAVault : state.tokenBVault;
     const tokenVault = isTokenANative ? state.tokenBVault : state.tokenAVault;
-    const pool = getPoolPda(tokenMint, programId);
-    const authority = getPoolAuthorityPda(pool, programId);
-    const userTokenAta = getAssociatedTokenAddressSync(tokenMint, user);
-    const holderRewardAccount = getHolderRewardPda(tokenMint, user, programId);
+    const pool = (0, pda_js_1.getPoolPda)(tokenMint, programId);
+    const authority = (0, pda_js_1.getPoolAuthorityPda)(pool, programId);
+    const userTokenAta = (0, spl_token_1.getAssociatedTokenAddressSync)(tokenMint, user);
+    const holderRewardAccount = (0, pda_js_1.getHolderRewardPda)(tokenMint, user, programId);
     const instructions = [];
     // Check if user's token ATA exists, create if needed
     try {
-        await getAccount(connection, userTokenAta);
+        await (0, spl_token_1.getAccount)(connection, userTokenAta);
     }
     catch {
-        instructions.push(createAssociatedTokenAccountInstruction(user, userTokenAta, user, tokenMint));
+        instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(user, userTokenAta, user, tokenMint));
     }
     // Build swap instruction
-    const swapIx = new TransactionInstruction({
+    const swapIx = new web3_js_1.TransactionInstruction({
         programId,
         keys: [
             { pubkey: pool, isWritable: true, isSigner: false },
@@ -121,11 +128,11 @@ export async function buildSwapSolToTokenInstruction(connection, params, program
             // Holder reward account
             { pubkey: holderRewardAccount, isWritable: true, isSigner: false },
             { pubkey: user, isWritable: true, isSigner: true },
-            { pubkey: TOKEN_PROGRAM_ID, isWritable: false, isSigner: false },
-            { pubkey: SystemProgram.programId, isWritable: false, isSigner: false },
+            { pubkey: spl_token_1.TOKEN_PROGRAM_ID, isWritable: false, isSigner: false },
+            { pubkey: web3_js_1.SystemProgram.programId, isWritable: false, isSigner: false },
         ],
         data: Buffer.concat([
-            DISCRIMINATORS.swap_sol_to_token,
+            constants_js_1.DISCRIMINATORS.swap_sol_to_token,
             writeU64LE(lamportsIn),
             writeU64LE(minimumAmountOut),
         ]),
@@ -138,32 +145,32 @@ export async function buildSwapSolToTokenInstruction(connection, params, program
  *
  * IMPORTANT: Fee recipients are read from on-chain state and cannot be modified.
  */
-export async function buildSwapTokenToSolInstruction(connection, params, programId) {
+async function buildSwapTokenToSolInstruction(connection, params, programId) {
     const { tokenMint, user, amountIn, minimumLamportsOut } = params;
     // Fetch pool state to get fee recipients and vault addresses (enforced on-chain)
-    const state = await getPoolState(connection, tokenMint, programId);
+    const state = await (0, accounts_js_1.getPoolState)(connection, tokenMint, programId);
     if (!state) {
         throw new Error("Pool not found for this token");
     }
     // Determine which vault is WSOL and which is the token based on stored mints
-    const isTokenANative = state.tokenAMint.equals(NATIVE_MINT);
+    const isTokenANative = state.tokenAMint.equals(constants_js_1.NATIVE_MINT);
     const wsolVault = isTokenANative ? state.tokenAVault : state.tokenBVault;
     const tokenVault = isTokenANative ? state.tokenBVault : state.tokenAVault;
-    const pool = getPoolPda(tokenMint, programId);
-    const authority = getPoolAuthorityPda(pool, programId);
-    const userTokenAta = getAssociatedTokenAddressSync(tokenMint, user);
-    const userWsolAta = getAssociatedTokenAddressSync(NATIVE_MINT, user);
-    const holderRewardAccount = getHolderRewardPda(tokenMint, user, programId);
+    const pool = (0, pda_js_1.getPoolPda)(tokenMint, programId);
+    const authority = (0, pda_js_1.getPoolAuthorityPda)(pool, programId);
+    const userTokenAta = (0, spl_token_1.getAssociatedTokenAddressSync)(tokenMint, user);
+    const userWsolAta = (0, spl_token_1.getAssociatedTokenAddressSync)(constants_js_1.NATIVE_MINT, user);
+    const holderRewardAccount = (0, pda_js_1.getHolderRewardPda)(tokenMint, user, programId);
     const instructions = [];
     // Create WSOL ATA if needed (for receiving output)
     try {
-        await getAccount(connection, userWsolAta);
+        await (0, spl_token_1.getAccount)(connection, userWsolAta);
     }
     catch {
-        instructions.push(createAssociatedTokenAccountInstruction(user, userWsolAta, user, NATIVE_MINT));
+        instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(user, userWsolAta, user, constants_js_1.NATIVE_MINT));
     }
     // Build swap instruction
-    const swapIx = new TransactionInstruction({
+    const swapIx = new web3_js_1.TransactionInstruction({
         programId,
         keys: [
             { pubkey: pool, isWritable: true, isSigner: false },
@@ -178,49 +185,49 @@ export async function buildSwapTokenToSolInstruction(connection, params, program
             // Holder reward account
             { pubkey: holderRewardAccount, isWritable: true, isSigner: false },
             { pubkey: user, isWritable: true, isSigner: true },
-            { pubkey: TOKEN_PROGRAM_ID, isWritable: false, isSigner: false },
-            { pubkey: SystemProgram.programId, isWritable: false, isSigner: false },
+            { pubkey: spl_token_1.TOKEN_PROGRAM_ID, isWritable: false, isSigner: false },
+            { pubkey: web3_js_1.SystemProgram.programId, isWritable: false, isSigner: false },
         ],
         data: Buffer.concat([
-            DISCRIMINATORS.swap_token_to_sol,
+            constants_js_1.DISCRIMINATORS.swap_token_to_sol,
             writeU64LE(amountIn),
             writeU64LE(minimumLamportsOut),
         ]),
     });
     instructions.push(swapIx);
     // Close WSOL account to unwrap to SOL
-    instructions.push(createCloseAccountInstruction(userWsolAta, user, user));
+    instructions.push((0, spl_token_1.createCloseAccountInstruction)(userWsolAta, user, user));
     return instructions;
 }
 /**
  * Build swap_token_to_sol_max instruction (sell entire balance)
  */
-export async function buildSwapTokenToSolMaxInstruction(connection, params, programId) {
+async function buildSwapTokenToSolMaxInstruction(connection, params, programId) {
     const { tokenMint, user } = params;
     // Fetch pool state to get fee recipients and vault addresses (enforced on-chain)
-    const state = await getPoolState(connection, tokenMint, programId);
+    const state = await (0, accounts_js_1.getPoolState)(connection, tokenMint, programId);
     if (!state) {
         throw new Error("Pool not found for this token");
     }
     // Determine which vault is WSOL and which is the token based on stored mints
-    const isTokenANative = state.tokenAMint.equals(NATIVE_MINT);
+    const isTokenANative = state.tokenAMint.equals(constants_js_1.NATIVE_MINT);
     const wsolVault = isTokenANative ? state.tokenAVault : state.tokenBVault;
     const tokenVault = isTokenANative ? state.tokenBVault : state.tokenAVault;
-    const pool = getPoolPda(tokenMint, programId);
-    const authority = getPoolAuthorityPda(pool, programId);
-    const userTokenAta = getAssociatedTokenAddressSync(tokenMint, user);
-    const userWsolAta = getAssociatedTokenAddressSync(NATIVE_MINT, user);
-    const holderRewardAccount = getHolderRewardPda(tokenMint, user, programId);
+    const pool = (0, pda_js_1.getPoolPda)(tokenMint, programId);
+    const authority = (0, pda_js_1.getPoolAuthorityPda)(pool, programId);
+    const userTokenAta = (0, spl_token_1.getAssociatedTokenAddressSync)(tokenMint, user);
+    const userWsolAta = (0, spl_token_1.getAssociatedTokenAddressSync)(constants_js_1.NATIVE_MINT, user);
+    const holderRewardAccount = (0, pda_js_1.getHolderRewardPda)(tokenMint, user, programId);
     const instructions = [];
     // Create WSOL ATA if needed (for receiving output)
     try {
-        await getAccount(connection, userWsolAta);
+        await (0, spl_token_1.getAccount)(connection, userWsolAta);
     }
     catch {
-        instructions.push(createAssociatedTokenAccountInstruction(user, userWsolAta, user, NATIVE_MINT));
+        instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(user, userWsolAta, user, constants_js_1.NATIVE_MINT));
     }
     // Build swap max instruction
-    const swapMaxIx = new TransactionInstruction({
+    const swapMaxIx = new web3_js_1.TransactionInstruction({
         programId,
         keys: [
             { pubkey: pool, isWritable: true, isSigner: false },
@@ -235,14 +242,13 @@ export async function buildSwapTokenToSolMaxInstruction(connection, params, prog
             // Holder reward account
             { pubkey: holderRewardAccount, isWritable: true, isSigner: false },
             { pubkey: user, isWritable: true, isSigner: true },
-            { pubkey: TOKEN_PROGRAM_ID, isWritable: false, isSigner: false },
-            { pubkey: SystemProgram.programId, isWritable: false, isSigner: false },
+            { pubkey: spl_token_1.TOKEN_PROGRAM_ID, isWritable: false, isSigner: false },
+            { pubkey: web3_js_1.SystemProgram.programId, isWritable: false, isSigner: false },
         ],
-        data: DISCRIMINATORS.swap_token_to_sol_max,
+        data: constants_js_1.DISCRIMINATORS.swap_token_to_sol_max,
     });
     instructions.push(swapMaxIx);
     // Close WSOL account to unwrap to SOL
-    instructions.push(createCloseAccountInstruction(userWsolAta, user, user));
+    instructions.push((0, spl_token_1.createCloseAccountInstruction)(userWsolAta, user, user));
     return instructions;
 }
-//# sourceMappingURL=pool.js.map

package/dist/rewards.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Holder Rewards
+ * Claim accumulated holder rewards from bonding curves and AMM pools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildClaimHolderRewardsCurveInstruction = buildClaimHolderRewardsCurveInstruction;
+exports.buildClaimHolderRewardsInstruction = buildClaimHolderRewardsInstruction;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const constants_js_1 = require("./constants.js");
+const pda_js_1 = require("./pda.js");
+const accounts_js_1 = require("./accounts.js");
+// ============= Claim from Bonding Curve =============
+/**
+ * Build claim_holder_rewards_curve instruction
+ *
+ * Claims accumulated holder rewards from a bonding curve.
+ * Rewards are paid in SOL directly to the holder's wallet.
+ */
+async function buildClaimHolderRewardsCurveInstruction(connection, params, programId) {
+    const { tokenMint, holder } = params;
+    // Derive PDAs
+    const bondingCurve = (0, pda_js_1.getBondingCurvePda)(tokenMint, programId);
+    const solEscrow = (0, pda_js_1.getSolEscrowPda)(bondingCurve, programId);
+    const holderTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(tokenMint, holder);
+    const holderRewardAccount = (0, pda_js_1.getHolderRewardPda)(tokenMint, holder, programId);
+    const claimIx = new web3_js_1.TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: bondingCurve, isWritable: true, isSigner: false },
+            { pubkey: tokenMint, isWritable: false, isSigner: false },
+            { pubkey: solEscrow, isWritable: true, isSigner: false },
+            { pubkey: holderTokenAccount, isWritable: false, isSigner: false },
+            { pubkey: holderRewardAccount, isWritable: true, isSigner: false },
+            { pubkey: holder, isWritable: true, isSigner: true },
+            { pubkey: web3_js_1.SystemProgram.programId, isWritable: false, isSigner: false },
+        ],
+        data: constants_js_1.DISCRIMINATORS.claim_holder_rewards_curve,
+    });
+    return [claimIx];
+}
+// ============= Claim from AMM Pool =============
+/**
+ * Build claim_holder_rewards instruction
+ *
+ * Claims accumulated holder rewards from an AMM pool (post-graduation).
+ * Rewards are paid in WSOL which is then unwrapped to SOL.
+ */
+async function buildClaimHolderRewardsInstruction(connection, params, programId) {
+    const { tokenMint, holder } = params;
+    // Fetch pool state
+    const state = await (0, accounts_js_1.getPoolState)(connection, tokenMint, programId);
+    if (!state) {
+        throw new Error('Pool not found for this token');
+    }
+    // Derive PDAs
+    const pool = (0, pda_js_1.getPoolPda)(tokenMint, programId);
+    const authority = (0, pda_js_1.getPoolAuthorityPda)(pool, programId);
+    const holderTokenAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(tokenMint, holder);
+    const holderRewardAccount = (0, pda_js_1.getHolderRewardPda)(tokenMint, holder, programId);
+    const holderWsolAccount = (0, spl_token_1.getAssociatedTokenAddressSync)(constants_js_1.NATIVE_MINT, holder);
+    // Determine which vault is which
+    const isTokenANative = state.tokenAMint.equals(constants_js_1.NATIVE_MINT);
+    const solVault = isTokenANative ? state.tokenAVault : state.tokenBVault;
+    const tokenVault = isTokenANative ? state.tokenBVault : state.tokenAVault;
+    const instructions = [];
+    // Create WSOL ATA if needed
+    try {
+        await (0, spl_token_1.getAccount)(connection, holderWsolAccount);
+    }
+    catch {
+        instructions.push((0, spl_token_1.createAssociatedTokenAccountInstruction)(holder, holderWsolAccount, holder, constants_js_1.NATIVE_MINT));
+    }
+    const claimIx = new web3_js_1.TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: pool, isWritable: true, isSigner: false },
+            { pubkey: tokenMint, isWritable: false, isSigner: false },
+            { pubkey: state.lpMint, isWritable: false, isSigner: false },
+            { pubkey: tokenVault, isWritable: false, isSigner: false },
+            { pubkey: solVault, isWritable: true, isSigner: false },
+            { pubkey: holderTokenAccount, isWritable: false, isSigner: false },
+            { pubkey: holderWsolAccount, isWritable: true, isSigner: false },
+            { pubkey: holderRewardAccount, isWritable: true, isSigner: false },
+            { pubkey: authority, isWritable: false, isSigner: false },
+            { pubkey: holder, isWritable: true, isSigner: true },
+            { pubkey: spl_token_1.TOKEN_PROGRAM_ID, isWritable: false, isSigner: false },
+            { pubkey: web3_js_1.SystemProgram.programId, isWritable: false, isSigner: false },
+        ],
+        data: constants_js_1.DISCRIMINATORS.claim_holder_rewards,
+    });
+    instructions.push(claimIx);
+    // Close WSOL account to unwrap to SOL
+    instructions.push((0, spl_token_1.createCloseAccountInstruction)(holderWsolAccount, holder, holder));
+    return instructions;
+}