validate_trade_quote

Instructions

Args:
    chain_id: Chain ID (1, 10, 56, 100, 137, 8453, 42161)
    input_token_address: Address of token to trade from
    output_token_address: Address of token to trade to  
    input_amount: Amount of input token in wei format

Returns:
    JSON string with trade validation results.

Implementation Reference

• padex.py:1720-1814 (handler)

  The primary handler for the 'validate_trade_quote' MCP tool. Validates trades by checking if the trading pair exists, has liquidity, and if the requested amount does not exceed the maximum spread limit (40% of available liquidity). Returns JSON with validation results.

  async def validate_trade_quote(ctx: Context, chain_id: str, input_token_address: str, output_token_address: str, input_amount: str) -> str:
      """Validate a trade against max spread and liquidity requirements.
      
      Args:
          chain_id: Chain ID (1, 10, 56, 100, 137, 8453, 42161)
          input_token_address: Address of token to trade from
          output_token_address: Address of token to trade to  
          input_amount: Amount of input token in wei format
      
      Returns:
          JSON string with trade validation results.
      """
      try:
          paloma_ctx = ctx.request_context.lifespan_context
          
          if chain_id not in CHAIN_CONFIGS:
              return f"Error: Unsupported chain ID {chain_id}"
          
          config = CHAIN_CONFIGS[chain_id]
          
          # Validate addresses
          if not Web3.is_address(input_token_address):
              return f"Error: Invalid input token address: {input_token_address}"
          
          if not Web3.is_address(output_token_address):
              return f"Error: Invalid output token address: {output_token_address}"
          
          try:
              input_amount_int = int(input_amount)
              if input_amount_int <= 0:
                  raise ValueError("Amount must be positive")
          except ValueError:
              return f"Error: Invalid input amount: {input_amount}"
          
          # Use our Paloma-based quote validation
          try:
              quote_data = await paloma_ctx.palomadex_api.get_quote(
                  input_token_address, output_token_address, chain_id
              )
              
              if not quote_data.get('exist', False):
                  return json.dumps({
                      "valid": False,
                      "reason": "Trading pair does not exist",
                      "chain": config.name,
                      "chain_id": config.chain_id
                  }, indent=2)
              
              if quote_data.get('empty', True):
                  return json.dumps({
                      "valid": False,
                      "reason": "Pool has no liquidity",
                      "chain": config.name,
                      "chain_id": config.chain_id
                  }, indent=2)
              
              # Check against max spread (40% limit)
              available_liquidity = int(quote_data.get('amount0', '0'))
              max_trade_amount = int(available_liquidity * MAX_SPREAD) if available_liquidity > 0 else 0
              
              if input_amount_int > max_trade_amount:
                  return json.dumps({
                      "valid": False,
                      "reason": f"Amount exceeds max spread limit ({MAX_SPREAD*100}%)",
                      "max_amount": str(max_trade_amount),
                      "requested_amount": input_amount,
                      "chain": config.name,
                      "chain_id": config.chain_id
                  }, indent=2)
              
              # Trade is valid
              return json.dumps({
                  "valid": True,
                  "available_liquidity": str(available_liquidity),
                  "max_trade_amount": str(max_trade_amount),
                  "requested_amount": input_amount,
                  "spread_check": "passed",
                  "chain": config.name,
                  "chain_id": config.chain_id,
                  "trader_contract": TRADER_ADDRESSES.get(chain_id, "Not configured")
              }, indent=2)
              
          except Exception as api_error:
              logger.error(f"Quote validation failed: {api_error}")
              return json.dumps({
                  "valid": False,
                  "reason": f"Quote validation failed: {str(api_error)}",
                  "chain": config.name,
                  "chain_id": config.chain_id
              }, indent=2)
          
      except Exception as e:
          logger.error(f"Error validating trade quote: {e}")
          return f"Error validating trade quote: {str(e)}"

• padex.py:473-485 (helper)

  Helper method in PalomaDEXAPI class called by validate_trade_quote to retrieve liquidity quote data (amount0, exist, empty flags). Currently uses mock data.

  async def get_quote(self, token0: str, token1: str, chain_id: str) -> Dict:
      """Get quote for trade validation."""
      try:
          # Mock liquidity check
          return {
              "amount0": "1000000000000000000000000",  # 1M tokens
              "exist": True,
              "empty": False
          }
      except Exception as e:
          logger.error(f"Error in quote: {e}")
          return {"exist": False, "empty": True}

• padex.py:1720-1720 (registration)

  MCP tool registration decorator @mcp.tool() applied to the validate_trade_quote handler function.

  async def validate_trade_quote(ctx: Context, chain_id: str, input_token_address: str, output_token_address: str, input_amount: str) -> str: