feat(trading): update account data size limit and enhance price calculations

Author: smypmsa

bots/bot-sniper-1-geyser.yaml

@@ -61,8 +61,9 @@ compute_units:
   # Reduces CU cost from 16k to ~128 CU by limiting loaded account data.
   # Default is 64MB (16k CU). Setting to 512KB significantly reduces overhead.
   # Note: Savings don't show in "consumed CU" but improve tx priority/cost.
+  # Note (Nov 23, 2025): with data size set to 512KB, transactions fail - increasing to 12.5MB resolves the issue.
   # Reference: https://www.anza.xyz/blog/cu-optimization-with-setloadedaccountsdatasizelimit
-  account_data_size: 512_000 # 512KB limit
+  account_data_size: 12_500_000
 
 # Filters for token selection
 filters:

bots/bot-sniper-2-logs.yaml

@@ -24,7 +24,7 @@ geyser:
 # Control trade execution: amount of SOL per trade and acceptable price deviation
 trade:
   buy_amount: 0.0001 # Amount of SOL to spend when buying (in SOL)
-  buy_slippage: 0.2 # Maximum acceptable price deviation (0.2 = 20%)
+  buy_slippage: 0.3 # Maximum acceptable price deviation (0.3 = 30%)
   sell_slippage: 0.3
 
   # Exit strategy configuration
@@ -61,8 +61,9 @@ compute_units:
   # Reduces CU cost from 16k to ~128 CU by limiting loaded account data.
   # Default is 64MB (16k CU). Setting to 512KB significantly reduces overhead.
   # Note: Savings don't show in "consumed CU" but improve tx priority/cost.
+  # Note (Nov 23, 2025): with data size set to 512KB, transactions fail - increasing to 12.5MB resolves the issue.
   # Reference: https://www.anza.xyz/blog/cu-optimization-with-setloadedaccountsdatasizelimit
-  account_data_size: 512_000 # 512KB limit
+  account_data_size: 12_500_000
 
 # Filters for token selection
 filters:

bots/bot-sniper-3-blocks.yaml

@@ -61,8 +61,9 @@ compute_units:
   # Reduces CU cost from 16k to ~128 CU by limiting loaded account data.
   # Default is 64MB (16k CU). Setting to 512KB significantly reduces overhead.
   # Note: Savings don't show in "consumed CU" but improve tx priority/cost.
+  # Note (Nov 23, 2025): with data size set to 512KB, transactions fail - increasing to 12.5MB resolves the issue.
   # Reference: https://www.anza.xyz/blog/cu-optimization-with-setloadedaccountsdatasizelimit
-  account_data_size: 512_000 # 512KB limit
+  account_data_size: 12_500_000
 
 # Filters for token selection
 filters:

bots/bot-sniper-4-pp.yaml

@@ -59,8 +59,9 @@ compute_units:
   # Reduces CU cost from 16k to ~128 CU by limiting loaded account data.
   # Default is 64MB (16k CU). Setting to 512KB significantly reduces overhead.
   # Note: Savings don't show in "consumed CU" but improve tx priority/cost.
+  # Note (Nov 23, 2025): with data size set to 512KB, transactions fail - increasing to 12.5MB resolves the issue.
   # Reference: https://www.anza.xyz/blog/cu-optimization-with-setloadedaccountsdatasizelimit
-  account_data_size: 512_000 # 512KB limit
+  account_data_size: 12_500_000
 
 # Filters for token selection
 filters:

src/core/client.py

