diff --git a/hummingbot/client/command/config_command.py b/hummingbot/client/command/config_command.py
index 2e145380a5..2b6a7b178a 100644
--- a/hummingbot/client/command/config_command.py
+++ b/hummingbot/client/command/config_command.py
@@ -45,12 +45,7 @@
                              "send_error_logs",
                              "script_enabled",
                              "script_file_path",
-                             "manual_gas_price",
                              "ethereum_chain_name",
-                             "ethgasstation_gas_enabled",
-                             "ethgasstation_api_key",
-                             "ethgasstation_gas_level",
-                             "ethgasstation_refresh_time",
                              "gateway_enabled",
                              "gateway_cert_passphrase",
                              "gateway_api_host",
diff --git a/hummingbot/client/command/start_command.py b/hummingbot/client/command/start_command.py
index e8c2e589a3..3c36475ee1 100644
--- a/hummingbot/client/command/start_command.py
+++ b/hummingbot/client/command/start_command.py
@@ -20,14 +20,12 @@
 from hummingbot.client.settings import (
     STRATEGIES,
     SCRIPTS_PATH,
-    ethereum_gas_station_required,
     required_exchanges,
 )
 from hummingbot.core.utils.async_utils import safe_ensure_future
 from hummingbot.core.utils.kill_switch import KillSwitch
 from typing import TYPE_CHECKING
 from hummingbot.client.config.global_config_map import global_config_map
-from hummingbot.core.utils.eth_gas_station_lookup import EthGasStationLookup
 from hummingbot.script.script_iterator import ScriptIterator
 from hummingbot.connector.connector_status import get_connector_status, warning_messages
 if TYPE_CHECKING:
@@ -142,9 +140,6 @@ async def start_market_making(self,  # type: HummingbotApplication
                     self.clock.add_iterator(self._script_iterator)
                     self._notify(f"Script ({script_file}) started.")
 
-            if global_config_map["ethgasstation_gas_enabled"].value and ethereum_gas_station_required():
-                EthGasStationLookup.get_instance().start()
-
             self.strategy_task: asyncio.Task = safe_ensure_future(self._run_clock(), loop=self.ev_loop)
             self._notify(f"\n'{strategy_name}' strategy started.\n"
                          f"Run `status` command to query the progress.")
diff --git a/hummingbot/client/command/status_command.py b/hummingbot/client/command/status_command.py
index 3cf92785ad..1fb5e69344 100644
--- a/hummingbot/client/command/status_command.py
+++ b/hummingbot/client/command/status_command.py
@@ -18,7 +18,7 @@
 )
 from hummingbot.client.config.security import Security
 from hummingbot.user.user_balances import UserBalances
-from hummingbot.client.settings import required_exchanges, ethereum_wallet_required, ethereum_gas_station_required
+from hummingbot.client.settings import required_exchanges, ethereum_wallet_required
 from hummingbot.core.utils.async_utils import safe_ensure_future
 
 from typing import TYPE_CHECKING
