fix(bot): update token program handling and improve price validation in trading logic

Author: smypmsa

learning-examples/cleanup_accounts.py

@@ -19,6 +19,10 @@
 # Update this address to MINT address of a token you want to close
 MINT_ADDRESS = Pubkey.from_string("9WHpYbqG6LJvfCYfMjvGbyo1wHXgroCrixPb33s2pump")
 
+# Token program for the mint - use TOKEN_PROGRAM for legacy SPL tokens, TOKEN_2022_PROGRAM for Token-2022
+# This must match the actual token's program to derive the correct ATA address
+TOKEN_PROGRAM = SystemAddresses.TOKEN_PROGRAM
+
 
 async def close_account_if_exists(
     client: SolanaClient, wallet: Wallet, account: Pubkey, mint: Pubkey
@@ -41,7 +45,7 @@ async def close_account_if_exists(
                     mint=mint,
                     owner=wallet.pubkey,
                     amount=balance,
-                    program_id=SystemAddresses.TOKEN_PROGRAM,
+                    program_id=TOKEN_PROGRAM,
                 )
             )
             await client.build_and_send_transaction([burn_ix], wallet.keypair)
@@ -54,7 +58,7 @@ async def close_account_if_exists(
                 account=account,
                 dest=wallet.pubkey,
                 owner=wallet.pubkey,
-                program_id=SystemAddresses.TOKEN_PROGRAM,
+                program_id=TOKEN_PROGRAM,
             )
             ix = close_account(close_params)
 
@@ -78,7 +82,7 @@ async def main():
         wallet = Wallet(PRIVATE_KEY)
 
         # Get user's ATA for the token
-        ata = wallet.get_associated_token_address(MINT_ADDRESS)
+        ata = wallet.get_associated_token_address(MINT_ADDRESS, TOKEN_PROGRAM)
         await close_account_if_exists(client, wallet, ata, MINT_ADDRESS)
 
     except Exception as e:

src/platforms/letsbonk/address_provider.py

@@ -157,7 +157,8 @@ def derive_user_token_account(self, user: Pubkey, mint: Pubkey) -> Pubkey:
         Returns:
             User's associated token account address
         """
-        return get_associated_token_address(user, mint)
+        # Explicitly pass TOKEN_PROGRAM since LetsBonk uses standard SPL tokens
+        return get_associated_token_address(user, mint, SystemAddresses.TOKEN_PROGRAM)
 
     def get_additional_accounts(self, token_info: TokenInfo) -> dict[str, Pubkey]:
         """Get LetsBonk-specific additional accounts needed for trading.

src/platforms/letsbonk/curve_manager.py

@@ -194,14 +194,21 @@ def _decode_pool_state_with_idl(self, data: bytes) -> dict[str, Any]:
         }
 
         # Calculate additional metrics
-        if pool_data["virtual_base"] > 0:
-            pool_data["price_per_token"] = (
-                (pool_data["virtual_quote"] / pool_data["virtual_base"])
-                * (10**TOKEN_DECIMALS)
-                / LAMPORTS_PER_SOL
+        # Validate reserves are positive before calculating price
+        if pool_data["virtual_base"] <= 0:
+            raise ValueError(
+                f"Invalid virtual_base: {pool_data['virtual_base']} - cannot calculate price"
             )
-        else:
-            pool_data["price_per_token"] = 0
+        if pool_data["virtual_quote"] <= 0:
+            raise ValueError(
+                f"Invalid virtual_quote: {pool_data['virtual_quote']} - cannot calculate price"
+            )
+
+        pool_data["price_per_token"] = (
+            (pool_data["virtual_quote"] / pool_data["virtual_base"])
+            * (10**TOKEN_DECIMALS)
+            / LAMPORTS_PER_SOL
+        )
 
         logger.debug(
             f"Decoded pool state: virtual_base={pool_data['virtual_base']}, "

src/platforms/pumpfun/curve_manager.py

@@ -194,17 +194,24 @@ def _decode_curve_state_with_idl(self, data: bytes) -> dict[str, Any]:
         }
 
         # Calculate additional metrics
-        if curve_data["virtual_token_reserves"] > 0:
-            curve_data["price_per_token"] = (
-                (
-                    curve_data["virtual_sol_reserves"]
-                    / curve_data["virtual_token_reserves"]
-                )
-                * (10**TOKEN_DECIMALS)
-                / LAMPORTS_PER_SOL
+        # Validate reserves are positive before calculating price
+        if curve_data["virtual_token_reserves"] <= 0:
+            raise ValueError(
+                f"Invalid virtual_token_reserves: {curve_data['virtual_token_reserves']} - cannot calculate price"
             )
-        else:
-            curve_data["price_per_token"] = 0
+        if curve_data["virtual_sol_reserves"] <= 0:
+            raise ValueError(
+                f"Invalid virtual_sol_reserves: {curve_data['virtual_sol_reserves']} - cannot calculate price"
+            )
+
+        curve_data["price_per_token"] = (
+            (
+                curve_data["virtual_sol_reserves"]
+                / curve_data["virtual_token_reserves"]
+            )
+            * (10**TOKEN_DECIMALS)
+            / LAMPORTS_PER_SOL
+        )
 
         # Add convenience decimal fields
         curve_data["token_reserves_decimal"] = (

src/platforms/pumpfun/event_parser.py

@@ -110,9 +110,10 @@ def parse_token_creation_from_logs(
 
             # First, collect all Program data entries and note when Create instruction happens
             for i, log in enumerate(logs):
-                if "Program log: Instruction: Create" in log:
+                if "Program log: Instruction: Create" in log or "Program log: Instruction: Create_v2" in log:
                     create_instruction_found = True
-                    logger.info(f"📝 Found Create instruction at log index {i}")
+                    instruction_type = "Create_v2" if "Create_v2" in log else "Create"
+                    logger.info(f"📝 Found {instruction_type} instruction at log index {i}")
                 elif "Program data:" in log:
                     # Extract base64 encoded event data
                     encoded_data = log.split("Program data: ")[1].strip()
@@ -122,7 +123,7 @@ def parse_token_creation_from_logs(
                     )
 
             if not create_instruction_found:
-                logger.info("❌ No Create instruction found in logs")
+                logger.info("❌ No Create or Create_v2 instruction found in logs")
                 return None
 
             if not program_data_entries:

src/platforms/pumpfun/instruction_builder.py

@@ -67,19 +67,13 @@ async def build_buy_instruction(
         # Get all required accounts (includes mayhem-mode-aware fee recipient)
         accounts_info = address_provider.get_buy_instruction_accounts(token_info, user)
 
-        # Determine token program to use (default to TOKEN_2022_PROGRAM per pump.fun's migration to create_v2)
-        token_program_id = (
-            token_info.token_program_id
-            if token_info.token_program_id
-            else SystemAddresses.TOKEN_2022_PROGRAM
-        )
-
         # 1. Create idempotent ATA instruction (won't fail if ATA already exists)
+        # Use token_program from accounts_info to ensure AddressProvider controls program selection
         ata_instruction = create_idempotent_associated_token_account(
             user,  # payer
             user,  # owner
             token_info.mint,  # mint
-            token_program_id,  # token program (dynamic for token2022 support)
+            accounts_info["token_program"],  # token program from AddressProvider
         )
         instructions.append(ata_instruction)
 

src/trading/platform_aware.py

@@ -68,12 +68,18 @@ async def execute(self, token_info: TokenInfo) -> TradeResult:
                 # Regular behavior with RPC call
                 # Fetch pool state to get price and mayhem mode status
                 pool_state = await curve_manager.get_pool_state(pool_address)
-                token_price_sol = pool_state.get("price_per_token", 0)
+                token_price_sol = pool_state.get("price_per_token")
+
+                # Validate price_per_token is present and positive
+                if token_price_sol is None or token_price_sol <= 0:
+                    raise ValueError(
+                        f"Invalid price_per_token: {token_price_sol} for pool {pool_address} "
+                        f"(mint: {token_info.mint}) - cannot execute buy with zero/invalid price"
+                    )
+
                 # Set is_mayhem_mode from bonding curve state
                 token_info.is_mayhem_mode = pool_state.get("is_mayhem_mode", False)
-                token_amount = (
-                    self.amount / token_price_sol if token_price_sol > 0 else 0
-                )
+                token_amount = self.amount / token_price_sol
 
             # Calculate minimum token amount with slippage
             minimum_token_amount = token_amount * (1 - self.slippage)
@@ -231,7 +237,15 @@ async def execute(self, token_info: TokenInfo) -> TradeResult:
             pool_address = self._get_pool_address(token_info, address_provider)
             # Fetch pool state to get price and mayhem mode status
             pool_state = await curve_manager.get_pool_state(pool_address)
-            token_price_sol = pool_state.get("price_per_token", 0)
+            token_price_sol = pool_state.get("price_per_token")
+
+            # Validate price_per_token is present and positive
+            if token_price_sol is None or token_price_sol <= 0:
+                raise ValueError(
+                    f"Invalid price_per_token: {token_price_sol} for pool {pool_address} "
+                    f"(mint: {token_info.mint}) - cannot execute sell with zero/invalid price"
+                )
+
             # Set is_mayhem_mode from bonding curve state
             token_info.is_mayhem_mode = pool_state.get("is_mayhem_mode", False)