@@ -284,6 +284,118 @@ async def get_transaction_token_balance(
         Returns:
             Token balance (raw amount) after transaction, or None if not found
         """
+        result = await self._get_transaction_result(signature)
+        if not result:
+            return None
+
+        meta = result.get("meta", {})
+        post_token_balances = meta.get("postTokenBalances", [])
+
+        user_str = str(user_pubkey)
+        mint_str = str(mint)
+
+        for balance in post_token_balances:
+            if balance.get("owner") == user_str and balance.get("mint") == mint_str:
+                ui_amount = balance.get("uiTokenAmount", {})
+                amount_str = ui_amount.get("amount")
+                if amount_str:
+                    return int(amount_str)
+
+        return None
+
+    async def get_buy_transaction_details(
+        self, signature: str, mint: Pubkey, sol_destination: Pubkey
+    ) -> tuple[int | None, int | None]:
+        """Get actual tokens received and SOL spent from a buy transaction.
+
+        Uses preBalances/postBalances to find exact SOL transferred to the
+        pool/curve and pre/post token balance diff to find tokens received.
+
+        Args:
+            signature: Transaction signature
+            mint: Token mint address
+            sol_destination: Address where SOL is sent (bonding curve for pump.fun,
+                           quote_vault for letsbonk)
+
+        Returns:
+            Tuple of (tokens_received_raw, sol_spent_lamports), or (None, None)
+        """
+        result = await self._get_transaction_result(signature)
+        if not result:
+            return None, None
+
+        meta = result.get("meta", {})
+        mint_str = str(mint)
+
+        # Get tokens received from pre/post token balance diff
+        # This works for Token2022 where owner might be different
+        tokens_received = None
+        pre_token_balances = meta.get("preTokenBalances", [])
+        post_token_balances = meta.get("postTokenBalances", [])
+
+        # Build lookup by account index
+        pre_by_idx = {b.get("accountIndex"): b for b in pre_token_balances}
+        post_by_idx = {b.get("accountIndex"): b for b in post_token_balances}
+
+        # Find positive token diff for our mint (user receiving tokens)
+        all_indices = set(pre_by_idx.keys()) | set(post_by_idx.keys())
+        for idx in all_indices:
+            pre = pre_by_idx.get(idx)
+            post = post_by_idx.get(idx)
+
+            # Check if this is our mint
+            balance_mint = (post or pre).get("mint", "")
+            if balance_mint != mint_str:
+                continue
+
+            pre_amount = (
+                int(pre.get("uiTokenAmount", {}).get("amount", 0)) if pre else 0
+            )
+            post_amount = (
+                int(post.get("uiTokenAmount", {}).get("amount", 0)) if post else 0
+            )
+            diff = post_amount - pre_amount
+
+            # Positive diff means tokens received (not the bonding curve's negative)
+            if diff > 0:
+                tokens_received = diff
+                logger.info(f"Tokens received from tx: {tokens_received}")
+                break
+
+        # Get SOL spent from preBalances/postBalances at sol_destination
+        sol_destination_str = str(sol_destination)
+        sol_spent = None
+        pre_balances = meta.get("preBalances", [])
+        post_balances = meta.get("postBalances", [])
+        account_keys = (
+            result.get("transaction", {}).get("message", {}).get("accountKeys", [])
+        )
+
+        for i, key in enumerate(account_keys):
+            key_str = key if isinstance(key, str) else key.get("pubkey", "")
+            if key_str == sol_destination_str:
+                if i < len(pre_balances) and i < len(post_balances):
+                    sol_spent = post_balances[i] - pre_balances[i]
+                    if sol_spent > 0:
+                        logger.info(f"SOL to pool/curve: {sol_spent} lamports")
+                    else:
+                        logger.warning(
+                            f"SOL destination balance change not positive: {sol_spent}"
+                        )
+                        sol_spent = None
+                break
+
+        return tokens_received, sol_spent
+
+    async def _get_transaction_result(self, signature: str) -> dict | None:
+        """Fetch transaction result from RPC.
+
+        Args:
+            signature: Transaction signature
+
+        Returns:
+            Transaction result dict or None
+        """
         body = {
             "jsonrpc": "2.0",
             "id": 1,
@@ -303,20 +415,7 @@ async def get_transaction_token_balance(
         if not result or "meta" not in result:
             return None
 
-        meta = result["meta"]
-        post_token_balances = meta.get("postTokenBalances", [])
-
-        user_str = str(user_pubkey)
-        mint_str = str(mint)
-
-        for balance in post_token_balances:
-            if balance.get("owner") == user_str and balance.get("mint") == mint_str:
-                ui_amount = balance.get("uiTokenAmount", {})
-                amount_str = ui_amount.get("amount")
-                if amount_str:
-                    return int(amount_str)
-
-        return None
+        return result
 
     async def post_rpc(self, body: dict[str, Any]) -> dict[str, Any] | None:
         """

src/trading/platform_aware.py

@@ -131,22 +131,32 @@ async def execute(self, token_info: TokenInfo) -> TradeResult:
             if success:
                 logger.info(f"Buy transaction confirmed: {tx_signature}")
 
-                # Fetch actual token amount from transaction to handle slippage
-                actual_token_balance = await self.client.get_transaction_token_balance(
-                    str(tx_signature), self.wallet.pubkey, token_info.mint
+                # Fetch actual tokens and SOL spent from transaction
+                # Uses preBalances/postBalances to get exact amounts
+                sol_destination = self._get_sol_destination(
+                    token_info, address_provider
+                )
+                tokens_raw, sol_spent = await self.client.get_buy_transaction_details(
+                    str(tx_signature), token_info.mint, sol_destination
                 )
 
-                if actual_token_balance is not None:
-                    actual_amount = actual_token_balance / 10**TOKEN_DECIMALS
+                if tokens_raw is not None and sol_spent is not None:
+                    actual_amount = tokens_raw / 10**TOKEN_DECIMALS
+                    actual_price = (sol_spent / LAMPORTS_PER_SOL) / actual_amount
                     logger.info(
                         f"Actual tokens received: {actual_amount:.6f} "
                         f"(expected: {token_amount:.6f})"
                     )
+                    logger.info(
+                        f"Actual SOL spent: {sol_spent / LAMPORTS_PER_SOL:.10f} SOL"
+                    )
+                    logger.info(f"Actual price: {actual_price:.10f} SOL/token")
                     token_amount = actual_amount
+                    token_price_sol = actual_price
                 else:
-                    logger.warning(
-                        "Could not fetch actual token balance from tx, "
-                        f"using estimated: {token_amount:.6f}"
+                    raise ValueError(
+                        f"Failed to parse transaction details: tokens={tokens_raw}, "
+                        f"sol_spent={sol_spent}"
                     )
 
                 return TradeResult(
@@ -184,6 +194,42 @@ def _get_pool_address(
         # Fallback to deriving the address using platform provider
         return address_provider.derive_pool_address(token_info.mint)
 
+    def _get_sol_destination(
+        self, token_info: TokenInfo, address_provider: AddressProvider
+    ) -> Pubkey:
+        """Get the address where SOL is sent during a buy transaction.
+
+        For pump.fun: SOL goes to the bonding curve
+        For letsbonk: SOL goes to the quote_vault (WSOL vault)
+
+        Args:
+            token_info: Token information
+            address_provider: Platform-specific address provider
+
+        Returns:
+            Address where SOL is transferred during buy
+
+        Raises:
+            NotImplementedError: If platform SOL destination is not implemented
+        """
+        if token_info.platform == Platform.PUMP_FUN:
+            # For pump.fun, SOL goes directly to bonding curve
+            if hasattr(token_info, "bonding_curve") and token_info.bonding_curve:
+                return token_info.bonding_curve
+            return address_provider.derive_pool_address(token_info.mint)
+        elif token_info.platform == Platform.LETS_BONK:
+            # For letsbonk, SOL goes to quote_vault (WSOL vault)
+            if hasattr(token_info, "quote_vault") and token_info.quote_vault:
+                return token_info.quote_vault
+            # Derive quote_vault if not available
+            return address_provider.derive_quote_vault(token_info.mint)
+
+        raise NotImplementedError(
+            f"SOL destination not implemented for platform {token_info.platform.value}. "
+            f"Add platform-specific logic to _get_sol_destination() to specify where "
+            f"SOL is transferred during buy transactions for this platform."
+        )
+
     def _get_cu_override(self, operation: str, platform: Platform) -> int | None:
         """Get compute unit override from configuration.
 
@@ -246,7 +292,7 @@ async def execute(
             )
         if token_price is None or token_price <= 0:
             raise ValueError(
-                "token_price is required for sell operation. "
+                "token_price is required for sell operation and must be positive. "
                 "Pass the price from buy result to avoid RPC delays."
             )
 
@@ -274,20 +320,19 @@ async def execute(
                     error_message="No tokens to sell",
                 )
 
-            # Calculate expected SOL output
+            # Calculate expected SOL output with slippage protection
             expected_sol_output = token_balance_decimal * token_price_sol
-
-            # Calculate minimum SOL output with slippage protection
-            min_sol_output = int(
-                (expected_sol_output * (1 - self.slippage)) * LAMPORTS_PER_SOL
+            min_sol_output = max(
+                1,
+                int((expected_sol_output * (1 - self.slippage)) * LAMPORTS_PER_SOL),
             )
-
             logger.info(
                 f"Selling {token_balance_decimal} tokens on {token_info.platform.value}"
             )
-            logger.info(f"Expected SOL output: {expected_sol_output:.8f} SOL")
+            logger.info(f"Expected SOL output: {expected_sol_output:.10f} SOL")
             logger.info(
-                f"Minimum SOL output (with {self.slippage * 100:.1f}% slippage): {min_sol_output / LAMPORTS_PER_SOL:.8f} SOL"
+                f"Minimum SOL output (with {self.slippage * 100:.1f}% slippage): "
+                f"{min_sol_output / LAMPORTS_PER_SOL:.10f} SOL ({min_sol_output} lamports)"
             )
 
             # Build sell instructions using platform-specific builder