@@ -186,10 +186,6 @@ async def status_check_all(self,  # type: HummingbotApplication
             else:
                 self._notify("  - ETH wallet check: ETH wallet is not connected.")
 
-        if ethereum_gas_station_required() and not global_config_map["ethgasstation_gas_enabled"].value:
-            self._notify(f'  - ETH gas station check: Manual gas price is fixed at '
-                         f'{global_config_map["manual_gas_price"].value}.')
-
         loading_markets: List[ConnectorBase] = []
         for market in self.markets.values():
             if not market.ready:
diff --git a/hummingbot/client/command/stop_command.py b/hummingbot/client/command/stop_command.py
index 3848aadea4..6eac19b03e 100644
--- a/hummingbot/client/command/stop_command.py
+++ b/hummingbot/client/command/stop_command.py
@@ -3,7 +3,6 @@
 import threading
 from typing import TYPE_CHECKING
 from hummingbot.core.utils.async_utils import safe_ensure_future
-from hummingbot.core.utils.eth_gas_station_lookup import EthGasStationLookup
 if TYPE_CHECKING:
     from hummingbot.client.hummingbot_application import HummingbotApplication
 
@@ -45,9 +44,6 @@ async def stop_loop(self,  # type: HummingbotApplication
         if self.strategy_task is not None and not self.strategy_task.cancelled():
             self.strategy_task.cancel()
 
-        if EthGasStationLookup.get_instance().started:
-            EthGasStationLookup.get_instance().stop()
-
         if self.markets_recorder is not None:
             self.markets_recorder.stop()
 
diff --git a/hummingbot/client/config/global_config_map.py b/hummingbot/client/config/global_config_map.py
index 82b1cf2e8b..57f37bbdb6 100644
--- a/hummingbot/client/config/global_config_map.py
+++ b/hummingbot/client/config/global_config_map.py
@@ -298,32 +298,6 @@ def global_token_symbol_on_validated(value: str):
                   type_str="decimal",
                   validator=lambda v: validate_decimal(v, Decimal(0), inclusive=False),
                   default=50),
-    "ethgasstation_gas_enabled":
-        ConfigVar(key="ethgasstation_gas_enabled",
-                  prompt="Do you want to enable Ethereum gas station price lookup? >>> ",
-                  required_if=lambda: False,
-                  type_str="bool",
-                  validator=validate_bool,
-                  default=False),
-    "ethgasstation_api_key":
-        ConfigVar(key="ethgasstation_api_key",
-                  prompt="Enter API key for defipulse.com gas station API >>> ",
-                  required_if=lambda: global_config_map["ethgasstation_gas_enabled"].value,
-                  type_str="str"),
-    "ethgasstation_gas_level":
-        ConfigVar(key="ethgasstation_gas_level",
-                  prompt="Enter gas level you want to use for Ethereum transactions (fast, fastest, safeLow, average) "
-                         ">>> ",
-                  required_if=lambda: global_config_map["ethgasstation_gas_enabled"].value,
-                  type_str="str",
-                  validator=lambda s: None if s in {"fast", "fastest", "safeLow", "average"}
-                  else "Invalid gas level."),
-    "ethgasstation_refresh_time":
-        ConfigVar(key="ethgasstation_refresh_time",
-                  prompt="Enter refresh time for Ethereum gas price lookup (in seconds) >>> ",
-                  required_if=lambda: global_config_map["ethgasstation_gas_enabled"].value,
-                  type_str="int",
-                  default=120),
     "gateway_api_host":
         ConfigVar(key="gateway_api_host",
                   prompt=None,
diff --git a/hummingbot/client/hummingbot_application.py b/hummingbot/client/hummingbot_application.py
index 7d025e2d68..f777132f21 100644
--- a/hummingbot/client/hummingbot_application.py
+++ b/hummingbot/client/hummingbot_application.py
@@ -21,7 +21,6 @@
 from hummingbot.client.errors import InvalidCommandError, ArgumentParserError
 from hummingbot.client.config.global_config_map import global_config_map, using_wallet
 from hummingbot.client.config.config_helpers import (
-    get_erc20_token_addresses,
     get_strategy_config_map,
     get_connector_class,
     get_eth_wallet_private_key,
@@ -194,10 +193,14 @@ def _initialize_market_assets(market_name: str, trading_pairs: List[str]) -> Lis
         return market_trading_pairs
 
     def _initialize_wallet(self, token_trading_pairs: List[str]):
+        # Todo: This function should be removed as it's currently not used by current working connectors
+
         if not using_wallet():
             return
-        if not self.token_list:
-            self.token_list = get_erc20_token_addresses()
+        # Commented this out for now since get_erc20_token_addresses uses blocking call
+
+        # if not self.token_list:
+        #     self.token_list = get_erc20_token_addresses()
 
         ethereum_wallet = global_config_map.get("ethereum_wallet").value
         private_key = Security._private_keys[ethereum_wallet]
diff --git a/hummingbot/connector/connector/balancer/balancer_connector.py b/hummingbot/connector/connector/balancer/balancer_connector.py
index e1bc1e131d..179c6b2e8f 100644
--- a/hummingbot/connector/connector/balancer/balancer_connector.py
+++ b/hummingbot/connector/connector/balancer/balancer_connector.py
@@ -7,7 +7,6 @@
 import time
 import ssl
 import copy
-import itertools as it
 from hummingbot.logger.struct_logger import METRICS_LOG_LEVEL
 from hummingbot.core.utils import async_ttl_cache
 from hummingbot.core.network_iterator import NetworkStatus
@@ -31,9 +30,9 @@
 from hummingbot.connector.connector_base import ConnectorBase
 from hummingbot.connector.connector.balancer.balancer_in_flight_order import BalancerInFlightOrder
 from hummingbot.client.settings import GATEAWAY_CA_CERT_PATH, GATEAWAY_CLIENT_CERT_PATH, GATEAWAY_CLIENT_KEY_PATH
-from hummingbot.core.utils.eth_gas_station_lookup import get_gas_price
 from hummingbot.client.config.global_config_map import global_config_map
-from hummingbot.client.config.config_helpers import get_erc20_token_addresses
+from hummingbot.core.utils.ethereum import check_transaction_exceptions, fetch_trading_pairs
+from hummingbot.client.config.fee_overrides_config_map import fee_overrides_config_map
 
 s_logger = None
 s_decimal_0 = Decimal("0")
@@ -71,12 +70,9 @@ def __init__(self,
         """
         super().__init__()
         self._trading_pairs = trading_pairs
-        tokens = set()
+        self._tokens = set()
         for trading_pair in trading_pairs:
-            tokens.update(set(trading_pair.split("-")))
-        self._erc_20_token_list = self.token_list()
-        self._token_addresses = {t: l[0] for t, l in self._erc_20_token_list.items() if t in tokens}
-        self._token_decimals = {t: l[1] for t, l in self._erc_20_token_list.items() if t in tokens}
+            self._tokens.update(set(trading_pair.split("-")))
         self._wallet_private_key = wallet_private_key
         self._ethereum_rpc_url = ethereum_rpc_url
         self._trading_required = trading_required
@@ -84,10 +80,13 @@ def __init__(self,
         self._shared_client = None
         self._last_poll_timestamp = 0.0
         self._last_balance_poll_timestamp = time.time()
+        self._last_est_gas_cost_reported = 0
         self._in_flight_orders = {}
         self._allowances = {}
         self._status_polling_task = None
         self._auto_approve_task = None
+        self._initiate_pool_task = None
+        self._initiate_pool_status = None
         self._real_time_balance_update = False
         self._max_swaps = global_config_map['balancer_max_swaps'].value
         self._poll_notifier = None
@@ -96,17 +95,9 @@ def __init__(self,
     def name(self):
         return "balancer"
 
-    @staticmethod
-    def token_list():
-        return get_erc20_token_addresses()
-
     @staticmethod
     async def fetch_trading_pairs() -> List[str]:
-        token_list = BalancerConnector.token_list()
-        trading_pairs = []
-        for base, quote in it.permutations(token_list.keys(), 2):
-            trading_pairs.append(f"{base}-{quote}")
-        return trading_pairs
+        return await fetch_trading_pairs()
 
     @property
     def limit_orders(self) -> List[LimitOrder]:
@@ -115,6 +106,26 @@ def limit_orders(self) -> List[LimitOrder]:
             for in_flight_order in self._in_flight_orders.values()
         ]
 
+    async def initiate_pool(self) -> str:
+        """
+        Initiate connector and cache pools
+        """
+        try:
+            self.logger().info(f"Initializing Balancer connector and caching pools for {self._trading_pairs}.")
+            resp = await self._api_request("get", "eth/balancer/start",
+                                           {"pairs": json.dumps(self._trading_pairs)})
+            status = bool(str(resp["success"]))
+            if bool(str(resp["success"])):
+                self._initiate_pool_status = status
+        except asyncio.CancelledError:
+            raise
+        except Exception as e:
+            self.logger().network(
+                f"Error initializing {self._trading_pairs} swap pools",
+                exc_info=True,
+                app_warning_msg=str(e)
+            )
+
     async def auto_approve(self):
         """
         Automatically approves Balancer contract as a spender for token in trading pairs.
@@ -138,9 +149,7 @@ async def approve_balancer_spender(self, token_symbol: str) -> Decimal:
         """
         resp = await self._api_request("post",
                                        "eth/approve",
-                                       {"tokenAddress": self._token_addresses[token_symbol],
-                                        "gasPrice": str(get_gas_price()),
-                                        "decimals": self._token_decimals[token_symbol],  # if not supplied, gateway would treat it eth-like with 18 decimals
+                                       {"token": token_symbol,
                                         "connector": self.name})
         amount_approved = Decimal(str(resp["amount"]))
         if amount_approved > 0:
@@ -155,12 +164,11 @@ async def get_allowances(self) -> Dict[str, Decimal]:
         :return: A dictionary of token and its allowance (how much Balancer can spend).
         """
         ret_val = {}
-        resp = await self._api_request("post", "eth/allowances-2",
-                                       {"tokenAddressList": ("".join([tok + "," for tok in self._token_addresses.values()])).rstrip(","),
-                                        "tokenDecimalList": ("".join([str(dec) + "," for dec in self._token_decimals.values()])).rstrip(","),
+        resp = await self._api_request("post", "eth/allowances",
+                                       {"tokenList": "[" + (",".join(['"' + t + '"' for t in self._tokens])) + "]",
                                         "connector": self.name})
-        for address, amount in resp["approvals"].items():
-            ret_val[self.get_token(address)] = Decimal(str(amount))
+        for token, amount in resp["approvals"].items():
+            ret_val[token] = Decimal(str(amount))
         return ret_val
 
     @async_ttl_cache(ttl=5, maxsize=10)
@@ -177,15 +185,44 @@ async def get_quote_price(self, trading_pair: str, is_buy: bool, amount: Decimal
             base, quote = trading_pair.split("-")
             side = "buy" if is_buy else "sell"
             resp = await self._api_request("post",
-                                           f"balancer/{side}-price",
-                                           {"base": self._token_addresses[base],
-                                            "quote": self._token_addresses[quote],
+                                           "eth/balancer/price",
+                                           {"base": base,
+                                            "quote": quote,
                                             "amount": amount,
-                                            "base_decimals": self._token_decimals[base],
-                                            "quote_decimals": self._token_decimals[quote],
-                                            "maxSwaps": self._max_swaps})
-            if resp["price"] is not None:
-                return Decimal(str(resp["price"]))
+                                            "side": side.upper()})
+            required_items = ["price", "gasLimit", "gasPrice", "gasCost"]
+            if any(item not in resp.keys() for item in required_items):
+                if "info" in resp.keys():
+                    self.logger().info(f"Unable to get price. {resp['info']}")
+                else:
+                    self.logger().info(f"Missing data from price result. Incomplete return result for ({resp.keys()})")
+            else:
+                gas_limit = resp["gasLimit"]
+                gas_price = resp["gasPrice"]
+                gas_cost = resp["gasCost"]
+                price = resp["price"]
+                account_standing = {
+                    "allowances": self._allowances,
+                    "balances": self._account_balances,
+                    "base": base,
+                    "quote": quote,
+                    "amount": amount,
+                    "side": side,
+                    "gas_limit": gas_limit,
+                    "gas_price": gas_price,
+                    "gas_cost": gas_cost,
+                    "price": price,
+                    "swaps": len(resp["swaps"])
+                }
+                exceptions = check_transaction_exceptions(account_standing)
+                for index in range(len(exceptions)):
+                    self.logger().info(f"Warning! [{index+1}/{len(exceptions)}] {side} order - {exceptions[index]}")
+
+                if price is not None and len(exceptions) == 0:
+                    # TODO standardize quote price object to include price, fee, token, is fee part of quote.
+                    fee_overrides_config_map["balancer_maker_fee_amount"].value = Decimal(str(gas_cost))
+                    fee_overrides_config_map["balancer_taker_fee_amount"].value = Decimal(str(gas_cost))
+                    return Decimal(str(price))
         except asyncio.CancelledError:
             raise
         except Exception as e:
@@ -255,24 +292,28 @@ async def _create_order(self,
         amount = self.quantize_order_amount(trading_pair, amount)
         price = self.quantize_order_price(trading_pair, price)
         base, quote = trading_pair.split("-")
-        gas_price = get_gas_price()
-        api_params = {"base": self._token_addresses[base],
-                      "quote": self._token_addresses[quote],
+        api_params = {"base": base,
+                      "quote": quote,
+                      "side": trade_type.name.upper(),
                       "amount": str(amount),
-                      "maxPrice": str(price),
-                      "maxSwaps": str(self._max_swaps),
-                      "gasPrice": str(gas_price),
-                      "base_decimals": self._token_decimals[base],
-                      "quote_decimals": self._token_decimals[quote],
+                      "limitPrice": str(price),
                       }
-        self.start_tracking_order(order_id, None, trading_pair, trade_type, price, amount, gas_price)
         try:
-            order_result = await self._api_request("post", f"balancer/{trade_type.name.lower()}", api_params)
+            order_result = await self._api_request("post", "eth/balancer/trade", api_params)
             hash = order_result.get("txHash")
+            gas_price = order_result.get("gasPrice")
+            gas_limit = order_result.get("gasLimit")
+            gas_cost = order_result.get("gasCost")
+            self.start_tracking_order(order_id, None, trading_pair, trade_type, price, amount, gas_price)
             tracked_order = self._in_flight_orders.get(order_id)
+
+            # update onchain balance
+            await self._update_balances()
+
             if tracked_order is not None:
                 self.logger().info(f"Created {trade_type.name} order {order_id} txHash: {hash} "
-                                   f"for {amount} {trading_pair}.")
+                                   f"for {amount} {trading_pair}. Estimated Gas Cost: {gas_cost} ETH "
+                                   f" (gas limit: {gas_limit}, gas price: {gas_price})")
                 tracked_order.update_exchange_order_id(hash)
                 tracked_order.gas_price = gas_price
             if hash is not None:
@@ -340,7 +381,7 @@ async def _update_order_status(self):
             for tracked_order in tracked_orders:
                 order_id = await tracked_order.get_exchange_order_id()
                 tasks.append(self._api_request("post",
-                                               "eth/get-receipt",
+                                               "eth/poll",
                                                {"txHash": order_id}))
             update_results = await safe_gather(*tasks, return_exceptions=True)
             for update_result in update_results:
@@ -416,7 +457,7 @@ def has_allowances(self) -> bool:
         """
         Checks if all tokens have allowance (an amount approved)
         """
-        return len(self._allowances.values()) == len(self._token_addresses.values()) and \
+        return len(self._allowances.values()) == len(self._tokens) and \
             all(amount > s_decimal_0 for amount in self._allowances.values())
 
     @property
@@ -429,6 +470,7 @@ def status_dict(self) -> Dict[str, bool]:
     async def start_network(self):
         if self._trading_required:
             self._status_polling_task = safe_ensure_future(self._status_polling_loop())
+            self._initiate_pool_task = safe_ensure_future(self.initiate_pool())
             self._auto_approve_task = safe_ensure_future(self.auto_approve())
 
     async def stop_network(self):
@@ -438,6 +480,9 @@ async def stop_network(self):
         if self._auto_approve_task is not None:
             self._auto_approve_task.cancel()
             self._auto_approve_task = None
+        if self._initiate_pool_task is not None:
+            self._initiate_pool_task.cancel()
+            self._initiate_pool_task = None
 
     async def check_network(self) -> NetworkStatus:
         try:
@@ -478,9 +523,6 @@ async def _status_polling_loop(self):
                                       app_warning_msg="Could not fetch balances from Gateway API.")
                 await asyncio.sleep(0.5)
 
-    def get_token(self, token_address: str) -> str:
-        return [k for k, v in self._token_addresses.items() if v == token_address][0]
-
     async def _update_balances(self, on_interval = False):
         """
         Calls Eth API to update total and available balances.
@@ -492,12 +534,10 @@ async def _update_balances(self, on_interval = False):
             local_asset_names = set(self._account_balances.keys())
             remote_asset_names = set()
             resp_json = await self._api_request("post",
-                                                "eth/balances-2",
-                                                {"tokenAddressList": ("".join([tok + "," for tok in self._token_addresses.values()])).rstrip(","),
-                                                 "tokenDecimalList": ("".join([str(dec) + "," for dec in self._token_decimals.values()])).rstrip(",")})
+                                                "eth/balances",
+                                                {"tokenList": "[" + (",".join(['"' + t + '"' for t in self._tokens])) + "]"})
+
             for token, bal in resp_json["balances"].items():
-                if len(token) > 4:
-                    token = self.get_token(token)
                 self._account_available_balances[token] = Decimal(str(bal))
                 self._account_balances[token] = Decimal(str(bal))
                 remote_asset_names.add(token)
@@ -554,7 +594,7 @@ async def _api_request(self,
                 err_msg = f" Message: {parsed_response['error']}"
             raise IOError(f"Error fetching data from {url}. HTTP status is {response.status}.{err_msg}")
         if "error" in parsed_response:
-            raise Exception(f"Error: {parsed_response['error']}")
+            raise Exception(f"Error: {parsed_response['error']} {parsed_response['message']}")
 
         return parsed_response
 
diff --git a/hummingbot/connector/connector/terra/terra_connector.py b/hummingbot/connector/connector/terra/terra_connector.py
index 1836750621..0f27b3e0ed 100644
--- a/hummingbot/connector/connector/terra/terra_connector.py
+++ b/hummingbot/connector/connector/terra/terra_connector.py
@@ -107,7 +107,7 @@ async def get_quote_price(self, trading_pair: str, is_buy: bool, amount: Decimal
 
             base, quote = trading_pair.split("-")
             side = "buy" if is_buy else "sell"
-            resp = await self._api_request("post", "terra/price", {"base": base, "quote": quote, "trade_type": side,
+            resp = await self._api_request("post", "terra/price", {"base": base, "quote": quote, "side": side,
                                                                    "amount": str(amount)})
             txFee = resp["txFee"] / float(amount)
             price_with_txfee = resp["price"] + txFee if is_buy else resp["price"] - txFee
@@ -185,9 +185,9 @@ async def _create_order(self,
         base, quote = trading_pair.split("-")
         api_params = {"base": base,
                       "quote": quote,
-                      "trade_type": "buy" if trade_type is TradeType.BUY else "sell",
+                      "side": "buy" if trade_type is TradeType.BUY else "sell",
                       "amount": str(amount),
-                      "secret": self._terra_wallet_seeds,
+                      "privateKey": self._terra_wallet_seeds,
                       # "maxPrice": str(price),
                       }
         self.start_tracking_order(order_id, None, trading_pair, trade_type, price, amount)
diff --git a/hummingbot/connector/connector/uniswap/uniswap_connector.py b/hummingbot/connector/connector/uniswap/uniswap_connector.py
index 2fef254945..c8277b65b1 100644
--- a/hummingbot/connector/connector/uniswap/uniswap_connector.py
+++ b/hummingbot/connector/connector/uniswap/uniswap_connector.py
@@ -7,7 +7,6 @@
 import time
 import ssl
 import copy
-import itertools as it
 from hummingbot.logger.struct_logger import METRICS_LOG_LEVEL
 from hummingbot.core.utils import async_ttl_cache
 from hummingbot.core.network_iterator import NetworkStatus
@@ -31,9 +30,9 @@
 from hummingbot.connector.connector_base import ConnectorBase
 from hummingbot.connector.connector.uniswap.uniswap_in_flight_order import UniswapInFlightOrder
 from hummingbot.client.settings import GATEAWAY_CA_CERT_PATH, GATEAWAY_CLIENT_CERT_PATH, GATEAWAY_CLIENT_KEY_PATH
-from hummingbot.core.utils.eth_gas_station_lookup import get_gas_price
 from hummingbot.client.config.global_config_map import global_config_map
-from hummingbot.client.config.config_helpers import get_erc20_token_addresses
+from hummingbot.core.utils.ethereum import check_transaction_exceptions, fetch_trading_pairs
+from hummingbot.client.config.fee_overrides_config_map import fee_overrides_config_map
 
 s_logger = None
 s_decimal_0 = Decimal("0")
@@ -71,12 +70,9 @@ def __init__(self,
         """
         super().__init__()
         self._trading_pairs = trading_pairs
-        tokens = set()
+        self._tokens = set()
         for trading_pair in trading_pairs:
-            tokens.update(set(trading_pair.split("-")))
-        self._erc_20_token_list = self.token_list()
-        self._token_addresses = {t: l[0] for t, l in self._erc_20_token_list.items() if t in tokens}
-        self._token_decimals = {t: l[1] for t, l in self._erc_20_token_list.items() if t in tokens}
+            self._tokens.update(set(trading_pair.split("-")))
         self._wallet_private_key = wallet_private_key
         self._ethereum_rpc_url = ethereum_rpc_url
         self._trading_required = trading_required
@@ -84,10 +80,13 @@ def __init__(self,
         self._shared_client = None
         self._last_poll_timestamp = 0.0
         self._last_balance_poll_timestamp = time.time()
+        self._last_est_gas_cost_reported = 0
         self._in_flight_orders = {}
         self._allowances = {}
         self._status_polling_task = None
         self._auto_approve_task = None
+        self._initiate_pool_task = None
+        self._initiate_pool_status = None
         self._real_time_balance_update = False
         self._poll_notifier = None
 
@@ -95,17 +94,9 @@ def __init__(self,
     def name(self):
         return "uniswap"
 
-    @staticmethod
-    def token_list():
-        return get_erc20_token_addresses()
-
     @staticmethod
     async def fetch_trading_pairs() -> List[str]:
-        token_list = UniswapConnector.token_list()
-        trading_pairs = []
-        for base, quote in it.permutations(token_list.keys(), 2):
-            trading_pairs.append(f"{base}-{quote}")
-        return trading_pairs
+        return await fetch_trading_pairs()
 
     @property
     def limit_orders(self) -> List[LimitOrder]:
@@ -114,6 +105,26 @@ def limit_orders(self) -> List[LimitOrder]:
             for in_flight_order in self._in_flight_orders.values()
         ]
 
+    async def initiate_pool(self) -> str:
+        """
+        Initiate connector and start caching paths for trading_pairs
+        """
+        try:
+            self.logger().info(f"Initializing Uniswap connector and paths for {self._trading_pairs} pairs.")
+            resp = await self._api_request("get", "eth/uniswap/start",
+                                           {"pairs": json.dumps(self._trading_pairs)})
+            status = bool(str(resp["success"]))
+            if bool(str(resp["success"])):
+                self._initiate_pool_status = status
+        except asyncio.CancelledError:
+            raise
+        except Exception as e:
+            self.logger().network(
+                f"Error initializing {self._trading_pairs} ",
+                exc_info=True,
+                app_warning_msg=str(e)
+            )
+
     async def auto_approve(self):
         """
         Automatically approves Uniswap contract as a spender for token in trading pairs.
@@ -137,9 +148,7 @@ async def approve_uniswap_spender(self, token_symbol: str) -> Decimal:
         """
         resp = await self._api_request("post",
                                        "eth/approve",
-                                       {"tokenAddress": self._token_addresses[token_symbol],
-                                        "gasPrice": str(get_gas_price()),
-                                        "decimals": self._token_decimals[token_symbol],  # if not supplied, gateway would treat it eth-like with 18 decimals
+                                       {"token": token_symbol,
                                         "connector": self.name})
         amount_approved = Decimal(str(resp["amount"]))
         if amount_approved > 0:
@@ -154,12 +163,11 @@ async def get_allowances(self) -> Dict[str, Decimal]:
         :return: A dictionary of token and its allowance (how much Uniswap can spend).
         """
         ret_val = {}
-        resp = await self._api_request("post", "eth/allowances-2",
-                                       {"tokenAddressList": ("".join([tok + "," for tok in self._token_addresses.values()])).rstrip(","),
-                                        "tokenDecimalList": ("".join([str(dec) + "," for dec in self._token_decimals.values()])).rstrip(","),
+        resp = await self._api_request("post", "eth/allowances",
+                                       {"tokenList": "[" + (",".join(['"' + t + '"' for t in self._tokens])) + "]",
                                         "connector": self.name})
-        for address, amount in resp["approvals"].items():
-            ret_val[self.get_token(address)] = Decimal(str(amount))
+        for token, amount in resp["approvals"].items():
+            ret_val[token] = Decimal(str(amount))
         return ret_val
 
     @async_ttl_cache(ttl=5, maxsize=10)
@@ -176,12 +184,43 @@ async def get_quote_price(self, trading_pair: str, is_buy: bool, amount: Decimal
             base, quote = trading_pair.split("-")
             side = "buy" if is_buy else "sell"
             resp = await self._api_request("post",
-                                           f"uniswap/{side}-price",
-                                           {"base": self._token_addresses[base],
-                                            "quote": self._token_addresses[quote],
+                                           "eth/uniswap/price",
+                                           {"base": base,
+                                            "quote": quote,
+                                            "side": side.upper(),
                                             "amount": amount})
-            if resp["price"] is not None:
-                return Decimal(str(resp["price"]))
+            required_items = ["price", "gasLimit", "gasPrice", "gasCost"]
+            if any(item not in resp.keys() for item in required_items):
+                if "info" in resp.keys():
+                    self.logger().info(f"Unable to get price. {resp['info']}")
+                else:
+                    self.logger().info(f"Missing data from price result. Incomplete return result for ({resp.keys()})")
+            else:
+                gas_limit = resp["gasLimit"]
+                gas_price = resp["gasPrice"]
+                gas_cost = resp["gasCost"]
+                price = resp["price"]
+                account_standing = {
+                    "allowances": self._allowances,
+                    "balances": self._account_balances,
+                    "base": base,
+                    "quote": quote,
+                    "amount": amount,
+                    "side": side,
+                    "gas_limit": gas_limit,
+                    "gas_price": gas_price,
+                    "gas_cost": gas_cost,
+                    "price": price
+                }
+                exceptions = check_transaction_exceptions(account_standing)
+                for index in range(len(exceptions)):
+                    self.logger().info(f"Warning! [{index+1}/{len(exceptions)}] {side} order - {exceptions[index]}")
+
+                if price is not None and len(exceptions) == 0:
+                    # TODO standardize quote price object to include price, fee, token, is fee part of quote.
+                    fee_overrides_config_map["uniswap_maker_fee_amount"].value = Decimal(str(gas_cost))
+                    fee_overrides_config_map["uniswap_taker_fee_amount"].value = Decimal(str(gas_cost))
+                    return Decimal(str(price))
         except asyncio.CancelledError:
             raise
         except Exception as e:
@@ -251,21 +290,24 @@ async def _create_order(self,
         amount = self.quantize_order_amount(trading_pair, amount)
         price = self.quantize_order_price(trading_pair, price)
         base, quote = trading_pair.split("-")
-        gas_price = get_gas_price()
-        api_params = {"base": self._token_addresses[base],
-                      "quote": self._token_addresses[quote],
+        api_params = {"base": base,
+                      "quote": quote,
+                      "side": trade_type.name.upper(),
                       "amount": str(amount),
-                      "maxPrice": str(price),
-                      "gasPrice": str(gas_price),
+                      "limitPrice": str(price),
                       }
-        self.start_tracking_order(order_id, None, trading_pair, trade_type, price, amount, gas_price)
         try:
-            order_result = await self._api_request("post", f"uniswap/{trade_type.name.lower()}", api_params)
+            order_result = await self._api_request("post", "eth/uniswap/trade", api_params)
             hash = order_result.get("txHash")
+            gas_price = order_result.get("gasPrice")
+            gas_limit = order_result.get("gasLimit")
+            gas_cost = order_result.get("gasCost")
+            self.start_tracking_order(order_id, None, trading_pair, trade_type, price, amount, gas_price)
             tracked_order = self._in_flight_orders.get(order_id)
             if tracked_order is not None:
                 self.logger().info(f"Created {trade_type.name} order {order_id} txHash: {hash} "
-                                   f"for {amount} {trading_pair}.")
+                                   f"for {amount} {trading_pair}. Estimated Gas Cost: {gas_cost} ETH "
+                                   f" (gas limit: {gas_limit}, gas price: {gas_price})")
                 tracked_order.update_exchange_order_id(hash)
                 tracked_order.gas_price = gas_price
             if hash is not None:
@@ -333,7 +375,7 @@ async def _update_order_status(self):
             for tracked_order in tracked_orders:
                 order_id = await tracked_order.get_exchange_order_id()
                 tasks.append(self._api_request("post",
-                                               "eth/get-receipt",
+                                               "eth/poll",
                                                {"txHash": order_id}))
             update_results = await safe_gather(*tasks, return_exceptions=True)
             for update_result in update_results:
@@ -409,7 +451,7 @@ def has_allowances(self) -> bool:
         """
         Checks if all tokens have allowance (an amount approved)
         """
-        return len(self._allowances.values()) == len(self._token_addresses.values()) and \
+        return len(self._allowances.values()) == len(self._tokens) and \
             all(amount > s_decimal_0 for amount in self._allowances.values())
 
     @property
@@ -422,6 +464,7 @@ def status_dict(self) -> Dict[str, bool]:
     async def start_network(self):
         if self._trading_required:
             self._status_polling_task = safe_ensure_future(self._status_polling_loop())
+            self._initiate_pool_task = safe_ensure_future(self.initiate_pool())
             self._auto_approve_task = safe_ensure_future(self.auto_approve())
 
     async def stop_network(self):
@@ -431,6 +474,9 @@ async def stop_network(self):
         if self._auto_approve_task is not None:
             self._auto_approve_task.cancel()
             self._auto_approve_task = None
+        if self._initiate_pool_task is not None:
+            self._initiate_pool_task.cancel()
+            self._initiate_pool_task = None
 
     async def check_network(self) -> NetworkStatus:
         try:
@@ -458,7 +504,7 @@ async def _status_polling_loop(self):
                 self._poll_notifier = asyncio.Event()
                 await self._poll_notifier.wait()
                 await safe_gather(
-                    self._update_balances(),
+                    self._update_balances(on_interval=True),
                     self._update_order_status(),
                 )
                 self._last_poll_timestamp = self.current_timestamp
@@ -471,37 +517,32 @@ async def _status_polling_loop(self):
                                       app_warning_msg="Could not fetch balances from Gateway API.")
                 await asyncio.sleep(0.5)
 
-    def get_token(self, token_address: str) -> str:
-        return [k for k, v in self._token_addresses.items() if v == token_address][0]
-
-    async def _update_balances(self):
+    async def _update_balances(self, on_interval = False):
         """
         Calls Eth API to update total and available balances.
         """
         last_tick = self._last_balance_poll_timestamp
         current_tick = self.current_timestamp
-        if (current_tick - last_tick) > self.UPDATE_BALANCE_INTERVAL:
+        if not on_interval or (current_tick - last_tick) > self.UPDATE_BALANCE_INTERVAL:
             self._last_balance_poll_timestamp = current_tick
-        local_asset_names = set(self._account_balances.keys())
-        remote_asset_names = set()
-        resp_json = await self._api_request("post",
-                                            "eth/balances-2",
-                                            {"tokenAddressList": ("".join([tok + "," for tok in self._token_addresses.values()])).rstrip(","),
-                                             "tokenDecimalList": ("".join([str(dec) + "," for dec in self._token_decimals.values()])).rstrip(",")})
-        for token, bal in resp_json["balances"].items():
-            if len(token) > 4:
-                token = self.get_token(token)
-            self._account_available_balances[token] = Decimal(str(bal))
-            self._account_balances[token] = Decimal(str(bal))
-            remote_asset_names.add(token)
-
-        asset_names_to_remove = local_asset_names.difference(remote_asset_names)
-        for asset_name in asset_names_to_remove:
-            del self._account_available_balances[asset_name]
-            del self._account_balances[asset_name]
-
-        self._in_flight_orders_snapshot = {k: copy.copy(v) for k, v in self._in_flight_orders.items()}
-        self._in_flight_orders_snapshot_timestamp = self.current_timestamp
+            local_asset_names = set(self._account_balances.keys())
+            remote_asset_names = set()
+            resp_json = await self._api_request("post",
+                                                "eth/balances",
+                                                {"tokenList": "[" + (",".join(['"' + t + '"' for t in self._tokens])) + "]"})
+
+            for token, bal in resp_json["balances"].items():
+                self._account_available_balances[token] = Decimal(str(bal))
+                self._account_balances[token] = Decimal(str(bal))
+                remote_asset_names.add(token)
+
+            asset_names_to_remove = local_asset_names.difference(remote_asset_names)
+            for asset_name in asset_names_to_remove:
+                del self._account_available_balances[asset_name]
+                del self._account_balances[asset_name]
+
+            self._in_flight_orders_snapshot = {k: copy.copy(v) for k, v in self._in_flight_orders.items()}
+            self._in_flight_orders_snapshot_timestamp = self.current_timestamp
 
     async def _http_client(self) -> aiohttp.ClientSession:
         """
@@ -547,7 +588,7 @@ async def _api_request(self,
                 err_msg = f" Message: {parsed_response['error']}"
             raise IOError(f"Error fetching data from {url}. HTTP status is {response.status}.{err_msg}")
         if "error" in parsed_response:
-            raise Exception(f"Error: {parsed_response['error']}")
+            raise Exception(f"Error: {parsed_response['error']} {parsed_response['message']}")
 
         return parsed_response
 
diff --git a/hummingbot/core/utils/estimate_fee.py b/hummingbot/core/utils/estimate_fee.py
index 78823e425e..5a52568861 100644
--- a/hummingbot/core/utils/estimate_fee.py
+++ b/hummingbot/core/utils/estimate_fee.py
@@ -2,16 +2,11 @@
 from hummingbot.core.event.events import TradeFee, TradeFeeType
 from hummingbot.client.config.fee_overrides_config_map import fee_overrides_config_map
 from hummingbot.client.settings import CONNECTOR_SETTINGS
-from hummingbot.core.utils.eth_gas_station_lookup import get_gas_price, get_gas_limit
 
 
 def estimate_fee(exchange: str, is_maker: bool) -> TradeFee:
     if exchange not in CONNECTOR_SETTINGS:
         raise Exception(f"Invalid connector. {exchange} does not exist in CONNECTOR_SETTINGS")
-    use_gas = CONNECTOR_SETTINGS[exchange].use_eth_gas_lookup
-    if use_gas:
-        gas_amount = get_gas_price(in_gwei=False) * get_gas_limit(exchange)
-        return TradeFee(percent=0, flat_fees=[("ETH", gas_amount)])
     fee_type = CONNECTOR_SETTINGS[exchange].fee_type
     fee_token = CONNECTOR_SETTINGS[exchange].fee_token
     default_fees = CONNECTOR_SETTINGS[exchange].default_fees
diff --git a/hummingbot/core/utils/eth_gas_station_lookup.py b/hummingbot/core/utils/eth_gas_station_lookup.py
deleted file mode 100644
index ee56502631..0000000000
--- a/hummingbot/core/utils/eth_gas_station_lookup.py
+++ /dev/null
@@ -1,178 +0,0 @@
-import asyncio
-import requests
-import logging
-from typing import (
-    Optional,
-    Dict,
-    Any
-)
-import aiohttp
-from enum import Enum
-from decimal import Decimal
-from hummingbot.core.network_base import (
-    NetworkBase,
-    NetworkStatus
-)
-from hummingbot.core.utils.async_utils import safe_ensure_future
-from hummingbot.logger import HummingbotLogger
-from hummingbot.client.config.global_config_map import global_config_map
-from hummingbot.client.settings import CONNECTOR_SETTINGS
-from hummingbot.client.settings import GATEAWAY_CA_CERT_PATH, GATEAWAY_CLIENT_CERT_PATH, GATEAWAY_CLIENT_KEY_PATH
-
-ETH_GASSTATION_API_URL = "https://data-api.defipulse.com/api/v1/egs/api/ethgasAPI.json?api-key={}"
-
-
-def get_gas_price(in_gwei: bool = True) -> Decimal:
-    if not global_config_map["ethgasstation_gas_enabled"].value:
-        gas_price = global_config_map["manual_gas_price"].value
-    else:
-        gas_price = EthGasStationLookup.get_instance().gas_price
-    return gas_price if in_gwei else gas_price / Decimal("1e9")
-
-
-def get_gas_limit(connector_name: str) -> int:
-    gas_limit = request_gas_limit(connector_name)
-    return gas_limit
-
-
-def request_gas_limit(connector_name: str) -> int:
-    host = global_config_map["gateway_api_host"].value
-    port = global_config_map["gateway_api_port"].value
-    balancer_max_swaps = global_config_map["balancer_max_swaps"].value
-
-    base_url = ':'.join(['https://' + host, port])
-    url = f"{base_url}/{connector_name}/gas-limit"
-
-    ca_certs = GATEAWAY_CA_CERT_PATH
-    client_certs = (GATEAWAY_CLIENT_CERT_PATH, GATEAWAY_CLIENT_KEY_PATH)
-    params = {"maxSwaps": balancer_max_swaps} if connector_name == "balancer" else {}
-    response = requests.post(url, data=params, verify=ca_certs, cert=client_certs)
-    parsed_response = response.json()
-    if response.status_code != 200:
-        err_msg = ""
-        if "error" in parsed_response:
-            err_msg = f" Message: {parsed_response['error']}"
-        raise IOError(f"Error fetching data from {url}. HTTP status is {response.status}.{err_msg}")
-    if "error" in parsed_response:
-        raise Exception(f"Error: {parsed_response['error']}")
-    return parsed_response['gasLimit']
-
-
-class GasLevel(Enum):
-    fast = "fast"
-    fastest = "fastest"
-    safeLow = "safeLow"
-    average = "average"
-
-
-class EthGasStationLookup(NetworkBase):
-    _egsl_logger: Optional[HummingbotLogger] = None
-    _shared_instance: "EthGasStationLookup" = None
-
-    @classmethod
-    def get_instance(cls) -> "EthGasStationLookup":
-        if cls._shared_instance is None:
-            cls._shared_instance = EthGasStationLookup()
-        return cls._shared_instance
-
-    @classmethod
-    def logger(cls) -> HummingbotLogger:
-        if cls._egsl_logger is None:
-            cls._egsl_logger = logging.getLogger(__name__)
-        return cls._egsl_logger
-
-    def __init__(self):
-        super().__init__()
-        self._gas_prices: Dict[str, Decimal] = {}
-        self._gas_limits: Dict[str, Decimal] = {}
-        self._balancer_max_swaps: int = global_config_map["balancer_max_swaps"].value
-        self._async_task = None
-
-    @property
-    def api_key(self):
-        return global_config_map["ethgasstation_api_key"].value
-
-    @property
-    def gas_level(self) -> GasLevel:
-        return GasLevel[global_config_map["ethgasstation_gas_level"].value]
-
-    @property
-    def refresh_time(self):
-        return global_config_map["ethgasstation_refresh_time"].value
-
-    @property
-    def gas_price(self):
-        return self._gas_prices[self.gas_level]
-
-    @property
-    def gas_limits(self):
-        return self._gas_limits
-
-    @gas_limits.setter
-    def gas_limits(self, gas_limits: Dict[str, int]):
-        for key, value in gas_limits.items():
-            self._gas_limits[key] = value
-
-    @property
-    def balancer_max_swaps(self):
-        return self._balancer_max_swaps
-
-    @balancer_max_swaps.setter
-    def balancer_max_swaps(self, max_swaps: int):
-        self._balancer_max_swaps = max_swaps
-
-    async def gas_price_update_loop(self):
-        while True:
-            try:
-                url = ETH_GASSTATION_API_URL.format(self.api_key)
-                async with aiohttp.ClientSession() as client:
-                    response = await client.get(url=url)
-                    if response.status != 200:
-                        raise IOError(f"Error fetching current gas prices. "
-                                      f"HTTP status is {response.status}.")
-                    resp_data: Dict[str, Any] = await response.json()
-                    for key, value in resp_data.items():
-                        if key in GasLevel.__members__:
-                            self._gas_prices[GasLevel[key]] = Decimal(str(value)) / Decimal("10")
-                    prices_str = ', '.join([k.name + ': ' + str(v) for k, v in self._gas_prices.items()])
-                    self.logger().info(f"Gas levels: [{prices_str}]")
-                    for name, con_setting in CONNECTOR_SETTINGS.items():
-                        if con_setting.use_eth_gas_lookup:
-                            self._gas_limits[name] = get_gas_limit(name)
-                            self.logger().info(f"{name} Gas estimate:"
-                                               f" limit = {self._gas_limits[name]:.0f},"
-                                               f" price = {self.gas_level.name},"
-                                               f" estimated cost = {get_gas_price(False) * self._gas_limits[name]:.5f} ETH")
-                    await asyncio.sleep(self.refresh_time)
-            except asyncio.CancelledError:
-                raise
-            except Exception:
-                self.logger().network("Unexpected error running logging task.", exc_info=True)
-                await asyncio.sleep(self.refresh_time)
-
-    async def start_network(self):
-        self._async_task = safe_ensure_future(self.gas_price_update_loop())
-
-    async def stop_network(self):
-        if self._async_task is not None:
-            self._async_task.cancel()
-            self._async_task = None
-
-    async def check_network(self) -> NetworkStatus:
-        try:
-            url = ETH_GASSTATION_API_URL.format(self.api_key)
-            async with aiohttp.ClientSession() as client:
-                response = await client.get(url=url)
-                if response.status != 200:
-                    raise Exception(f"Error connecting to {url}. HTTP status is {response.status}.")
-        except asyncio.CancelledError:
-            raise
-        except Exception:
-            return NetworkStatus.NOT_CONNECTED
-        return NetworkStatus.CONNECTED
-
-    def start(self):
-        NetworkBase.start(self)
-
-    def stop(self):
-        NetworkBase.stop(self)
diff --git a/hummingbot/core/utils/ethereum.py b/hummingbot/core/utils/ethereum.py
index ff667d3a0a..e30c2b3478 100644
--- a/hummingbot/core/utils/ethereum.py
+++ b/hummingbot/core/utils/ethereum.py
@@ -3,7 +3,11 @@
 from hexbytes import HexBytes
 from web3 import Web3
 from web3.datastructures import AttributeDict
-from typing import Dict
+from typing import Dict, List
+import aiohttp
+from hummingbot.client.config.global_config_map import global_config_map
+import itertools as it
+from hummingbot.core.utils import async_ttl_cache
 
 
 def check_web3(ethereum_rpc_url: str) -> bool:
@@ -32,3 +36,55 @@ def block_values_to_hex(block: AttributeDict) -> AttributeDict:
         except binascii.Error:
             formatted_block[key] = value
     return AttributeDict(formatted_block)
+
+
+def check_transaction_exceptions(trade_data: dict) -> dict:
+
+    exception_list = []
+
+    gas_limit = trade_data["gas_limit"]
+    # gas_price = trade_data["gas_price"]
+    gas_cost = trade_data["gas_cost"]
+    amount = trade_data["amount"]
+    side = trade_data["side"]
+    base = trade_data["base"]
+    quote = trade_data["quote"]
+    balances = trade_data["balances"]
+    allowances = trade_data["allowances"]
+    swaps_message = f"Total swaps: {trade_data['swaps']}" if "swaps" in trade_data.keys() else ''
+
+    eth_balance = balances["ETH"]
+
+    # check for sufficient gas
+    if eth_balance < gas_cost:
+        exception_list.append(f"Insufficient ETH balance to cover gas:"
+                              f" Balance: {eth_balance}. Est. gas cost: {gas_cost}. {swaps_message}")
+
+    trade_token = base if side == "side" else quote
+    trade_allowance = allowances[trade_token]
+
+    # check for gas limit set to low
+    gas_limit_threshold = 21000
+    if gas_limit < gas_limit_threshold:
+        exception_list.append(f"Gas limit {gas_limit} below recommended {gas_limit_threshold} threshold.")
+
+    # check for insufficient token allowance
+    if allowances[trade_token] < amount:
+        exception_list.append(f"Insufficient {trade_token} allowance {trade_allowance}. Amount to trade: {amount}")
+
+    return exception_list
+
+
+@async_ttl_cache(ttl=30)
+async def fetch_trading_pairs() -> List[str]:
+    token_list_url = global_config_map.get("ethereum_token_list_url").value
+    tokens = set()
+    async with aiohttp.ClientSession() as client:
+        resp = await client.get(token_list_url)
+        resp_json = await resp.json()
+    for token in resp_json["tokens"]:
+        tokens.add(token["symbol"])
+    trading_pairs = []
+    for base, quote in it.permutations(tokens, 2):
+        trading_pairs.append(f"{base}-{quote}")
+    return trading_pairs
diff --git a/hummingbot/strategy/amm_arb/amm_arb.py b/hummingbot/strategy/amm_arb/amm_arb.py
index b96af808fc..381cd991cc 100644
--- a/hummingbot/strategy/amm_arb/amm_arb.py
+++ b/hummingbot/strategy/amm_arb/amm_arb.py
@@ -253,13 +253,18 @@ async def format_status(self) -> str:
             market, trading_pair, base_asset, quote_asset = market_info
             buy_price = await market.get_quote_price(trading_pair, True, self._order_amount)
             sell_price = await market.get_quote_price(trading_pair, False, self._order_amount)
-            mid_price = (buy_price + sell_price) / 2
+
+            # check for unavailable price data
+            buy_price = Decimal(str(buy_price)) if buy_price is not None else '-'
+            sell_price = Decimal(str(sell_price)) if sell_price is not None else '-'
+            mid_price = ((buy_price + sell_price) / 2) if '-' not in [buy_price, sell_price] else '-'
+
             data.append([
                 market.display_name,
                 trading_pair,
-                float(sell_price),
-                float(buy_price),
-                float(mid_price)
+                sell_price,
+                buy_price,
+                mid_price
             ])
         markets_df = pd.DataFrame(data=data, columns=columns)
         lines = []
@@ -335,7 +340,7 @@ async def quote_in_eth_rate_fetch_loop(self):
                     self._market_2_quote_eth_rate = await self.request_rate_in_eth(self._market_info_2.quote_asset)
                     self.logger().warning(f"Estimate conversion rate - "
                                           f"{self._market_info_2.quote_asset}:ETH = {self._market_2_quote_eth_rate} ")
-                await asyncio.sleep(60 * 5)
+                await asyncio.sleep(60 * 1)
             except asyncio.CancelledError:
                 raise
             except Exception as e:
@@ -348,4 +353,5 @@ async def quote_in_eth_rate_fetch_loop(self):
     async def request_rate_in_eth(self, quote: str) -> int:
         if self._uniswap is None:
             self._uniswap = UniswapConnector([f"{quote}-WETH"], "", None)
+            await self._uniswap.initiate_pool()  # initiate to cache swap pool
         return await self._uniswap.get_quote_price(f"{quote}-WETH", True, 1)
diff --git a/hummingbot/templates/conf_fee_overrides_TEMPLATE.yml b/hummingbot/templates/conf_fee_overrides_TEMPLATE.yml
index 08dea03918..3aff911e85 100644
--- a/hummingbot/templates/conf_fee_overrides_TEMPLATE.yml
+++ b/hummingbot/templates/conf_fee_overrides_TEMPLATE.yml
@@ -72,6 +72,12 @@ okex_taker_fee:
 balancer_maker_fee_amount:
 balancer_taker_fee_amount:
 
+uniswap_maker_fee_amount:
+uniswap_taker_fee_amount:
+
+bitmax_maker_fee:
+bitmax_taker_fee:
+
 ascend_ex_maker_fee:
 ascend_ex_taker_fee:
 
diff --git a/hummingbot/templates/conf_global_TEMPLATE.yml b/hummingbot/templates/conf_global_TEMPLATE.yml
index 42874f696c..508af5d1ff 100644
--- a/hummingbot/templates/conf_global_TEMPLATE.yml
+++ b/hummingbot/templates/conf_global_TEMPLATE.yml
@@ -94,7 +94,7 @@ ethereum_wallet: null
 ethereum_rpc_url: null
 ethereum_rpc_ws_url: null
 ethereum_chain_name: MAIN_NET
-ethereum_token_list_url: null
+ethereum_token_list_url: https://wispy-bird-88a7.uniswap.workers.dev/?url=http://tokens.1inch.eth.link
 
 # Kill switch
 kill_switch_enabled: null
@@ -175,14 +175,7 @@ balance_asset_limit:
 
 # Fixed gas price (in Gwei) for Ethereum transactions
 manual_gas_price:
-# To enable gas price lookup (true/false)
-ethgasstation_gas_enabled:
-# API key for defipulse.com gas station API
-ethgasstation_api_key:
-# Gas level you want to use for Ethereum transactions (fast, fastest, safeLow, average)
-ethgasstation_gas_level:
-# Refresh time for Ethereum gas price lookups (in seconds)
-ethgasstation_refresh_time:
+
 # Gateway API Configurations
 # default host to only use localhost
 # Port need to match the final installation port for Gateway
diff --git a/installation/docker-commands/create-gateway.sh b/installation/docker-commands/create-gateway.sh
index c6db0bae8c..49fc98579c 100755
--- a/installation/docker-commands/create-gateway.sh
+++ b/installation/docker-commands/create-gateway.sh
@@ -40,7 +40,7 @@ else
     else
       echo "‼️  hummingbot_conf & hummingbot_certs directory missing from path $FOLDER"
       prompt_hummingbot_data_path
-    fi 
+    fi
 
     if [[ -f "$FOLDER/hummingbot_certs/server_cert.pem" && -f "$FOLDER/hummingbot_certs/server_key.pem" && -f "$FOLDER/hummingbot_certs/ca_cert.pem" ]]; then
       echo
@@ -79,70 +79,208 @@ do
   then
     HUMMINGBOT_INSTANCE_ID="$(echo -e "${value}" | tr -d '[:space:]')"
   fi
-  # chain
-  if [ "$key" == "ethereum_chain_name" ]
+  #
+done < "$GLOBAL_CONFIG"
+}
+read_global_config
+
+# prompt to setup balancer, uniswap
+prompt_ethereum_setup () {
+  read -p "   Do you want to setup Balancer or Uniswap? [Y/N] (default \"Y\") >>> " PROCEED
+  if [[ "$PROCEED" == "Y" || "$PROCEED" == "y"  || "$PROCEED" == ""  ]]
   then
-    ETHEREUM_CHAIN="$(echo -e "${value}" | tr -d '[:space:]')"
-    # subgraph url
-    if [[ "$ETHEREUM_CHAIN" == "MAIN_NET" || "$ETHEREUM_CHAIN" == "main_net"  || "$ETHEREUM_CHAIN" == "MAINNET"  || "$ETHEREUM_CHAIN" == "mainnet" ]]
+    ETHEREUM_SETUP=true
+    echo
+    read -p "   Enter Ethereum chain you want to use [mainnet/kovan] (default = \"mainnet\") >>> " ETHEREUM_CHAIN
+    # chain selection
+    if [ "$ETHEREUM_CHAIN" == "" ]
+    then
+      ETHEREUM_CHAIN="mainnet"
+    fi
+    if [[ "$ETHEREUM_CHAIN" != "mainnet" && "$ETHEREUM_CHAIN" != "kovan" ]]
+    then
+      echo "‼️  ERROR. Unsupported chains (mainnet/kovan). "
+      prompt_ethereum_setup
+    fi
+    # set subgraph url, exchange_proxy
+    if [[ "$ETHEREUM_CHAIN" == "mainnet" ]]
     then
       ETHEREUM_CHAIN="mainnet"
       REACT_APP_SUBGRAPH_URL="https://api.thegraph.com/subgraphs/name/balancer-labs/balancer"
       EXCHANGE_PROXY="0x3E66B66Fd1d0b02fDa6C811Da9E0547970DB2f21"
     else
-      ETHEREUM_CHAIN="kovan"
-      REACT_APP_SUBGRAPH_URL="https://api.thegraph.com/subgraphs/name/balancer-labs/balancer-kovan"
-      EXCHANGE_PROXY="0x4e67bf5bD28Dd4b570FBAFe11D0633eCbA2754Ec"
+      if [[ "$ETHEREUM_CHAIN" == "kovan" ]]
+      then
+        REACT_APP_SUBGRAPH_URL="https://api.thegraph.com/subgraphs/name/balancer-labs/balancer-kovan"
+        EXCHANGE_PROXY="0x4e67bf5bD28Dd4b570FBAFe11D0633eCbA2754Ec"
+      fi
     fi
   fi
-  # ethereum rpc url
-  if [ "$key" == "ethereum_rpc_url" ]
+}
+prompt_ethereum_setup
+
+# prompt to ethereum rpc
+prompt_ethereum_rpc_setup () {
+  if [ "$ETHEREUM_RPC_URL" == "" ]
   then
-    ETHEREUM_RPC_URL="$(echo -e "${value}" | tr -d '[:space:]')"
+    read -p "   Enter the Ethereum RPC node URL to connect to  >>> " ETHEREUM_RPC_URL
+    if [ "$ETHEREUM_RPC_URL" == "" ]
+    then
+      prompt_ethereum_rpc_setup
+    fi
+  else
+    read -p "   Use the this Ethereum RPC node ($ETHEREUM_RPC_URL) setup in Hummingbot client?  [Y/N] (default = \"Y\") >>> " PROCEED
+    if [[ "$PROCEED" == "Y" || "$PROCEED" == "y" || "$PROCEED" == "" ]]
+    then
+      echo
+    else
+      ETHEREUM_RPC_URL=""
+      prompt_ethereum_rpc_setup
+    fi
   fi
-done < "$GLOBAL_CONFIG"
 }
-read_global_config
+prompt_ethereum_rpc_setup
 
-# prompt to setup balancer, uniswap
-prompt_ethereum_setup () {
-  read -p "   Do you want to setup Balancer/Uniswap/Perpetual Finance? [Y/N] >>> " PROCEED
-  if [[ "$PROCEED" == "Y" || "$PROCEED" == "y" ]]
+# prompt to setup ethereum token list
+prompt_token_list_source () {
+  echo
+  echo "   Enter the token list url available at https://tokenlists.org/"
+  read -p "      (default = \"https://wispy-bird-88a7.uniswap.workers.dev/?url=http://tokens.1inch.eth.link\") >>> " ETHEREUM_TOKEN_LIST_URL
+  if [ "$ETHEREUM_TOKEN_LIST_URL" == "" ]
   then
+    echo
     echo "ℹ️  Retrieving config from Hummingbot config file ... "
     ETHEREUM_SETUP=true
+    ETHEREUM_TOKEN_LIST_URL=https://wispy-bird-88a7.uniswap.workers.dev/?url=http://tokens.1inch.eth.link
+  fi
+}
+prompt_token_list_source
+
+# prompt to setup eth gas level
+prompt_eth_gasstation_gas_level () {
+  echo
+  read -p "   Enter gas level you want to use for Ethereum transactions (fast, fastest, safeLow, average) (default = \"fast\") >>> " ETH_GAS_STATION_GAS_LEVEL
+  if [ "$ETH_GAS_STATION_GAS_LEVEL" == "" ]
+  then
+    ETH_GAS_STATION_GAS_LEVEL=fast
+  else
+    if [[ "$ETH_GAS_STATION_GAS_LEVEL" != "fast" && "$ETH_GAS_STATION_GAS_LEVEL" != "fastest" && "$ETH_GAS_STATION_GAS_LEVEL" != "safeLow" && "$ETH_GAS_STATION_GAS_LEVEL" != "safelow" && "$ETH_GAS_STATION_GAS_LEVEL" != "average" ]]
+    then
+      prompt_eth_gasstation_gas_level
+    fi
+  fi
+}
+
+# prompt to setup eth gas station
+prompt_eth_gasstation_setup () {
+  echo
+  read -p "   Enable dynamic Ethereum gas price lookup? [Y/N] (default = \"Y\") >>> " PROCEED
+  if [[ "$PROCEED" == "Y" || "$PROCEED" == "y" || "$PROCEED" == "" ]]
+  then
+    ENABLE_ETH_GAS_STATION=true
+    read -p "   Enter API key for Eth Gas Station (https://ethgasstation.info/) >>> " ETH_GAS_STATION_API_KEY
+    if [ "$ETH_GAS_STATION_API_KEY" == "" ]
+    then
+      prompt_eth_gasstation_setup
+    else
+      # set gas level
+      prompt_eth_gasstation_gas_level
+
+      # set refresh interval
+      read -p "   Enter refresh time for Ethereum gas price lookup (in seconds) (default = \"120\") >>> " ETH_GAS_STATION_REFRESH_TIME
+      if [ "$ETH_GAS_STATION_REFRESH_TIME" == "" ]
+      then
+        ETH_GAS_STATION_REFRESH_TIME=120
+      fi
+    fi
+  else
+    if [[ "$PROCEED" == "N" || "$PROCEED" == "n" ]]
+    then
+      ENABLE_ETH_GAS_STATION=false
+      # set manual gas price
+      read -p "   Enter fixed gas price (in Gwei) you want to use for Ethereum transactions (default = \"100\") >>> " MANUAL_GAS_PRICE
+      if [ "$MANUAL_GAS_PRICE" == "" ]
+      then
+        MANUAL_GAS_PRICE=100
+      fi
+    else
+      prompt_eth_gasstation_setup
+    fi
+  fi
+  echo
+}
+prompt_eth_gasstation_setup
+
+prompt_balancer_setup () {
+  # Ask the user for the Balancer specific settings
+  echo "ℹ️  Balancer setting "
+  read -p "   Enter the maximum Balancer swap pool (default = \"4\") >>> " BALANCER_MAX_SWAPS
+  if [ "$BALANCER_MAX_SWAPS" == "" ]
+  then
+    BALANCER_MAX_SWAPS="4"
     echo
   fi
 }
-prompt_ethereum_setup
 
-# Ask the user for ethereum network
-prompt_terra_network () {
-read -p "   Enter Terra chain you want to use [mainnet/testnet] (default = \"mainnet\") >>> " TERRA
-# chain selection
-if [ "$TERRA" == "" ]
-then
-  TERRA="mainnet"
-fi
-if [[ "$TERRA" != "mainnet" && "$TERRA" != "testnet" ]]
-then
-  echo "‼️  ERROR. Unsupported chains (mainnet/testnet). "
-  prompt_terra_network
-fi
-# setup chain params
-if [[ "$TERRA" == "mainnet" ]]
-then
-  TERRA_LCD_URL="https://lcd.terra.dev"
-  TERRA_CHAIN="columbus-4"
-elif [ "$TERRA" == "testnet" ]
+prompt_uniswap_setup () {
+  # Ask the user for the Uniswap specific settings
+  echo "ℹ️  Uniswap setting "
+  read -p "   Enter the allowed slippage for swap transactions (default = \"1.5\") >>> " UNISWAP_SLIPPAGE
+  if [ "$UNISWAP_SLIPPAGE" == "" ]
+  then
+    UNISWAP_SLIPPAGE="1.5"
+    echo
+  fi
+}
+
+if [[ "$ETHEREUM_SETUP" == true ]]
 then
-  TERRA_LCD_URL="https://tequila-lcd.terra.dev"
-  TERRA_CHAIN="tequila-0004"
+  prompt_balancer_setup
+  prompt_uniswap_setup
 fi
+
+prompt_xdai_setup () {
+  # Ask the user for the Uniswap specific settings
+  echo "ℹ️  XDAI setting "
+  read -p "   Enter preferred XDAI rpc provider (default = \"https://rpc.xdaichain.com\") >>> " XDAI_PROVIDER
+  if [ "$XDAI_PROVIDER" == "" ]
+  then
+    XDAI_PROVIDER="https://rpc.xdaichain.com"
+    echo
+  fi
 }
+prompt_xdai_setup
+
+# Ask the user for ethereum network
+prompt_terra_network () {
+  echo
+  read -p "   Enter Terra chain you want to use [mainnet/testnet] (default = \"mainnet\") >>> " TERRA
+  # chain selection
+  if [ "$TERRA" == "" ]
+  then
+    TERRA="mainnet"
+  fi
+  if [[ "$TERRA" != "mainnet" && "$TERRA" != "testnet" ]]
+  then
+    echo "‼️  ERROR. Unsupported chains (mainnet/testnet). "
+    prompt_terra_network
+  fi
+  # setup chain params
+  if [[ "$TERRA" == "mainnet" ]]
+  then
+    TERRA_LCD_URL="https://lcd.terra.dev"
+    TERRA_CHAIN="columbus-4"
+  elif [ "$TERRA" == "testnet" ]
+  then
+    TERRA_LCD_URL="https://tequila-lcd.terra.dev"
+    TERRA_CHAIN="tequila-0004"
+  fi
+}
+
 prompt_terra_setup () {
-  read -p "   Do you want to setup Terra? [Y/N] >>> " PROCEED
-  if [[ "$PROCEED" == "Y" || "$PROCEED" == "y" ]]
+  echo
+  read -p "   Do you want to setup Terra? [Y/N] (default \"Y\") >>> " PROCEED
+  if [[ "$PROCEED" == "Y" || "$PROCEED" == "y" || "$PROCEED" == "" ]]
   then
     TERRA_SETUP=true
     prompt_terra_network
@@ -202,9 +340,17 @@ echo
 printf "%30s %5s\n" "Hummingbot Instance ID:" "$HUMMINGBOT_INSTANCE_ID"
 printf "%30s %5s\n" "Ethereum Chain:" "$ETHEREUM_CHAIN"
 printf "%30s %5s\n" "Ethereum RPC URL:" "$ETHEREUM_RPC_URL"
+printf "%30s %5s\n" "Ethereum Token List URL:" "$ETHEREUM_TOKEN_LIST_URL"
+printf "%30s %5s\n" "Manual Gas Price:" "$MANUAL_GAS_PRICE"
+printf "%30s %5s\n" "Enable Eth Gas Station:" "$ENABLE_ETH_GAS_STATION"
+printf "%30s %5s\n" "Eth Gas Station API:" "$ETH_GAS_STATION_API_KEY"
+printf "%30s %5s\n" "Eth Gas Station Level:" "$ETH_GAS_STATION_GAS_LEVEL"
+printf "%30s %5s\n" "Eth Gas Station Refresh Interval:" "$ETH_GAS_STATION_REFRESH_TIME"
 printf "%30s %5s\n" "Balancer Subgraph:" "$REACT_APP_SUBGRAPH_URL"
 printf "%30s %5s\n" "Balancer Exchange Proxy:" "$EXCHANGE_PROXY"
+printf "%30s %5s\n" "Balancer Max Swaps:" "$BALANCER_MAX_SWAPS"
 printf "%30s %5s\n" "Uniswap Router:" "$UNISWAP_ROUTER"
+printf "%30s %5s\n" "Uniswap Allowed Slippage:" "$UNISWAP_SLIPPAGE"
 printf "%30s %5s\n" "Terra Chain:" "$TERRA"
 printf "%30s %5s\n" "Gateway Log Path:" "$LOG_PATH"
 printf "%30s %5s\n" "Gateway Cert Path:" "$CERT_PATH"
@@ -220,13 +366,46 @@ echo "NODE_ENV=prod" >> $ENV_FILE
 echo "PORT=$PORT" >> $ENV_FILE
 echo "" >> $ENV_FILE
 echo "HUMMINGBOT_INSTANCE_ID=$HUMMINGBOT_INSTANCE_ID" >> $ENV_FILE
+
+# ethereum config
+echo "" >> $ENV_FILE
+echo "# Ethereum Settings" >> $ENV_FILE
 echo "ETHEREUM_CHAIN=$ETHEREUM_CHAIN" >> $ENV_FILE
 echo "ETHEREUM_RPC_URL=$ETHEREUM_RPC_URL" >> $ENV_FILE
+echo "ETHEREUM_TOKEN_LIST_URL=$ETHEREUM_TOKEN_LIST_URL" >> $ENV_FILE
+echo "" >> $ENV_FILE
+echo "ENABLE_ETH_GAS_STATION=$ENABLE_ETH_GAS_STATION" >> $ENV_FILE
+echo "ETH_GAS_STATION_API_KEY=$ETH_GAS_STATION_API_KEY" >> $ENV_FILE
+echo "ETH_GAS_STATION_GAS_LEVEL=$ETH_GAS_STATION_GAS_LEVEL" >> $ENV_FILE
+echo "ETH_GAS_STATION_REFRESH_TIME=$ETH_GAS_STATION_REFRESH_TIME" >> $ENV_FILE
+echo "MANUAL_GAS_PRICE=$MANUAL_GAS_PRICE" >> $ENV_FILE
+
+# balancer config
+echo "" >> $ENV_FILE
+echo "# Balancer Settings" >> $ENV_FILE
 echo "REACT_APP_SUBGRAPH_URL=$REACT_APP_SUBGRAPH_URL" >> $ENV_FILE # must used "REACT_APP_SUBGRAPH_URL" for balancer-sor
 echo "EXCHANGE_PROXY=$EXCHANGE_PROXY" >> $ENV_FILE
+echo "BALANCER_MAX_SWAPS=$BALANCER_MAX_SWAPS" >> $ENV_FILE
+
+# uniswap config
+echo "" >> $ENV_FILE
+echo "# Uniswap Settings" >> $ENV_FILE
 echo "UNISWAP_ROUTER=$UNISWAP_ROUTER" >> $ENV_FILE
+echo "UNISWAP_ALLOWED_SLIPPAGE=$UNISWAP_SLIPPAGE" >> $ENV_FILE
+echo "UNISWAP_NO_RESERVE_CHECK_INTERVAL=300000" >> $ENV_FILE
+echo "UNISWAP_PAIRS_CACHE_TIME=1000" >> $ENV_FILE
+
+# terra config
+echo "" >> $ENV_FILE
+echo "# Terra Settings" >> $ENV_FILE
 echo "TERRA_LCD_URL=$TERRA_LCD_URL" >> $ENV_FILE
 echo "TERRA_CHAIN=$TERRA_CHAIN" >> $ENV_FILE
+
+# perpeptual finance config
+echo "" >> $ENV_FILE
+echo "# Perpeptual Settings" >> $ENV_FILE
+echo "XDAI_PROVIDER=$XDAI_PROVIDER" >> $ENV_FILE
+
 echo "" >> $ENV_FILE
 
 prompt_proceed () {
@@ -234,7 +413,12 @@ prompt_proceed () {
  read -p "  Do you want to proceed with installation? [Y/N] >>> " PROCEED
  if [ "$PROCEED" == "" ]
  then
- PROCEED="Y"
+ prompt_proceed
+ else
+  if [[ "$PROCEED" != "Y" && "$PROCEED" != "y" ]]
+  then
+    PROCEED="N"
+  fi
  fi
 }
 
diff --git a/test/connector/connector/balancer/test_balancer_connector.py b/test/connector/connector/balancer/test_balancer_connector.py
index 151d0e403e..66ad53df97 100644
--- a/test/connector/connector/balancer/test_balancer_connector.py
+++ b/test/connector/connector/balancer/test_balancer_connector.py
@@ -28,8 +28,7 @@
 
 global_config_map['gateway_api_host'].value = "localhost"
 global_config_map['gateway_api_port'].value = 5000
-global_config_map['ethgasstation_gas_enabled'].value = False
-global_config_map['manual_gas_price'].value = 50
+global_config_map['ethereum_token_list_url'].value = "https://defi.cmc.eth.link"
 global_config_map.get("ethereum_chain_name").value = "kovan"
 
 trading_pair = "WETH-DAI"
@@ -96,6 +95,14 @@ def setUp(self):
         for event_tag in self.events:
             self.connector.add_listener(event_tag, self.event_logger)
 
+    def test_fetch_trading_pairs(self):
+        asyncio.get_event_loop().run_until_complete(self._test_fetch_trading_pairs())
+
+    async def _test_fetch_trading_pairs(self):
+        pairs = await BalancerConnector.fetch_trading_pairs()
+        print(pairs)
+        self.assertGreater(len(pairs), 0)
+
     def test_update_balances(self):
         all_bals = self.connector.get_all_balances()
         for token, bal in all_bals.items():